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

package/esm5/src/internal/dispatcher.js

@@ -3,15 +3,15 @@
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 import * as tslib_1 from "tslib";
-import { ErrorHandler, Injectable, Injector } from '@angular/core';
+import { Injectable } from '@angular/core';
 import { EMPTY, forkJoin, of, Subject, throwError } from 'rxjs';
 import { exhaustMap, filter, shareReplay, take } from 'rxjs/operators';
 import { compose } from '../utils/compose';
+import { InternalErrorReporter, ngxsErrorHandler } from './error-handler';
 import { InternalActions } from '../actions-stream';
 import { StateStream } from './state-stream';
 import { PluginManager } from '../plugin-manager';
 import { InternalNgxsExecutionStrategy } from '../execution/internal-ngxs-execution-strategy';
-import { leaveNgxs } from '../operators/leave-ngxs';
 import { getActionTypeFromInstance } from '../utils/utils';
 /**
  * Internal Action result stream that is emitted when an action is completed.
@@ -31,13 +31,13 @@ var InternalDispatchedActionResults = /** @class */ (function (_super) {
 }(Subject));
 export { InternalDispatchedActionResults };
 var InternalDispatcher = /** @class */ (function () {
-    function InternalDispatcher(_injector, _actions, _actionResults, _pluginManager, _stateStream, _ngxsExecutionStrategy) {
-        this._injector = _injector;
+    function InternalDispatcher(_actions, _actionResults, _pluginManager, _stateStream, _ngxsExecutionStrategy, _internalErrorReporter) {
         this._actions = _actions;
         this._actionResults = _actionResults;
         this._pluginManager = _pluginManager;
         this._stateStream = _stateStream;
         this._ngxsExecutionStrategy = _ngxsExecutionStrategy;
+        this._internalErrorReporter = _internalErrorReporter;
     }
     /**
      * Dispatches event(s).
@@ -61,26 +61,7 @@ var InternalDispatcher = /** @class */ (function () {
         function () {
             return _this.dispatchByEvents(actionOrActions);
         }));
-        result.subscribe({
-            error: (/**
-             * @param {?} error
-             * @return {?}
-             */
-            function (error) {
-                return _this._ngxsExecutionStrategy.leave((/**
-                 * @return {?}
-                 */
-                function () {
-                    try {
-                        // Retrieve lazily to avoid cyclic dependency exception
-                        _this._errorHandler = _this._errorHandler || _this._injector.get(ErrorHandler);
-                        _this._errorHandler.handleError(error);
-                    }
-                    catch (_a) { }
-                }));
-            })
-        });
-        return result.pipe(leaveNgxs(this._ngxsExecutionStrategy));
+        return result.pipe(ngxsErrorHandler(this._internalErrorReporter, this._ngxsExecutionStrategy));
     };
     /**
      * @private
@@ -205,27 +186,17 @@ var InternalDispatcher = /** @class */ (function () {
     ];
     /** @nocollapse */
     InternalDispatcher.ctorParameters = function () { return [
-        { type: Injector },
         { type: InternalActions },
         { type: InternalDispatchedActionResults },
         { type: PluginManager },
         { type: StateStream },
-        { type: InternalNgxsExecutionStrategy }
+        { type: InternalNgxsExecutionStrategy },
+        { type: InternalErrorReporter }
     ]; };
     return InternalDispatcher;
 }());
 export { InternalDispatcher };
 if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    InternalDispatcher.prototype._errorHandler;
-    /**
-     * @type {?}
-     * @private
-     */
-    InternalDispatcher.prototype._injector;
     /**
      * @type {?}
      * @private
@@ -251,5 +222,10 @@ if (false) {
      * @private
      */
     InternalDispatcher.prototype._ngxsExecutionStrategy;
+    /**
+     * @type {?}
+     * @private
+     */
+    InternalDispatcher.prototype._internalErrorReporter;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dispatcher.js","sourceRoot":"ng://@ngxs/store/","sources":["src/internal/dispatcher.ts"],"names":[],"mappings":";;;;;AAAA,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACnE,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAc,EAAE,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAC5E,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAEvE,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAC3C,OAAO,EAA+B,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACjF,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,6BAA6B,EAAE,MAAM,+CAA+C,CAAC;AAC9F,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,OAAO,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;;;;;;;AAQ3D;IACqD,2DAAsB;IAD3E;;IAC6E,CAAC;;gBAD7E,UAAU;;IACkE,sCAAC;CAAA,AAD9E,CACqD,OAAO,GAAkB;SAAjE,+BAA+B;AAE5C;IAIE,4BACU,SAAmB,EACnB,QAAyB,EACzB,cAA+C,EAC/C,cAA6B,EAC7B,YAAyB,EACzB,sBAAqD;QALrD,cAAS,GAAT,SAAS,CAAU;QACnB,aAAQ,GAAR,QAAQ,CAAiB;QACzB,mBAAc,GAAd,cAAc,CAAiC;QAC/C,mBAAc,GAAd,cAAc,CAAe;QAC7B,iBAAY,GAAZ,YAAY,CAAa;QACzB,2BAAsB,GAAtB,sBAAsB,CAA+B;IAC5D,CAAC;IAEJ;;OAEG;;;;;;IACH,qCAAQ;;;;;IAAR,UAAS,eAA4B;QAArC,iBAiBC;;YAhBO,MAAM,GAAG,IAAI,CAAC,sBAAsB,CAAC,KAAK;;;QAAC;YAC/C,OAAA,KAAI,CAAC,gBAAgB,CAAC,eAAe,CAAC;QAAtC,CAAsC,EACvC;QAED,MAAM,CAAC,SAAS,CAAC;YACf,KAAK;;;;YAAE,UAAA,KAAK;gBACV,OAAA,KAAI,CAAC,sBAAsB,CAAC,KAAK;;;gBAAC;oBAChC,IAAI;wBACF,uDAAuD;wBACvD,KAAI,CAAC,aAAa,GAAG,KAAI,CAAC,aAAa,IAAI,KAAI,CAAC,SAAS,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;wBAC5E,KAAI,CAAC,aAAa,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;qBACvC;oBAAC,WAAM,GAAE;gBACZ,CAAC,EAAC;YANF,CAME,CAAA;SACL,CAAC,CAAC;QAEH,OAAO,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC,CAAC;IAC7D,CAAC;;;;;;IAEO,6CAAgB;;;;;IAAxB,UAAyB,eAA4B;QAArD,iBAOC;QANC,IAAI,KAAK,CAAC,OAAO,CAAC,eAAe,CAAC,EAAE;YAClC,IAAI,eAAe,CAAC,MAAM,KAAK,CAAC;gBAAE,OAAO,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC,CAAC;YAC1E,OAAO,QAAQ,CAAC,eAAe,CAAC,GAAG;;;;YAAC,UAAA,MAAM,IAAI,OAAA,KAAI,CAAC,cAAc,CAAC,MAAM,CAAC,EAA3B,CAA2B,EAAC,CAAC,CAAC;SAC7E;aAAM;YACL,OAAO,IAAI,CAAC,cAAc,CAAC,eAAe,CAAC,CAAC;SAC7C;IACH,CAAC;;;;;;IAEO,2CAAc;;;;;IAAtB,UAAuB,MAAW;QAAlC,iBA0BC;QAzBC,IAAI,OAAO,SAAS,KAAK,WAAW,IAAI,SAAS,EAAE;;gBAC3C,IAAI,GAAuB,yBAAyB,CAAC,MAAM,CAAC;YAClE,IAAI,CAAC,IAAI,EAAE;;oBACH,KAAK,GAAG,IAAI,KAAK,CACrB,+CAA6C,MAAM,CAAC,WAAW,CAAC,IAAM,CACvE;gBACD,OAAO,UAAU,CAAC,KAAK,CAAC,CAAC;aAC1B;SACF;;YAEK,SAAS,GAAG,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE;;YACxC,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,OAAO;QAE3C,OAAO,CAAC,mBAAA,OAAO,kBACV,OAAO;;;;;;YACV,UAAC,SAAc,EAAE,UAAe;gBAC9B,IAAI,SAAS,KAAK,SAAS,EAAE;oBAC3B,KAAI,CAAC,YAAY,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;iBACnC;;oBACK,aAAa,GAAG,KAAI,CAAC,qBAAqB,CAAC,UAAU,CAAC;gBAC5D,aAAa,CAAC,SAAS;;;;gBAAC,UAAA,GAAG,IAAI,OAAA,KAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,EAAvB,CAAuB,EAAC,CAAC;gBACxD,KAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,+BAAyB,EAAE,CAAC,CAAC;gBAC5E,OAAO,KAAI,CAAC,wBAAwB,CAAC,aAAa,CAAC,CAAC;YACtD,CAAC;WACD,CAAC,SAAS,EAAE,MAAM,CAAC,EAAmB,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC;IAChE,CAAC;;;;;;IAEO,kDAAqB;;;;;IAA7B,UAA8B,MAAW;QACvC,OAAO,IAAI,CAAC,cAAc,CAAC,IAAI,CAC7B,MAAM;;;;QACJ,UAAC,GAAkB,IAAK,OAAA,GAAG,CAAC,MAAM,KAAK,MAAM,IAAI,GAAG,CAAC,MAAM,kCAA4B,EAA/D,CAA+D,EACxF,EACD,IAAI,CAAC,CAAC,CAAC,EACP,WAAW,EAAE,CACd,CAAC;IACJ,CAAC;;;;;;IAEO,qDAAwB;;;;;IAAhC,UAAiC,aAAwC;QAAzE,iBAeC;QAdC,OAAO,aAAa;aACjB,IAAI,CACH,UAAU;;;;QAAC,UAAC,GAAkB;YAC5B,QAAQ,GAAG,CAAC,MAAM,EAAE;gBAClB;oBACE,OAAO,EAAE,CAAC,KAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC,CAAC;gBAC1C;oBACE,OAAO,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;gBAC/B;oBACE,OAAO,KAAK,CAAC;aAChB;QACH,CAAC,EAAC,CACH;aACA,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC;IACzB,CAAC;;gBAjGF,UAAU;;;;gBArBwB,QAAQ;gBAKL,eAAe;gBAuBzB,+BAA+B;gBArBlD,aAAa;gBADb,WAAW;gBAEX,6BAA6B;;IA+GtC,yBAAC;CAAA,AAlGD,IAkGC;SAjGY,kBAAkB;;;;;;IAC7B,2CAAoC;;;;;IAGlC,uCAA2B;;;;;IAC3B,sCAAiC;;;;;IACjC,4CAAuD;;;;;IACvD,4CAAqC;;;;;IACrC,0CAAiC;;;;;IACjC,oDAA6D","sourcesContent":["import { ErrorHandler, Injectable, Injector } from '@angular/core';\nimport { EMPTY, forkJoin, Observable, of, Subject, throwError } from 'rxjs';\nimport { exhaustMap, filter, shareReplay, take } from 'rxjs/operators';\n\nimport { compose } from '../utils/compose';\nimport { ActionContext, ActionStatus, InternalActions } from '../actions-stream';\nimport { StateStream } from './state-stream';\nimport { PluginManager } from '../plugin-manager';\nimport { InternalNgxsExecutionStrategy } from '../execution/internal-ngxs-execution-strategy';\nimport { leaveNgxs } from '../operators/leave-ngxs';\nimport { getActionTypeFromInstance } from '../utils/utils';\n\n/**\n * Internal Action result stream that is emitted when an action is completed.\n * This is used as a method of returning the action result to the dispatcher\n * for the observable returned by the dispatch(...) call.\n * The dispatcher then asynchronously pushes the result from this stream onto the main action stream as a result.\n */\n@Injectable()\nexport class InternalDispatchedActionResults extends Subject<ActionContext> {}\n\n@Injectable()\nexport class InternalDispatcher {\n  private _errorHandler: ErrorHandler;\n\n  constructor(\n    private _injector: Injector,\n    private _actions: InternalActions,\n    private _actionResults: InternalDispatchedActionResults,\n    private _pluginManager: PluginManager,\n    private _stateStream: StateStream,\n    private _ngxsExecutionStrategy: InternalNgxsExecutionStrategy\n  ) {}\n\n  /**\n   * Dispatches event(s).\n   */\n  dispatch(actionOrActions: any | any[]): Observable<any> {\n    const result = this._ngxsExecutionStrategy.enter(() =>\n      this.dispatchByEvents(actionOrActions)\n    );\n\n    result.subscribe({\n      error: error =>\n        this._ngxsExecutionStrategy.leave(() => {\n          try {\n            // Retrieve lazily to avoid cyclic dependency exception\n            this._errorHandler = this._errorHandler || this._injector.get(ErrorHandler);\n            this._errorHandler.handleError(error);\n          } catch {}\n        })\n    });\n\n    return result.pipe(leaveNgxs(this._ngxsExecutionStrategy));\n  }\n\n  private dispatchByEvents(actionOrActions: any | any[]): Observable<any> {\n    if (Array.isArray(actionOrActions)) {\n      if (actionOrActions.length === 0) return of(this._stateStream.getValue());\n      return forkJoin(actionOrActions.map(action => this.dispatchSingle(action)));\n    } else {\n      return this.dispatchSingle(actionOrActions);\n    }\n  }\n\n  private dispatchSingle(action: any): Observable<any> {\n    if (typeof ngDevMode === 'undefined' || ngDevMode) {\n      const type: string | undefined = getActionTypeFromInstance(action);\n      if (!type) {\n        const error = new Error(\n          `This action doesn't have a type property: ${action.constructor.name}`\n        );\n        return throwError(error);\n      }\n    }\n\n    const prevState = this._stateStream.getValue();\n    const plugins = this._pluginManager.plugins;\n\n    return (compose([\n      ...plugins,\n      (nextState: any, nextAction: any) => {\n        if (nextState !== prevState) {\n          this._stateStream.next(nextState);\n        }\n        const actionResult$ = this.getActionResultStream(nextAction);\n        actionResult$.subscribe(ctx => this._actions.next(ctx));\n        this._actions.next({ action: nextAction, status: ActionStatus.Dispatched });\n        return this.createDispatchObservable(actionResult$);\n      }\n    ])(prevState, action) as Observable<any>).pipe(shareReplay());\n  }\n\n  private getActionResultStream(action: any): Observable<ActionContext> {\n    return this._actionResults.pipe(\n      filter(\n        (ctx: ActionContext) => ctx.action === action && ctx.status !== ActionStatus.Dispatched\n      ),\n      take(1),\n      shareReplay()\n    );\n  }\n\n  private createDispatchObservable(actionResult$: Observable<ActionContext>): Observable<any> {\n    return actionResult$\n      .pipe(\n        exhaustMap((ctx: ActionContext) => {\n          switch (ctx.status) {\n            case ActionStatus.Successful:\n              return of(this._stateStream.getValue());\n            case ActionStatus.Errored:\n              return throwError(ctx.error);\n            default:\n              return EMPTY;\n          }\n        })\n      )\n      .pipe(shareReplay());\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dispatcher.js","sourceRoot":"ng://@ngxs/store/","sources":["src/internal/dispatcher.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { EMPTY, forkJoin, Observable, of, Subject, throwError } from 'rxjs';\nimport { exhaustMap, filter, shareReplay, take } from 'rxjs/operators';\n\nimport { compose } from '../utils/compose';\nimport { InternalErrorReporter, ngxsErrorHandler } from './error-handler';\nimport { ActionContext, ActionStatus, InternalActions } from '../actions-stream';\nimport { StateStream } from './state-stream';\nimport { PluginManager } from '../plugin-manager';\nimport { InternalNgxsExecutionStrategy } from '../execution/internal-ngxs-execution-strategy';\nimport { getActionTypeFromInstance } from '../utils/utils';\n\n/**\n * Internal Action result stream that is emitted when an action is completed.\n * This is used as a method of returning the action result to the dispatcher\n * for the observable returned by the dispatch(...) call.\n * The dispatcher then asynchronously pushes the result from this stream onto the main action stream as a result.\n */\n@Injectable()\nexport class InternalDispatchedActionResults extends Subject<ActionContext> {}\n\n@Injectable()\nexport class InternalDispatcher {\n  constructor(\n    private _actions: InternalActions,\n    private _actionResults: InternalDispatchedActionResults,\n    private _pluginManager: PluginManager,\n    private _stateStream: StateStream,\n    private _ngxsExecutionStrategy: InternalNgxsExecutionStrategy,\n    private _internalErrorReporter: InternalErrorReporter\n  ) {}\n\n  /**\n   * Dispatches event(s).\n   */\n  dispatch(actionOrActions: any | any[]): Observable<any> {\n    const result = this._ngxsExecutionStrategy.enter(() =>\n      this.dispatchByEvents(actionOrActions)\n    );\n\n    return result.pipe(\n      ngxsErrorHandler(this._internalErrorReporter, this._ngxsExecutionStrategy)\n    );\n  }\n\n  private dispatchByEvents(actionOrActions: any | any[]): Observable<any> {\n    if (Array.isArray(actionOrActions)) {\n      if (actionOrActions.length === 0) return of(this._stateStream.getValue());\n      return forkJoin(actionOrActions.map(action => this.dispatchSingle(action)));\n    } else {\n      return this.dispatchSingle(actionOrActions);\n    }\n  }\n\n  private dispatchSingle(action: any): Observable<any> {\n    if (typeof ngDevMode === 'undefined' || ngDevMode) {\n      const type: string | undefined = getActionTypeFromInstance(action);\n      if (!type) {\n        const error = new Error(\n          `This action doesn't have a type property: ${action.constructor.name}`\n        );\n        return throwError(error);\n      }\n    }\n\n    const prevState = this._stateStream.getValue();\n    const plugins = this._pluginManager.plugins;\n\n    return (compose([\n      ...plugins,\n      (nextState: any, nextAction: any) => {\n        if (nextState !== prevState) {\n          this._stateStream.next(nextState);\n        }\n        const actionResult$ = this.getActionResultStream(nextAction);\n        actionResult$.subscribe(ctx => this._actions.next(ctx));\n        this._actions.next({ action: nextAction, status: ActionStatus.Dispatched });\n        return this.createDispatchObservable(actionResult$);\n      }\n    ])(prevState, action) as Observable<any>).pipe(shareReplay());\n  }\n\n  private getActionResultStream(action: any): Observable<ActionContext> {\n    return this._actionResults.pipe(\n      filter(\n        (ctx: ActionContext) => ctx.action === action && ctx.status !== ActionStatus.Dispatched\n      ),\n      take(1),\n      shareReplay()\n    );\n  }\n\n  private createDispatchObservable(actionResult$: Observable<ActionContext>): Observable<any> {\n    return actionResult$\n      .pipe(\n        exhaustMap((ctx: ActionContext) => {\n          switch (ctx.status) {\n            case ActionStatus.Successful:\n              return of(this._stateStream.getValue());\n            case ActionStatus.Errored:\n              return throwError(ctx.error);\n            default:\n              return EMPTY;\n          }\n        })\n      )\n      .pipe(shareReplay());\n  }\n}\n"]}

package/esm5/src/internal/error-handler.js

@@ -0,0 +1,125 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { ErrorHandler, Injectable, Injector } from '@angular/core';
+import { Observable } from 'rxjs';
+import { leaveNgxs } from '../operators/leave-ngxs';
+import * as i0 from "@angular/core";
+/**
+ * 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 {?}
+ */
+export function ngxsErrorHandler(internalErrorReporter, ngxsExecutionStrategy) {
+    return (/**
+     * @param {?} source
+     * @return {?}
+     */
+    function (source) {
+        /** @type {?} */
+        var subscribed = false;
+        source.subscribe({
+            error: (/**
+             * @param {?} error
+             * @return {?}
+             */
+            function (error) {
+                // Do not trigger change detection for a microtask. This depends on the execution
+                // strategy being used, but the default `DispatchOutsideZoneNgxsExecutionStrategy`
+                // leaves the Angular zone.
+                ngxsExecutionStrategy.enter((/**
+                 * @return {?}
+                 */
+                function () {
+                    return Promise.resolve().then((/**
+                     * @return {?}
+                     */
+                    function () {
+                        if (!subscribed) {
+                            ngxsExecutionStrategy.leave((/**
+                             * @return {?}
+                             */
+                            function () {
+                                return internalErrorReporter.reportErrorSafely(error);
+                            }));
+                        }
+                    }));
+                }));
+            })
+        });
+        return new Observable((/**
+         * @param {?} subscriber
+         * @return {?}
+         */
+        function (subscriber) {
+            subscribed = true;
+            return source.pipe(leaveNgxs(ngxsExecutionStrategy)).subscribe(subscriber);
+        }));
+    });
+}
+var InternalErrorReporter = /** @class */ (function () {
+    function InternalErrorReporter(_injector) {
+        this._injector = _injector;
+        /**
+         * Will be set lazily to be backward compatible.
+         */
+        this._errorHandler = (/** @type {?} */ (null));
+    }
+    /**
+     * @param {?} error
+     * @return {?}
+     */
+    InternalErrorReporter.prototype.reportErrorSafely = /**
+     * @param {?} error
+     * @return {?}
+     */
+    function (error) {
+        if (this._errorHandler === null) {
+            this._errorHandler = this._injector.get(ErrorHandler);
+        }
+        // The `try-catch` is used to avoid handling the error twice. Suppose we call
+        // `handleError` which re-throws the error internally. The re-thrown error will
+        // be caught by zone.js which will then get to the `zone.onError.emit()` and the
+        // `onError` subscriber will call `handleError` again.
+        try {
+            this._errorHandler.handleError(error);
+        }
+        catch (_a) { }
+    };
+    InternalErrorReporter.decorators = [
+        { type: Injectable, args: [{ providedIn: 'root' },] }
+    ];
+    /** @nocollapse */
+    InternalErrorReporter.ctorParameters = function () { return [
+        { type: Injector }
+    ]; };
+    /** @nocollapse */ InternalErrorReporter.ngInjectableDef = i0.defineInjectable({ factory: function InternalErrorReporter_Factory() { return new InternalErrorReporter(i0.inject(i0.INJECTOR)); }, token: InternalErrorReporter, providedIn: "root" });
+    return InternalErrorReporter;
+}());
+export { InternalErrorReporter };
+if (false) {
+    /**
+     * Will be set lazily to be backward compatible.
+     * @type {?}
+     * @private
+     */
+    InternalErrorReporter.prototype._errorHandler;
+    /**
+     * @type {?}
+     * @private
+     */
+    InternalErrorReporter.prototype._injector;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/src/internal/lifecycle-state-manager.js

@@ -5,16 +5,18 @@
 import * as tslib_1 from "tslib";
 import { Injectable } from '@angular/core';
 import { NgxsBootstrapper } from '@ngxs/store/internals';
-import { Subject } from 'rxjs';
-import { filter, mergeMap, pairwise, startWith, takeUntil, tap } from 'rxjs/operators';
+import { EMPTY, Subject } from 'rxjs';
+import { catchError, filter, mergeMap, pairwise, startWith, takeUntil, tap } from 'rxjs/operators';
 import { Store } from '../store';
 import { getValue } from '../utils/utils';
+import { InternalErrorReporter } from './error-handler';
 import { StateContextFactory } from './state-context-factory';
 import { InternalStateOperations } from './state-operations';
 import { NgxsSimpleChange } from '../symbols';
 var LifecycleStateManager = /** @class */ (function () {
-    function LifecycleStateManager(_store, _internalStateOperations, _stateContextFactory, _bootstrapper) {
+    function LifecycleStateManager(_store, _internalErrorReporter, _internalStateOperations, _stateContextFactory, _bootstrapper) {
         this._store = _store;
+        this._internalErrorReporter = _internalErrorReporter;
         this._internalStateOperations = _internalStateOperations;
         this._stateContextFactory = _stateContextFactory;
         this._bootstrapper = _bootstrapper;
@@ -52,30 +54,36 @@ var LifecycleStateManager = /** @class */ (function () {
         function () { return !!results; })), tap((/**
          * @return {?}
          */
-        function () { return _this._invokeInit((/** @type {?} */ (results)).states); })), mergeMap((/**
+        function () { return _this._invokeInitOnStates((/** @type {?} */ (results)).states); })), mergeMap((/**
          * @return {?}
          */
         function () { return _this._bootstrapper.appBootstrapped$; })), filter((/**
          * @param {?} appBootstrapped
          * @return {?}
          */
-        function (appBootstrapped) { return !!appBootstrapped; })), takeUntil(this._destroy$))
+        function (appBootstrapped) { return !!appBootstrapped; })), catchError((/**
+         * @param {?} error
+         * @return {?}
+         */
+        function (error) {
+            // The `SafeSubscriber` (which is used by most RxJS operators) re-throws
+            // errors asynchronously (`setTimeout(() => { throw error })`). This might
+            // break existing user's code or unit tests. We catch the error manually to
+            // be backward compatible with the old behavior.
+            _this._internalErrorReporter.reportErrorSafely(error);
+            return EMPTY;
+        })), takeUntil(this._destroy$))
             .subscribe((/**
          * @return {?}
          */
-        function () { return _this._invokeBootstrap((/** @type {?} */ (results)).states); }));
+        function () { return _this._invokeBootstrapOnStates((/** @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.
+    LifecycleStateManager.prototype._invokeInitOnStates = /**
      * @private
      * @param {?} mappedStores
      * @return {?}
@@ -125,16 +133,11 @@ var LifecycleStateManager = /** @class */ (function () {
         }
     };
     /**
-     * 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.
+    LifecycleStateManager.prototype._invokeBootstrapOnStates = /**
      * @private
      * @param {?} mappedStores
      * @return {?}
@@ -178,6 +181,7 @@ var LifecycleStateManager = /** @class */ (function () {
     /** @nocollapse */
     LifecycleStateManager.ctorParameters = function () { return [
         { type: Store },
+        { type: InternalErrorReporter },
         { type: InternalStateOperations },
         { type: StateContextFactory },
         { type: NgxsBootstrapper }
@@ -196,6 +200,11 @@ if (false) {
      * @private
      */
     LifecycleStateManager.prototype._store;
+    /**
+     * @type {?}
+     * @private
+     */
+    LifecycleStateManager.prototype._internalErrorReporter;
     /**
      * @type {?}
      * @private
@@ -212,4 +221,4 @@ if (false) {
      */
     LifecycleStateManager.prototype._bootstrapper;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lifecycle-state-manager.js","sourceRoot":"ng://@ngxs/store/","sources":["src/internal/lifecycle-state-manager.ts"],"names":[],"mappings":";;;;;AAAA,OAAO,EAAE,UAAU,EAAa,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACtC,OAAO,EACL,UAAU,EACV,MAAM,EACN,QAAQ,EACR,QAAQ,EACR,SAAS,EACT,SAAS,EACT,GAAG,EACJ,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACjC,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAE7D,OAAO,EAAiB,gBAAgB,EAAgB,MAAM,YAAY,CAAC;AAE3E;IAIE,+BACU,MAAa,EACb,sBAA6C,EAC7C,wBAAiD,EACjD,oBAAyC,EACzC,aAA+B;QAJ/B,WAAM,GAAN,MAAM,CAAO;QACb,2BAAsB,GAAtB,sBAAsB,CAAuB;QAC7C,6BAAwB,GAAxB,wBAAwB,CAAyB;QACjD,yBAAoB,GAApB,oBAAoB,CAAqB;QACzC,kBAAa,GAAb,aAAa,CAAkB;QAPxB,cAAS,GAAG,IAAI,OAAO,EAAQ,CAAC;IAQ9C,CAAC;;;;IAEJ,2CAAW;;;IAAX;QACE,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;IACxB,CAAC;;;;;;;IAED,6CAAa;;;;;;IAAb,UAAiB,MAAS,EAAE,OAAsC;QAAlE,iBAoBC;QAnBC,IAAI,CAAC,wBAAwB;aAC1B,sBAAsB,EAAE;aACxB,QAAQ,CAAC,MAAM,CAAC;aAChB,IAAI,CACH,MAAM;;;QAAC,cAAM,OAAA,CAAC,CAAC,OAAO,EAAT,CAAS,EAAC,EACvB,GAAG;;;QAAC,cAAM,OAAA,KAAI,CAAC,mBAAmB,CAAC,mBAAA,OAAO,EAAC,CAAC,MAAM,CAAC,EAAzC,CAAyC,EAAC,EACpD,QAAQ;;;QAAC,cAAM,OAAA,KAAI,CAAC,aAAa,CAAC,gBAAgB,EAAnC,CAAmC,EAAC,EACnD,MAAM;;;;QAAC,UAAA,eAAe,IAAI,OAAA,CAAC,CAAC,eAAe,EAAjB,CAAiB,EAAC,EAC5C,UAAU;;;;QAAC,UAAA,KAAK;YACd,wEAAwE;YACxE,0EAA0E;YAC1E,2EAA2E;YAC3E,gDAAgD;YAChD,KAAI,CAAC,sBAAsB,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC;YACrD,OAAO,KAAK,CAAC;QACf,CAAC,EAAC,EACF,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAC1B;aACA,SAAS;;;QAAC,cAAM,OAAA,KAAI,CAAC,wBAAwB,CAAC,mBAAA,OAAO,EAAC,CAAC,MAAM,CAAC,EAA9C,CAA8C,EAAC,CAAC;IACrE,CAAC;;;;;;IAEO,mDAAmB;;;;;IAA3B,UAA4B,YAA2B;;gCAC1C,WAAW;;gBACd,QAAQ,GAAkB,WAAW,CAAC,QAAQ;YAEpD,IAAI,QAAQ,CAAC,aAAa,EAAE;gBAC1B,OAAK,MAAM;qBACR,MAAM;;;;gBAAC,UAAA,KAAK,IAAI,OAAA,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,IAAI,CAAC,EAAjC,CAAiC,EAAC;qBAClD,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,EAAE,QAAQ,EAAE,EAAE,SAAS,CAAC,OAAK,SAAS,CAAC,CAAC;qBACjE,SAAS;;;;gBAAC,UAAC,EAA6B;wBAA7B,0BAA6B,EAA5B,qBAAa,EAAE,oBAAY;;wBAChC,MAAM,GAAG,IAAI,gBAAgB,CACjC,aAAa,EACb,YAAY,EACZ,CAAC,WAAW,CAAC,aAAa,CAC3B;oBACD,mBAAA,QAAQ,CAAC,aAAa,EAAC,CAAC,MAAM,CAAC,CAAC;gBAClC,CAAC,EAAC,CAAC;aACN;YAED,IAAI,QAAQ,CAAC,UAAU,EAAE;gBACvB,QAAQ,CAAC,UAAU,CAAC,OAAK,gBAAgB,CAAC,WAAW,CAAC,CAAC,CAAC;aACzD;YAED,WAAW,CAAC,aAAa,GAAG,IAAI,CAAC;QACnC,CAAC;;;YAtBD,KAA0B,IAAA,iBAAA,iBAAA,YAAY,CAAA,0CAAA;gBAAjC,IAAM,WAAW,yBAAA;wBAAX,WAAW;aAsBrB;;;;;;;;;IACH,CAAC;;;;;;IAEO,wDAAwB;;;;;IAAhC,UAAiC,YAA2B;;;YAC1D,KAA0B,IAAA,iBAAA,iBAAA,YAAY,CAAA,0CAAA,oEAAE;gBAAnC,IAAM,WAAW,yBAAA;;oBACd,QAAQ,GAAkB,WAAW,CAAC,QAAQ;gBACpD,IAAI,QAAQ,CAAC,kBAAkB,EAAE;oBAC/B,QAAQ,CAAC,kBAAkB,CAAC,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,CAAC,CAAC;iBACjE;aACF;;;;;;;;;IACH,CAAC;;;;;;IAEO,gDAAgB;;;;;IAAxB,UAAyB,WAAwB;QAC/C,OAAO,IAAI,CAAC,oBAAoB,CAAC,kBAAkB,CAAC,WAAW,CAAC,CAAC;IACnE,CAAC;;gBA3EF,UAAU;;;;gBARF,KAAK;gBAEL,qBAAqB;gBAErB,uBAAuB;gBADvB,mBAAmB;gBAfnB,gBAAgB;;IAgGzB,4BAAC;CAAA,AA5ED,IA4EC;SA3EY,qBAAqB;;;;;;IAChC,0CAAiD;;;;;IAG/C,uCAAqB;;;;;IACrB,uDAAqD;;;;;IACrD,yDAAyD;;;;;IACzD,qDAAiD;;;;;IACjD,8CAAuC","sourcesContent":["import { Injectable, OnDestroy } from '@angular/core';\nimport { NgxsBootstrapper } from '@ngxs/store/internals';\nimport { EMPTY, Subject } from 'rxjs';\nimport {\n  catchError,\n  filter,\n  mergeMap,\n  pairwise,\n  startWith,\n  takeUntil,\n  tap\n} from 'rxjs/operators';\n\nimport { Store } from '../store';\nimport { getValue } from '../utils/utils';\nimport { InternalErrorReporter } from './error-handler';\nimport { StateContextFactory } from './state-context-factory';\nimport { InternalStateOperations } from './state-operations';\nimport { MappedStore, StatesAndDefaults } from './internals';\nimport { NgxsLifeCycle, NgxsSimpleChange, StateContext } from '../symbols';\n\n@Injectable()\nexport class LifecycleStateManager implements OnDestroy {\n  private readonly _destroy$ = new Subject<void>();\n\n  constructor(\n    private _store: Store,\n    private _internalErrorReporter: InternalErrorReporter,\n    private _internalStateOperations: InternalStateOperations,\n    private _stateContextFactory: StateContextFactory,\n    private _bootstrapper: NgxsBootstrapper\n  ) {}\n\n  ngOnDestroy(): void {\n    this._destroy$.next();\n  }\n\n  ngxsBootstrap<T>(action: T, results: StatesAndDefaults | undefined): void {\n    this._internalStateOperations\n      .getRootStateOperations()\n      .dispatch(action)\n      .pipe(\n        filter(() => !!results),\n        tap(() => this._invokeInitOnStates(results!.states)),\n        mergeMap(() => this._bootstrapper.appBootstrapped$),\n        filter(appBootstrapped => !!appBootstrapped),\n        catchError(error => {\n          // The `SafeSubscriber` (which is used by most RxJS operators) re-throws\n          // errors asynchronously (`setTimeout(() => { throw error })`). This might\n          // break existing user's code or unit tests. We catch the error manually to\n          // be backward compatible with the old behavior.\n          this._internalErrorReporter.reportErrorSafely(error);\n          return EMPTY;\n        }),\n        takeUntil(this._destroy$)\n      )\n      .subscribe(() => this._invokeBootstrapOnStates(results!.states));\n  }\n\n  private _invokeInitOnStates(mappedStores: MappedStore[]): void {\n    for (const mappedStore of mappedStores) {\n      const instance: NgxsLifeCycle = mappedStore.instance;\n\n      if (instance.ngxsOnChanges) {\n        this._store\n          .select(state => getValue(state, mappedStore.path))\n          .pipe(startWith(undefined), pairwise(), takeUntil(this._destroy$))\n          .subscribe(([previousValue, currentValue]) => {\n            const change = new NgxsSimpleChange(\n              previousValue,\n              currentValue,\n              !mappedStore.isInitialised\n            );\n            instance.ngxsOnChanges!(change);\n          });\n      }\n\n      if (instance.ngxsOnInit) {\n        instance.ngxsOnInit(this._getStateContext(mappedStore));\n      }\n\n      mappedStore.isInitialised = true;\n    }\n  }\n\n  private _invokeBootstrapOnStates(mappedStores: MappedStore[]) {\n    for (const mappedStore of mappedStores) {\n      const instance: NgxsLifeCycle = mappedStore.instance;\n      if (instance.ngxsAfterBootstrap) {\n        instance.ngxsAfterBootstrap(this._getStateContext(mappedStore));\n      }\n    }\n  }\n\n  private _getStateContext(mappedStore: MappedStore): StateContext<any> {\n    return this._stateContextFactory.createStateContext(mappedStore);\n  }\n}\n"]}