• Version 17.2.0
  • Published
  • 561 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>, OnDestroy {}


        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 ngOnDestroy

                                      ngOnDestroy: () => 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 connectInZone

                                                      connectInZone?: boolean;
                                                      • The property determines whether the extension connection is established within the Angular zone or not. It is set to false by default.

                                                      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>