@ngxs/store 3.7.3 → 3.7.4

package/bundles/ngxs-store.umd.js

@@ -223,108 +223,84 @@
         return value;
     }
 
-    var _a;
     /**
      * @fileoverview added by tsickle
      * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
      */
-    /** @enum {string} */
-    var VALIDATION_CODE = {
-        STATE_NAME: 'STATE_NAME',
-        STATE_UNIQUE: 'STATE_UNIQUE',
-        STATE_NAME_PROPERTY: 'STATE_NAME_PROPERTY',
-        STATE_DECORATOR: 'STATE_DECORATOR',
-        INCORRECT_PRODUCTION: 'INCORRECT_PRODUCTION',
-        INCORRECT_DEVELOPMENT: 'INCORRECT_DEVELOPMENT',
-        SELECT_FACTORY_NOT_CONNECTED: 'SELECT_FACTORY_NOT_CONNECTED',
-        ACTION_DECORATOR: 'ACTION_DECORATOR',
-        SELECTOR_DECORATOR: 'SELECTOR_DECORATOR',
-        ZONE_WARNING: 'ZONE_WARNING',
-        PATCHING_ARRAY: 'PATCHING_ARRAY',
-        PATCHING_PRIMITIVE: 'PATCHING_PRIMITIVE',
-        UNDECORATED_STATE_IN_IVY: 'UNDECORATED_STATE_IN_IVY',
-    };
-    /** @type {?} */
-    var CONFIG_MESSAGES = (_a = {},
-        _a[VALIDATION_CODE.STATE_NAME] = (/**
-         * @param {?} name
-         * @return {?}
-         */
-        function (name) {
-            return name + " is not a valid state name. It needs to be a valid object property name.";
-        }),
-        _a[VALIDATION_CODE.STATE_NAME_PROPERTY] = (/**
-         * @return {?}
-         */
-        function () { return "States must register a 'name' property"; }),
-        _a[VALIDATION_CODE.STATE_UNIQUE] = (/**
-         * @param {?} current
-         * @param {?} newName
-         * @param {?} oldName
-         * @return {?}
-         */
-        function (current, newName, oldName) {
-            return "State name '" + current + "' from " + newName + " already exists in " + oldName;
-        }),
-        _a[VALIDATION_CODE.STATE_DECORATOR] = (/**
-         * @return {?}
-         */
-        function () { return 'States must be decorated with @State() decorator'; }),
-        _a[VALIDATION_CODE.INCORRECT_PRODUCTION] = (/**
-         * @return {?}
-         */
-        function () {
-            return 'Angular is running in production mode but NGXS is still running in the development mode!\n' +
-                'Please set developmentMode to false on the NgxsModule options when in production mode.\n' +
-                'NgxsModule.forRoot(states, { developmentMode: !environment.production })';
-        }),
-        _a[VALIDATION_CODE.INCORRECT_DEVELOPMENT] = (/**
-         * @return {?}
-         */
-        function () {
-            return 'RECOMMENDATION: Set developmentMode to true on the NgxsModule when Angular is running in development mode.\n' +
-                'NgxsModule.forRoot(states, { developmentMode: !environment.production })';
-        }),
-        _a[VALIDATION_CODE.SELECT_FACTORY_NOT_CONNECTED] = (/**
-         * @return {?}
-         */
-        function () {
-            return 'You have forgotten to import the NGXS module!';
-        }),
-        _a[VALIDATION_CODE.ACTION_DECORATOR] = (/**
-         * @return {?}
-         */
-        function () {
-            return '@Action() decorator cannot be used with static methods';
-        }),
-        _a[VALIDATION_CODE.SELECTOR_DECORATOR] = (/**
-         * @return {?}
-         */
-        function () { return 'Selectors only work on methods'; }),
-        _a[VALIDATION_CODE.ZONE_WARNING] = (/**
-         * @return {?}
-         */
-        function () {
-            return 'Your application was bootstrapped with nooped zone and your execution strategy requires an actual NgZone!\n' +
-                'Please set the value of the executionStrategy property to NoopNgxsExecutionStrategy.\n' +
-                'NgxsModule.forRoot(states, { executionStrategy: NoopNgxsExecutionStrategy })';
-        }),
-        _a[VALIDATION_CODE.PATCHING_ARRAY] = (/**
-         * @return {?}
-         */
-        function () { return 'Patching arrays is not supported.'; }),
-        _a[VALIDATION_CODE.PATCHING_PRIMITIVE] = (/**
-         * @return {?}
-         */
-        function () { return 'Patching primitives is not supported.'; }),
-        _a[VALIDATION_CODE.UNDECORATED_STATE_IN_IVY] = (/**
-         * @param {?} name
-         * @return {?}
-         */
-        function (name) {
-            return "'" + name + "' class should be decorated with @Injectable() right after the @State() decorator";
-        }),
-        _a);
+    /**
+     * @param {?} name
+     * @return {?}
+     */
+    function throwStateNameError(name) {
+        throw new Error(name + " is not a valid state name. It needs to be a valid object property name.");
+    }
+    /**
+     * @return {?}
+     */
+    function throwStateNamePropertyError() {
+        throw new Error("States must register a 'name' property.");
+    }
+    /**
+     * @param {?} current
+     * @param {?} newName
+     * @param {?} oldName
+     * @return {?}
+     */
+    function throwStateUniqueError(current, newName, oldName) {
+        throw new Error("State name '" + current + "' from " + newName + " already exists in " + oldName + ".");
+    }
+    /**
+     * @param {?} name
+     * @return {?}
+     */
+    function throwStateDecoratorError(name) {
+        throw new Error("States must be decorated with @State() decorator, but \"" + name + "\" isn't.");
+    }
+    /**
+     * @return {?}
+     */
+    function throwActionDecoratorError() {
+        throw new Error('@Action() decorator cannot be used with static methods.');
+    }
+    /**
+     * @return {?}
+     */
+    function throwSelectorDecoratorError() {
+        throw new Error('Selectors only work on methods.');
+    }
+    /**
+     * @return {?}
+     */
+    function getZoneWarningMessage() {
+        return ('Your application was bootstrapped with nooped zone and your execution strategy requires an actual NgZone!\n' +
+            'Please set the value of the executionStrategy property to NoopNgxsExecutionStrategy.\n' +
+            'NgxsModule.forRoot(states, { executionStrategy: NoopNgxsExecutionStrategy })');
+    }
+    /**
+     * @param {?} name
+     * @return {?}
+     */
+    function getUndecoratedStateInIvyWarningMessage(name) {
+        return "'" + name + "' class should be decorated with @Injectable() right after the @State() decorator";
+    }
+    /**
+     * @return {?}
+     */
+    function throwSelectFactoryNotConnectedError() {
+        throw new Error('You have forgotten to import the NGXS module!');
+    }
+    /**
+     * @return {?}
+     */
+    function throwPatchingArrayError() {
+        throw new Error('Patching arrays is not supported.');
+    }
+    /**
+     * @return {?}
+     */
+    function throwPatchingPrimitiveError() {
+        throw new Error('Patching primitives is not supported.');
+    }
 
     /**
      * @fileoverview added by tsickle
@@ -334,7 +310,11 @@
         function DispatchOutsideZoneNgxsExecutionStrategy(_ngZone, _platformId) {
             this._ngZone = _ngZone;
             this._platformId = _platformId;
-            this.verifyZoneIsNotNooped(this._ngZone);
+            // Caretaker note: we have still left the `typeof` condition in order to avoid
+            // creating a breaking change for projects that still use the View Engine.
+            if (typeof ngDevMode === 'undefined' || ngDevMode) {
+                verifyZoneIsNotNooped(_ngZone);
+            }
         }
         /**
          * @template T
@@ -401,33 +381,15 @@
             }
             return func();
         };
-        /**
-         * @private
-         * @param {?} ngZone
-         * @return {?}
-         */
-        DispatchOutsideZoneNgxsExecutionStrategy.prototype.verifyZoneIsNotNooped = /**
-         * @private
-         * @param {?} ngZone
-         * @return {?}
-         */
-        function (ngZone) {
-            // `NoopNgZone` is not exposed publicly as it doesn't expect
-            // to be used outside of the core Angular code, thus we just have
-            // to check if the zone doesn't extend or instanceof `NgZone`
-            if (ngZone instanceof core.NgZone) {
-                return;
-            }
-            console.warn(CONFIG_MESSAGES[VALIDATION_CODE.ZONE_WARNING]());
-        };
         DispatchOutsideZoneNgxsExecutionStrategy.decorators = [
-            { type: core.Injectable }
+            { type: core.Injectable, args: [{ providedIn: 'root' },] }
         ];
         /** @nocollapse */
         DispatchOutsideZoneNgxsExecutionStrategy.ctorParameters = function () { return [
             { type: core.NgZone },
             { type: String, decorators: [{ type: core.Inject, args: [core.PLATFORM_ID,] }] }
         ]; };
+        /** @nocollapse */ DispatchOutsideZoneNgxsExecutionStrategy.ngInjectableDef = core.defineInjectable({ factory: function DispatchOutsideZoneNgxsExecutionStrategy_Factory() { return new DispatchOutsideZoneNgxsExecutionStrategy(core.inject(core.NgZone), core.inject(core.PLATFORM_ID)); }, token: DispatchOutsideZoneNgxsExecutionStrategy, providedIn: "root" });
         return DispatchOutsideZoneNgxsExecutionStrategy;
     }());
     if (false) {
@@ -441,6 +403,21 @@
          * @private
          */
         DispatchOutsideZoneNgxsExecutionStrategy.prototype._platformId;
+    }
+    // Caretaker note: this should exist as a separate function and not a class method,
+    // since class methods are not tree-shakable.
+    /**
+     * @param {?} ngZone
+     * @return {?}
+     */
+    function verifyZoneIsNotNooped(ngZone) {
+        // `NoopNgZone` is not exposed publicly as it doesn't expect
+        // to be used outside of the core Angular code, thus we just have
+        // to check if the zone doesn't extend or instanceof `NgZone`.
+        if (ngZone instanceof core.NgZone) {
+            return;
+        }
+        console.warn(getZoneWarningMessage());
     }
 
     /**
@@ -454,10 +431,6 @@
     /** @type {?} */
     var NGXS_PLUGINS = new core.InjectionToken('NGXS_PLUGINS');
     /** @type {?} */
-    var NG_TEST_MODE = new core.InjectionToken('NG_TEST_MODE');
-    /** @type {?} */
-    var NG_DEV_MODE = new core.InjectionToken('NG_DEV_MODE');
-    /** @type {?} */
     var META_KEY = 'NGXS_META';
     /** @type {?} */
     var META_OPTIONS_KEY = 'NGXS_OPTIONS_META';
@@ -500,6 +473,9 @@
          * Run in development mode. This will add additional debugging features:
          * - Object.freeze on the state and actions to guarantee immutability
          * (default: false)
+         *
+         * @deprecated This property is no longer necessary when the Ivy compiler is used.
+         * We'll determine the development mode through the `ngDevMode`. It's still essential with View Engine.
          * @type {?}
          */
         NgxsConfig.prototype.developmentMode;
@@ -668,11 +644,72 @@
      * @fileoverview added by tsickle
      * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
      */
+    var NoopNgxsExecutionStrategy = /** @class */ (function () {
+        function NoopNgxsExecutionStrategy() {
+        }
+        /**
+         * @template T
+         * @param {?} func
+         * @return {?}
+         */
+        NoopNgxsExecutionStrategy.prototype.enter = /**
+         * @template T
+         * @param {?} func
+         * @return {?}
+         */
+        function (func) {
+            return func();
+        };
+        /**
+         * @template T
+         * @param {?} func
+         * @return {?}
+         */
+        NoopNgxsExecutionStrategy.prototype.leave = /**
+         * @template T
+         * @param {?} func
+         * @return {?}
+         */
+        function (func) {
+            return func();
+        };
+        NoopNgxsExecutionStrategy.decorators = [
+            { type: core.Injectable, args: [{ providedIn: 'root' },] }
+        ];
+        /** @nocollapse */ NoopNgxsExecutionStrategy.ngInjectableDef = core.defineInjectable({ factory: function NoopNgxsExecutionStrategy_Factory() { return new NoopNgxsExecutionStrategy(); }, token: NoopNgxsExecutionStrategy, providedIn: "root" });
+        return NoopNgxsExecutionStrategy;
+    }());
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * The strategy that might be provided by users through `options.executionStrategy`.
+     * @type {?}
+     */
+    var USER_PROVIDED_NGXS_EXECUTION_STRATEGY = new core.InjectionToken('USER_PROVIDED_NGXS_EXECUTION_STRATEGY');
     /*
      * Internal execution strategy injection token
      */
     /** @type {?} */
-    var NGXS_EXECUTION_STRATEGY = new core.InjectionToken('NGXS_EXECUTION_STRATEGY');
+    var NGXS_EXECUTION_STRATEGY = new core.InjectionToken('NGXS_EXECUTION_STRATEGY', {
+        providedIn: 'root',
+        factory: (/**
+         * @return {?}
+         */
+        function () {
+            /** @type {?} */
+            var injector = core.inject(core.INJECTOR);
+            /** @type {?} */
+            var executionStrategy = injector.get(USER_PROVIDED_NGXS_EXECUTION_STRATEGY);
+            return executionStrategy
+                ? injector.get(executionStrategy)
+                : injector.get(typeof core.ɵglobal.Zone !== 'undefined'
+                    ? DispatchOutsideZoneNgxsExecutionStrategy
+                    : NoopNgxsExecutionStrategy);
+        })
+    });
     /**
      * @record
      */
@@ -1153,10 +1190,12 @@
              * @return {?}
              */
             function (g) { return g === stateClass; }));
-            if (!meta) {
+            // Caretaker note: we have still left the `typeof` condition in order to avoid
+            // creating a breaking change for projects that still use the View Engine.
+            if ((typeof ngDevMode === 'undefined' || ngDevMode) && !meta) {
                 throw new Error("Child state not found: " + stateClass + ". \r\nYou may have forgotten to add states to module");
             }
-            return (/** @type {?} */ ((/** @type {?} */ (meta[META_KEY])).name));
+            return (/** @type {?} */ ((/** @type {?} */ ((/** @type {?} */ (meta))[META_KEY])).name));
         });
         return stateClasses.reduce((/**
          * @param {?} result
@@ -1288,7 +1327,9 @@
              * @return {?}
              */
             function (dep) {
-                if (ancestors.indexOf(dep) >= 0) {
+                // Caretaker note: we have still left the `typeof` condition in order to avoid
+                // creating a breaking change for projects that still use the View Engine.
+                if ((typeof ngDevMode === 'undefined' || ngDevMode) && ancestors.indexOf(dep) >= 0) {
                     throw new Error("Circular dependency '" + dep + "' is required by '" + name + "': " + ancestors.join(' -> '));
                 }
                 if (visited[dep]) {
@@ -1882,6 +1923,18 @@
         function StateStream() {
             return _super.call(this, {}) || this;
         }
+        /**
+         * @return {?}
+         */
+        StateStream.prototype.ngOnDestroy = /**
+         * @return {?}
+         */
+        function () {
+            // The `StateStream` should never emit values once the root view is removed, e.g. when the `NgModuleRef.destroy()` is called.
+            // This will eliminate memory leaks in server-side rendered apps where the `StateStream` is created per each HTTP request, users
+            // might forget to unsubscribe from `store.select` or `store.subscribe`, thus this will lead to huge memory leaks in SSR apps.
+            this.complete();
+        };
         StateStream.decorators = [
             { type: core.Injectable }
         ];
@@ -2243,103 +2296,6 @@
         return o;
     });
 
-    /**
-     * @fileoverview added by tsickle
-     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    var HostEnvironment = /** @class */ (function () {
-        function HostEnvironment(isDevMode, isTestMode) {
-            this.isDevMode = isDevMode;
-            this.isTestMode = isTestMode;
-        }
-        HostEnvironment.decorators = [
-            { type: core.Injectable }
-        ];
-        /** @nocollapse */
-        HostEnvironment.ctorParameters = function () { return [
-            { type: undefined, decorators: [{ type: core.Inject, args: [NG_DEV_MODE,] }] },
-            { type: undefined, decorators: [{ type: core.Inject, args: [NG_TEST_MODE,] }] }
-        ]; };
-        return HostEnvironment;
-    }());
-    if (false) {
-        /** @type {?} */
-        HostEnvironment.prototype.isDevMode;
-        /** @type {?} */
-        HostEnvironment.prototype.isTestMode;
-    }
-
-    /**
-     * @fileoverview added by tsickle
-     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    var ConfigValidator = /** @class */ (function () {
-        function ConfigValidator(_host, _config) {
-            this._host = _host;
-            this._config = _config;
-        }
-        Object.defineProperty(ConfigValidator.prototype, "isIncorrectProduction", {
-            get: /**
-             * @private
-             * @return {?}
-             */
-            function () {
-                return !this._host.isDevMode() && this._config.developmentMode;
-            },
-            enumerable: true,
-            configurable: true
-        });
-        Object.defineProperty(ConfigValidator.prototype, "isIncorrectDevelopment", {
-            get: /**
-             * @private
-             * @return {?}
-             */
-            function () {
-                return this._host.isDevMode() && !this._config.developmentMode;
-            },
-            enumerable: true,
-            configurable: true
-        });
-        /**
-         * @return {?}
-         */
-        ConfigValidator.prototype.verifyDevMode = /**
-         * @return {?}
-         */
-        function () {
-            if (this._host.isTestMode()) {
-                return;
-            }
-            if (this.isIncorrectProduction) {
-                console.warn(CONFIG_MESSAGES[VALIDATION_CODE.INCORRECT_PRODUCTION]());
-            }
-            else if (this.isIncorrectDevelopment) {
-                console.warn(CONFIG_MESSAGES[VALIDATION_CODE.INCORRECT_DEVELOPMENT]());
-            }
-        };
-        ConfigValidator.decorators = [
-            { type: core.Injectable }
-        ];
-        /** @nocollapse */
-        ConfigValidator.ctorParameters = function () { return [
-            { type: HostEnvironment },
-            { type: NgxsConfig }
-        ]; };
-        return ConfigValidator;
-    }());
-    if (false) {
-        /**
-         * @type {?}
-         * @private
-         */
-        ConfigValidator.prototype._host;
-        /**
-         * @type {?}
-         * @private
-         */
-        ConfigValidator.prototype._config;
-    }
-
     /**
      * @fileoverview added by tsickle
      * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
@@ -2349,11 +2305,10 @@
      * @ignore
      */
     var InternalStateOperations = /** @class */ (function () {
-        function InternalStateOperations(_stateStream, _dispatcher, _config, configValidator) {
+        function InternalStateOperations(_stateStream, _dispatcher, _config) {
             this._stateStream = _stateStream;
             this._dispatcher = _dispatcher;
             this._config = _config;
-            configValidator.verifyDevMode();
         }
         /**
          * Returns the root state operators.
@@ -2385,44 +2340,22 @@
                  */
                 function (actionOrActions) { return _this._dispatcher.dispatch(actionOrActions); })
             };
-            if (this._config.developmentMode) {
-                return this.ensureStateAndActionsAreImmutable(rootStateOperations);
+            // We have to have that duplication since this will allow us to tree-shake `ensureStateAndActionsAreImmutable`
+            // and `deepFreeze` in Ivy production build.
+            // The below `if` condition checks 2 things:
+            // 1) if we're in View Engine (`ngDevMode` is `undefined`)
+            // 2) if we're running tests, we should fallback to `config.developmentMode` to be backwards-compatible
+            if (typeof ngDevMode === 'undefined' || (ngDevMode && internals.isAngularInTestMode())) {
+                return this._config.developmentMode
+                    ? ensureStateAndActionsAreImmutable(rootStateOperations)
+                    : rootStateOperations;
+            }
+            else {
+                // If we're in Ivy and not running tests, then tree-shake `ensureStateAndActionsAreImmutable` and `deepFreeze`.
+                return ngDevMode
+                    ? ensureStateAndActionsAreImmutable(rootStateOperations)
+                    : rootStateOperations;
             }
-            return rootStateOperations;
-        };
-        /**
-         * @private
-         * @param {?} root
-         * @return {?}
-         */
-        InternalStateOperations.prototype.ensureStateAndActionsAreImmutable = /**
-         * @private
-         * @param {?} root
-         * @return {?}
-         */
-        function (root) {
-            return {
-                getState: (/**
-                 * @return {?}
-                 */
-                function () { return root.getState(); }),
-                setState: (/**
-                 * @param {?} value
-                 * @return {?}
-                 */
-                function (value) {
-                    /** @type {?} */
-                    var frozenValue = deepFreeze(value);
-                    return root.setState(frozenValue);
-                }),
-                dispatch: (/**
-                 * @param {?} actions
-                 * @return {?}
-                 */
-                function (actions) {
-                    return root.dispatch(actions);
-                })
-            };
         };
         /**
          * @param {?} results
@@ -2448,8 +2381,7 @@
         InternalStateOperations.ctorParameters = function () { return [
             { type: StateStream },
             { type: InternalDispatcher },
-            { type: NgxsConfig },
-            { type: ConfigValidator }
+            { type: NgxsConfig }
         ]; };
         return InternalStateOperations;
     }());
@@ -2469,6 +2401,34 @@
          * @private
          */
         InternalStateOperations.prototype._config;
+    }
+    /**
+     * @param {?} root
+     * @return {?}
+     */
+    function ensureStateAndActionsAreImmutable(root) {
+        return {
+            getState: (/**
+             * @return {?}
+             */
+            function () { return root.getState(); }),
+            setState: (/**
+             * @param {?} value
+             * @return {?}
+             */
+            function (value) {
+                /** @type {?} */
+                var frozenValue = deepFreeze(value);
+                return root.setState(frozenValue);
+            }),
+            dispatch: (/**
+             * @param {?} actions
+             * @return {?}
+             */
+            function (actions) {
+                return root.dispatch(actions);
+            })
+        };
     }
 
     /**
@@ -2487,10 +2447,10 @@
          */
         function (existingState) {
             if (Array.isArray(val)) {
-                throw new Error(CONFIG_MESSAGES[VALIDATION_CODE.PATCHING_ARRAY]());
+                throwPatchingArrayError();
             }
             else if (typeof val !== 'object') {
-                throw new Error(CONFIG_MESSAGES[VALIDATION_CODE.PATCHING_PRIMITIVE]());
+                throwPatchingPrimitiveError();
             }
             /** @type {?} */
             var newState = __assign({}, ((/** @type {?} */ (existingState))));
@@ -2657,72 +2617,64 @@
          * @param {?} name
          * @return {?}
          */
-        StoreValidators.stateNameErrorMessage = /**
-         * @param {?} name
-         * @return {?}
-         */
-        function (name) {
-            return CONFIG_MESSAGES[VALIDATION_CODE.STATE_NAME](name);
-        };
-        /**
-         * @param {?} name
-         * @return {?}
-         */
-        StoreValidators.checkCorrectStateName = /**
+        StoreValidators.checkThatStateIsNamedCorrectly = /**
          * @param {?} name
          * @return {?}
          */
         function (name) {
             if (!name) {
-                throw new Error(CONFIG_MESSAGES[VALIDATION_CODE.STATE_NAME_PROPERTY]());
+                throwStateNamePropertyError();
             }
-            if (!this.stateNameRegex.test(name)) {
-                throw new Error(this.stateNameErrorMessage(name));
+            else if (!this.stateNameRegex.test(name)) {
+                throwStateNameError(name);
             }
         };
         /**
+         * @param {?} stateName
          * @param {?} state
          * @param {?} statesByName
          * @return {?}
          */
-        StoreValidators.checkStateNameIsUnique = /**
+        StoreValidators.checkThatStateNameIsUnique = /**
+         * @param {?} stateName
          * @param {?} state
          * @param {?} statesByName
          * @return {?}
          */
-        function (state, statesByName) {
-            /** @type {?} */
-            var meta = this.getValidStateMeta(state);
-            /** @type {?} */
-            var stateName = (/** @type {?} */ ((/** @type {?} */ (meta)).name));
+        function (stateName, state, statesByName) {
             /** @type {?} */
             var existingState = statesByName[stateName];
             if (existingState && existingState !== state) {
-                throw new Error(CONFIG_MESSAGES[VALIDATION_CODE.STATE_UNIQUE](stateName, state.name, existingState.name));
+                throwStateUniqueError(stateName, state.name, existingState.name);
             }
-            return stateName;
         };
         /**
-         * @param {?} state
+         * @param {?} stateClasses
          * @return {?}
          */
-        StoreValidators.getValidStateMeta = /**
-         * @param {?} state
+        StoreValidators.checkThatStateClassesHaveBeenDecorated = /**
+         * @param {?} stateClasses
          * @return {?}
          */
-        function (state) {
-            /** @type {?} */
-            var meta = getStoreMetadata(state);
-            if (!meta) {
-                throw new Error(CONFIG_MESSAGES[VALIDATION_CODE.STATE_DECORATOR]());
-            }
-            return meta;
+        function (stateClasses) {
+            stateClasses.forEach((/**
+             * @param {?} stateClass
+             * @return {?}
+             */
+            function (stateClass) {
+                if (!getStoreMetadata(stateClass)) {
+                    throwStateDecoratorError(stateClass.name);
+                }
+            }));
         };
         StoreValidators.stateNameRegex = new RegExp('^[a-zA-Z0-9_]+$');
         return StoreValidators;
     }());
     if (false) {
-        /** @type {?} */
+        /**
+         * @type {?}
+         * @private
+         */
         StoreValidators.stateNameRegex;
     }
 
@@ -2864,19 +2816,6 @@
             }
             return value;
         };
-        /**
-         * @private
-         * @param {?} stateClasses
-         * @return {?}
-         */
-        StateFactory.checkStatesAreValid = /**
-         * @private
-         * @param {?} stateClasses
-         * @return {?}
-         */
-        function (stateClasses) {
-            stateClasses.forEach(StoreValidators.getValidStateMeta);
-        };
         /**
          * @return {?}
          */
@@ -2905,7 +2844,11 @@
          */
         function (stateClasses) {
             var e_1, _a;
-            StateFactory.checkStatesAreValid(stateClasses);
+            // Caretaker note: we have still left the `typeof` condition in order to avoid
+            // creating a breaking change for projects that still use the View Engine.
+            if (typeof ngDevMode === 'undefined' || ngDevMode) {
+                StoreValidators.checkThatStateClassesHaveBeenDecorated(stateClasses);
+            }
             var newStates = this.addToStatesMap(stateClasses).newStates;
             if (!newStates.length)
                 return [];
@@ -3000,18 +2943,22 @@
             var _this = this;
             if (this._actionsSubscription !== null)
                 return;
+            /** @type {?} */
+            var dispatched$ = new rxjs.Subject();
             this._actionsSubscription = this._actions
                 .pipe(operators.filter((/**
              * @param {?} ctx
              * @return {?}
              */
             function (ctx) { return ctx.status === "DISPATCHED" /* Dispatched */; })), operators.mergeMap((/**
-             * @param {?} __0
+             * @param {?} ctx
              * @return {?}
              */
-            function (_a) {
-                var action = _a.action;
-                return _this.invokeActions(_this._actions, (/** @type {?} */ (action))).pipe(operators.map((/**
+            function (ctx) {
+                dispatched$.next(ctx);
+                /** @type {?} */
+                var action = ctx.action;
+                return _this.invokeActions(dispatched$, (/** @type {?} */ (action))).pipe(operators.map((/**
                  * @return {?}
                  */
                 function () { return (/** @type {?} */ ({ action: action, status: "SUCCESSFUL" /* Successful */ })); })), operators.defaultIfEmpty((/** @type {?} */ ({ action: action, status: "CANCELED" /* Canceled */ }))), operators.catchError((/**
@@ -3033,17 +2980,17 @@
          */
         /**
          * Invoke actions on the states.
-         * @param {?} actions$
+         * @param {?} dispatched$
          * @param {?} action
          * @return {?}
          */
         StateFactory.prototype.invokeActions = /**
          * Invoke actions on the states.
-         * @param {?} actions$
+         * @param {?} dispatched$
          * @param {?} action
          * @return {?}
          */
-        function (actions$, action) {
+        function (dispatched$, action) {
             var e_2, _a, e_3, _b;
             /** @type {?} */
             var type = (/** @type {?} */ (getActionTypeFromInstance(action)));
@@ -3075,10 +3022,22 @@
                                         // `handler(ctx) { return EMPTY; }`
                                         // then the action will be canceled.
                                         // See https://github.com/ngxs/store/issues/1568
-                                        result = result.pipe(operators.defaultIfEmpty({}));
+                                        result = result.pipe(operators.mergeMap((/**
+                                         * @param {?} value
+                                         * @return {?}
+                                         */
+                                        function (value) {
+                                            if (value instanceof Promise) {
+                                                return rxjs.from(value);
+                                            }
+                                            if (value instanceof rxjs.Observable) {
+                                                return value;
+                                            }
+                                            return rxjs.of(value);
+                                        })), operators.defaultIfEmpty({}));
                                         if (actionMeta.options.cancelUncompleted) {
                                             // todo: ofActionDispatched should be used with action class
-                                            result = result.pipe(operators.takeUntil(actions$.pipe(ofActionDispatched((/** @type {?} */ (action))))));
+                                            result = result.pipe(operators.takeUntil(dispatched$.pipe(ofActionDispatched((/** @type {?} */ (action))))));
                                         }
                                     }
                                     else {
@@ -3133,7 +3092,12 @@
                 for (var stateClasses_1 = __values(stateClasses), stateClasses_1_1 = stateClasses_1.next(); !stateClasses_1_1.done; stateClasses_1_1 = stateClasses_1.next()) {
                     var stateClass = stateClasses_1_1.value;
                     /** @type {?} */
-                    var stateName = StoreValidators.checkStateNameIsUnique(stateClass, statesMap);
+                    var stateName = (/** @type {?} */ (getStoreMetadata(stateClass).name));
+                    // Caretaker note: we have still left the `typeof` condition in order to avoid
+                    // creating a breaking change for projects that still use the View Engine.
+                    if (typeof ngDevMode === 'undefined' || ngDevMode) {
+                        StoreValidators.checkThatStateNameIsUnique(stateName, stateClass, statesMap);
+                    }
                     /** @type {?} */
                     var unmountedState = !statesMap[stateName];
                     if (unmountedState) {
@@ -3682,6 +3646,12 @@
             this._config = _config;
             this._internalExecutionStrategy = _internalExecutionStrategy;
             this._stateFactory = _stateFactory;
+            /**
+             * This is a derived state stream that leaves NGXS execution strategy to emit state changes within the Angular zone,
+             * because state is being changed actually within the `<root>` zone, see `InternalDispatcher#dispatchSingle`.
+             * All selects would use this stream, and it would call leave only once for any state change across all active selectors.
+             */
+            this._selectableStateStream = this._stateStream.pipe(leaveNgxs(this._internalExecutionStrategy), operators.publishReplay(1), operators.refCount());
             this.initStateStream(initialStateValue);
         }
         /**
@@ -3712,7 +3682,7 @@
             var _this = this;
             /** @type {?} */
             var selectorFn = this.getStoreBoundSelectorFn(selector);
-            return this._stateStream.pipe(operators.map(selectorFn), operators.catchError((/**
+            return this._selectableStateStream.pipe(operators.map(selectorFn), operators.catchError((/**
              * @param {?} err
              * @return {?}
              */
@@ -3764,7 +3734,9 @@
          * @return {?}
          */
         function (fn) {
-            return this._stateStream.pipe(leaveNgxs(this._internalExecutionStrategy)).subscribe(fn);
+            return this._selectableStateStream
+                .pipe(leaveNgxs(this._internalExecutionStrategy))
+                .subscribe(fn);
         };
         /**
          * Return the raw value of the state.
@@ -3855,6 +3827,14 @@
         return Store;
     }());
     if (false) {
+        /**
+         * This is a derived state stream that leaves NGXS execution strategy to emit state changes within the Angular zone,
+         * because state is being changed actually within the `<root>` zone, see `InternalDispatcher#dispatchSingle`.
+         * All selects would use this stream, and it would call leave only once for any state change across all active selectors.
+         * @type {?}
+         * @private
+         */
+        Store.prototype._selectableStateStream;
         /**
          * @type {?}
          * @private
@@ -3887,9 +3867,8 @@
      * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
      */
     /**
-     * Allows the select decorator to get access to the DI store.
-     * \@internal only use in \@Select decorator
-     * @ignore
+     * Allows the select decorator to get access to the DI store, this is used internally
+     * in `\@Select` decorator.
      */
     var SelectFactory = /** @class */ (function () {
         function SelectFactory(store, config) {
@@ -3909,13 +3888,14 @@
         SelectFactory.store = null;
         SelectFactory.config = null;
         SelectFactory.decorators = [
-            { type: core.Injectable }
+            { type: core.Injectable, args: [{ providedIn: 'root' },] }
         ];
         /** @nocollapse */
         SelectFactory.ctorParameters = function () { return [
             { type: Store },
             { type: NgxsConfig }
         ]; };
+        /** @nocollapse */ SelectFactory.ngInjectableDef = core.defineInjectable({ factory: function SelectFactory_Factory() { return new SelectFactory(core.inject(Store), core.inject(NgxsConfig)); }, token: SelectFactory, providedIn: "root" });
         return SelectFactory;
     }());
     if (false) {
@@ -3979,44 +3959,6 @@
         UpdateState.prototype.addedStates;
     }
 
-    /**
-     * @fileoverview added by tsickle
-     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /** @type {?} */
-    var ivyEnabledInDevMode$ = new rxjs.ReplaySubject(1);
-    /**
-     * Ivy exposes helper functions to the global `window.ng` object.
-     * Those functions are `getComponent, getContext,
-     * getListeners, getViewComponent, getHostElement, getInjector,
-     * getRootComponents, getDirectives, getDebugNode`
-     * Previously, old view engine exposed `window.ng.coreTokens` and
-     * `window.ng.probe` if an application was in development/production.
-     * Ivy doesn't expose these functions in production. Developers will be able
-     * to see warnings in both JIT/AOT modes, but only if an application
-     * is in development.
-     * @return {?}
-     */
-    function setIvyEnabledInDevMode() {
-        try {
-            // `try-catch` will also handle server-side rendering, as
-            // `window is not defined` will not be thrown.
-            /** @type {?} */
-            var ng = ((/** @type {?} */ (window))).ng;
-            /** @type {?} */
-            var _viewEngineEnabled = !!ng.probe && !!ng.coreTokens;
-            /** @type {?} */
-            var _ivyEnabledInDevMode = !_viewEngineEnabled && core.isDevMode();
-            ivyEnabledInDevMode$.next(_ivyEnabledInDevMode);
-        }
-        catch (_a) {
-            ivyEnabledInDevMode$.next(false);
-        }
-        finally {
-            ivyEnabledInDevMode$.complete();
-        }
-    }
-
     /**
      * @fileoverview added by tsickle
      * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
@@ -4026,10 +3968,11 @@
      * @ignore
      */
     var NgxsRootModule = /** @class */ (function () {
-        function NgxsRootModule(factory, internalStateOperations, _store, _select, states, lifecycleStateManager) {
+        function NgxsRootModule(factory, internalStateOperations, _store, injector, states, lifecycleStateManager) {
             if (states === void 0) { states = []; }
-            // Validate states on having the `@Injectable()` decorator in Ivy
-            setIvyEnabledInDevMode();
+            // If the user is running View Engine then we create the `SelectFactory` instance,
+            // otherwise it'll be tree-shaken away in Ivy.
+            !core.ɵivyEnabled && injector.get(SelectFactory);
             // Add stores to the state graph and return their defaults
             /** @type {?} */
             var results = factory.addAndReturnDefaults(states);
@@ -4047,7 +3990,7 @@
             { type: StateFactory },
             { type: InternalStateOperations },
             { type: Store },
-            { type: SelectFactory },
+            { type: core.Injector },
             { type: Array, decorators: [{ type: core.Optional }, { type: core.Inject, args: [ROOT_STATE_TOKEN,] }] },
             { type: LifecycleStateManager }
         ]; };
@@ -4147,8 +4090,6 @@
                     Actions,
                     InternalActions,
                     internals.NgxsBootstrapper,
-                    ConfigValidator,
-                    HostEnvironment,
                     LifecycleStateManager,
                     InternalDispatcher,
                     InternalDispatchedActionResults,
@@ -4156,7 +4097,6 @@
                     InternalNgxsExecutionStrategy,
                     Store,
                     StateStream,
-                    SelectFactory,
                     PluginManager
                 ], states, NgxsModule.ngxsTokenProviders(states, options))
             };
@@ -4205,16 +4145,8 @@
         function (states, options) {
             return [
                 {
-                    provide: NG_TEST_MODE,
-                    useValue: internals.isAngularInTestMode
-                },
-                {
-                    provide: NG_DEV_MODE,
-                    useValue: core.isDevMode
-                },
-                {
-                    provide: NGXS_EXECUTION_STRATEGY,
-                    useClass: options.executionStrategy || DispatchOutsideZoneNgxsExecutionStrategy
+                    provide: USER_PROVIDED_NGXS_EXECUTION_STRATEGY,
+                    useValue: options.executionStrategy
                 },
                 {
                     provide: ROOT_STATE_TOKEN,
@@ -4321,10 +4253,14 @@
          */
         function (target, name) {
             var e_1, _a;
-            /** @type {?} */
-            var isStaticMethod = target.hasOwnProperty('prototype');
-            if (isStaticMethod) {
-                throw new Error(CONFIG_MESSAGES[VALIDATION_CODE.ACTION_DECORATOR]());
+            // Caretaker note: we have still left the `typeof` condition in order to avoid
+            // creating a breaking change for projects that still use the View Engine.
+            if (typeof ngDevMode === 'undefined' || ngDevMode) {
+                /** @type {?} */
+                var isStaticMethod = target.hasOwnProperty('prototype');
+                if (isStaticMethod) {
+                    throwActionDecoratorError();
+                }
             }
             /** @type {?} */
             var meta = ensureStoreMetadata(target.constructor);
@@ -4372,20 +4308,14 @@
         // AOT mode because this property is added before runtime. If an application is running in
         // JIT mode then this property can be added by the `@Injectable()` decorator. The `@Injectable()`
         // decorator has to go after the `@State()` decorator, thus we prevent users from unwanted DI errors.
-        ivyEnabledInDevMode$.subscribe((/**
-         * @param {?} _ivyEnabledInDevMode
-         * @return {?}
-         */
-        function (_ivyEnabledInDevMode) {
-            if (_ivyEnabledInDevMode) {
-                /** @type {?} */
-                /** @nocollapse */ var ngInjectableDef = target.ɵprov;
-                if (!ngInjectableDef) {
-                    // Don't warn if Ivy is disabled or `ɵprov` exists on the class
-                    console.warn(CONFIG_MESSAGES[VALIDATION_CODE.UNDECORATED_STATE_IN_IVY](target.name));
-                }
+        if (core.ɵivyEnabled) {
+            /** @type {?} */
+            /** @nocollapse */ var ngInjectableDef = target.ɵprov;
+            if (!ngInjectableDef) {
+                // Don't warn if Ivy is disabled or `ɵprov` exists on the class
+                console.warn(getUndecoratedStateInIvyWarningMessage(target.name));
             }
-        }));
+        }
     }
 
     /**
@@ -4430,7 +4360,11 @@
             var children = optionsWithInheritance.children, defaults = optionsWithInheritance.defaults, name = optionsWithInheritance.name;
             /** @type {?} */
             var stateName = typeof name === 'string' ? name : (name && name.getName()) || null;
-            StoreValidators.checkCorrectStateName(stateName);
+            // Caretaker note: we have still left the `typeof` condition in order to avoid
+            // creating a breaking change for projects that still use the View Engine.
+            if (typeof ngDevMode === 'undefined' || ngDevMode) {
+                StoreValidators.checkThatStateIsNamedCorrectly(stateName);
+            }
             if (inheritedStateClass.hasOwnProperty(META_KEY)) {
                 /** @type {?} */
                 var inheritedMeta = inheritedStateClass[META_KEY] || {};
@@ -4445,7 +4379,11 @@
          * @return {?}
          */
         function (target) {
-            ensureStateClassIsInjectable(target);
+            // Caretaker note: we have still left the `typeof` condition in order to avoid
+            // creating a breaking change for projects that still use the View Engine.
+            if (typeof ngDevMode === 'undefined' || ngDevMode) {
+                ensureStateClassIsInjectable(target);
+            }
             /** @type {?} */
             var stateClass = target;
             /** @type {?} */
@@ -4468,30 +4406,37 @@
     /**
      * @template T
      * @param {?} selector
+     * @param {?} store
      * @return {?}
      */
-    function createSelectObservable(selector) {
-        if (!SelectFactory.store) {
-            throw new Error(CONFIG_MESSAGES[VALIDATION_CODE.SELECT_FACTORY_NOT_CONNECTED]());
-        }
-        return SelectFactory.store.select(selector);
+    function createSelectObservable(selector, store) {
+        // We're doing this stuff to tree-shake the `SelectFactory` when the user
+        // is running Ivy since NGXS will select the state from the provided `store` argument.
+        return core.ɵivyEnabled
+            ? createSelectObservableIvy(selector, store)
+            : createSelectObservableViewEngine(selector);
     }
     /**
+     * @param {?} config
      * @param {?} name
      * @param {?=} rawSelector
      * @param {?=} paths
      * @return {?}
      */
-    function createSelectorFn(name, rawSelector, paths) {
+    function createSelectorFn(config, name, rawSelector, paths) {
         if (paths === void 0) { paths = []; }
-        rawSelector = !rawSelector ? removeDollarAtTheEnd(name) : rawSelector;
-        if (typeof rawSelector === 'string') {
+        rawSelector = rawSelector || removeDollarAtTheEnd(name);
+        if (typeof rawSelector !== 'string') {
+            return rawSelector;
+        }
+        else {
             /** @type {?} */
             var propsArray = paths.length
                 ? __spread([rawSelector], paths) : rawSelector.split('.');
-            return propGetter(propsArray, (/** @type {?} */ (SelectFactory.config)));
+            return core.ɵivyEnabled
+                ? createSelectorFnIvy(propsArray, config)
+                : createSelectorFnViewEngine(propsArray);
         }
-        return rawSelector;
     }
     /**
      * \@example If `foo$` => make it just `foo`
@@ -4504,6 +4449,42 @@
         /** @type {?} */
         var dollarAtTheEnd = name.charCodeAt(lastCharIndex) === DOLLAR_CHAR_CODE;
         return dollarAtTheEnd ? name.slice(0, lastCharIndex) : name;
+    }
+    /**
+     * @template T
+     * @param {?} selector
+     * @param {?} store
+     * @return {?}
+     */
+    function createSelectObservableIvy(selector, store) {
+        return ngDevMode && !store ? throwSelectFactoryNotConnectedError() : (/** @type {?} */ (store)).select(selector);
+    }
+    /**
+     * @template T
+     * @param {?} selector
+     * @return {?}
+     */
+    function createSelectObservableViewEngine(selector) {
+        return SelectFactory.store
+            ? SelectFactory.store.select(selector)
+            : throwSelectFactoryNotConnectedError();
+    }
+    /**
+     * @param {?} propsArray
+     * @param {?} config
+     * @return {?}
+     */
+    function createSelectorFnIvy(propsArray, config) {
+        return ngDevMode && !config
+            ? throwSelectFactoryNotConnectedError()
+            : propGetter(propsArray, (/** @type {?} */ (config)));
+    }
+    /**
+     * @param {?} propsArray
+     * @return {?}
+     */
+    function createSelectorFnViewEngine(propsArray) {
+        return propGetter(propsArray, (/** @type {?} */ (SelectFactory.config)));
     }
 
     /**
@@ -4534,7 +4515,12 @@
             /** @type {?} */
             var selectorId = "__" + name + "__selector";
             /** @type {?} */
-            var selector = createSelectorFn(name, rawSelector, paths);
+            var selector = null;
+            /** @type {?} */
+            var injectorNotifier$ = null;
+            if (core.ɵivyEnabled) {
+                injectorNotifier$ = internals.ensureInjectorNotifierIsCaptured(target);
+            }
             Object.defineProperties(target, (_a = {},
                 _a[selectorId] = {
                     writable: true,
@@ -4548,10 +4534,37 @@
                      * @return {?}
                      */
                     function () {
-                        return this[selectorId] || (this[selectorId] = createSelectObservable(selector));
+                        var _this = this;
+                        if (this[selectorId]) {
+                            return this[selectorId];
+                        }
+                        // The `localInject` will be tree-shaken away in apps that
+                        // still use the View Engine.
+                        if (core.ɵivyEnabled) {
+                            this[selectorId] = (/** @type {?} */ (injectorNotifier$)).pipe(operators.mergeMap((/**
+                             * @return {?}
+                             */
+                            function () {
+                                /** @type {?} */
+                                var store = internals.localInject(_this, Store);
+                                /** @type {?} */
+                                var config = internals.localInject(_this, NgxsConfig);
+                                selector = selector || createSelectorFn(config, name, rawSelector, paths);
+                                return createSelectObservable(selector, store);
+                            })));
+                        }
+                        else {
+                            selector = selector || createSelectorFn(null, name, rawSelector, paths);
+                            this[selectorId] = createSelectObservable(selector, null);
+                        }
+                        return this[selectorId];
                     }
                 },
                 _a));
+            // Keep this `if` guard here so the below stuff will be tree-shaken away in apps that still use the View Engine.
+            if (core.ɵivyEnabled) {
+                internals.ensureLocalInjectorCaptured(target);
+            }
         });
     }
 
@@ -4670,10 +4683,14 @@
          * @return {?}
          */
         function (target, key, descriptor) {
-            /** @type {?} */
-            var isNotMethod = !(descriptor && descriptor.value !== null);
-            if (isNotMethod) {
-                throw new Error(CONFIG_MESSAGES[VALIDATION_CODE.SELECTOR_DECORATOR]());
+            // Caretaker note: we have still left the `typeof` condition in order to avoid
+            // creating a breaking change for projects that still use the View Engine.
+            if (typeof ngDevMode === 'undefined' || ngDevMode) {
+                /** @type {?} */
+                var isNotMethod = !(descriptor && descriptor.value !== null);
+                if (isNotMethod) {
+                    throwSelectorDecoratorError();
+                }
             }
             /** @type {?} */
             var originalFn = descriptor.value;
@@ -4704,45 +4721,6 @@
         });
     }
 
-    /**
-     * @fileoverview added by tsickle
-     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    var NoopNgxsExecutionStrategy = /** @class */ (function () {
-        function NoopNgxsExecutionStrategy() {
-        }
-        /**
-         * @template T
-         * @param {?} func
-         * @return {?}
-         */
-        NoopNgxsExecutionStrategy.prototype.enter = /**
-         * @template T
-         * @param {?} func
-         * @return {?}
-         */
-        function (func) {
-            return func();
-        };
-        /**
-         * @template T
-         * @param {?} func
-         * @return {?}
-         */
-        NoopNgxsExecutionStrategy.prototype.leave = /**
-         * @template T
-         * @param {?} func
-         * @return {?}
-         */
-        function (func) {
-            return func();
-        };
-        NoopNgxsExecutionStrategy.decorators = [
-            { type: core.Injectable }
-        ];
-        return NoopNgxsExecutionStrategy;
-    }());
-
     /**
      * @fileoverview added by tsickle
      * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
@@ -4827,32 +4805,27 @@
     exports.setValue = setValue;
     exports.ɵa = OrderedSubject;
     exports.ɵb = InternalActions;
-    exports.ɵba = SelectFactory;
-    exports.ɵbb = LifecycleStateManager;
-    exports.ɵbc = NgxsFeatureModule;
-    exports.ɵbd = DispatchOutsideZoneNgxsExecutionStrategy;
     exports.ɵc = ROOT_STATE_TOKEN;
     exports.ɵd = FEATURE_STATE_TOKEN;
-    exports.ɵe = NG_TEST_MODE;
-    exports.ɵf = NG_DEV_MODE;
-    exports.ɵg = SELECTOR_META_KEY;
-    exports.ɵh = NgxsConfig;
-    exports.ɵi = mergeDeep;
-    exports.ɵj = NGXS_EXECUTION_STRATEGY;
-    exports.ɵk = NgxsRootModule;
-    exports.ɵl = StateFactory;
-    exports.ɵm = InternalDispatchedActionResults;
-    exports.ɵn = InternalDispatcher;
-    exports.ɵo = StateContextFactory;
-    exports.ɵp = InternalStateOperations;
-    exports.ɵq = PluginManager;
-    exports.ɵr = InternalNgxsExecutionStrategy;
-    exports.ɵs = ConfigValidator;
-    exports.ɵt = HostEnvironment;
-    exports.ɵw = ensureStoreMetadata;
-    exports.ɵx = getStoreMetadata;
-    exports.ɵy = ensureSelectorMetadata;
-    exports.ɵz = getSelectorMetadata;
+    exports.ɵe = SELECTOR_META_KEY;
+    exports.ɵf = NgxsConfig;
+    exports.ɵg = mergeDeep;
+    exports.ɵh = USER_PROVIDED_NGXS_EXECUTION_STRATEGY;
+    exports.ɵi = NGXS_EXECUTION_STRATEGY;
+    exports.ɵj = NgxsRootModule;
+    exports.ɵk = StateFactory;
+    exports.ɵl = InternalDispatchedActionResults;
+    exports.ɵm = InternalDispatcher;
+    exports.ɵn = StateContextFactory;
+    exports.ɵo = InternalStateOperations;
+    exports.ɵp = PluginManager;
+    exports.ɵq = InternalNgxsExecutionStrategy;
+    exports.ɵs = ensureStoreMetadata;
+    exports.ɵt = getStoreMetadata;
+    exports.ɵu = ensureSelectorMetadata;
+    exports.ɵv = getSelectorMetadata;
+    exports.ɵw = LifecycleStateManager;
+    exports.ɵx = NgxsFeatureModule;
 
     Object.defineProperty(exports, '__esModule', { value: true });