Enforced $scope + use lodash

Author: wbuchwalter

src/components/connector.js

@@ -1,44 +1,34 @@
-import isFunction from '../utils/isFunction';
-import isPlainObject from '../utils/isPlainObject';
 import shallowEqual from '../utils/shallowEqual';
 import invariant from 'invariant';
-import _ from 'lodash'
+import _ from 'lodash';
 
 export default function Connector(store, $injector) {
-  return (selector, target) => {
+  return (selector, scope) => {
 
-    invariant(
-      isPlainObject(target),
-      'The target parameter passed to connect must be a plain object. Instead received %s.',
-      typeof target
-    );
+    invariant(scope && _.isFunction(scope.$on) &&  _.isFunction(scope.$destroy), 'The scope parameter passed to connect must be an instance of $scope.');
 
     //Initial update
     let slice = getStateSlice(store.getState(), selector);
-    target = _.assign(target, slice);
+    _.assign(scope, slice);
 
     let unsubscribe = store.subscribe(() => {
       let nextSlice = getStateSlice(store.getState(), selector);
       if (!shallowEqual(slice, nextSlice)) {
-        target = _.assign(target, nextSlice);
         slice = nextSlice;
+        _.assign(scope, slice);
       }
     });
 
-    if(isFunction(target.$destroy)) {
-      target.$on('$destroy', () => {
-        unsubscribe();
-      });
-    }
-
-    return unsubscribe;
+    scope.$on('$destroy', () => {
+      unsubscribe();
+    });
   }
 }
 
 function getStateSlice(state, selector) {
   let slice = selector(state);
   invariant(
-    isPlainObject(slice),
+    _.isPlainObject(slice),
     '`selector` must return an object. Instead received %s.',
     slice
   );

src/components/ngRedux.js

@@ -1,8 +1,8 @@
 import Connector from './connector';
 import invariant from 'invariant';
-import isFunction from '../utils/isFunction';
 import {createStore, applyMiddleware, compose} from 'redux';
 import digestMiddleware from './digestMiddleware';
+import _ from 'lodash';
 
 export default function ngReduxProvider() {
   let _reducer = undefined;
@@ -11,13 +11,13 @@ export default function ngReduxProvider() {
 
   this.createStoreWith = (reducer, middlewares, storeEnhancers) => {
   	  invariant(
-        isFunction(reducer),
+         _.isFunction(reducer),
         'The reducer parameter passed to createStoreWith must be a Function. Instead received %s.',
         typeof reducer
       );
 
       invariant(
-        !storeEnhancers || Array.isArray(storeEnhancers),
+        !storeEnhancers || _.isArray(storeEnhancers),
         'The storeEnhancers parameter passed to createStoreWith must be an Array. Instead received %s.',
         typeof storeEnhancers
       );

src/utils/isFunction.js

@@ -5,42 +5,43 @@ import Connector from '../../src/components/connector';
 describe('Connector', () => {
 	let store;
 	let connect;
+	let scopeStub;
 
 	beforeEach(() => {
 		store = createStore((state, action) => ({
-      foo: 'bar',
-      baz: action.payload,
-      anotherState: 12,
-      childObject: {child: true}
+	      foo: 'bar',
+	      baz: action.payload,
+	      anotherState: 12,
+	      childObject: {child: true}
 		}));
+		scopeStub = { $on: () => {}, $destroy: () => {}};
 		connect = Connector(store);
 	});
 
-	it('Should throw when not passed a plain object as target', () => {
+	it('Should throw when not passed a $scope object as target', () => {
 		expect(connect.bind(connect, () => ({}), () => {})).toThrow();
 		expect(connect.bind(connect, () => ({}), 15)).toThrow();
 		expect(connect.bind(connect, () => ({}), undefined)).toThrow();
-		expect(connect.bind(connect, () => ({}), {})).toNotThrow();
+		expect(connect.bind(connect, () => ({}), {})).toThrow();
+
+		expect(connect.bind(connect, () => ({}), scopeStub)).toNotThrow();
 	});
 
 	it('Should throw when selector does not return a plain object as target', () => {
-		expect(connect.bind(connect, state => state.foo, {})).toThrow();
+		expect(connect.bind(connect, state => state.foo, scopeStub)).toThrow();
 	});
 
-
 	it('target should be extended with state once directly after creation', () => {
-		let target = {};
-		connect(() => ({test: 1}), target);
-		expect(target).toEqual({test: 1});
+		connect(() => ({vm : {test: 1}}), scopeStub);
+		expect(scopeStub.vm).toEqual({test: 1});
 	});
 
 	it('Should update the target passed to connect when the store updates', () => {
-		let target = {};
-		connect(state => state, target);
+		connect(state => state, scopeStub);
 		store.dispatch({type: 'ACTION', payload: 0});
-		expect(target.baz).toBe(0);
+		expect(scopeStub.baz).toBe(0);
 		store.dispatch({type: 'ACTION', payload: 1});
-		expect(target.baz).toBe(1);
+		expect(scopeStub.baz).toBe(1);
 	});
 
 		//does that still makes sense?
@@ -53,15 +54,4 @@ describe('Connector', () => {
 		store.dispatch({type: 'ACTION', payload: 1});
 		expect(counter).toBe(3);
 	});*/
-
-
-	it('Should return an unsubscribing function', () => {
-		let target = {};
-		let unsubscribe = connect(state => state, target);
-		store.dispatch({type: 'ACTION', payload: 1});
-		expect(target.baz).toBe(1);
-		unsubscribe();
-		store.dispatch({type: 'ACTION', payload: 2});
-		expect(target.baz).toBe(1);
-	});
 });