• Version 16.0.1
  • Published
  • 527 kB
  • 1 dependency
  • MIT license


npm i @ngrx/store-devtools
yarn add @ngrx/store-devtools
pnpm add @ngrx/store-devtools


Developer tools for @ngrx/store




const INITIAL_OPTIONS: InjectionToken<StoreDevtoolsConfig>;
  • Used to provide a StoreDevtoolsConfig for the store-devtools.

variable RECOMPUTE

const RECOMPUTE: string;


    const REDUX_DEVTOOLS_EXTENSION: InjectionToken<ReduxDevtoolsExtension>;


      function provideStoreDevtools

      provideStoreDevtools: (options?: StoreDevtoolsOptions) => EnvironmentProviders;
      • Provides developer tools and instrumentation for Store.

        bootstrapApplication(AppComponent, {
        providers: [
        maxAge: 25,
        logOnly: !isDevMode(),


      class StoreDevtools

      class StoreDevtools implements Observer<any> {}


        dispatcher: DevtoolsDispatcher,
        actions$: ActionsSubject,
        reducers$: ReducerObservable,
        extension: DevtoolsExtension,
        scannedActions: ScannedActionsSubject,
        errorHandler: ErrorHandler,
        initialState: any,
        config: StoreDevtoolsConfig

          property dispatcher

          dispatcher: ActionsSubject;

            property liftedState

            liftedState: Observable<LiftedState>;

              property ɵfac

              static ɵfac: i0.ɵɵFactoryDeclaration<StoreDevtools, never>;

                property ɵprov

                static ɵprov: i0.ɵɵInjectableDeclaration<StoreDevtools>;

                  property state

                  state: StateObservable;

                    method commit

                    commit: () => void;

                      method complete

                      complete: () => void;

                        method dispatch

                        dispatch: (action: Action) => void;

                          method error

                          error: (error: any) => void;

                            method importState

                            importState: (nextLiftedState: any) => void;

                              method jumpToAction

                              jumpToAction: (actionId: number) => void;

                                method jumpToState

                                jumpToState: (index: number) => void;

                                  method lockChanges

                                  lockChanges: (status: boolean) => void;

                                    method next

                                    next: (action: any) => void;

                                      method pauseRecording

                                      pauseRecording: (status: boolean) => void;

                                        method performAction

                                        performAction: (action: any) => void;

                                          method refresh

                                          refresh: () => void;

                                            method reset

                                            reset: () => void;

                                              method rollback

                                              rollback: () => void;

                                                method sweep

                                                sweep: () => void;

                                                  method toggleAction

                                                  toggleAction: (id: number) => void;

                                                    class StoreDevtoolsConfig

                                                    class StoreDevtoolsConfig {}
                                                    • Chrome extension documentation

                                                      See Also

                                                      • https://github.com/reduxjs/redux-devtools/blob/main/extension/docs/API/Arguments.md Firefox extension documentation

                                                      • https://github.com/zalmoxisus/redux-devtools-extension/blob/master/docs/API/Arguments.md

                                                    property actionSanitizer

                                                    actionSanitizer?: ActionSanitizer;
                                                    • Function which takes action object and id number as arguments, and should return action object back.

                                                    property actionsBlocklist

                                                    actionsBlocklist?: string[];
                                                    • Action types to be hidden in the monitors. If actionsSafelist specified, actionsBlocklist is ignored.

                                                    property actionsSafelist

                                                    actionsSafelist?: string[];
                                                    • Action types to be shown in the monitors

                                                    property autoPause

                                                    autoPause?: boolean;
                                                    • Auto pauses when the extension’s window is not opened, and so has zero impact on your app when not in use.

                                                    property features

                                                    features?: DevToolsFeatureOptions;

                                                      property logOnly

                                                      logOnly?: boolean;

                                                        property maxAge

                                                        maxAge: number | false;
                                                        • Maximum allowed actions to be stored in the history tree (default: false)

                                                        property monitor

                                                        monitor?: ActionReducer<any, any>;

                                                          property name

                                                          name?: string;
                                                          • The instance name to be shown on the monitor page (default: document.title)

                                                          property predicate

                                                          predicate?: Predicate;
                                                          • Called for every action before sending, takes state and action object, and returns true in case it allows sending the current data to the monitor.

                                                          property serialize

                                                          serialize?: boolean | SerializationOptions;

                                                            property stateSanitizer

                                                            stateSanitizer?: StateSanitizer;
                                                            • Function which takes state object and index as arguments, and should return state object back.

                                                            property trace

                                                            trace?: boolean | (() => string);
                                                            • If set to true, will include stack trace for every dispatched action

                                                            property traceLimit

                                                            traceLimit?: number;
                                                            • Maximum stack trace frames to be stored (in case trace option was provided as true).

                                                            class StoreDevtoolsModule

                                                            class StoreDevtoolsModule {}

                                                              property ɵfac

                                                              static ɵfac: i0.ɵɵFactoryDeclaration<StoreDevtoolsModule, never>;

                                                                property ɵinj

                                                                static ɵinj: i0.ɵɵInjectorDeclaration<StoreDevtoolsModule>;

                                                                  property ɵmod

                                                                  static ɵmod: i0.ɵɵNgModuleDeclaration<StoreDevtoolsModule, never, never, never>;

                                                                    method instrument

                                                                    static instrument: (
                                                                    options?: StoreDevtoolsOptions
                                                                    ) => ModuleWithProviders<StoreDevtoolsModule>;


                                                                      interface DevToolsFeatureOptions

                                                                      interface DevToolsFeatureOptions {}
                                                                      • Chrome extension documentation

                                                                        See Also

                                                                        • https://github.com/reduxjs/redux-devtools/blob/main/extension/docs/API/Arguments.md#features Firefox extension documentation

                                                                        • https://github.com/zalmoxisus/redux-devtools-extension/blob/master/docs/API/Arguments.md#features

                                                                      property dispatch

                                                                      dispatch?: boolean;
                                                                      • Dispatch custom actions or action creators

                                                                      property export

                                                                      export?: boolean;
                                                                      • Export history of actions in a file

                                                                      property import

                                                                      import?: 'custom' | boolean;
                                                                      • Import history of actions from a file

                                                                      property jump

                                                                      jump?: boolean;
                                                                      • Jump back and forth (time travelling)

                                                                      property lock

                                                                      lock?: boolean;
                                                                      • Lock/unlock dispatching actions and side effects

                                                                      property pause

                                                                      pause?: boolean;
                                                                      • Start/pause recording of dispatched actions

                                                                      property persist

                                                                      persist?: boolean;
                                                                      • Persist states on page reloading

                                                                      property reorder

                                                                      reorder?: boolean;
                                                                      • Drag and drop actions in the history list

                                                                      property skip

                                                                      skip?: boolean;
                                                                      • Skip (cancel) actions

                                                                      property test

                                                                      test?: boolean;
                                                                      • Generate tests for the selected actions

                                                                      interface LiftedState

                                                                      interface LiftedState {}

                                                                        property actionsById

                                                                        actionsById: LiftedActions;

                                                                          property committedState

                                                                          committedState: any;

                                                                            property computedStates

                                                                            computedStates: ComputedState[];

                                                                              property currentStateIndex

                                                                              currentStateIndex: number;

                                                                                property isLocked

                                                                                isLocked: boolean;

                                                                                  property isPaused

                                                                                  isPaused: boolean;

                                                                                    property monitorState

                                                                                    monitorState: any;

                                                                                      property nextActionId

                                                                                      nextActionId: number;

                                                                                        property skippedActionIds

                                                                                        skippedActionIds: number[];

                                                                                          property stagedActionIds

                                                                                          stagedActionIds: number[];

                                                                                            Type Aliases

                                                                                            type StoreDevtoolsOptions

                                                                                            type StoreDevtoolsOptions =
                                                                                            | Partial<StoreDevtoolsConfig>
                                                                                            | (() => Partial<StoreDevtoolsConfig>);

                                                                                              Package Files (7)

                                                                                              Dependencies (1)

                                                                                              Dev Dependencies (0)

                                                                                              No dev dependencies.

                                                                                              Peer Dependencies (2)


                                                                                              To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                              You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@ngrx/store-devtools.

                                                                                              • Markdown
                                                                                              • HTML
                                                                                                <a href="https://www.jsdocs.io/package/@ngrx/store-devtools"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>