synstate 0.1.2 → 1.0.0

package/dist/core/operators/{map-with-index.d.mts → map.d.mts}

@@ -11,8 +11,8 @@ import { type KeepInitialValueOperator } from '../types/index.mjs';
  * ```ts
  * //  Timeline:
  * //
- * //  num$      "a"      "b"      "c"
- * //  indexed$  "0: a"   "1: b"   "2: c"
+ * //  num$      "A"      "B"      "C"
+ * //  indexed$  "0: A"   "1: B"   "2: C"
  * //
  * //  Explanation:
  * //  - mapWithIndex transforms each value along with its index
@@ -20,22 +20,22 @@ import { type KeepInitialValueOperator } from '../types/index.mjs';
  *
  * const num$ = source<string>();
  *
- * const indexed$ = num$.pipe(mapWithIndex((x, i) => `${i}: ${x}`));
+ * const indexed$ = num$.pipe(map((x, i) => `${i}: ${x}`));
  *
- * const mut_history: string[] = [];
+ * const valueHistory: string[] = [];
  *
  * indexed$.subscribe((s) => {
- *   mut_history.push(s);
+ *   valueHistory.push(s);
  * });
  *
- * num$.next('a'); // 0: a
+ * num$.next('A'); // 0: A
  *
- * num$.next('b'); // 1: b
+ * num$.next('B'); // 1: B
  *
- * num$.next('c'); // 2: c
+ * num$.next('C'); // 2: C
  *
- * assert.deepStrictEqual(mut_history, ['0: a', '1: b', '2: c']);
+ * assert.deepStrictEqual(valueHistory, ['0: A', '1: B', '2: C']);
  * ```
  */
-export declare const mapWithIndex: <A, B>(mapFn: (x: A, index: SafeUint | -1) => B) => KeepInitialValueOperator<A, B>;
-//# sourceMappingURL=map-with-index.d.mts.map
+export declare const map: <A, B>(mapFn: (x: A, index: SafeUint | -1) => B) => KeepInitialValueOperator<A, B>;
+//# sourceMappingURL=map.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"map.d.mts","sourceRoot":"","sources":["../../../src/core/operators/map.mts"],"names":[],"mappings":"AAGA,OAAO,EAEL,KAAK,wBAAwB,EAI9B,MAAM,oBAAoB,CAAC;AAG5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,GAAG,GAAI,CAAC,EAAE,CAAC,EACtB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,KACvC,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAMQ,CAAC"}

package/dist/core/operators/{map-with-index.mjs → map.mjs}

@@ -14,8 +14,8 @@ import '../utils/id-maker.mjs';
  * ```ts
  * //  Timeline:
  * //
- * //  num$      "a"      "b"      "c"
- * //  indexed$  "0: a"   "1: b"   "2: c"
+ * //  num$      "A"      "B"      "C"
+ * //  indexed$  "0: A"   "1: B"   "2: C"
  * //
  * //  Explanation:
  * //  - mapWithIndex transforms each value along with its index
@@ -23,28 +23,28 @@ import '../utils/id-maker.mjs';
  *
  * const num$ = source<string>();
  *
- * const indexed$ = num$.pipe(mapWithIndex((x, i) => `${i}: ${x}`));
+ * const indexed$ = num$.pipe(map((x, i) => `${i}: ${x}`));
  *
- * const mut_history: string[] = [];
+ * const valueHistory: string[] = [];
  *
  * indexed$.subscribe((s) => {
- *   mut_history.push(s);
+ *   valueHistory.push(s);
  * });
  *
- * num$.next('a'); // 0: a
+ * num$.next('A'); // 0: A
  *
- * num$.next('b'); // 1: b
+ * num$.next('B'); // 1: B
  *
- * num$.next('c'); // 2: c
+ * num$.next('C'); // 2: C
  *
- * assert.deepStrictEqual(mut_history, ['0: a', '1: b', '2: c']);
+ * assert.deepStrictEqual(valueHistory, ['0: A', '1: B', '2: C']);
  * ```
  */
-const mapWithIndex = (mapFn) => 
+const map = (mapFn) => 
 // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-((parentObservable) => new MapWithIndexObservableClass(parentObservable, mapFn));
+((parentObservable) => new MapObservableClass(parentObservable, mapFn));
 /* implementation */
-class MapWithIndexObservableClass extends SyncChildObservableClass {
+class MapObservableClass extends SyncChildObservableClass {
     #mapFn;
     #mut_index;
     constructor(parentObservable, mapFn) {
@@ -55,17 +55,17 @@ class MapWithIndexObservableClass extends SyncChildObservableClass {
         this.#mut_index = -1;
         this.#mapFn = mapFn;
     }
-    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);
-        this.setNext(this.#mapFn(sn.value, this.#mut_index), updaterSymbol);
+        this.setNext(this.#mapFn(sn.value, this.#mut_index), updateToken);
     }
 }
 
-export { mapWithIndex };
-//# sourceMappingURL=map-with-index.mjs.map
+export { map };
+//# sourceMappingURL=map.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"map.mjs","sources":["../../../src/core/operators/map.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCG;AACI,MAAM,GAAG,GAAG,CACjB,KAAwC;AAExC;AACA,CAAC,CAAC,gBAAgB,KAChB,IAAI,kBAAkB,CACpB,gBAAgB,EAChB,KAAK,CACN;AAEL;AAEA,MAAM,kBACJ,SAAQ,wBAAyC,CAAA;AAGxC,IAAA,MAAM;AACf,IAAA,UAAU;IAEV,WAAA,CACE,gBAA+B,EAC/B,KAAwC,EAAA;AAExC,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,YAAY,EAAE,QAAQ,CAAC,GAAG,CAAC,gBAAgB,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC,KAC3D,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CACb;AACF,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,UAAU,GAAG,EAAE;AAEpB,QAAA,IAAI,CAAC,MAAM,GAAG,KAAK;;AAGZ,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;;AAGT,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,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,EAAE,WAAW,CAAC;;AAEpE;;;;"}

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

@@ -12,56 +12,83 @@ import { type DropInitialValueOperator, type Observable } from '../types/index.m
  * ```ts
  * //  Timeline:
  * //
- * //  ids$          1               2               3
- * //  requests      fetch(1)        fetch(2)        fetch(3)
- * //  users$        result1         result2         result3
- * //                (parallel)      (parallel)      (parallel)
+ * //  input$      A                          B              C
+ * //  inner A     A1    A2    A3
+ * //  inner B                                B1    B2             B3
+ * //  inner C                                              C1         C2    C3
+ * //  result$     A1    A2    A3              B1    B2      C1    B3   C2    C3
  * //
  * //  Explanation:
- * //  - mergeMap runs all inner observables in parallel
- * //  - Results are emitted as they arrive (may be out of order)
- * //  - Does NOT cancel previous requests
- * //  - All requests run concurrently and all results are emitted
+ * //  - mergeMap creates an inner observable for each source value
+ * //  - Unlike switchMap, previous inner observables are NOT cancelled
+ * //  - B's inner continues even after C arrives (B3 is still emitted)
+ * //  - All inner observables run concurrently and their results are merged
  *
- * const ids$ = source<number>();
+ * const input$ = source<string>();
  *
- * const users$ = ids$.pipe(
- *   mergeMap((id) => {
- *     const result$ = source<{ id: number }>();
+ * const result$ = input$.pipe(
+ *   mergeMap((letter) => {
+ *     const inner$ = source<string>();
  *
  *     setTimeout(() => {
- *       result$.next({ id });
- *
- *       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: { id: number }[] = [];
+ * const valueHistory: string[] = [];
  *
- * users$.subscribe((value) => {
- *   mut_history.push(value);
+ * result$.subscribe((value) => {
+ *   valueHistory.push(value);
  * });
  *
- * ids$.next(1);
+ * const sleep = (ms: number): Promise<void> =>
+ *   new Promise((resolve) => {
+ *     setTimeout(resolve, ms);
+ *   });
  *
- * ids$.next(2);
+ * // Emit A - inner emits A1, A2, A3 at 10ms, 110ms, 210ms
+ * input$.next('A');
  *
- * ids$.next(3);
+ * 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(mut_history.length, 3);
+ * assert.deepStrictEqual(valueHistory, ['A1', 'A2', 'A3', 'B1', 'B2']);
  *
- * assert.isTrue(mut_history.some((u) => u.id === 1));
+ * // Emit C while B's inner is still running (B3 at 210ms not yet fired)
+ * // Unlike switchMap, B's inner is NOT cancelled
+ * input$.next('C');
  *
- * assert.isTrue(mut_history.some((u) => u.id === 2));
+ * await sleep(250);
  *
- * assert.isTrue(mut_history.some((u) => u.id === 3));
+ * // B3 appears between C1 and C2, showing the merge behavior
+ * assert.deepStrictEqual(valueHistory, [
+ *   'A1',
+ *   'A2',
+ *   'A3',
+ *   'B1',
+ *   'B2',
+ *   'C1',
+ *   'B3',
+ *   'C2',
+ *   'C3',
+ * ]);
  * ```
  *
  * @note To improve code readability, consider using `createState` instead of `mergeMap`,

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

@@ -1 +1 @@
-{"version":3,"file":"merge-map.d.mts","sourceRoot":"","sources":["../../../src/core/operators/merge-map.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAE7B,KAAK,UAAU,EAGhB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AACH,eAAO,MAAM,QAAQ,GAClB,CAAC,EAAE,CAAC,EACH,iBAAiB,CAAC,IAAI,EAAE,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,KAC1C,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAEgC,CAAC;AAEnE;;;GAGG;AACH,eAAO,MAAM,OAAO,GAVjB,CAAC,EAAE,CAAC,mBACc,CAAC,IAAI,EAAE,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,KAC1C,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAQH,CAAC"}
+{"version":3,"file":"merge-map.d.mts","sourceRoot":"","sources":["../../../src/core/operators/merge-map.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAE7B,KAAK,UAAU,EAGhB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8FG;AACH,eAAO,MAAM,QAAQ,GAClB,CAAC,EAAE,CAAC,EACH,iBAAiB,CAAC,IAAI,EAAE,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,KAC1C,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAEgC,CAAC;AAEnE;;;GAGG;AACH,eAAO,MAAM,OAAO,GAVjB,CAAC,EAAE,CAAC,mBACc,CAAC,IAAI,EAAE,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,KAC1C,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAQH,CAAC"}

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

@@ -15,56 +15,83 @@ import '../utils/id-maker.mjs';
  * ```ts
  * //  Timeline:
  * //
- * //  ids$          1               2               3
- * //  requests      fetch(1)        fetch(2)        fetch(3)
- * //  users$        result1         result2         result3
- * //                (parallel)      (parallel)      (parallel)
+ * //  input$      A                          B              C
+ * //  inner A     A1    A2    A3
+ * //  inner B                                B1    B2             B3
+ * //  inner C                                              C1         C2    C3
+ * //  result$     A1    A2    A3              B1    B2      C1    B3   C2    C3
  * //
  * //  Explanation:
- * //  - mergeMap runs all inner observables in parallel
- * //  - Results are emitted as they arrive (may be out of order)
- * //  - Does NOT cancel previous requests
- * //  - All requests run concurrently and all results are emitted
+ * //  - mergeMap creates an inner observable for each source value
+ * //  - Unlike switchMap, previous inner observables are NOT cancelled
+ * //  - B's inner continues even after C arrives (B3 is still emitted)
+ * //  - All inner observables run concurrently and their results are merged
  *
- * const ids$ = source<number>();
+ * const input$ = source<string>();
  *
- * const users$ = ids$.pipe(
- *   mergeMap((id) => {
- *     const result$ = source<{ id: number }>();
+ * const result$ = input$.pipe(
+ *   mergeMap((letter) => {
+ *     const inner$ = source<string>();
  *
  *     setTimeout(() => {
- *       result$.next({ id });
- *
- *       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: { id: number }[] = [];
+ * const valueHistory: string[] = [];
  *
- * users$.subscribe((value) => {
- *   mut_history.push(value);
+ * result$.subscribe((value) => {
+ *   valueHistory.push(value);
  * });
  *
- * ids$.next(1);
+ * const sleep = (ms: number): Promise<void> =>
+ *   new Promise((resolve) => {
+ *     setTimeout(resolve, ms);
+ *   });
  *
- * ids$.next(2);
+ * // Emit A - inner emits A1, A2, A3 at 10ms, 110ms, 210ms
+ * input$.next('A');
  *
- * ids$.next(3);
+ * 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(mut_history.length, 3);
+ * assert.deepStrictEqual(valueHistory, ['A1', 'A2', 'A3', 'B1', 'B2']);
  *
- * assert.isTrue(mut_history.some((u) => u.id === 1));
+ * // Emit C while B's inner is still running (B3 at 210ms not yet fired)
+ * // Unlike switchMap, B's inner is NOT cancelled
+ * input$.next('C');
  *
- * assert.isTrue(mut_history.some((u) => u.id === 2));
+ * await sleep(250);
  *
- * assert.isTrue(mut_history.some((u) => u.id === 3));
+ * // B3 appears between C1 and C2, showing the merge behavior
+ * assert.deepStrictEqual(valueHistory, [
+ *   'A1',
+ *   'A2',
+ *   'A3',
+ *   'B1',
+ *   'B2',
+ *   'C1',
+ *   'B3',
+ *   'C2',
+ *   'C3',
+ * ]);
  * ```
  *
  * @note To improve code readability, consider using `createState` instead of `mergeMap`,
@@ -89,10 +116,10 @@ class MergeMapObservableClass extends AsyncChildObservableClass {
         this.#mut_observables = [];
         this.#mut_subscriptions = [];
     }
-    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 observable = this.#mapToObservable(sn.value);

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

@@ -1 +1 @@
-{"version":3,"file":"merge-map.mjs","sources":["../../../src/core/operators/merge-map.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmEG;MACU,QAAQ,GACnB,CACE,eAA2C,KAE7C,CAAC,gBAAgB,KACf,IAAI,uBAAuB,CAAC,gBAAgB,EAAE,eAAe;AAEjE;;;AAGG;AACI,MAAM,OAAO,GAAG;AAEvB,MAAM,uBACJ,SAAQ,yBAA0C,CAAA;AAGzC,IAAA,gBAAgB;AACzB,IAAA,gBAAgB;AAChB,IAAA,kBAAkB;IAElB,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,gBAAgB,GAAG,EAAE;AAE1B,QAAA,IAAI,CAAC,kBAAkB,GAAG,EAAE;IAC9B;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;QAEA,MAAM,UAAU,GAAG,IAAI,CAAC,gBAAgB,CAAC,EAAE,CAAC,KAAK,CAAC;AAElD,QAAA,IAAI,CAAC,gBAAgB,GAAG,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,gBAAgB,EAAE,UAAU,CAAC;QAEvE,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,kBAAkB,GAAG,GAAG,CAAC,QAAQ,CACpC,IAAI,CAAC,kBAAkB,EACvB,YAAY,CACb;IACH;IAES,QAAQ,GAAA;AACf,QAAA,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,kBAAkB,EAAE;YACvC,CAAC,CAAC,WAAW,EAAE;QACjB;AAEA,QAAA,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,gBAAgB,EAAE;YACrC,CAAC,CAAC,QAAQ,EAAE;QACd;QAEA,KAAK,CAAC,QAAQ,EAAE;IAClB;AACD;;;;"}
+{"version":3,"file":"merge-map.mjs","sources":["../../../src/core/operators/merge-map.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8FG;MACU,QAAQ,GACnB,CACE,eAA2C,KAE7C,CAAC,gBAAgB,KACf,IAAI,uBAAuB,CAAC,gBAAgB,EAAE,eAAe;AAEjE;;;AAGG;AACI,MAAM,OAAO,GAAG;AAEvB,MAAM,uBACJ,SAAQ,yBAA0C,CAAA;AAGzC,IAAA,gBAAgB;AACzB,IAAA,gBAAgB;AAChB,IAAA,kBAAkB;IAElB,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,gBAAgB,GAAG,EAAE;AAE1B,QAAA,IAAI,CAAC,kBAAkB,GAAG,EAAE;IAC9B;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;QAEA,MAAM,UAAU,GAAG,IAAI,CAAC,gBAAgB,CAAC,EAAE,CAAC,KAAK,CAAC;AAElD,QAAA,IAAI,CAAC,gBAAgB,GAAG,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,gBAAgB,EAAE,UAAU,CAAC;QAEvE,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,kBAAkB,GAAG,GAAG,CAAC,QAAQ,CACpC,IAAI,CAAC,kBAAkB,EACvB,YAAY,CACb;IACH;IAES,QAAQ,GAAA;AACf,QAAA,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,kBAAkB,EAAE;YACvC,CAAC,CAAC,WAAW,EAAE;QACjB;AAEA,QAAA,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,gBAAgB,EAAE;YACrC,CAAC,CAAC,QAAQ,EAAE;QACd;QAEA,KAAK,CAAC,QAAQ,EAAE;IAClB;AACD;;;;"}

package/dist/core/operators/pairwise.d.mts

@@ -22,30 +22,30 @@ import { type DropInitialValueOperator } from '../types/index.mjs';
  *
  * const pairs$ = num$.pipe(pairwise());
  *
- * const mut_history: (readonly [number, number])[] = [];
+ * const valueHistory: (readonly [number, number])[] = [];
  *
  * pairs$.subscribe(([prev, curr]) => {
- *   mut_history.push([prev, curr]);
+ *   valueHistory.push([prev, curr]);
  * });
  *
  * num$.next(1); // nothing logged
  *
- * assert.deepStrictEqual(mut_history, []);
+ * assert.deepStrictEqual(valueHistory, []);
  *
  * num$.next(2); // logs: 1, 2
  *
- * assert.deepStrictEqual(mut_history, [[1, 2]]);
+ * assert.deepStrictEqual(valueHistory, [[1, 2]]);
  *
  * num$.next(3); // logs: 2, 3
  *
- * assert.deepStrictEqual(mut_history, [
+ * assert.deepStrictEqual(valueHistory, [
  *   [1, 2],
  *   [2, 3],
  * ]);
  *
  * num$.next(4); // logs: 3, 4
  *
- * assert.deepStrictEqual(mut_history, [
+ * assert.deepStrictEqual(valueHistory, [
  *   [1, 2],
  *   [2, 3],
  *   [3, 4],

package/dist/core/operators/pairwise.mjs

@@ -25,30 +25,30 @@ import '../utils/id-maker.mjs';
  *
  * const pairs$ = num$.pipe(pairwise());
  *
- * const mut_history: (readonly [number, number])[] = [];
+ * const valueHistory: (readonly [number, number])[] = [];
  *
  * pairs$.subscribe(([prev, curr]) => {
- *   mut_history.push([prev, curr]);
+ *   valueHistory.push([prev, curr]);
  * });
  *
  * num$.next(1); // nothing logged
  *
- * assert.deepStrictEqual(mut_history, []);
+ * assert.deepStrictEqual(valueHistory, []);
  *
  * num$.next(2); // logs: 1, 2
  *
- * assert.deepStrictEqual(mut_history, [[1, 2]]);
+ * assert.deepStrictEqual(valueHistory, [[1, 2]]);
  *
  * num$.next(3); // logs: 2, 3
  *
- * assert.deepStrictEqual(mut_history, [
+ * assert.deepStrictEqual(valueHistory, [
  *   [1, 2],
  *   [2, 3],
  * ]);
  *
  * num$.next(4); // logs: 3, 4
  *
- * assert.deepStrictEqual(mut_history, [
+ * assert.deepStrictEqual(valueHistory, [
  *   [1, 2],
  *   [2, 3],
  *   [3, 4],
@@ -68,10 +68,10 @@ class PairwiseObservableClass extends SyncChildObservableClass {
         // if parentObservable is InitializedObservable
         this.#mut_previousValue = parentObservable.getSnapshot();
     }
-    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;
@@ -79,7 +79,7 @@ class PairwiseObservableClass extends SyncChildObservableClass {
         // NOTE: Must update before setNext, otherwise Optional.isNone(prev) remains true when tryUpdate is called consecutively
         this.#mut_previousValue = par.getSnapshot();
         if (cond) {
-            this.setNext([prev.value, sn.value], updaterSymbol);
+            this.setNext([prev.value, sn.value], updateToken);
         }
     }
 }

package/dist/core/operators/pairwise.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"pairwise.mjs","sources":["../../../src/core/operators/pairwise.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDG;MACU,QAAQ,GAAG,MACtB;AAEF,MAAM,CAAC,GAAG,CAAK,gBAA+B,KAC5C,IAAI,uBAAuB,CAAC,gBAAgB,CAAC;AAE/C,MAAM,uBACJ,SAAQ,wBAAuD,CAAA;AAG/D,IAAA,kBAAkB;AAElB,IAAA,WAAA,CAAY,gBAA+B,EAAA;AACzC,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,YAAY,EAAE,QAAQ,CAAC,IAAI;AAC5B,SAAA,CAAC;;;AAIF,QAAA,IAAI,CAAC,kBAAkB,GAAG,gBAAgB,CAAC,WAAW,EAAE;IAC1D;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,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC;;AAGnC,QAAA,IAAI,CAAC,kBAAkB,GAAG,GAAG,CAAC,WAAW,EAAE;QAE3C,IAAI,IAAI,EAAE;AACR,YAAA,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,aAAa,CAAC;QACrD;IACF;AACD;;;;"}
+{"version":3,"file":"pairwise.mjs","sources":["../../../src/core/operators/pairwise.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDG;MACU,QAAQ,GAAG,MACtB;AAEF,MAAM,CAAC,GAAG,CAAK,gBAA+B,KAC5C,IAAI,uBAAuB,CAAC,gBAAgB,CAAC;AAE/C,MAAM,uBACJ,SAAQ,wBAAuD,CAAA;AAG/D,IAAA,kBAAkB;AAElB,IAAA,WAAA,CAAY,gBAA+B,EAAA;AACzC,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,YAAY,EAAE,QAAQ,CAAC,IAAI;AAC5B,SAAA,CAAC;;;AAIF,QAAA,IAAI,CAAC,kBAAkB,GAAG,gBAAgB,CAAC,WAAW,EAAE;IAC1D;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,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC;;AAGnC,QAAA,IAAI,CAAC,kBAAkB,GAAG,GAAG,CAAC,WAAW,EAAE;QAE3C,IAAI,IAAI,EAAE;AACR,YAAA,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC;QACnD;IACF;AACD;;;;"}

package/dist/core/operators/scan.d.mts

@@ -27,25 +27,25 @@ import { type WithInitialValueOperator } from '../types/index.mjs';
  *
  * const sum$ = num$.pipe(scan((acc, curr) => acc + curr, 0));
  *
- * const mut_history: number[] = [];
+ * const valueHistory: number[] = [];
  *
  * sum$.subscribe((x) => {
- *   mut_history.push(x);
+ *   valueHistory.push(x);
  * });
  *
- * assert.deepStrictEqual(mut_history, [0]);
+ * assert.deepStrictEqual(valueHistory, [0]);
  *
  * num$.next(1); // logs: 1
  *
- * assert.deepStrictEqual(mut_history, [0, 1]);
+ * assert.deepStrictEqual(valueHistory, [0, 1]);
  *
  * num$.next(2); // logs: 3
  *
- * assert.deepStrictEqual(mut_history, [0, 1, 3]);
+ * assert.deepStrictEqual(valueHistory, [0, 1, 3]);
  *
  * num$.next(3); // logs: 6
  *
- * assert.deepStrictEqual(mut_history, [0, 1, 3, 6]);
+ * assert.deepStrictEqual(valueHistory, [0, 1, 3, 6]);
  * ```
  */
 export declare const scan: <A, B>(reducer: (acc: B, curr: A) => B, initialValue: B) => WithInitialValueOperator<A, B>;

package/dist/core/operators/scan.mjs

@@ -30,25 +30,25 @@ import '../utils/id-maker.mjs';
  *
  * const sum$ = num$.pipe(scan((acc, curr) => acc + curr, 0));
  *
- * const mut_history: number[] = [];
+ * const valueHistory: number[] = [];
  *
  * sum$.subscribe((x) => {
- *   mut_history.push(x);
+ *   valueHistory.push(x);
  * });
  *
- * assert.deepStrictEqual(mut_history, [0]);
+ * assert.deepStrictEqual(valueHistory, [0]);
  *
  * num$.next(1); // logs: 1
  *
- * assert.deepStrictEqual(mut_history, [0, 1]);
+ * assert.deepStrictEqual(valueHistory, [0, 1]);
  *
  * num$.next(2); // logs: 3
  *
- * assert.deepStrictEqual(mut_history, [0, 1, 3]);
+ * assert.deepStrictEqual(valueHistory, [0, 1, 3]);
  *
  * num$.next(3); // logs: 6
  *
- * assert.deepStrictEqual(mut_history, [0, 1, 3, 6]);
+ * assert.deepStrictEqual(valueHistory, [0, 1, 3, 6]);
  * ```
  */
 const scan = (reducer, initialValue) => (parentObservable) => new ScanObservableClass(parentObservable, reducer, initialValue);
@@ -61,16 +61,16 @@ class ScanObservableClass extends InitializedSyncChildObservableClass {
         });
         this.#reducer = reducer;
     }
-    tryUpdate(updaterSymbol) {
+    tryUpdate(updateToken) {
         const par = this.parents[0];
         const psn = par.getSnapshot();
         const sn = this.getSnapshot();
-        if (par.updaterSymbol !== updaterSymbol ||
+        if (par.updateToken !== updateToken ||
             Optional.isNone(psn) ||
             Optional.isNone(sn)) {
             return; // skip update
         }
-        this.setNext(this.#reducer(sn.value, psn.value), updaterSymbol);
+        this.setNext(this.#reducer(sn.value, psn.value), updateToken);
     }
 }
 

package/dist/core/operators/scan.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"scan.mjs","sources":["../../../src/core/operators/scan.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDG;AACI,MAAM,IAAI,GACf,CACE,OAA+B,EAC/B,YAAe,KAEjB,CAAC,gBAAgB,KACf,IAAI,mBAAmB,CAAC,gBAAgB,EAAE,OAAO,EAAE,YAAY;AAEnE,MAAM,mBACJ,SAAQ,mCAAoD,CAAA;AAGnD,IAAA,QAAQ;AAEjB,IAAA,WAAA,CACE,gBAA+B,EAC/B,OAA+B,EAC/B,YAAe,EAAA;AAEf,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;AAC3B,YAAA,YAAY,EAAE,QAAQ,CAAC,IAAI,CAAC,YAAY,CAAC;AAC1C,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,QAAQ,GAAG,OAAO;IACzB;AAES,IAAA,SAAS,CAAC,aAA4B,EAAA;QAC7C,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAE3B,QAAA,MAAM,GAAG,GAAG,GAAG,CAAC,WAAW,EAAE;AAE7B,QAAA,MAAM,EAAE,GAAG,IAAI,CAAC,WAAW,EAAE;AAE7B,QAAA,IACE,GAAG,CAAC,aAAa,KAAK,aAAa;AACnC,YAAA,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC;AACpB,YAAA,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EACnB;AACA,YAAA,OAAO;QACT;AAEA,QAAA,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,CAAC,KAAK,CAAC,EAAE,aAAa,CAAC;IACjE;AACD;;;;"}
+{"version":3,"file":"scan.mjs","sources":["../../../src/core/operators/scan.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDG;AACI,MAAM,IAAI,GACf,CACE,OAA+B,EAC/B,YAAe,KAEjB,CAAC,gBAAgB,KACf,IAAI,mBAAmB,CAAC,gBAAgB,EAAE,OAAO,EAAE,YAAY;AAEnE,MAAM,mBACJ,SAAQ,mCAAoD,CAAA;AAGnD,IAAA,QAAQ;AAEjB,IAAA,WAAA,CACE,gBAA+B,EAC/B,OAA+B,EAC/B,YAAe,EAAA;AAEf,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;AAC3B,YAAA,YAAY,EAAE,QAAQ,CAAC,IAAI,CAAC,YAAY,CAAC;AAC1C,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,QAAQ,GAAG,OAAO;IACzB;AAES,IAAA,SAAS,CAAC,WAAwB,EAAA;QACzC,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAE3B,QAAA,MAAM,GAAG,GAAG,GAAG,CAAC,WAAW,EAAE;AAE7B,QAAA,MAAM,EAAE,GAAG,IAAI,CAAC,WAAW,EAAE;AAE7B,QAAA,IACE,GAAG,CAAC,WAAW,KAAK,WAAW;AAC/B,YAAA,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC;AACpB,YAAA,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EACnB;AACA,YAAA,OAAO;QACT;AAEA,QAAA,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC;IAC/D;AACD;;;;"}

package/dist/core/operators/skip-if-no-change.d.mts

@@ -11,8 +11,8 @@ import { type KeepInitialValueOperator } from '../types/index.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
@@ -23,29 +23,41 @@ import { type KeepInitialValueOperator } from '../types/index.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]);
  * ```
  */
 export declare const skipIfNoChange: <A>(eq?: (x: A, y: A) => boolean) => KeepInitialValueOperator<A, A>;

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

@@ -1 +1 @@
-{"version":3,"file":"skip-if-no-change.d.mts","sourceRoot":"","sources":["../../../src/core/operators/skip-if-no-change.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAI9B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,EAC9B,KAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAmC,KACtD,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAMQ,CAAC;AAEzC;;;GAGG;AACH,eAAO,MAAM,oBAAoB,GAdF,CAAC,OAC1B,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,KAC1B,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAYkB,CAAC"}
+{"version":3,"file":"skip-if-no-change.d.mts","sourceRoot":"","sources":["../../../src/core/operators/skip-if-no-change.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAI9B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,EAC9B,KAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAmC,KACtD,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAMQ,CAAC;AAEzC;;;GAGG;AACH,eAAO,MAAM,oBAAoB,GAdF,CAAC,OAC1B,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,KAC1B,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAYkB,CAAC"}