TypeScript store.usePostMiddleware函数代码示例

export const loggerMiddleware = (opts : Object = {}) => {
    const defaults = {
        level : `log`,
        collapsed : false,
        duration : false,
        timestamp : true,
        stateTransformer : state => state,
        actionTransformer : actn => actn,
        colors : {
            title: () => `#000000`,
            prevState: () => `#9E9E9E`,
            action: () => `#03A9F4`,
            nextState: () => `#4CAF50`,
            error: () => `#F20404`,
        }
    };
    const options : Object = Object.assign({}, defaults, opts);

    return [
        provide(LOGGER, {
            useFactory(){
                return new BehaviorSubject(null);
            }
        }),
        provide(LOGGER_OPTIONS, {
            useValue: options
        }),
        provide(LOGGER_BUFFER, {
            useValue: printBuffer(options)
        }),
        usePreMiddleware(preLogger),
        usePostMiddleware(postLogger)
    ]
};

export function installSagaMiddleware(...sagas: Provider[]): Provider[] {
  return [
    provide(SagaRunner, { useClass: SagaRunner }),
    ...usePostMiddleware(sagaMiddleware),
    ...addInitSagas(...sagas)
  ];
}

export function main() {
  return browser.bootstrap(AppComponent, [
    ...APPLICATION_PROVIDERS,
    ngCore.provide(ngCore.PLATFORM_DIRECTIVES, {useValue: APPLICATION_DIRECTIVES, multi: true}),
    ngCore.provide(ngCore.PLATFORM_PIPES, {useValue: APPLICATION_PIPES, multi: true}),
    provideStore({counter, todos, visibilityFilter}),
    usePostMiddleware(stateLog),
  ])
  .catch(err => console.error(err));
}

export function main() {
  return bootstrap(ArtistPlaylistApp, [
      apiInjectables,
      ELEMENT_PROBE_PROVIDERS,
      HTTP_PROVIDERS,
      AudioServiceAction,
      provide(BrowserXhr, { useClass: CustomBrowserXhr }),
      provideStore(APP_REDUCERS),
      usePreMiddleware(actionLog),
      usePostMiddleware(stateLog),
      installSagaMiddleware(...audiomachineSagas)
  ])
  .catch(err => console.error(err));
}

import "zone.js";
import "reflect-metadata";
import assign from "lodash/assign";
import {bootstrap} from "@angular/platform-browser-dynamic";
import {provideStore, usePostMiddleware} from "@ngrx/store";
import {App} from "../app/app";
import {ROUTER_PROVIDERS} from "@angular/router-deprecated";
import {TODO_PROVIDERS} from "../app/todos";
import {reducers, initialStates} from "../app/store";
import {dev} from "./tools.dev.ts";

export {dev};

const PROVIDERS = [
  ROUTER_PROVIDERS,
  TODO_PROVIDERS,
  provideStore(reducers, assign({}, initialStates, dev.currentState)),
  usePostMiddleware(dev.stateLogging),
  usePostMiddleware(dev.stateTracking)
];

export const __reload = (m: {dev: typeof dev}) => {
  // Bootstrap a second time with recovered if the state dev module was reloaded
  if (dev.currentState !== m.dev.currentState) {
    dev.currentState = m.dev.currentState;
    bootstrap(App, [PROVIDERS, provideStore(reducers, assign({}, initialStates, dev.currentState))]);
  }
};

bootstrap(App, PROVIDERS);

import {WineCellarApp} from "./common/containers/application/application.container.ts";
import {bootstrap} from "@angular/platform-browser-dynamic";
import {HashLocationStrategy, LocationStrategy, APP_BASE_HREF} from "@angular/common";
import {ROUTER_PROVIDERS} from "@angular/router-deprecated";
import {provide} from "@angular/core";
import "rxjs/add/operator/do";
import {Middleware, provideStore, usePreMiddleware, usePostMiddleware} from "@ngrx/store";
import {store} from "./common/store";
import {HTTP_PROVIDERS} from "@angular/http";

const actionLog: Middleware = (action: any) => {
    return action.do((val: any) => {
        console.warn("DISPATCHED ACTION: ", val);
    });
};
const stateLog: Middleware = (state: any) => {
    return state.do((val: any) => {
        console.info("NEW STATE: ", val);
    });
};

bootstrap(WineCellarApp, [
    ROUTER_PROVIDERS,
    HTTP_PROVIDERS,
    provide(APP_BASE_HREF, {useValue: "/"}),
    provide(LocationStrategy, {useClass: HashLocationStrategy}),
    provideStore(store),
    usePreMiddleware(actionLog),
    usePostMiddleware(stateLog)
]);

import {Provider} from 'angular2/core';
import {usePostMiddleware} from '@ngrx/store';
import routerSubscriber from './subscriber';
import routerPostMiddleware from './middleware';

const routerMiddleware = [
  usePostMiddleware(routerPostMiddleware),
  routerSubscriber
];

export {RouterSubscriber} from './subscriber';
export {routerReducer, RouterState, RouterActions} from './reducer';
export {routerMiddleware};

import {usePreMiddleware, usePostMiddleware, Middleware, Action} from "@ngrx/store";

const actionLog: Middleware = action => {
    return action.do(val => {
        console.warn('DISPATCHED ACTION: ', val)
    });
};

const stateLog: Middleware = state => {
    return state.do(val => {
        console.info('NEW STATE: ', val)
    });
};

export const ActionLog = usePreMiddleware(actionLog);
export const StateLog = usePostMiddleware(stateLog);
export const MiddleWareLogs = [ActionLog, StateLog];