@ngxs/store 3.8.2-dev.master-0fd1fe5 → 3.8.2

package/esm2015/src/internal/state-factory.js

@@ -0,0 +1,288 @@
+import { Injectable, Injector, Optional, SkipSelf, Inject } from '@angular/core';
+import { forkJoin, from, of, throwError, Subject, isObservable } from 'rxjs';
+import { catchError, defaultIfEmpty, filter, map, mergeMap, shareReplay, takeUntil } from 'rxjs/operators';
+import { INITIAL_STATE_TOKEN, memoize } from '@ngxs/store/internals';
+import { META_KEY, NgxsConfig } from '../symbols';
+import { buildGraph, findFullParentPath, isObject, nameToState, propGetter, topologicalSort, getStoreMetadata } from './internals';
+import { getActionTypeFromInstance, getValue, setValue } from '../utils/utils';
+import { ofActionDispatched } from '../operators/of-action';
+import { InternalActions } from '../actions-stream';
+import { InternalDispatchedActionResults } from '../internal/dispatcher';
+import { StateContextFactory } from '../internal/state-context-factory';
+import { ensureStateNameIsUnique, ensureStatesAreDecorated } from '../utils/store-validators';
+import { ensureStateClassIsInjectable } from '../ivy/ivy-enabled-in-dev-mode';
+import { NgxsUnhandledActionsLogger } from '../dev-features/ngxs-unhandled-actions-logger';
+import * as i0 from "@angular/core";
+import * as i1 from "../symbols";
+import * as i2 from "../actions-stream";
+import * as i3 from "../internal/dispatcher";
+import * as i4 from "../internal/state-context-factory";
+const NG_DEV_MODE = typeof ngDevMode === 'undefined' || ngDevMode;
+/**
+ * The `StateFactory` class adds root and feature states to the graph.
+ * This extracts state names from state classes, checks if they already
+ * exist in the global graph, throws errors if their names are invalid, etc.
+ * See its constructor, state factories inject state factories that are
+ * parent-level providers. This is required to get feature states from the
+ * injector on the same level.
+ *
+ * The `NgxsModule.forFeature(...)` returns `providers: [StateFactory, ...states]`.
+ * The `StateFactory` is initialized on the feature level and goes through `...states`
+ * to get them from the injector through `injector.get(state)`.
+ * @ignore
+ */
+export class StateFactory {
+    constructor(_injector, _config, _parentFactory, _actions, _actionResults, _stateContextFactory, _initialState) {
+        this._injector = _injector;
+        this._config = _config;
+        this._parentFactory = _parentFactory;
+        this._actions = _actions;
+        this._actionResults = _actionResults;
+        this._stateContextFactory = _stateContextFactory;
+        this._initialState = _initialState;
+        this._actionsSubscription = null;
+        this._states = [];
+        this._statesByName = {};
+        this._statePaths = {};
+        this.getRuntimeSelectorContext = memoize(() => {
+            // eslint-disable-next-line @typescript-eslint/no-this-alias
+            const stateFactory = this;
+            function resolveGetter(key) {
+                const path = stateFactory.statePaths[key];
+                return path ? propGetter(path.split('.'), stateFactory._config) : null;
+            }
+            const context = this._parentFactory
+                ? this._parentFactory.getRuntimeSelectorContext()
+                : {
+                    getStateGetter(key) {
+                        let getter = resolveGetter(key);
+                        if (getter) {
+                            return getter;
+                        }
+                        return (...args) => {
+                            // Late loaded getter
+                            if (!getter) {
+                                getter = resolveGetter(key);
+                            }
+                            return getter ? getter(...args) : undefined;
+                        };
+                    },
+                    getSelectorOptions(localOptions) {
+                        const globalSelectorOptions = stateFactory._config.selectorOptions;
+                        return Object.assign(Object.assign({}, globalSelectorOptions), (localOptions || {}));
+                    }
+                };
+            return context;
+        });
+    }
+    get states() {
+        return this._parentFactory ? this._parentFactory.states : this._states;
+    }
+    get statesByName() {
+        return this._parentFactory ? this._parentFactory.statesByName : this._statesByName;
+    }
+    get statePaths() {
+        return this._parentFactory ? this._parentFactory.statePaths : this._statePaths;
+    }
+    static _cloneDefaults(defaults) {
+        let value = defaults;
+        if (Array.isArray(defaults)) {
+            value = defaults.slice();
+        }
+        else if (isObject(defaults)) {
+            value = Object.assign({}, defaults);
+        }
+        else if (defaults === undefined) {
+            value = {};
+        }
+        return value;
+    }
+    ngOnDestroy() {
+        var _a;
+        (_a = this._actionsSubscription) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+    }
+    /**
+     * Add a new state to the global defs.
+     */
+    add(stateClasses) {
+        if (NG_DEV_MODE) {
+            ensureStatesAreDecorated(stateClasses);
+        }
+        const { newStates } = this.addToStatesMap(stateClasses);
+        if (!newStates.length)
+            return [];
+        const stateGraph = buildGraph(newStates);
+        const sortedStates = topologicalSort(stateGraph);
+        const paths = findFullParentPath(stateGraph);
+        const nameGraph = nameToState(newStates);
+        const bootstrappedStores = [];
+        for (const name of sortedStates) {
+            const stateClass = nameGraph[name];
+            const path = paths[name];
+            const meta = stateClass[META_KEY];
+            this.addRuntimeInfoToMeta(meta, path);
+            // Note: previously we called `ensureStateClassIsInjectable` within the
+            // `State` decorator. This check is moved here because the `ɵprov` property
+            // will not exist on the class in JIT mode (because it's set asynchronously
+            // during JIT compilation through `Object.defineProperty`).
+            if (NG_DEV_MODE) {
+                ensureStateClassIsInjectable(stateClass);
+            }
+            const stateMap = {
+                name,
+                path,
+                isInitialised: false,
+                actions: meta.actions,
+                instance: this._injector.get(stateClass),
+                defaults: StateFactory._cloneDefaults(meta.defaults)
+            };
+            // ensure our store hasn't already been added
+            // but don't throw since it could be lazy
+            // loaded from different paths
+            if (!this.hasBeenMountedAndBootstrapped(name, path)) {
+                bootstrappedStores.push(stateMap);
+            }
+            this.states.push(stateMap);
+        }
+        return bootstrappedStores;
+    }
+    /**
+     * Add a set of states to the store and return the defaults
+     */
+    addAndReturnDefaults(stateClasses) {
+        const classes = stateClasses || [];
+        const mappedStores = this.add(classes);
+        const defaults = mappedStores.reduce((result, mappedStore) => setValue(result, mappedStore.path, mappedStore.defaults), {});
+        return { defaults, states: mappedStores };
+    }
+    connectActionHandlers() {
+        // Note: We have to connect actions only once when the `StateFactory`
+        //       is being created for the first time. This checks if we're in
+        //       a child state factory and the parent state factory already exists.
+        if (this._parentFactory || this._actionsSubscription !== null) {
+            return;
+        }
+        const dispatched$ = new Subject();
+        this._actionsSubscription = this._actions
+            .pipe(filter((ctx) => ctx.status === "DISPATCHED" /* Dispatched */), mergeMap(ctx => {
+            dispatched$.next(ctx);
+            const action = ctx.action;
+            return this.invokeActions(dispatched$, action).pipe(map(() => ({ action, status: "SUCCESSFUL" /* Successful */ })), defaultIfEmpty({ action, status: "CANCELED" /* Canceled */ }), catchError(error => of({ action, status: "ERRORED" /* Errored */, error })));
+        }))
+            .subscribe(ctx => this._actionResults.next(ctx));
+    }
+    /**
+     * Invoke actions on the states.
+     */
+    invokeActions(dispatched$, action) {
+        const type = getActionTypeFromInstance(action);
+        const results = [];
+        // Determines whether the dispatched action has been handled, this is assigned
+        // to `true` within the below `for` loop if any `actionMetas` has been found.
+        let actionHasBeenHandled = false;
+        for (const metadata of this.states) {
+            const actionMetas = metadata.actions[type];
+            if (actionMetas) {
+                for (const actionMeta of actionMetas) {
+                    const stateContext = this._stateContextFactory.createStateContext(metadata);
+                    try {
+                        let result = metadata.instance[actionMeta.fn](stateContext, action);
+                        if (result instanceof Promise) {
+                            result = from(result);
+                        }
+                        if (isObservable(result)) {
+                            // If this observable has been completed w/o emitting
+                            // any value then we wouldn't want to complete the whole chain
+                            // of actions. Since if any observable completes then
+                            // action will be canceled.
+                            // For instance if any action handler would've had such statement:
+                            // `handler(ctx) { return EMPTY; }`
+                            // then the action will be canceled.
+                            // See https://github.com/ngxs/store/issues/1568
+                            result = result.pipe(mergeMap((value) => {
+                                if (value instanceof Promise) {
+                                    return from(value);
+                                }
+                                if (isObservable(value)) {
+                                    return value;
+                                }
+                                return of(value);
+                            }), defaultIfEmpty({}));
+                            if (actionMeta.options.cancelUncompleted) {
+                                // todo: ofActionDispatched should be used with action class
+                                result = result.pipe(takeUntil(dispatched$.pipe(ofActionDispatched(action))));
+                            }
+                        }
+                        else {
+                            result = of({}).pipe(shareReplay());
+                        }
+                        results.push(result);
+                    }
+                    catch (e) {
+                        results.push(throwError(e));
+                    }
+                    actionHasBeenHandled = true;
+                }
+            }
+        }
+        // The `NgxsUnhandledActionsLogger` is a tree-shakable class which functions
+        // only during development.
+        if (NG_DEV_MODE && !actionHasBeenHandled) {
+            const unhandledActionsLogger = this._injector.get(NgxsUnhandledActionsLogger, null);
+            // The `NgxsUnhandledActionsLogger` will not be resolved by the injector if the
+            // `NgxsDevelopmentModule` is not provided. It's enough to check whether the `injector.get`
+            // didn't return `null` so we may ensure the module has been imported.
+            if (unhandledActionsLogger) {
+                unhandledActionsLogger.warn(action);
+            }
+        }
+        if (!results.length) {
+            results.push(of({}));
+        }
+        return forkJoin(results);
+    }
+    addToStatesMap(stateClasses) {
+        const newStates = [];
+        const statesMap = this.statesByName;
+        for (const stateClass of stateClasses) {
+            const stateName = getStoreMetadata(stateClass).name;
+            if (NG_DEV_MODE) {
+                ensureStateNameIsUnique(stateName, stateClass, statesMap);
+            }
+            const unmountedState = !statesMap[stateName];
+            if (unmountedState) {
+                newStates.push(stateClass);
+                statesMap[stateName] = stateClass;
+            }
+        }
+        return { newStates };
+    }
+    addRuntimeInfoToMeta(meta, path) {
+        this.statePaths[meta.name] = path;
+        // TODO: v4 - we plan to get rid of the path property because it is non-deterministic
+        // we can do this when we get rid of the incorrectly exposed getStoreMetadata
+        // We will need to come up with an alternative in v4 because this is used by many plugins
+        meta.path = path;
+    }
+    hasBeenMountedAndBootstrapped(name, path) {
+        const valueIsBootstrappedInInitialState = getValue(this._initialState, path) !== undefined;
+        // This checks whether a state has been already added to the global graph and
+        // its lifecycle is in 'bootstrapped' state.
+        return this.statesByName[name] && valueIsBootstrappedInInitialState;
+    }
+}
+/** @nocollapse */ StateFactory.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: StateFactory, deps: [{ token: i0.Injector }, { token: i1.NgxsConfig }, { token: StateFactory, optional: true, skipSelf: true }, { token: i2.InternalActions }, { token: i3.InternalDispatchedActionResults }, { token: i4.StateContextFactory }, { token: INITIAL_STATE_TOKEN, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ StateFactory.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: StateFactory });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: StateFactory, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.Injector }, { type: i1.NgxsConfig }, { type: StateFactory, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }, { type: i2.InternalActions }, { type: i3.InternalDispatchedActionResults }, { type: i4.StateContextFactory }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [INITIAL_STATE_TOKEN]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"state-factory.js","sourceRoot":"","sources":["../../../../../packages/store/src/internal/state-factory.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Injector, Optional, SkipSelf, Inject, OnDestroy } from '@angular/core';\nimport {\n  forkJoin,\n  from,\n  Observable,\n  of,\n  throwError,\n  Subscription,\n  Subject,\n  isObservable\n} from 'rxjs';\nimport {\n  catchError,\n  defaultIfEmpty,\n  filter,\n  map,\n  mergeMap,\n  shareReplay,\n  takeUntil\n} from 'rxjs/operators';\nimport { INITIAL_STATE_TOKEN, PlainObjectOf, memoize } from '@ngxs/store/internals';\n\nimport { META_KEY, NgxsConfig } from '../symbols';\nimport {\n  buildGraph,\n  findFullParentPath,\n  isObject,\n  MappedStore,\n  MetaDataModel,\n  nameToState,\n  propGetter,\n  StateClassInternal,\n  StateKeyGraph,\n  StatesAndDefaults,\n  StatesByName,\n  topologicalSort,\n  RuntimeSelectorContext,\n  SharedSelectorOptions,\n  getStoreMetadata\n} from './internals';\nimport { getActionTypeFromInstance, getValue, setValue } from '../utils/utils';\nimport { ofActionDispatched } from '../operators/of-action';\nimport { ActionContext, ActionStatus, InternalActions } from '../actions-stream';\nimport { InternalDispatchedActionResults } from '../internal/dispatcher';\nimport { StateContextFactory } from '../internal/state-context-factory';\nimport { ensureStateNameIsUnique, ensureStatesAreDecorated } from '../utils/store-validators';\nimport { ensureStateClassIsInjectable } from '../ivy/ivy-enabled-in-dev-mode';\nimport { NgxsUnhandledActionsLogger } from '../dev-features/ngxs-unhandled-actions-logger';\n\nconst NG_DEV_MODE = typeof ngDevMode === 'undefined' || ngDevMode;\n\n/**\n * The `StateFactory` class adds root and feature states to the graph.\n * This extracts state names from state classes, checks if they already\n * exist in the global graph, throws errors if their names are invalid, etc.\n * See its constructor, state factories inject state factories that are\n * parent-level providers. This is required to get feature states from the\n * injector on the same level.\n *\n * The `NgxsModule.forFeature(...)` returns `providers: [StateFactory, ...states]`.\n * The `StateFactory` is initialized on the feature level and goes through `...states`\n * to get them from the injector through `injector.get(state)`.\n * @ignore\n */\n@Injectable()\nexport class StateFactory implements OnDestroy {\n  private _actionsSubscription: Subscription | null = null;\n\n  constructor(\n    private _injector: Injector,\n    private _config: NgxsConfig,\n    @Optional()\n    @SkipSelf()\n    private _parentFactory: StateFactory,\n    private _actions: InternalActions,\n    private _actionResults: InternalDispatchedActionResults,\n    private _stateContextFactory: StateContextFactory,\n    @Optional()\n    @Inject(INITIAL_STATE_TOKEN)\n    private _initialState: any\n  ) {}\n\n  private _states: MappedStore[] = [];\n\n  get states(): MappedStore[] {\n    return this._parentFactory ? this._parentFactory.states : this._states;\n  }\n\n  private _statesByName: StatesByName = {};\n\n  get statesByName(): StatesByName {\n    return this._parentFactory ? this._parentFactory.statesByName : this._statesByName;\n  }\n\n  private _statePaths: PlainObjectOf<string> = {};\n\n  private get statePaths(): PlainObjectOf<string> {\n    return this._parentFactory ? this._parentFactory.statePaths : this._statePaths;\n  }\n\n  getRuntimeSelectorContext = memoize(() => {\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    const stateFactory = this;\n\n    function resolveGetter(key: string) {\n      const path = stateFactory.statePaths[key];\n      return path ? propGetter(path.split('.'), stateFactory._config) : null;\n    }\n\n    const context: RuntimeSelectorContext = this._parentFactory\n      ? this._parentFactory.getRuntimeSelectorContext()\n      : {\n          getStateGetter(key: string) {\n            let getter = resolveGetter(key);\n            if (getter) {\n              return getter;\n            }\n            return (...args) => {\n              // Late loaded getter\n              if (!getter) {\n                getter = resolveGetter(key);\n              }\n              return getter ? getter(...args) : undefined;\n            };\n          },\n          getSelectorOptions(localOptions?: SharedSelectorOptions) {\n            const globalSelectorOptions = stateFactory._config.selectorOptions;\n            return {\n              ...globalSelectorOptions,\n              ...(localOptions || {})\n            };\n          }\n        };\n    return context;\n  });\n\n  private static _cloneDefaults(defaults: any): any {\n    let value = defaults;\n\n    if (Array.isArray(defaults)) {\n      value = defaults.slice();\n    } else if (isObject(defaults)) {\n      value = { ...defaults };\n    } else if (defaults === undefined) {\n      value = {};\n    }\n\n    return value;\n  }\n\n  ngOnDestroy(): void {\n    this._actionsSubscription?.unsubscribe();\n  }\n\n  /**\n   * Add a new state to the global defs.\n   */\n  add(stateClasses: StateClassInternal[]): MappedStore[] {\n    if (NG_DEV_MODE) {\n      ensureStatesAreDecorated(stateClasses);\n    }\n\n    const { newStates } = this.addToStatesMap(stateClasses);\n    if (!newStates.length) return [];\n\n    const stateGraph: StateKeyGraph = buildGraph(newStates);\n    const sortedStates: string[] = topologicalSort(stateGraph);\n    const paths: PlainObjectOf<string> = findFullParentPath(stateGraph);\n    const nameGraph: PlainObjectOf<StateClassInternal> = nameToState(newStates);\n    const bootstrappedStores: MappedStore[] = [];\n\n    for (const name of sortedStates) {\n      const stateClass: StateClassInternal = nameGraph[name];\n      const path: string = paths[name];\n      const meta: MetaDataModel = stateClass[META_KEY]!;\n\n      this.addRuntimeInfoToMeta(meta, path);\n\n      // Note: previously we called `ensureStateClassIsInjectable` within the\n      // `State` decorator. This check is moved here because the `ɵprov` property\n      // will not exist on the class in JIT mode (because it's set asynchronously\n      // during JIT compilation through `Object.defineProperty`).\n      if (NG_DEV_MODE) {\n        ensureStateClassIsInjectable(stateClass);\n      }\n\n      const stateMap: MappedStore = {\n        name,\n        path,\n        isInitialised: false,\n        actions: meta.actions,\n        instance: this._injector.get(stateClass),\n        defaults: StateFactory._cloneDefaults(meta.defaults)\n      };\n\n      // ensure our store hasn't already been added\n      // but don't throw since it could be lazy\n      // loaded from different paths\n      if (!this.hasBeenMountedAndBootstrapped(name, path)) {\n        bootstrappedStores.push(stateMap);\n      }\n\n      this.states.push(stateMap);\n    }\n\n    return bootstrappedStores;\n  }\n\n  /**\n   * Add a set of states to the store and return the defaults\n   */\n  addAndReturnDefaults(stateClasses: StateClassInternal[]): StatesAndDefaults {\n    const classes: StateClassInternal[] = stateClasses || [];\n\n    const mappedStores: MappedStore[] = this.add(classes);\n    const defaults = mappedStores.reduce(\n      (result: any, mappedStore: MappedStore) =>\n        setValue(result, mappedStore.path, mappedStore.defaults),\n      {}\n    );\n    return { defaults, states: mappedStores };\n  }\n\n  connectActionHandlers(): void {\n    // Note: We have to connect actions only once when the `StateFactory`\n    //       is being created for the first time. This checks if we're in\n    //       a child state factory and the parent state factory already exists.\n    if (this._parentFactory || this._actionsSubscription !== null) {\n      return;\n    }\n\n    const dispatched$ = new Subject<ActionContext>();\n    this._actionsSubscription = this._actions\n      .pipe(\n        filter((ctx: ActionContext) => ctx.status === ActionStatus.Dispatched),\n        mergeMap(ctx => {\n          dispatched$.next(ctx);\n          const action = ctx.action;\n          return this.invokeActions(dispatched$, action!).pipe(\n            map(() => <ActionContext>{ action, status: ActionStatus.Successful }),\n            defaultIfEmpty(<ActionContext>{ action, status: ActionStatus.Canceled }),\n            catchError(error =>\n              of(<ActionContext>{ action, status: ActionStatus.Errored, error })\n            )\n          );\n        })\n      )\n      .subscribe(ctx => this._actionResults.next(ctx));\n  }\n\n  /**\n   * Invoke actions on the states.\n   */\n  invokeActions(dispatched$: Observable<ActionContext>, action: any) {\n    const type = getActionTypeFromInstance(action)!;\n    const results = [];\n\n    // Determines whether the dispatched action has been handled, this is assigned\n    // to `true` within the below `for` loop if any `actionMetas` has been found.\n    let actionHasBeenHandled = false;\n\n    for (const metadata of this.states) {\n      const actionMetas = metadata.actions[type];\n\n      if (actionMetas) {\n        for (const actionMeta of actionMetas) {\n          const stateContext = this._stateContextFactory.createStateContext(metadata);\n          try {\n            let result = metadata.instance[actionMeta.fn](stateContext, action);\n\n            if (result instanceof Promise) {\n              result = from(result);\n            }\n\n            if (isObservable(result)) {\n              // If this observable has been completed w/o emitting\n              // any value then we wouldn't want to complete the whole chain\n              // of actions. Since if any observable completes then\n              // action will be canceled.\n              // For instance if any action handler would've had such statement:\n              // `handler(ctx) { return EMPTY; }`\n              // then the action will be canceled.\n              // See https://github.com/ngxs/store/issues/1568\n              result = result.pipe(\n                mergeMap((value: any) => {\n                  if (value instanceof Promise) {\n                    return from(value);\n                  }\n                  if (isObservable(value)) {\n                    return value;\n                  }\n                  return of(value);\n                }),\n                defaultIfEmpty({})\n              );\n\n              if (actionMeta.options.cancelUncompleted) {\n                // todo: ofActionDispatched should be used with action class\n                result = result.pipe(\n                  takeUntil(dispatched$.pipe(ofActionDispatched(action as any)))\n                );\n              }\n            } else {\n              result = of({}).pipe(shareReplay());\n            }\n\n            results.push(result);\n          } catch (e) {\n            results.push(throwError(e));\n          }\n\n          actionHasBeenHandled = true;\n        }\n      }\n    }\n\n    // The `NgxsUnhandledActionsLogger` is a tree-shakable class which functions\n    // only during development.\n    if (NG_DEV_MODE && !actionHasBeenHandled) {\n      const unhandledActionsLogger = this._injector.get(NgxsUnhandledActionsLogger, null);\n      // The `NgxsUnhandledActionsLogger` will not be resolved by the injector if the\n      // `NgxsDevelopmentModule` is not provided. It's enough to check whether the `injector.get`\n      // didn't return `null` so we may ensure the module has been imported.\n      if (unhandledActionsLogger) {\n        unhandledActionsLogger.warn(action);\n      }\n    }\n\n    if (!results.length) {\n      results.push(of({}));\n    }\n\n    return forkJoin(results);\n  }\n\n  private addToStatesMap(stateClasses: StateClassInternal[]): {\n    newStates: StateClassInternal[];\n  } {\n    const newStates: StateClassInternal[] = [];\n    const statesMap: StatesByName = this.statesByName;\n\n    for (const stateClass of stateClasses) {\n      const stateName = getStoreMetadata(stateClass).name!;\n      if (NG_DEV_MODE) {\n        ensureStateNameIsUnique(stateName, stateClass, statesMap);\n      }\n      const unmountedState = !statesMap[stateName];\n      if (unmountedState) {\n        newStates.push(stateClass);\n        statesMap[stateName] = stateClass;\n      }\n    }\n\n    return { newStates };\n  }\n\n  private addRuntimeInfoToMeta(meta: MetaDataModel, path: string): void {\n    this.statePaths[meta.name!] = path;\n    // TODO: v4 - we plan to get rid of the path property because it is non-deterministic\n    // we can do this when we get rid of the incorrectly exposed getStoreMetadata\n    // We will need to come up with an alternative in v4 because this is used by many plugins\n    meta.path = path;\n  }\n\n  private hasBeenMountedAndBootstrapped(name: string, path: string): boolean {\n    const valueIsBootstrappedInInitialState: boolean =\n      getValue(this._initialState, path) !== undefined;\n    // This checks whether a state has been already added to the global graph and\n    // its lifecycle is in 'bootstrapped' state.\n    return this.statesByName[name] && valueIsBootstrappedInInitialState;\n  }\n}\n"]}

package/{esm2020/src/internal/state-operations.mjs → esm2015/src/internal/state-operations.js}

@@ -39,12 +39,12 @@ export class InternalStateOperations {
         // Get our current stream
         const currentState = stateOperations.getState();
         // Set the state to the current + new
-        stateOperations.setState({ ...currentState, ...results.defaults });
+        stateOperations.setState(Object.assign(Object.assign({}, currentState), results.defaults));
     }
 }
-/** @nocollapse */ InternalStateOperations.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.4", ngImport: i0, type: InternalStateOperations, deps: [{ token: i1.StateStream }, { token: i2.InternalDispatcher }, { token: i3.NgxsConfig }], target: i0.ɵɵFactoryTarget.Injectable });
-/** @nocollapse */ InternalStateOperations.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.4", ngImport: i0, type: InternalStateOperations, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.4", ngImport: i0, type: InternalStateOperations, decorators: [{
+/** @nocollapse */ InternalStateOperations.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalStateOperations, deps: [{ token: i1.StateStream }, { token: i2.InternalDispatcher }, { token: i3.NgxsConfig }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ InternalStateOperations.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalStateOperations, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalStateOperations, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: function () { return [{ type: i1.StateStream }, { type: i2.InternalDispatcher }, { type: i3.NgxsConfig }]; } });
@@ -60,4 +60,4 @@ function ensureStateAndActionsAreImmutable(root) {
         }
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/src/internal/state-operators.js

@@ -0,0 +1,20 @@
+import { throwPatchingArrayError, throwPatchingPrimitiveError } from '../configs/messages.config';
+export function simplePatch(value) {
+    return (existingState) => {
+        if (typeof ngDevMode === 'undefined' || ngDevMode) {
+            if (Array.isArray(value)) {
+                throwPatchingArrayError();
+            }
+            else if (typeof value !== 'object') {
+                throwPatchingPrimitiveError();
+            }
+        }
+        const newState = Object.assign({}, existingState);
+        for (const key in value) {
+            // deep clone for patch compatibility
+            newState[key] = value[key];
+        }
+        return newState;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhdGUtb3BlcmF0b3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvc3RvcmUvc3JjL2ludGVybmFsL3N0YXRlLW9wZXJhdG9ycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsdUJBQXVCLEVBQ3ZCLDJCQUEyQixFQUM1QixNQUFNLDRCQUE0QixDQUFDO0FBR3BDLE1BQU0sVUFBVSxXQUFXLENBQUksS0FBaUI7SUFDOUMsT0FBTyxDQUFDLGFBQStCLEVBQUUsRUFBRTtRQUN6QyxJQUFJLE9BQU8sU0FBUyxLQUFLLFdBQVcsSUFBSSxTQUFTLEVBQUU7WUFDakQsSUFBSSxLQUFLLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxFQUFFO2dCQUN4Qix1QkFBdUIsRUFBRSxDQUFDO2FBQzNCO2lCQUFNLElBQUksT0FBTyxLQUFLLEtBQUssUUFBUSxFQUFFO2dCQUNwQywyQkFBMkIsRUFBRSxDQUFDO2FBQy9CO1NBQ0Y7UUFFRCxNQUFNLFFBQVEscUJBQWMsYUFBcUIsQ0FBRSxDQUFDO1FBQ3BELEtBQUssTUFBTSxHQUFHLElBQUksS0FBSyxFQUFFO1lBQ3ZCLHFDQUFxQztZQUNyQyxRQUFRLENBQUMsR0FBRyxDQUFDLEdBQUksS0FBYSxDQUFDLEdBQUcsQ0FBQyxDQUFDO1NBQ3JDO1FBRUQsT0FBTyxRQUFhLENBQUM7SUFDdkIsQ0FBQyxDQUFDO0FBQ0osQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XG4gIHRocm93UGF0Y2hpbmdBcnJheUVycm9yLFxuICB0aHJvd1BhdGNoaW5nUHJpbWl0aXZlRXJyb3Jcbn0gZnJvbSAnLi4vY29uZmlncy9tZXNzYWdlcy5jb25maWcnO1xuaW1wb3J0IHsgRXhpc3RpbmdTdGF0ZSwgU3RhdGVPcGVyYXRvciB9IGZyb20gJ0BuZ3hzL3N0b3JlL29wZXJhdG9ycyc7XG5cbmV4cG9ydCBmdW5jdGlvbiBzaW1wbGVQYXRjaDxUPih2YWx1ZTogUGFydGlhbDxUPik6IFN0YXRlT3BlcmF0b3I8VD4ge1xuICByZXR1cm4gKGV4aXN0aW5nU3RhdGU6IEV4aXN0aW5nU3RhdGU8VD4pID0+IHtcbiAgICBpZiAodHlwZW9mIG5nRGV2TW9kZSA9PT0gJ3VuZGVmaW5lZCcgfHwgbmdEZXZNb2RlKSB7XG4gICAgICBpZiAoQXJyYXkuaXNBcnJheSh2YWx1ZSkpIHtcbiAgICAgICAgdGhyb3dQYXRjaGluZ0FycmF5RXJyb3IoKTtcbiAgICAgIH0gZWxzZSBpZiAodHlwZW9mIHZhbHVlICE9PSAnb2JqZWN0Jykge1xuICAgICAgICB0aHJvd1BhdGNoaW5nUHJpbWl0aXZlRXJyb3IoKTtcbiAgICAgIH1cbiAgICB9XG5cbiAgICBjb25zdCBuZXdTdGF0ZTogYW55ID0geyAuLi4oZXhpc3RpbmdTdGF0ZSBhcyBhbnkpIH07XG4gICAgZm9yIChjb25zdCBrZXkgaW4gdmFsdWUpIHtcbiAgICAgIC8vIGRlZXAgY2xvbmUgZm9yIHBhdGNoIGNvbXBhdGliaWxpdHlcbiAgICAgIG5ld1N0YXRlW2tleV0gPSAodmFsdWUgYXMgYW55KVtrZXldO1xuICAgIH1cblxuICAgIHJldHVybiBuZXdTdGF0ZSBhcyBUO1xuICB9O1xufVxuIl19

package/esm2015/src/internal/state-stream.js

@@ -0,0 +1,25 @@
+import { Injectable } from '@angular/core';
+import { OrderedBehaviorSubject } from './custom-rxjs-subjects';
+import * as i0 from "@angular/core";
+/**
+ * BehaviorSubject of the entire state.
+ * @ignore
+ */
+export class StateStream extends OrderedBehaviorSubject {
+    constructor() {
+        super({});
+    }
+    ngOnDestroy() {
+        // The `StateStream` should never emit values once the root view is removed, e.g. when the `NgModuleRef.destroy()` is called.
+        // This will eliminate memory leaks in server-side rendered apps where the `StateStream` is created per each HTTP request, users
+        // might forget to unsubscribe from `store.select` or `store.subscribe`, thus this will lead to huge memory leaks in SSR apps.
+        this.complete();
+    }
+}
+/** @nocollapse */ StateStream.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: StateStream, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ StateStream.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: StateStream, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: StateStream, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhdGUtc3RyZWFtLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvc3RvcmUvc3JjL2ludGVybmFsL3N0YXRlLXN0cmVhbS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFhLE1BQU0sZUFBZSxDQUFDO0FBSXRELE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLHdCQUF3QixDQUFDOztBQUVoRTs7O0dBR0c7QUFFSCxNQUFNLE9BQU8sV0FBWSxTQUFRLHNCQUFtQztJQUNsRTtRQUNFLEtBQUssQ0FBQyxFQUFFLENBQUMsQ0FBQztJQUNaLENBQUM7SUFFRCxXQUFXO1FBQ1QsNkhBQTZIO1FBQzdILGdJQUFnSTtRQUNoSSw4SEFBOEg7UUFDOUgsSUFBSSxDQUFDLFFBQVEsRUFBRSxDQUFDO0lBQ2xCLENBQUM7OzRIQVZVLFdBQVc7Z0lBQVgsV0FBVyxjQURFLE1BQU07NEZBQ25CLFdBQVc7a0JBRHZCLFVBQVU7bUJBQUMsRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSwgT25EZXN0cm95IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IFBsYWluT2JqZWN0IH0gZnJvbSAnQG5neHMvc3RvcmUvaW50ZXJuYWxzJztcblxuaW1wb3J0IHsgT3JkZXJlZEJlaGF2aW9yU3ViamVjdCB9IGZyb20gJy4vY3VzdG9tLXJ4anMtc3ViamVjdHMnO1xuXG4vKipcbiAqIEJlaGF2aW9yU3ViamVjdCBvZiB0aGUgZW50aXJlIHN0YXRlLlxuICogQGlnbm9yZVxuICovXG5ASW5qZWN0YWJsZSh7IHByb3ZpZGVkSW46ICdyb290JyB9KVxuZXhwb3J0IGNsYXNzIFN0YXRlU3RyZWFtIGV4dGVuZHMgT3JkZXJlZEJlaGF2aW9yU3ViamVjdDxQbGFpbk9iamVjdD4gaW1wbGVtZW50cyBPbkRlc3Ryb3kge1xuICBjb25zdHJ1Y3RvcigpIHtcbiAgICBzdXBlcih7fSk7XG4gIH1cblxuICBuZ09uRGVzdHJveSgpOiB2b2lkIHtcbiAgICAvLyBUaGUgYFN0YXRlU3RyZWFtYCBzaG91bGQgbmV2ZXIgZW1pdCB2YWx1ZXMgb25jZSB0aGUgcm9vdCB2aWV3IGlzIHJlbW92ZWQsIGUuZy4gd2hlbiB0aGUgYE5nTW9kdWxlUmVmLmRlc3Ryb3koKWAgaXMgY2FsbGVkLlxuICAgIC8vIFRoaXMgd2lsbCBlbGltaW5hdGUgbWVtb3J5IGxlYWtzIGluIHNlcnZlci1zaWRlIHJlbmRlcmVkIGFwcHMgd2hlcmUgdGhlIGBTdGF0ZVN0cmVhbWAgaXMgY3JlYXRlZCBwZXIgZWFjaCBIVFRQIHJlcXVlc3QsIHVzZXJzXG4gICAgLy8gbWlnaHQgZm9yZ2V0IHRvIHVuc3Vic2NyaWJlIGZyb20gYHN0b3JlLnNlbGVjdGAgb3IgYHN0b3JlLnN1YnNjcmliZWAsIHRodXMgdGhpcyB3aWxsIGxlYWQgdG8gaHVnZSBtZW1vcnkgbGVha3MgaW4gU1NSIGFwcHMuXG4gICAgdGhpcy5jb21wbGV0ZSgpO1xuICB9XG59XG4iXX0=

package/{esm2020/src/ivy/ivy-enabled-in-dev-mode.mjs → esm2015/src/ivy/ivy-enabled-in-dev-mode.js}

@@ -20,6 +20,6 @@ function aot_hasNgInjectableDef(stateClass) {
 function jit_hasInjectableAnnotation(stateClass) {
     // `ɵprov` doesn't exist in JIT mode (for instance when running unit tests with Jest).
     const annotations = stateClass.__annotations__ || [];
-    return annotations.some((annotation) => annotation?.ngMetadataName === 'Injectable');
+    return annotations.some((annotation) => (annotation === null || annotation === void 0 ? void 0 : annotation.ngMetadataName) === 'Injectable');
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/src/module.js

@@ -0,0 +1,88 @@
+import { APP_BOOTSTRAP_LISTENER, NgModule } from '@angular/core';
+import { ɵNGXS_STATE_FACTORY, ɵNGXS_STATE_CONTEXT_FACTORY, NgxsBootstrapper } from '@ngxs/store/internals';
+import { FEATURE_STATE_TOKEN, ROOT_OPTIONS, ROOT_STATE_TOKEN } from './symbols';
+import { USER_PROVIDED_NGXS_EXECUTION_STRATEGY } from './execution/symbols';
+import { StateFactory } from './internal/state-factory';
+import { StateContextFactory } from './internal/state-context-factory';
+import { PluginManager } from './plugin-manager';
+import { NgxsRootModule } from './modules/ngxs-root.module';
+import { NgxsFeatureModule } from './modules/ngxs-feature.module';
+import * as i0 from "@angular/core";
+/**
+ * Ngxs Module
+ */
+export class NgxsModule {
+    /**
+     * Root module factory
+     */
+    static forRoot(states = [], options = {}) {
+        return {
+            ngModule: NgxsRootModule,
+            providers: [
+                StateFactory,
+                PluginManager,
+                ...states,
+                ...NgxsModule.ngxsTokenProviders(states, options)
+            ]
+        };
+    }
+    /**
+     * Feature module factory
+     */
+    static forFeature(states = []) {
+        return {
+            ngModule: NgxsFeatureModule,
+            providers: [
+                // This is required on the feature level, see comments in `state-factory.ts`.
+                StateFactory,
+                PluginManager,
+                ...states,
+                {
+                    provide: FEATURE_STATE_TOKEN,
+                    multi: true,
+                    useValue: states
+                }
+            ]
+        };
+    }
+    static ngxsTokenProviders(states, options) {
+        return [
+            {
+                provide: USER_PROVIDED_NGXS_EXECUTION_STRATEGY,
+                useValue: options.executionStrategy
+            },
+            {
+                provide: ROOT_STATE_TOKEN,
+                useValue: states
+            },
+            {
+                provide: ROOT_OPTIONS,
+                useValue: options
+            },
+            {
+                provide: APP_BOOTSTRAP_LISTENER,
+                useFactory: NgxsModule.appBootstrapListenerFactory,
+                multi: true,
+                deps: [NgxsBootstrapper]
+            },
+            {
+                provide: ɵNGXS_STATE_CONTEXT_FACTORY,
+                useExisting: StateContextFactory
+            },
+            {
+                provide: ɵNGXS_STATE_FACTORY,
+                useExisting: StateFactory
+            }
+        ];
+    }
+    static appBootstrapListenerFactory(bootstrapper) {
+        return () => bootstrapper.bootstrap();
+    }
+}
+/** @nocollapse */ NgxsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ NgxsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsModule });
+/** @nocollapse */ NgxsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsModule, decorators: [{
+            type: NgModule
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/src/modules/ngxs-feature.module.js

@@ -0,0 +1,45 @@
+import { Inject, NgModule, Optional } from '@angular/core';
+import { Store } from '../store';
+import { InternalStateOperations } from '../internal/state-operations';
+import { StateFactory } from '../internal/state-factory';
+import { FEATURE_STATE_TOKEN } from '../symbols';
+import { LifecycleStateManager } from '../internal/lifecycle-state-manager';
+import { UpdateState } from '../actions/actions';
+import * as i0 from "@angular/core";
+import * as i1 from "../store";
+import * as i2 from "../internal/state-operations";
+import * as i3 from "../internal/state-factory";
+import * as i4 from "../internal/lifecycle-state-manager";
+/**
+ * Feature module
+ * @ignore
+ */
+export class NgxsFeatureModule {
+    constructor(_store, internalStateOperations, factory, states = [], lifecycleStateManager) {
+        // Since FEATURE_STATE_TOKEN is a multi token, we need to
+        // flatten it [[Feature1State, Feature2State], [Feature3State]]
+        const flattenedStates = NgxsFeatureModule.flattenStates(states);
+        // add stores to the state graph and return their defaults
+        const results = factory.addAndReturnDefaults(flattenedStates);
+        if (results.states.length) {
+            internalStateOperations.setStateToTheCurrentWithNew(results);
+            // dispatch the update action and invoke init and bootstrap functions after
+            lifecycleStateManager.ngxsBootstrap(new UpdateState(results.defaults), results);
+        }
+    }
+    static flattenStates(states = []) {
+        return states.reduce((total, values) => total.concat(values), []);
+    }
+}
+/** @nocollapse */ NgxsFeatureModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsFeatureModule, deps: [{ token: i1.Store }, { token: i2.InternalStateOperations }, { token: i3.StateFactory }, { token: FEATURE_STATE_TOKEN, optional: true }, { token: i4.LifecycleStateManager }], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ NgxsFeatureModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsFeatureModule });
+/** @nocollapse */ NgxsFeatureModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsFeatureModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsFeatureModule, decorators: [{
+            type: NgModule
+        }], ctorParameters: function () { return [{ type: i1.Store }, { type: i2.InternalStateOperations }, { type: i3.StateFactory }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [FEATURE_STATE_TOKEN]
+                }] }, { type: i4.LifecycleStateManager }]; } });
+//# sourceMappingURL=data:application/json;base64,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