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

package/fesm5/ngxs-store.js

@@ -1,5 +1,5 @@
 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 { 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, isObservable, queueScheduler } from 'rxjs';
@@ -1682,6 +1682,126 @@ function () {
         })]));
 }); });
 
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * This operator is used for piping the observable result
+ * from the `dispatch()`. It has a "smart" error handling
+ * strategy that allows us to decide whether we propagate
+ * errors to Angular's `ErrorHandler` or enable users to
+ * handle them manually. We consider following cases:
+ * 1) `store.dispatch()` (no subscribe) -> call `handleError()`
+ * 2) `store.dispatch().subscribe()` (no error callback) -> call `handleError()`
+ * 3) `store.dispatch().subscribe({ error: ... })` -> don't call `handleError()`
+ * 4) `toPromise()` without `catch` -> do `handleError()`
+ * 5) `toPromise()` with `catch` -> don't `handleError()`
+ * @template T
+ * @param {?} internalErrorReporter
+ * @param {?} ngxsExecutionStrategy
+ * @return {?}
+ */
+function ngxsErrorHandler(internalErrorReporter, ngxsExecutionStrategy) {
+    return (/**
+     * @param {?} source
+     * @return {?}
+     */
+    function (source) {
+        /** @type {?} */
+        var subscribed = false;
+        source.subscribe({
+            error: (/**
+             * @param {?} error
+             * @return {?}
+             */
+            function (error) {
+                // Do not trigger change detection for a microtask. This depends on the execution
+                // strategy being used, but the default `DispatchOutsideZoneNgxsExecutionStrategy`
+                // leaves the Angular zone.
+                ngxsExecutionStrategy.enter((/**
+                 * @return {?}
+                 */
+                function () {
+                    return Promise.resolve().then((/**
+                     * @return {?}
+                     */
+                    function () {
+                        if (!subscribed) {
+                            ngxsExecutionStrategy.leave((/**
+                             * @return {?}
+                             */
+                            function () {
+                                return internalErrorReporter.reportErrorSafely(error);
+                            }));
+                        }
+                    }));
+                }));
+            })
+        });
+        return new 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 = defineInjectable({ factory: function InternalErrorReporter_Factory() { return new InternalErrorReporter(inject(INJECTOR)); }, token: InternalErrorReporter, providedIn: "root" });
+    return InternalErrorReporter;
+}());
+if (false) {
+    /**
+     * Will be set lazily to be backward compatible.
+     * @type {?}
+     * @private
+     */
+    InternalErrorReporter.prototype._errorHandler;
+    /**
+     * @type {?}
+     * @private
+     */
+    InternalErrorReporter.prototype._injector;
+}
+
 /**
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
@@ -1814,13 +1934,13 @@ var InternalDispatchedActionResults = /** @class */ (function (_super) {
     return InternalDispatchedActionResults;
 }(Subject));
 var InternalDispatcher = /** @class */ (function () {
-    function InternalDispatcher(_injector, _actions, _actionResults, _pluginManager, _stateStream, _ngxsExecutionStrategy) {
-        this._injector = _injector;
+    function InternalDispatcher(_actions, _actionResults, _pluginManager, _stateStream, _ngxsExecutionStrategy, _internalErrorReporter) {
         this._actions = _actions;
         this._actionResults = _actionResults;
         this._pluginManager = _pluginManager;
         this._stateStream = _stateStream;
         this._ngxsExecutionStrategy = _ngxsExecutionStrategy;
+        this._internalErrorReporter = _internalErrorReporter;
     }
     /**
      * Dispatches event(s).
@@ -1844,26 +1964,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
@@ -1988,26 +2089,16 @@ 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;
 }());
 if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    InternalDispatcher.prototype._errorHandler;
-    /**
-     * @type {?}
-     * @private
-     */
-    InternalDispatcher.prototype._injector;
     /**
      * @type {?}
      * @private
@@ -2033,6 +2124,11 @@ if (false) {
      * @private
      */
     InternalDispatcher.prototype._ngxsExecutionStrategy;
+    /**
+     * @type {?}
+     * @private
+     */
+    InternalDispatcher.prototype._internalErrorReporter;
 }
 
 /**
@@ -3487,8 +3583,9 @@ if (false) {
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 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;
@@ -3526,30 +3623,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 {?}
@@ -3599,16 +3702,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 {?}
@@ -3652,6 +3750,7 @@ var LifecycleStateManager = /** @class */ (function () {
     /** @nocollapse */
     LifecycleStateManager.ctorParameters = function () { return [
         { type: Store },
+        { type: InternalErrorReporter },
         { type: InternalStateOperations },
         { type: StateContextFactory },
         { type: NgxsBootstrapper }
@@ -3669,6 +3768,11 @@ if (false) {
      * @private
      */
     LifecycleStateManager.prototype._store;
+    /**
+     * @type {?}
+     * @private
+     */
+    LifecycleStateManager.prototype._internalErrorReporter;
     /**
      * @type {?}
      * @private
@@ -4508,5 +4612,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