@ngxs/store 3.7.5-dev.master-f9549a3 → 3.7.5-dev.master-b4f4da3

package/bundles/ngxs-store.umd.js

@@ -1786,6 +1786,15 @@
         function InternalActions() {
             return _super !== null && _super.apply(this, arguments) || this;
         }
+        /**
+         * @return {?}
+         */
+        InternalActions.prototype.ngOnDestroy = /**
+         * @return {?}
+         */
+        function () {
+            this.complete();
+        };
         InternalActions.decorators = [
             { type: core.Injectable }
         ];
@@ -1891,6 +1900,126 @@
             })]));
     }); });
 
+    /**
+     * @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 rxjs.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(core.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: core.Injectable, args: [{ providedIn: 'root' },] }
+        ];
+        /** @nocollapse */
+        InternalErrorReporter.ctorParameters = function () { return [
+            { type: core.Injector }
+        ]; };
+        /** @nocollapse */ InternalErrorReporter.ngInjectableDef = core.defineInjectable({ factory: function InternalErrorReporter_Factory() { return new InternalErrorReporter(core.inject(core.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
@@ -2023,13 +2152,13 @@
         return InternalDispatchedActionResults;
     }(rxjs.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).
@@ -2053,26 +2182,7 @@
             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(core.ErrorHandler);
-                            _this._errorHandler.handleError(error);
-                        }
-                        catch (_a) { }
-                    }));
-                })
-            });
-            return result.pipe(leaveNgxs(this._ngxsExecutionStrategy));
+            return result.pipe(ngxsErrorHandler(this._internalErrorReporter, this._ngxsExecutionStrategy));
         };
         /**
          * @private
@@ -2197,26 +2307,16 @@
         ];
         /** @nocollapse */
         InternalDispatcher.ctorParameters = function () { return [
-            { type: core.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
@@ -2242,6 +2342,11 @@
          * @private
          */
         InternalDispatcher.prototype._ngxsExecutionStrategy;
+        /**
+         * @type {?}
+         * @private
+         */
+        InternalDispatcher.prototype._internalErrorReporter;
     }
 
     /**
@@ -3696,8 +3801,9 @@
      * @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;
@@ -3735,30 +3841,36 @@
             function () { return !!results; })), operators.tap((/**
              * @return {?}
              */
-            function () { return _this._invokeInit((/** @type {?} */ (results)).states); })), operators.mergeMap((/**
+            function () { return _this._invokeInitOnStates((/** @type {?} */ (results)).states); })), operators.mergeMap((/**
              * @return {?}
              */
             function () { return _this._bootstrapper.appBootstrapped$; })), operators.filter((/**
              * @param {?} appBootstrapped
              * @return {?}
              */
-            function (appBootstrapped) { return !!appBootstrapped; })), operators.takeUntil(this._destroy$))
+            function (appBootstrapped) { return !!appBootstrapped; })), operators.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 rxjs.EMPTY;
+            })), operators.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 {?}
@@ -3808,16 +3920,11 @@
             }
         };
         /**
-         * 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 {?}
@@ -3861,6 +3968,7 @@
         /** @nocollapse */
         LifecycleStateManager.ctorParameters = function () { return [
             { type: Store },
+            { type: InternalErrorReporter },
             { type: InternalStateOperations },
             { type: StateContextFactory },
             { type: internals.NgxsBootstrapper }
@@ -3878,6 +3986,11 @@
          * @private
          */
         LifecycleStateManager.prototype._store;
+        /**
+         * @type {?}
+         * @private
+         */
+        LifecycleStateManager.prototype._internalErrorReporter;
         /**
          * @type {?}
          * @private
@@ -4744,13 +4857,14 @@
     exports.ɵo = InternalStateOperations;
     exports.ɵp = PluginManager;
     exports.ɵq = InternalNgxsExecutionStrategy;
-    exports.ɵr = SelectFactory;
-    exports.ɵt = ensureStoreMetadata;
-    exports.ɵu = getStoreMetadata;
-    exports.ɵv = ensureSelectorMetadata;
-    exports.ɵw = getSelectorMetadata;
-    exports.ɵx = LifecycleStateManager;
-    exports.ɵy = NgxsFeatureModule;
+    exports.ɵr = InternalErrorReporter;
+    exports.ɵs = SelectFactory;
+    exports.ɵu = ensureStoreMetadata;
+    exports.ɵv = getStoreMetadata;
+    exports.ɵw = ensureSelectorMetadata;
+    exports.ɵx = getSelectorMetadata;
+    exports.ɵy = LifecycleStateManager;
+    exports.ɵz = NgxsFeatureModule;
 
     Object.defineProperty(exports, '__esModule', { value: true });