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

package/esm2015/src/actions-stream.js

@@ -1,45 +1,11 @@
 import { Injectable } from '@angular/core';
-import { Subject, Observable } from 'rxjs';
+import { Observable } from 'rxjs';
 import { share } from 'rxjs/operators';
 import { leaveNgxs } from './operators/leave-ngxs';
 import { InternalNgxsExecutionStrategy } from './execution/internal-ngxs-execution-strategy';
+import { OrderedSubject } from './internal/custom-rxjs-subjects';
 import * as i0 from "@angular/core";
 import * as i1 from "./execution/internal-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.
- * For example, given the following code:
- * ```typescript
- *   const subject = new Subject<string>();
-     subject.subscribe(value => {
-       if (value === 'start') subject.next('end');
-     });
-     subject.subscribe(value => { });
-     subject.next('start');
- * ```
- * When `subject` is a standard `Subject<T>` the second subscriber would recieve `end` and then `start`.
- * When `subject` is a `OrderedSubject<T>` the second subscriber would recieve `start` and then `end`.
- */
-export class OrderedSubject extends Subject {
-    constructor() {
-        super(...arguments);
-        this._itemQueue = [];
-        this._busyPushingNext = false;
-    }
-    next(value) {
-        if (this._busyPushingNext) {
-            this._itemQueue.unshift(value);
-            return;
-        }
-        this._busyPushingNext = true;
-        super.next(value);
-        while (this._itemQueue.length > 0) {
-            const nextValue = this._itemQueue.pop();
-            super.next(nextValue);
-        }
-        this._busyPushingNext = false;
-    }
-}
 /**
  * Internal Action stream that is emitted anytime an action is dispatched.
  */
@@ -81,4 +47,4 @@ export class Actions extends Observable {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: Actions, decorators: [{
             type: Injectable
         }], ctorParameters: function () { return [{ type: InternalActions }, { type: i1.InternalNgxsExecutionStrategy }]; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWN0aW9ucy1zdHJlYW0uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9zdG9yZS9zcmMvYWN0aW9ucy1zdHJlYW0udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBYSxNQUFNLGVBQWUsQ0FBQztBQUN0RCxPQUFPLEVBQUUsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLE1BQU0sQ0FBQztBQUMzQyxPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFFdkMsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQ25ELE9BQU8sRUFBRSw2QkFBNkIsRUFBRSxNQUFNLDhDQUE4QyxDQUFDOzs7QUFrQjdGOzs7Ozs7Ozs7Ozs7OztHQWNHO0FBQ0gsTUFBTSxPQUFPLGNBQWtCLFNBQVEsT0FBVTtJQUFqRDs7UUFDVSxlQUFVLEdBQVEsRUFBRSxDQUFDO1FBQ3JCLHFCQUFnQixHQUFHLEtBQUssQ0FBQztJQWVuQyxDQUFDO0lBYkMsSUFBSSxDQUFDLEtBQVM7UUFDWixJQUFJLElBQUksQ0FBQyxnQkFBZ0IsRUFBRTtZQUN6QixJQUFJLENBQUMsVUFBVSxDQUFDLE9BQU8sQ0FBQyxLQUFNLENBQUMsQ0FBQztZQUNoQyxPQUFPO1NBQ1I7UUFDRCxJQUFJLENBQUMsZ0JBQWdCLEdBQUcsSUFBSSxDQUFDO1FBQzdCLEtBQUssQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDbEIsT0FBTyxJQUFJLENBQUMsVUFBVSxDQUFDLE1BQU0sR0FBRyxDQUFDLEVBQUU7WUFDakMsTUFBTSxTQUFTLEdBQUcsSUFBSSxDQUFDLFVBQVUsQ0FBQyxHQUFHLEVBQUUsQ0FBQztZQUN4QyxLQUFLLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDO1NBQ3ZCO1FBQ0QsSUFBSSxDQUFDLGdCQUFnQixHQUFHLEtBQUssQ0FBQztJQUNoQyxDQUFDO0NBQ0Y7QUFFRDs7R0FFRztBQUVILE1BQU0sT0FBTyxlQUFnQixTQUFRLGNBQTZCO0lBQ2hFLFdBQVc7UUFDVCxJQUFJLENBQUMsUUFBUSxFQUFFLENBQUM7SUFDbEIsQ0FBQzs7Z0lBSFUsZUFBZTtvSUFBZixlQUFlOzRGQUFmLGVBQWU7a0JBRDNCLFVBQVU7O0FBT1g7Ozs7R0FJRztBQUVILE1BQU0sT0FBTyxPQUFRLFNBQVEsVUFBeUI7SUFDcEQsWUFDRSxnQkFBaUMsRUFDakMseUJBQXdEO1FBRXhELE1BQU0sc0JBQXNCLEdBQUcsZ0JBQWdCLENBQUMsSUFBSSxDQUNsRCxTQUFTLENBQUMseUJBQXlCLENBQUM7UUFDcEMsbUVBQW1FO1FBQ25FLGtFQUFrRTtRQUNsRSxrRUFBa0U7UUFDbEUseUZBQXlGO1FBQ3pGLEtBQUssRUFBRSxDQUNSLENBQUM7UUFFRixLQUFLLENBQUMsUUFBUSxDQUFDLEVBQUU7WUFDZixNQUFNLGlCQUFpQixHQUFHLHNCQUFzQixDQUFDLFNBQVMsQ0FBQztnQkFDekQsSUFBSSxFQUFFLEdBQUcsQ0FBQyxFQUFFLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUM7Z0JBQy9CLEtBQUssRUFBRSxLQUFLLENBQUMsRUFBRSxDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDO2dCQUNyQyxRQUFRLEVBQUUsR0FBRyxFQUFFLENBQUMsUUFBUSxDQUFDLFFBQVEsRUFBRTthQUNwQyxDQUFDLENBQUM7WUFFSCxRQUFRLENBQUMsR0FBRyxDQUFDLGlCQUFpQixDQUFDLENBQUM7UUFDbEMsQ0FBQyxDQUFDLENBQUM7SUFDTCxDQUFDOzt3SEF2QlUsT0FBTyxrQkFFRSxlQUFlOzRIQUZ4QixPQUFPOzRGQUFQLE9BQU87a0JBRG5CLFVBQVU7MERBR1csZUFBZSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUsIE9uRGVzdHJveSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgU3ViamVjdCwgT2JzZXJ2YWJsZSB9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHsgc2hhcmUgfSBmcm9tICdyeGpzL29wZXJhdG9ycyc7XG5cbmltcG9ydCB7IGxlYXZlTmd4cyB9IGZyb20gJy4vb3BlcmF0b3JzL2xlYXZlLW5neHMnO1xuaW1wb3J0IHsgSW50ZXJuYWxOZ3hzRXhlY3V0aW9uU3RyYXRlZ3kgfSBmcm9tICcuL2V4ZWN1dGlvbi9pbnRlcm5hbC1uZ3hzLWV4ZWN1dGlvbi1zdHJhdGVneSc7XG5cbi8qKlxuICogU3RhdHVzIG9mIGEgZGlzcGF0Y2hlZCBhY3Rpb25cbiAqL1xuZXhwb3J0IGNvbnN0IGVudW0gQWN0aW9uU3RhdHVzIHtcbiAgRGlzcGF0Y2hlZCA9ICdESVNQQVRDSEVEJyxcbiAgU3VjY2Vzc2Z1bCA9ICdTVUNDRVNTRlVMJyxcbiAgQ2FuY2VsZWQgPSAnQ0FOQ0VMRUQnLFxuICBFcnJvcmVkID0gJ0VSUk9SRUQnXG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgQWN0aW9uQ29udGV4dDxUID0gYW55PiB7XG4gIHN0YXR1czogQWN0aW9uU3RhdHVzO1xuICBhY3Rpb246IFQ7XG4gIGVycm9yPzogRXJyb3I7XG59XG5cbi8qKlxuICogQ3VzdG9tIFN1YmplY3QgdGhhdCBlbnN1cmVzIHRoYXQgc3Vic2NyaWJlcnMgYXJlIG5vdGlmaWVkIG9mIHZhbHVlcyBpbiB0aGUgb3JkZXIgdGhhdCB0aGV5IGFycml2ZWQuXG4gKiBBIHN0YW5kYXJkIFN1YmplY3QgZG9lcyBub3QgaGF2ZSB0aGlzIGd1YXJhbnRlZS5cbiAqIEZvciBleGFtcGxlLCBnaXZlbiB0aGUgZm9sbG93aW5nIGNvZGU6XG4gKiBgYGB0eXBlc2NyaXB0XG4gKiAgIGNvbnN0IHN1YmplY3QgPSBuZXcgU3ViamVjdDxzdHJpbmc+KCk7XG4gICAgIHN1YmplY3Quc3Vic2NyaWJlKHZhbHVlID0+IHtcbiAgICAgICBpZiAodmFsdWUgPT09ICdzdGFydCcpIHN1YmplY3QubmV4dCgnZW5kJyk7XG4gICAgIH0pO1xuICAgICBzdWJqZWN0LnN1YnNjcmliZSh2YWx1ZSA9PiB7IH0pO1xuICAgICBzdWJqZWN0Lm5leHQoJ3N0YXJ0Jyk7XG4gKiBgYGBcbiAqIFdoZW4gYHN1YmplY3RgIGlzIGEgc3RhbmRhcmQgYFN1YmplY3Q8VD5gIHRoZSBzZWNvbmQgc3Vic2NyaWJlciB3b3VsZCByZWNpZXZlIGBlbmRgIGFuZCB0aGVuIGBzdGFydGAuXG4gKiBXaGVuIGBzdWJqZWN0YCBpcyBhIGBPcmRlcmVkU3ViamVjdDxUPmAgdGhlIHNlY29uZCBzdWJzY3JpYmVyIHdvdWxkIHJlY2lldmUgYHN0YXJ0YCBhbmQgdGhlbiBgZW5kYC5cbiAqL1xuZXhwb3J0IGNsYXNzIE9yZGVyZWRTdWJqZWN0PFQ+IGV4dGVuZHMgU3ViamVjdDxUPiB7XG4gIHByaXZhdGUgX2l0ZW1RdWV1ZTogVFtdID0gW107XG4gIHByaXZhdGUgX2J1c3lQdXNoaW5nTmV4dCA9IGZhbHNlO1xuXG4gIG5leHQodmFsdWU/OiBUKTogdm9pZCB7XG4gICAgaWYgKHRoaXMuX2J1c3lQdXNoaW5nTmV4dCkge1xuICAgICAgdGhpcy5faXRlbVF1ZXVlLnVuc2hpZnQodmFsdWUhKTtcbiAgICAgIHJldHVybjtcbiAgICB9XG4gICAgdGhpcy5fYnVzeVB1c2hpbmdOZXh0ID0gdHJ1ZTtcbiAgICBzdXBlci5uZXh0KHZhbHVlKTtcbiAgICB3aGlsZSAodGhpcy5faXRlbVF1ZXVlLmxlbmd0aCA+IDApIHtcbiAgICAgIGNvbnN0IG5leHRWYWx1ZSA9IHRoaXMuX2l0ZW1RdWV1ZS5wb3AoKTtcbiAgICAgIHN1cGVyLm5leHQobmV4dFZhbHVlKTtcbiAgICB9XG4gICAgdGhpcy5fYnVzeVB1c2hpbmdOZXh0ID0gZmFsc2U7XG4gIH1cbn1cblxuLyoqXG4gKiBJbnRlcm5hbCBBY3Rpb24gc3RyZWFtIHRoYXQgaXMgZW1pdHRlZCBhbnl0aW1lIGFuIGFjdGlvbiBpcyBkaXNwYXRjaGVkLlxuICovXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgSW50ZXJuYWxBY3Rpb25zIGV4dGVuZHMgT3JkZXJlZFN1YmplY3Q8QWN0aW9uQ29udGV4dD4gaW1wbGVtZW50cyBPbkRlc3Ryb3kge1xuICBuZ09uRGVzdHJveSgpOiB2b2lkIHtcbiAgICB0aGlzLmNvbXBsZXRlKCk7XG4gIH1cbn1cblxuLyoqXG4gKiBBY3Rpb24gc3RyZWFtIHRoYXQgaXMgZW1pdHRlZCBhbnl0aW1lIGFuIGFjdGlvbiBpcyBkaXNwYXRjaGVkLlxuICpcbiAqIFlvdSBjYW4gbGlzdGVuIHRvIHRoaXMgaW4gc2VydmljZXMgdG8gcmVhY3Qgd2l0aG91dCBzdG9yZXMuXG4gKi9cbkBJbmplY3RhYmxlKClcbmV4cG9ydCBjbGFzcyBBY3Rpb25zIGV4dGVuZHMgT2JzZXJ2YWJsZTxBY3Rpb25Db250ZXh0PiB7XG4gIGNvbnN0cnVjdG9yKFxuICAgIGludGVybmFsQWN0aW9ucyQ6IEludGVybmFsQWN0aW9ucyxcbiAgICBpbnRlcm5hbEV4ZWN1dGlvblN0cmF0ZWd5OiBJbnRlcm5hbE5neHNFeGVjdXRpb25TdHJhdGVneVxuICApIHtcbiAgICBjb25zdCBzaGFyZWRJbnRlcm5hbEFjdGlvbnMkID0gaW50ZXJuYWxBY3Rpb25zJC5waXBlKFxuICAgICAgbGVhdmVOZ3hzKGludGVybmFsRXhlY3V0aW9uU3RyYXRlZ3kpLFxuICAgICAgLy8gVGhlIGBJbnRlcm5hbEFjdGlvbnNgIHN1YmplY3QgZW1pdHMgb3V0c2lkZSBvZiB0aGUgQW5ndWxhciB6b25lLlxuICAgICAgLy8gV2UgaGF2ZSB0byByZS1lbnRlciB0aGUgQW5ndWxhciB6b25lIGZvciBhbnkgaW5jb21pbmcgY29uc3VtZXIuXG4gICAgICAvLyBUaGUgYHNoYXJlKClgIG9wZXJhdG9yIHJlZHVjZXMgdGhlIG51bWJlciBvZiBjaGFuZ2UgZGV0ZWN0aW9ucy5cbiAgICAgIC8vIFRoaXMgd291bGQgY2FsbCBsZWF2ZSBvbmx5IG9uY2UgZm9yIGFueSBzdHJlYW0gZW1pc3Npb24gYWNyb3NzIGFsbCBhY3RpdmUgc3Vic2NyaWJlcnMuXG4gICAgICBzaGFyZSgpXG4gICAgKTtcblxuICAgIHN1cGVyKG9ic2VydmVyID0+IHtcbiAgICAgIGNvbnN0IGNoaWxkU3Vic2NyaXB0aW9uID0gc2hhcmVkSW50ZXJuYWxBY3Rpb25zJC5zdWJzY3JpYmUoe1xuICAgICAgICBuZXh0OiBjdHggPT4gb2JzZXJ2ZXIubmV4dChjdHgpLFxuICAgICAgICBlcnJvcjogZXJyb3IgPT4gb2JzZXJ2ZXIuZXJyb3IoZXJyb3IpLFxuICAgICAgICBjb21wbGV0ZTogKCkgPT4gb2JzZXJ2ZXIuY29tcGxldGUoKVxuICAgICAgfSk7XG5cbiAgICAgIG9ic2VydmVyLmFkZChjaGlsZFN1YnNjcmlwdGlvbik7XG4gICAgfSk7XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/src/internal/custom-rxjs-subjects.js

@@ -0,0 +1,81 @@
+import { Subject, BehaviorSubject } from 'rxjs';
+/**
+ * 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) {
+    const callsQueue = [];
+    let busyPushingNext = false;
+    return function callOperation(...args) {
+        if (busyPushingNext) {
+            callsQueue.unshift(args);
+            return;
+        }
+        busyPushingNext = true;
+        operation(...args);
+        while (callsQueue.length > 0) {
+            const nextCallArgs = callsQueue.pop();
+            nextCallArgs && operation(...nextCallArgs);
+        }
+        busyPushingNext = false;
+    };
+}
+/**
+ * Custom Subject that ensures that subscribers are notified of values in the order that they arrived.
+ * A standard Subject does not have this guarantee.
+ * For example, given the following code:
+ * ```typescript
+ *   const subject = new Subject<string>();
+     subject.subscribe(value => {
+       if (value === 'start') subject.next('end');
+     });
+     subject.subscribe(value => { });
+     subject.next('start');
+ * ```
+ * When `subject` is a standard `Subject<T>` the second subscriber would recieve `end` and then `start`.
+ * When `subject` is a `OrderedSubject<T>` the second subscriber would recieve `start` and then `end`.
+ */
+export class OrderedSubject extends Subject {
+    constructor() {
+        super(...arguments);
+        this.next = orderedQueueOperation((value) => super.next(value));
+    }
+}
+/**
+ * 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`.
+ */
+export class OrderedBehaviorSubject extends BehaviorSubject {
+    constructor() {
+        super(...arguments);
+        this.next = orderedQueueOperation((value) => super.next(value));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/src/internal/state-stream.js

@@ -1,11 +1,11 @@
 import { Injectable } from '@angular/core';
-import { BehaviorSubject } from 'rxjs';
+import { OrderedBehaviorSubject } from './custom-rxjs-subjects';
 import * as i0 from "@angular/core";
 /**
  * BehaviorSubject of the entire state.
  * @ignore
  */
-export class StateStream extends BehaviorSubject {
+export class StateStream extends OrderedBehaviorSubject {
     constructor() {
         super({});
     }
@@ -21,4 +21,4 @@ export class StateStream extends BehaviorSubject {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: StateStream, decorators: [{
             type: Injectable
         }], ctorParameters: function () { return []; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhdGUtc3RyZWFtLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvc3RvcmUvc3JjL2ludGVybmFsL3N0YXRlLXN0cmVhbS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFhLE1BQU0sZUFBZSxDQUFDO0FBQ3RELE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxNQUFNLENBQUM7O0FBSXZDOzs7R0FHRztBQUVILE1BQU0sT0FBTyxXQUFZLFNBQVEsZUFBNEI7SUFDM0Q7UUFDRSxLQUFLLENBQUMsRUFBRSxDQUFDLENBQUM7SUFDWixDQUFDO0lBRUQsV0FBVztRQUNULDZIQUE2SDtRQUM3SCxnSUFBZ0k7UUFDaEksOEhBQThIO1FBQzlILElBQUksQ0FBQyxRQUFRLEVBQUUsQ0FBQztJQUNsQixDQUFDOzs0SEFWVSxXQUFXO2dJQUFYLFdBQVc7NEZBQVgsV0FBVztrQkFEdkIsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUsIE9uRGVzdHJveSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQmVoYXZpb3JTdWJqZWN0IH0gZnJvbSAncnhqcyc7XG5cbmltcG9ydCB7IFBsYWluT2JqZWN0IH0gZnJvbSAnQG5neHMvc3RvcmUvaW50ZXJuYWxzJztcblxuLyoqXG4gKiBCZWhhdmlvclN1YmplY3Qgb2YgdGhlIGVudGlyZSBzdGF0ZS5cbiAqIEBpZ25vcmVcbiAqL1xuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIFN0YXRlU3RyZWFtIGV4dGVuZHMgQmVoYXZpb3JTdWJqZWN0PFBsYWluT2JqZWN0PiBpbXBsZW1lbnRzIE9uRGVzdHJveSB7XG4gIGNvbnN0cnVjdG9yKCkge1xuICAgIHN1cGVyKHt9KTtcbiAgfVxuXG4gIG5nT25EZXN0cm95KCk6IHZvaWQge1xuICAgIC8vIFRoZSBgU3RhdGVTdHJlYW1gIHNob3VsZCBuZXZlciBlbWl0IHZhbHVlcyBvbmNlIHRoZSByb290IHZpZXcgaXMgcmVtb3ZlZCwgZS5nLiB3aGVuIHRoZSBgTmdNb2R1bGVSZWYuZGVzdHJveSgpYCBpcyBjYWxsZWQuXG4gICAgLy8gVGhpcyB3aWxsIGVsaW1pbmF0ZSBtZW1vcnkgbGVha3MgaW4gc2VydmVyLXNpZGUgcmVuZGVyZWQgYXBwcyB3aGVyZSB0aGUgYFN0YXRlU3RyZWFtYCBpcyBjcmVhdGVkIHBlciBlYWNoIEhUVFAgcmVxdWVzdCwgdXNlcnNcbiAgICAvLyBtaWdodCBmb3JnZXQgdG8gdW5zdWJzY3JpYmUgZnJvbSBgc3RvcmUuc2VsZWN0YCBvciBgc3RvcmUuc3Vic2NyaWJlYCwgdGh1cyB0aGlzIHdpbGwgbGVhZCB0byBodWdlIG1lbW9yeSBsZWFrcyBpbiBTU1IgYXBwcy5cbiAgICB0aGlzLmNvbXBsZXRlKCk7XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhdGUtc3RyZWFtLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvc3RvcmUvc3JjL2ludGVybmFsL3N0YXRlLXN0cmVhbS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFhLE1BQU0sZUFBZSxDQUFDO0FBSXRELE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLHdCQUF3QixDQUFDOztBQUVoRTs7O0dBR0c7QUFFSCxNQUFNLE9BQU8sV0FBWSxTQUFRLHNCQUFtQztJQUNsRTtRQUNFLEtBQUssQ0FBQyxFQUFFLENBQUMsQ0FBQztJQUNaLENBQUM7SUFFRCxXQUFXO1FBQ1QsNkhBQTZIO1FBQzdILGdJQUFnSTtRQUNoSSw4SEFBOEg7UUFDOUgsSUFBSSxDQUFDLFFBQVEsRUFBRSxDQUFDO0lBQ2xCLENBQUM7OzRIQVZVLFdBQVc7Z0lBQVgsV0FBVzs0RkFBWCxXQUFXO2tCQUR2QixVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSwgT25EZXN0cm95IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IFBsYWluT2JqZWN0IH0gZnJvbSAnQG5neHMvc3RvcmUvaW50ZXJuYWxzJztcblxuaW1wb3J0IHsgT3JkZXJlZEJlaGF2aW9yU3ViamVjdCB9IGZyb20gJy4vY3VzdG9tLXJ4anMtc3ViamVjdHMnO1xuXG4vKipcbiAqIEJlaGF2aW9yU3ViamVjdCBvZiB0aGUgZW50aXJlIHN0YXRlLlxuICogQGlnbm9yZVxuICovXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgU3RhdGVTdHJlYW0gZXh0ZW5kcyBPcmRlcmVkQmVoYXZpb3JTdWJqZWN0PFBsYWluT2JqZWN0PiBpbXBsZW1lbnRzIE9uRGVzdHJveSB7XG4gIGNvbnN0cnVjdG9yKCkge1xuICAgIHN1cGVyKHt9KTtcbiAgfVxuXG4gIG5nT25EZXN0cm95KCk6IHZvaWQge1xuICAgIC8vIFRoZSBgU3RhdGVTdHJlYW1gIHNob3VsZCBuZXZlciBlbWl0IHZhbHVlcyBvbmNlIHRoZSByb290IHZpZXcgaXMgcmVtb3ZlZCwgZS5nLiB3aGVuIHRoZSBgTmdNb2R1bGVSZWYuZGVzdHJveSgpYCBpcyBjYWxsZWQuXG4gICAgLy8gVGhpcyB3aWxsIGVsaW1pbmF0ZSBtZW1vcnkgbGVha3MgaW4gc2VydmVyLXNpZGUgcmVuZGVyZWQgYXBwcyB3aGVyZSB0aGUgYFN0YXRlU3RyZWFtYCBpcyBjcmVhdGVkIHBlciBlYWNoIEhUVFAgcmVxdWVzdCwgdXNlcnNcbiAgICAvLyBtaWdodCBmb3JnZXQgdG8gdW5zdWJzY3JpYmUgZnJvbSBgc3RvcmUuc2VsZWN0YCBvciBgc3RvcmUuc3Vic2NyaWJlYCwgdGh1cyB0aGlzIHdpbGwgbGVhZCB0byBodWdlIG1lbW9yeSBsZWFrcyBpbiBTU1IgYXBwcy5cbiAgICB0aGlzLmNvbXBsZXRlKCk7XG4gIH1cbn1cbiJdfQ==

package/esm2015/src/store.js

@@ -1,7 +1,7 @@
 // tslint:disable:unified-signatures
 import { Inject, Injectable, Optional } from '@angular/core';
-import { of, throwError, queueScheduler } from 'rxjs';
-import { catchError, distinctUntilChanged, map, shareReplay, take, observeOn } from 'rxjs/operators';
+import { of, throwError } from 'rxjs';
+import { catchError, distinctUntilChanged, map, shareReplay, take } from 'rxjs/operators';
 import { INITIAL_STATE_TOKEN } from '@ngxs/store/internals';
 import { InternalNgxsExecutionStrategy } from './execution/internal-ngxs-execution-strategy';
 import { InternalStateOperations } from './internal/state-operations';
@@ -28,7 +28,7 @@ export class Store {
          * 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(observeOn(queueScheduler), leaveNgxs(this._internalExecutionStrategy), shareReplay({ bufferSize: 1, refCount: true }));
+        this._selectableStateStream = this._stateStream.pipe(leaveNgxs(this._internalExecutionStrategy), shareReplay({ bufferSize: 1, refCount: true }));
         this.initStateStream(initialStateValue);
     }
     /**
@@ -103,4 +103,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImpo
                     type: Inject,
                     args: [INITIAL_STATE_TOKEN]
                 }] }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"store.js","sourceRoot":"","sources":["../../../../packages/store/src/store.ts"],"names":[],"mappings":"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","sourcesContent":["// tslint:disable:unified-signatures\nimport { Inject, Injectable, Optional, Type } from '@angular/core';\nimport { Observable, of, Subscription, throwError, queueScheduler } from 'rxjs';\nimport {\n  catchError,\n  distinctUntilChanged,\n  map,\n  shareReplay,\n  take,\n  observeOn\n} from 'rxjs/operators';\nimport { INITIAL_STATE_TOKEN, PlainObject } from '@ngxs/store/internals';\n\nimport { InternalNgxsExecutionStrategy } from './execution/internal-ngxs-execution-strategy';\nimport { InternalStateOperations } from './internal/state-operations';\nimport { getRootSelectorFactory } from './utils/selector-utils';\nimport { StateStream } from './internal/state-stream';\nimport { leaveNgxs } from './operators/leave-ngxs';\nimport { NgxsConfig } from './symbols';\nimport { StateToken } from './state-token/state-token';\nimport { StateFactory } from './internal/state-factory';\n\n@Injectable()\nexport class Store {\n  /**\n   * This is a derived state stream that leaves NGXS execution strategy to emit state changes within the Angular zone,\n   * because state is being changed actually within the `<root>` zone, see `InternalDispatcher#dispatchSingle`.\n   * All selects would use this stream, and it would call leave only once for any state change across all active selectors.\n   */\n  private _selectableStateStream = this._stateStream.pipe(\n    observeOn(queueScheduler),\n    leaveNgxs(this._internalExecutionStrategy),\n    shareReplay({ bufferSize: 1, refCount: true })\n  );\n\n  constructor(\n    private _stateStream: StateStream,\n    private _internalStateOperations: InternalStateOperations,\n    private _config: NgxsConfig,\n    private _internalExecutionStrategy: InternalNgxsExecutionStrategy,\n    private _stateFactory: StateFactory,\n    @Optional()\n    @Inject(INITIAL_STATE_TOKEN)\n    initialStateValue: any\n  ) {\n    this.initStateStream(initialStateValue);\n  }\n\n  /**\n   * Dispatches event(s).\n   */\n  dispatch(actionOrActions: any | any[]): Observable<any> {\n    return this._internalStateOperations.getRootStateOperations().dispatch(actionOrActions);\n  }\n\n  /**\n   * Selects a slice of data from the store.\n   */\n  select<T>(selector: (state: any, ...states: any[]) => T): Observable<T>;\n  select<T = any>(selector: string | Type<any>): Observable<T>;\n  select<T>(selector: StateToken<T>): Observable<T>;\n  select(selector: any): Observable<any> {\n    const selectorFn = this.getStoreBoundSelectorFn(selector);\n    return this._selectableStateStream.pipe(\n      map(selectorFn),\n      catchError((err: Error): Observable<never> | Observable<undefined> => {\n        // if error is TypeError we swallow it to prevent usual errors with property access\n        const { suppressErrors } = this._config.selectorOptions;\n\n        if (err instanceof TypeError && suppressErrors) {\n          return of(undefined);\n        }\n\n        // rethrow other errors\n        return throwError(err);\n      }),\n      distinctUntilChanged(),\n      leaveNgxs(this._internalExecutionStrategy)\n    );\n  }\n\n  /**\n   * Select one slice of data from the store.\n   */\n\n  selectOnce<T>(selector: (state: any, ...states: any[]) => T): Observable<T>;\n  selectOnce<T = any>(selector: string | Type<any>): Observable<T>;\n  selectOnce<T>(selector: StateToken<T>): Observable<T>;\n  selectOnce(selector: any): Observable<any> {\n    return this.select(selector).pipe(take(1));\n  }\n\n  /**\n   * Select a snapshot from the state.\n   */\n  selectSnapshot<T>(selector: (state: any, ...states: any[]) => T): T;\n  selectSnapshot<T = any>(selector: string | Type<any>): T;\n  selectSnapshot<T>(selector: StateToken<T>): T;\n  selectSnapshot(selector: any): any {\n    const selectorFn = this.getStoreBoundSelectorFn(selector);\n    return selectorFn(this._stateStream.getValue());\n  }\n\n  /**\n   * Allow the user to subscribe to the root of the state\n   */\n  subscribe(fn?: (value: any) => void): Subscription {\n    return this._selectableStateStream\n      .pipe(leaveNgxs(this._internalExecutionStrategy))\n      .subscribe(fn);\n  }\n\n  /**\n   * Return the raw value of the state.\n   */\n  snapshot(): any {\n    return this._internalStateOperations.getRootStateOperations().getState();\n  }\n\n  /**\n   * Reset the state to a specific point in time. This method is useful\n   * for plugin's who need to modify the state directly or unit testing.\n   */\n  reset(state: any) {\n    return this._internalStateOperations.getRootStateOperations().setState(state);\n  }\n\n  private getStoreBoundSelectorFn(selector: any) {\n    const makeSelectorFn = getRootSelectorFactory(selector);\n    const runtimeContext = this._stateFactory.getRuntimeSelectorContext();\n    return makeSelectorFn(runtimeContext);\n  }\n\n  private initStateStream(initialStateValue: any): void {\n    const value: PlainObject = this._stateStream.value;\n    const storeIsEmpty: boolean = !value || Object.keys(value).length === 0;\n    if (storeIsEmpty) {\n      const defaultStateNotEmpty: boolean = Object.keys(this._config.defaultsState).length > 0;\n      const storeValues: PlainObject = defaultStateNotEmpty\n        ? { ...this._config.defaultsState, ...initialStateValue }\n        : initialStateValue;\n\n      this._stateStream.next(storeValues);\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"store.js","sourceRoot":"","sources":["../../../../packages/store/src/store.ts"],"names":[],"mappings":"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","sourcesContent":["// tslint:disable:unified-signatures\nimport { Inject, Injectable, Optional, Type } from '@angular/core';\nimport { Observable, of, Subscription, throwError } from 'rxjs';\nimport { catchError, distinctUntilChanged, map, shareReplay, take } from 'rxjs/operators';\nimport { INITIAL_STATE_TOKEN, PlainObject } from '@ngxs/store/internals';\n\nimport { InternalNgxsExecutionStrategy } from './execution/internal-ngxs-execution-strategy';\nimport { InternalStateOperations } from './internal/state-operations';\nimport { getRootSelectorFactory } from './utils/selector-utils';\nimport { StateStream } from './internal/state-stream';\nimport { leaveNgxs } from './operators/leave-ngxs';\nimport { NgxsConfig } from './symbols';\nimport { StateToken } from './state-token/state-token';\nimport { StateFactory } from './internal/state-factory';\n\n@Injectable()\nexport class Store {\n  /**\n   * This is a derived state stream that leaves NGXS execution strategy to emit state changes within the Angular zone,\n   * because state is being changed actually within the `<root>` zone, see `InternalDispatcher#dispatchSingle`.\n   * All selects would use this stream, and it would call leave only once for any state change across all active selectors.\n   */\n  private _selectableStateStream = this._stateStream.pipe(\n    leaveNgxs(this._internalExecutionStrategy),\n    shareReplay({ bufferSize: 1, refCount: true })\n  );\n\n  constructor(\n    private _stateStream: StateStream,\n    private _internalStateOperations: InternalStateOperations,\n    private _config: NgxsConfig,\n    private _internalExecutionStrategy: InternalNgxsExecutionStrategy,\n    private _stateFactory: StateFactory,\n    @Optional()\n    @Inject(INITIAL_STATE_TOKEN)\n    initialStateValue: any\n  ) {\n    this.initStateStream(initialStateValue);\n  }\n\n  /**\n   * Dispatches event(s).\n   */\n  dispatch(actionOrActions: any | any[]): Observable<any> {\n    return this._internalStateOperations.getRootStateOperations().dispatch(actionOrActions);\n  }\n\n  /**\n   * Selects a slice of data from the store.\n   */\n  select<T>(selector: (state: any, ...states: any[]) => T): Observable<T>;\n  select<T = any>(selector: string | Type<any>): Observable<T>;\n  select<T>(selector: StateToken<T>): Observable<T>;\n  select(selector: any): Observable<any> {\n    const selectorFn = this.getStoreBoundSelectorFn(selector);\n    return this._selectableStateStream.pipe(\n      map(selectorFn),\n      catchError((err: Error): Observable<never> | Observable<undefined> => {\n        // if error is TypeError we swallow it to prevent usual errors with property access\n        const { suppressErrors } = this._config.selectorOptions;\n\n        if (err instanceof TypeError && suppressErrors) {\n          return of(undefined);\n        }\n\n        // rethrow other errors\n        return throwError(err);\n      }),\n      distinctUntilChanged(),\n      leaveNgxs(this._internalExecutionStrategy)\n    );\n  }\n\n  /**\n   * Select one slice of data from the store.\n   */\n\n  selectOnce<T>(selector: (state: any, ...states: any[]) => T): Observable<T>;\n  selectOnce<T = any>(selector: string | Type<any>): Observable<T>;\n  selectOnce<T>(selector: StateToken<T>): Observable<T>;\n  selectOnce(selector: any): Observable<any> {\n    return this.select(selector).pipe(take(1));\n  }\n\n  /**\n   * Select a snapshot from the state.\n   */\n  selectSnapshot<T>(selector: (state: any, ...states: any[]) => T): T;\n  selectSnapshot<T = any>(selector: string | Type<any>): T;\n  selectSnapshot<T>(selector: StateToken<T>): T;\n  selectSnapshot(selector: any): any {\n    const selectorFn = this.getStoreBoundSelectorFn(selector);\n    return selectorFn(this._stateStream.getValue());\n  }\n\n  /**\n   * Allow the user to subscribe to the root of the state\n   */\n  subscribe(fn?: (value: any) => void): Subscription {\n    return this._selectableStateStream\n      .pipe(leaveNgxs(this._internalExecutionStrategy))\n      .subscribe(fn);\n  }\n\n  /**\n   * Return the raw value of the state.\n   */\n  snapshot(): any {\n    return this._internalStateOperations.getRootStateOperations().getState();\n  }\n\n  /**\n   * Reset the state to a specific point in time. This method is useful\n   * for plugin's who need to modify the state directly or unit testing.\n   */\n  reset(state: any) {\n    return this._internalStateOperations.getRootStateOperations().setState(state);\n  }\n\n  private getStoreBoundSelectorFn(selector: any) {\n    const makeSelectorFn = getRootSelectorFactory(selector);\n    const runtimeContext = this._stateFactory.getRuntimeSelectorContext();\n    return makeSelectorFn(runtimeContext);\n  }\n\n  private initStateStream(initialStateValue: any): void {\n    const value: PlainObject = this._stateStream.value;\n    const storeIsEmpty: boolean = !value || Object.keys(value).length === 0;\n    if (storeIsEmpty) {\n      const defaultStateNotEmpty: boolean = Object.keys(this._config.defaultsState).length > 0;\n      const storeValues: PlainObject = defaultStateNotEmpty\n        ? { ...this._config.defaultsState, ...initialStateValue }\n        : initialStateValue;\n\n      this._stateStream.next(storeValues);\n    }\n  }\n}\n"]}

package/fesm2015/ngxs-store.js

@@ -3,8 +3,8 @@ import { NgZone, PLATFORM_ID, Injectable, Inject, InjectionToken, inject, INJECT
 import * as i5 from '@ngxs/store/internals';
 import { memoize, INITIAL_STATE_TOKEN, NgxsBootstrapper, ɵNGXS_STATE_CONTEXT_FACTORY, ɵNGXS_STATE_FACTORY, InitialState } from '@ngxs/store/internals';
 import { isPlatformServer } from '@angular/common';
-import { Observable, Subject, BehaviorSubject, of, forkJoin, throwError, EMPTY, from, isObservable, queueScheduler } from 'rxjs';
-import { filter, map, share, shareReplay, take, exhaustMap, mergeMap, defaultIfEmpty, catchError, takeUntil, observeOn, distinctUntilChanged, tap, startWith, pairwise } from 'rxjs/operators';
+import { Observable, Subject, BehaviorSubject, of, forkJoin, throwError, EMPTY, from, isObservable } from 'rxjs';
+import { filter, map, share, shareReplay, take, exhaustMap, mergeMap, defaultIfEmpty, catchError, takeUntil, distinctUntilChanged, tap, startWith, pairwise } from 'rxjs/operators';
 
 function throwStateNameError(name) {
     throw new Error(`${name} is not a valid state name. It needs to be a valid object property name.`);
@@ -659,6 +659,43 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImpo
                     args: [NGXS_EXECUTION_STRATEGY]
                 }] }]; } });
 
+/**
+ * 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) {
+    const callsQueue = [];
+    let busyPushingNext = false;
+    return function callOperation(...args) {
+        if (busyPushingNext) {
+            callsQueue.unshift(args);
+            return;
+        }
+        busyPushingNext = true;
+        operation(...args);
+        while (callsQueue.length > 0) {
+            const nextCallArgs = callsQueue.pop();
+            nextCallArgs && operation(...nextCallArgs);
+        }
+        busyPushingNext = false;
+    };
+}
 /**
  * Custom Subject that ensures that subscribers are notified of values in the order that they arrived.
  * A standard Subject does not have this guarantee.
@@ -677,23 +714,31 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImpo
 class OrderedSubject extends Subject {
     constructor() {
         super(...arguments);
-        this._itemQueue = [];
-        this._busyPushingNext = false;
+        this.next = orderedQueueOperation((value) => super.next(value));
     }
-    next(value) {
-        if (this._busyPushingNext) {
-            this._itemQueue.unshift(value);
-            return;
-        }
-        this._busyPushingNext = true;
-        super.next(value);
-        while (this._itemQueue.length > 0) {
-            const nextValue = this._itemQueue.pop();
-            super.next(nextValue);
-        }
-        this._busyPushingNext = false;
+}
+/**
+ * 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`.
+ */
+class OrderedBehaviorSubject extends BehaviorSubject {
+    constructor() {
+        super(...arguments);
+        this.next = orderedQueueOperation((value) => super.next(value));
     }
 }
+
 /**
  * Internal Action stream that is emitted anytime an action is dispatched.
  */
@@ -826,7 +871,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImpo
  * BehaviorSubject of the entire state.
  * @ignore
  */
-class StateStream extends BehaviorSubject {
+class StateStream extends OrderedBehaviorSubject {
     constructor() {
         super({});
     }
@@ -1619,7 +1664,7 @@ class Store {
          * 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(observeOn(queueScheduler), leaveNgxs(this._internalExecutionStrategy), shareReplay({ bufferSize: 1, refCount: true }));
+        this._selectableStateStream = this._stateStream.pipe(leaveNgxs(this._internalExecutionStrategy), shareReplay({ bufferSize: 1, refCount: true }));
         this.initStateStream(initialStateValue);
     }
     /**