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

package/fesm2015/ngxs-store.js

@@ -1,4 +1,4 @@
-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';
@@ -1565,6 +1565,120 @@ const compose = (/**
     (...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
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
@@ -1678,20 +1792,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).
@@ -1704,24 +1818,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
@@ -1825,24 +1922,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
@@ -1868,6 +1955,11 @@ if (false) {
      * @private
      */
     InternalDispatcher.prototype._ngxsExecutionStrategy;
+    /**
+     * @type {?}
+     * @private
+     */
+    InternalDispatcher.prototype._internalErrorReporter;
 }
 
 /**
@@ -3111,12 +3203,14 @@ if (false) {
 class LifecycleStateManager {
     /**
      * @param {?} _store
+     * @param {?} _internalErrorReporter
      * @param {?} _internalStateOperations
      * @param {?} _stateContextFactory
      * @param {?} _bootstrapper
      */
-    constructor(_store, _internalStateOperations, _stateContextFactory, _bootstrapper) {
+    constructor(_store, _internalErrorReporter, _internalStateOperations, _stateContextFactory, _bootstrapper) {
         this._store = _store;
+        this._internalErrorReporter = _internalErrorReporter;
         this._internalStateOperations = _internalStateOperations;
         this._stateContextFactory = _stateContextFactory;
         this._bootstrapper = _bootstrapper;
@@ -3144,26 +3238,36 @@ class LifecycleStateManager {
         () => !!results)), tap((/**
          * @return {?}
          */
-        () => this._invokeInit((/** @type {?} */ (results)).states))), mergeMap((/**
+        () => this._invokeInitOnStates((/** @type {?} */ (results)).states))), mergeMap((/**
          * @return {?}
          */
         () => this._bootstrapper.appBootstrapped$)), filter((/**
          * @param {?} appBootstrapped
          * @return {?}
          */
-        appBootstrapped => !!appBootstrapped)), takeUntil(this._destroy$))
+        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._invokeBootstrap((/** @type {?} */ (results)).states)));
+        () => this._invokeBootstrapOnStates((/** @type {?} */ (results)).states)));
     }
     /**
-     * Invoke the init function on the states.
      * @private
      * @param {?} mappedStores
      * @return {?}
      */
-    _invokeInit(mappedStores) {
+    _invokeInitOnStates(mappedStores) {
         for (const mappedStore of mappedStores) {
             /** @type {?} */
             const instance = mappedStore.instance;
@@ -3192,12 +3296,11 @@ class LifecycleStateManager {
         }
     }
     /**
-     * Invoke the bootstrap function on the states.
      * @private
      * @param {?} mappedStores
      * @return {?}
      */
-    _invokeBootstrap(mappedStores) {
+    _invokeBootstrapOnStates(mappedStores) {
         for (const mappedStore of mappedStores) {
             /** @type {?} */
             const instance = mappedStore.instance;
@@ -3221,6 +3324,7 @@ LifecycleStateManager.decorators = [
 /** @nocollapse */
 LifecycleStateManager.ctorParameters = () => [
     { type: Store },
+    { type: InternalErrorReporter },
     { type: InternalStateOperations },
     { type: StateContextFactory },
     { type: NgxsBootstrapper }
@@ -3236,6 +3340,11 @@ if (false) {
      * @private
      */
     LifecycleStateManager.prototype._store;
+    /**
+     * @type {?}
+     * @private
+     */
+    LifecycleStateManager.prototype._internalErrorReporter;
     /**
      * @type {?}
      * @private
@@ -4000,5 +4109,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