@ngxs/store 3.7.5 → 3.7.6-dev.master-a585f14

package/fesm5/ngxs-store.js

@@ -1,9 +1,9 @@
-import { __assign, __spread, __extends, __values } from 'tslib';
-import { NgZone, Injectable, Inject, PLATFORM_ID, defineInjectable, inject, InjectionToken, INJECTOR, ɵglobal, Optional, SkipSelf, ErrorHandler, Injector, ɵivyEnabled, NgModule, APP_BOOTSTRAP_LISTENER } from '@angular/core';
+import { __assign, __spread, __extends, __values, __read } from 'tslib';
+import { NgZone, Injectable, Inject, PLATFORM_ID, defineInjectable, inject, InjectionToken, INJECTOR, ɵglobal, ErrorHandler, Injector, Optional, SkipSelf, ɵivyEnabled, NgModule, APP_BOOTSTRAP_LISTENER } from '@angular/core';
 import { memoize, INITIAL_STATE_TOKEN, NgxsBootstrapper, NGXS_STATE_CONTEXT_FACTORY, NGXS_STATE_FACTORY, InitialState } from '@ngxs/store/internals';
 import { isPlatformServer } from '@angular/common';
-import { Observable, Subject, BehaviorSubject, of, forkJoin, throwError, EMPTY, from, queueScheduler } from 'rxjs';
-import { filter, map, shareReplay, take, exhaustMap, mergeMap, defaultIfEmpty, catchError, takeUntil, tap, observeOn, distinctUntilChanged } from 'rxjs/operators';
+import { Observable, Subject, BehaviorSubject, of, forkJoin, throwError, EMPTY, from, isObservable, queueScheduler } from 'rxjs';
+import { filter, map, share, shareReplay, take, exhaustMap, mergeMap, defaultIfEmpty, catchError, takeUntil, observeOn, distinctUntilChanged, tap, startWith, pairwise } from 'rxjs/operators';
 
 /**
  * @fileoverview added by tsickle
@@ -512,156 +512,6 @@ if (false) {
     NgxsExecutionStrategy.prototype.leave = function (func) { };
 }
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * Returns the type from an action instance/class.
- * @ignore
- * @param {?} action
- * @return {?}
- */
-function getActionTypeFromInstance(action) {
-    if (action.constructor && action.constructor.type) {
-        return action.constructor.type;
-    }
-    else {
-        return action.type;
-    }
-}
-/**
- * Matches a action
- * @ignore
- * @param {?} action1
- * @return {?}
- */
-function actionMatcher(action1) {
-    /** @type {?} */
-    var type1 = getActionTypeFromInstance(action1);
-    return (/**
-     * @param {?} action2
-     * @return {?}
-     */
-    function (action2) {
-        return type1 === getActionTypeFromInstance(action2);
-    });
-}
-/**
- * Set a deeply nested value. Example:
- *
- *   setValue({ foo: { bar: { eat: false } } },
- *      'foo.bar.eat', true) //=> { foo: { bar: { eat: true } } }
- *
- * While it traverses it also creates new objects from top down.
- *
- * @ignore
- * @type {?}
- */
-var setValue = (/**
- * @param {?} obj
- * @param {?} prop
- * @param {?} val
- * @return {?}
- */
-function (obj, prop, val) {
-    obj = __assign({}, obj);
-    /** @type {?} */
-    var split = prop.split('.');
-    /** @type {?} */
-    var lastIndex = split.length - 1;
-    split.reduce((/**
-     * @param {?} acc
-     * @param {?} part
-     * @param {?} index
-     * @return {?}
-     */
-    function (acc, part, index) {
-        if (index === lastIndex) {
-            acc[part] = val;
-        }
-        else {
-            acc[part] = Array.isArray(acc[part]) ? acc[part].slice() : __assign({}, acc[part]);
-        }
-        return acc && acc[part];
-    }), obj);
-    return obj;
-});
-/**
- * Get a deeply nested value. Example:
- *
- *    getValue({ foo: bar: [] }, 'foo.bar') //=> []
- *
- * @ignore
- * @type {?}
- */
-var getValue = (/**
- * @param {?} obj
- * @param {?} prop
- * @return {?}
- */
-function (obj, prop) {
-    return prop.split('.').reduce((/**
-     * @param {?} acc
-     * @param {?} part
-     * @return {?}
-     */
-    function (acc, part) { return acc && acc[part]; }), obj);
-});
-/**
- * Simple object check.
- *
- *    isObject({a:1}) //=> true
- *    isObject(1) //=> false
- *
- * @ignore
- * @type {?}
- */
-var isObject = (/**
- * @param {?} item
- * @return {?}
- */
-function (item) {
-    return item && typeof item === 'object' && !Array.isArray(item);
-});
-/**
- * Deep merge two objects.
- *
- *    mergeDeep({a:1, b:{x: 1, y:2}}, {b:{x: 3}, c:4}) //=> {a:1, b:{x:3, y:2}, c:4}
- *
- * \@param base base object onto which `sources` will be applied
- * @type {?}
- */
-var mergeDeep = (/**
- * @param {?} base
- * @param {...?} sources
- * @return {?}
- */
-function (base) {
-    var sources = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        sources[_i - 1] = arguments[_i];
-    }
-    var _a, _b;
-    if (!sources.length)
-        return base;
-    /** @type {?} */
-    var source = sources.shift();
-    if (isObject(base) && isObject(source)) {
-        for (var key in source) {
-            if (isObject(source[key])) {
-                if (!base[key])
-                    Object.assign(base, (_a = {}, _a[key] = {}, _a));
-                mergeDeep(base[key], source[key]);
-            }
-            else {
-                Object.assign(base, (_b = {}, _b[key] = source[key], _b));
-            }
-        }
-    }
-    return mergeDeep.apply(void 0, __spread([base], sources));
-});
-
 /**
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
@@ -786,17 +636,6 @@ if (false) {
     /** @type {?} */
     StatesAndDefaults.prototype.states;
 }
-/**
- * @record
- * @template T
- */
-function RootStateDiff() { }
-if (false) {
-    /** @type {?} */
-    RootStateDiff.prototype.currentAppState;
-    /** @type {?} */
-    RootStateDiff.prototype.newAppState;
-}
 /**
  * Ensures metadata is attached to the class and returns it.
  *
@@ -1138,22 +977,159 @@ function topologicalSort(graph) {
  * @param {?} obj
  * @return {?}
  */
-function isObject$1(obj) {
+function isObject(obj) {
     return (typeof obj === 'object' && obj !== null) || typeof obj === 'function';
 }
+
 /**
- * @template T
- * @param {?} mappedStore
- * @param {?} diff
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * Returns the type from an action instance/class.
+ * @ignore
+ * @param {?} action
  * @return {?}
  */
-function getStateDiffChanges(mappedStore, diff) {
-    /** @type {?} */
-    var previousValue = getValue(diff.currentAppState, mappedStore.path);
+function getActionTypeFromInstance(action) {
+    if (action.constructor && action.constructor.type) {
+        return action.constructor.type;
+    }
+    else {
+        return action.type;
+    }
+}
+/**
+ * Matches a action
+ * @ignore
+ * @param {?} action1
+ * @return {?}
+ */
+function actionMatcher(action1) {
     /** @type {?} */
-    var currentValue = getValue(diff.newAppState, mappedStore.path);
-    return new NgxsSimpleChange(previousValue, currentValue, !mappedStore.isInitialised);
+    var type1 = getActionTypeFromInstance(action1);
+    return (/**
+     * @param {?} action2
+     * @return {?}
+     */
+    function (action2) {
+        return type1 === getActionTypeFromInstance(action2);
+    });
 }
+/**
+ * Set a deeply nested value. Example:
+ *
+ *   setValue({ foo: { bar: { eat: false } } },
+ *      'foo.bar.eat', true) //=> { foo: { bar: { eat: true } } }
+ *
+ * While it traverses it also creates new objects from top down.
+ *
+ * @ignore
+ * @type {?}
+ */
+var setValue = (/**
+ * @param {?} obj
+ * @param {?} prop
+ * @param {?} val
+ * @return {?}
+ */
+function (obj, prop, val) {
+    obj = __assign({}, obj);
+    /** @type {?} */
+    var split = prop.split('.');
+    /** @type {?} */
+    var lastIndex = split.length - 1;
+    split.reduce((/**
+     * @param {?} acc
+     * @param {?} part
+     * @param {?} index
+     * @return {?}
+     */
+    function (acc, part, index) {
+        if (index === lastIndex) {
+            acc[part] = val;
+        }
+        else {
+            acc[part] = Array.isArray(acc[part]) ? acc[part].slice() : __assign({}, acc[part]);
+        }
+        return acc && acc[part];
+    }), obj);
+    return obj;
+});
+/**
+ * Get a deeply nested value. Example:
+ *
+ *    getValue({ foo: bar: [] }, 'foo.bar') //=> []
+ *
+ * @ignore
+ * @type {?}
+ */
+var getValue = (/**
+ * @param {?} obj
+ * @param {?} prop
+ * @return {?}
+ */
+function (obj, prop) {
+    return prop.split('.').reduce((/**
+     * @param {?} acc
+     * @param {?} part
+     * @return {?}
+     */
+    function (acc, part) { return acc && acc[part]; }), obj);
+});
+/**
+ * Simple object check.
+ *
+ *    isObject({a:1}) //=> true
+ *    isObject(1) //=> false
+ *
+ * @ignore
+ * @type {?}
+ */
+var isObject$1 = (/**
+ * @param {?} item
+ * @return {?}
+ */
+function (item) {
+    return item && typeof item === 'object' && !Array.isArray(item);
+});
+/**
+ * Deep merge two objects.
+ *
+ *    mergeDeep({a:1, b:{x: 1, y:2}}, {b:{x: 3}, c:4}) //=> {a:1, b:{x:3, y:2}, c:4}
+ *
+ * \@param base base object onto which `sources` will be applied
+ * @type {?}
+ */
+var mergeDeep = (/**
+ * @param {?} base
+ * @param {...?} sources
+ * @return {?}
+ */
+function (base) {
+    var sources = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        sources[_i - 1] = arguments[_i];
+    }
+    var _a, _b;
+    if (!sources.length)
+        return base;
+    /** @type {?} */
+    var source = sources.shift();
+    if (isObject$1(base) && isObject$1(source)) {
+        for (var key in source) {
+            if (isObject$1(source[key])) {
+                if (!base[key])
+                    Object.assign(base, (_a = {}, _a[key] = {}, _a));
+                mergeDeep(base[key], source[key]);
+            }
+            else {
+                Object.assign(base, (_b = {}, _b[key] = source[key], _b));
+            }
+        }
+    }
+    return mergeDeep.apply(void 0, __spread([base], sources));
+});
 
 /**
  * @fileoverview added by tsickle
@@ -1174,6 +1150,7 @@ if (false) {
  * RxJS operator for selecting out specific actions.
  *
  * This will grab actions that have just been dispatched as well as actions that have completed
+ * @template T
  * @param {...?} allowedTypes
  * @return {?}
  */
@@ -1188,6 +1165,7 @@ function ofAction() {
  * RxJS operator for selecting out specific actions.
  *
  * This will ONLY grab actions that have just been dispatched
+ * @template T
  * @param {...?} allowedTypes
  * @return {?}
  */
@@ -1202,6 +1180,7 @@ function ofActionDispatched() {
  * RxJS operator for selecting out specific actions.
  *
  * This will ONLY grab actions that have just been successfully completed
+ * @template T
  * @param {...?} allowedTypes
  * @return {?}
  */
@@ -1216,6 +1195,7 @@ function ofActionSuccessful() {
  * RxJS operator for selecting out specific actions.
  *
  * This will ONLY grab actions that have just been canceled
+ * @template T
  * @param {...?} allowedTypes
  * @return {?}
  */
@@ -1230,6 +1210,7 @@ function ofActionCanceled() {
  * RxJS operator for selecting out specific actions.
  *
  * This will ONLY grab actions that have just been completed
+ * @template T
  * @param {...?} allowedTypes
  * @return {?}
  */
@@ -1250,6 +1231,7 @@ function ofActionCompleted() {
  * RxJS operator for selecting out specific actions.
  *
  * This will ONLY grab actions that have just thrown an error
+ * @template T
  * @param {...?} allowedTypes
  * @return {?}
  */
@@ -1586,6 +1568,15 @@ var InternalActions = /** @class */ (function (_super) {
     function InternalActions() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
+    /**
+     * @return {?}
+     */
+    InternalActions.prototype.ngOnDestroy = /**
+     * @return {?}
+     */
+    function () {
+        this.complete();
+    };
     InternalActions.decorators = [
         { type: Injectable }
     ];
@@ -1598,18 +1589,22 @@ var InternalActions = /** @class */ (function (_super) {
  */
 var Actions = /** @class */ (function (_super) {
     __extends(Actions, _super);
-    // This has to be `Observable<ActionContext>` in the v4. Because `InternalActions`
-    // is a `Subject<ActionContext>`. Leave it as `any` to avoid breaking changes
     function Actions(internalActions$, internalExecutionStrategy) {
-        return _super.call(this, (/**
+        var _this = this;
+        /** @type {?} */
+        var sharedInternalActions$ = internalActions$.pipe(leaveNgxs(internalExecutionStrategy), 
+        // The `InternalActions` subject emits outside of the Angular zone.
+        // We have to re-enter the Angular zone for any incoming consumer.
+        // The `share()` operator reduces the number of change detections.
+        // This would call leave only once for any stream emission across all active subscribers.
+        share());
+        _this = _super.call(this, (/**
          * @param {?} observer
          * @return {?}
          */
         function (observer) {
             /** @type {?} */
-            var childSubscription = internalActions$
-                .pipe(leaveNgxs(internalExecutionStrategy))
-                .subscribe({
+            var childSubscription = sharedInternalActions$.subscribe({
                 next: (/**
                  * @param {?} ctx
                  * @return {?}
@@ -1627,6 +1622,7 @@ var Actions = /** @class */ (function (_super) {
             });
             observer.add(childSubscription);
         })) || this;
+        return _this;
     }
     Actions.decorators = [
         { type: Injectable }
@@ -1693,6 +1689,126 @@ function () {
         })]));
 }); });
 
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * This operator is used for piping the observable result
+ * from the `dispatch()`. It has a "smart" error handling
+ * strategy that allows us to decide whether we propagate
+ * errors to Angular's `ErrorHandler` or enable users to
+ * handle them manually. We consider following cases:
+ * 1) `store.dispatch()` (no subscribe) -> call `handleError()`
+ * 2) `store.dispatch().subscribe()` (no error callback) -> call `handleError()`
+ * 3) `store.dispatch().subscribe({ error: ... })` -> don't call `handleError()`
+ * 4) `toPromise()` without `catch` -> do `handleError()`
+ * 5) `toPromise()` with `catch` -> don't `handleError()`
+ * @template T
+ * @param {?} internalErrorReporter
+ * @param {?} ngxsExecutionStrategy
+ * @return {?}
+ */
+function ngxsErrorHandler(internalErrorReporter, ngxsExecutionStrategy) {
+    return (/**
+     * @param {?} source
+     * @return {?}
+     */
+    function (source) {
+        /** @type {?} */
+        var subscribed = false;
+        source.subscribe({
+            error: (/**
+             * @param {?} error
+             * @return {?}
+             */
+            function (error) {
+                // Do not trigger change detection for a microtask. This depends on the execution
+                // strategy being used, but the default `DispatchOutsideZoneNgxsExecutionStrategy`
+                // leaves the Angular zone.
+                ngxsExecutionStrategy.enter((/**
+                 * @return {?}
+                 */
+                function () {
+                    return Promise.resolve().then((/**
+                     * @return {?}
+                     */
+                    function () {
+                        if (!subscribed) {
+                            ngxsExecutionStrategy.leave((/**
+                             * @return {?}
+                             */
+                            function () {
+                                return internalErrorReporter.reportErrorSafely(error);
+                            }));
+                        }
+                    }));
+                }));
+            })
+        });
+        return new Observable((/**
+         * @param {?} subscriber
+         * @return {?}
+         */
+        function (subscriber) {
+            subscribed = true;
+            return source.pipe(leaveNgxs(ngxsExecutionStrategy)).subscribe(subscriber);
+        }));
+    });
+}
+var InternalErrorReporter = /** @class */ (function () {
+    function InternalErrorReporter(_injector) {
+        this._injector = _injector;
+        /**
+         * Will be set lazily to be backward compatible.
+         */
+        this._errorHandler = (/** @type {?} */ (null));
+    }
+    /**
+     * @param {?} error
+     * @return {?}
+     */
+    InternalErrorReporter.prototype.reportErrorSafely = /**
+     * @param {?} error
+     * @return {?}
+     */
+    function (error) {
+        if (this._errorHandler === null) {
+            this._errorHandler = this._injector.get(ErrorHandler);
+        }
+        // The `try-catch` is used to avoid handling the error twice. Suppose we call
+        // `handleError` which re-throws the error internally. The re-thrown error will
+        // be caught by zone.js which will then get to the `zone.onError.emit()` and the
+        // `onError` subscriber will call `handleError` again.
+        try {
+            this._errorHandler.handleError(error);
+        }
+        catch (_a) { }
+    };
+    InternalErrorReporter.decorators = [
+        { type: Injectable, args: [{ providedIn: 'root' },] }
+    ];
+    /** @nocollapse */
+    InternalErrorReporter.ctorParameters = function () { return [
+        { type: Injector }
+    ]; };
+    /** @nocollapse */ InternalErrorReporter.ngInjectableDef = defineInjectable({ factory: function InternalErrorReporter_Factory() { return new InternalErrorReporter(inject(INJECTOR)); }, token: InternalErrorReporter, providedIn: "root" });
+    return InternalErrorReporter;
+}());
+if (false) {
+    /**
+     * Will be set lazily to be backward compatible.
+     * @type {?}
+     * @private
+     */
+    InternalErrorReporter.prototype._errorHandler;
+    /**
+     * @type {?}
+     * @private
+     */
+    InternalErrorReporter.prototype._injector;
+}
+
 /**
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
@@ -1825,13 +1941,13 @@ var InternalDispatchedActionResults = /** @class */ (function (_super) {
     return InternalDispatchedActionResults;
 }(Subject));
 var InternalDispatcher = /** @class */ (function () {
-    function InternalDispatcher(_injector, _actions, _actionResults, _pluginManager, _stateStream, _ngxsExecutionStrategy) {
-        this._injector = _injector;
+    function InternalDispatcher(_actions, _actionResults, _pluginManager, _stateStream, _ngxsExecutionStrategy, _internalErrorReporter) {
         this._actions = _actions;
         this._actionResults = _actionResults;
         this._pluginManager = _pluginManager;
         this._stateStream = _stateStream;
         this._ngxsExecutionStrategy = _ngxsExecutionStrategy;
+        this._internalErrorReporter = _internalErrorReporter;
     }
     /**
      * Dispatches event(s).
@@ -1855,26 +1971,7 @@ var InternalDispatcher = /** @class */ (function () {
         function () {
             return _this.dispatchByEvents(actionOrActions);
         }));
-        result.subscribe({
-            error: (/**
-             * @param {?} error
-             * @return {?}
-             */
-            function (error) {
-                return _this._ngxsExecutionStrategy.leave((/**
-                 * @return {?}
-                 */
-                function () {
-                    try {
-                        // Retrieve lazily to avoid cyclic dependency exception
-                        _this._errorHandler = _this._errorHandler || _this._injector.get(ErrorHandler);
-                        _this._errorHandler.handleError(error);
-                    }
-                    catch (_a) { }
-                }));
-            })
-        });
-        return result.pipe(leaveNgxs(this._ngxsExecutionStrategy));
+        return result.pipe(ngxsErrorHandler(this._internalErrorReporter, this._ngxsExecutionStrategy));
     };
     /**
      * @private
@@ -1999,26 +2096,16 @@ var InternalDispatcher = /** @class */ (function () {
     ];
     /** @nocollapse */
     InternalDispatcher.ctorParameters = function () { return [
-        { type: Injector },
         { type: InternalActions },
         { type: InternalDispatchedActionResults },
         { type: PluginManager },
         { type: StateStream },
-        { type: InternalNgxsExecutionStrategy }
+        { type: InternalNgxsExecutionStrategy },
+        { type: InternalErrorReporter }
     ]; };
     return InternalDispatcher;
 }());
 if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    InternalDispatcher.prototype._errorHandler;
-    /**
-     * @type {?}
-     * @private
-     */
-    InternalDispatcher.prototype._injector;
     /**
      * @type {?}
      * @private
@@ -2044,6 +2131,11 @@ if (false) {
      * @private
      */
     InternalDispatcher.prototype._ngxsExecutionStrategy;
+    /**
+     * @type {?}
+     * @private
+     */
+    InternalDispatcher.prototype._internalErrorReporter;
 }
 
 /**
@@ -2285,16 +2377,6 @@ var StateContextFactory = /** @class */ (function () {
         function setStateValue(currentAppState, newValue) {
             /** @type {?} */
             var newAppState = setValue(currentAppState, mappedStore.path, newValue);
-            /** @type {?} */
-            var instance = mappedStore.instance;
-            if (instance.ngxsOnChanges) {
-                /** @type {?} */
-                var change = getStateDiffChanges(mappedStore, {
-                    currentAppState: currentAppState,
-                    newAppState: newAppState
-                });
-                instance.ngxsOnChanges(change);
-            }
             root.setState(newAppState);
             return newAppState;
             // In doing this refactoring I noticed that there is a 'bug' where the
@@ -2608,7 +2690,7 @@ var StateFactory = /** @class */ (function () {
         if (Array.isArray(defaults)) {
             value = defaults.slice();
         }
-        else if (isObject$1(defaults)) {
+        else if (isObject(defaults)) {
             value = __assign({}, defaults);
         }
         else if (defaults === undefined) {
@@ -2823,7 +2905,7 @@ var StateFactory = /** @class */ (function () {
                                 if (result instanceof Promise) {
                                     result = from(result);
                                 }
-                                if (result instanceof Observable) {
+                                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
@@ -2840,7 +2922,7 @@ var StateFactory = /** @class */ (function () {
                                         if (value instanceof Promise) {
                                             return from(value);
                                         }
-                                        if (value instanceof Observable) {
+                                        if (isObservable(value)) {
                                             return value;
                                         }
                                         return of(value);
@@ -2933,289 +3015,120 @@ var StateFactory = /** @class */ (function () {
      */
     StateFactory.prototype.addRuntimeInfoToMeta = /**
      * @private
-     * @param {?} meta
-     * @param {?} path
-     * @return {?}
-     */
-    function (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
-     * @param name
-     * @param 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 {?}
-     */
-    StateFactory.prototype.hasBeenMountedAndBootstrapped = /**
-     * \@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 {?}
-     */
-    function (name, path) {
-        /** @type {?} */
-        var valueIsBootstrappedInInitialState = getValue(this._initialState, path) !== undefined;
-        return this.statesByName[name] && valueIsBootstrappedInInitialState;
-    };
-    StateFactory.decorators = [
-        { type: Injectable }
-    ];
-    /** @nocollapse */
-    StateFactory.ctorParameters = function () { return [
-        { 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,] }] }
-    ]; };
-    return StateFactory;
-}());
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    StateFactory.prototype._actionsSubscription;
-    /**
-     * @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;
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-var LifecycleStateManager = /** @class */ (function () {
-    function LifecycleStateManager(internalStateOperations, stateContextFactory, bootstrapper) {
-        this.internalStateOperations = internalStateOperations;
-        this.stateContextFactory = stateContextFactory;
-        this.bootstrapper = bootstrapper;
-    }
-    /**
-     * @template T
-     * @param {?} action
-     * @param {?} results
-     * @return {?}
-     */
-    LifecycleStateManager.prototype.ngxsBootstrap = /**
-     * @template T
-     * @param {?} action
-     * @param {?} results
-     * @return {?}
-     */
-    function (action, results) {
-        var _this = this;
-        this.internalStateOperations
-            .getRootStateOperations()
-            .dispatch(action)
-            .pipe(filter((/**
-         * @return {?}
-         */
-        function () { return !!results; })), tap((/**
-         * @return {?}
-         */
-        function () { return _this.invokeInit((/** @type {?} */ (results)).states); })), mergeMap((/**
-         * @return {?}
-         */
-        function () { return _this.bootstrapper.appBootstrapped$; })), filter((/**
-         * @param {?} appBootstrapped
-         * @return {?}
-         */
-        function (appBootstrapped) { return !!appBootstrapped; })))
-            .subscribe((/**
-         * @return {?}
-         */
-        function () { return _this.invokeBootstrap((/** @type {?} */ (results)).states); }));
-    };
-    /**
-     * Invoke the init function on the states.
-     */
-    /**
-     * Invoke the init function on the states.
-     * @param {?} mappedStores
-     * @return {?}
-     */
-    LifecycleStateManager.prototype.invokeInit = /**
-     * Invoke the init function on the states.
-     * @param {?} mappedStores
-     * @return {?}
-     */
-    function (mappedStores) {
-        var e_1, _a;
-        try {
-            for (var mappedStores_1 = __values(mappedStores), mappedStores_1_1 = mappedStores_1.next(); !mappedStores_1_1.done; mappedStores_1_1 = mappedStores_1.next()) {
-                var mappedStore = mappedStores_1_1.value;
-                /** @type {?} */
-                var instance = mappedStore.instance;
-                if (instance.ngxsOnChanges) {
-                    /** @type {?} */
-                    var currentAppState = {};
-                    /** @type {?} */
-                    var newAppState = this.internalStateOperations
-                        .getRootStateOperations()
-                        .getState();
-                    /** @type {?} */
-                    var firstDiffChange = getStateDiffChanges(mappedStore, {
-                        currentAppState: currentAppState,
-                        newAppState: newAppState
-                    });
-                    instance.ngxsOnChanges(firstDiffChange);
-                }
-                if (instance.ngxsOnInit) {
-                    instance.ngxsOnInit(this.getStateContext(mappedStore));
-                }
-                mappedStore.isInitialised = true;
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (mappedStores_1_1 && !mappedStores_1_1.done && (_a = mappedStores_1.return)) _a.call(mappedStores_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-    };
-    /**
-     * Invoke the bootstrap function on the states.
-     */
-    /**
-     * Invoke the bootstrap function on the states.
-     * @param {?} mappedStores
-     * @return {?}
-     */
-    LifecycleStateManager.prototype.invokeBootstrap = /**
-     * Invoke the bootstrap function on the states.
-     * @param {?} mappedStores
-     * @return {?}
-     */
-    function (mappedStores) {
-        var e_2, _a;
-        try {
-            for (var mappedStores_2 = __values(mappedStores), mappedStores_2_1 = mappedStores_2.next(); !mappedStores_2_1.done; mappedStores_2_1 = mappedStores_2.next()) {
-                var mappedStore = mappedStores_2_1.value;
-                /** @type {?} */
-                var instance = mappedStore.instance;
-                if (instance.ngxsAfterBootstrap) {
-                    instance.ngxsAfterBootstrap(this.getStateContext(mappedStore));
-                }
-            }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (mappedStores_2_1 && !mappedStores_2_1.done && (_a = mappedStores_2.return)) _a.call(mappedStores_2);
-            }
-            finally { if (e_2) throw e_2.error; }
-        }
+     * @param {?} meta
+     * @param {?} path
+     * @return {?}
+     */
+    function (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
+     * @param name
+     * @param path
+     */
+    /**
+     * \@description
+     * the method checks if the state has already been added to the tree
+     * and completed the life cycle
      * @private
-     * @param {?} mappedStore
+     * @param {?} name
+     * @param {?} path
      * @return {?}
      */
-    LifecycleStateManager.prototype.getStateContext = /**
+    StateFactory.prototype.hasBeenMountedAndBootstrapped = /**
+     * \@description
+     * the method checks if the state has already been added to the tree
+     * and completed the life cycle
      * @private
-     * @param {?} mappedStore
+     * @param {?} name
+     * @param {?} path
      * @return {?}
      */
-    function (mappedStore) {
-        return this.stateContextFactory.createStateContext(mappedStore);
+    function (name, path) {
+        /** @type {?} */
+        var valueIsBootstrappedInInitialState = getValue(this._initialState, path) !== undefined;
+        return this.statesByName[name] && valueIsBootstrappedInInitialState;
     };
-    LifecycleStateManager.decorators = [
+    StateFactory.decorators = [
         { type: Injectable }
     ];
     /** @nocollapse */
-    LifecycleStateManager.ctorParameters = function () { return [
-        { type: InternalStateOperations },
+    StateFactory.ctorParameters = function () { return [
+        { type: Injector },
+        { type: NgxsConfig },
+        { type: StateFactory, decorators: [{ type: Optional }, { type: SkipSelf }] },
+        { type: InternalActions },
+        { type: InternalDispatchedActionResults },
         { type: StateContextFactory },
-        { type: NgxsBootstrapper }
+        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [INITIAL_STATE_TOKEN,] }] }
     ]; };
-    return LifecycleStateManager;
+    return StateFactory;
 }());
 if (false) {
     /**
      * @type {?}
      * @private
      */
-    LifecycleStateManager.prototype.internalStateOperations;
+    StateFactory.prototype._actionsSubscription;
+    /**
+     * @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
      */
-    LifecycleStateManager.prototype.stateContextFactory;
+    StateFactory.prototype._stateContextFactory;
     /**
      * @type {?}
      * @private
      */
-    LifecycleStateManager.prototype.bootstrapper;
+    StateFactory.prototype._initialState;
 }
 
 /**
@@ -3672,6 +3585,218 @@ if (false) {
     Store.prototype._stateFactory;
 }
 
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+var LifecycleStateManager = /** @class */ (function () {
+    function LifecycleStateManager(_store, _internalErrorReporter, _internalStateOperations, _stateContextFactory, _bootstrapper) {
+        this._store = _store;
+        this._internalErrorReporter = _internalErrorReporter;
+        this._internalStateOperations = _internalStateOperations;
+        this._stateContextFactory = _stateContextFactory;
+        this._bootstrapper = _bootstrapper;
+        this._destroy$ = new Subject();
+    }
+    /**
+     * @return {?}
+     */
+    LifecycleStateManager.prototype.ngOnDestroy = /**
+     * @return {?}
+     */
+    function () {
+        this._destroy$.next();
+    };
+    /**
+     * @template T
+     * @param {?} action
+     * @param {?} results
+     * @return {?}
+     */
+    LifecycleStateManager.prototype.ngxsBootstrap = /**
+     * @template T
+     * @param {?} action
+     * @param {?} results
+     * @return {?}
+     */
+    function (action, results) {
+        var _this = this;
+        this._internalStateOperations
+            .getRootStateOperations()
+            .dispatch(action)
+            .pipe(filter((/**
+         * @return {?}
+         */
+        function () { return !!results; })), tap((/**
+         * @return {?}
+         */
+        function () { return _this._invokeInitOnStates((/** @type {?} */ (results)).states); })), mergeMap((/**
+         * @return {?}
+         */
+        function () { return _this._bootstrapper.appBootstrapped$; })), filter((/**
+         * @param {?} appBootstrapped
+         * @return {?}
+         */
+        function (appBootstrapped) { return !!appBootstrapped; })), catchError((/**
+         * @param {?} error
+         * @return {?}
+         */
+        function (error) {
+            // The `SafeSubscriber` (which is used by most RxJS operators) re-throws
+            // errors asynchronously (`setTimeout(() => { throw error })`). This might
+            // break existing user's code or unit tests. We catch the error manually to
+            // be backward compatible with the old behavior.
+            _this._internalErrorReporter.reportErrorSafely(error);
+            return EMPTY;
+        })), takeUntil(this._destroy$))
+            .subscribe((/**
+         * @return {?}
+         */
+        function () { return _this._invokeBootstrapOnStates((/** @type {?} */ (results)).states); }));
+    };
+    /**
+     * @private
+     * @param {?} mappedStores
+     * @return {?}
+     */
+    LifecycleStateManager.prototype._invokeInitOnStates = /**
+     * @private
+     * @param {?} mappedStores
+     * @return {?}
+     */
+    function (mappedStores) {
+        var e_1, _a;
+        var _loop_1 = function (mappedStore) {
+            /** @type {?} */
+            var instance = mappedStore.instance;
+            if (instance.ngxsOnChanges) {
+                this_1._store
+                    .select((/**
+                 * @param {?} state
+                 * @return {?}
+                 */
+                function (state) { return getValue(state, mappedStore.path); }))
+                    .pipe(startWith(undefined), pairwise(), takeUntil(this_1._destroy$))
+                    .subscribe((/**
+                 * @param {?} __0
+                 * @return {?}
+                 */
+                function (_a) {
+                    var _b = __read(_a, 2), previousValue = _b[0], currentValue = _b[1];
+                    /** @type {?} */
+                    var change = new NgxsSimpleChange(previousValue, currentValue, !mappedStore.isInitialised);
+                    (/** @type {?} */ (instance.ngxsOnChanges))(change);
+                }));
+            }
+            if (instance.ngxsOnInit) {
+                instance.ngxsOnInit(this_1._getStateContext(mappedStore));
+            }
+            mappedStore.isInitialised = true;
+        };
+        var this_1 = this;
+        try {
+            for (var mappedStores_1 = __values(mappedStores), mappedStores_1_1 = mappedStores_1.next(); !mappedStores_1_1.done; mappedStores_1_1 = mappedStores_1.next()) {
+                var mappedStore = mappedStores_1_1.value;
+                _loop_1(mappedStore);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (mappedStores_1_1 && !mappedStores_1_1.done && (_a = mappedStores_1.return)) _a.call(mappedStores_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    };
+    /**
+     * @private
+     * @param {?} mappedStores
+     * @return {?}
+     */
+    LifecycleStateManager.prototype._invokeBootstrapOnStates = /**
+     * @private
+     * @param {?} mappedStores
+     * @return {?}
+     */
+    function (mappedStores) {
+        var e_2, _a;
+        try {
+            for (var mappedStores_2 = __values(mappedStores), mappedStores_2_1 = mappedStores_2.next(); !mappedStores_2_1.done; mappedStores_2_1 = mappedStores_2.next()) {
+                var mappedStore = mappedStores_2_1.value;
+                /** @type {?} */
+                var instance = mappedStore.instance;
+                if (instance.ngxsAfterBootstrap) {
+                    instance.ngxsAfterBootstrap(this._getStateContext(mappedStore));
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (mappedStores_2_1 && !mappedStores_2_1.done && (_a = mappedStores_2.return)) _a.call(mappedStores_2);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+    };
+    /**
+     * @private
+     * @param {?} mappedStore
+     * @return {?}
+     */
+    LifecycleStateManager.prototype._getStateContext = /**
+     * @private
+     * @param {?} mappedStore
+     * @return {?}
+     */
+    function (mappedStore) {
+        return this._stateContextFactory.createStateContext(mappedStore);
+    };
+    LifecycleStateManager.decorators = [
+        { type: Injectable }
+    ];
+    /** @nocollapse */
+    LifecycleStateManager.ctorParameters = function () { return [
+        { type: Store },
+        { type: InternalErrorReporter },
+        { type: InternalStateOperations },
+        { type: StateContextFactory },
+        { type: NgxsBootstrapper }
+    ]; };
+    return LifecycleStateManager;
+}());
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    LifecycleStateManager.prototype._destroy$;
+    /**
+     * @type {?}
+     * @private
+     */
+    LifecycleStateManager.prototype._store;
+    /**
+     * @type {?}
+     * @private
+     */
+    LifecycleStateManager.prototype._internalErrorReporter;
+    /**
+     * @type {?}
+     * @private
+     */
+    LifecycleStateManager.prototype._internalStateOperations;
+    /**
+     * @type {?}
+     * @private
+     */
+    LifecycleStateManager.prototype._stateContextFactory;
+    /**
+     * @type {?}
+     * @private
+     */
+    LifecycleStateManager.prototype._bootstrapper;
+}
+
 /**
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
@@ -4494,5 +4619,5 @@ if (false) {
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 
-export { Action, Actions, InitState, NGXS_PLUGINS, NgxsModule, NgxsSimpleChange, NoopNgxsExecutionStrategy, Select, Selector, SelectorOptions, State, StateStream, StateToken, Store, UpdateState, actionMatcher, createSelector, ensureSelectorMetadata$1 as ensureSelectorMetadata, ensureStoreMetadata$1 as ensureStoreMetadata, getActionTypeFromInstance, getSelectorMetadata$1 as getSelectorMetadata, getStoreMetadata$1 as getStoreMetadata, getValue, ofAction, ofActionCanceled, ofActionCompleted, ofActionDispatched, ofActionErrored, ofActionSuccessful, setValue, OrderedSubject as ɵa, InternalActions as ɵb, ROOT_STATE_TOKEN as ɵc, FEATURE_STATE_TOKEN as ɵd, SELECTOR_META_KEY as ɵe, NgxsConfig as ɵf, mergeDeep as ɵg, USER_PROVIDED_NGXS_EXECUTION_STRATEGY as ɵh, NGXS_EXECUTION_STRATEGY as ɵi, NgxsRootModule as ɵj, StateFactory as ɵk, InternalDispatchedActionResults as ɵl, InternalDispatcher as ɵm, StateContextFactory as ɵn, InternalStateOperations as ɵo, PluginManager as ɵp, InternalNgxsExecutionStrategy as ɵq, SelectFactory as ɵr, ensureStoreMetadata as ɵt, getStoreMetadata as ɵu, ensureSelectorMetadata as ɵv, getSelectorMetadata as ɵw, LifecycleStateManager as ɵx, NgxsFeatureModule as ɵy };
+export { Action, Actions, InitState, NGXS_PLUGINS, NgxsModule, NgxsSimpleChange, NoopNgxsExecutionStrategy, Select, Selector, SelectorOptions, State, StateStream, StateToken, Store, UpdateState, actionMatcher, createSelector, ensureSelectorMetadata$1 as ensureSelectorMetadata, ensureStoreMetadata$1 as ensureStoreMetadata, getActionTypeFromInstance, getSelectorMetadata$1 as getSelectorMetadata, getStoreMetadata$1 as getStoreMetadata, getValue, ofAction, ofActionCanceled, ofActionCompleted, ofActionDispatched, ofActionErrored, ofActionSuccessful, setValue, OrderedSubject as ɵa, InternalActions as ɵb, ROOT_STATE_TOKEN as ɵc, FEATURE_STATE_TOKEN as ɵd, SELECTOR_META_KEY as ɵe, NgxsConfig as ɵf, mergeDeep as ɵg, USER_PROVIDED_NGXS_EXECUTION_STRATEGY as ɵh, NGXS_EXECUTION_STRATEGY as ɵi, NgxsRootModule as ɵj, StateFactory as ɵk, InternalDispatchedActionResults as ɵl, InternalDispatcher as ɵm, StateContextFactory as ɵn, InternalStateOperations as ɵo, PluginManager as ɵp, InternalNgxsExecutionStrategy as ɵq, InternalErrorReporter as ɵr, SelectFactory as ɵs, ensureStoreMetadata as ɵu, getStoreMetadata as ɵv, ensureSelectorMetadata as ɵw, getSelectorMetadata as ɵx, LifecycleStateManager as ɵy, NgxsFeatureModule as ɵz };
 //# sourceMappingURL=ngxs-store.js.map