@ngrx/store-devtools 6.1.2 → 7.0.0-beta.0

package/bundles/store-devtools.umd.js

@@ -1,13 +1,13 @@
 /**
- * @license NgRx 6.1.2
+ * @license NgRx 7.0.0-beta.0
  * (c) 2015-2018 Brandon Roberts, Mike Ryan, Rob Wormald, Victor Savkin
  * License: MIT
  */
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('rxjs'), require('rxjs/operators'), require('@ngrx/store')) :
-    typeof define === 'function' && define.amd ? define('@ngrx/store-devtools', ['exports', '@angular/core', 'rxjs', 'rxjs/operators', '@ngrx/store'], factory) :
-    (factory((global.ngrx = global.ngrx || {}, global.ngrx.storeDevtools = {}),global.ng.core,global.rxjs,global.rxjs.operators,global['@ngrx/store']));
-}(this, (function (exports,core,rxjs,operators,store) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@ngrx/store'), require('rxjs'), require('rxjs/operators')) :
+    typeof define === 'function' && define.amd ? define('@ngrx/store-devtools', ['exports', '@angular/core', '@ngrx/store', 'rxjs', 'rxjs/operators'], factory) :
+    (factory((global.ngrx = global.ngrx || {}, global.ngrx.storeDevtools = {}),global.ng.core,global['@ngrx/store'],global.rxjs,global.rxjs.operators));
+}(this, (function (exports,core,store,rxjs,operators) { 'use strict';
 
     var StoreDevtoolsConfig = /** @class */ (function () {
         function StoreDevtoolsConfig() {
@@ -16,6 +16,45 @@
     }());
     var STORE_DEVTOOLS_CONFIG = new core.InjectionToken('@ngrx/devtools Options');
     var INITIAL_OPTIONS = new core.InjectionToken('@ngrx/devtools Initial Config');
+    function noMonitor() {
+        return null;
+    }
+    var DEFAULT_NAME = 'NgRx Store DevTools';
+    function createConfig(_options) {
+        var DEFAULT_OPTIONS = {
+            maxAge: false,
+            monitor: noMonitor,
+            actionSanitizer: undefined,
+            stateSanitizer: undefined,
+            name: DEFAULT_NAME,
+            serialize: false,
+            logOnly: false,
+            // Add all features explicitely. This prevent buggy behavior for
+            // options like "lock" which might otherwise not show up.
+            features: {
+                pause: true,
+                lock: true,
+                persist: true,
+                export: true,
+                import: 'custom',
+                jump: true,
+                skip: true,
+                reorder: true,
+                dispatch: true,
+                test: true,
+            },
+        };
+        var options = typeof _options === 'function' ? _options() : _options;
+        var logOnly = options.logOnly
+            ? { pause: true, export: true, test: true }
+            : false;
+        var features = options.features || logOnly || DEFAULT_OPTIONS.features;
+        var config = Object.assign({}, DEFAULT_OPTIONS, { features: features }, options);
+        if (config.maxAge && config.maxAge < 2) {
+            throw new Error("Devtools 'maxAge' cannot be less than 2, got " + config.maxAge);
+        }
+        return config;
+    }
 
     var PERFORM_ACTION = 'PERFORM_ACTION';
     var REFRESH = 'REFRESH';
@@ -28,6 +67,8 @@
     var JUMP_TO_STATE = 'JUMP_TO_STATE';
     var JUMP_TO_ACTION = 'JUMP_TO_ACTION';
     var IMPORT_STATE = 'IMPORT_STATE';
+    var LOCK_CHANGES = 'LOCK_CHANGES';
+    var PAUSE_RECORDING = 'PAUSE_RECORDING';
     var PerformAction = /** @class */ (function () {
         function PerformAction(action, timestamp) {
             this.action = action;
@@ -101,14 +142,31 @@
         }
         return ImportState;
     }());
-
-    var __assign = (undefined && undefined.__assign) || Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
+    var LockChanges = /** @class */ (function () {
+        function LockChanges(status) {
+            this.status = status;
+            this.type = LOCK_CHANGES;
+        }
+        return LockChanges;
+    }());
+    var PauseRecording = /** @class */ (function () {
+        function PauseRecording(status) {
+            this.status = status;
+            this.type = PAUSE_RECORDING;
         }
-        return t;
+        return PauseRecording;
+    }());
+
+    var __assign = (undefined && undefined.__assign) || function () {
+        __assign = Object.assign || function(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                    t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign.apply(this, arguments);
     };
     function difference(first, second) {
         return first.filter(function (item) { return second.indexOf(item) < 0; });
@@ -147,12 +205,10 @@
      * Sanitizes given states with given function.
      */
     function sanitizeStates(stateSanitizer, states) {
-        return states.map(function (computedState, idx) {
-            return ({
-                state: sanitizeState(stateSanitizer, computedState.state, idx),
-                error: computedState.error,
-            });
-        });
+        return states.map(function (computedState, idx) { return ({
+            state: sanitizeState(stateSanitizer, computedState.state, idx),
+            error: computedState.error,
+        }); });
     }
     /**
      * Sanitizes given state with given function.
@@ -160,14 +216,94 @@
     function sanitizeState(stateSanitizer, state, stateIdx) {
         return stateSanitizer(state, stateIdx);
     }
+    /**
+     * Read the config and tell if actions should be filtered
+     */
+    function shouldFilterActions(config) {
+        return config.predicate || config.actionsWhitelist || config.actionsBlacklist;
+    }
+    /**
+     * Return a full filtered lifted state
+     */
+    function filterLiftedState(liftedState, predicate, whitelist, blacklist) {
+        var filteredStagedActionIds = [];
+        var filteredActionsById = {};
+        var filteredComputedStates = [];
+        liftedState.stagedActionIds.forEach(function (id, idx) {
+            var liftedAction = liftedState.actionsById[id];
+            if (!liftedAction)
+                return;
+            if (idx &&
+                isActionFiltered(liftedState.computedStates[idx], liftedAction, predicate, whitelist, blacklist)) {
+                return;
+            }
+            filteredActionsById[id] = liftedAction;
+            filteredStagedActionIds.push(id);
+            filteredComputedStates.push(liftedState.computedStates[idx]);
+        });
+        return __assign({}, liftedState, { stagedActionIds: filteredStagedActionIds, actionsById: filteredActionsById, computedStates: filteredComputedStates });
+    }
+    /**
+     * Return true is the action should be ignored
+     */
+    function isActionFiltered(state, action, predicate, whitelist, blacklist) {
+        return ((predicate && !predicate(state, action.action)) ||
+            (whitelist && !action.action.type.match(whitelist.join('|'))) ||
+            (blacklist && action.action.type.match(blacklist.join('|'))));
+    }
 
-    var __assign$1 = (undefined && undefined.__assign) || Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
+    var __extends = (undefined && undefined.__extends) || (function () {
+        var extendStatics = function (d, b) {
+            extendStatics = Object.setPrototypeOf ||
+                ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+                function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+            return extendStatics(d, b);
+        };
+        return function (d, b) {
+            extendStatics(d, b);
+            function __() { this.constructor = d; }
+            d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+        };
+    })();
+    var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+        if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+        else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+        return c > 3 && r && Object.defineProperty(target, key, r), r;
+    };
+    var DevtoolsDispatcher = /** @class */ (function (_super) {
+        __extends(DevtoolsDispatcher, _super);
+        function DevtoolsDispatcher() {
+            return _super !== null && _super.apply(this, arguments) || this;
         }
-        return t;
+        DevtoolsDispatcher = __decorate([
+            core.Injectable()
+        ], DevtoolsDispatcher);
+        return DevtoolsDispatcher;
+    }(store.ActionsSubject));
+
+    var __assign$1 = (undefined && undefined.__assign) || function () {
+        __assign$1 = Object.assign || function(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                    t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign$1.apply(this, arguments);
+    };
+    var __decorate$1 = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+        if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+        else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+        return c > 3 && r && Object.defineProperty(target, key, r), r;
+    };
+    var __metadata = (undefined && undefined.__metadata) || function (k, v) {
+        if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+    };
+    var __param = (undefined && undefined.__param) || function (paramIndex, decorator) {
+        return function (target, key) { decorator(target, key, paramIndex); }
     };
     var ExtensionActionTypes = {
         START: 'START',
@@ -177,9 +313,9 @@
     };
     var REDUX_DEVTOOLS_EXTENSION = new core.InjectionToken('Redux Devtools Extension');
     var DevtoolsExtension = /** @class */ (function () {
-        function DevtoolsExtension(devtoolsExtension, config) {
+        function DevtoolsExtension(devtoolsExtension, config, dispatcher) {
             this.config = config;
-            this.instanceId = "ngrx-store-" + Date.now();
+            this.dispatcher = dispatcher;
             this.devtoolsExtension = devtoolsExtension;
             this.createActionStreams();
         }
@@ -188,8 +324,8 @@
                 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, only send the
-            // action and the current state (fast).
+            // 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:
@@ -201,7 +337,14 @@
             //   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;
+                }
                 var currentState = unliftState(state);
+                if (shouldFilterActions(this.config) &&
+                    isActionFiltered(currentState, action, this.config.predicate, this.config.actionsWhitelist, this.config.actionsBlacklist)) {
+                    return;
+                }
                 var sanitizedState = this.config.stateSanitizer
                     ? sanitizeState(this.config.stateSanitizer, currentState, state.currentStateIndex)
                     : currentState;
@@ -212,12 +355,12 @@
             }
             else {
                 // Requires full state update
-                var sanitizedLiftedState = __assign$1({}, state, { actionsById: this.config.actionSanitizer
+                var sanitizedLiftedState = __assign$1({}, 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.devtoolsExtension.send(null, sanitizedLiftedState, this.getExtensionConfig(this.instanceId, this.config), this.instanceId);
+                this.devtoolsExtension.send(null, sanitizedLiftedState, this.getExtensionConfig(this.config));
             }
         };
         DevtoolsExtension.prototype.createChangesObservable = function () {
@@ -226,7 +369,7 @@
                 return rxjs.empty();
             }
             return new rxjs.Observable(function (subscriber) {
-                var connection = _this.devtoolsExtension.connect(_this.getExtensionConfig(_this.instanceId, _this.config));
+                var connection = _this.devtoolsExtension.connect(_this.getExtensionConfig(_this.config));
                 _this.extensionConnection = connection;
                 connection.init();
                 connection.subscribe(function (change) { return subscriber.next(change); });
@@ -235,14 +378,29 @@
         };
         DevtoolsExtension.prototype.createActionStreams = function () {
             var _this = this;
-            // Listens to all changes based on our instanceId
+            // Listens to all changes
             var changes$ = this.createChangesObservable().pipe(operators.share());
             // Listen for the start action
             var start$ = changes$.pipe(operators.filter(function (change) { return change.type === ExtensionActionTypes.START; }));
             // Listen for the stop action
             var stop$ = changes$.pipe(operators.filter(function (change) { return change.type === ExtensionActionTypes.STOP; }));
             // Listen for lifted actions
-            var liftedActions$ = changes$.pipe(operators.filter(function (change) { return change.type === ExtensionActionTypes.DISPATCH; }), operators.map(function (change) { return _this.unwrapAction(change.payload); }));
+            var liftedActions$ = changes$.pipe(operators.filter(function (change) { return change.type === ExtensionActionTypes.DISPATCH; }), operators.map(function (change) { return _this.unwrapAction(change.payload); }), operators.concatMap(function (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(operators.filter(function (action) { return action.type === store.UPDATE; }), operators.timeout(1000), operators.debounceTime(1000), operators.map(function () { return action; }), operators.catchError(function () { return rxjs.of(action); }), operators.take(1));
+                }
+                else {
+                    return rxjs.of(action);
+                }
+            }));
             // Listen for unlifted actions
             var actions$ = changes$.pipe(operators.filter(function (change) { return change.type === ExtensionActionTypes.ACTION; }), operators.map(function (change) { return _this.unwrapAction(change.payload); }));
             var actionsUntilStop$ = actions$.pipe(operators.takeUntil(stop$));
@@ -255,9 +413,8 @@
         DevtoolsExtension.prototype.unwrapAction = function (action) {
             return typeof action === 'string' ? eval("(" + action + ")") : action;
         };
-        DevtoolsExtension.prototype.getExtensionConfig = function (instanceId, config) {
+        DevtoolsExtension.prototype.getExtensionConfig = function (config) {
             var extensionOptions = {
-                instanceId: instanceId,
                 name: config.name,
                 features: config.features,
                 serialize: config.serialize,
@@ -267,24 +424,26 @@
             }
             return extensionOptions;
         };
-        DevtoolsExtension.decorators = [
-            { type: core.Injectable }
-        ];
-        /** @nocollapse */
-        DevtoolsExtension.ctorParameters = function () { return [
-            { type: undefined, decorators: [{ type: core.Inject, args: [REDUX_DEVTOOLS_EXTENSION,] },] },
-            { type: StoreDevtoolsConfig, decorators: [{ type: core.Inject, args: [STORE_DEVTOOLS_CONFIG,] },] },
-        ]; };
+        DevtoolsExtension = __decorate$1([
+            core.Injectable(),
+            __param(0, core.Inject(REDUX_DEVTOOLS_EXTENSION)),
+            __param(1, core.Inject(STORE_DEVTOOLS_CONFIG)),
+            __metadata("design:paramtypes", [Object, StoreDevtoolsConfig,
+                DevtoolsDispatcher])
+        ], DevtoolsExtension);
         return DevtoolsExtension;
     }());
 
-    var __assign$2 = (undefined && undefined.__assign) || Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
+    var __assign$2 = (undefined && undefined.__assign) || function () {
+        __assign$2 = Object.assign || function(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                    t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign$2.apply(this, arguments);
     };
     var __read = (undefined && undefined.__read) || function (o, n) {
         var m = typeof Symbol === "function" && o[Symbol.iterator];
@@ -307,6 +466,8 @@
         return ar;
     };
     var INIT_ACTION = { type: store.INIT };
+    var RECOMPUTE = '@ngrx/store-devtools/recompute';
+    var RECOMPUTE_ACTION = { type: RECOMPUTE };
     /**
      * Computes the next entry in the log by applying an action.
      */
@@ -334,7 +495,7 @@
     /**
      * Runs the reducer on invalidated actions to get a fresh computation log.
      */
-    function recomputeStates(computedStates, minInvalidatedStateIndex, reducer, committedState, actionsById, stagedActionIds, skippedActionIds, errorHandler) {
+    function recomputeStates(computedStates, minInvalidatedStateIndex, reducer, committedState, actionsById, stagedActionIds, skippedActionIds, errorHandler, isPaused) {
         // Optimization: exit early and return the same reference
         // if we know nothing could have changed.
         if (minInvalidatedStateIndex >= computedStates.length &&
@@ -342,7 +503,10 @@
             return computedStates;
         }
         var nextComputedStates = computedStates.slice(0, minInvalidatedStateIndex);
-        for (var i = minInvalidatedStateIndex; i < stagedActionIds.length; i++) {
+        // If the recording is paused, recompute all states up until the pause state,
+        // else recompute all states.
+        var lastIncludedActionId = stagedActionIds.length - (isPaused ? 1 : 0);
+        for (var i = minInvalidatedStateIndex; i < lastIncludedActionId; i++) {
             var actionId = stagedActionIds[i];
             var action = actionsById[actionId].action;
             var previousEntry = nextComputedStates[i - 1];
@@ -354,6 +518,11 @@
                 : computeNextEntry(reducer, action, previousState, previousError, errorHandler);
             nextComputedStates.push(entry);
         }
+        // If the recording is paused, the last state will not be recomputed,
+        // because it's essentially not part of the state history.
+        if (isPaused) {
+            nextComputedStates.push(computedStates[computedStates.length - 1]);
+        }
         return nextComputedStates;
     }
     function liftInitialState(initialCommittedState, monitorReducer) {
@@ -366,6 +535,8 @@
             committedState: initialCommittedState,
             currentStateIndex: 0,
             computedStates: [],
+            isLocked: false,
+            isPaused: false,
         };
     }
     /**
@@ -374,182 +545,232 @@
     function liftReducerWith(initialCommittedState, initialLiftedState, errorHandler, monitorReducer, options) {
         if (options === void 0) { options = {}; }
         /**
-           * Manages how the history actions modify the history state.
-           */
-        return function (reducer) {
-            return function (liftedState, liftedAction) {
-                var _a = liftedState || initialLiftedState, monitorState = _a.monitorState, actionsById = _a.actionsById, nextActionId = _a.nextActionId, stagedActionIds = _a.stagedActionIds, skippedActionIds = _a.skippedActionIds, committedState = _a.committedState, currentStateIndex = _a.currentStateIndex, computedStates = _a.computedStates;
-                if (!liftedState) {
-                    // Prevent mutating initialLiftedState
-                    actionsById = Object.create(actionsById);
+         * Manages how the history actions modify the history state.
+         */
+        return function (reducer) { return function (liftedState, liftedAction) {
+            var _a;
+            var _b = liftedState || initialLiftedState, monitorState = _b.monitorState, actionsById = _b.actionsById, nextActionId = _b.nextActionId, stagedActionIds = _b.stagedActionIds, skippedActionIds = _b.skippedActionIds, committedState = _b.committedState, currentStateIndex = _b.currentStateIndex, computedStates = _b.computedStates, isLocked = _b.isLocked, isPaused = _b.isPaused;
+            if (!liftedState) {
+                // Prevent mutating initialLiftedState
+                actionsById = Object.create(actionsById);
+            }
+            function commitExcessActions(n) {
+                // Auto-commits n-number of excess actions.
+                var excess = n;
+                var idsToDelete = stagedActionIds.slice(1, excess + 1);
+                for (var i = 0; i < idsToDelete.length; i++) {
+                    if (computedStates[i + 1].error) {
+                        // Stop if error is found. Commit actions up to error.
+                        excess = i;
+                        idsToDelete = stagedActionIds.slice(1, excess + 1);
+                        break;
+                    }
+                    else {
+                        delete actionsById[idsToDelete[i]];
+                    }
                 }
-                function commitExcessActions(n) {
-                    // Auto-commits n-number of excess actions.
-                    var excess = n;
-                    var idsToDelete = stagedActionIds.slice(1, excess + 1);
-                    for (var i = 0; i < idsToDelete.length; i++) {
-                        if (computedStates[i + 1].error) {
-                            // Stop if error is found. Commit actions up to error.
-                            excess = i;
-                            idsToDelete = stagedActionIds.slice(1, excess + 1);
-                            break;
-                        }
-                        else {
-                            delete actionsById[idsToDelete[i]];
+                skippedActionIds = skippedActionIds.filter(function (id) { return idsToDelete.indexOf(id) === -1; });
+                stagedActionIds = __spread([0], stagedActionIds.slice(excess + 1));
+                committedState = computedStates[excess].state;
+                computedStates = computedStates.slice(excess);
+                currentStateIndex =
+                    currentStateIndex > excess ? currentStateIndex - excess : 0;
+            }
+            function commitChanges() {
+                // Consider the last committed state the new starting point.
+                // Squash any staged actions into a single committed state.
+                actionsById = { 0: liftAction(INIT_ACTION) };
+                nextActionId = 1;
+                stagedActionIds = [0];
+                skippedActionIds = [];
+                committedState = computedStates[currentStateIndex].state;
+                currentStateIndex = 0;
+                computedStates = [];
+            }
+            // 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.
+            var minInvalidatedStateIndex = 0;
+            switch (liftedAction.type) {
+                case LOCK_CHANGES: {
+                    isLocked = liftedAction.status;
+                    minInvalidatedStateIndex = Infinity;
+                    break;
+                }
+                case PAUSE_RECORDING: {
+                    isPaused = liftedAction.status;
+                    if (isPaused) {
+                        // Add a pause action to signal the devtools-user the recording is paused.
+                        // The corresponding state will be overwritten on each update to always contain
+                        // the latest state (see Actions.PERFORM_ACTION).
+                        stagedActionIds = __spread(stagedActionIds, [nextActionId]);
+                        actionsById[nextActionId] = new PerformAction({
+                            type: '@ngrx/devtools/pause',
+                        }, +Date.now());
+                        nextActionId++;
+                        minInvalidatedStateIndex = stagedActionIds.length - 1;
+                        computedStates = computedStates.concat(computedStates[computedStates.length - 1]);
+                        if (currentStateIndex === stagedActionIds.length - 2) {
+                            currentStateIndex++;
                         }
+                        minInvalidatedStateIndex = Infinity;
                     }
-                    skippedActionIds = skippedActionIds.filter(function (id) { return idsToDelete.indexOf(id) === -1; });
-                    stagedActionIds = __spread([0], stagedActionIds.slice(excess + 1));
-                    committedState = computedStates[excess].state;
-                    computedStates = computedStates.slice(excess);
-                    currentStateIndex =
-                        currentStateIndex > excess ? currentStateIndex - excess : 0;
-                }
-                // 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.
-                var minInvalidatedStateIndex = 0;
-                switch (liftedAction.type) {
-                    case RESET: {
-                        // Get back to the state the store was created with.
-                        actionsById = { 0: liftAction(INIT_ACTION) };
-                        nextActionId = 1;
-                        stagedActionIds = [0];
-                        skippedActionIds = [];
-                        committedState = initialCommittedState;
-                        currentStateIndex = 0;
-                        computedStates = [];
-                        break;
+                    else {
+                        commitChanges();
                     }
-                    case COMMIT: {
-                        // Consider the last committed state the new starting point.
-                        // Squash any staged actions into a single committed state.
-                        actionsById = { 0: liftAction(INIT_ACTION) };
-                        nextActionId = 1;
-                        stagedActionIds = [0];
-                        skippedActionIds = [];
-                        committedState = computedStates[currentStateIndex].state;
-                        currentStateIndex = 0;
-                        computedStates = [];
-                        break;
+                    break;
+                }
+                case RESET: {
+                    // Get back to the state the store was created with.
+                    actionsById = { 0: liftAction(INIT_ACTION) };
+                    nextActionId = 1;
+                    stagedActionIds = [0];
+                    skippedActionIds = [];
+                    committedState = initialCommittedState;
+                    currentStateIndex = 0;
+                    computedStates = [];
+                    break;
+                }
+                case COMMIT: {
+                    commitChanges();
+                    break;
+                }
+                case ROLLBACK: {
+                    // Forget about any staged actions.
+                    // Start again from the last committed state.
+                    actionsById = { 0: liftAction(INIT_ACTION) };
+                    nextActionId = 1;
+                    stagedActionIds = [0];
+                    skippedActionIds = [];
+                    currentStateIndex = 0;
+                    computedStates = [];
+                    break;
+                }
+                case TOGGLE_ACTION: {
+                    // Toggle whether an action with given ID is skipped.
+                    // Being skipped means it is a no-op during the computation.
+                    var actionId_1 = liftedAction.id;
+                    var index = skippedActionIds.indexOf(actionId_1);
+                    if (index === -1) {
+                        skippedActionIds = __spread([actionId_1], skippedActionIds);
                     }
-                    case ROLLBACK: {
-                        // Forget about any staged actions.
-                        // Start again from the last committed state.
-                        actionsById = { 0: liftAction(INIT_ACTION) };
-                        nextActionId = 1;
-                        stagedActionIds = [0];
-                        skippedActionIds = [];
-                        currentStateIndex = 0;
-                        computedStates = [];
-                        break;
+                    else {
+                        skippedActionIds = skippedActionIds.filter(function (id) { return id !== actionId_1; });
                     }
-                    case TOGGLE_ACTION: {
-                        // Toggle whether an action with given ID is skipped.
-                        // Being skipped means it is a no-op during the computation.
-                        var actionId_1 = liftedAction.id;
-                        var index = skippedActionIds.indexOf(actionId_1);
-                        if (index === -1) {
-                            skippedActionIds = __spread([actionId_1], skippedActionIds);
-                        }
-                        else {
-                            skippedActionIds = skippedActionIds.filter(function (id) { return id !== actionId_1; });
-                        }
-                        // Optimization: we know history before this action hasn't changed
-                        minInvalidatedStateIndex = stagedActionIds.indexOf(actionId_1);
-                        break;
+                    // Optimization: we know history before this action hasn't changed
+                    minInvalidatedStateIndex = stagedActionIds.indexOf(actionId_1);
+                    break;
+                }
+                case SET_ACTIONS_ACTIVE: {
+                    // Toggle whether an action with given ID is skipped.
+                    // Being skipped means it is a no-op during the computation.
+                    var start = liftedAction.start, end = liftedAction.end, active = liftedAction.active;
+                    var actionIds = [];
+                    for (var i = start; i < end; i++)
+                        actionIds.push(i);
+                    if (active) {
+                        skippedActionIds = difference(skippedActionIds, actionIds);
                     }
-                    case SET_ACTIONS_ACTIVE: {
-                        // Toggle whether an action with given ID is skipped.
-                        // Being skipped means it is a no-op during the computation.
-                        var start = liftedAction.start, end = liftedAction.end, active = liftedAction.active;
-                        var actionIds = [];
-                        for (var i = start; i < end; i++)
-                            actionIds.push(i);
-                        if (active) {
-                            skippedActionIds = difference(skippedActionIds, actionIds);
-                        }
-                        else {
-                            skippedActionIds = __spread(skippedActionIds, actionIds);
-                        }
-                        // Optimization: we know history before this action hasn't changed
-                        minInvalidatedStateIndex = stagedActionIds.indexOf(start);
-                        break;
+                    else {
+                        skippedActionIds = __spread(skippedActionIds, actionIds);
                     }
-                    case JUMP_TO_STATE: {
-                        // Without recomputing anything, move the pointer that tell us
-                        // which state is considered the current one. Useful for sliders.
-                        currentStateIndex = liftedAction.index;
-                        // Optimization: we know the history has not changed.
-                        minInvalidatedStateIndex = Infinity;
-                        break;
+                    // Optimization: we know history before this action hasn't changed
+                    minInvalidatedStateIndex = stagedActionIds.indexOf(start);
+                    break;
+                }
+                case JUMP_TO_STATE: {
+                    // Without recomputing anything, move the pointer that tell us
+                    // which state is considered the current one. Useful for sliders.
+                    currentStateIndex = liftedAction.index;
+                    // Optimization: we know the history has not changed.
+                    minInvalidatedStateIndex = Infinity;
+                    break;
+                }
+                case JUMP_TO_ACTION: {
+                    // Jumps to a corresponding state to a specific action.
+                    // Useful when filtering actions.
+                    var index = stagedActionIds.indexOf(liftedAction.actionId);
+                    if (index !== -1)
+                        currentStateIndex = index;
+                    minInvalidatedStateIndex = Infinity;
+                    break;
+                }
+                case SWEEP: {
+                    // Forget any actions that are currently being skipped.
+                    stagedActionIds = difference(stagedActionIds, skippedActionIds);
+                    skippedActionIds = [];
+                    currentStateIndex = Math.min(currentStateIndex, stagedActionIds.length - 1);
+                    break;
+                }
+                case PERFORM_ACTION: {
+                    // Ignore action and return state as is if recording is locked
+                    if (isLocked) {
+                        return liftedState || initialLiftedState;
                     }
-                    case JUMP_TO_ACTION: {
-                        // Jumps to a corresponding state to a specific action.
-                        // Useful when filtering actions.
-                        var index = stagedActionIds.indexOf(liftedAction.actionId);
-                        if (index !== -1)
-                            currentStateIndex = index;
+                    if (isPaused) {
+                        // If recording is paused, overwrite the last state
+                        // (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.
+                        var lastState = computedStates[computedStates.length - 1];
+                        computedStates = __spread(computedStates.slice(0, -1), [
+                            computeNextEntry(reducer, liftedAction.action, lastState.state, lastState.error, errorHandler),
+                        ]);
                         minInvalidatedStateIndex = Infinity;
                         break;
                     }
-                    case SWEEP: {
-                        // Forget any actions that are currently being skipped.
-                        stagedActionIds = difference(stagedActionIds, skippedActionIds);
-                        skippedActionIds = [];
-                        currentStateIndex = Math.min(currentStateIndex, stagedActionIds.length - 1);
-                        break;
+                    // Auto-commit as new actions come in.
+                    if (options.maxAge && stagedActionIds.length === options.maxAge) {
+                        commitExcessActions(1);
                     }
-                    case PERFORM_ACTION: {
-                        // Auto-commit as new actions come in.
-                        if (options.maxAge && stagedActionIds.length === options.maxAge) {
-                            commitExcessActions(1);
-                        }
-                        if (currentStateIndex === stagedActionIds.length - 1) {
-                            currentStateIndex++;
-                        }
-                        var 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.
-                        actionsById[actionId] = liftedAction;
-                        stagedActionIds = __spread(stagedActionIds, [actionId]);
-                        // Optimization: we know that only the new action needs computing.
-                        minInvalidatedStateIndex = stagedActionIds.length - 1;
-                        break;
+                    if (currentStateIndex === stagedActionIds.length - 1) {
+                        currentStateIndex++;
                     }
-                    case IMPORT_STATE: {
-                        // Completely replace everything.
-                        (_b = liftedAction.nextLiftedState, monitorState = _b.monitorState, actionsById = _b.actionsById, nextActionId = _b.nextActionId, stagedActionIds = _b.stagedActionIds, skippedActionIds = _b.skippedActionIds, committedState = _b.committedState, currentStateIndex = _b.currentStateIndex, 
-                        // prettier-ignore
-                        computedStates = _b.computedStates);
-                        break;
+                    var 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.
+                    actionsById[actionId] = liftedAction;
+                    stagedActionIds = __spread(stagedActionIds, [actionId]);
+                    // Optimization: we know that only the new action needs computing.
+                    minInvalidatedStateIndex = stagedActionIds.length - 1;
+                    break;
+                }
+                case IMPORT_STATE: {
+                    // Completely replace everything.
+                    (_a = liftedAction.nextLiftedState, monitorState = _a.monitorState, actionsById = _a.actionsById, nextActionId = _a.nextActionId, stagedActionIds = _a.stagedActionIds, skippedActionIds = _a.skippedActionIds, committedState = _a.committedState, currentStateIndex = _a.currentStateIndex, computedStates = _a.computedStates, isLocked = _a.isLocked, 
+                    // prettier-ignore
+                    isPaused = _a.isPaused);
+                    break;
+                }
+                case store.INIT: {
+                    // Always recompute states on hot reload and init.
+                    minInvalidatedStateIndex = 0;
+                    if (options.maxAge && stagedActionIds.length > options.maxAge) {
+                        // States must be recomputed before committing excess.
+                        computedStates = recomputeStates(computedStates, minInvalidatedStateIndex, reducer, committedState, actionsById, stagedActionIds, skippedActionIds, errorHandler, isPaused);
+                        commitExcessActions(stagedActionIds.length - options.maxAge);
+                        // Avoid double computation.
+                        minInvalidatedStateIndex = Infinity;
                     }
-                    case store.INIT: {
-                        // Always recompute states on hot reload and init.
+                    break;
+                }
+                case store.UPDATE: {
+                    var stateHasErrors = computedStates.filter(function (state) { return state.error; }).length > 0;
+                    if (stateHasErrors) {
+                        // Recompute all states
                         minInvalidatedStateIndex = 0;
                         if (options.maxAge && stagedActionIds.length > options.maxAge) {
                             // States must be recomputed before committing excess.
-                            computedStates = recomputeStates(computedStates, minInvalidatedStateIndex, reducer, committedState, actionsById, stagedActionIds, skippedActionIds, errorHandler);
+                            computedStates = recomputeStates(computedStates, minInvalidatedStateIndex, reducer, committedState, actionsById, stagedActionIds, skippedActionIds, errorHandler, isPaused);
                             commitExcessActions(stagedActionIds.length - options.maxAge);
                             // Avoid double computation.
                             minInvalidatedStateIndex = Infinity;
                         }
-                        break;
                     }
-                    case store.UPDATE: {
-                        var stateHasErrors = computedStates.filter(function (state) { return state.error; }).length > 0;
-                        if (stateHasErrors) {
-                            // Recompute all states
-                            minInvalidatedStateIndex = 0;
-                            if (options.maxAge && stagedActionIds.length > options.maxAge) {
-                                // States must be recomputed before committing excess.
-                                computedStates = recomputeStates(computedStates, minInvalidatedStateIndex, reducer, committedState, actionsById, stagedActionIds, skippedActionIds, errorHandler);
-                                commitExcessActions(stagedActionIds.length - options.maxAge);
-                                // Avoid double computation.
-                                minInvalidatedStateIndex = Infinity;
-                            }
-                        }
-                        else {
+                    else {
+                        // If not paused/locked, add a new action to signal devtools-user
+                        // that there was a reducer update.
+                        if (!isPaused && !isLocked) {
                             if (currentStateIndex === stagedActionIds.length - 1) {
                                 currentStateIndex++;
                             }
@@ -558,55 +779,55 @@
                             actionsById[actionId] = new PerformAction(liftedAction, +Date.now());
                             stagedActionIds = __spread(stagedActionIds, [actionId]);
                             minInvalidatedStateIndex = stagedActionIds.length - 1;
-                            // States must be recomputed before committing excess.
-                            computedStates = recomputeStates(computedStates, minInvalidatedStateIndex, reducer, committedState, actionsById, stagedActionIds, skippedActionIds, errorHandler);
-                            // Recompute state history with latest reducer and update action
-                            computedStates = computedStates.map(function (cmp) {
-                                return (__assign$2({}, cmp, { state: reducer(cmp.state, liftedAction) }));
-                            });
-                            currentStateIndex = minInvalidatedStateIndex;
-                            if (options.maxAge && stagedActionIds.length > options.maxAge) {
-                                commitExcessActions(stagedActionIds.length - options.maxAge);
-                            }
-                            // Avoid double computation.
-                            minInvalidatedStateIndex = Infinity;
+                            computedStates = recomputeStates(computedStates, minInvalidatedStateIndex, reducer, committedState, actionsById, stagedActionIds, skippedActionIds, errorHandler, isPaused);
                         }
-                        break;
-                    }
-                    default: {
-                        // If the action is not recognized, it's a monitor action.
-                        // Optimization: a monitor action can't change history.
+                        // Recompute state history with latest reducer and update action
+                        computedStates = computedStates.map(function (cmp) { return (__assign$2({}, cmp, { state: reducer(cmp.state, RECOMPUTE_ACTION) })); });
+                        currentStateIndex = stagedActionIds.length - 1;
+                        if (options.maxAge && stagedActionIds.length > options.maxAge) {
+                            commitExcessActions(stagedActionIds.length - options.maxAge);
+                        }
+                        // Avoid double computation.
                         minInvalidatedStateIndex = Infinity;
-                        break;
                     }
+                    break;
+                }
+                default: {
+                    // If the action is not recognized, it's a monitor action.
+                    // Optimization: a monitor action can't change history.
+                    minInvalidatedStateIndex = Infinity;
+                    break;
                 }
-                computedStates = recomputeStates(computedStates, minInvalidatedStateIndex, reducer, committedState, actionsById, stagedActionIds, skippedActionIds, errorHandler);
-                monitorState = monitorReducer(monitorState, liftedAction);
-                return {
-                    monitorState: monitorState,
-                    actionsById: actionsById,
-                    nextActionId: nextActionId,
-                    stagedActionIds: stagedActionIds,
-                    skippedActionIds: skippedActionIds,
-                    committedState: committedState,
-                    currentStateIndex: currentStateIndex,
-                    computedStates: computedStates,
-                };
-                var _b;
+            }
+            computedStates = recomputeStates(computedStates, minInvalidatedStateIndex, reducer, committedState, actionsById, stagedActionIds, skippedActionIds, errorHandler, isPaused);
+            monitorState = monitorReducer(monitorState, liftedAction);
+            return {
+                monitorState: monitorState,
+                actionsById: actionsById,
+                nextActionId: nextActionId,
+                stagedActionIds: stagedActionIds,
+                skippedActionIds: skippedActionIds,
+                committedState: committedState,
+                currentStateIndex: currentStateIndex,
+                computedStates: computedStates,
+                isLocked: isLocked,
+                isPaused: isPaused,
             };
-        };
+        }; };
     }
 
-    var __extends = (undefined && undefined.__extends) || (function () {
-        var extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
-        return function (d, b) {
-            extendStatics(d, b);
-            function __() { this.constructor = d; }
-            d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-        };
-    })();
+    var __decorate$2 = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+        if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+        else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+        return c > 3 && r && Object.defineProperty(target, key, r), r;
+    };
+    var __metadata$1 = (undefined && undefined.__metadata) || function (k, v) {
+        if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+    };
+    var __param$1 = (undefined && undefined.__param) || function (paramIndex, decorator) {
+        return function (target, key) { decorator(target, key, paramIndex); }
+    };
     var __read$1 = (undefined && undefined.__read) || function (o, n) {
         var m = typeof Symbol === "function" && o[Symbol.iterator];
         if (!m) return o;
@@ -623,16 +844,6 @@
         }
         return ar;
     };
-    var DevtoolsDispatcher = /** @class */ (function (_super) {
-        __extends(DevtoolsDispatcher, _super);
-        function DevtoolsDispatcher() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        DevtoolsDispatcher.decorators = [
-            { type: core.Injectable }
-        ];
-        return DevtoolsDispatcher;
-    }(store.ActionsSubject));
     var StoreDevtools = /** @class */ (function () {
         function StoreDevtools(dispatcher, actions$, reducers$, extension, scannedActions, errorHandler, initialState, config) {
             var _this = this;
@@ -646,7 +857,12 @@
                 var liftedState = _a.state;
                 var _c = __read$1(_b, 2), action = _c[0], reducer = _c[1];
                 var reducedLiftedState = reducer(liftedState, action);
-                // // Extension should be sent the sanitized lifted state
+                // On full state update
+                // If we have actions filters, we must filter completly our lifted state to be sync with the extension
+                if (action.type !== PERFORM_ACTION && shouldFilterActions(config)) {
+                    reducedLiftedState = filterLiftedState(reducedLiftedState, config.predicate, config.actionsWhitelist, config.actionsBlacklist);
+                }
+                // Extension should be sent the sanitized lifted state
                 extension.notify(action, reducedLiftedState);
                 return { state: reducedLiftedState, action: action };
             }, { state: liftedInitialState, action: null }))
@@ -707,23 +923,32 @@
         StoreDevtools.prototype.importState = function (nextLiftedState) {
             this.dispatch(new ImportState(nextLiftedState));
         };
-        StoreDevtools.decorators = [
-            { type: core.Injectable }
-        ];
-        /** @nocollapse */
-        StoreDevtools.ctorParameters = function () { return [
-            { type: DevtoolsDispatcher, },
-            { type: store.ActionsSubject, },
-            { type: store.ReducerObservable, },
-            { type: DevtoolsExtension, },
-            { type: store.ScannedActionsSubject, },
-            { type: core.ErrorHandler, },
-            { type: undefined, decorators: [{ type: core.Inject, args: [store.INITIAL_STATE,] },] },
-            { type: StoreDevtoolsConfig, decorators: [{ type: core.Inject, args: [STORE_DEVTOOLS_CONFIG,] },] },
-        ]; };
+        StoreDevtools.prototype.lockChanges = function (status) {
+            this.dispatch(new LockChanges(status));
+        };
+        StoreDevtools.prototype.pauseRecording = function (status) {
+            this.dispatch(new PauseRecording(status));
+        };
+        StoreDevtools = __decorate$2([
+            core.Injectable(),
+            __param$1(6, core.Inject(store.INITIAL_STATE)),
+            __param$1(7, core.Inject(STORE_DEVTOOLS_CONFIG)),
+            __metadata$1("design:paramtypes", [DevtoolsDispatcher,
+                store.ActionsSubject,
+                store.ReducerObservable,
+                DevtoolsExtension,
+                store.ScannedActionsSubject,
+                core.ErrorHandler, Object, StoreDevtoolsConfig])
+        ], StoreDevtools);
         return StoreDevtools;
     }());
 
+    var __decorate$3 = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+        if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+        else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+        return c > 3 && r && Object.defineProperty(target, key, r), r;
+    };
     var IS_EXTENSION_OR_MONITOR_PRESENT = new core.InjectionToken('Is Devtools Extension or Monitor Present');
     function createIsExtensionOrMonitorPresent(extension, config) {
         return Boolean(extension) || config.monitor !== noMonitor;
@@ -741,39 +966,14 @@
     function createStateObservable(devtools) {
         return devtools.state;
     }
-    function noMonitor() {
-        return null;
-    }
-    var DEFAULT_NAME = 'NgRx Store DevTools';
-    function createConfig(_options) {
-        var DEFAULT_OPTIONS = {
-            maxAge: false,
-            monitor: noMonitor,
-            actionSanitizer: undefined,
-            stateSanitizer: undefined,
-            name: DEFAULT_NAME,
-            serialize: false,
-            logOnly: false,
-            features: false,
-        };
-        var options = typeof _options === 'function' ? _options() : _options;
-        var logOnly = options.logOnly
-            ? { pause: true, export: true, test: true }
-            : false;
-        var features = options.features || logOnly;
-        var config = Object.assign({}, DEFAULT_OPTIONS, { features: features }, options);
-        if (config.maxAge && config.maxAge < 2) {
-            throw new Error("Devtools 'maxAge' cannot be less than 2, got " + config.maxAge);
-        }
-        return config;
-    }
     var StoreDevtoolsModule = /** @class */ (function () {
         function StoreDevtoolsModule() {
         }
+        StoreDevtoolsModule_1 = StoreDevtoolsModule;
         StoreDevtoolsModule.instrument = function (options) {
             if (options === void 0) { options = {}; }
             return {
-                ngModule: StoreDevtoolsModule,
+                ngModule: StoreDevtoolsModule_1,
                 providers: [
                     DevtoolsExtension,
                     DevtoolsDispatcher,
@@ -808,9 +1008,10 @@
                 ],
             };
         };
-        StoreDevtoolsModule.decorators = [
-            { type: core.NgModule, args: [{},] }
-        ];
+        var StoreDevtoolsModule_1;
+        StoreDevtoolsModule = StoreDevtoolsModule_1 = __decorate$3([
+            core.NgModule({})
+        ], StoreDevtoolsModule);
         return StoreDevtoolsModule;
     }());
 
@@ -824,18 +1025,19 @@
      * Generated bundle index. Do not edit.
      */
 
-    exports.ɵngrx_modules_store_devtools_store_devtools_i = INITIAL_OPTIONS;
-    exports.ɵngrx_modules_store_devtools_store_devtools_h = STORE_DEVTOOLS_CONFIG;
-    exports.ɵngrx_modules_store_devtools_store_devtools_g = DevtoolsDispatcher;
-    exports.ɵngrx_modules_store_devtools_store_devtools_k = DevtoolsExtension;
-    exports.ɵngrx_modules_store_devtools_store_devtools_j = REDUX_DEVTOOLS_EXTENSION;
+    exports.ɵngrx_modules_store_devtools_store_devtools_f = INITIAL_OPTIONS;
+    exports.ɵngrx_modules_store_devtools_store_devtools_e = STORE_DEVTOOLS_CONFIG;
+    exports.ɵngrx_modules_store_devtools_store_devtools_h = createConfig;
+    exports.ɵngrx_modules_store_devtools_store_devtools_g = noMonitor;
+    exports.ɵngrx_modules_store_devtools_store_devtools_k = DevtoolsDispatcher;
+    exports.ɵngrx_modules_store_devtools_store_devtools_j = DevtoolsExtension;
+    exports.ɵngrx_modules_store_devtools_store_devtools_i = REDUX_DEVTOOLS_EXTENSION;
     exports.ɵngrx_modules_store_devtools_store_devtools_a = IS_EXTENSION_OR_MONITOR_PRESENT;
-    exports.ɵngrx_modules_store_devtools_store_devtools_f = createConfig;
     exports.ɵngrx_modules_store_devtools_store_devtools_b = createIsExtensionOrMonitorPresent;
     exports.ɵngrx_modules_store_devtools_store_devtools_c = createReduxDevtoolsExtension;
     exports.ɵngrx_modules_store_devtools_store_devtools_d = createStateObservable;
-    exports.ɵngrx_modules_store_devtools_store_devtools_e = noMonitor;
     exports.StoreDevtoolsModule = StoreDevtoolsModule;
+    exports.RECOMPUTE = RECOMPUTE;
     exports.StoreDevtools = StoreDevtools;
     exports.StoreDevtoolsConfig = StoreDevtoolsConfig;