• Version 12.0.0
  • Published
  • 656 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





    variable ɵa

    const ɵa: any;

      variable ɵe

      const ɵe: any;

        variable ɵh

        const ɵh: any;

          variable RECOMPUTE

          const RECOMPUTE: string;


            function ɵb

            ɵb: (
            extension: ReduxDevtoolsExtension | null,
            config: StoreDevtoolsConfig
            ) => boolean;

              function ɵc

              ɵc: () => any;

                function ɵd

                ɵd: (devtools: StoreDevtools) => any;

                  function ɵf

                  ɵf: () => null;

                    function ɵg

                    ɵg: (optionsInput: StoreDevtoolsOptions) => StoreDevtoolsConfig;


                      class ɵi

                      class DevtoolsExtension {}


                        devtoolsExtension: ReduxDevtoolsExtension,
                        config: StoreDevtoolsConfig,
                        dispatcher: DevtoolsDispatcher

                          property actions$

                          actions$: any;

                            property liftedActions$

                            liftedActions$: any;

                              property start$

                              start$: any;

                                method notify

                                notify: (action: LiftedAction, state: LiftedState) => void;

                                  class ɵj

                                  class DevtoolsDispatcher extends ActionsSubject {}

                                    class StoreDevtools

                                    class StoreDevtools implements Observer<any> {}


                                      dispatcher: DevtoolsDispatcher,
                                      actions$: any,
                                      reducers$: any,
                                      extension: DevtoolsExtension,
                                      scannedActions: any,
                                      errorHandler: any,
                                      initialState: any,
                                      config: StoreDevtoolsConfig

                                        property dispatcher

                                        dispatcher: any;

                                          property liftedState

                                          liftedState: any;

                                            property state

                                            state: any;

                                              method commit

                                              commit: () => void;

                                                method complete

                                                complete: () => void;

                                                  method dispatch

                                                  dispatch: (action: any) => 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 {}

                                                                                property actionSanitizer

                                                                                actionSanitizer?: ActionSanitizer;

                                                                                  property actionsBlocklist

                                                                                  actionsBlocklist?: string[];

                                                                                    property actionsSafelist

                                                                                    actionsSafelist?: string[];

                                                                                      property features

                                                                                      features?: DevToolsFeatureOptions;

                                                                                        property logOnly

                                                                                        logOnly?: boolean;

                                                                                          property maxAge

                                                                                          maxAge: number | false;

                                                                                            property monitor

                                                                                            monitor?: any;

                                                                                              property name

                                                                                              name?: string;

                                                                                                property predicate

                                                                                                predicate?: Predicate;

                                                                                                  property serialize

                                                                                                  serialize?: boolean | SerializationOptions;

                                                                                                    property stateSanitizer

                                                                                                    stateSanitizer?: StateSanitizer;

                                                                                                      class StoreDevtoolsModule

                                                                                                      class StoreDevtoolsModule {}

                                                                                                        method instrument

                                                                                                        static instrument: (options?: StoreDevtoolsOptions) => any;


                                                                                                          interface DevToolsFeatureOptions

                                                                                                          interface DevToolsFeatureOptions {}

                                                                                                            property dispatch

                                                                                                            dispatch?: boolean;

                                                                                                              property export

                                                                                                              export?: boolean;

                                                                                                                property import

                                                                                                                import?: 'custom' | boolean;

                                                                                                                  property jump

                                                                                                                  jump?: boolean;

                                                                                                                    property lock

                                                                                                                    lock?: boolean;

                                                                                                                      property pause

                                                                                                                      pause?: boolean;

                                                                                                                        property persist

                                                                                                                        persist?: boolean;

                                                                                                                          property reorder

                                                                                                                          reorder?: boolean;

                                                                                                                            property skip

                                                                                                                            skip?: boolean;

                                                                                                                              property test

                                                                                                                              test?: boolean;

                                                                                                                                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>