@ngxs/store 3.8.2-dev.master-87ee261 → 3.8.2-dev.master-3d36414

package/fesm2022/ngxs-store.mjs

@@ -1,6 +1,6 @@
 import * as i0 from '@angular/core';
-import { Injectable, NgZone, PLATFORM_ID, Inject, InjectionToken, inject, INJECTOR, ɵglobal as _global, ErrorHandler, Optional, SkipSelf, ɵisPromise as _isPromise, computed, ENVIRONMENT_INITIALIZER, NgModule, APP_BOOTSTRAP_LISTENER, makeEnvironmentProviders } from '@angular/core';
-import { Observable, Subject, of, forkJoin, throwError, EMPTY, from, isObservable, ReplaySubject } from 'rxjs';
+import { Injectable, NgZone, PLATFORM_ID, Inject, InjectionToken, inject, INJECTOR, ɵglobal as _global, Optional, SkipSelf, ErrorHandler, ɵisPromise as _isPromise, computed, ENVIRONMENT_INITIALIZER, NgModule, APP_BOOTSTRAP_LISTENER, makeEnvironmentProviders } from '@angular/core';
+import { Observable, config, Subject, of, forkJoin, throwError, EMPTY, from, isObservable, ReplaySubject } from 'rxjs';
 import { share, map, shareReplay, filter, take, exhaustMap, mergeMap, defaultIfEmpty, catchError, takeUntil, distinctUntilChanged, tap, startWith, pairwise } from 'rxjs/operators';
 import * as i1 from '@ngxs/store/internals';
 import { ɵOrderedSubject as _OrderedSubject, ɵmemoize as _memoize, ɵgetStoreMetadata as _getStoreMetadata, ɵgetSelectorMetadata as _getSelectorMetadata, ɵMETA_KEY as _META_KEY, ɵINITIAL_STATE_TOKEN as _INITIAL_STATE_TOKEN, ɵNgxsAppBootstrappedState as _NgxsAppBootstrappedState, ɵNGXS_STATE_CONTEXT_FACTORY as _NGXS_STATE_CONTEXT_FACTORY, ɵNGXS_STATE_FACTORY as _NGXS_STATE_FACTORY, ɵensureStoreMetadata as _ensureStoreMetadata, ɵMETA_OPTIONS_KEY as _META_OPTIONS_KEY, ɵensureSelectorMetadata as _ensureSelectorMetadata } from '@ngxs/store/internals';
@@ -217,66 +217,6 @@ function leaveNgxs(ngxsExecutionStrategy) {
     };
 }
 
-/**
- * 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()`
- */
-function ngxsErrorHandler(internalErrorReporter, ngxsExecutionStrategy) {
-    return (source) => {
-        let subscribed = false;
-        source.subscribe({
-            error: 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(() => Promise.resolve().then(() => {
-                    if (!subscribed) {
-                        ngxsExecutionStrategy.leave(() => internalErrorReporter.reportErrorSafely(error));
-                    }
-                }));
-            }
-        });
-        return new Observable(subscriber => {
-            subscribed = true;
-            return source.pipe(leaveNgxs(ngxsExecutionStrategy)).subscribe(subscriber);
-        });
-    };
-}
-class InternalErrorReporter {
-    constructor(_injector) {
-        this._injector = _injector;
-        /** Will be set lazily to be backward compatible. */
-        this._errorHandler = null;
-    }
-    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 { }
-    }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.5", ngImport: i0, type: InternalErrorReporter, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.5", ngImport: i0, type: InternalErrorReporter, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.5", ngImport: i0, type: InternalErrorReporter, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [{ type: i0.Injector }] });
-
 /**
  * Internal Action stream that is emitted anytime an action is dispatched.
  */
@@ -355,6 +295,71 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.5", ngImpor
                     type: Optional
                 }] }] });
 
+const ɵɵunhandledRxjsErrorCallbacks = new WeakMap();
+const existingHandler = config.onUnhandledError;
+config.onUnhandledError = function (error) {
+    const unhandledErrorCallback = ɵɵunhandledRxjsErrorCallbacks.get(error);
+    if (unhandledErrorCallback) {
+        unhandledErrorCallback();
+    }
+    else if (existingHandler) {
+        existingHandler.call(this, error);
+    }
+    else {
+        throw error;
+    }
+};
+function executeUnhandledCallback(error) {
+    const unhandledErrorCallback = ɵɵunhandledRxjsErrorCallbacks.get(error);
+    if (unhandledErrorCallback) {
+        unhandledErrorCallback();
+        return true;
+    }
+    return false;
+}
+function assignUnhandledCallback(error, callback) {
+    // Since the error can be essentially anything, we must ensure that we only
+    // handle objects, as weak maps do not allow any other key type besides objects.
+    // The error can also be a string if thrown in the following manner: `throwError('My Error')`.
+    if (error !== null && typeof error === 'object') {
+        let hasBeenCalled = false;
+        ɵɵunhandledRxjsErrorCallbacks.set(error, () => {
+            if (!hasBeenCalled) {
+                hasBeenCalled = true;
+                callback();
+            }
+        });
+    }
+    return error;
+}
+
+function fallbackSubscriber(ngZone) {
+    return (source) => {
+        let subscription = source.subscribe({
+            error: error => {
+                ngZone.runOutsideAngular(() => {
+                    // This is necessary to schedule a microtask to ensure that synchronous
+                    // errors are not reported before the real subscriber arrives. If an error
+                    // is thrown synchronously in any action, it will be reported to the error
+                    // handler regardless. Since RxJS reports unhandled errors asynchronously,
+                    // implementing a microtask ensures that we are also safe in this scenario.
+                    queueMicrotask(() => {
+                        if (subscription) {
+                            executeUnhandledCallback(error);
+                        }
+                    });
+                });
+            }
+        });
+        return new Observable(subscriber => {
+            // Now that there is a real subscriber, we can unsubscribe our pro-active subscription
+            subscription?.unsubscribe();
+            subscription = null;
+            return source.subscribe(subscriber);
+        });
+    };
+}
+
 /**
  * Internal Action result stream that is emitted when an action is completed.
  * This is used as a method of returning the action result to the dispatcher
@@ -370,20 +375,20 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.5", ngImpor
             args: [{ providedIn: 'root' }]
         }] });
 class InternalDispatcher {
-    constructor(_actions, _actionResults, _pluginManager, _stateStream, _ngxsExecutionStrategy, _internalErrorReporter) {
+    constructor(_ngZone, _actions, _actionResults, _pluginManager, _stateStream, _ngxsExecutionStrategy) {
+        this._ngZone = _ngZone;
         this._actions = _actions;
         this._actionResults = _actionResults;
         this._pluginManager = _pluginManager;
         this._stateStream = _stateStream;
         this._ngxsExecutionStrategy = _ngxsExecutionStrategy;
-        this._internalErrorReporter = _internalErrorReporter;
     }
     /**
      * Dispatches event(s).
      */
     dispatch(actionOrActions) {
         const result = this._ngxsExecutionStrategy.enter(() => this.dispatchByEvents(actionOrActions));
-        return result.pipe(ngxsErrorHandler(this._internalErrorReporter, this._ngxsExecutionStrategy));
+        return result.pipe(fallbackSubscriber(this._ngZone), leaveNgxs(this._ngxsExecutionStrategy));
     }
     dispatchByEvents(actionOrActions) {
         if (Array.isArray(actionOrActions)) {
@@ -400,7 +405,7 @@ class InternalDispatcher {
             const type = getActionTypeFromInstance(action);
             if (!type) {
                 const error = new Error(`This action doesn't have a type property: ${action.constructor.name}`);
-                return throwError(error);
+                return throwError(() => error);
             }
         }
         const prevState = this._stateStream.getValue();
@@ -430,20 +435,20 @@ class InternalDispatcher {
                     // state, as its result is utilized by plugins.
                     return of(this._stateStream.getValue());
                 case "ERRORED" /* ActionStatus.Errored */:
-                    return throwError(ctx.error);
+                    return throwError(() => ctx.error);
                 default:
                     return EMPTY;
             }
         }))
             .pipe(shareReplay());
     }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.5", ngImport: i0, type: InternalDispatcher, deps: [{ token: InternalActions }, { token: InternalDispatchedActionResults }, { token: PluginManager }, { token: i1.ɵStateStream }, { token: InternalNgxsExecutionStrategy }, { token: InternalErrorReporter }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.5", ngImport: i0, type: InternalDispatcher, deps: [{ token: i0.NgZone }, { token: InternalActions }, { token: InternalDispatchedActionResults }, { token: PluginManager }, { token: i1.ɵStateStream }, { token: InternalNgxsExecutionStrategy }], target: i0.ɵɵFactoryTarget.Injectable }); }
     /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.5", ngImport: i0, type: InternalDispatcher, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.5", ngImport: i0, type: InternalDispatcher, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [{ type: InternalActions }, { type: InternalDispatchedActionResults }, { type: PluginManager }, { type: i1.ɵStateStream }, { type: InternalNgxsExecutionStrategy }, { type: InternalErrorReporter }] });
+        }], ctorParameters: () => [{ type: i0.NgZone }, { type: InternalActions }, { type: InternalDispatchedActionResults }, { type: PluginManager }, { type: i1.ɵStateStream }, { type: InternalNgxsExecutionStrategy }] });
 
 const NG_DEV_MODE$6 = typeof ngDevMode !== 'undefined' && ngDevMode;
 // The injection token is used to resolve a list of states provided at
@@ -1179,6 +1184,33 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.5", ngImpor
                     args: [NGXS_DEVELOPMENT_OPTIONS]
                 }] }] });
 
+class NgxsUnhandledErrorHandler {
+    constructor() {
+        this._ngZone = inject(NgZone);
+        this._errorHandler = inject(ErrorHandler);
+    }
+    /**
+     * The `_unhandledErrorContext` is left unused internally since we do not
+     * require it for internal operations. However, developers who wish to provide
+     * their own custom error handler may utilize this context information.
+     */
+    handleError(error, _unhandledErrorContext) {
+        // In order to avoid duplicate error handling, it is necessary to leave
+        // the Angular zone to ensure that errors are not caught twice. The `handleError`
+        // method may contain a `throw error` statement, which is used to re-throw the error.
+        // If the error is re-thrown within the Angular zone, it will be caught again by the
+        // Angular zone. By default, `@angular/core` leaves the Angular zone when invoking
+        // `handleError` (see `_callAndReportToErrorHandler`).
+        this._ngZone.runOutsideAngular(() => this._errorHandler.handleError(error));
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.5", ngImport: i0, type: NgxsUnhandledErrorHandler, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.5", ngImport: i0, type: NgxsUnhandledErrorHandler, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.5", ngImport: i0, type: NgxsUnhandledErrorHandler, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
 const NG_DEV_MODE$2 = typeof ngDevMode !== 'undefined' && ngDevMode;
 function cloneDefaults(defaults) {
     let value = defaults === undefined ? {} : defaults;
@@ -1216,6 +1248,7 @@ class StateFactory {
         this._initialState = _initialState;
         this._actionsSubscription = null;
         this._propGetter = inject(ɵPROP_GETTER);
+        this._ngxsUnhandledErrorHandler = null;
         this._states = [];
         this._statesByName = {};
         this._statePaths = {};
@@ -1334,7 +1367,16 @@ class StateFactory {
             .pipe(filter((ctx) => ctx.status === "DISPATCHED" /* ActionStatus.Dispatched */), mergeMap(ctx => {
             dispatched$.next(ctx);
             const action = ctx.action;
-            return this.invokeActions(dispatched$, action).pipe(map(() => ({ action, status: "SUCCESSFUL" /* ActionStatus.Successful */ })), defaultIfEmpty({ action, status: "CANCELED" /* ActionStatus.Canceled */ }), catchError(error => of({ action, status: "ERRORED" /* ActionStatus.Errored */, error })));
+            return this.invokeActions(dispatched$, action).pipe(map(() => ({ action, status: "SUCCESSFUL" /* ActionStatus.Successful */ })), defaultIfEmpty({ action, status: "CANCELED" /* ActionStatus.Canceled */ }), catchError(error => {
+                const ngxsUnhandledErrorHandler = (this._ngxsUnhandledErrorHandler ||=
+                    this._injector.get(NgxsUnhandledErrorHandler));
+                const handleableError = assignUnhandledCallback(error, () => ngxsUnhandledErrorHandler.handleError(error, { action }));
+                return of({
+                    action,
+                    status: "ERRORED" /* ActionStatus.Errored */,
+                    error: handleableError
+                });
+            }));
         }))
             .subscribe(ctx => this._actionResults.next(ctx));
     }
@@ -1585,9 +1627,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.5", ngImpor
 
 const NG_DEV_MODE$1 = typeof ngDevMode !== 'undefined' && ngDevMode;
 class LifecycleStateManager {
-    constructor(_store, _internalErrorReporter, _internalStateOperations, _stateContextFactory, _appBootstrappedState) {
+    constructor(_store, _internalStateOperations, _stateContextFactory, _appBootstrappedState) {
         this._store = _store;
-        this._internalErrorReporter = _internalErrorReporter;
         this._internalStateOperations = _internalStateOperations;
         this._stateContextFactory = _stateContextFactory;
         this._appBootstrappedState = _appBootstrappedState;
@@ -1615,14 +1656,7 @@ class LifecycleStateManager {
         this._internalStateOperations
             .getRootStateOperations()
             .dispatch(action)
-            .pipe(filter(() => !!results), tap(() => this._invokeInitOnStates(results.states)), mergeMap(() => this._appBootstrappedState), filter(appBootstrapped => !!appBootstrapped), catchError(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$))
+            .pipe(filter(() => !!results), tap(() => this._invokeInitOnStates(results.states)), mergeMap(() => this._appBootstrappedState), filter(appBootstrapped => !!appBootstrapped), takeUntil(this._destroy$))
             .subscribe(() => this._invokeBootstrapOnStates(results.states));
     }
     _invokeInitOnStates(mappedStores) {
@@ -1654,13 +1688,13 @@ class LifecycleStateManager {
     _getStateContext(mappedStore) {
         return this._stateContextFactory.createStateContext(mappedStore);
     }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.5", ngImport: i0, type: LifecycleStateManager, deps: [{ token: Store }, { token: InternalErrorReporter }, { token: InternalStateOperations }, { token: StateContextFactory }, { token: i1.ɵNgxsAppBootstrappedState }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.5", ngImport: i0, type: LifecycleStateManager, deps: [{ token: Store }, { token: InternalStateOperations }, { token: StateContextFactory }, { token: i1.ɵNgxsAppBootstrappedState }], target: i0.ɵɵFactoryTarget.Injectable }); }
     /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.5", ngImport: i0, type: LifecycleStateManager, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.5", ngImport: i0, type: LifecycleStateManager, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [{ type: Store }, { type: InternalErrorReporter }, { type: InternalStateOperations }, { type: StateContextFactory }, { type: i1.ɵNgxsAppBootstrappedState }] });
+        }], ctorParameters: () => [{ type: Store }, { type: InternalStateOperations }, { type: StateContextFactory }, { type: i1.ɵNgxsAppBootstrappedState }] });
 
 const NG_DEV_MODE = typeof ngDevMode !== 'undefined' && ngDevMode;
 /**
@@ -2225,5 +2259,5 @@ function withNgxsPlugin(plugin) {
  * Generated bundle index. Do not edit.
  */
 
-export { Action, Actions, NgxsDevelopmentModule, NgxsModule, NgxsSimpleChange, NgxsUnhandledActionsLogger, NoopNgxsExecutionStrategy, Select, Selector, SelectorOptions, State, Store, createModelSelector, createPickSelector, createPropertySelectors, createSelector, ofAction, ofActionCanceled, ofActionCompleted, ofActionDispatched, ofActionErrored, ofActionSuccessful, provideStates, provideStore, withNgxsDevelopmentOptions, withNgxsPlugin, NgxsFeatureModule as ɵNgxsFeatureModule, NgxsRootModule as ɵNgxsRootModule };
+export { Action, Actions, NgxsDevelopmentModule, NgxsModule, NgxsSimpleChange, NgxsUnhandledActionsLogger, NgxsUnhandledErrorHandler, NoopNgxsExecutionStrategy, Select, Selector, SelectorOptions, State, Store, createModelSelector, createPickSelector, createPropertySelectors, createSelector, ofAction, ofActionCanceled, ofActionCompleted, ofActionDispatched, ofActionErrored, ofActionSuccessful, provideStates, provideStore, withNgxsDevelopmentOptions, withNgxsPlugin, NgxsFeatureModule as ɵNgxsFeatureModule, NgxsRootModule as ɵNgxsRootModule };
 //# sourceMappingURL=ngxs-store.mjs.map