@ngxs/store 3.7.6-dev.master-f2e2560 → 3.7.6-dev.master-daef739

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: [{
@@ -2032,41 +2084,8 @@
                         }] }];
         } });
 
-    var SELECTOR_OPTIONS_META_KEY = 'NGXS_SELECTOR_OPTIONS_META';
-    var selectorOptionsMetaAccessor = {
-        getOptions: function (target) {
-            return (target && target[SELECTOR_OPTIONS_META_KEY]) || {};
-        },
-        defineOptions: function (target, options) {
-            if (!target)
-                return;
-            target[SELECTOR_OPTIONS_META_KEY] = options;
-        }
-    };
-    /**
-     * Function for creating a selector
-     * @param selectors The selectors to use to create the arguments of this function
-     * @param originalFn The original function being made into a selector
-     * @param creationMetadata
-     */
-    function createSelector(selectors, originalFn, creationMetadata) {
-        var containerClass = creationMetadata && creationMetadata.containerClass;
-        var wrappedFn = function wrappedSelectorFn() {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            var returnValue = originalFn.apply(containerClass, args);
-            if (returnValue instanceof Function) {
-                var innerMemoizedFn = i5.memoize.apply(null, [returnValue]);
-                return innerMemoizedFn;
-            }
-            return returnValue;
-        };
-        var memoizedFn = i5.memoize(wrappedFn);
-        Object.setPrototypeOf(memoizedFn, originalFn);
-        var selectorMetaData = setupSelectorMetadata(originalFn, creationMetadata);
-        var makeRootSelector = function (context) {
+    function createRootSelectorFactory(selectorMetaData, selectors, memoizedSelectorFn) {
+        return function (context) {
             var _a = getRuntimeSelectorInfo(context, selectorMetaData, selectors), argumentSelectorFunctions = _a.argumentSelectorFunctions, selectorOptions = _a.selectorOptions;
             return function selectFromRoot(rootState) {
                 // Determine arguments from the app state using the selectors
@@ -2075,7 +2094,7 @@
                 // state that doesn't exist, it will throw a TypeError.
                 // since this is quite usual behaviour, we simply return undefined if so.
                 try {
-                    return memoizedFn.apply(void 0, __spreadArray([], __read(results)));
+                    return memoizedSelectorFn.apply(void 0, __spreadArray([], __read(results)));
                 }
                 catch (ex) {
                     if (ex instanceof TypeError && selectorOptions.suppressErrors) {
@@ -2085,22 +2104,24 @@
                 }
             };
         };
-        selectorMetaData.makeRootSelector = makeRootSelector;
-        return memoizedFn;
     }
-    function setupSelectorMetadata(originalFn, creationMetadata) {
-        var selectorMetaData = ensureSelectorMetadata$1(originalFn);
-        selectorMetaData.originalFn = originalFn;
-        var getExplicitSelectorOptions = function () { return ({}); };
-        if (creationMetadata) {
-            selectorMetaData.containerClass = creationMetadata.containerClass;
-            selectorMetaData.selectorName = creationMetadata.selectorName;
-            getExplicitSelectorOptions =
-                creationMetadata.getSelectorOptions || getExplicitSelectorOptions;
-        }
-        var selectorMetaDataClone = Object.assign({}, selectorMetaData);
-        selectorMetaData.getSelectorOptions = function () { return getLocalSelectorOptions(selectorMetaDataClone, getExplicitSelectorOptions()); };
-        return selectorMetaData;
+    function createMemoizedSelectorFn(originalFn, creationMetadata) {
+        var containerClass = creationMetadata && creationMetadata.containerClass;
+        var wrappedFn = function wrappedSelectorFn() {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            var returnValue = originalFn.apply(containerClass, args);
+            if (returnValue instanceof Function) {
+                var innerMemoizedFn = i5.memoize.apply(null, [returnValue]);
+                return innerMemoizedFn;
+            }
+            return returnValue;
+        };
+        var memoizedFn = i5.memoize(wrappedFn);
+        Object.setPrototypeOf(memoizedFn, originalFn);
+        return memoizedFn;
     }
     function getRuntimeSelectorInfo(context, selectorMetaData, selectors) {
         if (selectors === void 0) { selectors = []; }
@@ -2113,12 +2134,9 @@
         });
         return {
             selectorOptions: selectorOptions,
-            argumentSelectorFunctions: argumentSelectorFunctions
+            argumentSelectorFunctions: argumentSelectorFunctions,
         };
     }
-    function getLocalSelectorOptions(selectorMetaData, explicitOptions) {
-        return Object.assign(Object.assign(Object.assign(Object.assign({}, (selectorOptionsMetaAccessor.getOptions(selectorMetaData.containerClass) || {})), (selectorOptionsMetaAccessor.getOptions(selectorMetaData.originalFn) || {})), (selectorMetaData.getSelectorOptions() || {})), explicitOptions);
-    }
     function getSelectorsToApply(selectors, selectorOptions, containerClass) {
         if (selectors === void 0) { selectors = []; }
         var selectorsToApply = [];
@@ -2157,7 +2175,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);
         }
         /**
@@ -2662,6 +2680,35 @@
         };
     }
 
+    var SELECTOR_OPTIONS_META_KEY = 'NGXS_SELECTOR_OPTIONS_META';
+    var selectorOptionsMetaAccessor = {
+        getOptions: function (target) {
+            return (target && target[SELECTOR_OPTIONS_META_KEY]) || {};
+        },
+        defineOptions: function (target, options) {
+            if (!target)
+                return;
+            target[SELECTOR_OPTIONS_META_KEY] = options;
+        },
+    };
+    function setupSelectorMetadata(originalFn, creationMetadata) {
+        var selectorMetaData = ensureSelectorMetadata$1(originalFn);
+        selectorMetaData.originalFn = originalFn;
+        var getExplicitSelectorOptions = function () { return ({}); };
+        if (creationMetadata) {
+            selectorMetaData.containerClass = creationMetadata.containerClass;
+            selectorMetaData.selectorName = creationMetadata.selectorName || null;
+            getExplicitSelectorOptions =
+                creationMetadata.getSelectorOptions || getExplicitSelectorOptions;
+        }
+        var selectorMetaDataClone = Object.assign({}, selectorMetaData);
+        selectorMetaData.getSelectorOptions = function () { return getLocalSelectorOptions(selectorMetaDataClone, getExplicitSelectorOptions()); };
+        return selectorMetaData;
+    }
+    function getLocalSelectorOptions(selectorMetaData, explicitOptions) {
+        return Object.assign(Object.assign(Object.assign(Object.assign({}, (selectorOptionsMetaAccessor.getOptions(selectorMetaData.containerClass) || {})), (selectorOptionsMetaAccessor.getOptions(selectorMetaData.originalFn) || {})), (selectorMetaData.getSelectorOptions() || {})), explicitOptions);
+    }
+
     /**
      * Decorator for setting selector options at a method or class level.
      */
@@ -2695,9 +2742,13 @@
         return getSelectorMetadata$1(target);
     }
 
-    /**
-     * Decorator for memoizing a state selector.
-     */
+    function createSelector(selectors, projector, creationMetadata) {
+        var memoizedFn = createMemoizedSelectorFn(projector, creationMetadata);
+        var selectorMetaData = setupSelectorMetadata(projector, creationMetadata);
+        selectorMetaData.makeRootSelector = createRootSelectorFactory(selectorMetaData, selectors, memoizedFn);
+        return memoizedFn;
+    }
+
     function Selector(selectors) {
         return function (target, key, descriptor) {
             descriptor || (descriptor = Object.getOwnPropertyDescriptor(target, key));