feat(Store): Allow parent modules to provide reducers with tokens

modules/store/spec/modules.spec.ts

@@ -1,29 +1,73 @@
-import 'rxjs/add/operator/take';
-import { zip } from 'rxjs/observable/zip';
-import { ReflectiveInjector } from '@angular/core';
-import { createInjector, createChildInjector } from './helpers/injector';
-import { StoreModule, Store } from '../';
+import { TestBed } from '@angular/core/testing';
+import { NgModule, InjectionToken } from '@angular/core';
+import { StoreModule, Store, ActionReducer, ActionReducerMap } from '../';
 
 
 describe('Nested Store Modules', () => {
-  let store: Store<any>;
+  type RootState = { fruit: string };
+  type FeatureAState = number;
+  type FeatureBState = { list: number[], index: number };
+  type State = RootState & { a: FeatureAState } & { b: FeatureBState };
 
-  beforeEach(() => {
-    const parentReducers = { stateKey: () => 'root' };
-    const featureReducers = { stateKey: () => 'child' };
+  let store: Store<State>;
+
+  const reducersToken = new InjectionToken<ActionReducerMap<RootState>>('Root Reducers');
+  const rootFruitReducer: ActionReducer<string> = () => 'apple';
+  const featureAReducer: ActionReducer<FeatureAState> = () => 5;
+  const featureBListReducer: ActionReducer<number[]> = () => [1, 2, 3];
+  const featureBIndexReducer: ActionReducer<number> = () => 2;
+  const featureBReducerMap: ActionReducerMap<FeatureBState> = {
+    list: featureBListReducer,
+    index: featureBIndexReducer,
+  };
+
+  @NgModule({
+    imports: [
+      StoreModule.forFeature('a', featureAReducer),
+    ]
+  })
+  class FeatureAModule { }
+
+  @NgModule({
+    imports: [
+      StoreModule.forFeature('b', featureBReducerMap),
+    ]
+  })
+  class FeatureBModule { }
 
-    const rootInjector = createInjector(StoreModule.forRoot(parentReducers));
-    const featureInjector = createChildInjector(rootInjector, StoreModule.forFeature('inner', featureReducers));
+  @NgModule({
+    imports: [
+      StoreModule.forRoot<RootState>(reducersToken),
+      FeatureAModule,
+      FeatureBModule,
+    ],
+    providers: [
+      {
+        provide: reducersToken,
+        useValue: { fruit: rootFruitReducer },
+      }
+    ]
+  })
+  class RootModule { }
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [
+        RootModule,
+      ]
+    });
 
-    store = rootInjector.get(Store);
+    store = TestBed.get(Store);
   });
 
   it('should nest the child module in the root store object', () => {
     store.take(1).subscribe(state => {
       expect(state).toEqual({
-        stateKey: 'root',
-        inner: {
-          stateKey: 'child'
+        fruit: 'apple',
+        a: 5,
+        b: {
+          list: [1, 2, 3],
+          index: 2,
         }
       });
     });

modules/store/spec/ngc/main.ts

@@ -45,27 +45,33 @@ export const reducerToken = new InjectionToken('Reducers');
 })
 export class NgcSpecComponent {
   count: Observable<number>;
-  constructor(public store:Store<AppState>){
+  constructor(public store: Store<AppState>) {
     this.count = store.select(state => state.count);
   }
-  increment(){
+  increment() {
     this.store.dispatch({ type: INCREMENT });
   }
-  decrement(){
+  decrement() {
     this.store.dispatch({ type: DECREMENT });
   }
 }
 
 @NgModule({
   imports: [
     BrowserModule,
-    StoreModule.forRoot({ count: counterReducer }, {
-      initialState: { count : 0 },
+    StoreModule.forRoot(reducerToken, {
+      initialState: { count: 0 },
       reducerFactory: combineReducers
     }),
     FeatureModule
   ],
+  providers: [
+    {
+      provide: reducerToken,
+      useValue: { count: counterReducer }
+    }
+  ],
   declarations: [NgcSpecComponent],
   bootstrap: [NgcSpecComponent]
 })
-export class NgcSpecModule {}
+export class NgcSpecModule { }

modules/store/src/models.ts

@@ -16,7 +16,7 @@ export interface ActionReducerFactory<T, V extends Action = Action> {
 
 export interface StoreFeature<T, V extends Action = Action> {
   key: string;
-  reducers: ActionReducerMap<T, V>;
+  reducers: ActionReducerMap<T, V> | ActionReducer<T, V>;
   reducerFactory: ActionReducerFactory<T, V>;
   initialState: T | undefined;
 }

modules/store/src/reducer_manager.ts

@@ -23,7 +23,7 @@ export class ReducerManager extends BehaviorSubject<ActionReducer<any, any>> imp
   }
 
   addFeature({ reducers, reducerFactory, initialState, key }: StoreFeature<any, any>) {
-    const reducer = reducerFactory(reducers, initialState);
+    const reducer = typeof reducers === 'function' ? reducers : reducerFactory(reducers, initialState);
 
     this.addReducer(key, reducer);
   }

modules/store/src/selector.ts

@@ -125,3 +125,7 @@ export function createFeatureSelector<T>(featureName: string): MemoizedSelector<
 
   return Object.assign(memoized, { release: reset });
 }
+
+export function isSelector(v: any): v is MemoizedSelector<any, any> {
+  return typeof v === 'function' && v.release && typeof v.release === 'function';
+}

modules/store/src/store.ts

@@ -9,6 +9,7 @@ import { Action, ActionReducer } from './models';
 import { ActionsSubject } from './actions_subject';
 import { StateObservable } from './state';
 import { ReducerManager } from './reducer_manager';
+import { isSelector, createSelector } from './selector';
 
 
 @Injectable()
@@ -36,11 +37,14 @@ export class Store<T> extends Observable<Readonly<T>> implements Observer<Action
     if (typeof pathOrMapFn === 'string') {
       mapped$ = pluck.call(this, pathOrMapFn, ...paths);
     }
-    else if (typeof pathOrMapFn === 'function') {
+    else if (typeof pathOrMapFn === 'function' && isSelector(pathOrMapFn)) {
       mapped$ = map.call(this, pathOrMapFn);
     }
+    else if (typeof pathOrMapFn === 'function') {
+      mapped$ = map.call(this, createSelector(s => s, pathOrMapFn));
+    }
     else {
-      throw new TypeError(`Unexpected type '${ typeof pathOrMapFn }' in select operator,`
+      throw new TypeError(`Unexpected type '${typeof pathOrMapFn}' in select operator,`
         + ` expected 'string' or 'function'`);
     }
 

modules/store/src/store_module.ts

@@ -1,5 +1,5 @@
-import { NgModule, Inject, ModuleWithProviders, OnDestroy } from '@angular/core';
-import { Action, ActionReducerMap, ActionReducerFactory, StoreFeature } from './models';
+import { NgModule, Inject, ModuleWithProviders, OnDestroy, InjectionToken } from '@angular/core';
+import { Action, ActionReducer, ActionReducerMap, ActionReducerFactory, StoreFeature } from './models';
 import { combineReducers } from './utils';
 import { INITIAL_STATE, INITIAL_REDUCERS, REDUCER_FACTORY, STORE_FEATURES } from './tokens';
 import { ACTIONS_SUBJECT_PROVIDERS } from './actions_subject';
@@ -10,12 +10,12 @@ import { STORE_PROVIDERS } from './store';
 
 
 
-@NgModule({ })
+@NgModule({})
 export class StoreRootModule {
 
 }
 
-@NgModule({ })
+@NgModule({})
 export class StoreFeatureModule implements OnDestroy {
   constructor(
     @Inject(STORE_FEATURES) private features: StoreFeature<any, any>[],
@@ -31,15 +31,15 @@ export class StoreFeatureModule implements OnDestroy {
 
 export type StoreConfig<T, V extends Action = Action> = { initialState?: T, reducerFactory?: ActionReducerFactory<T, V> };
 
-@NgModule({ })
+@NgModule({})
 export class StoreModule {
-  static forRoot<T, V extends Action = Action>(reducers: ActionReducerMap<T, V>, config?: StoreConfig<T, V>): ModuleWithProviders;
-  static forRoot(reducers: ActionReducerMap<any, any>, config: StoreConfig<any, any> = { }): ModuleWithProviders {
+  static forRoot<T, V extends Action = Action>(reducers: ActionReducerMap<T, V> | InjectionToken<ActionReducerMap<T, V>>, config?: StoreConfig<T, V>): ModuleWithProviders;
+  static forRoot(reducers: ActionReducerMap<any, any> | InjectionToken<ActionReducerMap<any, any>>, config: StoreConfig<any, any> = {}): ModuleWithProviders {
     return {
       ngModule: StoreRootModule,
       providers: [
         { provide: INITIAL_STATE, useValue: config.initialState },
-        { provide: INITIAL_REDUCERS, useValue: reducers },
+        reducers instanceof InjectionToken ? { provide: INITIAL_REDUCERS, useExisting: reducers } : { provide: INITIAL_REDUCERS, useValue: reducers },
         { provide: REDUCER_FACTORY, useValue: config.reducerFactory ? config.reducerFactory : combineReducers },
         ACTIONS_SUBJECT_PROVIDERS,
         REDUCER_MANAGER_PROVIDERS,
@@ -51,7 +51,8 @@ export class StoreModule {
   }
 
   static forFeature<T, V extends Action = Action>(featureName: string, reducers: ActionReducerMap<T, V>, config?: StoreConfig<T, V>): ModuleWithProviders;
-  static forFeature(featureName: string, reducers: ActionReducerMap<any, any>, config: StoreConfig<any, any> = {}): ModuleWithProviders {
+  static forFeature<T, V extends Action = Action>(featureName: string, reducer: ActionReducer<T, V>, config?: StoreConfig<T, V>): ModuleWithProviders;
+  static forFeature(featureName: string, reducers: ActionReducerMap<any, any> | ActionReducer<any, any>, config: StoreConfig<any, any> = {}): ModuleWithProviders {
     return {
       ngModule: StoreFeatureModule,
       providers: [