@ngxs/store 18.1.5-dev.master-cd94934 → 18.1.5-dev.master-a4f3a7f

package/fesm2022/ngxs-store.mjs

@@ -258,19 +258,26 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImpor
         }], ctorParameters: () => [] });
 
 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;
+let installed = false;
+function installOnUnhandhedErrorHandler() {
+    if (installed) {
+        return;
     }
-};
+    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;
+        }
+    };
+    installed = true;
+}
 function executeUnhandledCallback(error) {
     const unhandledErrorCallback = ɵɵunhandledRxjsErrorCallbacks.get(error);
     if (unhandledErrorCallback) {
@@ -1241,20 +1248,17 @@ function cloneDefaults(defaults) {
  * The `StateFactory` class adds root and feature states to the graph.
  * This extracts state names from state classes, checks if they already
  * exist in the global graph, throws errors if their names are invalid, etc.
- * See its constructor, state factories inject state factories that are
- * parent-level providers. This is required to get feature states from the
- * injector on the same level.
  *
- * The `NgxsModule.forFeature(...)` returns `providers: [StateFactory, ...states]`.
- * The `StateFactory` is initialized on the feature level and goes through `...states`
- * to get them from the injector through `injector.get(state)`.
+ * Root and feature initializers call `addAndReturnDefaults()` to add those states
+ * to the global graph. Since `addAndReturnDefaults` runs within the injection
+ * context (which might be the root injector or a feature injector), we can
+ * retrieve an instance of the state class using `inject(StateClass)`.
  * @ignore
  */
 class StateFactory {
     constructor() {
         this._injector = inject(Injector);
         this._config = inject(NgxsConfig);
-        this._parentFactory = inject(StateFactory, { optional: true, skipSelf: true });
         this._stateContextFactory = inject(StateContextFactory);
         this._actions = inject(InternalActions);
         this._actionResults = inject(InternalDispatchedActionResults);
@@ -1271,47 +1275,36 @@ class StateFactory {
             const stateFactory = this;
             const propGetter = stateFactory._propGetter;
             function resolveGetter(key) {
-                const path = stateFactory.statePaths[key];
+                const path = stateFactory._statePaths[key];
                 return path ? propGetter(path.split('.')) : null;
             }
-            const context = this._parentFactory
-                ? this._parentFactory.getRuntimeSelectorContext()
-                : {
-                    getStateGetter(key) {
-                        // Use `@__INLINE__` annotation to forcely inline `resolveGetter`.
-                        // This is a Terser annotation, which will function only in the production mode.
-                        let getter = /*@__INLINE__*/ resolveGetter(key);
-                        if (getter) {
-                            return getter;
-                        }
-                        return (...args) => {
-                            // Late loaded getter
-                            if (!getter) {
-                                getter = /*@__INLINE__*/ resolveGetter(key);
-                            }
-                            return getter ? getter(...args) : undefined;
-                        };
-                    },
-                    getSelectorOptions(localOptions) {
-                        const globalSelectorOptions = stateFactory._config.selectorOptions;
-                        return {
-                            ...globalSelectorOptions,
-                            ...(localOptions || {})
-                        };
+            const context = {
+                getStateGetter(key) {
+                    // Use `@__INLINE__` annotation to forcely inline `resolveGetter`.
+                    // This is a Terser annotation, which will function only in the production mode.
+                    let getter = /*@__INLINE__*/ resolveGetter(key);
+                    if (getter) {
+                        return getter;
                     }
-                };
+                    return (...args) => {
+                        // Late loaded getter
+                        if (!getter) {
+                            getter = /*@__INLINE__*/ resolveGetter(key);
+                        }
+                        return getter ? getter(...args) : undefined;
+                    };
+                },
+                getSelectorOptions(localOptions) {
+                    const globalSelectorOptions = stateFactory._config.selectorOptions;
+                    return {
+                        ...globalSelectorOptions,
+                        ...(localOptions || {})
+                    };
+                }
+            };
             return context;
         });
     }
-    get states() {
-        return this._parentFactory ? this._parentFactory.states : this._states;
-    }
-    get statesByName() {
-        return this._parentFactory ? this._parentFactory.statesByName : this._statesByName;
-    }
-    get statePaths() {
-        return this._parentFactory ? this._parentFactory.statePaths : this._statePaths;
-    }
     ngOnDestroy() {
         this._actionsSubscription?.unsubscribe();
     }
@@ -1347,7 +1340,7 @@ class StateFactory {
                 path,
                 isInitialised: false,
                 actions: meta.actions,
-                instance: this._injector.get(stateClass),
+                instance: inject(stateClass),
                 defaults: cloneDefaults(meta.defaults)
             };
             // ensure our store hasn't already been added
@@ -1356,7 +1349,7 @@ class StateFactory {
             if (!this.hasBeenMountedAndBootstrapped(name, path)) {
                 bootstrappedStores.push(stateMap);
             }
-            this.states.push(stateMap);
+            this._states.push(stateMap);
             this.hydrateActionMetasMap(stateMap);
         }
         return bootstrappedStores;
@@ -1371,12 +1364,6 @@ class StateFactory {
         return { defaults, states: mappedStores };
     }
     connectActionHandlers() {
-        // Note: We have to connect actions only once when the `StateFactory`
-        //       is being created for the first time. This checks if we're in
-        //       a child state factory and the parent state factory already exists.
-        if (this._parentFactory || this._actionsSubscription !== null) {
-            return;
-        }
         this._actionsSubscription = this._actions
             .pipe(filter((ctx) => ctx.status === "DISPATCHED" /* ActionStatus.Dispatched */), mergeMap$1(ctx => {
             const action = ctx.action;
@@ -1432,7 +1419,7 @@ class StateFactory {
     }
     addToStatesMap(stateClasses) {
         const newStates = [];
-        const statesMap = this.statesByName;
+        const statesMap = this._statesByName;
         for (const stateClass of stateClasses) {
             const stateName = _getStoreMetadata(stateClass).name;
             if (typeof ngDevMode !== 'undefined' && ngDevMode) {
@@ -1447,7 +1434,7 @@ class StateFactory {
         return { newStates };
     }
     addRuntimeInfoToMeta(meta, path) {
-        this.statePaths[meta.name] = path;
+        this._statePaths[meta.name] = path;
         // TODO: versions after v3 - we plan to get rid of the `path` property because it is non-deterministic
         // we can do this when we get rid of the incorrectly exposed getStoreMetadata
         // We will need to come up with an alternative to what was exposed in v3 because this is used by many plugins
@@ -1457,7 +1444,7 @@ class StateFactory {
         const valueIsBootstrappedInInitialState = getValue(this._initialState, path) !== undefined;
         // This checks whether a state has been already added to the global graph and
         // its lifecycle is in 'bootstrapped' state.
-        return this.statesByName[name] && valueIsBootstrappedInInitialState;
+        return this._statesByName[name] && valueIsBootstrappedInInitialState;
     }
     hydrateActionMetasMap({ path, actions, instance }) {
         const { dispatched$ } = this._actions;
@@ -1528,10 +1515,11 @@ class StateFactory {
         }
     }
     /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: StateFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: StateFactory }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: StateFactory, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: StateFactory, decorators: [{
-            type: Injectable
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
         }] });
 // This is used to replace `setState` and `patchState` once the action
 // handler has been unsubscribed or completed, to prevent writing
@@ -1774,6 +1762,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImpor
  * same initialization functionality.
  */
 function rootStoreInitializer() {
+    // Override the RxJS `config.onUnhandledError` within the root store initializer,
+    // but only after other code has already executed.
+    // If users have a custom `config.onUnhandledError`, we might overwrite it too
+    // early and capture the original `config.onUnhandledError` before it is properly set.
+    installOnUnhandhedErrorHandler();
     const prebootFns = inject(NGXS_PREBOOT_FNS, { optional: true }) || [];
     prebootFns.forEach(prebootFn => prebootFn());
     const factory = inject(StateFactory);
@@ -1883,7 +1876,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImpor
  */
 function getRootProviders(states, options) {
     return [
-        StateFactory,
         ...states,
         {
             provide: ROOT_STATE_TOKEN,
@@ -1914,7 +1906,6 @@ function getRootProviders(states, options) {
  */
 function getFeatureProviders(states) {
     return [
-        StateFactory,
         PluginManager,
         ...states,
         {