@ngxs/store 3.7.6-dev.master-94b06c2 → 3.7.6-dev.master-f234866

package/bundles/ngxs-store.umd.js

@@ -1169,29 +1169,47 @@
         };
     }
 
-    var InternalNgxsExecutionStrategy = /** @class */ (function () {
-        function InternalNgxsExecutionStrategy(_executionStrategy) {
-            this._executionStrategy = _executionStrategy;
-        }
-        InternalNgxsExecutionStrategy.prototype.enter = function (func) {
-            return this._executionStrategy.enter(func);
-        };
-        InternalNgxsExecutionStrategy.prototype.leave = function (func) {
-            return this._executionStrategy.leave(func);
+    /**
+     * 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) {
+        var callsQueue = [];
+        var busyPushingNext = false;
+        return function callOperation() {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            if (busyPushingNext) {
+                callsQueue.unshift(args);
+                return;
+            }
+            busyPushingNext = true;
+            operation.apply(void 0, __spreadArray([], __read(args)));
+            while (callsQueue.length > 0) {
+                var nextCallArgs = callsQueue.pop();
+                nextCallArgs && operation.apply(void 0, __spreadArray([], __read(nextCallArgs)));
+            }
+            busyPushingNext = false;
         };
-        return InternalNgxsExecutionStrategy;
-    }());
-    /** @nocollapse */ InternalNgxsExecutionStrategy.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: InternalNgxsExecutionStrategy, deps: [{ token: NGXS_EXECUTION_STRATEGY }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
-    /** @nocollapse */ InternalNgxsExecutionStrategy.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: InternalNgxsExecutionStrategy });
-    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: InternalNgxsExecutionStrategy, decorators: [{
-                type: i0.Injectable
-            }], ctorParameters: function () {
-            return [{ type: undefined, decorators: [{
-                            type: i0.Inject,
-                            args: [NGXS_EXECUTION_STRATEGY]
-                        }] }];
-        } });
-
+    }
     /**
      * Custom Subject that ensures that subscribers are notified of values in the order that they arrived.
      * A standard Subject does not have this guarantee.
@@ -1211,25 +1229,59 @@
         __extends(OrderedSubject, _super);
         function OrderedSubject() {
             var _this = _super.apply(this, __spreadArray([], __read(arguments))) || this;
-            _this._itemQueue = [];
-            _this._busyPushingNext = false;
+            _this.next = orderedQueueOperation(function (value) { return _super.prototype.next.call(_this, value); });
             return _this;
         }
-        OrderedSubject.prototype.next = function (value) {
-            if (this._busyPushingNext) {
-                this._itemQueue.unshift(value);
-                return;
-            }
-            this._busyPushingNext = true;
-            _super.prototype.next.call(this, value);
-            while (this._itemQueue.length > 0) {
-                var nextValue = this._itemQueue.pop();
-                _super.prototype.next.call(this, nextValue);
-            }
-            this._busyPushingNext = false;
-        };
         return OrderedSubject;
     }(rxjs.Subject));
+    /**
+     * 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`.
+     */
+    var OrderedBehaviorSubject = /** @class */ (function (_super) {
+        __extends(OrderedBehaviorSubject, _super);
+        function OrderedBehaviorSubject() {
+            var _this = _super.apply(this, __spreadArray([], __read(arguments))) || this;
+            _this.next = orderedQueueOperation(function (value) { return _super.prototype.next.call(_this, value); });
+            return _this;
+        }
+        return OrderedBehaviorSubject;
+    }(rxjs.BehaviorSubject));
+
+    var InternalNgxsExecutionStrategy = /** @class */ (function () {
+        function InternalNgxsExecutionStrategy(_executionStrategy) {
+            this._executionStrategy = _executionStrategy;
+        }
+        InternalNgxsExecutionStrategy.prototype.enter = function (func) {
+            return this._executionStrategy.enter(func);
+        };
+        InternalNgxsExecutionStrategy.prototype.leave = function (func) {
+            return this._executionStrategy.leave(func);
+        };
+        return InternalNgxsExecutionStrategy;
+    }());
+    /** @nocollapse */ InternalNgxsExecutionStrategy.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: InternalNgxsExecutionStrategy, deps: [{ token: NGXS_EXECUTION_STRATEGY }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ InternalNgxsExecutionStrategy.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: InternalNgxsExecutionStrategy });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: InternalNgxsExecutionStrategy, decorators: [{
+                type: i0.Injectable
+            }], ctorParameters: function () {
+            return [{ type: undefined, decorators: [{
+                            type: i0.Inject,
+                            args: [NGXS_EXECUTION_STRATEGY]
+                        }] }];
+        } });
+
     /**
      * Internal Action stream that is emitted anytime an action is dispatched.
      */
@@ -1436,7 +1488,7 @@
             this.complete();
         };
         return StateStream;
-    }(rxjs.BehaviorSubject));
+    }(OrderedBehaviorSubject));
     /** @nocollapse */ StateStream.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: StateStream, deps: [], target: i0__namespace.ɵɵFactoryTarget.Injectable });
     /** @nocollapse */ StateStream.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: StateStream });
     i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: StateStream, decorators: [{
@@ -2157,7 +2209,7 @@
              * 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(operators.observeOn(rxjs.queueScheduler), leaveNgxs(this._internalExecutionStrategy), operators.shareReplay({ bufferSize: 1, refCount: true }));
+            this._selectableStateStream = this._stateStream.pipe(leaveNgxs(this._internalExecutionStrategy), operators.shareReplay({ bufferSize: 1, refCount: true }));
             this.initStateStream(initialStateValue);
         }
         /**