TypeScript NgRedux.configureStore方法代码示例

  constructor(private ngRedux: NgRedux<IAppState>,
              private router: Router,
              private userEpics: UserEpics,
              private profileEpics: ProfileEpics,
              private quotesEpics: QuotesEpics,
              private usersEpics: UsersEpics) {

    const epics = [
      this.userEpics.signin,
      this.userEpics.signup,
      this.userEpics.resetPassword,
      this.userEpics.changePassword,
      this.profileEpics.fetchUser,
      this.profileEpics.updateUser,
      this.quotesEpics.fetchQuotes,
      this.quotesEpics.saveQuote,
      this.quotesEpics.updateQuoteModal,
      this.quotesEpics.updateQuote,
      this.quotesEpics.removeQuote,
      this.quotesEpics.recommendQuote,
      this.quotesEpics.unrecommendQuote,
      this.usersEpics.fetchUsers,
      this.usersEpics.followUser,
      this.usersEpics.unfollowUser,
    ];

    const epicsMiddlewares = epics.reduce((acc: any[], epic: any) => acc.concat(createEpicMiddleware(epic)), []);

    ngRedux.configureStore(rootReducer, {}, [...middlewares, ...epicsMiddlewares], enhancers);
  }

  constructor(
    private ngRedux: NgRedux<IAppState>,
    private devTool: DevToolsExtension,
    private rootEpic: RootEpic,
    private router: Router,
  ) {
    const middleware = [
      createEpicMiddleware(this.rootEpic.combineAll()),
      createLogger(),
    ];

    const reducer = compose(
      mergePersistedState()
    )(rootReducer);

    const storage = compose(
      filter('auth')
    )(adapter(window.localStorage));

    const enhancers = [
      persistState(storage, 'fyibn/store'),
    ];

    if (devTool.isEnabled()) {
      enhancers.push(devTool.enhancer());
    }

    this.ngRedux.configureStore(
      reducer,
      {} as IAppState,
      middleware,
      enhancers,
    );
  }

 constructor(ngRedux: NgRedux<IAppState>, devTools: DevToolsExtension) {
   ngRedux.configureStore(
     rootReducer,
     INITIAL_STATE,
     [],
     devTools.isEnabled() ? [ devTools.enhancer() ] : []
   );
 }

 constructor(ngRedux: NgRedux<IAppState>) {
   // Tell @angular-redux/store about our rootReducer and our initial state.
   // It will use this to create a redux store for us and wire up all the
   // events.
   ngRedux.configureStore(
     rootReducer,
     INITIAL_STATE);
 }

  constructor(
    private ngRedux: NgRedux<IAppState>,
    private devTool: DevToolsExtension) {

    // configure the store here, this is where the enhancers are set
    this.ngRedux.configureStore(rootReducer, {},
      isDevMode() ? [createLogger({ collapsed: true })] : [],
      isDevMode() && devTool.isEnabled() ? [...enhancers, devTool.enhancer()] : [...enhancers]);
  }

 beforeEach(inject([NgRedux], (store: NgRedux<AppState>) => {
     store.configureStore(rootReducer, {
         ...APP_INITIAL_STATE,
         inventur: {
             ...INVENTUR_INITIAL_STATE,
             inventurId: testfall.inventurId,
             eroeffnungsbilanz: testfall.eroeffnungsbilanz
         }
     })
 }))

  constructor(
    private ngRedux: NgRedux<IAppState>,
    private devTool: DevToolsExtension) {

    this.ngRedux.configureStore(
      rootReducer,
      {},
      [ createLogger() ],
      [ ...enhancers, devTool.isEnabled() ? devTool.enhancer() : f => f]);
  }

 constructor(private ngRedux:NgRedux<any>) {
   this.ngRedux.configureStore(
     rootReducer, {
       apiPanel:configJcropInitialState('apiPanel'),
       defaultPanel:configJcropInitialState('defaultPanel'),
       showSelectionPanel:configJcropInitialState('showSelectionPanel'),
       previewPanel:configJcropInitialState('previewPanel'),
       animationsPanel:configJcropInitialState('animationsPanel'),
       stylingPanel:configJcropInitialState('stylingPanel'),
     }
   );
 }

    constructor(
        public store: NgRedux<AppStateModel>,
        ngReduxRouter: NgReduxRouter
    ) {
        store.configureStore(rootReducer, initialState);

        if (ngReduxRouter) {
            ngReduxRouter.initialize();
        }

        provideReduxForms(store);
    }

  constructor(
    private ngRedux: NgRedux<IAppState>,
    private devTools: DevToolsExtension
  ) {

    const tools = devTools.isEnabled() ?
      [ ...enhancers, devTools.enhancer() ] : enhancers;

    ngRedux.configureStore(
      rootReducer,
      {},
      middleware,
      tools
    );
  }