TypeScript store-log-monitor.useLogMonitor函数代码示例

export function main(initialHmrState?: any): Promise<any> {

  return bootstrap(App, [
    // To add more vendor providers please look in the platform/ folder
    ...PLATFORM_PROVIDERS,
    ...ENV_PROVIDERS,
    ...APP_PROVIDERS,
    instrumentStore({
      monitor: useLogMonitor({
        visible: true,
        position: 'right'
      })
    }),
    provideStore({})
  ])
    .then(decorateComponentRef)
    .catch(err => console.error(err));

}

import { provideStore } from '@ngrx/store'
import { instrumentStore } from '@ngrx/store-devtools'
import { useLogMonitor } from '@ngrx/store-log-monitor'
import { runEffects } from '@ngrx/effects'

import { AppComponent, environment } from './app/'

import { giphy as reducer } from './app/reducers/giphy'
import { GiphyEffects } from './app/effects/giphy'

import services from './app/services/index'
import { GiphyActions } from './app/actions/giphy'

if (environment.production) {
  enableProdMode()
}

bootstrap(AppComponent, [
  provideStore({ giphy: reducer }),
  runEffects([ GiphyEffects ]),
  services,
  [GiphyActions],
  instrumentStore({
    monitor: useLogMonitor({
      visible: true,
      position: 'right'
    })
  })
])

   * Override the default location strategy with `HashLocationStrategy`
   */
  { provide: LocationStrategy, useClass: HashLocationStrategy },

  /**
   * provideDB sets up @ngrx/db with the provided schema and makes the Database
   * service everywhere.
   */
  provideDB(schema),

  /**
   * instrumentStore() sets up the @ngrx/store-devtools providers
   */
  instrumentStore({
    monitor: useLogMonitor({
      position: 'right',
      visible: true
    })
  }),

  /**
   * Finall we provide additional services and action creators so they can
   * be used by all of our components, effects, and guards.
   */
  services,
  actions,
  guards,

  disableDeprecatedForms(),
  provideForms()
]);

export function instrumentOptions() {
  return {
    monitor: useLogMonitor({ visible: true, position: 'right' })
  };
}

import {Provider} from '@angular/core';
import {provideStore} from '@ngrx/store';
import {instrumentStore} from '@ngrx/store-devtools';
import {useLogMonitor} from '@ngrx/store-log-monitor';

// Reducers
import {counterReducer} from '../counter/counter.reducer';

export interface AppState {
  counter: number;
}

export const STORE_PROVIDERS: Provider[] = [
  ...provideStore(
    {
      counter: counterReducer
    }, {
      counter: 55
    }
  ),
  ...instrumentStore({
    monitor: useLogMonitor({
      // Default log monitor options
      position: 'bottom',
      visible: false,
      size: 0.3
    })
  }),
];

import { provideStore } from '@ngrx/store';
import { peopleReducer } from './app/reducers/peopleReducer';
import { partyFilter } from './app/reducers/partyFilterReducer';
import { instrumentStore } from '@ngrx/store-devtools';
import { useLogMonitor } from '@ngrx/store-log-monitor';
import { disableDeprecatedForms, provideForms } from '@angular/forms';
import "angular2-materialize";

let providers = [
  disableDeprecatedForms(),
  provideForms(),
  provideStore({people: peopleReducer, partyFilter: partyFilter})
];

if (environment.production) {
  enableProdMode();
}

if (!environment.production) {
  providers.push(instrumentStore({
    monitor: useLogMonitor({
      visible: false,
      position: 'bottom'
    })
  }));
}

bootstrap(AppComponent, providers).catch((e) => {
  console.log(e);
}) ;

import {bootstrap} from "@angular/platform-browser-dynamic";
import {HashLocationStrategy, LocationStrategy, APP_BASE_HREF} from "@angular/common";
import "rxjs/add/operator/do";
import {store} from "./common/store";
import {HTTP_PROVIDERS} from "@angular/http";
import {instrumentStore} from "@ngrx/store-devtools";
import {provideStore} from "@ngrx/store";
import {useLogMonitor} from "@ngrx/store-log-monitor";
import {AppRoutes} from "./common/routes";
import {provideRouter} from "@angular/router";
import {provideForms} from "@angular/forms";
import {AuthenticatedGuard} from "./common/authenticated.guard";


bootstrap(WineCellarApp, [
    provideRouter(AppRoutes),
    HTTP_PROVIDERS,
    {provide: APP_BASE_HREF, useValue: "/"},
    {provide: LocationStrategy, useClass: HashLocationStrategy},
    provideForms(),
    provideStore(store),
    AuthenticatedGuard,
    instrumentStore({
        monitor: useLogMonitor({
            visible: false,
            position: "right"
        })
    }),
])
.catch((err: any) => console.error(err));