@ngxs/store 3.7.5 → 3.7.6

package/fesm2015/ngxs-store.js

@@ -1,8 +1,8 @@
-import { NgZone, Injectable, Inject, PLATFORM_ID, defineInjectable, inject, InjectionToken, INJECTOR, ɵglobal, Optional, SkipSelf, ErrorHandler, Injector, ɵivyEnabled, NgModule, APP_BOOTSTRAP_LISTENER } from '@angular/core';
+import { NgZone, Injectable, Inject, PLATFORM_ID, defineInjectable, inject, InjectionToken, INJECTOR, ɵglobal, ErrorHandler, Injector, Optional, SkipSelf, ɵivyEnabled, NgModule, APP_BOOTSTRAP_LISTENER } from '@angular/core';
 import { memoize, INITIAL_STATE_TOKEN, NgxsBootstrapper, NGXS_STATE_CONTEXT_FACTORY, NGXS_STATE_FACTORY, InitialState } from '@ngxs/store/internals';
 import { isPlatformServer } from '@angular/common';
-import { Observable, Subject, BehaviorSubject, of, forkJoin, throwError, EMPTY, from, queueScheduler } from 'rxjs';
-import { filter, map, shareReplay, take, exhaustMap, mergeMap, defaultIfEmpty, catchError, takeUntil, tap, observeOn, distinctUntilChanged } from 'rxjs/operators';
+import { Observable, Subject, BehaviorSubject, of, forkJoin, throwError, EMPTY, from, isObservable, queueScheduler } from 'rxjs';
+import { filter, map, share, shareReplay, take, exhaustMap, mergeMap, defaultIfEmpty, catchError, takeUntil, observeOn, distinctUntilChanged, tap, startWith, pairwise } from 'rxjs/operators';
 
 /**
  * @fileoverview added by tsickle
@@ -477,149 +477,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 {?} */
-    const 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 {?}
- */
-const setValue = (/**
- * @param {?} obj
- * @param {?} prop
- * @param {?} val
- * @return {?}
- */
-(obj, prop, val) => {
-    obj = Object.assign({}, obj);
-    /** @type {?} */
-    const split = prop.split('.');
-    /** @type {?} */
-    const lastIndex = split.length - 1;
-    split.reduce((/**
-     * @param {?} acc
-     * @param {?} part
-     * @param {?} index
-     * @return {?}
-     */
-    (acc, part, index) => {
-        if (index === lastIndex) {
-            acc[part] = val;
-        }
-        else {
-            acc[part] = Array.isArray(acc[part]) ? acc[part].slice() : Object.assign({}, acc[part]);
-        }
-        return acc && acc[part];
-    }), obj);
-    return obj;
-});
-/**
- * Get a deeply nested value. Example:
- *
- *    getValue({ foo: bar: [] }, 'foo.bar') //=> []
- *
- * @ignore
- * @type {?}
- */
-const getValue = (/**
- * @param {?} obj
- * @param {?} prop
- * @return {?}
- */
-(obj, prop) => prop.split('.').reduce((/**
- * @param {?} acc
- * @param {?} part
- * @return {?}
- */
-(acc, part) => acc && acc[part]), obj));
-/**
- * Simple object check.
- *
- *    isObject({a:1}) //=> true
- *    isObject(1) //=> false
- *
- * @ignore
- * @type {?}
- */
-const isObject = (/**
- * @param {?} item
- * @return {?}
- */
-(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 {?}
- */
-const mergeDeep = (/**
- * @param {?} base
- * @param {...?} sources
- * @return {?}
- */
-(base, ...sources) => {
-    if (!sources.length)
-        return base;
-    /** @type {?} */
-    const source = sources.shift();
-    if (isObject(base) && isObject(source)) {
-        for (const key in source) {
-            if (isObject(source[key])) {
-                if (!base[key])
-                    Object.assign(base, { [key]: {} });
-                mergeDeep(base[key], source[key]);
-            }
-            else {
-                Object.assign(base, { [key]: source[key] });
-            }
-        }
-    }
-    return mergeDeep(base, ...sources);
-});
-
 /**
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
@@ -744,17 +601,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.
  *
@@ -1094,22 +940,152 @@ function topologicalSort(graph) {
  * @param {?} obj
  * @return {?}
  */
-function isObject$1(obj) {
+function isObject(obj) {
     return (typeof obj === 'object' && obj !== null) || typeof obj === 'function';
 }
+
 /**
- * @template T
- * @param {?} mappedStore
- * @param {?} diff
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * Returns the type from an action instance/class.
+ * @ignore
+ * @param {?} action
  * @return {?}
  */
-function getStateDiffChanges(mappedStore, diff) {
-    /** @type {?} */
-    const 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 {?} */
-    const currentValue = getValue(diff.newAppState, mappedStore.path);
-    return new NgxsSimpleChange(previousValue, currentValue, !mappedStore.isInitialised);
+    const 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 {?}
+ */
+const setValue = (/**
+ * @param {?} obj
+ * @param {?} prop
+ * @param {?} val
+ * @return {?}
+ */
+(obj, prop, val) => {
+    obj = Object.assign({}, obj);
+    /** @type {?} */
+    const split = prop.split('.');
+    /** @type {?} */
+    const lastIndex = split.length - 1;
+    split.reduce((/**
+     * @param {?} acc
+     * @param {?} part
+     * @param {?} index
+     * @return {?}
+     */
+    (acc, part, index) => {
+        if (index === lastIndex) {
+            acc[part] = val;
+        }
+        else {
+            acc[part] = Array.isArray(acc[part]) ? acc[part].slice() : Object.assign({}, acc[part]);
+        }
+        return acc && acc[part];
+    }), obj);
+    return obj;
+});
+/**
+ * Get a deeply nested value. Example:
+ *
+ *    getValue({ foo: bar: [] }, 'foo.bar') //=> []
+ *
+ * @ignore
+ * @type {?}
+ */
+const getValue = (/**
+ * @param {?} obj
+ * @param {?} prop
+ * @return {?}
+ */
+(obj, prop) => prop.split('.').reduce((/**
+ * @param {?} acc
+ * @param {?} part
+ * @return {?}
+ */
+(acc, part) => acc && acc[part]), obj));
+/**
+ * Simple object check.
+ *
+ *    isObject({a:1}) //=> true
+ *    isObject(1) //=> false
+ *
+ * @ignore
+ * @type {?}
+ */
+const isObject$1 = (/**
+ * @param {?} item
+ * @return {?}
+ */
+(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 {?}
+ */
+const mergeDeep = (/**
+ * @param {?} base
+ * @param {...?} sources
+ * @return {?}
+ */
+(base, ...sources) => {
+    if (!sources.length)
+        return base;
+    /** @type {?} */
+    const source = sources.shift();
+    if (isObject$1(base) && isObject$1(source)) {
+        for (const key in source) {
+            if (isObject$1(source[key])) {
+                if (!base[key])
+                    Object.assign(base, { [key]: {} });
+                mergeDeep(base[key], source[key]);
+            }
+            else {
+                Object.assign(base, { [key]: source[key] });
+            }
+        }
+    }
+    return mergeDeep(base, ...sources);
+});
 
 /**
  * @fileoverview added by tsickle
@@ -1481,6 +1457,12 @@ if (false) {
  * Internal Action stream that is emitted anytime an action is dispatched.
  */
 class InternalActions extends OrderedSubject {
+    /**
+     * @return {?}
+     */
+    ngOnDestroy() {
+        this.complete();
+    }
 }
 InternalActions.decorators = [
     { type: Injectable }
@@ -1498,15 +1480,20 @@ class Actions extends Observable {
      * @param {?} internalExecutionStrategy
      */
     constructor(internalActions$, internalExecutionStrategy) {
+        /** @type {?} */
+        const sharedInternalActions$ = internalActions$.pipe(leaveNgxs(internalExecutionStrategy), 
+        // The `InternalActions` subject emits outside of the Angular zone.
+        // We have to re-enter the Angular zone for any incoming consumer.
+        // The `share()` operator reduces the number of change detections.
+        // This would call leave only once for any stream emission across all active subscribers.
+        share());
         super((/**
          * @param {?} observer
          * @return {?}
          */
         observer => {
             /** @type {?} */
-            const childSubscription = internalActions$
-                .pipe(leaveNgxs(internalExecutionStrategy))
-                .subscribe({
+            const childSubscription = sharedInternalActions$.subscribe({
                 next: (/**
                  * @param {?} ctx
                  * @return {?}
@@ -1576,8 +1563,122 @@ const compose = (/**
      * @param {...?} nextArgs
      * @return {?}
      */
-    (...nextArgs) => compose(funcs)(...nextArgs)));
-}));
+    (...nextArgs) => compose(funcs)(...nextArgs)));
+}));
+
+/**
+ * @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 {?}
+     */
+    (source) => {
+        /** @type {?} */
+        let subscribed = false;
+        source.subscribe({
+            error: (/**
+             * @param {?} error
+             * @return {?}
+             */
+            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 {?}
+                 */
+                () => Promise.resolve().then((/**
+                 * @return {?}
+                 */
+                () => {
+                    if (!subscribed) {
+                        ngxsExecutionStrategy.leave((/**
+                         * @return {?}
+                         */
+                        () => internalErrorReporter.reportErrorSafely(error)));
+                    }
+                }))));
+            })
+        });
+        return new Observable((/**
+         * @param {?} subscriber
+         * @return {?}
+         */
+        subscriber => {
+            subscribed = true;
+            return source.pipe(leaveNgxs(ngxsExecutionStrategy)).subscribe(subscriber);
+        }));
+    });
+}
+class InternalErrorReporter {
+    /**
+     * @param {?} _injector
+     */
+    constructor(_injector) {
+        this._injector = _injector;
+        /**
+         * Will be set lazily to be backward compatible.
+         */
+        this._errorHandler = (/** @type {?} */ (null));
+    }
+    /**
+     * @param {?} error
+     * @return {?}
+     */
+    reportErrorSafely(error) {
+        if (this._errorHandler === null) {
+            this._errorHandler = this._injector.get(ErrorHandler);
+        }
+        // The `try-catch` is used to avoid handling the error twice. Suppose we call
+        // `handleError` which re-throws the error internally. The re-thrown error will
+        // be caught by zone.js which will then get to the `zone.onError.emit()` and the
+        // `onError` subscriber will call `handleError` again.
+        try {
+            this._errorHandler.handleError(error);
+        }
+        catch (_a) { }
+    }
+}
+InternalErrorReporter.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+/** @nocollapse */
+InternalErrorReporter.ctorParameters = () => [
+    { type: Injector }
+];
+/** @nocollapse */ InternalErrorReporter.ngInjectableDef = defineInjectable({ factory: function InternalErrorReporter_Factory() { return new InternalErrorReporter(inject(INJECTOR)); }, token: InternalErrorReporter, providedIn: "root" });
+if (false) {
+    /**
+     * Will be set lazily to be backward compatible.
+     * @type {?}
+     * @private
+     */
+    InternalErrorReporter.prototype._errorHandler;
+    /**
+     * @type {?}
+     * @private
+     */
+    InternalErrorReporter.prototype._injector;
+}
 
 /**
  * @fileoverview added by tsickle
@@ -1692,20 +1793,20 @@ InternalDispatchedActionResults.decorators = [
 ];
 class InternalDispatcher {
     /**
-     * @param {?} _injector
      * @param {?} _actions
      * @param {?} _actionResults
      * @param {?} _pluginManager
      * @param {?} _stateStream
      * @param {?} _ngxsExecutionStrategy
+     * @param {?} _internalErrorReporter
      */
-    constructor(_injector, _actions, _actionResults, _pluginManager, _stateStream, _ngxsExecutionStrategy) {
-        this._injector = _injector;
+    constructor(_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).
@@ -1718,24 +1819,7 @@ class InternalDispatcher {
          * @return {?}
          */
         () => this.dispatchByEvents(actionOrActions)));
-        result.subscribe({
-            error: (/**
-             * @param {?} error
-             * @return {?}
-             */
-            error => this._ngxsExecutionStrategy.leave((/**
-             * @return {?}
-             */
-            () => {
-                try {
-                    // Retrieve lazily to avoid cyclic dependency exception
-                    this._errorHandler = this._errorHandler || this._injector.get(ErrorHandler);
-                    this._errorHandler.handleError(error);
-                }
-                catch (_a) { }
-            })))
-        });
-        return result.pipe(leaveNgxs(this._ngxsExecutionStrategy));
+        return result.pipe(ngxsErrorHandler(this._internalErrorReporter, this._ngxsExecutionStrategy));
     }
     /**
      * @private
@@ -1839,24 +1923,14 @@ InternalDispatcher.decorators = [
 ];
 /** @nocollapse */
 InternalDispatcher.ctorParameters = () => [
-    { type: Injector },
     { type: InternalActions },
     { type: InternalDispatchedActionResults },
     { type: PluginManager },
     { type: StateStream },
-    { type: InternalNgxsExecutionStrategy }
+    { type: InternalNgxsExecutionStrategy },
+    { type: InternalErrorReporter }
 ];
 if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    InternalDispatcher.prototype._errorHandler;
-    /**
-     * @type {?}
-     * @private
-     */
-    InternalDispatcher.prototype._injector;
     /**
      * @type {?}
      * @private
@@ -1882,6 +1956,11 @@ if (false) {
      * @private
      */
     InternalDispatcher.prototype._ngxsExecutionStrategy;
+    /**
+     * @type {?}
+     * @private
+     */
+    InternalDispatcher.prototype._internalErrorReporter;
 }
 
 /**
@@ -2109,16 +2188,6 @@ class StateContextFactory {
         function setStateValue(currentAppState, newValue) {
             /** @type {?} */
             const newAppState = setValue(currentAppState, mappedStore.path, newValue);
-            /** @type {?} */
-            const instance = mappedStore.instance;
-            if (instance.ngxsOnChanges) {
-                /** @type {?} */
-                const change = getStateDiffChanges(mappedStore, {
-                    currentAppState,
-                    newAppState
-                });
-                instance.ngxsOnChanges(change);
-            }
             root.setState(newAppState);
             return newAppState;
             // In doing this refactoring I noticed that there is a 'bug' where the
@@ -2401,7 +2470,7 @@ class StateFactory {
         if (Array.isArray(defaults)) {
             value = defaults.slice();
         }
-        else if (isObject$1(defaults)) {
+        else if (isObject(defaults)) {
             value = Object.assign({}, defaults);
         }
         else if (defaults === undefined) {
@@ -2560,7 +2629,7 @@ class StateFactory {
                         if (result instanceof Promise) {
                             result = from(result);
                         }
-                        if (result instanceof Observable) {
+                        if (isObservable(result)) {
                             // If this observable has been completed w/o emitting
                             // any value then we wouldn't want to complete the whole chain
                             // of actions. Since if any observable completes then
@@ -2577,7 +2646,7 @@ class StateFactory {
                                 if (value instanceof Promise) {
                                     return from(value);
                                 }
-                                if (value instanceof Observable) {
+                                if (isObservable(value)) {
                                     return value;
                                 }
                                 return of(value);
@@ -2731,129 +2800,6 @@ if (false) {
     StateFactory.prototype._initialState;
 }
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-class LifecycleStateManager {
-    /**
-     * @param {?} internalStateOperations
-     * @param {?} stateContextFactory
-     * @param {?} bootstrapper
-     */
-    constructor(internalStateOperations, stateContextFactory, bootstrapper) {
-        this.internalStateOperations = internalStateOperations;
-        this.stateContextFactory = stateContextFactory;
-        this.bootstrapper = bootstrapper;
-    }
-    /**
-     * @template T
-     * @param {?} action
-     * @param {?} results
-     * @return {?}
-     */
-    ngxsBootstrap(action, results) {
-        this.internalStateOperations
-            .getRootStateOperations()
-            .dispatch(action)
-            .pipe(filter((/**
-         * @return {?}
-         */
-        () => !!results)), tap((/**
-         * @return {?}
-         */
-        () => this.invokeInit((/** @type {?} */ (results)).states))), mergeMap((/**
-         * @return {?}
-         */
-        () => this.bootstrapper.appBootstrapped$)), filter((/**
-         * @param {?} appBootstrapped
-         * @return {?}
-         */
-        appBootstrapped => !!appBootstrapped)))
-            .subscribe((/**
-         * @return {?}
-         */
-        () => this.invokeBootstrap((/** @type {?} */ (results)).states)));
-    }
-    /**
-     * Invoke the init function on the states.
-     * @param {?} mappedStores
-     * @return {?}
-     */
-    invokeInit(mappedStores) {
-        for (const mappedStore of mappedStores) {
-            /** @type {?} */
-            const instance = mappedStore.instance;
-            if (instance.ngxsOnChanges) {
-                /** @type {?} */
-                const currentAppState = {};
-                /** @type {?} */
-                const newAppState = this.internalStateOperations
-                    .getRootStateOperations()
-                    .getState();
-                /** @type {?} */
-                const firstDiffChange = getStateDiffChanges(mappedStore, {
-                    currentAppState,
-                    newAppState
-                });
-                instance.ngxsOnChanges(firstDiffChange);
-            }
-            if (instance.ngxsOnInit) {
-                instance.ngxsOnInit(this.getStateContext(mappedStore));
-            }
-            mappedStore.isInitialised = true;
-        }
-    }
-    /**
-     * Invoke the bootstrap function on the states.
-     * @param {?} mappedStores
-     * @return {?}
-     */
-    invokeBootstrap(mappedStores) {
-        for (const mappedStore of mappedStores) {
-            /** @type {?} */
-            const instance = mappedStore.instance;
-            if (instance.ngxsAfterBootstrap) {
-                instance.ngxsAfterBootstrap(this.getStateContext(mappedStore));
-            }
-        }
-    }
-    /**
-     * @private
-     * @param {?} mappedStore
-     * @return {?}
-     */
-    getStateContext(mappedStore) {
-        return this.stateContextFactory.createStateContext(mappedStore);
-    }
-}
-LifecycleStateManager.decorators = [
-    { type: Injectable }
-];
-/** @nocollapse */
-LifecycleStateManager.ctorParameters = () => [
-    { type: InternalStateOperations },
-    { type: StateContextFactory },
-    { type: NgxsBootstrapper }
-];
-if (false) {
-    /**
-     * @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
@@ -3251,6 +3197,172 @@ if (false) {
     Store.prototype._stateFactory;
 }
 
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class LifecycleStateManager {
+    /**
+     * @param {?} _store
+     * @param {?} _internalErrorReporter
+     * @param {?} _internalStateOperations
+     * @param {?} _stateContextFactory
+     * @param {?} _bootstrapper
+     */
+    constructor(_store, _internalErrorReporter, _internalStateOperations, _stateContextFactory, _bootstrapper) {
+        this._store = _store;
+        this._internalErrorReporter = _internalErrorReporter;
+        this._internalStateOperations = _internalStateOperations;
+        this._stateContextFactory = _stateContextFactory;
+        this._bootstrapper = _bootstrapper;
+        this._destroy$ = new Subject();
+    }
+    /**
+     * @return {?}
+     */
+    ngOnDestroy() {
+        this._destroy$.next();
+    }
+    /**
+     * @template T
+     * @param {?} action
+     * @param {?} results
+     * @return {?}
+     */
+    ngxsBootstrap(action, results) {
+        this._internalStateOperations
+            .getRootStateOperations()
+            .dispatch(action)
+            .pipe(filter((/**
+         * @return {?}
+         */
+        () => !!results)), tap((/**
+         * @return {?}
+         */
+        () => this._invokeInitOnStates((/** @type {?} */ (results)).states))), mergeMap((/**
+         * @return {?}
+         */
+        () => this._bootstrapper.appBootstrapped$)), filter((/**
+         * @param {?} appBootstrapped
+         * @return {?}
+         */
+        appBootstrapped => !!appBootstrapped)), catchError((/**
+         * @param {?} error
+         * @return {?}
+         */
+        error => {
+            // The `SafeSubscriber` (which is used by most RxJS operators) re-throws
+            // errors asynchronously (`setTimeout(() => { throw error })`). This might
+            // break existing user's code or unit tests. We catch the error manually to
+            // be backward compatible with the old behavior.
+            this._internalErrorReporter.reportErrorSafely(error);
+            return EMPTY;
+        })), takeUntil(this._destroy$))
+            .subscribe((/**
+         * @return {?}
+         */
+        () => this._invokeBootstrapOnStates((/** @type {?} */ (results)).states)));
+    }
+    /**
+     * @private
+     * @param {?} mappedStores
+     * @return {?}
+     */
+    _invokeInitOnStates(mappedStores) {
+        for (const mappedStore of mappedStores) {
+            /** @type {?} */
+            const instance = mappedStore.instance;
+            if (instance.ngxsOnChanges) {
+                this._store
+                    .select((/**
+                 * @param {?} state
+                 * @return {?}
+                 */
+                state => getValue(state, mappedStore.path)))
+                    .pipe(startWith(undefined), pairwise(), takeUntil(this._destroy$))
+                    .subscribe((/**
+                 * @param {?} __0
+                 * @return {?}
+                 */
+                ([previousValue, currentValue]) => {
+                    /** @type {?} */
+                    const change = new NgxsSimpleChange(previousValue, currentValue, !mappedStore.isInitialised);
+                    (/** @type {?} */ (instance.ngxsOnChanges))(change);
+                }));
+            }
+            if (instance.ngxsOnInit) {
+                instance.ngxsOnInit(this._getStateContext(mappedStore));
+            }
+            mappedStore.isInitialised = true;
+        }
+    }
+    /**
+     * @private
+     * @param {?} mappedStores
+     * @return {?}
+     */
+    _invokeBootstrapOnStates(mappedStores) {
+        for (const mappedStore of mappedStores) {
+            /** @type {?} */
+            const instance = mappedStore.instance;
+            if (instance.ngxsAfterBootstrap) {
+                instance.ngxsAfterBootstrap(this._getStateContext(mappedStore));
+            }
+        }
+    }
+    /**
+     * @private
+     * @param {?} mappedStore
+     * @return {?}
+     */
+    _getStateContext(mappedStore) {
+        return this._stateContextFactory.createStateContext(mappedStore);
+    }
+}
+LifecycleStateManager.decorators = [
+    { type: Injectable }
+];
+/** @nocollapse */
+LifecycleStateManager.ctorParameters = () => [
+    { type: Store },
+    { type: InternalErrorReporter },
+    { type: InternalStateOperations },
+    { type: StateContextFactory },
+    { type: NgxsBootstrapper }
+];
+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
@@ -3998,5 +4110,5 @@ if (false) {
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 
-export { Action, Actions, InitState, NGXS_PLUGINS, NgxsModule, NgxsSimpleChange, NoopNgxsExecutionStrategy, Select, Selector, SelectorOptions, State, StateStream, StateToken, Store, UpdateState, actionMatcher, createSelector, ensureSelectorMetadata$1 as ensureSelectorMetadata, ensureStoreMetadata$1 as ensureStoreMetadata, getActionTypeFromInstance, getSelectorMetadata$1 as getSelectorMetadata, getStoreMetadata$1 as getStoreMetadata, getValue, ofAction, ofActionCanceled, ofActionCompleted, ofActionDispatched, ofActionErrored, ofActionSuccessful, setValue, OrderedSubject as ɵa, InternalActions as ɵb, ROOT_STATE_TOKEN as ɵc, FEATURE_STATE_TOKEN as ɵd, SELECTOR_META_KEY as ɵe, NgxsConfig as ɵf, mergeDeep as ɵg, USER_PROVIDED_NGXS_EXECUTION_STRATEGY as ɵh, NGXS_EXECUTION_STRATEGY as ɵi, NgxsRootModule as ɵj, StateFactory as ɵk, InternalDispatchedActionResults as ɵl, InternalDispatcher as ɵm, StateContextFactory as ɵn, InternalStateOperations as ɵo, PluginManager as ɵp, InternalNgxsExecutionStrategy as ɵq, SelectFactory as ɵr, ensureStoreMetadata as ɵt, getStoreMetadata as ɵu, ensureSelectorMetadata as ɵv, getSelectorMetadata as ɵw, LifecycleStateManager as ɵx, NgxsFeatureModule as ɵy };
+export { Action, Actions, InitState, NGXS_PLUGINS, NgxsModule, NgxsSimpleChange, NoopNgxsExecutionStrategy, Select, Selector, SelectorOptions, State, StateStream, StateToken, Store, UpdateState, actionMatcher, createSelector, ensureSelectorMetadata$1 as ensureSelectorMetadata, ensureStoreMetadata$1 as ensureStoreMetadata, getActionTypeFromInstance, getSelectorMetadata$1 as getSelectorMetadata, getStoreMetadata$1 as getStoreMetadata, getValue, ofAction, ofActionCanceled, ofActionCompleted, ofActionDispatched, ofActionErrored, ofActionSuccessful, setValue, OrderedSubject as ɵa, InternalActions as ɵb, ROOT_STATE_TOKEN as ɵc, FEATURE_STATE_TOKEN as ɵd, SELECTOR_META_KEY as ɵe, NgxsConfig as ɵf, mergeDeep as ɵg, USER_PROVIDED_NGXS_EXECUTION_STRATEGY as ɵh, NGXS_EXECUTION_STRATEGY as ɵi, NgxsRootModule as ɵj, StateFactory as ɵk, InternalDispatchedActionResults as ɵl, InternalDispatcher as ɵm, StateContextFactory as ɵn, InternalStateOperations as ɵo, PluginManager as ɵp, InternalNgxsExecutionStrategy as ɵq, InternalErrorReporter as ɵr, SelectFactory as ɵs, ensureStoreMetadata as ɵu, getStoreMetadata as ɵv, ensureSelectorMetadata as ɵw, getSelectorMetadata as ɵx, LifecycleStateManager as ɵy, NgxsFeatureModule as ɵz };
 //# sourceMappingURL=ngxs-store.js.map