@ngxs/store 3.7.3-dev.master-5b116c1 → 3.7.3-dev.master-cdd7ae3

package/bundles/ngxs-store.umd.js

@@ -382,13 +382,14 @@
             return func();
         };
         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) {
@@ -472,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;
@@ -640,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
      */
@@ -1856,6 +1921,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 }
         ];
@@ -2261,9 +2338,22 @@
                  */
                 function (actionOrActions) { return _this._dispatcher.dispatch(actionOrActions); })
             };
-            return this._config.developmentMode
-                ? ensureStateAndActionsAreImmutable(rootStateOperations)
-                : 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;
+            }
         };
         /**
          * @param {?} results
@@ -2310,7 +2400,6 @@
          */
         InternalStateOperations.prototype._config;
     }
-    // We make it as a separate function and not the class method to tree-shake it in the future.
     /**
      * @param {?} root
      * @return {?}
@@ -4038,8 +4127,8 @@
         function (states, options) {
             return [
                 {
-                    provide: NGXS_EXECUTION_STRATEGY,
-                    useClass: options.executionStrategy || DispatchOutsideZoneNgxsExecutionStrategy
+                    provide: USER_PROVIDED_NGXS_EXECUTION_STRATEGY,
+                    useValue: options.executionStrategy
                 },
                 {
                     provide: ROOT_STATE_TOKEN,
@@ -4614,45 +4703,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
@@ -4742,22 +4792,22 @@
     exports.ɵe = SELECTOR_META_KEY;
     exports.ɵf = NgxsConfig;
     exports.ɵg = mergeDeep;
-    exports.ɵh = NGXS_EXECUTION_STRATEGY;
-    exports.ɵi = NgxsRootModule;
-    exports.ɵj = StateFactory;
-    exports.ɵk = InternalDispatchedActionResults;
-    exports.ɵl = InternalDispatcher;
-    exports.ɵm = StateContextFactory;
-    exports.ɵn = InternalStateOperations;
-    exports.ɵo = PluginManager;
-    exports.ɵp = InternalNgxsExecutionStrategy;
-    exports.ɵr = ensureStoreMetadata;
-    exports.ɵs = getStoreMetadata;
-    exports.ɵt = ensureSelectorMetadata;
-    exports.ɵu = getSelectorMetadata;
-    exports.ɵv = LifecycleStateManager;
-    exports.ɵw = NgxsFeatureModule;
-    exports.ɵx = DispatchOutsideZoneNgxsExecutionStrategy;
+    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 });