@ngxs/store 3.6.2-dev.master-8e14fe1 → 3.7.0

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

@@ -1,392 +1,401 @@
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-import { Injectable, Injector, Optional, SkipSelf, Inject } from '@angular/core';
-import { forkJoin, from, Observable, of, throwError } from 'rxjs';
-import { catchError, defaultIfEmpty, filter, map, mergeMap, shareReplay, takeUntil } from 'rxjs/operators';
-import { META_KEY, NgxsConfig } from '../symbols';
-import { buildGraph, findFullParentPath, isObject, nameToState, propGetter, topologicalSort } 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 { StoreValidators } from '../utils/store-validators';
-import { INITIAL_STATE_TOKEN, memoize } from '@ngxs/store/internals';
-/**
- * State factory class
- * @ignore
- */
-export class StateFactory {
-    /**
-     * @param {?} _injector
-     * @param {?} _config
-     * @param {?} _parentFactory
-     * @param {?} _actions
-     * @param {?} _actionResults
-     * @param {?} _stateContextFactory
-     * @param {?} _initialState
-     */
-    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._connected = false;
-        this._states = [];
-        this._statesByName = {};
-        this._statePaths = {};
-        this.getRuntimeSelectorContext = memoize((/**
-         * @return {?}
-         */
-        () => {
-            /** @type {?} */
-            const stateFactory = this;
-            /** @type {?} */
-            const context = this._parentFactory
-                ? this._parentFactory.getRuntimeSelectorContext()
-                : {
-                    /**
-                     * @param {?} key
-                     * @return {?}
-                     */
-                    getStateGetter(key) {
-                        /** @type {?} */
-                        const path = stateFactory.statePaths[key];
-                        return path ? propGetter(path.split('.'), stateFactory._config) : (/**
-                         * @return {?}
-                         */
-                        () => undefined);
-                    },
-                    /**
-                     * @param {?=} localOptions
-                     * @return {?}
-                     */
-                    getSelectorOptions(localOptions) {
-                        /** @type {?} */
-                        const globalSelectorOptions = stateFactory._config.selectorOptions;
-                        return Object.assign({}, globalSelectorOptions, (localOptions || {}));
-                    }
-                };
-            return context;
-        }));
-    }
-    /**
-     * @return {?}
-     */
-    get states() {
-        return this._parentFactory ? this._parentFactory.states : this._states;
-    }
-    /**
-     * @return {?}
-     */
-    get statesByName() {
-        return this._parentFactory ? this._parentFactory.statesByName : this._statesByName;
-    }
-    /**
-     * @private
-     * @return {?}
-     */
-    get statePaths() {
-        return this._parentFactory ? this._parentFactory.statePaths : this._statePaths;
-    }
-    /**
-     * @private
-     * @param {?} defaults
-     * @return {?}
-     */
-    static cloneDefaults(defaults) {
-        /** @type {?} */
-        let value = {};
-        if (Array.isArray(defaults)) {
-            value = defaults.slice();
-        }
-        else if (isObject(defaults)) {
-            value = Object.assign({}, defaults);
-        }
-        else if (defaults === undefined) {
-            value = {};
-        }
-        else {
-            value = defaults;
-        }
-        return value;
-    }
-    /**
-     * @private
-     * @param {?} stateClasses
-     * @return {?}
-     */
-    static checkStatesAreValid(stateClasses) {
-        stateClasses.forEach(StoreValidators.getValidStateMeta);
-    }
-    /**
-     * Add a new state to the global defs.
-     * @param {?} stateClasses
-     * @return {?}
-     */
-    add(stateClasses) {
-        StateFactory.checkStatesAreValid(stateClasses);
-        const { newStates } = this.addToStatesMap(stateClasses);
-        if (!newStates.length)
-            return [];
-        /** @type {?} */
-        const stateGraph = buildGraph(newStates);
-        /** @type {?} */
-        const sortedStates = topologicalSort(stateGraph);
-        /** @type {?} */
-        const paths = findFullParentPath(stateGraph);
-        /** @type {?} */
-        const nameGraph = nameToState(newStates);
-        /** @type {?} */
-        const bootstrappedStores = [];
-        for (const name of sortedStates) {
-            /** @type {?} */
-            const stateClass = nameGraph[name];
-            /** @type {?} */
-            const path = paths[name];
-            /** @type {?} */
-            const meta = (/** @type {?} */ (stateClass[META_KEY]));
-            this.addRuntimeInfoToMeta(meta, path);
-            /** @type {?} */
-            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
-     * @param {?} stateClasses
-     * @return {?}
-     */
-    addAndReturnDefaults(stateClasses) {
-        /** @type {?} */
-        const classes = stateClasses || [];
-        /** @type {?} */
-        const mappedStores = this.add(classes);
-        /** @type {?} */
-        const defaults = mappedStores.reduce((/**
-         * @param {?} result
-         * @param {?} mappedStore
-         * @return {?}
-         */
-        (result, mappedStore) => setValue(result, mappedStore.path, mappedStore.defaults)), {});
-        return { defaults, states: mappedStores };
-    }
-    /**
-     * Bind the actions to the handlers
-     * @return {?}
-     */
-    connectActionHandlers() {
-        if (this._connected)
-            return;
-        this._actions
-            .pipe(filter((/**
-         * @param {?} ctx
-         * @return {?}
-         */
-        (ctx) => ctx.status === "DISPATCHED" /* Dispatched */)), mergeMap((/**
-         * @param {?} __0
-         * @return {?}
-         */
-        ({ action }) => this.invokeActions(this._actions, (/** @type {?} */ (action))).pipe(map((/**
-         * @return {?}
-         */
-        () => (/** @type {?} */ ({ action, status: "SUCCESSFUL" /* Successful */ })))), defaultIfEmpty((/** @type {?} */ ({ action, status: "CANCELED" /* Canceled */ }))), catchError((/**
-         * @param {?} error
-         * @return {?}
-         */
-        error => of((/** @type {?} */ ({ action, status: "ERRORED" /* Errored */, error })))))))))
-            .subscribe((/**
-         * @param {?} ctx
-         * @return {?}
-         */
-        ctx => this._actionResults.next(ctx)));
-        this._connected = true;
-    }
-    /**
-     * Invoke actions on the states.
-     * @param {?} actions$
-     * @param {?} action
-     * @return {?}
-     */
-    invokeActions(actions$, action) {
-        /** @type {?} */
-        const results = [];
-        for (const metadata of this.states) {
-            /** @type {?} */
-            const type = (/** @type {?} */ (getActionTypeFromInstance(action)));
-            /** @type {?} */
-            const actionMetas = metadata.actions[type];
-            if (actionMetas) {
-                for (const actionMeta of actionMetas) {
-                    /** @type {?} */
-                    const stateContext = this._stateContextFactory.createStateContext(metadata);
-                    try {
-                        /** @type {?} */
-                        let result = metadata.instance[actionMeta.fn](stateContext, action);
-                        if (result instanceof Promise) {
-                            result = from(result);
-                        }
-                        if (result instanceof Observable) {
-                            if (actionMeta.options.cancelUncompleted) {
-                                // todo: ofActionDispatched should be used with action class
-                                result = result.pipe(takeUntil(actions$.pipe(ofActionDispatched((/** @type {?} */ (action))))));
-                            }
-                        }
-                        else {
-                            result = of({}).pipe(shareReplay());
-                        }
-                        results.push(result);
-                    }
-                    catch (e) {
-                        results.push(throwError(e));
-                    }
-                }
-            }
-        }
-        if (!results.length) {
-            results.push(of({}));
-        }
-        return forkJoin(results);
-    }
-    /**
-     * @private
-     * @param {?} stateClasses
-     * @return {?}
-     */
-    addToStatesMap(stateClasses) {
-        /** @type {?} */
-        const newStates = [];
-        /** @type {?} */
-        const statesMap = this.statesByName;
-        for (const stateClass of stateClasses) {
-            /** @type {?} */
-            const stateName = StoreValidators.checkStateNameIsUnique(stateClass, statesMap);
-            /** @type {?} */
-            const unmountedState = !statesMap[stateName];
-            if (unmountedState) {
-                newStates.push(stateClass);
-                statesMap[stateName] = stateClass;
-            }
-        }
-        return { newStates };
-    }
-    /**
-     * @private
-     * @param {?} meta
-     * @param {?} path
-     * @return {?}
-     */
-    addRuntimeInfoToMeta(meta, path) {
-        this.statePaths[(/** @type {?} */ (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;
-    }
-    /**
-     * \@description
-     * the method checks if the state has already been added to the tree
-     * and completed the life cycle
-     * @private
-     * @param {?} name
-     * @param {?} path
-     * @return {?}
-     */
-    hasBeenMountedAndBootstrapped(name, path) {
-        /** @type {?} */
-        const valueIsBootstrappedInInitialState = getValue(this._initialState, path) !== undefined;
-        return this.statesByName[name] && valueIsBootstrappedInInitialState;
-    }
-}
-StateFactory.decorators = [
-    { type: Injectable }
-];
-/** @nocollapse */
-StateFactory.ctorParameters = () => [
-    { type: Injector },
-    { type: NgxsConfig },
-    { type: StateFactory, decorators: [{ type: Optional }, { type: SkipSelf }] },
-    { type: InternalActions },
-    { type: InternalDispatchedActionResults },
-    { type: StateContextFactory },
-    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [INITIAL_STATE_TOKEN,] }] }
-];
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    StateFactory.prototype._connected;
-    /**
-     * @type {?}
-     * @private
-     */
-    StateFactory.prototype._states;
-    /**
-     * @type {?}
-     * @private
-     */
-    StateFactory.prototype._statesByName;
-    /**
-     * @type {?}
-     * @private
-     */
-    StateFactory.prototype._statePaths;
-    /** @type {?} */
-    StateFactory.prototype.getRuntimeSelectorContext;
-    /**
-     * @type {?}
-     * @private
-     */
-    StateFactory.prototype._injector;
-    /**
-     * @type {?}
-     * @private
-     */
-    StateFactory.prototype._config;
-    /**
-     * @type {?}
-     * @private
-     */
-    StateFactory.prototype._parentFactory;
-    /**
-     * @type {?}
-     * @private
-     */
-    StateFactory.prototype._actions;
-    /**
-     * @type {?}
-     * @private
-     */
-    StateFactory.prototype._actionResults;
-    /**
-     * @type {?}
-     * @private
-     */
-    StateFactory.prototype._stateContextFactory;
-    /**
-     * @type {?}
-     * @private
-     */
-    StateFactory.prototype._initialState;
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"state-factory.js","sourceRoot":"ng://@ngxs/store/","sources":["src/internal/state-factory.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Injector, Optional, SkipSelf, Inject } from '@angular/core';\nimport { forkJoin, from, Observable, of, throwError } from 'rxjs';\nimport {\n  catchError,\n  defaultIfEmpty,\n  filter,\n  map,\n  mergeMap,\n  shareReplay,\n  takeUntil\n} from 'rxjs/operators';\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} 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 { StoreValidators } from '../utils/store-validators';\nimport { INITIAL_STATE_TOKEN, PlainObjectOf, memoize } from '@ngxs/store/internals';\n\n/**\n * State factory class\n * @ignore\n */\n@Injectable()\nexport class StateFactory {\n  private _connected = false;\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  public get states(): MappedStore[] {\n    return this._parentFactory ? this._parentFactory.states : this._states;\n  }\n\n  private _statesByName: StatesByName = {};\n\n  public 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  public getRuntimeSelectorContext = memoize(() => {\n    const stateFactory = this;\n    const context: RuntimeSelectorContext = this._parentFactory\n      ? this._parentFactory.getRuntimeSelectorContext()\n      : {\n          getStateGetter(key: string) {\n            const path = stateFactory.statePaths[key];\n            return path ? propGetter(path.split('.'), stateFactory._config) : () => undefined;\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 = {};\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    } else {\n      value = defaults;\n    }\n\n    return value;\n  }\n\n  private static checkStatesAreValid(stateClasses: StateClassInternal[]): void {\n    stateClasses.forEach(StoreValidators.getValidStateMeta);\n  }\n\n  /**\n   * Add a new state to the global defs.\n   */\n  add(stateClasses: StateClassInternal[]): MappedStore[] {\n    StateFactory.checkStatesAreValid(stateClasses);\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      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  /**\n   * Bind the actions to the handlers\n   */\n  connectActionHandlers() {\n    if (this._connected) return;\n    this._actions\n      .pipe(\n        filter((ctx: ActionContext) => ctx.status === ActionStatus.Dispatched),\n        mergeMap(({ action }) =>\n          this.invokeActions(this._actions, 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    this._connected = true;\n  }\n\n  /**\n   * Invoke actions on the states.\n   */\n  invokeActions(actions$: InternalActions, action: any) {\n    const results = [];\n\n    for (const metadata of this.states) {\n      const type = getActionTypeFromInstance(action)!;\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 (result instanceof Observable) {\n              if (actionMeta.options.cancelUncompleted) {\n                // todo: ofActionDispatched should be used with action class\n                result = result.pipe(\n                  takeUntil(actions$.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      }\n    }\n\n    if (!results.length) {\n      results.push(of({}));\n    }\n\n    return forkJoin(results);\n  }\n\n  private addToStatesMap(\n    stateClasses: StateClassInternal[]\n  ): { newStates: StateClassInternal[] } {\n    const newStates: StateClassInternal[] = [];\n    const statesMap: StatesByName = this.statesByName;\n\n    for (const stateClass of stateClasses) {\n      const stateName: string = StoreValidators.checkStateNameIsUnique(stateClass, statesMap);\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  /**\n   * @description\n   * the method checks if the state has already been added to the tree\n   * and completed the life cycle\n   * @param name\n   * @param path\n   */\n  private hasBeenMountedAndBootstrapped(name: string, path: string): boolean {\n    const valueIsBootstrappedInInitialState: boolean =\n      getValue(this._initialState, path) !== undefined;\n    return this.statesByName[name] && valueIsBootstrappedInInitialState;\n  }\n}\n"]}
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Injectable, Injector, Optional, SkipSelf, Inject } from '@angular/core';
+import { forkJoin, from, Observable, of, throwError } from 'rxjs';
+import { catchError, defaultIfEmpty, filter, map, mergeMap, shareReplay, takeUntil } from 'rxjs/operators';
+import { META_KEY, NgxsConfig } from '../symbols';
+import { buildGraph, findFullParentPath, isObject, nameToState, propGetter, topologicalSort } 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 { StoreValidators } from '../utils/store-validators';
+import { INITIAL_STATE_TOKEN, memoize } from '@ngxs/store/internals';
+/**
+ * State factory class
+ * @ignore
+ */
+export class StateFactory {
+    /**
+     * @param {?} _injector
+     * @param {?} _config
+     * @param {?} _parentFactory
+     * @param {?} _actions
+     * @param {?} _actionResults
+     * @param {?} _stateContextFactory
+     * @param {?} _initialState
+     */
+    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._connected = false;
+        this._states = [];
+        this._statesByName = {};
+        this._statePaths = {};
+        this.getRuntimeSelectorContext = memoize((/**
+         * @return {?}
+         */
+        () => {
+            /** @type {?} */
+            const stateFactory = this;
+            /** @type {?} */
+            const context = this._parentFactory
+                ? this._parentFactory.getRuntimeSelectorContext()
+                : {
+                    /**
+                     * @param {?} key
+                     * @return {?}
+                     */
+                    getStateGetter(key) {
+                        /** @type {?} */
+                        const path = stateFactory.statePaths[key];
+                        return path ? propGetter(path.split('.'), stateFactory._config) : (/**
+                         * @return {?}
+                         */
+                        () => undefined);
+                    },
+                    /**
+                     * @param {?=} localOptions
+                     * @return {?}
+                     */
+                    getSelectorOptions(localOptions) {
+                        /** @type {?} */
+                        const globalSelectorOptions = stateFactory._config.selectorOptions;
+                        return Object.assign({}, globalSelectorOptions, (localOptions || {}));
+                    }
+                };
+            return context;
+        }));
+    }
+    /**
+     * @return {?}
+     */
+    get states() {
+        return this._parentFactory ? this._parentFactory.states : this._states;
+    }
+    /**
+     * @return {?}
+     */
+    get statesByName() {
+        return this._parentFactory ? this._parentFactory.statesByName : this._statesByName;
+    }
+    /**
+     * @private
+     * @return {?}
+     */
+    get statePaths() {
+        return this._parentFactory ? this._parentFactory.statePaths : this._statePaths;
+    }
+    /**
+     * @private
+     * @param {?} defaults
+     * @return {?}
+     */
+    static cloneDefaults(defaults) {
+        /** @type {?} */
+        let value = {};
+        if (Array.isArray(defaults)) {
+            value = defaults.slice();
+        }
+        else if (isObject(defaults)) {
+            value = Object.assign({}, defaults);
+        }
+        else if (defaults === undefined) {
+            value = {};
+        }
+        else {
+            value = defaults;
+        }
+        return value;
+    }
+    /**
+     * @private
+     * @param {?} stateClasses
+     * @return {?}
+     */
+    static checkStatesAreValid(stateClasses) {
+        stateClasses.forEach(StoreValidators.getValidStateMeta);
+    }
+    /**
+     * Add a new state to the global defs.
+     * @param {?} stateClasses
+     * @return {?}
+     */
+    add(stateClasses) {
+        StateFactory.checkStatesAreValid(stateClasses);
+        const { newStates } = this.addToStatesMap(stateClasses);
+        if (!newStates.length)
+            return [];
+        /** @type {?} */
+        const stateGraph = buildGraph(newStates);
+        /** @type {?} */
+        const sortedStates = topologicalSort(stateGraph);
+        /** @type {?} */
+        const paths = findFullParentPath(stateGraph);
+        /** @type {?} */
+        const nameGraph = nameToState(newStates);
+        /** @type {?} */
+        const bootstrappedStores = [];
+        for (const name of sortedStates) {
+            /** @type {?} */
+            const stateClass = nameGraph[name];
+            /** @type {?} */
+            const path = paths[name];
+            /** @type {?} */
+            const meta = (/** @type {?} */ (stateClass[META_KEY]));
+            this.addRuntimeInfoToMeta(meta, path);
+            /** @type {?} */
+            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
+     * @param {?} stateClasses
+     * @return {?}
+     */
+    addAndReturnDefaults(stateClasses) {
+        /** @type {?} */
+        const classes = stateClasses || [];
+        /** @type {?} */
+        const mappedStores = this.add(classes);
+        /** @type {?} */
+        const defaults = mappedStores.reduce((/**
+         * @param {?} result
+         * @param {?} mappedStore
+         * @return {?}
+         */
+        (result, mappedStore) => setValue(result, mappedStore.path, mappedStore.defaults)), {});
+        return { defaults, states: mappedStores };
+    }
+    /**
+     * Bind the actions to the handlers
+     * @return {?}
+     */
+    connectActionHandlers() {
+        if (this._connected)
+            return;
+        this._actions
+            .pipe(filter((/**
+         * @param {?} ctx
+         * @return {?}
+         */
+        (ctx) => ctx.status === "DISPATCHED" /* Dispatched */)), mergeMap((/**
+         * @param {?} __0
+         * @return {?}
+         */
+        ({ action }) => this.invokeActions(this._actions, (/** @type {?} */ (action))).pipe(map((/**
+         * @return {?}
+         */
+        () => (/** @type {?} */ ({ action, status: "SUCCESSFUL" /* Successful */ })))), defaultIfEmpty((/** @type {?} */ ({ action, status: "CANCELED" /* Canceled */ }))), catchError((/**
+         * @param {?} error
+         * @return {?}
+         */
+        error => of((/** @type {?} */ ({ action, status: "ERRORED" /* Errored */, error })))))))))
+            .subscribe((/**
+         * @param {?} ctx
+         * @return {?}
+         */
+        ctx => this._actionResults.next(ctx)));
+        this._connected = true;
+    }
+    /**
+     * Invoke actions on the states.
+     * @param {?} actions$
+     * @param {?} action
+     * @return {?}
+     */
+    invokeActions(actions$, action) {
+        /** @type {?} */
+        const type = (/** @type {?} */ (getActionTypeFromInstance(action)));
+        /** @type {?} */
+        const results = [];
+        for (const metadata of this.states) {
+            /** @type {?} */
+            const actionMetas = metadata.actions[type];
+            if (actionMetas) {
+                for (const actionMeta of actionMetas) {
+                    /** @type {?} */
+                    const stateContext = this._stateContextFactory.createStateContext(metadata);
+                    try {
+                        /** @type {?} */
+                        let result = metadata.instance[actionMeta.fn](stateContext, action);
+                        if (result instanceof Promise) {
+                            result = from(result);
+                        }
+                        if (result instanceof Observable) {
+                            // 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(defaultIfEmpty({}));
+                            if (actionMeta.options.cancelUncompleted) {
+                                // todo: ofActionDispatched should be used with action class
+                                result = result.pipe(takeUntil(actions$.pipe(ofActionDispatched((/** @type {?} */ (action))))));
+                            }
+                        }
+                        else {
+                            result = of({}).pipe(shareReplay());
+                        }
+                        results.push(result);
+                    }
+                    catch (e) {
+                        results.push(throwError(e));
+                    }
+                }
+            }
+        }
+        if (!results.length) {
+            results.push(of({}));
+        }
+        return forkJoin(results);
+    }
+    /**
+     * @private
+     * @param {?} stateClasses
+     * @return {?}
+     */
+    addToStatesMap(stateClasses) {
+        /** @type {?} */
+        const newStates = [];
+        /** @type {?} */
+        const statesMap = this.statesByName;
+        for (const stateClass of stateClasses) {
+            /** @type {?} */
+            const stateName = StoreValidators.checkStateNameIsUnique(stateClass, statesMap);
+            /** @type {?} */
+            const unmountedState = !statesMap[stateName];
+            if (unmountedState) {
+                newStates.push(stateClass);
+                statesMap[stateName] = stateClass;
+            }
+        }
+        return { newStates };
+    }
+    /**
+     * @private
+     * @param {?} meta
+     * @param {?} path
+     * @return {?}
+     */
+    addRuntimeInfoToMeta(meta, path) {
+        this.statePaths[(/** @type {?} */ (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;
+    }
+    /**
+     * \@description
+     * the method checks if the state has already been added to the tree
+     * and completed the life cycle
+     * @private
+     * @param {?} name
+     * @param {?} path
+     * @return {?}
+     */
+    hasBeenMountedAndBootstrapped(name, path) {
+        /** @type {?} */
+        const valueIsBootstrappedInInitialState = getValue(this._initialState, path) !== undefined;
+        return this.statesByName[name] && valueIsBootstrappedInInitialState;
+    }
+}
+StateFactory.decorators = [
+    { type: Injectable }
+];
+/** @nocollapse */
+StateFactory.ctorParameters = () => [
+    { type: Injector },
+    { type: NgxsConfig },
+    { type: StateFactory, decorators: [{ type: Optional }, { type: SkipSelf }] },
+    { type: InternalActions },
+    { type: InternalDispatchedActionResults },
+    { type: StateContextFactory },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [INITIAL_STATE_TOKEN,] }] }
+];
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    StateFactory.prototype._connected;
+    /**
+     * @type {?}
+     * @private
+     */
+    StateFactory.prototype._states;
+    /**
+     * @type {?}
+     * @private
+     */
+    StateFactory.prototype._statesByName;
+    /**
+     * @type {?}
+     * @private
+     */
+    StateFactory.prototype._statePaths;
+    /** @type {?} */
+    StateFactory.prototype.getRuntimeSelectorContext;
+    /**
+     * @type {?}
+     * @private
+     */
+    StateFactory.prototype._injector;
+    /**
+     * @type {?}
+     * @private
+     */
+    StateFactory.prototype._config;
+    /**
+     * @type {?}
+     * @private
+     */
+    StateFactory.prototype._parentFactory;
+    /**
+     * @type {?}
+     * @private
+     */
+    StateFactory.prototype._actions;
+    /**
+     * @type {?}
+     * @private
+     */
+    StateFactory.prototype._actionResults;
+    /**
+     * @type {?}
+     * @private
+     */
+    StateFactory.prototype._stateContextFactory;
+    /**
+     * @type {?}
+     * @private
+     */
+    StateFactory.prototype._initialState;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"state-factory.js","sourceRoot":"ng://@ngxs/store/","sources":["src/internal/state-factory.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Injector, Optional, SkipSelf, Inject } from '@angular/core';\r\nimport { forkJoin, from, Observable, of, throwError } from 'rxjs';\r\nimport {\r\n  catchError,\r\n  defaultIfEmpty,\r\n  filter,\r\n  map,\r\n  mergeMap,\r\n  shareReplay,\r\n  takeUntil\r\n} from 'rxjs/operators';\r\n\r\nimport { META_KEY, NgxsConfig } from '../symbols';\r\nimport {\r\n  buildGraph,\r\n  findFullParentPath,\r\n  isObject,\r\n  MappedStore,\r\n  MetaDataModel,\r\n  nameToState,\r\n  propGetter,\r\n  StateClassInternal,\r\n  StateKeyGraph,\r\n  StatesAndDefaults,\r\n  StatesByName,\r\n  topologicalSort,\r\n  RuntimeSelectorContext,\r\n  SharedSelectorOptions\r\n} from './internals';\r\nimport { getActionTypeFromInstance, getValue, setValue } from '../utils/utils';\r\nimport { ofActionDispatched } from '../operators/of-action';\r\nimport { ActionContext, ActionStatus, InternalActions } from '../actions-stream';\r\nimport { InternalDispatchedActionResults } from '../internal/dispatcher';\r\nimport { StateContextFactory } from '../internal/state-context-factory';\r\nimport { StoreValidators } from '../utils/store-validators';\r\nimport { INITIAL_STATE_TOKEN, PlainObjectOf, memoize } from '@ngxs/store/internals';\r\n\r\n/**\r\n * State factory class\r\n * @ignore\r\n */\r\n@Injectable()\r\nexport class StateFactory {\r\n  private _connected = false;\r\n\r\n  constructor(\r\n    private _injector: Injector,\r\n    private _config: NgxsConfig,\r\n    @Optional()\r\n    @SkipSelf()\r\n    private _parentFactory: StateFactory,\r\n    private _actions: InternalActions,\r\n    private _actionResults: InternalDispatchedActionResults,\r\n    private _stateContextFactory: StateContextFactory,\r\n    @Optional()\r\n    @Inject(INITIAL_STATE_TOKEN)\r\n    private _initialState: any\r\n  ) {}\r\n\r\n  private _states: MappedStore[] = [];\r\n\r\n  public get states(): MappedStore[] {\r\n    return this._parentFactory ? this._parentFactory.states : this._states;\r\n  }\r\n\r\n  private _statesByName: StatesByName = {};\r\n\r\n  public get statesByName(): StatesByName {\r\n    return this._parentFactory ? this._parentFactory.statesByName : this._statesByName;\r\n  }\r\n\r\n  private _statePaths: PlainObjectOf<string> = {};\r\n\r\n  private get statePaths(): PlainObjectOf<string> {\r\n    return this._parentFactory ? this._parentFactory.statePaths : this._statePaths;\r\n  }\r\n\r\n  public getRuntimeSelectorContext = memoize(() => {\r\n    const stateFactory = this;\r\n    const context: RuntimeSelectorContext = this._parentFactory\r\n      ? this._parentFactory.getRuntimeSelectorContext()\r\n      : {\r\n          getStateGetter(key: string) {\r\n            const path = stateFactory.statePaths[key];\r\n            return path ? propGetter(path.split('.'), stateFactory._config) : () => undefined;\r\n          },\r\n          getSelectorOptions(localOptions?: SharedSelectorOptions) {\r\n            const globalSelectorOptions = stateFactory._config.selectorOptions;\r\n            return {\r\n              ...globalSelectorOptions,\r\n              ...(localOptions || {})\r\n            };\r\n          }\r\n        };\r\n    return context;\r\n  });\r\n\r\n  private static cloneDefaults(defaults: any): any {\r\n    let value = {};\r\n\r\n    if (Array.isArray(defaults)) {\r\n      value = defaults.slice();\r\n    } else if (isObject(defaults)) {\r\n      value = { ...defaults };\r\n    } else if (defaults === undefined) {\r\n      value = {};\r\n    } else {\r\n      value = defaults;\r\n    }\r\n\r\n    return value;\r\n  }\r\n\r\n  private static checkStatesAreValid(stateClasses: StateClassInternal[]): void {\r\n    stateClasses.forEach(StoreValidators.getValidStateMeta);\r\n  }\r\n\r\n  /**\r\n   * Add a new state to the global defs.\r\n   */\r\n  add(stateClasses: StateClassInternal[]): MappedStore[] {\r\n    StateFactory.checkStatesAreValid(stateClasses);\r\n    const { newStates } = this.addToStatesMap(stateClasses);\r\n    if (!newStates.length) return [];\r\n\r\n    const stateGraph: StateKeyGraph = buildGraph(newStates);\r\n    const sortedStates: string[] = topologicalSort(stateGraph);\r\n    const paths: PlainObjectOf<string> = findFullParentPath(stateGraph);\r\n    const nameGraph: PlainObjectOf<StateClassInternal> = nameToState(newStates);\r\n    const bootstrappedStores: MappedStore[] = [];\r\n\r\n    for (const name of sortedStates) {\r\n      const stateClass: StateClassInternal = nameGraph[name];\r\n      const path: string = paths[name];\r\n      const meta: MetaDataModel = stateClass[META_KEY]!;\r\n\r\n      this.addRuntimeInfoToMeta(meta, path);\r\n\r\n      const stateMap: MappedStore = {\r\n        name,\r\n        path,\r\n        isInitialised: false,\r\n        actions: meta.actions,\r\n        instance: this._injector.get(stateClass),\r\n        defaults: StateFactory.cloneDefaults(meta.defaults)\r\n      };\r\n\r\n      // ensure our store hasn't already been added\r\n      // but don't throw since it could be lazy\r\n      // loaded from different paths\r\n      if (!this.hasBeenMountedAndBootstrapped(name, path)) {\r\n        bootstrappedStores.push(stateMap);\r\n      }\r\n\r\n      this.states.push(stateMap);\r\n    }\r\n\r\n    return bootstrappedStores;\r\n  }\r\n\r\n  /**\r\n   * Add a set of states to the store and return the defaults\r\n   */\r\n  addAndReturnDefaults(stateClasses: StateClassInternal[]): StatesAndDefaults {\r\n    const classes: StateClassInternal[] = stateClasses || [];\r\n\r\n    const mappedStores: MappedStore[] = this.add(classes);\r\n    const defaults = mappedStores.reduce(\r\n      (result: any, mappedStore: MappedStore) =>\r\n        setValue(result, mappedStore.path, mappedStore.defaults),\r\n      {}\r\n    );\r\n    return { defaults, states: mappedStores };\r\n  }\r\n\r\n  /**\r\n   * Bind the actions to the handlers\r\n   */\r\n  connectActionHandlers() {\r\n    if (this._connected) return;\r\n    this._actions\r\n      .pipe(\r\n        filter((ctx: ActionContext) => ctx.status === ActionStatus.Dispatched),\r\n        mergeMap(({ action }) =>\r\n          this.invokeActions(this._actions, action!).pipe(\r\n            map(() => <ActionContext>{ action, status: ActionStatus.Successful }),\r\n            defaultIfEmpty(<ActionContext>{ action, status: ActionStatus.Canceled }),\r\n            catchError(error =>\r\n              of(<ActionContext>{ action, status: ActionStatus.Errored, error })\r\n            )\r\n          )\r\n        )\r\n      )\r\n      .subscribe(ctx => this._actionResults.next(ctx));\r\n    this._connected = true;\r\n  }\r\n\r\n  /**\r\n   * Invoke actions on the states.\r\n   */\r\n  invokeActions(actions$: InternalActions, action: any) {\r\n    const type = getActionTypeFromInstance(action)!;\r\n    const results = [];\r\n\r\n    for (const metadata of this.states) {\r\n      const actionMetas = metadata.actions[type];\r\n\r\n      if (actionMetas) {\r\n        for (const actionMeta of actionMetas) {\r\n          const stateContext = this._stateContextFactory.createStateContext(metadata);\r\n          try {\r\n            let result = metadata.instance[actionMeta.fn](stateContext, action);\r\n\r\n            if (result instanceof Promise) {\r\n              result = from(result);\r\n            }\r\n\r\n            if (result instanceof Observable) {\r\n              // If this observable has been completed w/o emitting\r\n              // any value then we wouldn't want to complete the whole chain\r\n              // of actions. Since if any observable completes then\r\n              // action will be canceled.\r\n              // For instance if any action handler would've had such statement:\r\n              // `handler(ctx) { return EMPTY; }`\r\n              // then the action will be canceled.\r\n              // See https://github.com/ngxs/store/issues/1568\r\n              result = result.pipe(defaultIfEmpty({}));\r\n\r\n              if (actionMeta.options.cancelUncompleted) {\r\n                // todo: ofActionDispatched should be used with action class\r\n                result = result.pipe(\r\n                  takeUntil(actions$.pipe(ofActionDispatched(action as any)))\r\n                );\r\n              }\r\n            } else {\r\n              result = of({}).pipe(shareReplay());\r\n            }\r\n\r\n            results.push(result);\r\n          } catch (e) {\r\n            results.push(throwError(e));\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    if (!results.length) {\r\n      results.push(of({}));\r\n    }\r\n\r\n    return forkJoin(results);\r\n  }\r\n\r\n  private addToStatesMap(\r\n    stateClasses: StateClassInternal[]\r\n  ): { newStates: StateClassInternal[] } {\r\n    const newStates: StateClassInternal[] = [];\r\n    const statesMap: StatesByName = this.statesByName;\r\n\r\n    for (const stateClass of stateClasses) {\r\n      const stateName: string = StoreValidators.checkStateNameIsUnique(stateClass, statesMap);\r\n      const unmountedState = !statesMap[stateName];\r\n      if (unmountedState) {\r\n        newStates.push(stateClass);\r\n        statesMap[stateName] = stateClass;\r\n      }\r\n    }\r\n\r\n    return { newStates };\r\n  }\r\n\r\n  private addRuntimeInfoToMeta(meta: MetaDataModel, path: string): void {\r\n    this.statePaths[meta.name!] = path;\r\n    // TODO: v4 - we plan to get rid of the path property because it is non-deterministic\r\n    // we can do this when we get rid of the incorrectly exposed getStoreMetadata\r\n    // We will need to come up with an alternative in v4 because this is used by many plugins\r\n    meta.path = path;\r\n  }\r\n\r\n  /**\r\n   * @description\r\n   * the method checks if the state has already been added to the tree\r\n   * and completed the life cycle\r\n   * @param name\r\n   * @param path\r\n   */\r\n  private hasBeenMountedAndBootstrapped(name: string, path: string): boolean {\r\n    const valueIsBootstrappedInInitialState: boolean =\r\n      getValue(this._initialState, path) !== undefined;\r\n    return this.statesByName[name] && valueIsBootstrappedInInitialState;\r\n  }\r\n}\r\n"]}