@ngrx/store-devtools 12.5.0

package/esm2015/src/extension.js

@@ -0,0 +1,160 @@
+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, StoreDevtoolsConfig, } from './config';
+import { DevtoolsDispatcher } from './devtools-dispatcher';
+import { isActionFiltered, sanitizeAction, sanitizeActions, sanitizeState, sanitizeStates, shouldFilterActions, unliftState, } from './utils';
+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 = Object.assign(Object.assign({}, 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) {
+        var _a;
+        const extensionOptions = {
+            name: config.name,
+            features: config.features,
+            serialize: config.serialize,
+            autoPause: (_a = config.autoPause) !== null && _a !== void 0 ? _a : 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);
+        }
+    }
+}
+/** @type {!Array<{type: !Function, args: (undefined|!Array<?>)}>} */
+DevtoolsExtension.decorators = [
+    { type: Injectable }
+];
+/**
+ * @type {function(): !Array<(null|{
+ *   type: ?,
+ *   decorators: (undefined|!Array<{type: !Function, args: (undefined|!Array<?>)}>),
+ * })>}
+ * @nocollapse
+ */
+DevtoolsExtension.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [REDUX_DEVTOOLS_EXTENSION,] }] },
+    { type: StoreDevtoolsConfig, decorators: [{ type: Inject, args: [STORE_DEVTOOLS_CONFIG,] }] },
+    { type: 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 = 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) {\n      console.warn(\n        '@ngrx/store-devtools: something went wrong inside the redux devtools',\n        err\n      );\n    }\n  }\n}\n"]}

package/esm2015/src/index.js

@@ -0,0 +1,5 @@
+export { StoreDevtoolsModule } from './instrument';
+export { RECOMPUTE } from './reducer';
+export { StoreDevtools } from './devtools';
+export { StoreDevtoolsConfig, INITIAL_OPTIONS, } from './config';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9tb2R1bGVzL3N0b3JlLWRldnRvb2xzL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFDbkQsT0FBTyxFQUFlLFNBQVMsRUFBRSxNQUFNLFdBQVcsQ0FBQztBQUNuRCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sWUFBWSxDQUFDO0FBQzNDLE9BQU8sRUFDTCxtQkFBbUIsRUFHbkIsZUFBZSxHQUNoQixNQUFNLFVBQVUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IFN0b3JlRGV2dG9vbHNNb2R1bGUgfSBmcm9tICcuL2luc3RydW1lbnQnO1xuZXhwb3J0IHsgTGlmdGVkU3RhdGUsIFJFQ09NUFVURSB9IGZyb20gJy4vcmVkdWNlcic7XG5leHBvcnQgeyBTdG9yZURldnRvb2xzIH0gZnJvbSAnLi9kZXZ0b29scyc7XG5leHBvcnQge1xuICBTdG9yZURldnRvb2xzQ29uZmlnLFxuICBTdG9yZURldnRvb2xzT3B0aW9ucyxcbiAgRGV2VG9vbHNGZWF0dXJlT3B0aW9ucyxcbiAgSU5JVElBTF9PUFRJT05TLFxufSBmcm9tICcuL2NvbmZpZyc7XG4iXX0=

package/esm2015/src/instrument.js

@@ -0,0 +1,67 @@
+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';
+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,
+                },
+            ],
+        };
+    }
+}
+/** @type {!Array<{type: !Function, args: (undefined|!Array<?>)}>} */
+StoreDevtoolsModule.decorators = [
+    { type: NgModule, args: [{},] }
+];
+//# sourceMappingURL=data:application/json;base64,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