@ngxs/store 3.6.2 → 3.7.0

package/bundles/ngxs-store.umd.js

@@ -5,18 +5,18 @@
 }(this, function (exports, core, internals, common, rxjs, operators) { 'use strict';
 
     /*! *****************************************************************************
-    Copyright (c) Microsoft Corporation. All rights reserved.
-    Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-    this file except in compliance with the License. You may obtain a copy of the
-    License at http://www.apache.org/licenses/LICENSE-2.0
+    Copyright (c) Microsoft Corporation.
 
-    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-    KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
-    WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
-    MERCHANTABLITY OR NON-INFRINGEMENT.
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
 
-    See the Apache Version 2.0 License for specific language governing permissions
-    and limitations under the License.
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
     ***************************************************************************** */
     /* global Reflect, Promise */
 
@@ -72,10 +72,11 @@
     }
 
     function __awaiter(thisArg, _arguments, P, generator) {
+        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
         return new (P || (P = Promise))(function (resolve, reject) {
             function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
             function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-            function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
             step((generator = generator.apply(thisArg, _arguments || [])).next());
         });
     }
@@ -108,19 +109,25 @@
         }
     }
 
+    function __createBinding(o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        o[k2] = m[k];
+    }
+
     function __exportStar(m, exports) {
-        for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+        for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) exports[p] = m[p];
     }
 
     function __values(o) {
-        var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
         if (m) return m.call(o);
-        return {
+        if (o && typeof o.length === "number") return {
             next: function () {
                 if (o && i >= o.length) o = void 0;
                 return { value: o && o[i++], done: !o };
             }
         };
+        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
     }
 
     function __read(o, n) {
@@ -199,6 +206,21 @@
 
     function __importDefault(mod) {
         return (mod && mod.__esModule) ? mod : { default: mod };
+    }
+
+    function __classPrivateFieldGet(receiver, privateMap) {
+        if (!privateMap.has(receiver)) {
+            throw new TypeError("attempted to get private field on non-instance");
+        }
+        return privateMap.get(receiver);
+    }
+
+    function __classPrivateFieldSet(receiver, privateMap, value) {
+        if (!privateMap.has(receiver)) {
+            throw new TypeError("attempted to set private field on non-instance");
+        }
+        privateMap.set(receiver, value);
+        return value;
     }
 
     var _a;
@@ -684,7 +706,9 @@
         if (action.constructor && action.constructor.type) {
             return action.constructor.type;
         }
-        return action.type;
+        else {
+            return action.type;
+        }
     }
     /**
      * Matches a action
@@ -796,10 +820,10 @@
          */
         StateOperations.prototype.setState = function (val) { };
         /**
-         * @param {?} actions
+         * @param {?} actionOrActions
          * @return {?}
          */
-        StateOperations.prototype.dispatch = function (actions) { };
+        StateOperations.prototype.dispatch = function (actionOrActions) { };
     }
     /**
      * @record
@@ -1360,13 +1384,16 @@
         return ofActionOperator(allowedTypes, ["ERRORED" /* Errored */]);
     }
     /**
-     * @template T
      * @param {?} allowedTypes
      * @param {?=} statuses
      * @param {?=} mapOperator
      * @return {?}
      */
-    function ofActionOperator(allowedTypes, statuses, mapOperator) {
+    function ofActionOperator(allowedTypes, statuses, 
+    // This actually could've been `OperatorFunction<ActionContext, ActionCompletion | any>`,
+    // since it maps either to `ctx.action` OR to `ActionCompletion`. But `ActionCompleteion | any`
+    // defaults to `any`, thus there is no sense from union type.
+    mapOperator) {
         if (mapOperator === void 0) { mapOperator = mapAction; }
         /** @type {?} */
         var allowedMap = createAllowedActionTypesMap(allowedTypes);
@@ -1996,6 +2023,13 @@
         function (action) {
             var _this = this;
             /** @type {?} */
+            var type = getActionTypeFromInstance(action);
+            if (!type) {
+                /** @type {?} */
+                var error = new Error("This action doesn't have a type property: " + action.constructor.name);
+                return rxjs.throwError(error);
+            }
+            /** @type {?} */
             var prevState = this._stateStream.getValue();
             /** @type {?} */
             var plugins = this._pluginManager.plugins;
@@ -2286,10 +2320,10 @@
                  */
                 function (newState) { return _this._stateStream.next(newState); }),
                 dispatch: (/**
-                 * @param {?} actions
+                 * @param {?} actionOrActions
                  * @return {?}
                  */
-                function (actions) { return _this._dispatcher.dispatch(actions); })
+                function (actionOrActions) { return _this._dispatcher.dispatch(actionOrActions); })
             };
             if (this._config.developmentMode) {
                 return this.ensureStateAndActionsAreImmutable(rootStateOperations);
@@ -2917,13 +2951,13 @@
         function (actions$, action) {
             var e_2, _a, e_3, _b;
             /** @type {?} */
+            var type = (/** @type {?} */ (getActionTypeFromInstance(action)));
+            /** @type {?} */
             var results = [];
             try {
                 for (var _c = __values(this.states), _d = _c.next(); !_d.done; _d = _c.next()) {
                     var metadata = _d.value;
                     /** @type {?} */
-                    var type = (/** @type {?} */ (getActionTypeFromInstance(action)));
-                    /** @type {?} */
                     var actionMetas = metadata.actions[type];
                     if (actionMetas) {
                         try {
@@ -2938,6 +2972,15 @@
                                         result = rxjs.from(result);
                                     }
                                     if (result instanceof rxjs.Observable) {
+                                        // If this observable has been completed w/o emitting
+                                        // any value then we wouldn't want to complete the whole chain
+                                        // of actions. Since if any observable completes then
+                                        // action will be canceled.
+                                        // For instance if any action handler would've had such statement:
+                                        // `handler(ctx) { return EMPTY; }`
+                                        // then the action will be canceled.
+                                        // See https://github.com/ngxs/store/issues/1568
+                                        result = result.pipe(operators.defaultIfEmpty({}));
                                         if (actionMeta.options.cancelUncompleted) {
                                             // todo: ofActionDispatched should be used with action class
                                             result = result.pipe(operators.takeUntil(actions$.pipe(ofActionDispatched((/** @type {?} */ (action))))));
@@ -3551,16 +3594,16 @@
          */
         /**
          * Dispatches event(s).
-         * @param {?} event
+         * @param {?} actionOrActions
          * @return {?}
          */
         Store.prototype.dispatch = /**
          * Dispatches event(s).
-         * @param {?} event
+         * @param {?} actionOrActions
          * @return {?}
          */
-        function (event) {
-            return this._internalStateOperations.getRootStateOperations().dispatch(event);
+        function (actionOrActions) {
+            return this._internalStateOperations.getRootStateOperations().dispatch(actionOrActions);
         };
         /**
          * @param {?} selector
@@ -3835,12 +3878,8 @@
      * @fileoverview added by tsickle
      * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
      */
-    /**
-     * Keep it as a single `const` variable since this `ReplaySubject`
-     * will be private and accessible only within this file.
-     * @type {?}
-     */
-    var _ivyEnabledInDevMode$ = new rxjs.ReplaySubject(1);
+    /** @type {?} */
+    var ivyEnabledInDevMode$ = new rxjs.ReplaySubject(1);
     /**
      * Ivy exposes helper functions to the global `window.ng` object.
      * Those functions are `getComponent, getContext,
@@ -3863,20 +3902,14 @@
             var _viewEngineEnabled = !!ng.probe && !!ng.coreTokens;
             /** @type {?} */
             var _ivyEnabledInDevMode = !_viewEngineEnabled && core.isDevMode();
-            _ivyEnabledInDevMode$.next(_ivyEnabledInDevMode);
+            ivyEnabledInDevMode$.next(_ivyEnabledInDevMode);
         }
         catch (_a) {
-            _ivyEnabledInDevMode$.next(false);
+            ivyEnabledInDevMode$.next(false);
         }
         finally {
-            _ivyEnabledInDevMode$.complete();
+            ivyEnabledInDevMode$.complete();
         }
-    }
-    /**
-     * @return {?}
-     */
-    function ivyEnabledInDevMode() {
-        return _ivyEnabledInDevMode$.asObservable();
     }
 
     /**
@@ -4234,7 +4267,7 @@
         // 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((/**
+        ivyEnabledInDevMode$.subscribe((/**
          * @param {?} _ivyEnabledInDevMode
          * @return {?}
          */
@@ -4385,7 +4418,6 @@
             paths[_i - 1] = arguments[_i];
         }
         return (/**
-         * @template U, K
          * @param {?} target
          * @param {?} key
          * @return {?}