synstate 0.1.2 → 1.0.0

package/dist/core/operators/skip-if-no-change.mjs

@@ -14,8 +14,8 @@ import '../utils/id-maker.mjs';
  * ```ts
  * //  Timeline:
  * //
- * //  num$      1     1     2     2     2     3
- * //  distinct$ 1           2                 3
+ * //  num$      1     1     2     2     1     2     3     2
+ * //  distinct$ 1           2           1     2     3     2
  * //
  * //  Explanation:
  * //  - skipIfNoChange filters out consecutive duplicate values
@@ -26,29 +26,41 @@ import '../utils/id-maker.mjs';
  *
  * const distinct$ = num$.pipe(skipIfNoChange());
  *
- * const mut_history: number[] = [];
+ * const valueHistory: number[] = [];
  *
  * distinct$.subscribe((x) => {
- *   mut_history.push(x);
+ *   valueHistory.push(x);
  * });
  *
  * num$.next(1); // logs: 1
  *
- * assert.deepStrictEqual(mut_history, [1]);
+ * assert.deepStrictEqual(valueHistory, [1]);
  *
  * num$.next(1); // nothing logged
  *
- * assert.deepStrictEqual(mut_history, [1]);
+ * assert.deepStrictEqual(valueHistory, [1]);
  *
  * num$.next(2); // logs: 2
  *
- * assert.deepStrictEqual(mut_history, [1, 2]);
+ * assert.deepStrictEqual(valueHistory, [1, 2]);
  *
  * num$.next(2); // nothing logged
  *
+ * num$.next(1); // logs: 1
+ *
+ * assert.deepStrictEqual(valueHistory, [1, 2, 1]);
+ *
+ * num$.next(2); // logs: 2
+ *
+ * assert.deepStrictEqual(valueHistory, [1, 2, 1, 2]);
+ *
  * num$.next(3); // logs: 3
  *
- * assert.deepStrictEqual(mut_history, [1, 2, 3]);
+ * assert.deepStrictEqual(valueHistory, [1, 2, 1, 2, 3]);
+ *
+ * num$.next(2); // logs: 2
+ *
+ * assert.deepStrictEqual(valueHistory, [1, 2, 1, 2, 3, 2]);
  * ```
  */
 const skipIfNoChange = (eq = (x, y) => Object.is(x, y)) => 
@@ -72,10 +84,10 @@ class SkipIfNoChangeObservableClass extends SyncChildObservableClass {
         this.#mut_previousValue = parentObservable.getSnapshot();
         this.#eq = eq;
     }
-    tryUpdate(updaterSymbol) {
+    tryUpdate(updateToken) {
         const par = this.parents[0];
         const sn = par.getSnapshot();
-        if (par.updaterSymbol !== updaterSymbol || Optional.isNone(sn)) {
+        if (par.updateToken !== updateToken || Optional.isNone(sn)) {
             return; // skip update
         }
         const prev = this.#mut_previousValue;
@@ -83,7 +95,7 @@ class SkipIfNoChangeObservableClass extends SyncChildObservableClass {
         // NOTE: Must update before setNext, otherwise Optional.isNone(prev) remains true when tryUpdate is called consecutively
         this.#mut_previousValue = sn;
         if (cond) {
-            this.setNext(sn.value, updaterSymbol);
+            this.setNext(sn.value, updateToken);
         }
     }
 }

package/dist/core/operators/skip-if-no-change.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"skip-if-no-change.mjs","sources":["../../../src/core/operators/skip-if-no-change.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDG;MACU,cAAc,GAAG,CAC5B,EAAA,GAA8B,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;AAEvD;AACA,CAAC,CAAC,gBAAgB,KAChB,IAAI,6BAA6B,CAC/B,gBAAgB,EAChB,EAAE,CACH;AAEL;;;AAGG;AACI,MAAM,oBAAoB,GAAG;AAEpC,MAAM,6BACJ,SAAQ,wBAAyC,CAAA;AAGxC,IAAA,GAAG;AACZ,IAAA,kBAAkB;IAElB,WAAA,CAAY,gBAA+B,EAAE,EAA2B,EAAA;AACtE,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;AAC3B,YAAA,YAAY,EAAE,gBAAgB,CAAC,WAAW,EAAE;AAC7C,SAAA,CAAC;;;AAIF,QAAA,IAAI,CAAC,kBAAkB,GAAG,gBAAgB,CAAC,WAAW,EAAE;AAExD,QAAA,IAAI,CAAC,GAAG,GAAG,EAAE;IACf;AAES,IAAA,SAAS,CAAC,aAA4B,EAAA;QAC7C,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAE3B,QAAA,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE;AAE5B,QAAA,IAAI,GAAG,CAAC,aAAa,KAAK,aAAa,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE;AAC9D,YAAA,OAAO;QACT;AAEA,QAAA,MAAM,IAAI,GAAG,IAAI,CAAC,kBAAkB;QAEpC,MAAM,IAAI,GAAG,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC;;AAGrE,QAAA,IAAI,CAAC,kBAAkB,GAAG,EAAE;QAE5B,IAAI,IAAI,EAAE;YACR,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,CAAC;QACvC;IACF;AACD;;;;"}
+{"version":3,"file":"skip-if-no-change.mjs","sources":["../../../src/core/operators/skip-if-no-change.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4DG;MACU,cAAc,GAAG,CAC5B,EAAA,GAA8B,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;AAEvD;AACA,CAAC,CAAC,gBAAgB,KAChB,IAAI,6BAA6B,CAC/B,gBAAgB,EAChB,EAAE,CACH;AAEL;;;AAGG;AACI,MAAM,oBAAoB,GAAG;AAEpC,MAAM,6BACJ,SAAQ,wBAAyC,CAAA;AAGxC,IAAA,GAAG;AACZ,IAAA,kBAAkB;IAElB,WAAA,CAAY,gBAA+B,EAAE,EAA2B,EAAA;AACtE,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;AAC3B,YAAA,YAAY,EAAE,gBAAgB,CAAC,WAAW,EAAE;AAC7C,SAAA,CAAC;;;AAIF,QAAA,IAAI,CAAC,kBAAkB,GAAG,gBAAgB,CAAC,WAAW,EAAE;AAExD,QAAA,IAAI,CAAC,GAAG,GAAG,EAAE;IACf;AAES,IAAA,SAAS,CAAC,WAAwB,EAAA;QACzC,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAE3B,QAAA,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE;AAE5B,QAAA,IAAI,GAAG,CAAC,WAAW,KAAK,WAAW,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE;AAC1D,YAAA,OAAO;QACT;AAEA,QAAA,MAAM,IAAI,GAAG,IAAI,CAAC,kBAAkB;QAEpC,MAAM,IAAI,GAAG,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC;;AAGrE,QAAA,IAAI,CAAC,kBAAkB,GAAG,EAAE;QAE5B,IAAI,IAAI,EAAE;YACR,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC;QACrC;IACF;AACD;;;;"}

package/dist/core/operators/skip-until.d.mts

@@ -26,27 +26,27 @@ import { type DropInitialValueOperator, type Observable } from '../types/index.m
  *
  * const skipped$ = num$.pipe(skipUntil(startNotifier));
  *
- * const mut_history: number[] = [];
+ * const valueHistory: number[] = [];
  *
  * skipped$.subscribe((x) => {
- *   mut_history.push(x);
+ *   valueHistory.push(x);
  * });
  *
  * num$.next(1); // nothing logged
  *
  * num$.next(2); // nothing logged
  *
- * assert.deepStrictEqual(mut_history, []);
+ * assert.deepStrictEqual(valueHistory, []);
  *
  * start_();
  *
  * num$.next(4); // logs: 4
  *
- * assert.deepStrictEqual(mut_history, [4]);
+ * assert.deepStrictEqual(valueHistory, [4]);
  *
  * num$.next(5); // logs: 5
  *
- * assert.deepStrictEqual(mut_history, [4, 5]);
+ * assert.deepStrictEqual(valueHistory, [4, 5]);
  * ```
  */
 export declare const skipUntil: <A>(notifier: Observable<unknown>) => DropInitialValueOperator<A, A>;

package/dist/core/operators/skip-until.mjs

@@ -29,27 +29,27 @@ import '../utils/id-maker.mjs';
  *
  * const skipped$ = num$.pipe(skipUntil(startNotifier));
  *
- * const mut_history: number[] = [];
+ * const valueHistory: number[] = [];
  *
  * skipped$.subscribe((x) => {
- *   mut_history.push(x);
+ *   valueHistory.push(x);
  * });
  *
  * num$.next(1); // nothing logged
  *
  * num$.next(2); // nothing logged
  *
- * assert.deepStrictEqual(mut_history, []);
+ * assert.deepStrictEqual(valueHistory, []);
  *
  * start_();
  *
  * num$.next(4); // logs: 4
  *
- * assert.deepStrictEqual(mut_history, [4]);
+ * assert.deepStrictEqual(valueHistory, [4]);
  *
  * num$.next(5); // logs: 5
  *
- * assert.deepStrictEqual(mut_history, [4, 5]);
+ * assert.deepStrictEqual(valueHistory, [4, 5]);
  * ```
  */
 const skipUntil = (notifier) => (parentObservable) => new SkipUntilObservableClass(parentObservable, notifier);
@@ -67,15 +67,15 @@ class SkipUntilObservableClass extends SyncChildObservableClass {
             this.#mut_isSkipping = false;
         });
     }
-    tryUpdate(updaterSymbol) {
+    tryUpdate(updateToken) {
         const par = this.parents[0];
         const sn = par.getSnapshot();
-        if (par.updaterSymbol !== updaterSymbol ||
+        if (par.updateToken !== updateToken ||
             Optional.isNone(sn) ||
             this.#mut_isSkipping) {
             return; // skip update
         }
-        this.setNext(sn.value, updaterSymbol);
+        this.setNext(sn.value, updateToken);
     }
 }
 

package/dist/core/operators/skip-until.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"skip-until.mjs","sources":["../../../src/core/operators/skip-until.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDG;MACU,SAAS,GACpB,CAAK,QAA6B,KAClC,CAAC,gBAAgB,KACf,IAAI,wBAAwB,CAAC,gBAAgB,EAAE,QAAQ;AAE3D,MAAM,wBACJ,SAAQ,wBAAyC,CAAA;AAGjD,IAAA,eAAe;IAEf,WAAA,CAAY,gBAA+B,EAAE,QAA6B,EAAA;AACxE,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,YAAY,EAAE,QAAQ,CAAC,IAAI;AAC5B,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,eAAe,GAAG,IAAI;AAE3B,QAAA,QAAQ,CAAC,SAAS,CAChB,MAAK;AACH,YAAA,IAAI,CAAC,eAAe,GAAG,KAAK;QAC9B,CAAC,EACD,MAAK;AACH,YAAA,IAAI,CAAC,eAAe,GAAG,KAAK;AAC9B,QAAA,CAAC,CACF;IACH;AAES,IAAA,SAAS,CAAC,aAA4B,EAAA;QAC7C,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAE3B,QAAA,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE;AAE5B,QAAA,IACE,GAAG,CAAC,aAAa,KAAK,aAAa;AACnC,YAAA,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;YACnB,IAAI,CAAC,eAAe,EACpB;AACA,YAAA,OAAO;QACT;QAEA,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,CAAC;IACvC;AACD;;;;"}
+{"version":3,"file":"skip-until.mjs","sources":["../../../src/core/operators/skip-until.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDG;MACU,SAAS,GACpB,CAAK,QAA6B,KAClC,CAAC,gBAAgB,KACf,IAAI,wBAAwB,CAAC,gBAAgB,EAAE,QAAQ;AAE3D,MAAM,wBACJ,SAAQ,wBAAyC,CAAA;AAGjD,IAAA,eAAe;IAEf,WAAA,CAAY,gBAA+B,EAAE,QAA6B,EAAA;AACxE,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,YAAY,EAAE,QAAQ,CAAC,IAAI;AAC5B,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,eAAe,GAAG,IAAI;AAE3B,QAAA,QAAQ,CAAC,SAAS,CAChB,MAAK;AACH,YAAA,IAAI,CAAC,eAAe,GAAG,KAAK;QAC9B,CAAC,EACD,MAAK;AACH,YAAA,IAAI,CAAC,eAAe,GAAG,KAAK;AAC9B,QAAA,CAAC,CACF;IACH;AAES,IAAA,SAAS,CAAC,WAAwB,EAAA;QACzC,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAE3B,QAAA,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE;AAE5B,QAAA,IACE,GAAG,CAAC,WAAW,KAAK,WAAW;AAC/B,YAAA,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;YACnB,IAAI,CAAC,eAAe,EACpB;AACA,YAAA,OAAO;QACT;QAEA,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC;IACrC;AACD;;;;"}

package/dist/core/operators/skip-while.d.mts

@@ -11,9 +11,9 @@ import { type DropInitialValueOperator } from '../types/index.mjs';
  * ```ts
  * //  Timeline:
  * //
- * //  num$        1     2     3     4     5     6     7
- * //  skipped$                      5     6     7
- * //              |---- skip -----|
+ * //  num$        1     2     3     4     5     6     7     1     2
+ * //  skipped$                            5     6     7     1     2
+ * //              |-------- skip --------|
  * //
  * //  Explanation:
  * //  - skipWhile skips values while the predicate returns true
@@ -24,27 +24,37 @@ import { type DropInitialValueOperator } from '../types/index.mjs';
  *
  * const skipped$ = num$.pipe(skipWhile((x) => x < 5));
  *
- * const mut_history: number[] = [];
+ * const valueHistory: number[] = [];
  *
  * skipped$.subscribe((x) => {
- *   mut_history.push(x);
+ *   valueHistory.push(x);
  * });
  *
  * num$.next(1); // nothing logged
  *
  * num$.next(2); // nothing logged
  *
+ * num$.next(3); // nothing logged
+ *
+ * num$.next(4); // nothing logged
+ *
  * num$.next(5); // logs: 5
  *
- * assert.deepStrictEqual(mut_history, [5]);
+ * assert.deepStrictEqual(valueHistory, [5]);
  *
  * num$.next(6); // logs: 6
  *
- * assert.deepStrictEqual(mut_history, [5, 6]);
+ * assert.deepStrictEqual(valueHistory, [5, 6]);
  *
  * num$.next(7); // logs: 7
  *
- * assert.deepStrictEqual(mut_history, [5, 6, 7]);
+ * assert.deepStrictEqual(valueHistory, [5, 6, 7]);
+ *
+ * num$.next(1); // logs: 1
+ *
+ * num$.next(2); // logs: 2
+ *
+ * assert.deepStrictEqual(valueHistory, [5, 6, 7, 1, 2]);
  * ```
  */
 export declare const skipWhile: <A>(predicate: (value: A, index: SafeUint | -1) => boolean) => DropInitialValueOperator<A, A>;

package/dist/core/operators/skip-while.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"skip-while.d.mts","sourceRoot":"","sources":["../../../src/core/operators/skip-while.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAI9B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,eAAO,MAAM,SAAS,GACnB,CAAC,EACA,WAAW,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,GAAG,CAAC,CAAC,KAAK,OAAO,KACrD,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAE2B,CAAC"}
+{"version":3,"file":"skip-while.d.mts","sourceRoot":"","sources":["../../../src/core/operators/skip-while.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAI9B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,eAAO,MAAM,SAAS,GACnB,CAAC,EACA,WAAW,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,GAAG,CAAC,CAAC,KAAK,OAAO,KACrD,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAE2B,CAAC"}

package/dist/core/operators/skip-while.mjs

@@ -14,9 +14,9 @@ import '../utils/id-maker.mjs';
  * ```ts
  * //  Timeline:
  * //
- * //  num$        1     2     3     4     5     6     7
- * //  skipped$                      5     6     7
- * //              |---- skip -----|
+ * //  num$        1     2     3     4     5     6     7     1     2
+ * //  skipped$                            5     6     7     1     2
+ * //              |-------- skip --------|
  * //
  * //  Explanation:
  * //  - skipWhile skips values while the predicate returns true
@@ -27,27 +27,37 @@ import '../utils/id-maker.mjs';
  *
  * const skipped$ = num$.pipe(skipWhile((x) => x < 5));
  *
- * const mut_history: number[] = [];
+ * const valueHistory: number[] = [];
  *
  * skipped$.subscribe((x) => {
- *   mut_history.push(x);
+ *   valueHistory.push(x);
  * });
  *
  * num$.next(1); // nothing logged
  *
  * num$.next(2); // nothing logged
  *
+ * num$.next(3); // nothing logged
+ *
+ * num$.next(4); // nothing logged
+ *
  * num$.next(5); // logs: 5
  *
- * assert.deepStrictEqual(mut_history, [5]);
+ * assert.deepStrictEqual(valueHistory, [5]);
  *
  * num$.next(6); // logs: 6
  *
- * assert.deepStrictEqual(mut_history, [5, 6]);
+ * assert.deepStrictEqual(valueHistory, [5, 6]);
  *
  * num$.next(7); // logs: 7
  *
- * assert.deepStrictEqual(mut_history, [5, 6, 7]);
+ * assert.deepStrictEqual(valueHistory, [5, 6, 7]);
+ *
+ * num$.next(1); // logs: 1
+ *
+ * num$.next(2); // logs: 2
+ *
+ * assert.deepStrictEqual(valueHistory, [5, 6, 7, 1, 2]);
  * ```
  */
 const skipWhile = (predicate) => (parentObservable) => new SkipWhileObservableClass(parentObservable, predicate);
@@ -55,6 +65,7 @@ const skipWhile = (predicate) => (parentObservable) => new SkipWhileObservableCl
 class SkipWhileObservableClass extends SyncChildObservableClass {
     #predicate;
     #mut_index;
+    #mut_skipping;
     constructor(parentObservable, predicate) {
         super({
             parents: [parentObservable],
@@ -66,17 +77,21 @@ class SkipWhileObservableClass extends SyncChildObservableClass {
         });
         this.#mut_index = -1;
         this.#predicate = predicate;
+        this.#mut_skipping = true;
     }
-    tryUpdate(updaterSymbol) {
+    tryUpdate(updateToken) {
         const par = this.parents[0];
         const sn = par.getSnapshot();
-        if (par.updaterSymbol !== updaterSymbol || Optional.isNone(sn)) {
+        if (par.updateToken !== updateToken || Optional.isNone(sn)) {
             return; // skip update
         }
         this.#mut_index =
             this.#mut_index === -1 ? asSafeUint(0) : SafeUint.add(1, this.#mut_index);
         if (!this.#predicate(sn.value, this.#mut_index)) {
-            this.setNext(sn.value, updaterSymbol);
+            this.#mut_skipping = false;
+        }
+        if (!this.#mut_skipping) {
+            this.setNext(sn.value, updateToken);
         }
     }
 }

package/dist/core/operators/skip-while.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"skip-while.mjs","sources":["../../../src/core/operators/skip-while.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CG;MACU,SAAS,GACpB,CACE,SAAsD,KAExD,CAAC,gBAAgB,KACf,IAAI,wBAAwB,CAAC,gBAAgB,EAAE,SAAS;AAE5D;AAEA,MAAM,wBACJ,SAAQ,wBAAyC,CAAA;AAGxC,IAAA,UAAU;AACnB,IAAA,UAAU;IAEV,WAAA,CACE,gBAA+B,EAC/B,SAAsD,EAAA;AAEtD,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,YAAY,EAAE,IAAI,CAAC,gBAAgB,CAAC,WAAW,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,KACxD,QAAQ,CAAC,MAAM,CAAC,EAAE;kBACd,QAAQ,CAAC;kBACT,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE;sBACpB,QAAQ,CAAC;AACX,sBAAE,EAAE,CACT,CAAC,KAAK;AACR,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,UAAU,GAAG,EAAE;AAEpB,QAAA,IAAI,CAAC,UAAU,GAAG,SAAS;IAC7B;AAES,IAAA,SAAS,CAAC,aAA4B,EAAA;QAC7C,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAE3B,QAAA,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE;AAE5B,QAAA,IAAI,GAAG,CAAC,aAAa,KAAK,aAAa,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE;AAC9D,YAAA,OAAO;QACT;AAEA,QAAA,IAAI,CAAC,UAAU;YACb,IAAI,CAAC,UAAU,KAAK,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,UAAU,CAAC;AAE3E,QAAA,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,EAAE;YAC/C,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,CAAC;QACvC;IACF;AACD;;;;"}
+{"version":3,"file":"skip-while.mjs","sources":["../../../src/core/operators/skip-while.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDG;MACU,SAAS,GACpB,CACE,SAAsD,KAExD,CAAC,gBAAgB,KACf,IAAI,wBAAwB,CAAC,gBAAgB,EAAE,SAAS;AAE5D;AAEA,MAAM,wBACJ,SAAQ,wBAAyC,CAAA;AAGxC,IAAA,UAAU;AACnB,IAAA,UAAU;AACV,IAAA,aAAa;IAEb,WAAA,CACE,gBAA+B,EAC/B,SAAsD,EAAA;AAEtD,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,YAAY,EAAE,IAAI,CAAC,gBAAgB,CAAC,WAAW,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,KACxD,QAAQ,CAAC,MAAM,CAAC,EAAE;kBACd,QAAQ,CAAC;kBACT,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE;sBACpB,QAAQ,CAAC;AACX,sBAAE,EAAE,CACT,CAAC,KAAK;AACR,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,UAAU,GAAG,EAAE;AAEpB,QAAA,IAAI,CAAC,UAAU,GAAG,SAAS;AAE3B,QAAA,IAAI,CAAC,aAAa,GAAG,IAAI;IAC3B;AAES,IAAA,SAAS,CAAC,WAAwB,EAAA;QACzC,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAE3B,QAAA,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE;AAE5B,QAAA,IAAI,GAAG,CAAC,WAAW,KAAK,WAAW,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE;AAC1D,YAAA,OAAO;QACT;AAEA,QAAA,IAAI,CAAC,UAAU;YACb,IAAI,CAAC,UAAU,KAAK,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,UAAU,CAAC;AAE3E,QAAA,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,EAAE;AAC/C,YAAA,IAAI,CAAC,aAAa,GAAG,KAAK;QAC5B;AAEA,QAAA,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE;YACvB,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC;QACrC;IACF;AACD;;;;"}

package/dist/core/operators/switch-map.d.mts

@@ -12,50 +12,81 @@ import { type DropInitialValueOperator, type Observable } from '../types/index.m
  * ```ts
  * //  Timeline:
  * //
- * //  searchQuery$  "a"       "ab"      "abc"
- * //  requests      fetch1    fetch2    fetch3
- * //  results$                cancel    cancel    result3
- * //                          fetch1    fetch2
+ * //  input$      A                          B              C
+ * //  inner A     A1    A2    A3
+ * //  inner B                                B1    B2      (switched!)
+ * //  inner C                                              C1    C2    C3
+ * //  result$     A1    A2    A3              B1    B2      C1    C2    C3
  * //
  * //  Explanation:
- * //  - switchMap cancels previous inner observables when a new value arrives
- * //  - Only the result from the latest search query is emitted
- * //  - Previous ongoing requests are cancelled
- * //  - Ideal for search-as-you-type scenarios
+ * //  - switchMap creates an inner observable for each source value
+ * //  - When a new source value arrives, the previous inner is unsubscribed
+ * //  - A's inner completes normally (all 3 values emitted)
+ * //  - B's inner is interrupted by C (only 2 values emitted)
+ * //  - C's inner completes normally (all 3 values emitted)
  *
- * const searchQuery$ = source<string>();
+ * const input$ = source<string>();
  *
- * const results$ = searchQuery$.pipe(
- *   switchMap((query) => {
- *     const result$ = source<string[]>();
+ * const result$ = input$.pipe(
+ *   switchMap((letter) => {
+ *     const inner$ = source<string>();
  *
  *     setTimeout(() => {
- *       result$.next([query]);
- *
- *       result$.complete();
+ *       inner$.next(`${letter}1`);
  *     }, 10);
  *
- *     return result$;
+ *     setTimeout(() => {
+ *       inner$.next(`${letter}2`);
+ *     }, 110);
+ *
+ *     setTimeout(() => {
+ *       inner$.next(`${letter}3`);
+ *     }, 210);
+ *
+ *     return inner$;
  *   }),
  * );
  *
- * const mut_history: string[][] = [];
+ * const valueHistory: string[] = [];
  *
- * results$.subscribe((value) => {
- *   mut_history.push(value);
+ * result$.subscribe((value) => {
+ *   valueHistory.push(value);
  * });
  *
- * searchQuery$.next('a');
+ * const sleep = (ms: number): Promise<void> =>
+ *   new Promise((resolve) => {
+ *     setTimeout(resolve, ms);
+ *   });
  *
- * searchQuery$.next('ab');
+ * // Emit A - inner emits A1, A2, A3 at 10ms, 110ms, 210ms
+ * input$.next('A');
  *
- * searchQuery$.next('abc');
+ * await sleep(250);
  *
- * await new Promise((resolve) => {
- *   setTimeout(resolve, 200);
- * });
+ * assert.deepStrictEqual(valueHistory, ['A1', 'A2', 'A3']);
+ *
+ * // Emit B - inner starts emitting B1, B2 at 10ms, 110ms
+ * input$.next('B');
+ *
+ * await sleep(150);
+ *
+ * assert.deepStrictEqual(valueHistory, ['A1', 'A2', 'A3', 'B1', 'B2']);
+ *
+ * // Emit C - switches away from B (B3 cancelled), C's inner starts
+ * input$.next('C');
+ *
+ * await sleep(250);
  *
- * assert.deepStrictEqual(mut_history, [['abc']]);
+ * assert.deepStrictEqual(valueHistory, [
+ *   'A1',
+ *   'A2',
+ *   'A3',
+ *   'B1',
+ *   'B2',
+ *   'C1',
+ *   'C2',
+ *   'C3',
+ * ]);
  * ```
  *
  * @note To improve code readability, consider using `createState` instead of `switchMap`,

package/dist/core/operators/switch-map.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"switch-map.d.mts","sourceRoot":"","sources":["../../../src/core/operators/switch-map.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,UAAU,EAIhB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,eAAO,MAAM,SAAS,GACnB,CAAC,EAAE,CAAC,EACH,iBAAiB,CAAC,IAAI,EAAE,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,KAC1C,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAEiC,CAAC"}
+{"version":3,"file":"switch-map.d.mts","sourceRoot":"","sources":["../../../src/core/operators/switch-map.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,UAAU,EAIhB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4FG;AACH,eAAO,MAAM,SAAS,GACnB,CAAC,EAAE,CAAC,EACH,iBAAiB,CAAC,IAAI,EAAE,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,KAC1C,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAEiC,CAAC"}

package/dist/core/operators/switch-map.mjs

@@ -15,50 +15,81 @@ import '../utils/id-maker.mjs';
  * ```ts
  * //  Timeline:
  * //
- * //  searchQuery$  "a"       "ab"      "abc"
- * //  requests      fetch1    fetch2    fetch3
- * //  results$                cancel    cancel    result3
- * //                          fetch1    fetch2
+ * //  input$      A                          B              C
+ * //  inner A     A1    A2    A3
+ * //  inner B                                B1    B2      (switched!)
+ * //  inner C                                              C1    C2    C3
+ * //  result$     A1    A2    A3              B1    B2      C1    C2    C3
  * //
  * //  Explanation:
- * //  - switchMap cancels previous inner observables when a new value arrives
- * //  - Only the result from the latest search query is emitted
- * //  - Previous ongoing requests are cancelled
- * //  - Ideal for search-as-you-type scenarios
+ * //  - switchMap creates an inner observable for each source value
+ * //  - When a new source value arrives, the previous inner is unsubscribed
+ * //  - A's inner completes normally (all 3 values emitted)
+ * //  - B's inner is interrupted by C (only 2 values emitted)
+ * //  - C's inner completes normally (all 3 values emitted)
  *
- * const searchQuery$ = source<string>();
+ * const input$ = source<string>();
  *
- * const results$ = searchQuery$.pipe(
- *   switchMap((query) => {
- *     const result$ = source<string[]>();
+ * const result$ = input$.pipe(
+ *   switchMap((letter) => {
+ *     const inner$ = source<string>();
  *
  *     setTimeout(() => {
- *       result$.next([query]);
- *
- *       result$.complete();
+ *       inner$.next(`${letter}1`);
  *     }, 10);
  *
- *     return result$;
+ *     setTimeout(() => {
+ *       inner$.next(`${letter}2`);
+ *     }, 110);
+ *
+ *     setTimeout(() => {
+ *       inner$.next(`${letter}3`);
+ *     }, 210);
+ *
+ *     return inner$;
  *   }),
  * );
  *
- * const mut_history: string[][] = [];
+ * const valueHistory: string[] = [];
  *
- * results$.subscribe((value) => {
- *   mut_history.push(value);
+ * result$.subscribe((value) => {
+ *   valueHistory.push(value);
  * });
  *
- * searchQuery$.next('a');
+ * const sleep = (ms: number): Promise<void> =>
+ *   new Promise((resolve) => {
+ *     setTimeout(resolve, ms);
+ *   });
  *
- * searchQuery$.next('ab');
+ * // Emit A - inner emits A1, A2, A3 at 10ms, 110ms, 210ms
+ * input$.next('A');
  *
- * searchQuery$.next('abc');
+ * await sleep(250);
  *
- * await new Promise((resolve) => {
- *   setTimeout(resolve, 200);
- * });
+ * assert.deepStrictEqual(valueHistory, ['A1', 'A2', 'A3']);
+ *
+ * // Emit B - inner starts emitting B1, B2 at 10ms, 110ms
+ * input$.next('B');
+ *
+ * await sleep(150);
+ *
+ * assert.deepStrictEqual(valueHistory, ['A1', 'A2', 'A3', 'B1', 'B2']);
+ *
+ * // Emit C - switches away from B (B3 cancelled), C's inner starts
+ * input$.next('C');
+ *
+ * await sleep(250);
  *
- * assert.deepStrictEqual(mut_history, [['abc']]);
+ * assert.deepStrictEqual(valueHistory, [
+ *   'A1',
+ *   'A2',
+ *   'A3',
+ *   'B1',
+ *   'B2',
+ *   'C1',
+ *   'C2',
+ *   'C3',
+ * ]);
  * ```
  *
  * @note To improve code readability, consider using `createState` instead of `switchMap`,
@@ -78,10 +109,10 @@ class SwitchMapObservableClass extends AsyncChildObservableClass {
         this.#mut_observable = undefined;
         this.#mut_subscription = undefined;
     }
-    tryUpdate(updaterSymbol) {
+    tryUpdate(updateToken) {
         const par = this.parents[0];
         const sn = par.getSnapshot();
-        if (par.updaterSymbol !== updaterSymbol || Optional.isNone(sn)) {
+        if (par.updateToken !== updateToken || Optional.isNone(sn)) {
             return; // skip update
         }
         this.#mut_observable?.complete();

package/dist/core/operators/switch-map.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"switch-map.mjs","sources":["../../../src/core/operators/switch-map.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6DG;MACU,SAAS,GACpB,CACE,eAA2C,KAE7C,CAAC,gBAAgB,KACf,IAAI,wBAAwB,CAAC,gBAAgB,EAAE,eAAe;AAElE,MAAM,wBACJ,SAAQ,yBAA0C,CAAA;AAGzC,IAAA,gBAAgB;AACzB,IAAA,eAAe;AACf,IAAA,iBAAiB;IAEjB,WAAA,CACE,gBAA+B,EAC/B,eAA2C,EAAA;AAE3C,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,YAAY,EAAE,QAAQ,CAAC,IAAI;AAC5B,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,gBAAgB,GAAG,eAAe;AAEvC,QAAA,IAAI,CAAC,eAAe,GAAG,SAAS;AAEhC,QAAA,IAAI,CAAC,iBAAiB,GAAG,SAAS;IACpC;AAES,IAAA,SAAS,CAAC,aAA4B,EAAA;QAC7C,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAE3B,QAAA,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE;AAE5B,QAAA,IAAI,GAAG,CAAC,aAAa,KAAK,aAAa,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE;AAC9D,YAAA,OAAO;QACT;AAEA,QAAA,IAAI,CAAC,eAAe,EAAE,QAAQ,EAAE;AAEhC,QAAA,IAAI,CAAC,iBAAiB,EAAE,WAAW,EAAE;QAErC,MAAM,UAAU,GAAG,IAAI,CAAC,gBAAgB,CAAC,EAAE,CAAC,KAAK,CAAC;AAElD,QAAA,IAAI,CAAC,eAAe,GAAG,UAAU;QAEjC,MAAM,YAAY,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,IAAI,KAAI;AACjD,YAAA,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;AACxB,QAAA,CAAC,CAAC;AAEF,QAAA,IAAI,CAAC,iBAAiB,GAAG,YAAY;IACvC;IAES,QAAQ,GAAA;AACf,QAAA,IAAI,CAAC,iBAAiB,EAAE,WAAW,EAAE;AAErC,QAAA,IAAI,CAAC,eAAe,EAAE,QAAQ,EAAE;QAEhC,KAAK,CAAC,QAAQ,EAAE;IAClB;AACD;;;;"}
+{"version":3,"file":"switch-map.mjs","sources":["../../../src/core/operators/switch-map.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4FG;MACU,SAAS,GACpB,CACE,eAA2C,KAE7C,CAAC,gBAAgB,KACf,IAAI,wBAAwB,CAAC,gBAAgB,EAAE,eAAe;AAElE,MAAM,wBACJ,SAAQ,yBAA0C,CAAA;AAGzC,IAAA,gBAAgB;AACzB,IAAA,eAAe;AACf,IAAA,iBAAiB;IAEjB,WAAA,CACE,gBAA+B,EAC/B,eAA2C,EAAA;AAE3C,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,YAAY,EAAE,QAAQ,CAAC,IAAI;AAC5B,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,gBAAgB,GAAG,eAAe;AAEvC,QAAA,IAAI,CAAC,eAAe,GAAG,SAAS;AAEhC,QAAA,IAAI,CAAC,iBAAiB,GAAG,SAAS;IACpC;AAES,IAAA,SAAS,CAAC,WAAwB,EAAA;QACzC,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAE3B,QAAA,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE;AAE5B,QAAA,IAAI,GAAG,CAAC,WAAW,KAAK,WAAW,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE;AAC1D,YAAA,OAAO;QACT;AAEA,QAAA,IAAI,CAAC,eAAe,EAAE,QAAQ,EAAE;AAEhC,QAAA,IAAI,CAAC,iBAAiB,EAAE,WAAW,EAAE;QAErC,MAAM,UAAU,GAAG,IAAI,CAAC,gBAAgB,CAAC,EAAE,CAAC,KAAK,CAAC;AAElD,QAAA,IAAI,CAAC,eAAe,GAAG,UAAU;QAEjC,MAAM,YAAY,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,IAAI,KAAI;AACjD,YAAA,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;AACxB,QAAA,CAAC,CAAC;AAEF,QAAA,IAAI,CAAC,iBAAiB,GAAG,YAAY;IACvC;IAES,QAAQ,GAAA;AACf,QAAA,IAAI,CAAC,iBAAiB,EAAE,WAAW,EAAE;AAErC,QAAA,IAAI,CAAC,eAAe,EAAE,QAAQ,EAAE;QAEhC,KAAK,CAAC,QAAQ,EAAE;IAClB;AACD;;;;"}

package/dist/core/operators/take-until.d.mts

@@ -26,25 +26,25 @@ import { type KeepInitialValueOperator, type Observable } from '../types/index.m
  *
  * const limited$ = num$.pipe(takeUntil(stopNotifier));
  *
- * const mut_history: number[] = [];
+ * const valueHistory: number[] = [];
  *
  * limited$.subscribe((x) => {
- *   mut_history.push(x);
+ *   valueHistory.push(x);
  * });
  *
  * num$.next(1); // logs: 1
  *
- * assert.deepStrictEqual(mut_history, [1]);
+ * assert.deepStrictEqual(valueHistory, [1]);
  *
  * num$.next(2); // logs: 2
  *
- * assert.deepStrictEqual(mut_history, [1, 2]);
+ * assert.deepStrictEqual(valueHistory, [1, 2]);
  *
  * stop_();
  *
  * num$.next(3); // nothing logged (completed)
  *
- * assert.deepStrictEqual(mut_history, [1, 2]);
+ * assert.deepStrictEqual(valueHistory, [1, 2]);
  * ```
  */
 export declare const takeUntil: <A>(notifier: Observable<unknown>) => KeepInitialValueOperator<A, A>;