@ngxs/store 3.7.5 → 3.7.6-dev.master-95e4742

package/bundles/ngxs-store.umd.js

@@ -730,156 +730,6 @@
         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
@@ -1004,17 +854,6 @@
         /** @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.
      *
@@ -1356,22 +1195,159 @@
      * @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
@@ -1392,6 +1368,7 @@
      * 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 {?}
      */
@@ -1406,6 +1383,7 @@
      * RxJS operator for selecting out specific actions.
      *
      * This will ONLY grab actions that have just been dispatched
+     * @template T
      * @param {...?} allowedTypes
      * @return {?}
      */
@@ -1420,6 +1398,7 @@
      * RxJS operator for selecting out specific actions.
      *
      * This will ONLY grab actions that have just been successfully completed
+     * @template T
      * @param {...?} allowedTypes
      * @return {?}
      */
@@ -1434,6 +1413,7 @@
      * RxJS operator for selecting out specific actions.
      *
      * This will ONLY grab actions that have just been canceled
+     * @template T
      * @param {...?} allowedTypes
      * @return {?}
      */
@@ -1448,6 +1428,7 @@
      * RxJS operator for selecting out specific actions.
      *
      * This will ONLY grab actions that have just been completed
+     * @template T
      * @param {...?} allowedTypes
      * @return {?}
      */
@@ -1468,6 +1449,7 @@
      * RxJS operator for selecting out specific actions.
      *
      * This will ONLY grab actions that have just thrown an error
+     * @template T
      * @param {...?} allowedTypes
      * @return {?}
      */
@@ -1804,6 +1786,15 @@
         function InternalActions() {
             return _super !== null && _super.apply(this, arguments) || this;
         }
+        /**
+         * @return {?}
+         */
+        InternalActions.prototype.ngOnDestroy = /**
+         * @return {?}
+         */
+        function () {
+            this.complete();
+        };
         InternalActions.decorators = [
             { type: core.Injectable }
         ];
@@ -1816,18 +1807,22 @@
      */
     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.
+            operators.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 {?}
@@ -1845,6 +1840,7 @@
                 });
                 observer.add(childSubscription);
             })) || this;
+            return _this;
         }
         Actions.decorators = [
             { type: core.Injectable }
@@ -1911,6 +1907,126 @@
             })]));
     }); });
 
+    /**
+     * @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 rxjs.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(core.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: core.Injectable, args: [{ providedIn: 'root' },] }
+        ];
+        /** @nocollapse */
+        InternalErrorReporter.ctorParameters = function () { return [
+            { type: core.Injector }
+        ]; };
+        /** @nocollapse */ InternalErrorReporter.ngInjectableDef = core.defineInjectable({ factory: function InternalErrorReporter_Factory() { return new InternalErrorReporter(core.inject(core.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
@@ -2043,13 +2159,13 @@
         return InternalDispatchedActionResults;
     }(rxjs.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).
@@ -2073,26 +2189,7 @@
             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(core.ErrorHandler);
-                            _this._errorHandler.handleError(error);
-                        }
-                        catch (_a) { }
-                    }));
-                })
-            });
-            return result.pipe(leaveNgxs(this._ngxsExecutionStrategy));
+            return result.pipe(ngxsErrorHandler(this._internalErrorReporter, this._ngxsExecutionStrategy));
         };
         /**
          * @private
@@ -2217,26 +2314,16 @@
         ];
         /** @nocollapse */
         InternalDispatcher.ctorParameters = function () { return [
-            { type: core.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
@@ -2262,6 +2349,11 @@
          * @private
          */
         InternalDispatcher.prototype._ngxsExecutionStrategy;
+        /**
+         * @type {?}
+         * @private
+         */
+        InternalDispatcher.prototype._internalErrorReporter;
     }
 
     /**
@@ -2503,16 +2595,6 @@
             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
@@ -2826,7 +2908,7 @@
             if (Array.isArray(defaults)) {
                 value = defaults.slice();
             }
-            else if (isObject$1(defaults)) {
+            else if (isObject(defaults)) {
                 value = __assign({}, defaults);
             }
             else if (defaults === undefined) {
@@ -3041,7 +3123,7 @@
                                     if (result instanceof Promise) {
                                         result = rxjs.from(result);
                                     }
-                                    if (result instanceof rxjs.Observable) {
+                                    if (rxjs.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
@@ -3058,7 +3140,7 @@
                                             if (value instanceof Promise) {
                                                 return rxjs.from(value);
                                             }
-                                            if (value instanceof rxjs.Observable) {
+                                            if (rxjs.isObservable(value)) {
                                                 return value;
                                             }
                                             return rxjs.of(value);
@@ -3151,289 +3233,120 @@
          */
         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: core.Injectable }
-        ];
-        /** @nocollapse */
-        StateFactory.ctorParameters = function () { return [
-            { type: core.Injector },
-            { type: NgxsConfig },
-            { type: StateFactory, decorators: [{ type: core.Optional }, { type: core.SkipSelf }] },
-            { type: InternalActions },
-            { type: InternalDispatchedActionResults },
-            { type: StateContextFactory },
-            { type: undefined, decorators: [{ type: core.Optional }, { type: core.Inject, args: [internals.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(operators.filter((/**
-             * @return {?}
-             */
-            function () { return !!results; })), operators.tap((/**
-             * @return {?}
-             */
-            function () { return _this.invokeInit((/** @type {?} */ (results)).states); })), operators.mergeMap((/**
-             * @return {?}
-             */
-            function () { return _this.bootstrapper.appBootstrapped$; })), operators.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: core.Injectable }
         ];
         /** @nocollapse */
-        LifecycleStateManager.ctorParameters = function () { return [
-            { type: InternalStateOperations },
+        StateFactory.ctorParameters = function () { return [
+            { type: core.Injector },
+            { type: NgxsConfig },
+            { type: StateFactory, decorators: [{ type: core.Optional }, { type: core.SkipSelf }] },
+            { type: InternalActions },
+            { type: InternalDispatchedActionResults },
             { type: StateContextFactory },
-            { type: internals.NgxsBootstrapper }
+            { type: undefined, decorators: [{ type: core.Optional }, { type: core.Inject, args: [internals.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;
     }
 
     /**
@@ -3890,6 +3803,218 @@
         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 rxjs.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(operators.filter((/**
+             * @return {?}
+             */
+            function () { return !!results; })), operators.tap((/**
+             * @return {?}
+             */
+            function () { return _this._invokeInitOnStates((/** @type {?} */ (results)).states); })), operators.mergeMap((/**
+             * @return {?}
+             */
+            function () { return _this._bootstrapper.appBootstrapped$; })), operators.filter((/**
+             * @param {?} appBootstrapped
+             * @return {?}
+             */
+            function (appBootstrapped) { return !!appBootstrapped; })), operators.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 rxjs.EMPTY;
+            })), operators.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(operators.startWith(undefined), operators.pairwise(), operators.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: core.Injectable }
+        ];
+        /** @nocollapse */
+        LifecycleStateManager.ctorParameters = function () { return [
+            { type: Store },
+            { type: InternalErrorReporter },
+            { type: InternalStateOperations },
+            { type: StateContextFactory },
+            { type: internals.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
@@ -4739,13 +4864,14 @@
     exports.ɵo = InternalStateOperations;
     exports.ɵp = PluginManager;
     exports.ɵq = InternalNgxsExecutionStrategy;
-    exports.ɵr = SelectFactory;
-    exports.ɵt = ensureStoreMetadata;
-    exports.ɵu = getStoreMetadata;
-    exports.ɵv = ensureSelectorMetadata;
-    exports.ɵw = getSelectorMetadata;
-    exports.ɵx = LifecycleStateManager;
-    exports.ɵy = NgxsFeatureModule;
+    exports.ɵr = InternalErrorReporter;
+    exports.ɵs = SelectFactory;
+    exports.ɵu = ensureStoreMetadata;
+    exports.ɵv = getStoreMetadata;
+    exports.ɵw = ensureSelectorMetadata;
+    exports.ɵx = getSelectorMetadata;
+    exports.ɵy = LifecycleStateManager;
+    exports.ɵz = NgxsFeatureModule;
 
     Object.defineProperty(exports, '__esModule', { value: true });