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

package/fesm5/ngxs-store.js

@@ -1,9 +1,9 @@
-import { __assign, __spread, __extends, __values } from 'tslib';
+import { __assign, __spread, __extends, __values, __read } 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 { 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, isObservable, queueScheduler } from 'rxjs';
-import { filter, map, shareReplay, take, exhaustMap, mergeMap, defaultIfEmpty, catchError, takeUntil, tap, observeOn, distinctUntilChanged } from 'rxjs/operators';
+import { filter, map, 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 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
@@ -1592,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 }
     ];
@@ -2289,16 +2274,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
@@ -2612,7 +2587,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) {
@@ -2941,285 +2916,116 @@ var StateFactory = /** @class */ (function () {
      * @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; }
-        }
+    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;
 }
 
 /**
@@ -3676,6 +3482,210 @@ 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, _internalStateOperations, _stateContextFactory, _bootstrapper) {
+        this._store = _store;
+        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._invokeInit((/** @type {?} */ (results)).states); })), mergeMap((/**
+         * @return {?}
+         */
+        function () { return _this._bootstrapper.appBootstrapped$; })), filter((/**
+         * @param {?} appBootstrapped
+         * @return {?}
+         */
+        function (appBootstrapped) { return !!appBootstrapped; })), 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(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; }
+        }
+    };
+    /**
+     * 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: Injectable }
+    ];
+    /** @nocollapse */
+    LifecycleStateManager.ctorParameters = function () { return [
+        { type: Store },
+        { type: InternalStateOperations },
+        { type: StateContextFactory },
+        { type: 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