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

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "../../node_modules/ng-packagr/package.schema.json",
   "name": "@ngxs/store",
-  "version": "3.7.6-dev.master-94b06c2",
+  "version": "3.7.6-dev.master-f234866",
   "license": "MIT",
   "sideEffects": true,
   "peerDependencies": {

package/src/actions-stream.d.ts

@@ -1,6 +1,7 @@
 import { OnDestroy } from '@angular/core';
-import { Subject, Observable } from 'rxjs';
+import { Observable } from 'rxjs';
 import { InternalNgxsExecutionStrategy } from './execution/internal-ngxs-execution-strategy';
+import { OrderedSubject } from './internal/custom-rxjs-subjects';
 import * as i0 from "@angular/core";
 /**
  * Status of a dispatched action
@@ -16,26 +17,6 @@ export interface ActionContext<T = any> {
     action: T;
     error?: Error;
 }
-/**
- * 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 declare class OrderedSubject<T> extends Subject<T> {
-    private _itemQueue;
-    private _busyPushingNext;
-    next(value?: T): void;
-}
 /**
  * Internal Action stream that is emitted anytime an action is dispatched.
  */

package/src/internal/custom-rxjs-subjects.d.ts

@@ -0,0 +1,37 @@
+import { Subject, BehaviorSubject } from 'rxjs';
+/**
+ * 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 declare class OrderedSubject<T> extends Subject<T> {
+    next: (value?: T | undefined) => void;
+}
+/**
+ * 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 declare class OrderedBehaviorSubject<T> extends BehaviorSubject<T> {
+    next: (value: T) => void;
+}

package/src/internal/state-stream.d.ts

@@ -1,12 +1,12 @@
 import { OnDestroy } from '@angular/core';
-import { BehaviorSubject } from 'rxjs';
 import { PlainObject } from '@ngxs/store/internals';
+import { OrderedBehaviorSubject } from './custom-rxjs-subjects';
 import * as i0 from "@angular/core";
 /**
  * BehaviorSubject of the entire state.
  * @ignore
  */
-export declare class StateStream extends BehaviorSubject<PlainObject> implements OnDestroy {
+export declare class StateStream extends OrderedBehaviorSubject<PlainObject> implements OnDestroy {
     constructor();
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<StateStream, never>;