@ngxs/store 3.8.2 → 18.0.0-dev.master-f4c2c19

package/esm2022/src/internal/internals.mjs

@@ -0,0 +1,206 @@
+import { InjectionToken, inject } from '@angular/core';
+import { ɵMETA_KEY } from '@ngxs/store/internals';
+import { NgxsConfig } from '../symbols';
+const NG_DEV_MODE = typeof ngDevMode !== 'undefined' && ngDevMode;
+/**
+ * Get a deeply nested value. Example:
+ *
+ *    getValue({ foo: bar: [] }, 'foo.bar') //=> []
+ *
+ * Note: This is not as fast as the `fastPropGetter` but is strict Content Security Policy compliant.
+ * See perf hit: https://jsperf.com/fast-value-getter-given-path/1
+ *
+ * @ignore
+ */
+function compliantPropGetter(paths) {
+    return obj => {
+        for (let i = 0; i < paths.length; i++) {
+            if (!obj)
+                return undefined;
+            obj = obj[paths[i]];
+        }
+        return obj;
+    };
+}
+/**
+ * The generated function is faster than:
+ * - pluck (Observable operator)
+ * - memoize
+ *
+ * @ignore
+ */
+function fastPropGetter(paths) {
+    const segments = paths;
+    let seg = 'store.' + segments[0];
+    let i = 0;
+    const l = segments.length;
+    let expr = seg;
+    while (++i < l) {
+        expr = expr + ' && ' + (seg = seg + '.' + segments[i]);
+    }
+    const fn = new Function('store', 'return ' + expr + ';');
+    return fn;
+}
+/**
+ * Get a deeply nested value. Example:
+ *
+ *    getValue({ foo: bar: [] }, 'foo.bar') //=> []
+ *
+ * @ignore
+ *
+ * Marked for removal. It's only used within `createSelectorFn`.
+ */
+export function propGetter(paths, config) {
+    if (config?.compatibility?.strictContentSecurityPolicy) {
+        return compliantPropGetter(paths);
+    }
+    else {
+        return fastPropGetter(paths);
+    }
+}
+// This injection token selects the prop getter implementation once the app is
+// bootstrapped, as the `propGetter` function's behavior determines the implementation
+// each time it's called. It accepts the config as the second argument. We no longer
+// need to check for the `strictContentSecurityPolicy` every time the prop getter
+// implementation is selected. Now, the `propGetter` function is only used within
+// `createSelectorFn`, which, in turn, is solely used by the `Select` decorator.
+// We've been trying to deprecate the `Select` decorator because it's unstable with
+// server-side rendering and micro-frontend applications.
+export const ɵPROP_GETTER = new InjectionToken(NG_DEV_MODE ? 'PROP_GETTER' : '', {
+    providedIn: 'root',
+    factory: () => inject(NgxsConfig).compatibility?.strictContentSecurityPolicy
+        ? compliantPropGetter
+        : fastPropGetter
+});
+/**
+ * Given an array of states, it will return a object graph. Example:
+ *    const states = [
+ *      Cart,
+ *      CartSaved,
+ *      CartSavedItems
+ *    ]
+ *
+ * would return:
+ *
+ *  const graph = {
+ *    cart: ['saved'],
+ *    saved: ['items'],
+ *    items: []
+ *  };
+ *
+ * @ignore
+ */
+export function buildGraph(stateClasses) {
+    const findName = (stateClass) => {
+        const meta = stateClasses.find(g => g === stateClass);
+        if (NG_DEV_MODE && !meta) {
+            throw new Error(`Child state not found: ${stateClass}. \r\nYou may have forgotten to add states to module`);
+        }
+        return meta[ɵMETA_KEY].name;
+    };
+    return stateClasses.reduce((result, stateClass) => {
+        const { name, children } = stateClass[ɵMETA_KEY];
+        result[name] = (children || []).map(findName);
+        return result;
+    }, {});
+}
+/**
+ * Given a states array, returns object graph
+ * returning the name and state metadata. Example:
+ *
+ *  const graph = {
+ *    cart: { metadata }
+ *  };
+ *
+ * @ignore
+ */
+export function nameToState(states) {
+    return states.reduce((result, stateClass) => {
+        const meta = stateClass[ɵMETA_KEY];
+        result[meta.name] = stateClass;
+        return result;
+    }, {});
+}
+/**
+ * Given a object relationship graph will return the full path
+ * for the child items. Example:
+ *
+ *  const graph = {
+ *    cart: ['saved'],
+ *    saved: ['items'],
+ *    items: []
+ *  };
+ *
+ * would return:
+ *
+ *  const r = {
+ *    cart: 'cart',
+ *    saved: 'cart.saved',
+ *    items: 'cart.saved.items'
+ *  };
+ *
+ * @ignore
+ */
+export function findFullParentPath(obj, newObj = {}) {
+    const visit = (child, keyToFind) => {
+        for (const key in child) {
+            if (child.hasOwnProperty(key) && child[key].indexOf(keyToFind) >= 0) {
+                const parent = visit(child, key);
+                return parent !== null ? `${parent}.${key}` : key;
+            }
+        }
+        return null;
+    };
+    for (const key in obj) {
+        if (obj.hasOwnProperty(key)) {
+            const parent = visit(obj, key);
+            newObj[key] = parent ? `${parent}.${key}` : key;
+        }
+    }
+    return newObj;
+}
+/**
+ * Given a object graph, it will return the items topologically sorted Example:
+ *
+ *  const graph = {
+ *    cart: ['saved'],
+ *    saved: ['items'],
+ *    items: []
+ *  };
+ *
+ * would return:
+ *
+ *  const results = [
+ *    'items',
+ *    'saved',
+ *    'cart'
+ *  ];
+ *
+ * @ignore
+ */
+export function topologicalSort(graph) {
+    const sorted = [];
+    const visited = {};
+    const visit = (name, ancestors = []) => {
+        if (!Array.isArray(ancestors)) {
+            ancestors = [];
+        }
+        ancestors.push(name);
+        visited[name] = true;
+        graph[name].forEach((dep) => {
+            if (NG_DEV_MODE && ancestors.indexOf(dep) >= 0) {
+                throw new Error(`Circular dependency '${dep}' is required by '${name}': ${ancestors.join(' -> ')}`);
+            }
+            if (visited[dep]) {
+                return;
+            }
+            visit(dep, ancestors.slice(0));
+        });
+        if (sorted.indexOf(name) < 0) {
+            sorted.push(name);
+        }
+    };
+    Object.keys(graph).forEach(k => visit(k));
+    return sorted.reverse();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"internals.js","sourceRoot":"","sources":["../../../../../packages/store/src/internal/internals.ts"],"names":[],"mappings":"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","sourcesContent":["import { InjectionToken, inject } from '@angular/core';\nimport { Observable } from 'rxjs';\n\nimport {\n  ɵMETA_KEY,\n  ɵPlainObjectOf,\n  ɵStateClassInternal,\n  ɵActionHandlerMetaData\n} from '@ngxs/store/internals';\n\nimport { NgxsConfig } from '../symbols';\n\ndeclare const ngDevMode: boolean;\n\nconst NG_DEV_MODE = typeof ngDevMode !== 'undefined' && ngDevMode;\n\nexport type StateKeyGraph = ɵPlainObjectOf<string[]>;\nexport type StatesByName = ɵPlainObjectOf<ɵStateClassInternal>;\n\nexport interface StateOperations<T> {\n  getState(): T;\n\n  setState(val: T): void;\n\n  dispatch(actionOrActions: any | any[]): Observable<void>;\n}\n\nexport interface MappedStore {\n  name: string;\n  isInitialised: boolean;\n  actions: ɵPlainObjectOf<ɵActionHandlerMetaData[]>;\n  defaults: any;\n  instance: any;\n  path: string;\n}\n\nexport interface StatesAndDefaults {\n  defaults: any;\n  states: MappedStore[];\n}\n\n/**\n * Get a deeply nested value. Example:\n *\n *    getValue({ foo: bar: [] }, 'foo.bar') //=> []\n *\n * Note: This is not as fast as the `fastPropGetter` but is strict Content Security Policy compliant.\n * See perf hit: https://jsperf.com/fast-value-getter-given-path/1\n *\n * @ignore\n */\nfunction compliantPropGetter(paths: string[]): (x: any) => any {\n  return obj => {\n    for (let i = 0; i < paths.length; i++) {\n      if (!obj) return undefined;\n      obj = obj[paths[i]];\n    }\n    return obj;\n  };\n}\n\n/**\n * The generated function is faster than:\n * - pluck (Observable operator)\n * - memoize\n *\n * @ignore\n */\nfunction fastPropGetter(paths: string[]): (x: any) => any {\n  const segments = paths;\n  let seg = 'store.' + segments[0];\n  let i = 0;\n  const l = segments.length;\n\n  let expr = seg;\n  while (++i < l) {\n    expr = expr + ' && ' + (seg = seg + '.' + segments[i]);\n  }\n\n  const fn = new Function('store', 'return ' + expr + ';');\n\n  return <(x: any) => any>fn;\n}\n\n/**\n * Get a deeply nested value. Example:\n *\n *    getValue({ foo: bar: [] }, 'foo.bar') //=> []\n *\n * @ignore\n *\n * Marked for removal. It's only used within `createSelectorFn`.\n */\nexport function propGetter(paths: string[], config: NgxsConfig) {\n  if (config?.compatibility?.strictContentSecurityPolicy) {\n    return compliantPropGetter(paths);\n  } else {\n    return fastPropGetter(paths);\n  }\n}\n\n// This injection token selects the prop getter implementation once the app is\n// bootstrapped, as the `propGetter` function's behavior determines the implementation\n// each time it's called. It accepts the config as the second argument. We no longer\n// need to check for the `strictContentSecurityPolicy` every time the prop getter\n// implementation is selected. Now, the `propGetter` function is only used within\n// `createSelectorFn`, which, in turn, is solely used by the `Select` decorator.\n// We've been trying to deprecate the `Select` decorator because it's unstable with\n// server-side rendering and micro-frontend applications.\nexport const ɵPROP_GETTER = new InjectionToken<(paths: string[]) => (x: any) => any>(\n  NG_DEV_MODE ? 'PROP_GETTER' : '',\n  {\n    providedIn: 'root',\n    factory: () =>\n      inject(NgxsConfig).compatibility?.strictContentSecurityPolicy\n        ? compliantPropGetter\n        : fastPropGetter\n  }\n);\n\n/**\n * Given an array of states, it will return a object graph. Example:\n *    const states = [\n *      Cart,\n *      CartSaved,\n *      CartSavedItems\n *    ]\n *\n * would return:\n *\n *  const graph = {\n *    cart: ['saved'],\n *    saved: ['items'],\n *    items: []\n *  };\n *\n * @ignore\n */\nexport function buildGraph(stateClasses: ɵStateClassInternal[]): StateKeyGraph {\n  const findName = (stateClass: ɵStateClassInternal) => {\n    const meta = stateClasses.find(g => g === stateClass);\n\n    if (NG_DEV_MODE && !meta) {\n      throw new Error(\n        `Child state not found: ${stateClass}. \\r\\nYou may have forgotten to add states to module`\n      );\n    }\n\n    return meta![ɵMETA_KEY]!.name!;\n  };\n\n  return stateClasses.reduce<StateKeyGraph>(\n    (result: StateKeyGraph, stateClass: ɵStateClassInternal) => {\n      const { name, children } = stateClass[ɵMETA_KEY]!;\n      result[name!] = (children || []).map(findName);\n      return result;\n    },\n    {}\n  );\n}\n\n/**\n * Given a states array, returns object graph\n * returning the name and state metadata. Example:\n *\n *  const graph = {\n *    cart: { metadata }\n *  };\n *\n * @ignore\n */\nexport function nameToState(\n  states: ɵStateClassInternal[]\n): ɵPlainObjectOf<ɵStateClassInternal> {\n  return states.reduce<ɵPlainObjectOf<ɵStateClassInternal>>(\n    (result: ɵPlainObjectOf<ɵStateClassInternal>, stateClass: ɵStateClassInternal) => {\n      const meta = stateClass[ɵMETA_KEY]!;\n      result[meta.name!] = stateClass;\n      return result;\n    },\n    {}\n  );\n}\n\n/**\n * Given a object relationship graph will return the full path\n * for the child items. Example:\n *\n *  const graph = {\n *    cart: ['saved'],\n *    saved: ['items'],\n *    items: []\n *  };\n *\n * would return:\n *\n *  const r = {\n *    cart: 'cart',\n *    saved: 'cart.saved',\n *    items: 'cart.saved.items'\n *  };\n *\n * @ignore\n */\nexport function findFullParentPath(\n  obj: StateKeyGraph,\n  newObj: ɵPlainObjectOf<string> = {}\n): ɵPlainObjectOf<string> {\n  const visit = (child: StateKeyGraph, keyToFind: string): string | null => {\n    for (const key in child) {\n      if (child.hasOwnProperty(key) && child[key].indexOf(keyToFind) >= 0) {\n        const parent = visit(child, key);\n        return parent !== null ? `${parent}.${key}` : key;\n      }\n    }\n    return null;\n  };\n\n  for (const key in obj) {\n    if (obj.hasOwnProperty(key)) {\n      const parent = visit(obj, key);\n      newObj[key] = parent ? `${parent}.${key}` : key;\n    }\n  }\n\n  return newObj;\n}\n\n/**\n * Given a object graph, it will return the items topologically sorted Example:\n *\n *  const graph = {\n *    cart: ['saved'],\n *    saved: ['items'],\n *    items: []\n *  };\n *\n * would return:\n *\n *  const results = [\n *    'items',\n *    'saved',\n *    'cart'\n *  ];\n *\n * @ignore\n */\nexport function topologicalSort(graph: StateKeyGraph): string[] {\n  const sorted: string[] = [];\n  const visited: ɵPlainObjectOf<boolean> = {};\n\n  const visit = (name: string, ancestors: string[] = []) => {\n    if (!Array.isArray(ancestors)) {\n      ancestors = [];\n    }\n\n    ancestors.push(name);\n    visited[name] = true;\n\n    graph[name].forEach((dep: string) => {\n      if (NG_DEV_MODE && ancestors.indexOf(dep) >= 0) {\n        throw new Error(\n          `Circular dependency '${dep}' is required by '${name}': ${ancestors.join(' -> ')}`\n        );\n      }\n\n      if (visited[dep]) {\n        return;\n      }\n\n      visit(dep, ancestors.slice(0));\n    });\n\n    if (sorted.indexOf(name) < 0) {\n      sorted.push(name);\n    }\n  };\n\n  Object.keys(graph).forEach(k => visit(k));\n\n  return sorted.reverse();\n}\n"]}

package/esm2022/src/internal/lifecycle-state-manager.mjs

@@ -0,0 +1,86 @@
+import { Injectable } from '@angular/core';
+import { ɵNgxsAppBootstrappedState } from '@ngxs/store/internals';
+import { getValue, InitState, UpdateState } from '@ngxs/store/plugins';
+import { ReplaySubject } from 'rxjs';
+import { filter, mergeMap, pairwise, startWith, takeUntil, tap } from 'rxjs/operators';
+import { Store } from '../store';
+import { StateContextFactory } from './state-context-factory';
+import { InternalStateOperations } from './state-operations';
+import { NgxsSimpleChange } from '../symbols';
+import { getInvalidInitializationOrderMessage } from '../configs/messages.config';
+import * as i0 from "@angular/core";
+import * as i1 from "../store";
+import * as i2 from "./state-operations";
+import * as i3 from "./state-context-factory";
+import * as i4 from "@ngxs/store/internals";
+const NG_DEV_MODE = typeof ngDevMode !== 'undefined' && ngDevMode;
+export class LifecycleStateManager {
+    constructor(_store, _internalStateOperations, _stateContextFactory, _appBootstrappedState) {
+        this._store = _store;
+        this._internalStateOperations = _internalStateOperations;
+        this._stateContextFactory = _stateContextFactory;
+        this._appBootstrappedState = _appBootstrappedState;
+        this._destroy$ = new ReplaySubject(1);
+    }
+    ngOnDestroy() {
+        this._destroy$.next();
+    }
+    ngxsBootstrap(action, results) {
+        if (NG_DEV_MODE) {
+            if (action instanceof InitState) {
+                this._initStateHasBeenDispatched = true;
+            }
+            else if (
+            // This is a dev mode-only check that ensures the correct order of
+            // state initialization. The `NgxsModule.forRoot` or `provideStore` should
+            // always come first, followed by `forFeature` and `provideStates`. If the
+            // `UpdateState` is dispatched before the `InitState` is dispatched, it indicates
+            // that modules or providers are in an invalid order.
+            action instanceof UpdateState &&
+                !this._initStateHasBeenDispatched) {
+                console.error(getInvalidInitializationOrderMessage(action.addedStates));
+            }
+        }
+        this._internalStateOperations
+            .getRootStateOperations()
+            .dispatch(action)
+            .pipe(filter(() => !!results), tap(() => this._invokeInitOnStates(results.states)), mergeMap(() => this._appBootstrappedState), filter(appBootstrapped => !!appBootstrapped), takeUntil(this._destroy$))
+            .subscribe(() => this._invokeBootstrapOnStates(results.states));
+    }
+    _invokeInitOnStates(mappedStores) {
+        for (const mappedStore of mappedStores) {
+            const instance = mappedStore.instance;
+            if (instance.ngxsOnChanges) {
+                this._store
+                    .select(state => getValue(state, mappedStore.path))
+                    .pipe(startWith(undefined), pairwise(), takeUntil(this._destroy$))
+                    .subscribe(([previousValue, currentValue]) => {
+                    const change = new NgxsSimpleChange(previousValue, currentValue, !mappedStore.isInitialised);
+                    instance.ngxsOnChanges(change);
+                });
+            }
+            if (instance.ngxsOnInit) {
+                instance.ngxsOnInit(this._getStateContext(mappedStore));
+            }
+            mappedStore.isInitialised = true;
+        }
+    }
+    _invokeBootstrapOnStates(mappedStores) {
+        for (const mappedStore of mappedStores) {
+            const instance = mappedStore.instance;
+            if (instance.ngxsAfterBootstrap) {
+                instance.ngxsAfterBootstrap(this._getStateContext(mappedStore));
+            }
+        }
+    }
+    _getStateContext(mappedStore) {
+        return this._stateContextFactory.createStateContext(mappedStore);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: LifecycleStateManager, deps: [{ token: i1.Store }, { token: i2.InternalStateOperations }, { token: i3.StateContextFactory }, { token: i4.ɵNgxsAppBootstrappedState }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: LifecycleStateManager, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: LifecycleStateManager, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.Store }, { type: i2.InternalStateOperations }, { type: i3.StateContextFactory }, { type: i4.ɵNgxsAppBootstrappedState }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lifecycle-state-manager.js","sourceRoot":"","sources":["../../../../../packages/store/src/internal/lifecycle-state-manager.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, OnDestroy } from '@angular/core';\nimport { ɵNgxsAppBootstrappedState } from '@ngxs/store/internals';\nimport { getValue, InitState, UpdateState } from '@ngxs/store/plugins';\nimport { ReplaySubject } from 'rxjs';\nimport { filter, mergeMap, pairwise, startWith, takeUntil, tap } from 'rxjs/operators';\n\nimport { Store } from '../store';\nimport { StateContextFactory } from './state-context-factory';\nimport { InternalStateOperations } from './state-operations';\nimport { MappedStore, StatesAndDefaults } from './internals';\nimport { NgxsLifeCycle, NgxsSimpleChange, StateContext } from '../symbols';\nimport { getInvalidInitializationOrderMessage } from '../configs/messages.config';\n\nconst NG_DEV_MODE = typeof ngDevMode !== 'undefined' && ngDevMode;\n\n@Injectable({ providedIn: 'root' })\nexport class LifecycleStateManager implements OnDestroy {\n  private readonly _destroy$ = new ReplaySubject<void>(1);\n\n  private _initStateHasBeenDispatched?: boolean;\n\n  constructor(\n    private _store: Store,\n    private _internalStateOperations: InternalStateOperations,\n    private _stateContextFactory: StateContextFactory,\n    private _appBootstrappedState: ɵNgxsAppBootstrappedState\n  ) {}\n\n  ngOnDestroy(): void {\n    this._destroy$.next();\n  }\n\n  ngxsBootstrap(\n    action: InitState | UpdateState,\n    results: StatesAndDefaults | undefined\n  ): void {\n    if (NG_DEV_MODE) {\n      if (action instanceof InitState) {\n        this._initStateHasBeenDispatched = true;\n      } else if (\n        // This is a dev mode-only check that ensures the correct order of\n        // state initialization. The `NgxsModule.forRoot` or `provideStore` should\n        // always come first, followed by `forFeature` and `provideStates`. If the\n        // `UpdateState` is dispatched before the `InitState` is dispatched, it indicates\n        // that modules or providers are in an invalid order.\n        action instanceof UpdateState &&\n        !this._initStateHasBeenDispatched\n      ) {\n        console.error(getInvalidInitializationOrderMessage(action.addedStates));\n      }\n    }\n\n    this._internalStateOperations\n      .getRootStateOperations()\n      .dispatch(action)\n      .pipe(\n        filter(() => !!results),\n        tap(() => this._invokeInitOnStates(results!.states)),\n        mergeMap(() => this._appBootstrappedState),\n        filter(appBootstrapped => !!appBootstrapped),\n        takeUntil(this._destroy$)\n      )\n      .subscribe(() => this._invokeBootstrapOnStates(results!.states));\n  }\n\n  private _invokeInitOnStates(mappedStores: MappedStore[]): void {\n    for (const mappedStore of mappedStores) {\n      const instance: NgxsLifeCycle = mappedStore.instance;\n\n      if (instance.ngxsOnChanges) {\n        this._store\n          .select(state => getValue(state, mappedStore.path))\n          .pipe(startWith(undefined), pairwise(), takeUntil(this._destroy$))\n          .subscribe(([previousValue, currentValue]) => {\n            const change = new NgxsSimpleChange(\n              previousValue,\n              currentValue,\n              !mappedStore.isInitialised\n            );\n            instance.ngxsOnChanges!(change);\n          });\n      }\n\n      if (instance.ngxsOnInit) {\n        instance.ngxsOnInit(this._getStateContext(mappedStore));\n      }\n\n      mappedStore.isInitialised = true;\n    }\n  }\n\n  private _invokeBootstrapOnStates(mappedStores: MappedStore[]) {\n    for (const mappedStore of mappedStores) {\n      const instance: NgxsLifeCycle = mappedStore.instance;\n      if (instance.ngxsAfterBootstrap) {\n        instance.ngxsAfterBootstrap(this._getStateContext(mappedStore));\n      }\n    }\n  }\n\n  private _getStateContext(mappedStore: MappedStore): StateContext<any> {\n    return this._stateContextFactory.createStateContext(mappedStore);\n  }\n}\n"]}

package/esm2022/src/internal/state-context-factory.mjs

@@ -0,0 +1,71 @@
+import { Injectable } from '@angular/core';
+import { getValue, setValue } from '@ngxs/store/plugins';
+import { isStateOperator } from '@ngxs/store/operators';
+import { InternalStateOperations } from '../internal/state-operations';
+import { simplePatch } from './state-operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../internal/state-operations";
+/**
+ * State Context factory class
+ * @ignore
+ */
+export class StateContextFactory {
+    constructor(_internalStateOperations) {
+        this._internalStateOperations = _internalStateOperations;
+    }
+    /**
+     * Create the state context
+     */
+    createStateContext(mappedStore) {
+        const root = this._internalStateOperations.getRootStateOperations();
+        return {
+            getState() {
+                const currentAppState = root.getState();
+                return getState(currentAppState, mappedStore.path);
+            },
+            patchState(val) {
+                const currentAppState = root.getState();
+                const patchOperator = simplePatch(val);
+                setStateFromOperator(root, currentAppState, patchOperator, mappedStore.path);
+            },
+            setState(val) {
+                const currentAppState = root.getState();
+                if (isStateOperator(val)) {
+                    setStateFromOperator(root, currentAppState, val, mappedStore.path);
+                }
+                else {
+                    setStateValue(root, currentAppState, val, mappedStore.path);
+                }
+            },
+            dispatch(actions) {
+                return root.dispatch(actions);
+            }
+        };
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: StateContextFactory, deps: [{ token: i1.InternalStateOperations }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: StateContextFactory, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: StateContextFactory, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.InternalStateOperations }] });
+function setStateValue(root, currentAppState, newValue, path) {
+    const newAppState = setValue(currentAppState, path, newValue);
+    root.setState(newAppState);
+    return newAppState;
+    // In doing this refactoring I noticed that there is a 'bug' where the
+    // application state is returned instead of this state slice.
+    // This has worked this way since the beginning see:
+    // https://github.com/ngxs/store/blame/324c667b4b7debd8eb979006c67ca0ae347d88cd/src/state-factory.ts
+    // This needs to be fixed, but is a 'breaking' change.
+    // I will do this fix in a subsequent PR and we can decide how to handle it.
+}
+function setStateFromOperator(root, currentAppState, stateOperator, path) {
+    const local = getState(currentAppState, path);
+    const newValue = stateOperator(local);
+    return setStateValue(root, currentAppState, newValue, path);
+}
+function getState(currentAppState, path) {
+    return getValue(currentAppState, path);
+}
+//# sourceMappingURL=data:application/json;base64,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