@ngrx/store-devtools 11.0.0-rc.0 → 11.1.1

package/fesm2015/ngrx-store-devtools.js

@@ -3,84 +3,18 @@ import { ActionsSubject, UPDATE, INIT, ReducerObservable, ScannedActionsSubject,
 import { EMPTY, Observable, of, merge, queueScheduler, ReplaySubject } from 'rxjs';
 import { share, filter, map, concatMap, timeout, debounceTime, catchError, take, takeUntil, switchMap, skip, observeOn, withLatestFrom, scan } from 'rxjs/operators';
 
-/**
- * @fileoverview added by tsickle
- * Generated from: src/config.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @record
- */
-function DevToolsFeatureOptions() { }
-if (false) {
-    /** @type {?|undefined} */
-    DevToolsFeatureOptions.prototype.pause;
-    /** @type {?|undefined} */
-    DevToolsFeatureOptions.prototype.lock;
-    /** @type {?|undefined} */
-    DevToolsFeatureOptions.prototype.persist;
-    /** @type {?|undefined} */
-    DevToolsFeatureOptions.prototype.export;
-    /** @type {?|undefined} */
-    DevToolsFeatureOptions.prototype.import;
-    /** @type {?|undefined} */
-    DevToolsFeatureOptions.prototype.jump;
-    /** @type {?|undefined} */
-    DevToolsFeatureOptions.prototype.skip;
-    /** @type {?|undefined} */
-    DevToolsFeatureOptions.prototype.reorder;
-    /** @type {?|undefined} */
-    DevToolsFeatureOptions.prototype.dispatch;
-    /** @type {?|undefined} */
-    DevToolsFeatureOptions.prototype.test;
-}
 class StoreDevtoolsConfig {
     constructor() {
         this.maxAge = false;
     }
 }
-if (false) {
-    /** @type {?} */
-    StoreDevtoolsConfig.prototype.maxAge;
-    /** @type {?} */
-    StoreDevtoolsConfig.prototype.monitor;
-    /** @type {?} */
-    StoreDevtoolsConfig.prototype.actionSanitizer;
-    /** @type {?} */
-    StoreDevtoolsConfig.prototype.stateSanitizer;
-    /** @type {?} */
-    StoreDevtoolsConfig.prototype.name;
-    /** @type {?} */
-    StoreDevtoolsConfig.prototype.serialize;
-    /** @type {?} */
-    StoreDevtoolsConfig.prototype.logOnly;
-    /** @type {?} */
-    StoreDevtoolsConfig.prototype.features;
-    /** @type {?} */
-    StoreDevtoolsConfig.prototype.actionsBlocklist;
-    /** @type {?} */
-    StoreDevtoolsConfig.prototype.actionsSafelist;
-    /** @type {?} */
-    StoreDevtoolsConfig.prototype.predicate;
-}
-/** @type {?} */
 const STORE_DEVTOOLS_CONFIG = new InjectionToken('@ngrx/store-devtools Options');
-/** @type {?} */
 const INITIAL_OPTIONS = new InjectionToken('@ngrx/store-devtools Initial Config');
-/**
- * @return {?}
- */
 function noMonitor() {
     return null;
 }
-/** @type {?} */
 const DEFAULT_NAME = 'NgRx Store DevTools';
-/**
- * @param {?} _options
- * @return {?}
- */
 function createConfig(_options) {
-    /** @type {?} */
     const DEFAULT_OPTIONS = {
         maxAge: false,
         monitor: noMonitor,
@@ -93,35 +27,22 @@ function createConfig(_options) {
         // options like "lock" which might otherwise not show up.
         features: {
             pause: true,
-            // start/pause recording of dispatched actions
             lock: true,
-            // lock/unlock dispatching actions and side effects
             persist: true,
-            // persist states on page reloading
             export: true,
-            // export history of actions in a file
             import: 'custom',
-            // import history of actions from a file
             jump: true,
-            // jump back and forth (time travelling)
             skip: true,
-            // skip (cancel) actions
             reorder: true,
-            // drag and drop actions in the history list
             dispatch: true,
-            // dispatch custom actions or action creators
             test: true,
         },
     };
-    /** @type {?} */
     let options = typeof _options === 'function' ? _options() : _options;
-    /** @type {?} */
     const logOnly = options.logOnly
         ? { pause: true, export: true, test: true }
         : false;
-    /** @type {?} */
     const features = options.features || logOnly || DEFAULT_OPTIONS.features;
-    /** @type {?} */
     const config = Object.assign({}, DEFAULT_OPTIONS, { features }, options);
     if (config.maxAge && config.maxAge < 2) {
         throw new Error(`Devtools 'maxAge' cannot be less than 2, got ${config.maxAge}`);
@@ -129,42 +50,20 @@ function createConfig(_options) {
     return config;
 }
 
-/**
- * @fileoverview added by tsickle
- * Generated from: src/actions.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/** @type {?} */
 const PERFORM_ACTION = 'PERFORM_ACTION';
-/** @type {?} */
 const REFRESH = 'REFRESH';
-/** @type {?} */
 const RESET = 'RESET';
-/** @type {?} */
 const ROLLBACK = 'ROLLBACK';
-/** @type {?} */
 const COMMIT = 'COMMIT';
-/** @type {?} */
 const SWEEP = 'SWEEP';
-/** @type {?} */
 const TOGGLE_ACTION = 'TOGGLE_ACTION';
-/** @type {?} */
 const SET_ACTIONS_ACTIVE = 'SET_ACTIONS_ACTIVE';
-/** @type {?} */
 const JUMP_TO_STATE = 'JUMP_TO_STATE';
-/** @type {?} */
 const JUMP_TO_ACTION = 'JUMP_TO_ACTION';
-/** @type {?} */
 const IMPORT_STATE = 'IMPORT_STATE';
-/** @type {?} */
 const LOCK_CHANGES = 'LOCK_CHANGES';
-/** @type {?} */
 const PAUSE_RECORDING = 'PAUSE_RECORDING';
 class PerformAction {
-    /**
-     * @param {?} action
-     * @param {?} timestamp
-     */
     constructor(action, timestamp) {
         this.action = action;
         this.timestamp = timestamp;
@@ -175,98 +74,41 @@ class PerformAction {
         }
     }
 }
-if (false) {
-    /** @type {?} */
-    PerformAction.prototype.type;
-    /** @type {?} */
-    PerformAction.prototype.action;
-    /** @type {?} */
-    PerformAction.prototype.timestamp;
-}
 class Refresh {
     constructor() {
         this.type = REFRESH;
     }
 }
-if (false) {
-    /** @type {?} */
-    Refresh.prototype.type;
-}
 class Reset {
-    /**
-     * @param {?} timestamp
-     */
     constructor(timestamp) {
         this.timestamp = timestamp;
         this.type = RESET;
     }
 }
-if (false) {
-    /** @type {?} */
-    Reset.prototype.type;
-    /** @type {?} */
-    Reset.prototype.timestamp;
-}
 class Rollback {
-    /**
-     * @param {?} timestamp
-     */
     constructor(timestamp) {
         this.timestamp = timestamp;
         this.type = ROLLBACK;
     }
 }
-if (false) {
-    /** @type {?} */
-    Rollback.prototype.type;
-    /** @type {?} */
-    Rollback.prototype.timestamp;
-}
 class Commit {
-    /**
-     * @param {?} timestamp
-     */
     constructor(timestamp) {
         this.timestamp = timestamp;
         this.type = COMMIT;
     }
 }
-if (false) {
-    /** @type {?} */
-    Commit.prototype.type;
-    /** @type {?} */
-    Commit.prototype.timestamp;
-}
 class Sweep {
     constructor() {
         this.type = SWEEP;
     }
 }
-if (false) {
-    /** @type {?} */
-    Sweep.prototype.type;
-}
 class ToggleAction {
-    /**
-     * @param {?} id
-     */
     constructor(id) {
         this.id = id;
         this.type = TOGGLE_ACTION;
     }
 }
-if (false) {
-    /** @type {?} */
-    ToggleAction.prototype.type;
-    /** @type {?} */
-    ToggleAction.prototype.id;
-}
 class SetActionsActive {
-    /**
-     * @param {?} start
-     * @param {?} end
-     * @param {?=} active
-     */
     constructor(start, end, active = true) {
         this.start = start;
         this.end = end;
@@ -274,124 +116,48 @@ class SetActionsActive {
         this.type = SET_ACTIONS_ACTIVE;
     }
 }
-if (false) {
-    /** @type {?} */
-    SetActionsActive.prototype.type;
-    /** @type {?} */
-    SetActionsActive.prototype.start;
-    /** @type {?} */
-    SetActionsActive.prototype.end;
-    /** @type {?} */
-    SetActionsActive.prototype.active;
-}
 class JumpToState {
-    /**
-     * @param {?} index
-     */
     constructor(index) {
         this.index = index;
         this.type = JUMP_TO_STATE;
     }
 }
-if (false) {
-    /** @type {?} */
-    JumpToState.prototype.type;
-    /** @type {?} */
-    JumpToState.prototype.index;
-}
 class JumpToAction {
-    /**
-     * @param {?} actionId
-     */
     constructor(actionId) {
         this.actionId = actionId;
         this.type = JUMP_TO_ACTION;
     }
 }
-if (false) {
-    /** @type {?} */
-    JumpToAction.prototype.type;
-    /** @type {?} */
-    JumpToAction.prototype.actionId;
-}
 class ImportState {
-    /**
-     * @param {?} nextLiftedState
-     */
     constructor(nextLiftedState) {
         this.nextLiftedState = nextLiftedState;
         this.type = IMPORT_STATE;
     }
 }
-if (false) {
-    /** @type {?} */
-    ImportState.prototype.type;
-    /** @type {?} */
-    ImportState.prototype.nextLiftedState;
-}
 class LockChanges {
-    /**
-     * @param {?} status
-     */
     constructor(status) {
         this.status = status;
         this.type = LOCK_CHANGES;
     }
 }
-if (false) {
-    /** @type {?} */
-    LockChanges.prototype.type;
-    /** @type {?} */
-    LockChanges.prototype.status;
-}
 class PauseRecording {
-    /**
-     * @param {?} status
-     */
     constructor(status) {
         this.status = status;
         this.type = PAUSE_RECORDING;
     }
 }
-if (false) {
-    /** @type {?} */
-    PauseRecording.prototype.type;
-    /** @type {?} */
-    PauseRecording.prototype.status;
-}
 
-/**
- * @fileoverview added by tsickle
- * Generated from: src/devtools-dispatcher.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 class DevtoolsDispatcher extends ActionsSubject {
 }
 DevtoolsDispatcher.decorators = [
     { type: Injectable }
 ];
 
-/**
- * @fileoverview added by tsickle
- * Generated from: src/utils.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @param {?} first
- * @param {?} second
- * @return {?}
- */
 function difference(first, second) {
-    return first.filter((/**
-     * @param {?} item
-     * @return {?}
-     */
-    (item) => second.indexOf(item) < 0));
+    return first.filter((item) => second.indexOf(item) < 0);
 }
 /**
  * Provides an app's view into the state of the lifted store.
- * @param {?} liftedState
- * @return {?}
  */
 function unliftState(liftedState) {
     const { computedStates, currentStateIndex } = liftedState;
@@ -406,107 +172,60 @@ function unliftState(liftedState) {
     const { state } = computedStates[currentStateIndex];
     return state;
 }
-/**
- * @param {?} liftedState
- * @return {?}
- */
 function unliftAction(liftedState) {
     return liftedState.actionsById[liftedState.nextActionId - 1];
 }
 /**
  * Lifts an app's action into an action on the lifted store.
- * @param {?} action
- * @return {?}
  */
 function liftAction(action) {
     return new PerformAction(action, +Date.now());
 }
 /**
  * Sanitizes given actions with given function.
- * @param {?} actionSanitizer
- * @param {?} actions
- * @return {?}
  */
 function sanitizeActions(actionSanitizer, actions) {
-    return Object.keys(actions).reduce((/**
-     * @param {?} sanitizedActions
-     * @param {?} actionIdx
-     * @return {?}
-     */
-    (sanitizedActions, actionIdx) => {
-        /** @type {?} */
+    return Object.keys(actions).reduce((sanitizedActions, actionIdx) => {
         const idx = Number(actionIdx);
         sanitizedActions[idx] = sanitizeAction(actionSanitizer, actions[idx], idx);
         return sanitizedActions;
-    }), (/** @type {?} */ ({})));
+    }, {});
 }
 /**
  * Sanitizes given action with given function.
- * @param {?} actionSanitizer
- * @param {?} action
- * @param {?} actionIdx
- * @return {?}
  */
 function sanitizeAction(actionSanitizer, action, actionIdx) {
     return Object.assign(Object.assign({}, action), { action: actionSanitizer(action.action, actionIdx) });
 }
 /**
  * Sanitizes given states with given function.
- * @param {?} stateSanitizer
- * @param {?} states
- * @return {?}
  */
 function sanitizeStates(stateSanitizer, states) {
-    return states.map((/**
-     * @param {?} computedState
-     * @param {?} idx
-     * @return {?}
-     */
-    (computedState, idx) => ({
+    return states.map((computedState, idx) => ({
         state: sanitizeState(stateSanitizer, computedState.state, idx),
         error: computedState.error,
-    })));
+    }));
 }
 /**
  * Sanitizes given state with given function.
- * @param {?} stateSanitizer
- * @param {?} state
- * @param {?} stateIdx
- * @return {?}
  */
 function sanitizeState(stateSanitizer, state, stateIdx) {
     return stateSanitizer(state, stateIdx);
 }
 /**
  * Read the config and tell if actions should be filtered
- * @param {?} config
- * @return {?}
  */
 function shouldFilterActions(config) {
     return config.predicate || config.actionsSafelist || config.actionsBlocklist;
 }
 /**
  * Return a full filtered lifted state
- * @param {?} liftedState
- * @param {?=} predicate
- * @param {?=} safelist
- * @param {?=} blocklist
- * @return {?}
  */
 function filterLiftedState(liftedState, predicate, safelist, blocklist) {
-    /** @type {?} */
     const filteredStagedActionIds = [];
-    /** @type {?} */
     const filteredActionsById = {};
-    /** @type {?} */
     const filteredComputedStates = [];
-    liftedState.stagedActionIds.forEach((/**
-     * @param {?} id
-     * @param {?} idx
-     * @return {?}
-     */
-    (id, idx) => {
-        /** @type {?} */
+    liftedState.stagedActionIds.forEach((id, idx) => {
         const liftedAction = liftedState.actionsById[id];
         if (!liftedAction)
             return;
@@ -517,141 +236,42 @@ function filterLiftedState(liftedState, predicate, safelist, blocklist) {
         filteredActionsById[id] = liftedAction;
         filteredStagedActionIds.push(id);
         filteredComputedStates.push(liftedState.computedStates[idx]);
-    }));
+    });
     return Object.assign(Object.assign({}, liftedState), { stagedActionIds: filteredStagedActionIds, actionsById: filteredActionsById, computedStates: filteredComputedStates });
 }
 /**
  * Return true is the action should be ignored
- * @param {?} state
- * @param {?} action
- * @param {?=} predicate
- * @param {?=} safelist
- * @param {?=} blockedlist
- * @return {?}
  */
 function isActionFiltered(state, action, predicate, safelist, blockedlist) {
-    /** @type {?} */
     const predicateMatch = predicate && !predicate(state, action.action);
-    /** @type {?} */
     const safelistMatch = safelist &&
-        !action.action.type.match(safelist.map((/**
-         * @param {?} s
-         * @return {?}
-         */
-        (s) => escapeRegExp(s))).join('|'));
-    /** @type {?} */
+        !action.action.type.match(safelist.map((s) => escapeRegExp(s)).join('|'));
     const blocklistMatch = blockedlist &&
-        action.action.type.match(blockedlist.map((/**
-         * @param {?} s
-         * @return {?}
-         */
-        (s) => escapeRegExp(s))).join('|'));
+        action.action.type.match(blockedlist.map((s) => escapeRegExp(s)).join('|'));
     return predicateMatch || safelistMatch || blocklistMatch;
 }
 /**
  * Return string with escaped RegExp special characters
  * https://stackoverflow.com/a/6969486/1337347
- * @param {?} s
- * @return {?}
  */
 function escapeRegExp(s) {
     return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
-/**
- * @fileoverview added by tsickle
- * Generated from: src/extension.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/** @type {?} */
 const ExtensionActionTypes = {
     START: 'START',
     DISPATCH: 'DISPATCH',
     STOP: 'STOP',
     ACTION: 'ACTION',
 };
-/** @type {?} */
 const REDUX_DEVTOOLS_EXTENSION = new InjectionToken('@ngrx/store-devtools Redux Devtools Extension');
-/**
- * @record
- */
-function ReduxDevtoolsExtensionConnection() { }
-if (false) {
-    /**
-     * @param {?} listener
-     * @return {?}
-     */
-    ReduxDevtoolsExtensionConnection.prototype.subscribe = function (listener) { };
-    /**
-     * @return {?}
-     */
-    ReduxDevtoolsExtensionConnection.prototype.unsubscribe = function () { };
-    /**
-     * @param {?} action
-     * @param {?} state
-     * @return {?}
-     */
-    ReduxDevtoolsExtensionConnection.prototype.send = function (action, state) { };
-    /**
-     * @param {?=} state
-     * @return {?}
-     */
-    ReduxDevtoolsExtensionConnection.prototype.init = function (state) { };
-    /**
-     * @param {?} anyErr
-     * @return {?}
-     */
-    ReduxDevtoolsExtensionConnection.prototype.error = function (anyErr) { };
-}
-/**
- * @record
- */
-function ReduxDevtoolsExtensionConfig() { }
-if (false) {
-    /** @type {?|undefined} */
-    ReduxDevtoolsExtensionConfig.prototype.features;
-    /** @type {?} */
-    ReduxDevtoolsExtensionConfig.prototype.name;
-    /** @type {?|undefined} */
-    ReduxDevtoolsExtensionConfig.prototype.maxAge;
-    /** @type {?|undefined} */
-    ReduxDevtoolsExtensionConfig.prototype.serialize;
-}
-/**
- * @record
- */
-function ReduxDevtoolsExtension() { }
-if (false) {
-    /**
-     * @param {?} options
-     * @return {?}
-     */
-    ReduxDevtoolsExtension.prototype.connect = function (options) { };
-    /**
-     * @param {?} action
-     * @param {?} state
-     * @param {?} options
-     * @return {?}
-     */
-    ReduxDevtoolsExtension.prototype.send = function (action, state, options) { };
-}
 class DevtoolsExtension {
-    /**
-     * @param {?} devtoolsExtension
-     * @param {?} config
-     * @param {?} dispatcher
-     */
     constructor(devtoolsExtension, config, dispatcher) {
         this.config = config;
         this.dispatcher = dispatcher;
         this.devtoolsExtension = devtoolsExtension;
         this.createActionStreams();
     }
-    /**
-     * @param {?} action
-     * @param {?} state
-     * @return {?}
-     */
     notify(action, state) {
         if (!this.devtoolsExtension) {
             return;
@@ -673,101 +293,50 @@ class DevtoolsExtension {
             if (state.isLocked || state.isPaused) {
                 return;
             }
-            /** @type {?} */
             const currentState = unliftState(state);
             if (shouldFilterActions(this.config) &&
                 isActionFiltered(currentState, action, this.config.predicate, this.config.actionsSafelist, this.config.actionsBlocklist)) {
                 return;
             }
-            /** @type {?} */
             const sanitizedState = this.config.stateSanitizer
                 ? sanitizeState(this.config.stateSanitizer, currentState, state.currentStateIndex)
                 : currentState;
-            /** @type {?} */
             const sanitizedAction = this.config.actionSanitizer
                 ? sanitizeAction(this.config.actionSanitizer, action, state.nextActionId)
                 : action;
-            this.sendToReduxDevtools((/**
-             * @return {?}
-             */
-            () => this.extensionConnection.send(sanitizedAction, sanitizedState)));
+            this.sendToReduxDevtools(() => this.extensionConnection.send(sanitizedAction, sanitizedState));
         }
         else {
             // Requires full state update
-            /** @type {?} */
             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((/**
-             * @return {?}
-             */
-            () => this.devtoolsExtension.send(null, sanitizedLiftedState, this.getExtensionConfig(this.config))));
+            this.sendToReduxDevtools(() => this.devtoolsExtension.send(null, sanitizedLiftedState, this.getExtensionConfig(this.config)));
         }
     }
-    /**
-     * @private
-     * @return {?}
-     */
     createChangesObservable() {
         if (!this.devtoolsExtension) {
             return EMPTY;
         }
-        return new Observable((/**
-         * @param {?} subscriber
-         * @return {?}
-         */
-        (subscriber) => {
-            /** @type {?} */
+        return new Observable((subscriber) => {
             const connection = this.devtoolsExtension.connect(this.getExtensionConfig(this.config));
             this.extensionConnection = connection;
             connection.init();
-            connection.subscribe((/**
-             * @param {?} change
-             * @return {?}
-             */
-            (change) => subscriber.next(change)));
+            connection.subscribe((change) => subscriber.next(change));
             return connection.unsubscribe;
-        }));
+        });
     }
-    /**
-     * @private
-     * @return {?}
-     */
     createActionStreams() {
         // Listens to all changes
-        /** @type {?} */
         const changes$ = this.createChangesObservable().pipe(share());
         // Listen for the start action
-        /** @type {?} */
-        const start$ = changes$.pipe(filter((/**
-         * @param {?} change
-         * @return {?}
-         */
-        (change) => change.type === ExtensionActionTypes.START)));
+        const start$ = changes$.pipe(filter((change) => change.type === ExtensionActionTypes.START));
         // Listen for the stop action
-        /** @type {?} */
-        const stop$ = changes$.pipe(filter((/**
-         * @param {?} change
-         * @return {?}
-         */
-        (change) => change.type === ExtensionActionTypes.STOP)));
+        const stop$ = changes$.pipe(filter((change) => change.type === ExtensionActionTypes.STOP));
         // Listen for lifted actions
-        /** @type {?} */
-        const liftedActions$ = changes$.pipe(filter((/**
-         * @param {?} change
-         * @return {?}
-         */
-        (change) => change.type === ExtensionActionTypes.DISPATCH)), map((/**
-         * @param {?} change
-         * @return {?}
-         */
-        (change) => this.unwrapAction(change.payload))), concatMap((/**
-         * @param {?} action
-         * @return {?}
-         */
-        (action) => {
+        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
@@ -777,63 +346,25 @@ class DevtoolsExtension {
                 // 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((/**
-                 * @param {?} action
-                 * @return {?}
-                 */
-                (action) => action.type === UPDATE)), timeout(1000), debounceTime(1000), map((/**
-                 * @return {?}
-                 */
-                () => action)), catchError((/**
-                 * @return {?}
-                 */
-                () => of(action))), take(1));
+                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
-        /** @type {?} */
-        const actions$ = changes$.pipe(filter((/**
-         * @param {?} change
-         * @return {?}
-         */
-        (change) => change.type === ExtensionActionTypes.ACTION)), map((/**
-         * @param {?} change
-         * @return {?}
-         */
-        (change) => this.unwrapAction(change.payload))));
-        /** @type {?} */
+        const actions$ = changes$.pipe(filter((change) => change.type === ExtensionActionTypes.ACTION), map((change) => this.unwrapAction(change.payload)));
         const actionsUntilStop$ = actions$.pipe(takeUntil(stop$));
-        /** @type {?} */
         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((/**
-         * @return {?}
-         */
-        () => actionsUntilStop$)));
-        this.liftedActions$ = this.start$.pipe(switchMap((/**
-         * @return {?}
-         */
-        () => liftedUntilStop$)));
+        this.actions$ = this.start$.pipe(switchMap(() => actionsUntilStop$));
+        this.liftedActions$ = this.start$.pipe(switchMap(() => liftedUntilStop$));
     }
-    /**
-     * @private
-     * @param {?} action
-     * @return {?}
-     */
     unwrapAction(action) {
         return typeof action === 'string' ? eval(`(${action})`) : action;
     }
-    /**
-     * @private
-     * @param {?} config
-     * @return {?}
-     */
     getExtensionConfig(config) {
-        /** @type {?} */
         const extensionOptions = {
             name: config.name,
             features: config.features,
@@ -844,11 +375,6 @@ class DevtoolsExtension {
         }
         return extensionOptions;
     }
-    /**
-     * @private
-     * @param {?} send
-     * @return {?}
-     */
     sendToReduxDevtools(send) {
         try {
             send();
@@ -867,104 +393,12 @@ DevtoolsExtension.ctorParameters = () => [
     { type: StoreDevtoolsConfig, decorators: [{ type: Inject, args: [STORE_DEVTOOLS_CONFIG,] }] },
     { type: DevtoolsDispatcher }
 ];
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    DevtoolsExtension.prototype.devtoolsExtension;
-    /**
-     * @type {?}
-     * @private
-     */
-    DevtoolsExtension.prototype.extensionConnection;
-    /** @type {?} */
-    DevtoolsExtension.prototype.liftedActions$;
-    /** @type {?} */
-    DevtoolsExtension.prototype.actions$;
-    /** @type {?} */
-    DevtoolsExtension.prototype.start$;
-    /**
-     * @type {?}
-     * @private
-     */
-    DevtoolsExtension.prototype.config;
-    /**
-     * @type {?}
-     * @private
-     */
-    DevtoolsExtension.prototype.dispatcher;
-}
 
-/**
- * @fileoverview added by tsickle
- * Generated from: src/reducer.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/** @type {?} */
 const INIT_ACTION = { type: INIT };
-/** @type {?} */
-const RECOMPUTE = (/** @type {?} */ ('@ngrx/store-devtools/recompute'));
-/** @type {?} */
+const RECOMPUTE = '@ngrx/store-devtools/recompute';
 const RECOMPUTE_ACTION = { type: RECOMPUTE };
-/**
- * @record
- */
-function ComputedState() { }
-if (false) {
-    /** @type {?} */
-    ComputedState.prototype.state;
-    /** @type {?} */
-    ComputedState.prototype.error;
-}
-/**
- * @record
- */
-function LiftedAction() { }
-if (false) {
-    /** @type {?} */
-    LiftedAction.prototype.type;
-    /** @type {?} */
-    LiftedAction.prototype.action;
-}
-/**
- * @record
- */
-function LiftedActions() { }
-/**
- * @record
- */
-function LiftedState() { }
-if (false) {
-    /** @type {?} */
-    LiftedState.prototype.monitorState;
-    /** @type {?} */
-    LiftedState.prototype.nextActionId;
-    /** @type {?} */
-    LiftedState.prototype.actionsById;
-    /** @type {?} */
-    LiftedState.prototype.stagedActionIds;
-    /** @type {?} */
-    LiftedState.prototype.skippedActionIds;
-    /** @type {?} */
-    LiftedState.prototype.committedState;
-    /** @type {?} */
-    LiftedState.prototype.currentStateIndex;
-    /** @type {?} */
-    LiftedState.prototype.computedStates;
-    /** @type {?} */
-    LiftedState.prototype.isLocked;
-    /** @type {?} */
-    LiftedState.prototype.isPaused;
-}
 /**
  * Computes the next entry in the log by applying an action.
- * @param {?} reducer
- * @param {?} action
- * @param {?} state
- * @param {?} error
- * @param {?} errorHandler
- * @return {?}
  */
 function computeNextEntry(reducer, action, state, error, errorHandler) {
     if (error) {
@@ -973,9 +407,7 @@ function computeNextEntry(reducer, action, state, error, errorHandler) {
             error: 'Interrupted by an error up the chain',
         };
     }
-    /** @type {?} */
     let nextState = state;
-    /** @type {?} */
     let nextError;
     try {
         nextState = reducer(state, action);
@@ -991,16 +423,6 @@ function computeNextEntry(reducer, action, state, error, errorHandler) {
 }
 /**
  * Runs the reducer on invalidated actions to get a fresh computation log.
- * @param {?} computedStates
- * @param {?} minInvalidatedStateIndex
- * @param {?} reducer
- * @param {?} committedState
- * @param {?} actionsById
- * @param {?} stagedActionIds
- * @param {?} skippedActionIds
- * @param {?} errorHandler
- * @param {?} isPaused
- * @return {?}
  */
 function recomputeStates(computedStates, minInvalidatedStateIndex, reducer, committedState, actionsById, stagedActionIds, skippedActionIds, errorHandler, isPaused) {
     // Optimization: exit early and return the same reference
@@ -1009,26 +431,17 @@ function recomputeStates(computedStates, minInvalidatedStateIndex, reducer, comm
         computedStates.length === stagedActionIds.length) {
         return computedStates;
     }
-    /** @type {?} */
     const nextComputedStates = computedStates.slice(0, minInvalidatedStateIndex);
     // If the recording is paused, recompute all states up until the pause state,
     // else recompute all states.
-    /** @type {?} */
     const lastIncludedActionId = stagedActionIds.length - (isPaused ? 1 : 0);
     for (let i = minInvalidatedStateIndex; i < lastIncludedActionId; i++) {
-        /** @type {?} */
         const actionId = stagedActionIds[i];
-        /** @type {?} */
         const action = actionsById[actionId].action;
-        /** @type {?} */
         const previousEntry = nextComputedStates[i - 1];
-        /** @type {?} */
         const previousState = previousEntry ? previousEntry.state : committedState;
-        /** @type {?} */
         const previousError = previousEntry ? previousEntry.error : undefined;
-        /** @type {?} */
         const shouldSkip = skippedActionIds.indexOf(actionId) > -1;
-        /** @type {?} */
         const entry = shouldSkip
             ? previousEntry
             : computeNextEntry(reducer, action, previousState, previousError, errorHandler);
@@ -1041,11 +454,6 @@ function recomputeStates(computedStates, minInvalidatedStateIndex, reducer, comm
     }
     return nextComputedStates;
 }
-/**
- * @param {?=} initialCommittedState
- * @param {?=} monitorReducer
- * @return {?}
- */
 function liftInitialState(initialCommittedState, monitorReducer) {
     return {
         monitorState: monitorReducer(undefined, {}),
@@ -1062,41 +470,20 @@ function liftInitialState(initialCommittedState, monitorReducer) {
 }
 /**
  * Creates a history state reducer from an app's reducer.
- * @param {?} initialCommittedState
- * @param {?} initialLiftedState
- * @param {?} errorHandler
- * @param {?=} monitorReducer
- * @param {?=} options
- * @return {?}
  */
 function liftReducerWith(initialCommittedState, initialLiftedState, errorHandler, monitorReducer, options = {}) {
     /**
      * Manages how the history actions modify the history state.
      */
-    return (/**
-     * @param {?} reducer
-     * @return {?}
-     */
-    (reducer) => (/**
-     * @param {?} liftedState
-     * @param {?} liftedAction
-     * @return {?}
-     */
-    (liftedState, liftedAction) => {
+    return (reducer) => (liftedState, liftedAction) => {
         let { monitorState, actionsById, nextActionId, stagedActionIds, skippedActionIds, committedState, currentStateIndex, computedStates, isLocked, isPaused, } = liftedState || initialLiftedState;
         if (!liftedState) {
             // Prevent mutating initialLiftedState
             actionsById = Object.create(actionsById);
         }
-        /**
-         * @param {?} n
-         * @return {?}
-         */
         function commitExcessActions(n) {
             // Auto-commits n-number of excess actions.
-            /** @type {?} */
             let excess = n;
-            /** @type {?} */
             let idsToDelete = stagedActionIds.slice(1, excess + 1);
             for (let i = 0; i < idsToDelete.length; i++) {
                 if (computedStates[i + 1].error) {
@@ -1109,20 +496,13 @@ function liftReducerWith(initialCommittedState, initialLiftedState, errorHandler
                     delete actionsById[idsToDelete[i]];
                 }
             }
-            skippedActionIds = skippedActionIds.filter((/**
-             * @param {?} id
-             * @return {?}
-             */
-            (id) => idsToDelete.indexOf(id) === -1));
+            skippedActionIds = skippedActionIds.filter((id) => idsToDelete.indexOf(id) === -1);
             stagedActionIds = [0, ...stagedActionIds.slice(excess + 1)];
             committedState = computedStates[excess].state;
             computedStates = computedStates.slice(excess);
             currentStateIndex =
                 currentStateIndex > excess ? currentStateIndex - excess : 0;
         }
-        /**
-         * @return {?}
-         */
         function commitChanges() {
             // Consider the last committed state the new starting point.
             // Squash any staged actions into a single committed state.
@@ -1137,7 +517,6 @@ function liftReducerWith(initialCommittedState, initialLiftedState, errorHandler
         // By default, aggressively recompute every state whatever happens.
         // This has O(n) performance, so we'll override this to a sensible
         // value whenever we feel like we don't have to recompute the states.
-        /** @type {?} */
         let minInvalidatedStateIndex = 0;
         switch (liftedAction.type) {
             case LOCK_CHANGES: {
@@ -1198,17 +577,12 @@ function liftReducerWith(initialCommittedState, initialLiftedState, errorHandler
                 // Toggle whether an action with given ID is skipped.
                 // Being skipped means it is a no-op during the computation.
                 const { id: actionId } = liftedAction;
-                /** @type {?} */
                 const index = skippedActionIds.indexOf(actionId);
                 if (index === -1) {
                     skippedActionIds = [actionId, ...skippedActionIds];
                 }
                 else {
-                    skippedActionIds = skippedActionIds.filter((/**
-                     * @param {?} id
-                     * @return {?}
-                     */
-                    (id) => id !== actionId));
+                    skippedActionIds = skippedActionIds.filter((id) => id !== actionId);
                 }
                 // Optimization: we know history before this action hasn't changed
                 minInvalidatedStateIndex = stagedActionIds.indexOf(actionId);
@@ -1218,7 +592,6 @@ function liftReducerWith(initialCommittedState, initialLiftedState, errorHandler
                 // Toggle whether an action with given ID is skipped.
                 // Being skipped means it is a no-op during the computation.
                 const { start, end, active } = liftedAction;
-                /** @type {?} */
                 const actionIds = [];
                 for (let i = start; i < end; i++)
                     actionIds.push(i);
@@ -1243,7 +616,6 @@ function liftReducerWith(initialCommittedState, initialLiftedState, errorHandler
             case JUMP_TO_ACTION: {
                 // Jumps to a corresponding state to a specific action.
                 // Useful when filtering actions.
-                /** @type {?} */
                 const index = stagedActionIds.indexOf(liftedAction.actionId);
                 if (index !== -1)
                     currentStateIndex = index;
@@ -1269,7 +641,6 @@ function liftReducerWith(initialCommittedState, initialLiftedState, errorHandler
                     // (corresponds to the pause action) and keep everything else as is.
                     // This way, the app gets the new current state while the devtools
                     // do not record another action.
-                    /** @type {?} */
                     const lastState = computedStates[computedStates.length - 1];
                     computedStates = [
                         ...computedStates.slice(0, -1),
@@ -1285,7 +656,6 @@ function liftReducerWith(initialCommittedState, initialLiftedState, errorHandler
                 if (currentStateIndex === stagedActionIds.length - 1) {
                     currentStateIndex++;
                 }
-                /** @type {?} */
                 const actionId = nextActionId++;
                 // Mutation! This is the hottest path, and we optimize on purpose.
                 // It is safe because we set a new key in a cache dictionary.
@@ -1324,12 +694,7 @@ function liftReducerWith(initialCommittedState, initialLiftedState, errorHandler
                 break;
             }
             case UPDATE: {
-                /** @type {?} */
-                const stateHasErrors = computedStates.filter((/**
-                 * @param {?} state
-                 * @return {?}
-                 */
-                (state) => state.error)).length > 0;
+                const stateHasErrors = computedStates.filter((state) => state.error).length > 0;
                 if (stateHasErrors) {
                     // Recompute all states
                     minInvalidatedStateIndex = 0;
@@ -1349,7 +714,6 @@ function liftReducerWith(initialCommittedState, initialLiftedState, errorHandler
                             currentStateIndex++;
                         }
                         // Add a new action to only recompute state
-                        /** @type {?} */
                         const actionId = nextActionId++;
                         actionsById[actionId] = new PerformAction(liftedAction, +Date.now());
                         stagedActionIds = [...stagedActionIds, actionId];
@@ -1357,11 +721,7 @@ function liftReducerWith(initialCommittedState, initialLiftedState, errorHandler
                         computedStates = recomputeStates(computedStates, minInvalidatedStateIndex, reducer, committedState, actionsById, stagedActionIds, skippedActionIds, errorHandler, isPaused);
                     }
                     // Recompute state history with latest reducer and update action
-                    computedStates = computedStates.map((/**
-                     * @param {?} cmp
-                     * @return {?}
-                     */
-                    (cmp) => (Object.assign(Object.assign({}, cmp), { state: reducer(cmp.state, RECOMPUTE_ACTION) }))));
+                    computedStates = computedStates.map((cmp) => (Object.assign(Object.assign({}, cmp), { state: reducer(cmp.state, RECOMPUTE_ACTION) })));
                     currentStateIndex = stagedActionIds.length - 1;
                     if (options.maxAge && stagedActionIds.length > options.maxAge) {
                         commitExcessActions(stagedActionIds.length - options.maxAge);
@@ -1392,45 +752,18 @@ function liftReducerWith(initialCommittedState, initialLiftedState, errorHandler
             isLocked,
             isPaused,
         };
-    }));
+    };
 }
 
-/**
- * @fileoverview added by tsickle
- * Generated from: src/devtools.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 class StoreDevtools {
-    /**
-     * @param {?} dispatcher
-     * @param {?} actions$
-     * @param {?} reducers$
-     * @param {?} extension
-     * @param {?} scannedActions
-     * @param {?} errorHandler
-     * @param {?} initialState
-     * @param {?} config
-     */
     constructor(dispatcher, actions$, reducers$, extension, scannedActions, errorHandler, initialState, config) {
-        /** @type {?} */
         const liftedInitialState = liftInitialState(initialState, config.monitor);
-        /** @type {?} */
         const liftReducer = liftReducerWith(initialState, liftedInitialState, errorHandler, config.monitor, config);
-        /** @type {?} */
         const liftedAction$ = merge(merge(actions$.asObservable().pipe(skip(1)), extension.actions$).pipe(map(liftAction)), dispatcher, extension.liftedActions$).pipe(observeOn(queueScheduler));
-        /** @type {?} */
         const liftedReducer$ = reducers$.pipe(map(liftReducer));
-        /** @type {?} */
         const liftedStateSubject = new ReplaySubject(1);
-        /** @type {?} */
         const liftedStateSubscription = liftedAction$
-            .pipe(withLatestFrom(liftedReducer$), scan((/**
-         * @param {?} __0
-         * @param {?} __1
-         * @return {?}
-         */
-        ({ state: liftedState }, [action, reducer]) => {
-            /** @type {?} */
+            .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
@@ -1440,29 +773,18 @@ class StoreDevtools {
             // Extension should be sent the sanitized lifted state
             extension.notify(action, reducedLiftedState);
             return { state: reducedLiftedState, action };
-        }), { state: liftedInitialState, action: (/** @type {?} */ (null)) }))
-            .subscribe((/**
-         * @param {?} __0
-         * @return {?}
-         */
-        ({ state, action }) => {
+        }, { state: liftedInitialState, action: null }))
+            .subscribe(({ state, action }) => {
             liftedStateSubject.next(state);
             if (action.type === PERFORM_ACTION) {
-                /** @type {?} */
-                const unliftedAction = ((/** @type {?} */ (action))).action;
+                const unliftedAction = action.action;
                 scannedActions.next(unliftedAction);
             }
-        }));
-        /** @type {?} */
-        const extensionStartSubscription = extension.start$.subscribe((/**
-         * @return {?}
-         */
-        () => {
+        });
+        const extensionStartSubscription = extension.start$.subscribe(() => {
             this.refresh();
-        }));
-        /** @type {?} */
-        const liftedState$ = (/** @type {?} */ (liftedStateSubject.asObservable()));
-        /** @type {?} */
+        });
+        const liftedState$ = liftedStateSubject.asObservable();
         const state$ = liftedState$.pipe(map(unliftState));
         this.extensionStartSubscription = extensionStartSubscription;
         this.stateSubscription = liftedStateSubscription;
@@ -1470,105 +792,47 @@ class StoreDevtools {
         this.liftedState = liftedState$;
         this.state = state$;
     }
-    /**
-     * @param {?} action
-     * @return {?}
-     */
     dispatch(action) {
         this.dispatcher.next(action);
     }
-    /**
-     * @param {?} action
-     * @return {?}
-     */
     next(action) {
         this.dispatcher.next(action);
     }
-    /**
-     * @param {?} error
-     * @return {?}
-     */
     error(error) { }
-    /**
-     * @return {?}
-     */
     complete() { }
-    /**
-     * @param {?} action
-     * @return {?}
-     */
     performAction(action) {
         this.dispatch(new PerformAction(action, +Date.now()));
     }
-    /**
-     * @return {?}
-     */
     refresh() {
         this.dispatch(new Refresh());
     }
-    /**
-     * @return {?}
-     */
     reset() {
         this.dispatch(new Reset(+Date.now()));
     }
-    /**
-     * @return {?}
-     */
     rollback() {
         this.dispatch(new Rollback(+Date.now()));
     }
-    /**
-     * @return {?}
-     */
     commit() {
         this.dispatch(new Commit(+Date.now()));
     }
-    /**
-     * @return {?}
-     */
     sweep() {
         this.dispatch(new Sweep());
     }
-    /**
-     * @param {?} id
-     * @return {?}
-     */
     toggleAction(id) {
         this.dispatch(new ToggleAction(id));
     }
-    /**
-     * @param {?} actionId
-     * @return {?}
-     */
     jumpToAction(actionId) {
         this.dispatch(new JumpToAction(actionId));
     }
-    /**
-     * @param {?} index
-     * @return {?}
-     */
     jumpToState(index) {
         this.dispatch(new JumpToState(index));
     }
-    /**
-     * @param {?} nextLiftedState
-     * @return {?}
-     */
     importState(nextLiftedState) {
         this.dispatch(new ImportState(nextLiftedState));
     }
-    /**
-     * @param {?} status
-     * @return {?}
-     */
     lockChanges(status) {
         this.dispatch(new LockChanges(status));
     }
-    /**
-     * @param {?} status
-     * @return {?}
-     */
     pauseRecording(status) {
         this.dispatch(new PauseRecording(status));
     }
@@ -1587,66 +851,25 @@ StoreDevtools.ctorParameters = () => [
     { type: undefined, decorators: [{ type: Inject, args: [INITIAL_STATE,] }] },
     { type: StoreDevtoolsConfig, decorators: [{ type: Inject, args: [STORE_DEVTOOLS_CONFIG,] }] }
 ];
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    StoreDevtools.prototype.stateSubscription;
-    /**
-     * @type {?}
-     * @private
-     */
-    StoreDevtools.prototype.extensionStartSubscription;
-    /** @type {?} */
-    StoreDevtools.prototype.dispatcher;
-    /** @type {?} */
-    StoreDevtools.prototype.liftedState;
-    /** @type {?} */
-    StoreDevtools.prototype.state;
-}
 
-/**
- * @fileoverview added by tsickle
- * Generated from: src/instrument.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/** @type {?} */
 const IS_EXTENSION_OR_MONITOR_PRESENT = new InjectionToken('@ngrx/store-devtools Is Devtools Extension or Monitor Present');
-/**
- * @param {?} extension
- * @param {?} config
- * @return {?}
- */
 function createIsExtensionOrMonitorPresent(extension, config) {
     return Boolean(extension) || config.monitor !== noMonitor;
 }
-/**
- * @return {?}
- */
 function createReduxDevtoolsExtension() {
-    /** @type {?} */
     const extensionKey = '__REDUX_DEVTOOLS_EXTENSION__';
     if (typeof window === 'object' &&
-        typeof ((/** @type {?} */ (window)))[extensionKey] !== 'undefined') {
-        return ((/** @type {?} */ (window)))[extensionKey];
+        typeof window[extensionKey] !== 'undefined') {
+        return window[extensionKey];
     }
     else {
         return null;
     }
 }
-/**
- * @param {?} devtools
- * @return {?}
- */
 function createStateObservable(devtools) {
     return devtools.state;
 }
 class StoreDevtoolsModule {
-    /**
-     * @param {?=} options
-     * @return {?}
-     */
     static instrument(options = {}) {
         return {
             ngModule: StoreDevtoolsModule,
@@ -1690,27 +913,13 @@ StoreDevtoolsModule.decorators = [
 ];
 
 /**
- * @fileoverview added by tsickle
- * Generated from: src/index.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-
-/**
- * @fileoverview added by tsickle
- * Generated from: public_api.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-
-/**
- * @fileoverview added by tsickle
- * Generated from: index.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * DO NOT EDIT
+ *
+ * This file is automatically generated at build
  */
 
 /**
- * @fileoverview added by tsickle
- * Generated from: ngrx-store-devtools.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * Generated bundle index. Do not edit.
  */
 
 export { INITIAL_OPTIONS, RECOMPUTE, StoreDevtools, StoreDevtoolsConfig, StoreDevtoolsModule, IS_EXTENSION_OR_MONITOR_PRESENT as ɵa, createIsExtensionOrMonitorPresent as ɵb, createReduxDevtoolsExtension as ɵc, createStateObservable as ɵd, STORE_DEVTOOLS_CONFIG as ɵe, noMonitor as ɵf, createConfig as ɵg, REDUX_DEVTOOLS_EXTENSION as ɵh, DevtoolsExtension as ɵi, DevtoolsDispatcher as ɵj };