Introduce differentiated constructors

src/ReactDream.js

@@ -6,7 +6,8 @@ import withDebugger from '@hocs/with-debugger'
 import withLog from '@hocs/with-log'
 import doAp from './internals/doAp'
 import doConcat from './internals/doConcat'
-import doContramap from './internals/doContramap'
+import doStatefulContramap from './internals/stateful/doContramap'
+import doStatelessContramap from './internals/stateless/doContramap'
 import doMap from './internals/doMap'
 import doPromap from './internals/doPromap'
 import doRotate from './internals/doRotate'
@@ -31,9 +32,13 @@ const map = Component => higherOrderComponent => ReactDream(doMap(higherOrderCom
 const concat = Component => OtherComponent =>
   ReactDream(doConcat(OtherComponent.Component)(Component))
 
-// contramap : Component -> (a -> Props) -> ReactDream
-const contramap = Component => propsPreprocessor =>
-  ReactDream(doContramap(propsPreprocessor)(Component))
+// statelessContramap : Component -> (a -> Props) -> ReactDream
+const statelessContramap = Component => propsPreprocessor =>
+  ReactDream(doStatelessContramap(propsPreprocessor)(Component))
+
+// statefulContramap : Component -> (a -> Props) -> ReactDream
+const statefulContramap = Component => propsPreprocessor =>
+  ReactDream(doStatefulContramap(propsPreprocessor)(Component))
 
 // promap : Component -> (a -> Props) -> (Component -> Component) -> ReactDream
 const promap = Component => (propsPreprocessor, higherOrderComponent) =>
@@ -96,15 +101,42 @@ const style = Component => getStyleFromProps =>
 // TYPE
 // ////////////////////////////////////////////////////////////////////////// //
 
-// ReactDream : Component -> ReactDream
-const ReactDream = Component => ({
+// ReactDream.Stateless : Component -> ReactDream
+export const Stateless = Component => ({
+  Component,
+
+  // Algebras
+  ap: ap(Component),
+  chain: chain(Component),
+  concat: concat(Component),
+  contramap: statelessContramap(Component),
+  map: map(Component),
+  promap: promap(Component),
+
+  // Custom helpers
+  addProps: addProps(Component),
+  debug: debug(Component),
+  defaultProps: defaultProps(Component),
+  fork: fork(Component),
+  name: name(Component),
+  log: log(Component),
+  propTypes: propTypes(Component),
+  removeProps: removeProps(Component),
+  rotate: rotate(Component),
+  scale: scale(Component),
+  style: style(Component),
+  translate: translate(Component),
+})
+
+// ReactDream.Stateful : Component -> ReactDream
+export const Stateful = Component => ({
   Component,
 
   // Algebras
   ap: ap(Component),
   chain: chain(Component),
   concat: concat(Component),
-  contramap: contramap(Component),
+  contramap: statefulContramap(Component),
   map: map(Component),
   promap: promap(Component),
 
@@ -123,6 +155,11 @@ const ReactDream = Component => ({
   translate: translate(Component),
 })
 
+const ReactDream = Component =>
+  isReferentiallyTransparentFunctionComponent(Component)
+    ? Stateless(Component)
+    : Stateful(Component)
+
 ReactDream.of = ReactDream
 
 export const of = ReactDream.of

src/internals/doAp.js

@@ -1,2 +1,2 @@
 // doAp : (Component -> Component) -> ReactDream -> Component
-export default higherOrderComponent => DreamComponent => DreamComponent.fork(higherOrderComponent)
+export default higherOrderComponent => DreamComponent => higherOrderComponent(DreamComponent.Component)

src/internals/doContramap.js → src/internals/stateful/doContramap.js

@@ -1,13 +1,10 @@
 import React from 'react'
 import compose from 'recompose/compose'
 import getDisplayName from 'recompose/getDisplayName'
-import isReferentiallyTransparentFunctionComponent from '../isReferentiallyTransparentFunctionComponent'
 
 // doContramap : (a -> Props) -> Component -> Component
 export default propsPreprocessor => Component => {
-  const Enhanced = isReferentiallyTransparentFunctionComponent(Component)
-    ? compose(Component, propsPreprocessor)
-    : props => <Component {...propsPreprocessor(props)} />
+  const Enhanced = props => <Component {...propsPreprocessor(props)} />
 
   Enhanced.displayName = getDisplayName(Component)
 

src/internals/stateful/doContramap.spec.js

@@ -0,0 +1,86 @@
+import React, { Component } from 'react'
+import { create } from 'react-test-renderer'
+import doContramap from './doContramap'
+import { equal } from 'assert'
+
+describe('Stateful / doContramap', () => {
+  it('returns a new component that wraps building the inner component with the propsPreprocesssor filtering the props', () => {
+    class NotReferentiallyTransparent extends Component {
+      constructor() {
+        super()
+
+        this.state = {}
+      }
+
+      render() {
+        return (
+          <div>
+            {this.props.name}
+          </div>
+        )
+      }
+    }
+
+    const propsPreprocesssor = () => ({ name: 'Regina Spektor' })
+
+    const Enhanced = doContramap(propsPreprocesssor)(NotReferentiallyTransparent)
+
+    const renderer = create(<Enhanced />)
+
+    equal(renderer.toJSON().children, 'Regina Spektor')
+  })
+
+  describe('it has name', () => {
+    it('preserves the name as displayName', () => {
+      class NotReferentiallyTransparent extends Component {
+        constructor() {
+          super()
+
+          this.state = {}
+        }
+
+        render() {
+          return (
+            <div>
+              {this.props.name}
+            </div>
+          )
+        }
+      }
+
+      const propsPreprocesssor = () => ({ name: 'Regina Spektor' })
+
+      const Enhanced = doContramap(propsPreprocesssor)(NotReferentiallyTransparent)
+
+      equal(Enhanced.displayName, 'NotReferentiallyTransparent')
+    })
+  })
+
+  describe('it has displayName', () => {
+    it('preserves it', () => {
+      class NotReferentiallyTransparent extends Component {
+        constructor() {
+          super()
+
+          this.state = {}
+        }
+
+        render() {
+          return (
+            <div>
+              {this.props.name}
+            </div>
+          )
+        }
+      }
+
+      NotReferentiallyTransparent.displayName = 'BeginToHope'
+
+      const propsPreprocesssor = () => ({ name: 'Regina Spektor' })
+
+      const Enhanced = doContramap(propsPreprocesssor)(NotReferentiallyTransparent)
+
+      equal(Enhanced.displayName, 'BeginToHope')
+    })
+  })
+})

src/internals/stateless/doContramap.js

@@ -0,0 +1,12 @@
+import React from 'react'
+import compose from 'recompose/compose'
+import getDisplayName from 'recompose/getDisplayName'
+
+// doContramap : (a -> Props) -> Component -> Component
+export default propsPreprocessor => Component => {
+  const Enhanced = compose(Component, propsPreprocessor)
+
+  Enhanced.displayName = getDisplayName(Component)
+
+  return Enhanced
+}

src/internals/stateless/doContramap.spec.js

@@ -0,0 +1,35 @@
+import React, { Component } from 'react'
+import { create } from 'react-test-renderer'
+import doContramap from './doContramap'
+import { equal } from 'assert'
+
+describe('Stateless / doContramap', () => {
+  it('pre composes the propsPreprocesssor', () => {
+    const ReferentiallyTransparentComponent = x => !x
+    const propsPreprocessor = () => true
+
+    equal(doContramap(propsPreprocessor)(ReferentiallyTransparentComponent)(), false)
+  })
+
+  describe('it has name', () => {
+    it('preserves the name as displayName', () => {
+      function ReferentiallyTransparentComponent(x) {
+        return x
+      }
+
+      equal(
+        doContramap(x => x)(ReferentiallyTransparentComponent).displayName,
+        'ReferentiallyTransparentComponent'
+      )
+    })
+  })
+
+  describe('it has displayName', () => {
+    it('preserves it', () => {
+      const ReferentiallyTransparentComponent = x => x
+      ReferentiallyTransparentComponent.displayName = 'Casablanca'
+
+      equal(doContramap(x => x)(ReferentiallyTransparentComponent).displayName, 'Casablanca')
+    })
+  })
+})