@ngxs/store 3.6.2 → 3.7.0

package/fesm5/ngxs-store.js

@@ -488,7 +488,9 @@ function getActionTypeFromInstance(action) {
     if (action.constructor && action.constructor.type) {
         return action.constructor.type;
     }
-    return action.type;
+    else {
+        return action.type;
+    }
 }
 /**
  * Matches a action
@@ -600,10 +602,10 @@ if (false) {
      */
     StateOperations.prototype.setState = function (val) { };
     /**
-     * @param {?} actions
+     * @param {?} actionOrActions
      * @return {?}
      */
-    StateOperations.prototype.dispatch = function (actions) { };
+    StateOperations.prototype.dispatch = function (actionOrActions) { };
 }
 /**
  * @record
@@ -1164,13 +1166,16 @@ function ofActionErrored() {
     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);
@@ -1800,6 +1805,13 @@ var InternalDispatcher = /** @class */ (function () {
     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 throwError(error);
+        }
+        /** @type {?} */
         var prevState = this._stateStream.getValue();
         /** @type {?} */
         var plugins = this._pluginManager.plugins;
@@ -2090,10 +2102,10 @@ var InternalStateOperations = /** @class */ (function () {
              */
             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);
@@ -2721,13 +2733,13 @@ var StateFactory = /** @class */ (function () {
     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 {
@@ -2742,6 +2754,15 @@ var StateFactory = /** @class */ (function () {
                                     result = from(result);
                                 }
                                 if (result instanceof 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(defaultIfEmpty({}));
                                     if (actionMeta.options.cancelUncompleted) {
                                         // todo: ofActionDispatched should be used with action class
                                         result = result.pipe(takeUntil(actions$.pipe(ofActionDispatched((/** @type {?} */ (action))))));
@@ -3355,16 +3376,16 @@ var Store = /** @class */ (function () {
      */
     /**
      * 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
@@ -3639,12 +3660,8 @@ if (false) {
  * @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 ReplaySubject(1);
+/** @type {?} */
+var ivyEnabledInDevMode$ = new ReplaySubject(1);
 /**
  * Ivy exposes helper functions to the global `window.ng` object.
  * Those functions are `getComponent, getContext,
@@ -3667,20 +3684,14 @@ function setIvyEnabledInDevMode() {
         var _viewEngineEnabled = !!ng.probe && !!ng.coreTokens;
         /** @type {?} */
         var _ivyEnabledInDevMode = !_viewEngineEnabled && 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();
 }
 
 /**
@@ -4038,7 +4049,7 @@ function ensureStateClassIsInjectable(target) {
     // 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 {?}
      */
@@ -4189,7 +4200,6 @@ function Select(rawSelector) {
         paths[_i - 1] = arguments[_i];
     }
     return (/**
-     * @template U, K
      * @param {?} target
      * @param {?} key
      * @return {?}