@ngrx/store-devtools

  • Version 12.4.0
  • Published
  • 666 kB
  • 1 dependency
  • MIT license

Install

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

Overview

Developer tools for @ngrx/store

Index

Variables

variable INITIAL_OPTIONS

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

variable ɵa

const ɵa: any;

    variable ɵe

    const ɵe: any;

      variable ɵh

      const ɵh: any;

        variable RECOMPUTE

        const RECOMPUTE: string;

          Functions

          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;

                    Classes

                    class ɵi

                    class DevtoolsExtension {}

                      constructor

                      constructor(
                      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> {}

                                    constructor

                                    constructor(
                                    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 {}
                                                                            • See Also

                                                                              • http://extension.remotedev.io/docs/API/Arguments.html

                                                                            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?: 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.

                                                                                    class StoreDevtoolsModule

                                                                                    class StoreDevtoolsModule {}

                                                                                      method instrument

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

                                                                                        Interfaces

                                                                                        interface DevToolsFeatureOptions

                                                                                        interface DevToolsFeatureOptions {}
                                                                                        • See Also

                                                                                          • http://extension.remotedev.io/docs/API/Arguments.html#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)

                                                                                                                Badge

                                                                                                                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
                                                                                                                  [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@ngrx/store-devtools)
                                                                                                                • 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>