@ngxs/store 3.7.5-dev.master-708406e → 3.7.5-dev.master-0da56b4

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 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$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 getStateDiffChanges(mappedStore, diff) {
-        /** @type {?} */
-        var previousValue = getValue(diff.currentAppState, mappedStore.path);
+    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 currentValue = getValue(diff.newAppState, mappedStore.path);
-        return new NgxsSimpleChange(previousValue, currentValue, !mappedStore.isInitialised);
-    }
+        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
@@ -1810,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 }
         ];
@@ -2507,16 +2492,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
@@ -2830,7 +2805,7 @@
             if (Array.isArray(defaults)) {
                 value = defaults.slice();
             }
-            else if (isObject$1(defaults)) {
+            else if (isObject(defaults)) {
                 value = __assign({}, defaults);
             }
             else if (defaults === undefined) {
@@ -3159,285 +3134,116 @@
          * @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; }
-            }
+        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;
     }
 
     /**
@@ -3894,6 +3700,210 @@
         Store.prototype._stateFactory;
     }
 
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var LifecycleStateManager = /** @class */ (function () {
+        function LifecycleStateManager(_store, _internalStateOperations, _stateContextFactory, _bootstrapper) {
+            this._store = _store;
+            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._invokeInit((/** @type {?} */ (results)).states); })), operators.mergeMap((/**
+             * @return {?}
+             */
+            function () { return _this._bootstrapper.appBootstrapped$; })), operators.filter((/**
+             * @param {?} appBootstrapped
+             * @return {?}
+             */
+            function (appBootstrapped) { return !!appBootstrapped; })), operators.takeUntil(this._destroy$))
+                .subscribe((/**
+             * @return {?}
+             */
+            function () { return _this._invokeBootstrap((/** @type {?} */ (results)).states); }));
+        };
+        /**
+         * Invoke the init function on the states.
+         */
+        /**
+         * Invoke the init function on the states.
+         * @private
+         * @param {?} mappedStores
+         * @return {?}
+         */
+        LifecycleStateManager.prototype._invokeInit = /**
+         * Invoke the init function on the states.
+         * @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; }
+            }
+        };
+        /**
+         * Invoke the bootstrap function on the states.
+         */
+        /**
+         * Invoke the bootstrap function on the states.
+         * @private
+         * @param {?} mappedStores
+         * @return {?}
+         */
+        LifecycleStateManager.prototype._invokeBootstrap = /**
+         * Invoke the bootstrap function on the states.
+         * @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: InternalStateOperations },
+            { type: StateContextFactory },
+            { type: internals.NgxsBootstrapper }
+        ]; };
+        return LifecycleStateManager;
+    }());
+    if (false) {
+        /**
+         * @type {?}
+         * @private
+         */
+        LifecycleStateManager.prototype._destroy$;
+        /**
+         * @type {?}
+         * @private
+         */
+        LifecycleStateManager.prototype._store;
+        /**
+         * @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