feat(createPubSubConnector): Simplified 'mapSubscriptionsToProps' logic

Provided callback now receive always current props as last parameters

Breaking Changes: provided callback are no longer refreshed when component props are changed

Author: cef62

src/components/createPubSubConnector.js

@@ -4,7 +4,6 @@ import isPlainObject from '../utils/isPlainObject';
 import shallowEqual from '../utils/shallowEqual';
 import pubSubShape from '../shapes/pubSubShape';
 
-const defaultRetriveProps = () => ({});
 const defaultMapPublishToProps = publish => ({ publish });
 
 function getDisplayName(WrappedComponent) {
@@ -62,15 +61,9 @@ export default function createPubSubConnector(mapSubscriptionsToProps, mapPublis
     const updateMappedSubscriptions = (key, transformerOrAlias) => {
       let callback;
       if (typeof transformerOrAlias === 'function') {
-        const shouldUpdateSubscriptionProps = transformerOrAlias.length > 1;
-        callback = (retrieveProps = defaultRetriveProps, silent = false) =>
-        (...args) => {
-          // store received values
-          mappedSubscriptions[key].lastResult = args;
-          mappedSubscriptions[key].shouldUpdateSubscriptionProps = shouldUpdateSubscriptionProps;
-
+        callback = (...args) => {
           // transform values
-          const newValues = transformerOrAlias(...args, retrieveProps());
+          const newValues = transformerOrAlias(...args, getProps());
 
           if (!isPlainObject(newValues)) {
             throw new Error(
@@ -86,8 +79,7 @@ export default function createPubSubConnector(mapSubscriptionsToProps, mapPublis
             );
           }
 
-          updateSubscriptionProps(newValues, silent);
-          return newValues;
+          updateSubscriptionProps(newValues);
         };
       } else {
         callback = result => updateSubscriptionProps({ [transformerOrAlias]: result });
@@ -98,45 +90,8 @@ export default function createPubSubConnector(mapSubscriptionsToProps, mapPublis
 
     mappedSubscriptions = Object.keys(subscriptionsMap)
     .reduce((acc, key) => {
-      const refresh = updateMappedSubscriptions(key, subscriptionsMap[key]);
-      let callback = refresh;
-      if (typeof subscriptionsMap[key] === 'function') {
-        callback = refresh(getProps);
-      }
-      acc[key] = {
-        key,
-        refresh,
-        unsubscribe: add(key, callback),
-      };
-      return acc;
-    }, {});
-  }
-
-  function refreshMappedSubscriptions(subscriptionsMap = {}, getProps) {
-    const mappedSubscriptionsKeys = Object.keys(mappedSubscriptions);
-    if (!mappedSubscriptionsKeys.length) {
-      return {};
-    }
-
-    const silent = true;
-
-    return Object.keys(subscriptionsMap)
-    .reduce((acc, key) => {
-      if (
-        typeof subscriptionsMap[key] === 'function'
-          && mappedSubscriptions[key] !== undefined
-      ) {
-        const {
-          refresh,
-          lastResult,
-          shouldUpdateSubscriptionProps,
-        } = mappedSubscriptions[key];
-
-        if (shouldUpdateSubscriptionProps) {
-          const res = refresh(getProps, silent)(...lastResult);
-          Object.assign(acc, res);
-        }
-      }
+      const callback = updateMappedSubscriptions(key, subscriptionsMap[key]);
+      acc[key] = add(key, callback);
       return acc;
     }, {});
   }
@@ -156,14 +111,9 @@ export default function createPubSubConnector(mapSubscriptionsToProps, mapPublis
     return publishProps;
   }
 
-  function computeMappedSubscriptionProps(mappedSubscriptionProps = {}, props = {}) {
-    const nextSubscriptionsProps = refreshMappedSubscriptions(mapSubscriptionsToProps, () => props);
-    const merged = Object.assign({}, mappedSubscriptionProps, nextSubscriptionsProps);
-    return cleanEmptyKeys(merged);
-  }
-
   return function wrapComponent(Composed) {
     class PubSubConnector extends Component {
+
       constructor(props, context) {
         super(props, context);
         this.pubSubCore = props.pubSubCore || context.pubSubCore;
@@ -189,25 +139,21 @@ export default function createPubSubConnector(mapSubscriptionsToProps, mapPublis
         }
 
         this.publishProps = computePublishProps(this.pubSub, props);
-        this.mappedSubscriptionProps = computeMappedSubscriptionProps({}, props);
+        this.mappedSubscriptionProps = {};
+
         this.state = {};
       }
 
       shouldComponentUpdate(nextProps, nextState) {
         const stateChanged = !shallowEqual(nextState, this.state);
         const propsChanged = !shallowEqual(nextProps, this.props);
         let publishPropsChanged = false;
-        let mappedSubscriptionsPropsChanged = false;
 
         if (propsChanged && shouldUpdatePublishProps) {
           publishPropsChanged = this.updatePublishProps(nextProps);
         }
 
-        if (propsChanged && shouldMapSubscriptions) {
-          mappedSubscriptionsPropsChanged = this.updateMappedSubscriptions(nextProps);
-        }
-
-        return propsChanged || stateChanged || publishPropsChanged || mappedSubscriptionsPropsChanged;
+        return propsChanged || stateChanged || publishPropsChanged;
       }
 
       componentWillUnmount() {
@@ -225,25 +171,15 @@ export default function createPubSubConnector(mapSubscriptionsToProps, mapPublis
         return this.refs.wrappedInstance;
       }
 
-      updateSingleMappedSubscription(updatedSubscription, silent = false) {
-        if (!silent && updatedSubscription) {
+      updateSingleMappedSubscription(updatedSubscription) {
+        if (updatedSubscription) {
           Object.assign(this.mappedSubscriptionProps, updatedSubscription);
           cleanEmptyKeys(this.mappedSubscriptionProps);
           const lastSubscription = this.state.lastSubscription ? this.state.lastSubscription + 1 : 1;
           this.setState({ lastSubscription });
         }
       }
 
-      updateMappedSubscriptions(props = this.props) {
-        const nextSubscriptionProps = computeMappedSubscriptionProps(this.mappedSubscriptionProps, props);
-        if (shallowEqual(nextSubscriptionProps, this.mappedSubscriptionProps)) {
-          return false;
-        }
-
-        this.mappedSubscriptionProps = nextSubscriptionProps;
-        return true;
-      }
-
       updatePublishProps(props = this.props) {
         const nextPublishProps = computePublishProps(this.pubSub, props);
         if (shallowEqual(nextPublishProps, this.publishProps)) {

test/components/createPubSubConnector.spec.js

@@ -364,7 +364,6 @@ test(
     pubSub.publish(UPDATE, { label: 'myLabel', name: 'myName' });
     t.is(stub.props.updatedField, 'myLabel');
     wrapper.setState({ updateField: 'name' });
-    t.is(stub.props.updatedField, 'myName');
     pubSub.publish(UPDATE, { label: 'myLabel', name: 'myNewName' });
     t.is(stub.props.updatedField, 'myNewName');
 
@@ -379,10 +378,11 @@ test(
 );
 
 test(
-  'should update subscriptions from `mapSubscriptionsToProps` when props changes only'
-  + ' if the callback defines a second arguments',
+  'should not update subscribed actions when props changes if `mapSubscriptionsToProps`'
+  + ' is an object',
   t => {
     const SIMPLE_UPDATE = 'simpleUpdate';
+    const OTHER_UPDATE = 'otherUpdate';
     const pubSubCore = createPubSub();
     const register = pubSubCore.register;
     let pubSub;
@@ -414,6 +414,10 @@ test(
         const now = new Date().getTime();
         return { simpleField: payload.name, now };
       },
+      [OTHER_UPDATE]: (a, b) => {
+        const otherNow = new Date().getTime();
+        return { otherNow, a, b };
+      },
     };
     const WrapperContainer = createPubSubConnector(mapSubscriptionsToProps)(Container);
 
@@ -428,10 +432,16 @@ test(
     t.is(stub.props.simpleField, undefined);
     pubSub.publish(SIMPLE_UPDATE, { name: 'john' });
     t.is(stub.props.simpleField, 'john');
-    const nowValue = stub.props.now;
+    let nowValue = stub.props.now;
     wrapper.setState({ updateField: 'label' });
     t.is(stub.props.now, nowValue);
 
+    pubSub.publish(OTHER_UPDATE, 'yo', 'ye');
+    t.is(stub.props.a, 'yo');
+    nowValue = stub.props.otherNow;
+    wrapper.setState({ updateField: 'color' });
+    t.is(stub.props.otherNow, nowValue);
+
     t.end();
   }
 );