@ngrx/store-devtools 12.5.0

package/esm2015/src/reducer.js

@@ -0,0 +1,365 @@
+import { UPDATE, INIT } from '@ngrx/store';
+import { difference, liftAction, isActionFiltered } from './utils';
+import * as DevtoolsActions from './actions';
+import { PerformAction } from './actions';
+export const INIT_ACTION = { type: INIT };
+export const RECOMPUTE = '@ngrx/store-devtools/recompute';
+export const RECOMPUTE_ACTION = { type: RECOMPUTE };
+/**
+ * Computes the next entry in the log by applying an action.
+ */
+function computeNextEntry(reducer, action, state, error, errorHandler) {
+    if (error) {
+        return {
+            state,
+            error: 'Interrupted by an error up the chain',
+        };
+    }
+    let nextState = state;
+    let nextError;
+    try {
+        nextState = reducer(state, action);
+    }
+    catch (err) {
+        nextError = err.toString();
+        errorHandler.handleError(err);
+    }
+    return {
+        state: nextState,
+        error: nextError,
+    };
+}
+/**
+ * Runs the reducer on invalidated actions to get a fresh computation log.
+ */
+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 &&
+        computedStates.length === stagedActionIds.length) {
+        return computedStates;
+    }
+    const nextComputedStates = computedStates.slice(0, minInvalidatedStateIndex);
+    // If the recording is paused, recompute all states up until the pause state,
+    // else recompute all states.
+    const lastIncludedActionId = stagedActionIds.length - (isPaused ? 1 : 0);
+    for (let i = minInvalidatedStateIndex; i < lastIncludedActionId; i++) {
+        const actionId = stagedActionIds[i];
+        const action = actionsById[actionId].action;
+        const previousEntry = nextComputedStates[i - 1];
+        const previousState = previousEntry ? previousEntry.state : committedState;
+        const previousError = previousEntry ? previousEntry.error : undefined;
+        const shouldSkip = skippedActionIds.indexOf(actionId) > -1;
+        const entry = shouldSkip
+            ? previousEntry
+            : 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;
+}
+export function liftInitialState(initialCommittedState, monitorReducer) {
+    return {
+        monitorState: monitorReducer(undefined, {}),
+        nextActionId: 1,
+        actionsById: { 0: liftAction(INIT_ACTION) },
+        stagedActionIds: [0],
+        skippedActionIds: [],
+        committedState: initialCommittedState,
+        currentStateIndex: 0,
+        computedStates: [],
+        isLocked: false,
+        isPaused: false,
+    };
+}
+/**
+ * Creates a history state reducer from an app's reducer.
+ */
+export function liftReducerWith(initialCommittedState, initialLiftedState, errorHandler, monitorReducer, options = {}) {
+    /**
+     * Manages how the history actions modify the history state.
+     */
+    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);
+        }
+        function commitExcessActions(n) {
+            // Auto-commits n-number of excess actions.
+            let excess = n;
+            let idsToDelete = stagedActionIds.slice(1, excess + 1);
+            for (let 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((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;
+        }
+        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.
+        let minInvalidatedStateIndex = 0;
+        switch (liftedAction.type) {
+            case DevtoolsActions.LOCK_CHANGES: {
+                isLocked = liftedAction.status;
+                minInvalidatedStateIndex = Infinity;
+                break;
+            }
+            case DevtoolsActions.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 = [...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;
+                }
+                else {
+                    commitChanges();
+                }
+                break;
+            }
+            case DevtoolsActions.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 DevtoolsActions.COMMIT: {
+                commitChanges();
+                break;
+            }
+            case DevtoolsActions.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 DevtoolsActions.TOGGLE_ACTION: {
+                // Toggle whether an action with given ID is skipped.
+                // Being skipped means it is a no-op during the computation.
+                const { id: actionId } = liftedAction;
+                const index = skippedActionIds.indexOf(actionId);
+                if (index === -1) {
+                    skippedActionIds = [actionId, ...skippedActionIds];
+                }
+                else {
+                    skippedActionIds = skippedActionIds.filter((id) => id !== actionId);
+                }
+                // Optimization: we know history before this action hasn't changed
+                minInvalidatedStateIndex = stagedActionIds.indexOf(actionId);
+                break;
+            }
+            case DevtoolsActions.SET_ACTIONS_ACTIVE: {
+                // 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;
+                const actionIds = [];
+                for (let i = start; i < end; i++)
+                    actionIds.push(i);
+                if (active) {
+                    skippedActionIds = difference(skippedActionIds, actionIds);
+                }
+                else {
+                    skippedActionIds = [...skippedActionIds, ...actionIds];
+                }
+                // Optimization: we know history before this action hasn't changed
+                minInvalidatedStateIndex = stagedActionIds.indexOf(start);
+                break;
+            }
+            case DevtoolsActions.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 DevtoolsActions.JUMP_TO_ACTION: {
+                // Jumps to a corresponding state to a specific action.
+                // Useful when filtering actions.
+                const index = stagedActionIds.indexOf(liftedAction.actionId);
+                if (index !== -1)
+                    currentStateIndex = index;
+                minInvalidatedStateIndex = Infinity;
+                break;
+            }
+            case DevtoolsActions.SWEEP: {
+                // Forget any actions that are currently being skipped.
+                stagedActionIds = difference(stagedActionIds, skippedActionIds);
+                skippedActionIds = [];
+                currentStateIndex = Math.min(currentStateIndex, stagedActionIds.length - 1);
+                break;
+            }
+            case DevtoolsActions.PERFORM_ACTION: {
+                // Ignore action and return state as is if recording is locked
+                if (isLocked) {
+                    return liftedState || initialLiftedState;
+                }
+                if (isPaused ||
+                    (liftedState &&
+                        isActionFiltered(liftedState.computedStates[currentStateIndex], liftedAction, options.predicate, options.actionsSafelist, options.actionsBlocklist))) {
+                    // If recording is paused or if the action should be ignored, 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.
+                    const lastState = computedStates[computedStates.length - 1];
+                    computedStates = [
+                        ...computedStates.slice(0, -1),
+                        computeNextEntry(reducer, liftedAction.action, lastState.state, lastState.error, errorHandler),
+                    ];
+                    minInvalidatedStateIndex = Infinity;
+                    break;
+                }
+                // Auto-commit as new actions come in.
+                if (options.maxAge && stagedActionIds.length === options.maxAge) {
+                    commitExcessActions(1);
+                }
+                if (currentStateIndex === stagedActionIds.length - 1) {
+                    currentStateIndex++;
+                }
+                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.
+                actionsById[actionId] = liftedAction;
+                stagedActionIds = [...stagedActionIds, actionId];
+                // Optimization: we know that only the new action needs computing.
+                minInvalidatedStateIndex = stagedActionIds.length - 1;
+                break;
+            }
+            case DevtoolsActions.IMPORT_STATE: {
+                // Completely replace everything.
+                ({
+                    monitorState,
+                    actionsById,
+                    nextActionId,
+                    stagedActionIds,
+                    skippedActionIds,
+                    committedState,
+                    currentStateIndex,
+                    computedStates,
+                    isLocked,
+                    isPaused,
+                } = liftedAction.nextLiftedState);
+                break;
+            }
+            case 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;
+                }
+                break;
+            }
+            case UPDATE: {
+                const stateHasErrors = computedStates.filter((state) => 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, isPaused);
+                        commitExcessActions(stagedActionIds.length - options.maxAge);
+                        // Avoid double computation.
+                        minInvalidatedStateIndex = Infinity;
+                    }
+                }
+                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++;
+                        }
+                        // Add a new action to only recompute state
+                        const actionId = nextActionId++;
+                        actionsById[actionId] = new PerformAction(liftedAction, +Date.now());
+                        stagedActionIds = [...stagedActionIds, actionId];
+                        minInvalidatedStateIndex = stagedActionIds.length - 1;
+                        computedStates = recomputeStates(computedStates, minInvalidatedStateIndex, reducer, committedState, actionsById, stagedActionIds, skippedActionIds, errorHandler, isPaused);
+                    }
+                    // Recompute state history with latest reducer and update 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);
+                    }
+                    // Avoid double computation.
+                    minInvalidatedStateIndex = Infinity;
+                }
+                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, isPaused);
+        monitorState = monitorReducer(monitorState, liftedAction);
+        return {
+            monitorState,
+            actionsById,
+            nextActionId,
+            stagedActionIds,
+            skippedActionIds,
+            committedState,
+            currentStateIndex,
+            computedStates,
+            isLocked,
+            isPaused,
+        };
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"reducer.js","sourceRoot":"","sources":["../../../../../modules/store-devtools/src/reducer.ts"],"names":[],"mappings":"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","sourcesContent":["import { ErrorHandler } from '@angular/core';\nimport { Action, ActionReducer, UPDATE, INIT } from '@ngrx/store';\n\nimport { difference, liftAction, isActionFiltered } from './utils';\nimport * as DevtoolsActions from './actions';\nimport { StoreDevtoolsConfig } from './config';\nimport { PerformAction } from './actions';\n\nexport type InitAction = {\n  readonly type: typeof INIT;\n};\n\nexport type UpdateReducerAction = {\n  readonly type: typeof UPDATE;\n};\n\nexport type CoreActions = InitAction | UpdateReducerAction;\nexport type Actions = DevtoolsActions.All | CoreActions;\n\nexport const INIT_ACTION = { type: INIT };\n\nexport const RECOMPUTE = '@ngrx/store-devtools/recompute' as const;\nexport const RECOMPUTE_ACTION = { type: RECOMPUTE };\n\nexport interface ComputedState {\n  state: any;\n  error: any;\n}\n\nexport interface LiftedAction {\n  type: string;\n  action: Action;\n}\n\nexport interface LiftedActions {\n  [id: number]: LiftedAction;\n}\n\nexport interface LiftedState {\n  monitorState: any;\n  nextActionId: number;\n  actionsById: LiftedActions;\n  stagedActionIds: number[];\n  skippedActionIds: number[];\n  committedState: any;\n  currentStateIndex: number;\n  computedStates: ComputedState[];\n  isLocked: boolean;\n  isPaused: boolean;\n}\n\n/**\n * Computes the next entry in the log by applying an action.\n */\nfunction computeNextEntry(\n  reducer: ActionReducer<any, any>,\n  action: Action,\n  state: any,\n  error: any,\n  errorHandler: ErrorHandler\n) {\n  if (error) {\n    return {\n      state,\n      error: 'Interrupted by an error up the chain',\n    };\n  }\n\n  let nextState = state;\n  let nextError;\n  try {\n    nextState = reducer(state, action);\n  } catch (err) {\n    nextError = err.toString();\n    errorHandler.handleError(err);\n  }\n\n  return {\n    state: nextState,\n    error: nextError,\n  };\n}\n\n/**\n * Runs the reducer on invalidated actions to get a fresh computation log.\n */\nfunction recomputeStates(\n  computedStates: ComputedState[],\n  minInvalidatedStateIndex: number,\n  reducer: ActionReducer<any, any>,\n  committedState: any,\n  actionsById: LiftedActions,\n  stagedActionIds: number[],\n  skippedActionIds: number[],\n  errorHandler: ErrorHandler,\n  isPaused: boolean\n) {\n  // Optimization: exit early and return the same reference\n  // if we know nothing could have changed.\n  if (\n    minInvalidatedStateIndex >= computedStates.length &&\n    computedStates.length === stagedActionIds.length\n  ) {\n    return computedStates;\n  }\n\n  const nextComputedStates = computedStates.slice(0, minInvalidatedStateIndex);\n  // If the recording is paused, recompute all states up until the pause state,\n  // else recompute all states.\n  const lastIncludedActionId = stagedActionIds.length - (isPaused ? 1 : 0);\n  for (let i = minInvalidatedStateIndex; i < lastIncludedActionId; i++) {\n    const actionId = stagedActionIds[i];\n    const action = actionsById[actionId].action;\n\n    const previousEntry = nextComputedStates[i - 1];\n    const previousState = previousEntry ? previousEntry.state : committedState;\n    const previousError = previousEntry ? previousEntry.error : undefined;\n\n    const shouldSkip = skippedActionIds.indexOf(actionId) > -1;\n    const entry: ComputedState = shouldSkip\n      ? previousEntry\n      : computeNextEntry(\n          reducer,\n          action,\n          previousState,\n          previousError,\n          errorHandler\n        );\n\n    nextComputedStates.push(entry);\n  }\n  // If the recording is paused, the last state will not be recomputed,\n  // because it's essentially not part of the state history.\n  if (isPaused) {\n    nextComputedStates.push(computedStates[computedStates.length - 1]);\n  }\n\n  return nextComputedStates;\n}\n\nexport function liftInitialState(\n  initialCommittedState?: any,\n  monitorReducer?: any\n): LiftedState {\n  return {\n    monitorState: monitorReducer(undefined, {}),\n    nextActionId: 1,\n    actionsById: { 0: liftAction(INIT_ACTION) },\n    stagedActionIds: [0],\n    skippedActionIds: [],\n    committedState: initialCommittedState,\n    currentStateIndex: 0,\n    computedStates: [],\n    isLocked: false,\n    isPaused: false,\n  };\n}\n\n/**\n * Creates a history state reducer from an app's reducer.\n */\nexport function liftReducerWith(\n  initialCommittedState: any,\n  initialLiftedState: LiftedState,\n  errorHandler: ErrorHandler,\n  monitorReducer?: any,\n  options: Partial<StoreDevtoolsConfig> = {}\n) {\n  /**\n   * Manages how the history actions modify the history state.\n   */\n  return (\n    reducer: ActionReducer<any, any>\n  ): ActionReducer<LiftedState, Actions> => (liftedState, liftedAction) => {\n    let {\n      monitorState,\n      actionsById,\n      nextActionId,\n      stagedActionIds,\n      skippedActionIds,\n      committedState,\n      currentStateIndex,\n      computedStates,\n      isLocked,\n      isPaused,\n    } = liftedState || initialLiftedState;\n\n    if (!liftedState) {\n      // Prevent mutating initialLiftedState\n      actionsById = Object.create(actionsById);\n    }\n\n    function commitExcessActions(n: number) {\n      // Auto-commits n-number of excess actions.\n      let excess = n;\n      let idsToDelete = stagedActionIds.slice(1, excess + 1);\n\n      for (let i = 0; i < idsToDelete.length; i++) {\n        if (computedStates[i + 1].error) {\n          // Stop if error is found. Commit actions up to error.\n          excess = i;\n          idsToDelete = stagedActionIds.slice(1, excess + 1);\n          break;\n        } else {\n          delete actionsById[idsToDelete[i]];\n        }\n      }\n\n      skippedActionIds = skippedActionIds.filter(\n        (id) => idsToDelete.indexOf(id) === -1\n      );\n      stagedActionIds = [0, ...stagedActionIds.slice(excess + 1)];\n      committedState = computedStates[excess].state;\n      computedStates = computedStates.slice(excess);\n      currentStateIndex =\n        currentStateIndex > excess ? currentStateIndex - excess : 0;\n    }\n\n    function commitChanges() {\n      // Consider the last committed state the new starting point.\n      // Squash any staged actions into a single committed state.\n      actionsById = { 0: liftAction(INIT_ACTION) };\n      nextActionId = 1;\n      stagedActionIds = [0];\n      skippedActionIds = [];\n      committedState = computedStates[currentStateIndex].state;\n      currentStateIndex = 0;\n      computedStates = [];\n    }\n\n    // By default, aggressively recompute every state whatever happens.\n    // This has O(n) performance, so we'll override this to a sensible\n    // value whenever we feel like we don't have to recompute the states.\n    let minInvalidatedStateIndex = 0;\n\n    switch (liftedAction.type) {\n      case DevtoolsActions.LOCK_CHANGES: {\n        isLocked = liftedAction.status;\n        minInvalidatedStateIndex = Infinity;\n        break;\n      }\n      case DevtoolsActions.PAUSE_RECORDING: {\n        isPaused = liftedAction.status;\n        if (isPaused) {\n          // Add a pause action to signal the devtools-user the recording is paused.\n          // The corresponding state will be overwritten on each update to always contain\n          // the latest state (see Actions.PERFORM_ACTION).\n          stagedActionIds = [...stagedActionIds, nextActionId];\n          actionsById[nextActionId] = new PerformAction(\n            {\n              type: '@ngrx/devtools/pause',\n            },\n            +Date.now()\n          );\n          nextActionId++;\n          minInvalidatedStateIndex = stagedActionIds.length - 1;\n          computedStates = computedStates.concat(\n            computedStates[computedStates.length - 1]\n          );\n\n          if (currentStateIndex === stagedActionIds.length - 2) {\n            currentStateIndex++;\n          }\n          minInvalidatedStateIndex = Infinity;\n        } else {\n          commitChanges();\n        }\n        break;\n      }\n      case DevtoolsActions.RESET: {\n        // Get back to the state the store was created with.\n        actionsById = { 0: liftAction(INIT_ACTION) };\n        nextActionId = 1;\n        stagedActionIds = [0];\n        skippedActionIds = [];\n        committedState = initialCommittedState;\n        currentStateIndex = 0;\n        computedStates = [];\n        break;\n      }\n      case DevtoolsActions.COMMIT: {\n        commitChanges();\n        break;\n      }\n      case DevtoolsActions.ROLLBACK: {\n        // Forget about any staged actions.\n        // Start again from the last committed state.\n        actionsById = { 0: liftAction(INIT_ACTION) };\n        nextActionId = 1;\n        stagedActionIds = [0];\n        skippedActionIds = [];\n        currentStateIndex = 0;\n        computedStates = [];\n        break;\n      }\n      case DevtoolsActions.TOGGLE_ACTION: {\n        // Toggle whether an action with given ID is skipped.\n        // Being skipped means it is a no-op during the computation.\n        const { id: actionId } = liftedAction;\n        const index = skippedActionIds.indexOf(actionId);\n        if (index === -1) {\n          skippedActionIds = [actionId, ...skippedActionIds];\n        } else {\n          skippedActionIds = skippedActionIds.filter((id) => id !== actionId);\n        }\n        // Optimization: we know history before this action hasn't changed\n        minInvalidatedStateIndex = stagedActionIds.indexOf(actionId);\n        break;\n      }\n      case DevtoolsActions.SET_ACTIONS_ACTIVE: {\n        // Toggle whether an action with given ID is skipped.\n        // Being skipped means it is a no-op during the computation.\n        const { start, end, active } = liftedAction;\n        const actionIds = [];\n        for (let i = start; i < end; i++) actionIds.push(i);\n        if (active) {\n          skippedActionIds = difference(skippedActionIds, actionIds);\n        } else {\n          skippedActionIds = [...skippedActionIds, ...actionIds];\n        }\n\n        // Optimization: we know history before this action hasn't changed\n        minInvalidatedStateIndex = stagedActionIds.indexOf(start);\n        break;\n      }\n      case DevtoolsActions.JUMP_TO_STATE: {\n        // Without recomputing anything, move the pointer that tell us\n        // which state is considered the current one. Useful for sliders.\n        currentStateIndex = liftedAction.index;\n        // Optimization: we know the history has not changed.\n        minInvalidatedStateIndex = Infinity;\n        break;\n      }\n      case DevtoolsActions.JUMP_TO_ACTION: {\n        // Jumps to a corresponding state to a specific action.\n        // Useful when filtering actions.\n        const index = stagedActionIds.indexOf(liftedAction.actionId);\n        if (index !== -1) currentStateIndex = index;\n        minInvalidatedStateIndex = Infinity;\n        break;\n      }\n      case DevtoolsActions.SWEEP: {\n        // Forget any actions that are currently being skipped.\n        stagedActionIds = difference(stagedActionIds, skippedActionIds);\n        skippedActionIds = [];\n        currentStateIndex = Math.min(\n          currentStateIndex,\n          stagedActionIds.length - 1\n        );\n        break;\n      }\n      case DevtoolsActions.PERFORM_ACTION: {\n        // Ignore action and return state as is if recording is locked\n        if (isLocked) {\n          return liftedState || initialLiftedState;\n        }\n\n        if (\n          isPaused ||\n          (liftedState &&\n            isActionFiltered(\n              liftedState.computedStates[currentStateIndex],\n              liftedAction,\n              options.predicate,\n              options.actionsSafelist,\n              options.actionsBlocklist\n            ))\n        ) {\n          // If recording is paused or if the action should be ignored, overwrite the last state\n          // (corresponds to the pause action) and keep everything else as is.\n          // This way, the app gets the new current state while the devtools\n          // do not record another action.\n          const lastState = computedStates[computedStates.length - 1];\n          computedStates = [\n            ...computedStates.slice(0, -1),\n            computeNextEntry(\n              reducer,\n              liftedAction.action,\n              lastState.state,\n              lastState.error,\n              errorHandler\n            ),\n          ];\n          minInvalidatedStateIndex = Infinity;\n          break;\n        }\n\n        // Auto-commit as new actions come in.\n        if (options.maxAge && stagedActionIds.length === options.maxAge) {\n          commitExcessActions(1);\n        }\n\n        if (currentStateIndex === stagedActionIds.length - 1) {\n          currentStateIndex++;\n        }\n        const actionId = nextActionId++;\n        // Mutation! This is the hottest path, and we optimize on purpose.\n        // It is safe because we set a new key in a cache dictionary.\n        actionsById[actionId] = liftedAction;\n\n        stagedActionIds = [...stagedActionIds, actionId];\n        // Optimization: we know that only the new action needs computing.\n        minInvalidatedStateIndex = stagedActionIds.length - 1;\n        break;\n      }\n      case DevtoolsActions.IMPORT_STATE: {\n        // Completely replace everything.\n        ({\n          monitorState,\n          actionsById,\n          nextActionId,\n          stagedActionIds,\n          skippedActionIds,\n          committedState,\n          currentStateIndex,\n          computedStates,\n          isLocked,\n          isPaused,\n        } = liftedAction.nextLiftedState);\n        break;\n      }\n      case INIT: {\n        // Always recompute states on hot reload and init.\n        minInvalidatedStateIndex = 0;\n\n        if (options.maxAge && stagedActionIds.length > options.maxAge) {\n          // States must be recomputed before committing excess.\n          computedStates = recomputeStates(\n            computedStates,\n            minInvalidatedStateIndex,\n            reducer,\n            committedState,\n            actionsById,\n            stagedActionIds,\n            skippedActionIds,\n            errorHandler,\n            isPaused\n          );\n\n          commitExcessActions(stagedActionIds.length - options.maxAge);\n\n          // Avoid double computation.\n          minInvalidatedStateIndex = Infinity;\n        }\n\n        break;\n      }\n      case UPDATE: {\n        const stateHasErrors =\n          computedStates.filter((state) => state.error).length > 0;\n\n        if (stateHasErrors) {\n          // Recompute all states\n          minInvalidatedStateIndex = 0;\n\n          if (options.maxAge && stagedActionIds.length > options.maxAge) {\n            // States must be recomputed before committing excess.\n            computedStates = recomputeStates(\n              computedStates,\n              minInvalidatedStateIndex,\n              reducer,\n              committedState,\n              actionsById,\n              stagedActionIds,\n              skippedActionIds,\n              errorHandler,\n              isPaused\n            );\n\n            commitExcessActions(stagedActionIds.length - options.maxAge);\n\n            // Avoid double computation.\n            minInvalidatedStateIndex = Infinity;\n          }\n        } else {\n          // If not paused/locked, add a new action to signal devtools-user\n          // that there was a reducer update.\n          if (!isPaused && !isLocked) {\n            if (currentStateIndex === stagedActionIds.length - 1) {\n              currentStateIndex++;\n            }\n\n            // Add a new action to only recompute state\n            const actionId = nextActionId++;\n            actionsById[actionId] = new PerformAction(\n              liftedAction,\n              +Date.now()\n            );\n            stagedActionIds = [...stagedActionIds, actionId];\n\n            minInvalidatedStateIndex = stagedActionIds.length - 1;\n\n            computedStates = recomputeStates(\n              computedStates,\n              minInvalidatedStateIndex,\n              reducer,\n              committedState,\n              actionsById,\n              stagedActionIds,\n              skippedActionIds,\n              errorHandler,\n              isPaused\n            );\n          }\n\n          // Recompute state history with latest reducer and update action\n          computedStates = computedStates.map((cmp) => ({\n            ...cmp,\n            state: reducer(cmp.state, RECOMPUTE_ACTION),\n          }));\n\n          currentStateIndex = stagedActionIds.length - 1;\n\n          if (options.maxAge && stagedActionIds.length > options.maxAge) {\n            commitExcessActions(stagedActionIds.length - options.maxAge);\n          }\n\n          // Avoid double computation.\n          minInvalidatedStateIndex = Infinity;\n        }\n\n        break;\n      }\n      default: {\n        // If the action is not recognized, it's a monitor action.\n        // Optimization: a monitor action can't change history.\n        minInvalidatedStateIndex = Infinity;\n        break;\n      }\n    }\n\n    computedStates = recomputeStates(\n      computedStates,\n      minInvalidatedStateIndex,\n      reducer,\n      committedState,\n      actionsById,\n      stagedActionIds,\n      skippedActionIds,\n      errorHandler,\n      isPaused\n    );\n    monitorState = monitorReducer(monitorState, liftedAction);\n\n    return {\n      monitorState,\n      actionsById,\n      nextActionId,\n      stagedActionIds,\n      skippedActionIds,\n      committedState,\n      currentStateIndex,\n      computedStates,\n      isLocked,\n      isPaused,\n    };\n  };\n}\n"]}

package/esm2015/src/utils.js

@@ -0,0 +1,106 @@
+import * as Actions from './actions';
+export function difference(first, second) {
+    return first.filter((item) => second.indexOf(item) < 0);
+}
+/**
+ * Provides an app's view into the state of the lifted store.
+ */
+export function unliftState(liftedState) {
+    const { computedStates, currentStateIndex } = liftedState;
+    // At start up NgRx dispatches init actions,
+    // When these init actions are being filtered out by the predicate or safe/block list options
+    // we don't have a complete computed states yet.
+    // At this point it could happen that we're out of bounds, when this happens we fall back to the last known state
+    if (currentStateIndex >= computedStates.length) {
+        const { state } = computedStates[computedStates.length - 1];
+        return state;
+    }
+    const { state } = computedStates[currentStateIndex];
+    return state;
+}
+export function unliftAction(liftedState) {
+    return liftedState.actionsById[liftedState.nextActionId - 1];
+}
+/**
+ * Lifts an app's action into an action on the lifted store.
+ */
+export function liftAction(action) {
+    return new Actions.PerformAction(action, +Date.now());
+}
+/**
+ * Sanitizes given actions with given function.
+ */
+export function sanitizeActions(actionSanitizer, actions) {
+    return Object.keys(actions).reduce((sanitizedActions, actionIdx) => {
+        const idx = Number(actionIdx);
+        sanitizedActions[idx] = sanitizeAction(actionSanitizer, actions[idx], idx);
+        return sanitizedActions;
+    }, {});
+}
+/**
+ * Sanitizes given action with given function.
+ */
+export function sanitizeAction(actionSanitizer, action, actionIdx) {
+    return Object.assign(Object.assign({}, action), { action: actionSanitizer(action.action, actionIdx) });
+}
+/**
+ * Sanitizes given states with given function.
+ */
+export function sanitizeStates(stateSanitizer, states) {
+    return states.map((computedState, idx) => ({
+        state: sanitizeState(stateSanitizer, computedState.state, idx),
+        error: computedState.error,
+    }));
+}
+/**
+ * Sanitizes given state with given function.
+ */
+export function sanitizeState(stateSanitizer, state, stateIdx) {
+    return stateSanitizer(state, stateIdx);
+}
+/**
+ * Read the config and tell if actions should be filtered
+ */
+export function shouldFilterActions(config) {
+    return config.predicate || config.actionsSafelist || config.actionsBlocklist;
+}
+/**
+ * Return a full filtered lifted state
+ */
+export function filterLiftedState(liftedState, predicate, safelist, blocklist) {
+    const filteredStagedActionIds = [];
+    const filteredActionsById = {};
+    const filteredComputedStates = [];
+    liftedState.stagedActionIds.forEach((id, idx) => {
+        const liftedAction = liftedState.actionsById[id];
+        if (!liftedAction)
+            return;
+        if (idx &&
+            isActionFiltered(liftedState.computedStates[idx], liftedAction, predicate, safelist, blocklist)) {
+            return;
+        }
+        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
+ */
+export function isActionFiltered(state, action, predicate, safelist, blockedlist) {
+    const predicateMatch = predicate && !predicate(state, action.action);
+    const safelistMatch = safelist &&
+        !action.action.type.match(safelist.map((s) => escapeRegExp(s)).join('|'));
+    const blocklistMatch = blockedlist &&
+        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
+ */
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../modules/store-devtools/src/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { Action } from '@ngrx/store';\n\nimport * as Actions from './actions';\nimport {\n  ActionSanitizer,\n  StateSanitizer,\n  Predicate,\n  StoreDevtoolsConfig,\n} from './config';\nimport {\n  ComputedState,\n  LiftedAction,\n  LiftedActions,\n  LiftedState,\n} from './reducer';\n\nexport function difference(first: any[], second: any[]) {\n  return first.filter((item) => second.indexOf(item) < 0);\n}\n\n/**\n * Provides an app's view into the state of the lifted store.\n */\nexport function unliftState(liftedState: LiftedState) {\n  const { computedStates, currentStateIndex } = liftedState;\n\n  // At start up NgRx dispatches init actions,\n  // When these init actions are being filtered out by the predicate or safe/block list options\n  // we don't have a complete computed states yet.\n  // At this point it could happen that we're out of bounds, when this happens we fall back to the last known state\n  if (currentStateIndex >= computedStates.length) {\n    const { state } = computedStates[computedStates.length - 1];\n    return state;\n  }\n\n  const { state } = computedStates[currentStateIndex];\n  return state;\n}\n\nexport function unliftAction(liftedState: LiftedState): LiftedAction {\n  return liftedState.actionsById[liftedState.nextActionId - 1];\n}\n\n/**\n * Lifts an app's action into an action on the lifted store.\n */\nexport function liftAction(action: Action) {\n  return new Actions.PerformAction(action, +Date.now());\n}\n\n/**\n * Sanitizes given actions with given function.\n */\nexport function sanitizeActions(\n  actionSanitizer: ActionSanitizer,\n  actions: LiftedActions\n): LiftedActions {\n  return Object.keys(actions).reduce((sanitizedActions, actionIdx) => {\n    const idx = Number(actionIdx);\n    sanitizedActions[idx] = sanitizeAction(actionSanitizer, actions[idx], idx);\n    return sanitizedActions;\n  }, <LiftedActions>{});\n}\n\n/**\n * Sanitizes given action with given function.\n */\nexport function sanitizeAction(\n  actionSanitizer: ActionSanitizer,\n  action: LiftedAction,\n  actionIdx: number\n): LiftedAction {\n  return {\n    ...action,\n    action: actionSanitizer(action.action, actionIdx),\n  };\n}\n\n/**\n * Sanitizes given states with given function.\n */\nexport function sanitizeStates(\n  stateSanitizer: StateSanitizer,\n  states: ComputedState[]\n): ComputedState[] {\n  return states.map((computedState, idx) => ({\n    state: sanitizeState(stateSanitizer, computedState.state, idx),\n    error: computedState.error,\n  }));\n}\n\n/**\n * Sanitizes given state with given function.\n */\nexport function sanitizeState(\n  stateSanitizer: StateSanitizer,\n  state: any,\n  stateIdx: number\n) {\n  return stateSanitizer(state, stateIdx);\n}\n\n/**\n * Read the config and tell if actions should be filtered\n */\nexport function shouldFilterActions(config: StoreDevtoolsConfig) {\n  return config.predicate || config.actionsSafelist || config.actionsBlocklist;\n}\n\n/**\n * Return a full filtered lifted state\n */\nexport function filterLiftedState(\n  liftedState: LiftedState,\n  predicate?: Predicate,\n  safelist?: string[],\n  blocklist?: string[]\n): LiftedState {\n  const filteredStagedActionIds: number[] = [];\n  const filteredActionsById: LiftedActions = {};\n  const filteredComputedStates: ComputedState[] = [];\n  liftedState.stagedActionIds.forEach((id, idx) => {\n    const liftedAction = liftedState.actionsById[id];\n    if (!liftedAction) return;\n    if (\n      idx &&\n      isActionFiltered(\n        liftedState.computedStates[idx],\n        liftedAction,\n        predicate,\n        safelist,\n        blocklist\n      )\n    ) {\n      return;\n    }\n    filteredActionsById[id] = liftedAction;\n    filteredStagedActionIds.push(id);\n    filteredComputedStates.push(liftedState.computedStates[idx]);\n  });\n  return {\n    ...liftedState,\n    stagedActionIds: filteredStagedActionIds,\n    actionsById: filteredActionsById,\n    computedStates: filteredComputedStates,\n  };\n}\n\n/**\n * Return true is the action should be ignored\n */\nexport function isActionFiltered(\n  state: any,\n  action: LiftedAction,\n  predicate?: Predicate,\n  safelist?: string[],\n  blockedlist?: string[]\n) {\n  const predicateMatch = predicate && !predicate(state, action.action);\n  const safelistMatch =\n    safelist &&\n    !action.action.type.match(safelist.map((s) => escapeRegExp(s)).join('|'));\n  const blocklistMatch =\n    blockedlist &&\n    action.action.type.match(blockedlist.map((s) => escapeRegExp(s)).join('|'));\n  return predicateMatch || safelistMatch || blocklistMatch;\n}\n\n/**\n * Return string with escaped RegExp special characters\n * https://stackoverflow.com/a/6969486/1337347\n */\nfunction escapeRegExp(s: string): string {\n  return s.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n}\n"]}