@ngxs/store 3.8.2-dev.master-a836c51 → 3.8.2-dev.master-42a8ed3

package/fesm2022/ngxs-store.mjs

@@ -1,11 +1,13 @@
 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, BehaviorSubject, of, forkJoin, throwError, EMPTY, from, isObservable, ReplaySubject } from 'rxjs';
+import { Observable, Subject, of, forkJoin, throwError, EMPTY, from, isObservable, ReplaySubject } from 'rxjs';
 import { share, shareReplay, filter, take, exhaustMap, map, mergeMap, defaultIfEmpty, catchError, takeUntil, distinctUntilChanged, tap, startWith, pairwise } from 'rxjs/operators';
 import * as i5 from '@ngxs/store/internals';
-import { ɵMETA_KEY as _META_KEY, ɵSELECTOR_META_KEY as _SELECTOR_META_KEY, memoize, INITIAL_STATE_TOKEN, NgxsBootstrapper, ɵNGXS_STATE_CONTEXT_FACTORY as _NGXS_STATE_CONTEXT_FACTORY, ɵNGXS_STATE_FACTORY as _NGXS_STATE_FACTORY, ɵMETA_OPTIONS_KEY as _META_OPTIONS_KEY } from '@ngxs/store/internals';
+import { ɵOrderedSubject as _OrderedSubject, ɵStateStream as _StateStream, ɵ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';
+export { StateToken } from '@ngxs/store/internals';
 import { isPlatformServer } from '@angular/common';
-import { toSignal } from '@angular/core/rxjs-interop';
+import { NGXS_PLUGINS, getActionTypeFromInstance, setValue, getValue, InitState, UpdateState } from '@ngxs/store/plugins';
+export { InitState, NGXS_PLUGINS, UpdateState, actionMatcher, getActionTypeFromInstance, getValue, setValue } from '@ngxs/store/plugins';
 import { isStateOperator } from '@ngxs/store/operators';
 
 class NoopNgxsExecutionStrategy {
@@ -124,18 +126,18 @@ function verifyZoneIsNotNooped(ngZone) {
     console.warn(getZoneWarningMessage());
 }
 
-const NG_DEV_MODE$4 = typeof ngDevMode === 'undefined' || ngDevMode;
+const NG_DEV_MODE$5 = typeof ngDevMode === 'undefined' || ngDevMode;
 /**
  * Consumers have the option to utilize the execution strategy provided by
  * `NgxsModule.forRoot({executionStrategy})` or `provideStore([], {executionStrategy})`.
  */
-const CUSTOM_NGXS_EXECUTION_STRATEGY = new InjectionToken(NG_DEV_MODE$4 ? 'CUSTOM_NGXS_EXECUTION_STRATEGY' : '');
+const CUSTOM_NGXS_EXECUTION_STRATEGY = new InjectionToken(NG_DEV_MODE$5 ? 'CUSTOM_NGXS_EXECUTION_STRATEGY' : '');
 /**
  * The injection token is used internally to resolve an instance of the execution
  * strategy. It checks whether consumers have provided their own `executionStrategy`
  * and also verifies if we are operating in a zone-aware environment.
  */
-const NGXS_EXECUTION_STRATEGY = new InjectionToken(NG_DEV_MODE$4 ? 'NGXS_EXECUTION_STRATEGY' : '', {
+const NGXS_EXECUTION_STRATEGY = new InjectionToken(NG_DEV_MODE$5 ? 'NGXS_EXECUTION_STRATEGY' : '', {
     providedIn: 'root',
     factory: () => {
         const injector = inject(INJECTOR);
@@ -277,101 +279,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.5", ngImpor
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [{ type: i0.Injector }] });
 
-/**
- * This wraps the provided function, and will enforce the following:
- * - The calls will execute in the order that they are made
- * - A call will only be initiated when the previous call has completed
- * - If there is a call currently executing then the new call will be added
- *   to the queue and the function will return immediately
- *
- * NOTE: The following assumptions about the operation must hold true:
- * - The operation is synchronous in nature
- * - If any asynchronous side effects of the call exist, it should not
- *   have any bearing on the correctness of the next call in the queue
- * - The operation has a void return
- * - The caller should not assume that the call has completed upon
- *   return of the function
- * - The caller can assume that all the queued calls will complete
- *   within the current microtask
- * - The only way that a call will encounter another call in the queue
- *   would be if the call at the front of the queue initiated this call
- *   as part of its synchronous execution
- */
-function orderedQueueOperation(operation) {
-    const callsQueue = [];
-    let busyPushingNext = false;
-    return function callOperation(...args) {
-        if (busyPushingNext) {
-            callsQueue.unshift(args);
-            return;
-        }
-        busyPushingNext = true;
-        operation(...args);
-        while (callsQueue.length > 0) {
-            const nextCallArgs = callsQueue.pop();
-            nextCallArgs && operation(...nextCallArgs);
-        }
-        busyPushingNext = false;
-    };
-}
-/**
- * Custom Subject that ensures that subscribers are notified of values in the order that they arrived.
- * A standard Subject does not have this guarantee.
- * For example, given the following code:
- * ```typescript
- *   const subject = new Subject<string>();
-     subject.subscribe(value => {
-       if (value === 'start') subject.next('end');
-     });
-     subject.subscribe(value => { });
-     subject.next('start');
- * ```
- * When `subject` is a standard `Subject<T>` the second subscriber would recieve `end` and then `start`.
- * When `subject` is a `OrderedSubject<T>` the second subscriber would recieve `start` and then `end`.
- */
-class OrderedSubject extends Subject {
-    constructor() {
-        super(...arguments);
-        this._orderedNext = orderedQueueOperation((value) => super.next(value));
-    }
-    next(value) {
-        this._orderedNext(value);
-    }
-}
-/**
- * Custom BehaviorSubject that ensures that subscribers are notified of values in the order that they arrived.
- * A standard BehaviorSubject does not have this guarantee.
- * For example, given the following code:
- * ```typescript
- *   const subject = new BehaviorSubject<string>();
-     subject.subscribe(value => {
-       if (value === 'start') subject.next('end');
-     });
-     subject.subscribe(value => { });
-     subject.next('start');
- * ```
- * When `subject` is a standard `BehaviorSubject<T>` the second subscriber would recieve `end` and then `start`.
- * When `subject` is a `OrderedBehaviorSubject<T>` the second subscriber would recieve `start` and then `end`.
- */
-class OrderedBehaviorSubject extends BehaviorSubject {
-    constructor(value) {
-        super(value);
-        this._orderedNext = orderedQueueOperation((value) => super.next(value));
-        this._currentValue = value;
-    }
-    getValue() {
-        return this._currentValue;
-    }
-    next(value) {
-        this._currentValue = value;
-        this._orderedNext(value);
-    }
-}
-
 /**
  * Internal Action stream that is emitted anytime an action is dispatched.
  */
-class InternalActions extends OrderedSubject {
+class InternalActions extends _OrderedSubject {
     ngOnDestroy() {
         this.complete();
     }
@@ -413,185 +324,16 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.5", ngImpor
         }], ctorParameters: () => [{ type: InternalActions }, { type: InternalNgxsExecutionStrategy }] });
 
 /**
- * BehaviorSubject of the entire state.
- * @ignore
+ * @deprecated use `ɵStateStream` from `@ngxs/store/internals`.
  */
-class StateStream extends OrderedBehaviorSubject {
-    constructor() {
-        super({});
-        this.state = toSignal(this, {
-            manualCleanup: true,
-            requireSync: true
-        });
-    }
-    ngOnDestroy() {
-        // The StateStream should never emit values once the root view is removed,
-        // such as when the `NgModuleRef.destroy()` method is called. This is crucial
-        // for preventing memory leaks in server-side rendered apps, where a new StateStream
-        // is created for each HTTP request. If users forget to unsubscribe from `store.select`
-        // or `store.subscribe`, it can result in significant memory leaks in SSR apps.
-        this.complete();
-    }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.5", ngImport: i0, type: StateStream, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+class StateStream extends _StateStream {
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.5", ngImport: i0, type: StateStream, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
     /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.5", ngImport: i0, type: StateStream, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.5", ngImport: i0, type: StateStream, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [] });
-
-/**
- * Returns the type from an action instance/class.
- * @ignore
- */
-function getActionTypeFromInstance(action) {
-    if (action.constructor && action.constructor.type) {
-        return action.constructor.type;
-    }
-    else {
-        return action.type;
-    }
-}
-/**
- * Matches a action
- * @ignore
- */
-function actionMatcher(action1) {
-    const type1 = getActionTypeFromInstance(action1);
-    return function (action2) {
-        return type1 === getActionTypeFromInstance(action2);
-    };
-}
-/**
- * Set a deeply nested value. Example:
- *
- *   setValue({ foo: { bar: { eat: false } } },
- *      'foo.bar.eat', true) //=> { foo: { bar: { eat: true } } }
- *
- * While it traverses it also creates new objects from top down.
- *
- * @ignore
- */
-const setValue = (obj, prop, val) => {
-    obj = { ...obj };
-    const split = prop.split('.');
-    const lastIndex = split.length - 1;
-    split.reduce((acc, part, index) => {
-        if (index === lastIndex) {
-            acc[part] = val;
-        }
-        else {
-            acc[part] = Array.isArray(acc[part]) ? acc[part].slice() : { ...acc[part] };
-        }
-        return acc && acc[part];
-    }, obj);
-    return obj;
-};
-/**
- * Get a deeply nested value. Example:
- *
- *    getValue({ foo: bar: [] }, 'foo.bar') //=> []
- *
- * @ignore
- */
-const getValue = (obj, prop) => prop.split('.').reduce((acc, part) => acc && acc[part], obj);
-/**
- * Simple object check.
- *
- *    isObject({a:1}) //=> true
- *    isObject(1) //=> false
- *
- * @ignore
- */
-const isObject$1 = (item) => {
-    return item && typeof item === 'object' && !Array.isArray(item);
-};
-/**
- * Deep merge two objects.
- *
- *    mergeDeep({a:1, b:{x: 1, y:2}}, {b:{x: 3}, c:4}) //=> {a:1, b:{x:3, y:2}, c:4}
- *
- * @param base base object onto which `sources` will be applied
- */
-const mergeDeep = (base, ...sources) => {
-    if (!sources.length)
-        return base;
-    const source = sources.shift();
-    if (isObject$1(base) && isObject$1(source)) {
-        for (const key in source) {
-            if (isObject$1(source[key])) {
-                if (!base[key])
-                    Object.assign(base, { [key]: {} });
-                mergeDeep(base[key], source[key]);
-            }
-            else {
-                Object.assign(base, { [key]: source[key] });
-            }
-        }
-    }
-    return mergeDeep(base, ...sources);
-};
-
-const NG_DEV_MODE$3 = typeof ngDevMode === 'undefined' || ngDevMode;
-// The injection token is used to resolve a list of states provided at
-// the root level through either `NgxsModule.forRoot` or `provideStore`.
-const ROOT_STATE_TOKEN = new InjectionToken(NG_DEV_MODE$3 ? 'ROOT_STATE_TOKEN' : '');
-// The injection token is used to resolve a list of states provided at
-// the feature level through either `NgxsModule.forFeature` or `provideStates`.
-// The Array<Array> is used to overload the resolved value of the token because
-// it is a multi-provider token.
-const FEATURE_STATE_TOKEN = new InjectionToken(NG_DEV_MODE$3 ? 'FEATURE_STATE_TOKEN' : '');
-// The injection token is used to resolve to custom NGXS plugins provided
-// at the root level through either `{provide}` scheme or `withNgxsPlugin`.
-const NGXS_PLUGINS = new InjectionToken(NG_DEV_MODE$3 ? 'NGXS_PLUGINS' : '');
-// The injection token is used to resolve to options provided at the root
-// level through either `NgxsModule.forRoot` or `provideStore`.
-const NGXS_OPTIONS = new InjectionToken(NG_DEV_MODE$3 ? 'NGXS_OPTIONS' : '');
-/**
- * The NGXS config settings.
- */
-class NgxsConfig {
-    constructor() {
-        /**
-         * Defining the default state before module initialization
-         * This is convenient if we need to create a define our own set of states.
-         * @deprecated will be removed after v4
-         * (default: {})
-         */
-        this.defaultsState = {};
-        /**
-         * Defining shared selector options
-         */
-        this.selectorOptions = {
-            injectContainerState: true,
-            suppressErrors: true // TODO: default is true in v3, will change in v4
-        };
-        this.compatibility = {
-            strictContentSecurityPolicy: false
-        };
-        this.executionStrategy = DispatchOutsideZoneNgxsExecutionStrategy;
-    }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.5", ngImport: i0, type: NgxsConfig, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.5", ngImport: i0, type: NgxsConfig, providedIn: 'root', useFactory: () => mergeDeep(new NgxsConfig(), inject(NGXS_OPTIONS)) }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.5", ngImport: i0, type: NgxsConfig, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                    useFactory: () => mergeDeep(new NgxsConfig(), inject(NGXS_OPTIONS))
-                }]
-        }], ctorParameters: () => [] });
-/**
- * Represents a basic change from a previous to a new value for a single state instance.
- * Passed as a value in a NgxsSimpleChanges object to the ngxsOnChanges hook.
- */
-class NgxsSimpleChange {
-    constructor(previousValue, currentValue, firstChange) {
-        this.previousValue = previousValue;
-        this.currentValue = currentValue;
-        this.firstChange = firstChange;
-    }
-}
+        }] });
 
 class PluginManager {
     constructor(_parentManager, _pluginHandlers) {
@@ -715,6 +457,97 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.5", ngImpor
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [{ type: InternalActions }, { type: InternalDispatchedActionResults }, { type: PluginManager }, { type: StateStream }, { type: InternalNgxsExecutionStrategy }, { type: InternalErrorReporter }] });
 
+const NG_DEV_MODE$4 = typeof ngDevMode === 'undefined' || ngDevMode;
+// The injection token is used to resolve a list of states provided at
+// the root level through either `NgxsModule.forRoot` or `provideStore`.
+const ROOT_STATE_TOKEN = new InjectionToken(NG_DEV_MODE$4 ? 'ROOT_STATE_TOKEN' : '');
+// The injection token is used to resolve a list of states provided at
+// the feature level through either `NgxsModule.forFeature` or `provideStates`.
+// The Array<Array> is used to overload the resolved value of the token because
+// it is a multi-provider token.
+const FEATURE_STATE_TOKEN = new InjectionToken(NG_DEV_MODE$4 ? 'FEATURE_STATE_TOKEN' : '');
+// The injection token is used to resolve to options provided at the root
+// level through either `NgxsModule.forRoot` or `provideStore`.
+const NGXS_OPTIONS = new InjectionToken(NG_DEV_MODE$4 ? 'NGXS_OPTIONS' : '');
+/**
+ * The NGXS config settings.
+ */
+class NgxsConfig {
+    constructor() {
+        this.compatibility = {
+            strictContentSecurityPolicy: false
+        };
+        /**
+         * Determines the execution context to perform async operations inside. An implementation can be
+         * provided to override the default behaviour where the async operations are run
+         * outside Angular's zone but all observable behaviours of NGXS are run back inside Angular's zone.
+         * These observable behaviours are from:
+         *   `@Select(...)`, `store.select(...)`, `actions.subscribe(...)` or `store.dispatch(...).subscribe(...)`
+         * Every `zone.run` causes Angular to run change detection on the whole tree (`app.tick()`) so of your
+         * application doesn't rely on zone.js running change detection then you can switch to the
+         * `NoopNgxsExecutionStrategy` that doesn't interact with zones.
+         * (default: null)
+         */
+        this.executionStrategy = DispatchOutsideZoneNgxsExecutionStrategy;
+        /**
+         * Defining the default state before module initialization
+         * This is convenient if we need to create a define our own set of states.
+         * @deprecated will be removed after v4
+         * (default: {})
+         */
+        this.defaultsState = {};
+        /**
+         * Defining shared selector options
+         */
+        this.selectorOptions = {
+            injectContainerState: true,
+            suppressErrors: true // TODO: default is true in v3, will change in v4
+        };
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.5", ngImport: i0, type: NgxsConfig, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.5", ngImport: i0, type: NgxsConfig, providedIn: 'root', useFactory: () => {
+            const defaultConfig = new NgxsConfig();
+            const config = inject(NGXS_OPTIONS);
+            return {
+                ...defaultConfig,
+                ...config,
+                selectorOptions: {
+                    ...defaultConfig.selectorOptions,
+                    ...config.selectorOptions
+                }
+            };
+        } }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.5", ngImport: i0, type: NgxsConfig, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                    useFactory: () => {
+                        const defaultConfig = new NgxsConfig();
+                        const config = inject(NGXS_OPTIONS);
+                        return {
+                            ...defaultConfig,
+                            ...config,
+                            selectorOptions: {
+                                ...defaultConfig.selectorOptions,
+                                ...config.selectorOptions
+                            }
+                        };
+                    }
+                }]
+        }] });
+/**
+ * Represents a basic change from a previous to a new value for a single state instance.
+ * Passed as a value in a NgxsSimpleChanges object to the ngxsOnChanges hook.
+ */
+class NgxsSimpleChange {
+    constructor(previousValue, currentValue, firstChange) {
+        this.previousValue = previousValue;
+        this.currentValue = currentValue;
+        this.firstChange = firstChange;
+    }
+}
+
 /**
  * Object freeze code
  * https://github.com/jsdf/deep-freeze
@@ -789,61 +622,78 @@ function ensureStateAndActionsAreImmutable(root) {
     };
 }
 
-/**
- * Ensures metadata is attached to the class and returns it.
- *
- * @ignore
- */
-function ensureStoreMetadata$1(target) {
-    if (!target.hasOwnProperty(_META_KEY)) {
-        const defaultMetadata = {
-            name: null,
-            actions: {},
-            defaults: {},
-            path: null,
-            makeRootSelector(context) {
-                return context.getStateGetter(defaultMetadata.name);
-            },
-            children: []
+function createRootSelectorFactory(selectorMetaData, selectors, memoizedSelectorFn) {
+    return (context) => {
+        const { argumentSelectorFunctions, selectorOptions } = getRuntimeSelectorInfo(context, selectorMetaData, selectors);
+        return function selectFromRoot(rootState) {
+            // Determine arguments from the app state using the selectors
+            const results = argumentSelectorFunctions.map(argFn => argFn(rootState));
+            // if the lambda tries to access a something on the
+            // state that doesn't exist, it will throw a TypeError.
+            // since this is quite usual behaviour, we simply return undefined if so.
+            try {
+                return memoizedSelectorFn(...results);
+            }
+            catch (ex) {
+                if (ex instanceof TypeError && selectorOptions.suppressErrors) {
+                    return undefined;
+                }
+                throw ex;
+            }
         };
-        Object.defineProperty(target, _META_KEY, { value: defaultMetadata });
-    }
-    return getStoreMetadata$1(target);
+    };
 }
-/**
- * Get the metadata attached to the state class if it exists.
- *
- * @ignore
- */
-function getStoreMetadata$1(target) {
-    return target[_META_KEY];
+function createMemoizedSelectorFn(originalFn, creationMetadata) {
+    const containerClass = creationMetadata && creationMetadata.containerClass;
+    const wrappedFn = function wrappedSelectorFn(...args) {
+        const returnValue = originalFn.apply(containerClass, args);
+        if (returnValue instanceof Function) {
+            const innerMemoizedFn = _memoize.apply(null, [returnValue]);
+            return innerMemoizedFn;
+        }
+        return returnValue;
+    };
+    const memoizedFn = _memoize(wrappedFn);
+    Object.setPrototypeOf(memoizedFn, originalFn);
+    return memoizedFn;
 }
-/**
- * Ensures metadata is attached to the selector and returns it.
- *
- * @ignore
- */
-function ensureSelectorMetadata$1(target) {
-    if (!target.hasOwnProperty(_SELECTOR_META_KEY)) {
-        const defaultMetadata = {
-            makeRootSelector: null,
-            originalFn: null,
-            containerClass: null,
-            selectorName: null,
-            getSelectorOptions: () => ({})
-        };
-        Object.defineProperty(target, _SELECTOR_META_KEY, { value: defaultMetadata });
+function getRuntimeSelectorInfo(context, selectorMetaData, selectors = []) {
+    const localSelectorOptions = selectorMetaData.getSelectorOptions();
+    const selectorOptions = context.getSelectorOptions(localSelectorOptions);
+    const selectorsToApply = getSelectorsToApply(selectors, selectorOptions, selectorMetaData.containerClass);
+    const argumentSelectorFunctions = selectorsToApply.map(selector => {
+        const factory = getRootSelectorFactory(selector);
+        return factory(context);
+    });
+    return {
+        selectorOptions,
+        argumentSelectorFunctions
+    };
+}
+function getSelectorsToApply(selectors = [], selectorOptions, containerClass) {
+    const selectorsToApply = [];
+    const canInjectContainerState = selectors.length === 0 || selectorOptions.injectContainerState;
+    if (containerClass && canInjectContainerState) {
+        // If we are on a state class, add it as the first selector parameter
+        const metadata = _getStoreMetadata(containerClass);
+        if (metadata) {
+            selectorsToApply.push(containerClass);
+        }
+    }
+    if (selectors) {
+        selectorsToApply.push(...selectors);
     }
-    return getSelectorMetadata$1(target);
+    return selectorsToApply;
 }
 /**
- * Get the metadata attached to the selector if it exists.
- *
+ * This function gets the factory function to create the selector to get the selected slice from the app state
  * @ignore
  */
-function getSelectorMetadata$1(target) {
-    return target[_SELECTOR_META_KEY];
+function getRootSelectorFactory(selector) {
+    const metadata = _getSelectorMetadata(selector) || _getStoreMetadata(selector);
+    return (metadata && metadata.makeRootSelector) || (() => selector);
 }
+
 /**
  * Get a deeply nested value. Example:
  *
@@ -855,8 +705,14 @@ function getSelectorMetadata$1(target) {
  * @ignore
  */
 function compliantPropGetter(paths) {
-    const copyOfPaths = paths.slice();
-    return obj => copyOfPaths.reduce((acc, part) => acc && acc[part], obj);
+    return obj => {
+        for (let i = 0; i < paths.length; i++) {
+            if (!obj)
+                return undefined;
+            obj = obj[paths[i]];
+        }
+        return obj;
+    };
 }
 /**
  * The generated function is faster than:
@@ -885,7 +741,7 @@ function fastPropGetter(paths) {
  * @ignore
  */
 function propGetter(paths, config) {
-    if (config && config.compatibility && config.compatibility.strictContentSecurityPolicy) {
+    if (config?.compatibility?.strictContentSecurityPolicy) {
         return compliantPropGetter(paths);
     }
     else {
@@ -1027,86 +883,6 @@ function topologicalSort(graph) {
     Object.keys(graph).forEach(k => visit(k));
     return sorted.reverse();
 }
-/**
- * Returns if the parameter is a object or not.
- *
- * @ignore
- */
-function isObject(obj) {
-    return (typeof obj === 'object' && obj !== null) || typeof obj === 'function';
-}
-
-function createRootSelectorFactory(selectorMetaData, selectors, memoizedSelectorFn) {
-    return (context) => {
-        const { argumentSelectorFunctions, selectorOptions } = getRuntimeSelectorInfo(context, selectorMetaData, selectors);
-        return function selectFromRoot(rootState) {
-            // Determine arguments from the app state using the selectors
-            const results = argumentSelectorFunctions.map(argFn => argFn(rootState));
-            // if the lambda tries to access a something on the
-            // state that doesn't exist, it will throw a TypeError.
-            // since this is quite usual behaviour, we simply return undefined if so.
-            try {
-                return memoizedSelectorFn(...results);
-            }
-            catch (ex) {
-                if (ex instanceof TypeError && selectorOptions.suppressErrors) {
-                    return undefined;
-                }
-                throw ex;
-            }
-        };
-    };
-}
-function createMemoizedSelectorFn(originalFn, creationMetadata) {
-    const containerClass = creationMetadata && creationMetadata.containerClass;
-    const wrappedFn = function wrappedSelectorFn(...args) {
-        const returnValue = originalFn.apply(containerClass, args);
-        if (returnValue instanceof Function) {
-            const innerMemoizedFn = memoize.apply(null, [returnValue]);
-            return innerMemoizedFn;
-        }
-        return returnValue;
-    };
-    const memoizedFn = memoize(wrappedFn);
-    Object.setPrototypeOf(memoizedFn, originalFn);
-    return memoizedFn;
-}
-function getRuntimeSelectorInfo(context, selectorMetaData, selectors = []) {
-    const localSelectorOptions = selectorMetaData.getSelectorOptions();
-    const selectorOptions = context.getSelectorOptions(localSelectorOptions);
-    const selectorsToApply = getSelectorsToApply(selectors, selectorOptions, selectorMetaData.containerClass);
-    const argumentSelectorFunctions = selectorsToApply.map(selector => {
-        const factory = getRootSelectorFactory(selector);
-        return factory(context);
-    });
-    return {
-        selectorOptions,
-        argumentSelectorFunctions
-    };
-}
-function getSelectorsToApply(selectors = [], selectorOptions, containerClass) {
-    const selectorsToApply = [];
-    const canInjectContainerState = selectors.length === 0 || selectorOptions.injectContainerState;
-    if (containerClass && canInjectContainerState) {
-        // If we are on a state class, add it as the first selector parameter
-        const metadata = getStoreMetadata$1(containerClass);
-        if (metadata) {
-            selectorsToApply.push(containerClass);
-        }
-    }
-    if (selectors) {
-        selectorsToApply.push(...selectors);
-    }
-    return selectorsToApply;
-}
-/**
- * This function gets the factory function to create the selector to get the selected slice from the app state
- * @ignore
- */
-function getRootSelectorFactory(selector) {
-    const metadata = getSelectorMetadata$1(selector) || getStoreMetadata$1(selector);
-    return (metadata && metadata.makeRootSelector) || (() => selector);
-}
 
 /**
  * RxJS operator for selecting out specific actions.
@@ -1305,7 +1081,7 @@ function ensureStateNameIsUnique(stateName, state, statesByName) {
 }
 function ensureStatesAreDecorated(stateClasses) {
     stateClasses.forEach((stateClass) => {
-        if (!getStoreMetadata$1(stateClass)) {
+        if (!_getStoreMetadata(stateClass)) {
             throwStateDecoratorError(stateClass.name);
         }
     });
@@ -1335,23 +1111,8 @@ function jit_hasInjectableAnnotation(stateClass) {
     return annotations.some((annotation) => annotation?.ngMetadataName === 'Injectable');
 }
 
-/**
- * Init action
- */
-class InitState {
-    static { this.type = '@@INIT'; }
-}
-/**
- * Update action
- */
-class UpdateState {
-    static { this.type = '@@UPDATE_STATE'; }
-    constructor(addedStates) {
-        this.addedStates = addedStates;
-    }
-}
-
-const NGXS_DEVELOPMENT_OPTIONS = new InjectionToken('NGXS_DEVELOPMENT_OPTIONS', {
+const NG_DEV_MODE$3 = typeof ngDevMode === 'undefined' || ngDevMode;
+const NGXS_DEVELOPMENT_OPTIONS = new InjectionToken(NG_DEV_MODE$3 ? 'NGXS_DEVELOPMENT_OPTIONS' : '', {
     providedIn: 'root',
     factory: () => ({ warnOnUnhandledActions: true })
 });
@@ -1398,6 +1159,18 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.5", ngImpor
                 }] }] });
 
 const NG_DEV_MODE$2 = typeof ngDevMode === 'undefined' || ngDevMode;
+function cloneDefaults(defaults) {
+    let value = defaults === undefined ? {} : defaults;
+    if (defaults) {
+        if (Array.isArray(defaults)) {
+            value = defaults.slice();
+        }
+        else if (typeof defaults === 'object') {
+            value = { ...defaults };
+        }
+    }
+    return value;
+}
 /**
  * The `StateFactory` class adds root and feature states to the graph.
  * This extracts state names from state classes, checks if they already
@@ -1424,7 +1197,7 @@ class StateFactory {
         this._states = [];
         this._statesByName = {};
         this._statePaths = {};
-        this.getRuntimeSelectorContext = memoize(() => {
+        this.getRuntimeSelectorContext = _memoize(() => {
             // eslint-disable-next-line @typescript-eslint/no-this-alias
             const stateFactory = this;
             function resolveGetter(key) {
@@ -1469,19 +1242,6 @@ class StateFactory {
     get statePaths() {
         return this._parentFactory ? this._parentFactory.statePaths : this._statePaths;
     }
-    static _cloneDefaults(defaults) {
-        let value = defaults;
-        if (Array.isArray(defaults)) {
-            value = defaults.slice();
-        }
-        else if (isObject(defaults)) {
-            value = { ...defaults };
-        }
-        else if (defaults === undefined) {
-            value = {};
-        }
-        return value;
-    }
     ngOnDestroy() {
         this._actionsSubscription?.unsubscribe();
     }
@@ -1518,7 +1278,7 @@ class StateFactory {
                 isInitialised: false,
                 actions: meta.actions,
                 instance: this._injector.get(stateClass),
-                defaults: StateFactory._cloneDefaults(meta.defaults)
+                defaults: cloneDefaults(meta.defaults)
             };
             // ensure our store hasn't already been added
             // but don't throw since it could be lazy
@@ -1635,7 +1395,7 @@ class StateFactory {
         const newStates = [];
         const statesMap = this.statesByName;
         for (const stateClass of stateClasses) {
-            const stateName = getStoreMetadata$1(stateClass).name;
+            const stateName = _getStoreMetadata(stateClass).name;
             if (NG_DEV_MODE$2) {
                 ensureStateNameIsUnique(stateName, stateClass, statesMap);
             }
@@ -1660,7 +1420,7 @@ class StateFactory {
         // its lifecycle is in 'bootstrapped' state.
         return this.statesByName[name] && valueIsBootstrappedInInitialState;
     }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.5", ngImport: i0, type: StateFactory, deps: [{ token: i0.Injector }, { token: NgxsConfig }, { token: StateFactory, optional: true, skipSelf: true }, { token: InternalActions }, { token: InternalDispatchedActionResults }, { token: StateContextFactory }, { token: INITIAL_STATE_TOKEN, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.5", ngImport: i0, type: StateFactory, deps: [{ token: i0.Injector }, { token: NgxsConfig }, { token: StateFactory, optional: true, skipSelf: true }, { token: InternalActions }, { token: InternalDispatchedActionResults }, { token: StateContextFactory }, { token: _INITIAL_STATE_TOKEN, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
     /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.5", ngImport: i0, type: StateFactory }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.5", ngImport: i0, type: StateFactory, decorators: [{
@@ -1673,7 +1433,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.5", ngImpor
                     type: Optional
                 }, {
                     type: Inject,
-                    args: [INITIAL_STATE_TOKEN]
+                    args: [_INITIAL_STATE_TOKEN]
                 }] }] });
 
 // tslint:disable:unified-signatures
@@ -1761,7 +1521,7 @@ class Store {
             this._stateStream.next(storeValues);
         }
     }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.5", ngImport: i0, type: Store, deps: [{ token: StateStream }, { token: InternalStateOperations }, { token: NgxsConfig }, { token: InternalNgxsExecutionStrategy }, { token: StateFactory }, { token: INITIAL_STATE_TOKEN, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.5", ngImport: i0, type: Store, deps: [{ token: StateStream }, { token: InternalStateOperations }, { token: NgxsConfig }, { token: InternalNgxsExecutionStrategy }, { token: StateFactory }, { token: _INITIAL_STATE_TOKEN, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
     /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.5", ngImport: i0, type: Store, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.5", ngImport: i0, type: Store, decorators: [{
@@ -1771,7 +1531,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.5", ngImpor
                     type: Optional
                 }, {
                     type: Inject,
-                    args: [INITIAL_STATE_TOKEN]
+                    args: [_INITIAL_STATE_TOKEN]
                 }] }] });
 
 /**
@@ -1799,12 +1559,12 @@ 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, _bootstrapper) {
+    constructor(_store, _internalErrorReporter, _internalStateOperations, _stateContextFactory, _appBootstrappedState) {
         this._store = _store;
         this._internalErrorReporter = _internalErrorReporter;
         this._internalStateOperations = _internalStateOperations;
         this._stateContextFactory = _stateContextFactory;
-        this._bootstrapper = _bootstrapper;
+        this._appBootstrappedState = _appBootstrappedState;
         this._destroy$ = new ReplaySubject(1);
     }
     ngOnDestroy() {
@@ -1829,7 +1589,7 @@ class LifecycleStateManager {
         this._internalStateOperations
             .getRootStateOperations()
             .dispatch(action)
-            .pipe(filter(() => !!results), tap(() => this._invokeInitOnStates(results.states)), mergeMap(() => this._bootstrapper.appBootstrapped$), filter(appBootstrapped => !!appBootstrapped), catchError(error => {
+            .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
@@ -1868,13 +1628,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: i5.NgxsBootstrapper }], 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: InternalErrorReporter }, { token: InternalStateOperations }, { token: StateContextFactory }, { token: i5.ɵ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: i5.NgxsBootstrapper }] });
+        }], ctorParameters: () => [{ type: Store }, { type: InternalErrorReporter }, { type: InternalStateOperations }, { type: StateContextFactory }, { type: i5.ɵNgxsAppBootstrappedState }] });
 
 const NG_DEV_MODE = typeof ngDevMode === 'undefined' || ngDevMode;
 /**
@@ -2000,8 +1760,8 @@ function getRootProviders(states, options) {
         {
             provide: APP_BOOTSTRAP_LISTENER,
             useFactory: () => {
-                const bootstrapper = inject(NgxsBootstrapper);
-                return () => bootstrapper.bootstrap();
+                const appBootstrappedState = inject(_NgxsAppBootstrappedState);
+                return () => appBootstrappedState.bootstrap();
             },
             multi: true
         },
@@ -2075,7 +1835,7 @@ function Action(actions, options) {
                 throwActionDecoratorError();
             }
         }
-        const meta = ensureStoreMetadata$1(target.constructor);
+        const meta = _ensureStoreMetadata(target.constructor);
         if (!Array.isArray(actions)) {
             actions = [actions];
         }
@@ -2099,7 +1859,7 @@ function Action(actions, options) {
 function State(options) {
     return (target) => {
         const stateClass = target;
-        const meta = ensureStoreMetadata$1(stateClass);
+        const meta = _ensureStoreMetadata(stateClass);
         const inheritedStateClass = Object.getPrototypeOf(stateClass);
         const optionsWithInheritance = getStateOptions(inheritedStateClass, options);
         mutateMetaData({ meta, inheritedStateClass, optionsWithInheritance });
@@ -2189,7 +1949,7 @@ const selectorOptionsMetaAccessor = {
     }
 };
 function setupSelectorMetadata(originalFn, creationMetadata) {
-    const selectorMetaData = ensureSelectorMetadata$1(originalFn);
+    const selectorMetaData = _ensureSelectorMetadata(originalFn);
     selectorMetaData.originalFn = originalFn;
     let getExplicitSelectorOptions = () => ({});
     if (creationMetadata) {
@@ -2231,17 +1991,29 @@ function SelectorOptions(options) {
     });
 }
 
+/**
+ * @deprecated will be removed after v4
+ */
 function ensureStoreMetadata(target) {
-    return ensureStoreMetadata$1(target);
+    return _ensureStoreMetadata(target);
 }
+/**
+ * @deprecated will be removed after v4
+ */
 function getStoreMetadata(target) {
-    return getStoreMetadata$1(target);
+    return _getStoreMetadata(target);
 }
+/**
+ * @deprecated will be removed after v4
+ */
 function ensureSelectorMetadata(target) {
-    return ensureSelectorMetadata$1(target);
+    return _ensureSelectorMetadata(target);
 }
+/**
+ * @deprecated will be removed after v4
+ */
 function getSelectorMetadata(target) {
-    return getSelectorMetadata$1(target);
+    return _getSelectorMetadata(target);
 }
 
 function createSelector(selectors, projector, creationMetadata) {
@@ -2281,22 +2053,6 @@ function Selector(selectors) {
     };
 }
 
-class StateToken {
-    constructor(name) {
-        this.name = name;
-        const selectorMetadata = ensureSelectorMetadata$1(this);
-        selectorMetadata.makeRootSelector = (runtimeContext) => {
-            return runtimeContext.getStateGetter(this.name);
-        };
-    }
-    getName() {
-        return this.name;
-    }
-    toString() {
-        return `StateToken[${this.name}]`;
-    }
-}
-
 class NgxsDevelopmentModule {
     static forRoot(options) {
         return {
@@ -2314,12 +2070,18 @@ class NgxsDevelopmentModule {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.5", ngImport: i0, type: NgxsDevelopmentModule, decorators: [{
             type: NgModule
         }] });
+function provideNgxsDevelopmentOptions(options) {
+    return makeEnvironmentProviders([
+        NgxsUnhandledActionsLogger,
+        { provide: NGXS_DEVELOPMENT_OPTIONS, useValue: options }
+    ]);
+}
 
 function ensureValidSelector(selector, context = {}) {
     const noun = context.noun || 'selector';
     const prefix = context.prefix ? context.prefix + ': ' : '';
     ensureValueProvided(selector, { noun, prefix: context.prefix });
-    const metadata = getSelectorMetadata$1(selector) || getStoreMetadata$1(selector);
+    const metadata = _getSelectorMetadata(selector) || _getStoreMetadata(selector);
     if (!metadata) {
         throw new Error(`${prefix}The value provided as the ${noun} is not a valid selector.`);
     }
@@ -2464,5 +2226,5 @@ function withNgxsPlugin(plugin) {
  * Generated bundle index. Do not edit.
  */
 
-export { Action, Actions, InitState, NGXS_PLUGINS, NgxsDevelopmentModule, NgxsModule, NgxsSimpleChange, NgxsUnhandledActionsLogger, NoopNgxsExecutionStrategy, Select, Selector, SelectorOptions, State, StateStream, StateToken, Store, UpdateState, actionMatcher, createModelSelector, createPickSelector, createPropertySelectors, createSelector, ensureSelectorMetadata, ensureStoreMetadata, getActionTypeFromInstance, getSelectorMetadata, getStoreMetadata, getValue, ofAction, ofActionCanceled, ofActionCompleted, ofActionDispatched, ofActionErrored, ofActionSuccessful, provideStates, provideStore, setValue, withNgxsPlugin, NgxsFeatureModule as ɵNgxsFeatureModule, NgxsRootModule as ɵNgxsRootModule };
+export { Action, Actions, NgxsDevelopmentModule, NgxsModule, NgxsSimpleChange, NgxsUnhandledActionsLogger, NoopNgxsExecutionStrategy, Select, Selector, SelectorOptions, State, StateStream, Store, createModelSelector, createPickSelector, createPropertySelectors, createSelector, ensureSelectorMetadata, ensureStoreMetadata, getSelectorMetadata, getStoreMetadata, ofAction, ofActionCanceled, ofActionCompleted, ofActionDispatched, ofActionErrored, ofActionSuccessful, provideStates, provideStore, withNgxsPlugin, NgxsFeatureModule as ɵNgxsFeatureModule, NgxsRootModule as ɵNgxsRootModule };
 //# sourceMappingURL=ngxs-store.mjs.map