@ngrx/store-devtools 12.5.0 → 13.0.0

package/esm2020/ngrx-store-devtools.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmdyeC1zdG9yZS1kZXZ0b29scy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL21vZHVsZXMvc3RvcmUtZGV2dG9vbHMvbmdyeC1zdG9yZS1kZXZ0b29scy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==

package/esm2020/src/devtools-dispatcher.mjs

@@ -0,0 +1,11 @@
+import { ActionsSubject } from '@ngrx/store';
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class DevtoolsDispatcher extends ActionsSubject {
+}
+/** @nocollapse */ /** @nocollapse */ DevtoolsDispatcher.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DevtoolsDispatcher, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ DevtoolsDispatcher.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DevtoolsDispatcher });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DevtoolsDispatcher, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGV2dG9vbHMtZGlzcGF0Y2hlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL21vZHVsZXMvc3RvcmUtZGV2dG9vbHMvc3JjL2RldnRvb2xzLWRpc3BhdGNoZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUM3QyxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUczQyxNQUFNLE9BQU8sa0JBQW1CLFNBQVEsY0FBYzs7cUpBQXpDLGtCQUFrQjt5SkFBbEIsa0JBQWtCOzJGQUFsQixrQkFBa0I7a0JBRDlCLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBY3Rpb25zU3ViamVjdCB9IGZyb20gJ0BuZ3J4L3N0b3JlJztcbmltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIERldnRvb2xzRGlzcGF0Y2hlciBleHRlbmRzIEFjdGlvbnNTdWJqZWN0IHt9XG4iXX0=

package/esm2020/src/devtools.mjs

@@ -0,0 +1,108 @@
+import { Injectable, Inject } from '@angular/core';
+import { INITIAL_STATE, } from '@ngrx/store';
+import { merge, queueScheduler, ReplaySubject, } from 'rxjs';
+import { map, observeOn, scan, skip, withLatestFrom } from 'rxjs/operators';
+import * as Actions from './actions';
+import { STORE_DEVTOOLS_CONFIG } from './config';
+import { liftInitialState, liftReducerWith } from './reducer';
+import { liftAction, unliftState, shouldFilterActions, filterLiftedState, } from './utils';
+import { PERFORM_ACTION } from './actions';
+import * as i0 from "@angular/core";
+import * as i1 from "./devtools-dispatcher";
+import * as i2 from "@ngrx/store";
+import * as i3 from "./extension";
+import * as i4 from "./config";
+export class StoreDevtools {
+    constructor(dispatcher, actions$, reducers$, extension, scannedActions, errorHandler, initialState, config) {
+        const liftedInitialState = liftInitialState(initialState, config.monitor);
+        const liftReducer = liftReducerWith(initialState, liftedInitialState, errorHandler, config.monitor, config);
+        const liftedAction$ = merge(merge(actions$.asObservable().pipe(skip(1)), extension.actions$).pipe(map(liftAction)), dispatcher, extension.liftedActions$).pipe(observeOn(queueScheduler));
+        const liftedReducer$ = reducers$.pipe(map(liftReducer));
+        const liftedStateSubject = new ReplaySubject(1);
+        const liftedStateSubscription = liftedAction$
+            .pipe(withLatestFrom(liftedReducer$), scan(({ state: liftedState }, [action, reducer]) => {
+            let reducedLiftedState = reducer(liftedState, action);
+            // On full state update
+            // If we have actions filters, we must filter completely our lifted state to be sync with the extension
+            if (action.type !== PERFORM_ACTION && shouldFilterActions(config)) {
+                reducedLiftedState = filterLiftedState(reducedLiftedState, config.predicate, config.actionsSafelist, config.actionsBlocklist);
+            }
+            // Extension should be sent the sanitized lifted state
+            extension.notify(action, reducedLiftedState);
+            return { state: reducedLiftedState, action };
+        }, { state: liftedInitialState, action: null }))
+            .subscribe(({ state, action }) => {
+            liftedStateSubject.next(state);
+            if (action.type === Actions.PERFORM_ACTION) {
+                const unliftedAction = action.action;
+                scannedActions.next(unliftedAction);
+            }
+        });
+        const extensionStartSubscription = extension.start$.subscribe(() => {
+            this.refresh();
+        });
+        const liftedState$ = liftedStateSubject.asObservable();
+        const state$ = liftedState$.pipe(map(unliftState));
+        this.extensionStartSubscription = extensionStartSubscription;
+        this.stateSubscription = liftedStateSubscription;
+        this.dispatcher = dispatcher;
+        this.liftedState = liftedState$;
+        this.state = state$;
+    }
+    dispatch(action) {
+        this.dispatcher.next(action);
+    }
+    next(action) {
+        this.dispatcher.next(action);
+    }
+    error(error) { }
+    complete() { }
+    performAction(action) {
+        this.dispatch(new Actions.PerformAction(action, +Date.now()));
+    }
+    refresh() {
+        this.dispatch(new Actions.Refresh());
+    }
+    reset() {
+        this.dispatch(new Actions.Reset(+Date.now()));
+    }
+    rollback() {
+        this.dispatch(new Actions.Rollback(+Date.now()));
+    }
+    commit() {
+        this.dispatch(new Actions.Commit(+Date.now()));
+    }
+    sweep() {
+        this.dispatch(new Actions.Sweep());
+    }
+    toggleAction(id) {
+        this.dispatch(new Actions.ToggleAction(id));
+    }
+    jumpToAction(actionId) {
+        this.dispatch(new Actions.JumpToAction(actionId));
+    }
+    jumpToState(index) {
+        this.dispatch(new Actions.JumpToState(index));
+    }
+    importState(nextLiftedState) {
+        this.dispatch(new Actions.ImportState(nextLiftedState));
+    }
+    lockChanges(status) {
+        this.dispatch(new Actions.LockChanges(status));
+    }
+    pauseRecording(status) {
+        this.dispatch(new Actions.PauseRecording(status));
+    }
+}
+/** @nocollapse */ /** @nocollapse */ StoreDevtools.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: StoreDevtools, deps: [{ token: i1.DevtoolsDispatcher }, { token: i2.ActionsSubject }, { token: i2.ReducerObservable }, { token: i3.DevtoolsExtension }, { token: i2.ScannedActionsSubject }, { token: i0.ErrorHandler }, { token: INITIAL_STATE }, { token: STORE_DEVTOOLS_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ StoreDevtools.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: StoreDevtools });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: StoreDevtools, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.DevtoolsDispatcher }, { type: i2.ActionsSubject }, { type: i2.ReducerObservable }, { type: i3.DevtoolsExtension }, { type: i2.ScannedActionsSubject }, { type: i0.ErrorHandler }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [INITIAL_STATE]
+                }] }, { type: i4.StoreDevtoolsConfig, decorators: [{
+                    type: Inject,
+                    args: [STORE_DEVTOOLS_CONFIG]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"devtools.js","sourceRoot":"","sources":["../../../../../modules/store-devtools/src/devtools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,EAAgB,MAAM,eAAe,CAAC;AACjE,OAAO,EAIL,aAAa,GAGd,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,KAAK,EAGL,cAAc,EACd,aAAa,GAEd,MAAM,MAAM,CAAC;AACd,OAAO,EAAE,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAE5E,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AACrC,OAAO,EAAE,qBAAqB,EAAuB,MAAM,UAAU,CAAC;AAEtE,OAAO,EAAe,gBAAgB,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAC3E,OAAO,EACL,UAAU,EACV,WAAW,EACX,mBAAmB,EACnB,iBAAiB,GAClB,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;;;;;;AAG3C,MAAM,OAAO,aAAa;IAOxB,YACE,UAA8B,EAC9B,QAAwB,EACxB,SAA4B,EAC5B,SAA4B,EAC5B,cAAqC,EACrC,YAA0B,EACH,YAAiB,EACT,MAA2B;QAE1D,MAAM,kBAAkB,GAAG,gBAAgB,CAAC,YAAY,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC;QAC1E,MAAM,WAAW,GAAG,eAAe,CACjC,YAAY,EACZ,kBAAkB,EAClB,YAAY,EACZ,MAAM,CAAC,OAAO,EACd,MAAM,CACP,CAAC;QAEF,MAAM,aAAa,GAAG,KAAK,CACzB,KAAK,CAAC,QAAQ,CAAC,YAAY,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC,IAAI,CACnE,GAAG,CAAC,UAAU,CAAC,CAChB,EACD,UAAU,EACV,SAAS,CAAC,cAAc,CACzB,CAAC,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC,CAAC;QAElC,MAAM,cAAc,GAAG,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC;QAExD,MAAM,kBAAkB,GAAG,IAAI,aAAa,CAAc,CAAC,CAAC,CAAC;QAE7D,MAAM,uBAAuB,GAAG,aAAa;aAC1C,IAAI,CACH,cAAc,CAAC,cAAc,CAAC,EAC9B,IAAI,CAOF,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAAE;YAC5C,IAAI,kBAAkB,GAAG,OAAO,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;YACtD,uBAAuB;YACvB,uGAAuG;YACvG,IAAI,MAAM,CAAC,IAAI,KAAK,cAAc,IAAI,mBAAmB,CAAC,MAAM,CAAC,EAAE;gBACjE,kBAAkB,GAAG,iBAAiB,CACpC,kBAAkB,EAClB,MAAM,CAAC,SAAS,EAChB,MAAM,CAAC,eAAe,EACtB,MAAM,CAAC,gBAAgB,CACxB,CAAC;aACH;YACD,sDAAsD;YACtD,SAAS,CAAC,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;YAC7C,OAAO,EAAE,KAAK,EAAE,kBAAkB,EAAE,MAAM,EAAE,CAAC;QAC/C,CAAC,EACD,EAAE,KAAK,EAAE,kBAAkB,EAAE,MAAM,EAAE,IAAW,EAAE,CACnD,CACF;aACA,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE;YAC/B,kBAAkB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAE/B,IAAI,MAAM,CAAC,IAAI,KAAK,OAAO,CAAC,cAAc,EAAE;gBAC1C,MAAM,cAAc,GAAI,MAAgC,CAAC,MAAM,CAAC;gBAEhE,cAAc,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;aACrC;QACH,CAAC,CAAC,CAAC;QAEL,MAAM,0BAA0B,GAAG,SAAS,CAAC,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE;YACjE,IAAI,CAAC,OAAO,EAAE,CAAC;QACjB,CAAC,CAAC,CAAC;QAEH,MAAM,YAAY,GAAG,kBAAkB,CAAC,YAAY,EAEnD,CAAC;QACF,MAAM,MAAM,GAAG,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC;QAEnD,IAAI,CAAC,0BAA0B,GAAG,0BAA0B,CAAC;QAC7D,IAAI,CAAC,iBAAiB,GAAG,uBAAuB,CAAC;QACjD,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,WAAW,GAAG,YAAY,CAAC;QAChC,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC;IACtB,CAAC;IAED,QAAQ,CAAC,MAAc;QACrB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC/B,CAAC;IAED,IAAI,CAAC,MAAW;QACd,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC/B,CAAC;IAED,KAAK,CAAC,KAAU,IAAG,CAAC;IAEpB,QAAQ,KAAI,CAAC;IAEb,aAAa,CAAC,MAAW;QACvB,IAAI,CAAC,QAAQ,CAAC,IAAI,OAAO,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;IAChE,CAAC;IAED,OAAO;QACL,IAAI,CAAC,QAAQ,CAAC,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;IACvC,CAAC;IAED,KAAK;QACH,IAAI,CAAC,QAAQ,CAAC,IAAI,OAAO,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;IAChD,CAAC;IAED,QAAQ;QACN,IAAI,CAAC,QAAQ,CAAC,IAAI,OAAO,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;IACnD,CAAC;IAED,MAAM;QACJ,IAAI,CAAC,QAAQ,CAAC,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;IACjD,CAAC;IAED,KAAK;QACH,IAAI,CAAC,QAAQ,CAAC,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC;IACrC,CAAC;IAED,YAAY,CAAC,EAAU;QACrB,IAAI,CAAC,QAAQ,CAAC,IAAI,OAAO,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC,CAAC;IAC9C,CAAC;IAED,YAAY,CAAC,QAAgB;QAC3B,IAAI,CAAC,QAAQ,CAAC,IAAI,OAAO,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC;IACpD,CAAC;IAED,WAAW,CAAC,KAAa;QACvB,IAAI,CAAC,QAAQ,CAAC,IAAI,OAAO,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;IAChD,CAAC;IAED,WAAW,CAAC,eAAoB;QAC9B,IAAI,CAAC,QAAQ,CAAC,IAAI,OAAO,CAAC,WAAW,CAAC,eAAe,CAAC,CAAC,CAAC;IAC1D,CAAC;IAED,WAAW,CAAC,MAAe;QACzB,IAAI,CAAC,QAAQ,CAAC,IAAI,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC;IACjD,CAAC;IAED,cAAc,CAAC,MAAe;QAC5B,IAAI,CAAC,QAAQ,CAAC,IAAI,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC;IACpD,CAAC;;gJAvJU,aAAa,qNAcd,aAAa,aACb,qBAAqB;oJAfpB,aAAa;2FAAb,aAAa;kBADzB,UAAU;;0BAeN,MAAM;2BAAC,aAAa;;0BACpB,MAAM;2BAAC,qBAAqB","sourcesContent":["import { Injectable, Inject, ErrorHandler } from '@angular/core';\nimport {\n  Action,\n  ActionReducer,\n  ActionsSubject,\n  INITIAL_STATE,\n  ReducerObservable,\n  ScannedActionsSubject,\n} from '@ngrx/store';\nimport {\n  merge,\n  Observable,\n  Observer,\n  queueScheduler,\n  ReplaySubject,\n  Subscription,\n} from 'rxjs';\nimport { map, observeOn, scan, skip, withLatestFrom } from 'rxjs/operators';\n\nimport * as Actions from './actions';\nimport { STORE_DEVTOOLS_CONFIG, StoreDevtoolsConfig } from './config';\nimport { DevtoolsExtension } from './extension';\nimport { LiftedState, liftInitialState, liftReducerWith } from './reducer';\nimport {\n  liftAction,\n  unliftState,\n  shouldFilterActions,\n  filterLiftedState,\n} from './utils';\nimport { DevtoolsDispatcher } from './devtools-dispatcher';\nimport { PERFORM_ACTION } from './actions';\n\n@Injectable()\nexport class StoreDevtools implements Observer<any> {\n  private stateSubscription: Subscription;\n  private extensionStartSubscription: Subscription;\n  public dispatcher: ActionsSubject;\n  public liftedState: Observable<LiftedState>;\n  public state: Observable<any>;\n\n  constructor(\n    dispatcher: DevtoolsDispatcher,\n    actions$: ActionsSubject,\n    reducers$: ReducerObservable,\n    extension: DevtoolsExtension,\n    scannedActions: ScannedActionsSubject,\n    errorHandler: ErrorHandler,\n    @Inject(INITIAL_STATE) initialState: any,\n    @Inject(STORE_DEVTOOLS_CONFIG) config: StoreDevtoolsConfig\n  ) {\n    const liftedInitialState = liftInitialState(initialState, config.monitor);\n    const liftReducer = liftReducerWith(\n      initialState,\n      liftedInitialState,\n      errorHandler,\n      config.monitor,\n      config\n    );\n\n    const liftedAction$ = merge(\n      merge(actions$.asObservable().pipe(skip(1)), extension.actions$).pipe(\n        map(liftAction)\n      ),\n      dispatcher,\n      extension.liftedActions$\n    ).pipe(observeOn(queueScheduler));\n\n    const liftedReducer$ = reducers$.pipe(map(liftReducer));\n\n    const liftedStateSubject = new ReplaySubject<LiftedState>(1);\n\n    const liftedStateSubscription = liftedAction$\n      .pipe(\n        withLatestFrom(liftedReducer$),\n        scan<\n          [any, ActionReducer<LiftedState, Actions.All>],\n          {\n            state: LiftedState;\n            action: any;\n          }\n        >(\n          ({ state: liftedState }, [action, reducer]) => {\n            let reducedLiftedState = reducer(liftedState, action);\n            // On full state update\n            // If we have actions filters, we must filter completely our lifted state to be sync with the extension\n            if (action.type !== PERFORM_ACTION && shouldFilterActions(config)) {\n              reducedLiftedState = filterLiftedState(\n                reducedLiftedState,\n                config.predicate,\n                config.actionsSafelist,\n                config.actionsBlocklist\n              );\n            }\n            // Extension should be sent the sanitized lifted state\n            extension.notify(action, reducedLiftedState);\n            return { state: reducedLiftedState, action };\n          },\n          { state: liftedInitialState, action: null as any }\n        )\n      )\n      .subscribe(({ state, action }) => {\n        liftedStateSubject.next(state);\n\n        if (action.type === Actions.PERFORM_ACTION) {\n          const unliftedAction = (action as Actions.PerformAction).action;\n\n          scannedActions.next(unliftedAction);\n        }\n      });\n\n    const extensionStartSubscription = extension.start$.subscribe(() => {\n      this.refresh();\n    });\n\n    const liftedState$ = liftedStateSubject.asObservable() as Observable<\n      LiftedState\n    >;\n    const state$ = liftedState$.pipe(map(unliftState));\n\n    this.extensionStartSubscription = extensionStartSubscription;\n    this.stateSubscription = liftedStateSubscription;\n    this.dispatcher = dispatcher;\n    this.liftedState = liftedState$;\n    this.state = state$;\n  }\n\n  dispatch(action: Action) {\n    this.dispatcher.next(action);\n  }\n\n  next(action: any) {\n    this.dispatcher.next(action);\n  }\n\n  error(error: any) {}\n\n  complete() {}\n\n  performAction(action: any) {\n    this.dispatch(new Actions.PerformAction(action, +Date.now()));\n  }\n\n  refresh() {\n    this.dispatch(new Actions.Refresh());\n  }\n\n  reset() {\n    this.dispatch(new Actions.Reset(+Date.now()));\n  }\n\n  rollback() {\n    this.dispatch(new Actions.Rollback(+Date.now()));\n  }\n\n  commit() {\n    this.dispatch(new Actions.Commit(+Date.now()));\n  }\n\n  sweep() {\n    this.dispatch(new Actions.Sweep());\n  }\n\n  toggleAction(id: number) {\n    this.dispatch(new Actions.ToggleAction(id));\n  }\n\n  jumpToAction(actionId: number) {\n    this.dispatch(new Actions.JumpToAction(actionId));\n  }\n\n  jumpToState(index: number) {\n    this.dispatch(new Actions.JumpToState(index));\n  }\n\n  importState(nextLiftedState: any) {\n    this.dispatch(new Actions.ImportState(nextLiftedState));\n  }\n\n  lockChanges(status: boolean) {\n    this.dispatch(new Actions.LockChanges(status));\n  }\n\n  pauseRecording(status: boolean) {\n    this.dispatch(new Actions.PauseRecording(status));\n  }\n}\n"]}

package/esm2020/src/extension.mjs

@@ -0,0 +1,161 @@
+import { Inject, Injectable, InjectionToken } from '@angular/core';
+import { UPDATE } from '@ngrx/store';
+import { EMPTY, Observable, of } from 'rxjs';
+import { catchError, concatMap, debounceTime, filter, map, share, switchMap, take, takeUntil, timeout, } from 'rxjs/operators';
+import { IMPORT_STATE, PERFORM_ACTION } from './actions';
+import { STORE_DEVTOOLS_CONFIG, } from './config';
+import { isActionFiltered, sanitizeAction, sanitizeActions, sanitizeState, sanitizeStates, shouldFilterActions, unliftState, } from './utils';
+import * as i0 from "@angular/core";
+import * as i1 from "./devtools-dispatcher";
+import * as i2 from "./config";
+export const ExtensionActionTypes = {
+    START: 'START',
+    DISPATCH: 'DISPATCH',
+    STOP: 'STOP',
+    ACTION: 'ACTION',
+};
+export const REDUX_DEVTOOLS_EXTENSION = new InjectionToken('@ngrx/store-devtools Redux Devtools Extension');
+export class DevtoolsExtension {
+    constructor(devtoolsExtension, config, dispatcher) {
+        this.config = config;
+        this.dispatcher = dispatcher;
+        this.devtoolsExtension = devtoolsExtension;
+        this.createActionStreams();
+    }
+    notify(action, state) {
+        if (!this.devtoolsExtension) {
+            return;
+        }
+        // Check to see if the action requires a full update of the liftedState.
+        // If it is a simple action generated by the user's app and the recording
+        // is not locked/paused, only send the action and the current state (fast).
+        //
+        // A full liftedState update (slow: serializes the entire liftedState) is
+        // only required when:
+        //   a) redux-devtools-extension fires the @@Init action (ignored by
+        //      @ngrx/store-devtools)
+        //   b) an action is generated by an @ngrx module (e.g. @ngrx/effects/init
+        //      or @ngrx/store/update-reducers)
+        //   c) the state has been recomputed due to time-traveling
+        //   d) any action that is not a PerformAction to err on the side of
+        //      caution.
+        if (action.type === PERFORM_ACTION) {
+            if (state.isLocked || state.isPaused) {
+                return;
+            }
+            const currentState = unliftState(state);
+            if (shouldFilterActions(this.config) &&
+                isActionFiltered(currentState, action, this.config.predicate, this.config.actionsSafelist, this.config.actionsBlocklist)) {
+                return;
+            }
+            const sanitizedState = this.config.stateSanitizer
+                ? sanitizeState(this.config.stateSanitizer, currentState, state.currentStateIndex)
+                : currentState;
+            const sanitizedAction = this.config.actionSanitizer
+                ? sanitizeAction(this.config.actionSanitizer, action, state.nextActionId)
+                : action;
+            this.sendToReduxDevtools(() => this.extensionConnection.send(sanitizedAction, sanitizedState));
+        }
+        else {
+            // Requires full state update
+            const sanitizedLiftedState = {
+                ...state,
+                stagedActionIds: state.stagedActionIds,
+                actionsById: this.config.actionSanitizer
+                    ? sanitizeActions(this.config.actionSanitizer, state.actionsById)
+                    : state.actionsById,
+                computedStates: this.config.stateSanitizer
+                    ? sanitizeStates(this.config.stateSanitizer, state.computedStates)
+                    : state.computedStates,
+            };
+            this.sendToReduxDevtools(() => this.devtoolsExtension.send(null, sanitizedLiftedState, this.getExtensionConfig(this.config)));
+        }
+    }
+    createChangesObservable() {
+        if (!this.devtoolsExtension) {
+            return EMPTY;
+        }
+        return new Observable((subscriber) => {
+            const connection = this.devtoolsExtension.connect(this.getExtensionConfig(this.config));
+            this.extensionConnection = connection;
+            connection.init();
+            connection.subscribe((change) => subscriber.next(change));
+            return connection.unsubscribe;
+        });
+    }
+    createActionStreams() {
+        // Listens to all changes
+        const changes$ = this.createChangesObservable().pipe(share());
+        // Listen for the start action
+        const start$ = changes$.pipe(filter((change) => change.type === ExtensionActionTypes.START));
+        // Listen for the stop action
+        const stop$ = changes$.pipe(filter((change) => change.type === ExtensionActionTypes.STOP));
+        // Listen for lifted actions
+        const liftedActions$ = changes$.pipe(filter((change) => change.type === ExtensionActionTypes.DISPATCH), map((change) => this.unwrapAction(change.payload)), concatMap((action) => {
+            if (action.type === IMPORT_STATE) {
+                // State imports may happen in two situations:
+                // 1. Explicitly by user
+                // 2. User activated the "persist state accross reloads" option
+                //    and now the state is imported during reload.
+                // Because of option 2, we need to give possible
+                // lazy loaded reducers time to instantiate.
+                // As soon as there is no UPDATE action within 1 second,
+                // it is assumed that all reducers are loaded.
+                return this.dispatcher.pipe(filter((action) => action.type === UPDATE), timeout(1000), debounceTime(1000), map(() => action), catchError(() => of(action)), take(1));
+            }
+            else {
+                return of(action);
+            }
+        }));
+        // Listen for unlifted actions
+        const actions$ = changes$.pipe(filter((change) => change.type === ExtensionActionTypes.ACTION), map((change) => this.unwrapAction(change.payload)));
+        const actionsUntilStop$ = actions$.pipe(takeUntil(stop$));
+        const liftedUntilStop$ = liftedActions$.pipe(takeUntil(stop$));
+        this.start$ = start$.pipe(takeUntil(stop$));
+        // Only take the action sources between the start/stop events
+        this.actions$ = this.start$.pipe(switchMap(() => actionsUntilStop$));
+        this.liftedActions$ = this.start$.pipe(switchMap(() => liftedUntilStop$));
+    }
+    unwrapAction(action) {
+        return typeof action === 'string' ? eval(`(${action})`) : action;
+    }
+    getExtensionConfig(config) {
+        const extensionOptions = {
+            name: config.name,
+            features: config.features,
+            serialize: config.serialize,
+            autoPause: config.autoPause ?? false,
+            // The action/state sanitizers are not added to the config
+            // because sanitation is done in this class already.
+            // It is done before sending it to the devtools extension for consistency:
+            // - If we call extensionConnection.send(...),
+            //   the extension would call the sanitizers.
+            // - If we call devtoolsExtension.send(...) (aka full state update),
+            //   the extension would NOT call the sanitizers, so we have to do it ourselves.
+        };
+        if (config.maxAge !== false /* support === 0 */) {
+            extensionOptions.maxAge = config.maxAge;
+        }
+        return extensionOptions;
+    }
+    sendToReduxDevtools(send) {
+        try {
+            send();
+        }
+        catch (err) {
+            console.warn('@ngrx/store-devtools: something went wrong inside the redux devtools', err);
+        }
+    }
+}
+/** @nocollapse */ /** @nocollapse */ DevtoolsExtension.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DevtoolsExtension, deps: [{ token: REDUX_DEVTOOLS_EXTENSION }, { token: STORE_DEVTOOLS_CONFIG }, { token: i1.DevtoolsDispatcher }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ DevtoolsExtension.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DevtoolsExtension });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DevtoolsExtension, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [REDUX_DEVTOOLS_EXTENSION]
+                }] }, { type: i2.StoreDevtoolsConfig, decorators: [{
+                    type: Inject,
+                    args: [STORE_DEVTOOLS_CONFIG]
+                }] }, { type: i1.DevtoolsDispatcher }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"extension.js","sourceRoot":"","sources":["../../../../../modules/store-devtools/src/extension.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, InjectionToken } from '@angular/core';\nimport { Action, UPDATE } from '@ngrx/store';\nimport { EMPTY, Observable, of } from 'rxjs';\nimport {\n  catchError,\n  concatMap,\n  debounceTime,\n  filter,\n  map,\n  share,\n  switchMap,\n  take,\n  takeUntil,\n  timeout,\n} from 'rxjs/operators';\n\nimport { IMPORT_STATE, PERFORM_ACTION } from './actions';\nimport {\n  SerializationOptions,\n  STORE_DEVTOOLS_CONFIG,\n  StoreDevtoolsConfig,\n} from './config';\nimport { DevtoolsDispatcher } from './devtools-dispatcher';\nimport { LiftedAction, LiftedState } from './reducer';\nimport {\n  isActionFiltered,\n  sanitizeAction,\n  sanitizeActions,\n  sanitizeState,\n  sanitizeStates,\n  shouldFilterActions,\n  unliftState,\n} from './utils';\n\nexport const ExtensionActionTypes = {\n  START: 'START',\n  DISPATCH: 'DISPATCH',\n  STOP: 'STOP',\n  ACTION: 'ACTION',\n};\n\nexport const REDUX_DEVTOOLS_EXTENSION =\n  new InjectionToken<ReduxDevtoolsExtension>(\n    '@ngrx/store-devtools Redux Devtools Extension'\n  );\n\nexport interface ReduxDevtoolsExtensionConnection {\n  subscribe(listener: (change: any) => void): void;\n  unsubscribe(): void;\n  send(action: any, state: any): void;\n  init(state?: any): void;\n  error(anyErr: any): void;\n}\nexport interface ReduxDevtoolsExtensionConfig {\n  features?: object | boolean;\n  name: string | undefined;\n  maxAge?: number;\n  autoPause?: boolean;\n  serialize?: boolean | SerializationOptions;\n}\n\nexport interface ReduxDevtoolsExtension {\n  connect(\n    options: ReduxDevtoolsExtensionConfig\n  ): ReduxDevtoolsExtensionConnection;\n  send(action: any, state: any, options: ReduxDevtoolsExtensionConfig): void;\n}\n\n@Injectable()\nexport class DevtoolsExtension {\n  private devtoolsExtension: ReduxDevtoolsExtension;\n  private extensionConnection!: ReduxDevtoolsExtensionConnection;\n\n  liftedActions$!: Observable<any>;\n  actions$!: Observable<any>;\n  start$!: Observable<any>;\n\n  constructor(\n    @Inject(REDUX_DEVTOOLS_EXTENSION) devtoolsExtension: ReduxDevtoolsExtension,\n    @Inject(STORE_DEVTOOLS_CONFIG) private config: StoreDevtoolsConfig,\n    private dispatcher: DevtoolsDispatcher\n  ) {\n    this.devtoolsExtension = devtoolsExtension;\n    this.createActionStreams();\n  }\n\n  notify(action: LiftedAction, state: LiftedState) {\n    if (!this.devtoolsExtension) {\n      return;\n    }\n    // Check to see if the action requires a full update of the liftedState.\n    // If it is a simple action generated by the user's app and the recording\n    // is not locked/paused, only send the action and the current state (fast).\n    //\n    // A full liftedState update (slow: serializes the entire liftedState) is\n    // only required when:\n    //   a) redux-devtools-extension fires the @@Init action (ignored by\n    //      @ngrx/store-devtools)\n    //   b) an action is generated by an @ngrx module (e.g. @ngrx/effects/init\n    //      or @ngrx/store/update-reducers)\n    //   c) the state has been recomputed due to time-traveling\n    //   d) any action that is not a PerformAction to err on the side of\n    //      caution.\n    if (action.type === PERFORM_ACTION) {\n      if (state.isLocked || state.isPaused) {\n        return;\n      }\n\n      const currentState = unliftState(state);\n      if (\n        shouldFilterActions(this.config) &&\n        isActionFiltered(\n          currentState,\n          action,\n          this.config.predicate,\n          this.config.actionsSafelist,\n          this.config.actionsBlocklist\n        )\n      ) {\n        return;\n      }\n      const sanitizedState = this.config.stateSanitizer\n        ? sanitizeState(\n            this.config.stateSanitizer,\n            currentState,\n            state.currentStateIndex\n          )\n        : currentState;\n      const sanitizedAction = this.config.actionSanitizer\n        ? sanitizeAction(\n            this.config.actionSanitizer,\n            action,\n            state.nextActionId\n          )\n        : action;\n\n      this.sendToReduxDevtools(() =>\n        this.extensionConnection.send(sanitizedAction, sanitizedState)\n      );\n    } else {\n      // Requires full state update\n      const sanitizedLiftedState = {\n        ...state,\n        stagedActionIds: state.stagedActionIds,\n        actionsById: this.config.actionSanitizer\n          ? sanitizeActions(this.config.actionSanitizer, state.actionsById)\n          : state.actionsById,\n        computedStates: this.config.stateSanitizer\n          ? sanitizeStates(this.config.stateSanitizer, state.computedStates)\n          : state.computedStates,\n      };\n\n      this.sendToReduxDevtools(() =>\n        this.devtoolsExtension.send(\n          null,\n          sanitizedLiftedState,\n          this.getExtensionConfig(this.config)\n        )\n      );\n    }\n  }\n\n  private createChangesObservable(): Observable<any> {\n    if (!this.devtoolsExtension) {\n      return EMPTY;\n    }\n\n    return new Observable((subscriber) => {\n      const connection = this.devtoolsExtension.connect(\n        this.getExtensionConfig(this.config)\n      );\n      this.extensionConnection = connection;\n      connection.init();\n\n      connection.subscribe((change: any) => subscriber.next(change));\n      return connection.unsubscribe;\n    });\n  }\n\n  private createActionStreams() {\n    // Listens to all changes\n    const changes$ = this.createChangesObservable().pipe(share());\n\n    // Listen for the start action\n    const start$ = changes$.pipe(\n      filter((change: any) => change.type === ExtensionActionTypes.START)\n    );\n\n    // Listen for the stop action\n    const stop$ = changes$.pipe(\n      filter((change: any) => change.type === ExtensionActionTypes.STOP)\n    );\n\n    // Listen for lifted actions\n    const liftedActions$ = changes$.pipe(\n      filter((change) => change.type === ExtensionActionTypes.DISPATCH),\n      map((change) => this.unwrapAction(change.payload)),\n      concatMap((action: any) => {\n        if (action.type === IMPORT_STATE) {\n          // State imports may happen in two situations:\n          // 1. Explicitly by user\n          // 2. User activated the \"persist state accross reloads\" option\n          //    and now the state is imported during reload.\n          // Because of option 2, we need to give possible\n          // lazy loaded reducers time to instantiate.\n          // As soon as there is no UPDATE action within 1 second,\n          // it is assumed that all reducers are loaded.\n          return this.dispatcher.pipe(\n            filter((action) => action.type === UPDATE),\n            timeout(1000),\n            debounceTime(1000),\n            map(() => action),\n            catchError(() => of(action)),\n            take(1)\n          );\n        } else {\n          return of(action);\n        }\n      })\n    );\n\n    // Listen for unlifted actions\n    const actions$ = changes$.pipe(\n      filter((change) => change.type === ExtensionActionTypes.ACTION),\n      map((change) => this.unwrapAction(change.payload))\n    );\n\n    const actionsUntilStop$ = actions$.pipe(takeUntil(stop$));\n    const liftedUntilStop$ = liftedActions$.pipe(takeUntil(stop$));\n    this.start$ = start$.pipe(takeUntil(stop$));\n\n    // Only take the action sources between the start/stop events\n    this.actions$ = this.start$.pipe(switchMap(() => actionsUntilStop$));\n    this.liftedActions$ = this.start$.pipe(switchMap(() => liftedUntilStop$));\n  }\n\n  private unwrapAction(action: Action) {\n    return typeof action === 'string' ? eval(`(${action})`) : action;\n  }\n\n  private getExtensionConfig(config: StoreDevtoolsConfig) {\n    const extensionOptions: ReduxDevtoolsExtensionConfig = {\n      name: config.name,\n      features: config.features,\n      serialize: config.serialize,\n      autoPause: config.autoPause ?? false,\n      // The action/state sanitizers are not added to the config\n      // because sanitation is done in this class already.\n      // It is done before sending it to the devtools extension for consistency:\n      // - If we call extensionConnection.send(...),\n      //   the extension would call the sanitizers.\n      // - If we call devtoolsExtension.send(...) (aka full state update),\n      //   the extension would NOT call the sanitizers, so we have to do it ourselves.\n    };\n    if (config.maxAge !== false /* support === 0 */) {\n      extensionOptions.maxAge = config.maxAge;\n    }\n    return extensionOptions;\n  }\n\n  private sendToReduxDevtools(send: Function) {\n    try {\n      send();\n    } catch (err: any) {\n      console.warn(\n        '@ngrx/store-devtools: something went wrong inside the redux devtools',\n        err\n      );\n    }\n  }\n}\n"]}

package/esm2020/src/instrument.mjs

@@ -0,0 +1,71 @@
+import { InjectionToken, NgModule } from '@angular/core';
+import { ReducerManagerDispatcher, StateObservable } from '@ngrx/store';
+import { INITIAL_OPTIONS, STORE_DEVTOOLS_CONFIG, noMonitor, createConfig, } from './config';
+import { StoreDevtools } from './devtools';
+import { DevtoolsExtension, REDUX_DEVTOOLS_EXTENSION, } from './extension';
+import { DevtoolsDispatcher } from './devtools-dispatcher';
+import * as i0 from "@angular/core";
+export const IS_EXTENSION_OR_MONITOR_PRESENT = new InjectionToken('@ngrx/store-devtools Is Devtools Extension or Monitor Present');
+export function createIsExtensionOrMonitorPresent(extension, config) {
+    return Boolean(extension) || config.monitor !== noMonitor;
+}
+export function createReduxDevtoolsExtension() {
+    const extensionKey = '__REDUX_DEVTOOLS_EXTENSION__';
+    if (typeof window === 'object' &&
+        typeof window[extensionKey] !== 'undefined') {
+        return window[extensionKey];
+    }
+    else {
+        return null;
+    }
+}
+export function createStateObservable(devtools) {
+    return devtools.state;
+}
+export class StoreDevtoolsModule {
+    static instrument(options = {}) {
+        return {
+            ngModule: StoreDevtoolsModule,
+            providers: [
+                DevtoolsExtension,
+                DevtoolsDispatcher,
+                StoreDevtools,
+                {
+                    provide: INITIAL_OPTIONS,
+                    useValue: options,
+                },
+                {
+                    provide: IS_EXTENSION_OR_MONITOR_PRESENT,
+                    deps: [REDUX_DEVTOOLS_EXTENSION, STORE_DEVTOOLS_CONFIG],
+                    useFactory: createIsExtensionOrMonitorPresent,
+                },
+                {
+                    provide: REDUX_DEVTOOLS_EXTENSION,
+                    useFactory: createReduxDevtoolsExtension,
+                },
+                {
+                    provide: STORE_DEVTOOLS_CONFIG,
+                    deps: [INITIAL_OPTIONS],
+                    useFactory: createConfig,
+                },
+                {
+                    provide: StateObservable,
+                    deps: [StoreDevtools],
+                    useFactory: createStateObservable,
+                },
+                {
+                    provide: ReducerManagerDispatcher,
+                    useExisting: DevtoolsDispatcher,
+                },
+            ],
+        };
+    }
+}
+/** @nocollapse */ /** @nocollapse */ StoreDevtoolsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: StoreDevtoolsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ /** @nocollapse */ StoreDevtoolsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: StoreDevtoolsModule });
+/** @nocollapse */ /** @nocollapse */ StoreDevtoolsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: StoreDevtoolsModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: StoreDevtoolsModule, decorators: [{
+            type: NgModule,
+            args: [{}]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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