synstate 1.0.2 → 2.0.1

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

@@ -2,142 +2,46 @@ import { Optional, Arr } from 'ts-data-forge';
 import { AsyncChildObservableClass } from '../class/child-observable-class.mjs';
 import '../utils/id-maker.mjs';
 
-/**
- * Projects each source value to an observable and merges all inner observables.
- * Unlike `switchMap`, does not cancel previous inner observables.
- *
- * @template A - The type of values from the source
- * @template B - The type of values from the projected observable
- * @param mapToObservable - A function that maps each source value to an observable
- * @returns An operator that merges mapped observables
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  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 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 input$ = source<string>();
- *
- * const result$ = input$.pipe(
- *   mergeMap((letter) => {
- *     const inner$ = source<string>();
- *
- *     setTimeout(() => {
- *       inner$.next(`${letter}1`);
- *     }, 10);
- *
- *     setTimeout(() => {
- *       inner$.next(`${letter}2`);
- *     }, 110);
- *
- *     setTimeout(() => {
- *       inner$.next(`${letter}3`);
- *     }, 210);
- *
- *     return inner$;
- *   }),
- * );
- *
- * const valueHistory: string[] = [];
- *
- * result$.subscribe((value) => {
- *   valueHistory.push(value);
- * });
- *
- * const sleep = (ms: number): Promise<void> =>
- *   new Promise((resolve) => {
- *     setTimeout(resolve, ms);
- *   });
- *
- * // Emit A - inner emits A1, A2, A3 at 10ms, 110ms, 210ms
- * input$.next('A');
- *
- * await sleep(250);
- *
- * 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 while B's inner is still running (B3 at 210ms not yet fired)
- * // Unlike switchMap, B's inner is NOT cancelled
- * input$.next('C');
- *
- * await sleep(250);
- *
- * // 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`,
- * subscribing to `parentObservable` and calling `setState` within it.
- */
 const mergeMap = (mapToObservable) => (parentObservable) => new MergeMapObservableClass(parentObservable, mapToObservable);
-/**
- * Alias for `mergeMap`.
- * @see mergeMap
- */
 const flatMap = mergeMap;
 class MergeMapObservableClass extends AsyncChildObservableClass {
-    #mapToObservable;
-    #mut_observables;
-    #mut_subscriptions;
-    constructor(parentObservable, mapToObservable) {
-        super({
-            parents: [parentObservable],
-            initialValue: Optional.none,
-        });
-        this.#mapToObservable = mapToObservable;
-        this.#mut_observables = [];
-        this.#mut_subscriptions = [];
+  #mapToObservable;
+  #mut_observables;
+  #mut_subscriptions;
+  constructor(parentObservable, mapToObservable) {
+    super({
+      parents: [parentObservable],
+      initialValue: Optional.none
+    });
+    this.#mapToObservable = mapToObservable;
+    this.#mut_observables = [];
+    this.#mut_subscriptions = [];
+  }
+  tryUpdate(updateToken) {
+    const par = this.parents[0];
+    const sn = par.getSnapshot();
+    if (par.updateToken !== updateToken || Optional.isNone(sn)) {
+      return;
     }
-    tryUpdate(updateToken) {
-        const par = this.parents[0];
-        const sn = par.getSnapshot();
-        if (par.updateToken !== updateToken || Optional.isNone(sn)) {
-            return; // skip update
-        }
-        const observable = this.#mapToObservable(sn.value);
-        this.#mut_observables = Arr.toPushed(this.#mut_observables, observable);
-        const subscription = observable.subscribe((curr) => {
-            this.startUpdate(curr);
-        });
-        this.#mut_subscriptions = Arr.toPushed(this.#mut_subscriptions, subscription);
+    const observable = this.#mapToObservable(sn.value);
+    this.#mut_observables = Arr.toPushed(this.#mut_observables, observable);
+    const subscription = observable.subscribe((curr) => {
+      this.startUpdate(curr);
+    });
+    this.#mut_subscriptions = Arr.toPushed(
+      this.#mut_subscriptions,
+      subscription
+    );
+  }
+  complete() {
+    for (const s of this.#mut_subscriptions) {
+      s.unsubscribe();
     }
-    complete() {
-        for (const s of this.#mut_subscriptions) {
-            s.unsubscribe();
-        }
-        for (const o of this.#mut_observables) {
-            o.complete();
-        }
-        super.complete();
+    for (const o of this.#mut_observables) {
+      o.complete();
     }
+    super.complete();
+  }
 }
 
 export { flatMap, mergeMap };

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;;;;"}
+{"version":3,"file":"merge-map.mjs","sources":["../../../src/core/operators/merge-map.mts"],"sourcesContent":["import { Arr, Optional } from 'ts-data-forge';\nimport { AsyncChildObservableClass } from '../class/index.mjs';\nimport {\n  type DropInitialValueOperator,\n  type MergeMapOperatorObservable,\n  type Observable,\n  type Subscription,\n  type UpdateToken,\n} from '../types/index.mjs';\n\n/**\n * Projects each source value to an observable and merges all inner observables.\n * Unlike `switchMap`, does not cancel previous inner observables.\n *\n * @template A - The type of values from the source\n * @template B - The type of values from the projected observable\n * @param mapToObservable - A function that maps each source value to an observable\n * @returns An operator that merges mapped observables\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  input$      A                          B              C\n * //  inner A     A1    A2    A3\n * //  inner B                                B1    B2             B3\n * //  inner C                                              C1         C2    C3\n * //  result$     A1    A2    A3              B1    B2      C1    B3   C2    C3\n * //\n * //  Explanation:\n * //  - mergeMap creates an inner observable for each source value\n * //  - Unlike switchMap, previous inner observables are NOT cancelled\n * //  - B's inner continues even after C arrives (B3 is still emitted)\n * //  - All inner observables run concurrently and their results are merged\n *\n * const input$ = source<string>();\n *\n * const result$ = input$.pipe(\n *   mergeMap((letter) => {\n *     const inner$ = source<string>();\n *\n *     setTimeout(() => {\n *       inner$.next(`${letter}1`);\n *     }, 10);\n *\n *     setTimeout(() => {\n *       inner$.next(`${letter}2`);\n *     }, 110);\n *\n *     setTimeout(() => {\n *       inner$.next(`${letter}3`);\n *     }, 210);\n *\n *     return inner$;\n *   }),\n * );\n *\n * const valueHistory: string[] = [];\n *\n * result$.subscribe((value) => {\n *   valueHistory.push(value);\n * });\n *\n * const sleep = (ms: number): Promise<void> =>\n *   new Promise((resolve) => {\n *     setTimeout(resolve, ms);\n *   });\n *\n * // Emit A - inner emits A1, A2, A3 at 10ms, 110ms, 210ms\n * input$.next('A');\n *\n * await sleep(250);\n *\n * assert.deepStrictEqual(valueHistory, ['A1', 'A2', 'A3']);\n *\n * // Emit B - inner starts emitting B1, B2 at 10ms, 110ms\n * input$.next('B');\n *\n * await sleep(150);\n *\n * assert.deepStrictEqual(valueHistory, ['A1', 'A2', 'A3', 'B1', 'B2']);\n *\n * // Emit C while B's inner is still running (B3 at 210ms not yet fired)\n * // Unlike switchMap, B's inner is NOT cancelled\n * input$.next('C');\n *\n * await sleep(250);\n *\n * // B3 appears between C1 and C2, showing the merge behavior\n * assert.deepStrictEqual(valueHistory, [\n *   'A1',\n *   'A2',\n *   'A3',\n *   'B1',\n *   'B2',\n *   'C1',\n *   'B3',\n *   'C2',\n *   'C3',\n * ]);\n * ```\n *\n * @note To improve code readability, consider using `createState` instead of `mergeMap`,\n * subscribing to `parentObservable` and calling `setState` within it.\n */\nexport const mergeMap =\n  <A, B>(\n    mapToObservable: (curr: A) => Observable<B>,\n  ): DropInitialValueOperator<A, B> =>\n  (parentObservable) =>\n    new MergeMapObservableClass(parentObservable, mapToObservable);\n\n/**\n * Alias for `mergeMap`.\n * @see mergeMap\n */\nexport const flatMap = mergeMap;\n\nclass MergeMapObservableClass<A, B>\n  extends AsyncChildObservableClass<B, readonly [A]>\n  implements MergeMapOperatorObservable<A, B>\n{\n  readonly #mapToObservable: (curr: A) => Observable<B>;\n  #mut_observables: readonly Observable<B>[];\n  #mut_subscriptions: readonly Subscription[];\n\n  constructor(\n    parentObservable: Observable<A>,\n    mapToObservable: (curr: A) => Observable<B>,\n  ) {\n    super({\n      parents: [parentObservable],\n      initialValue: Optional.none,\n    });\n\n    this.#mapToObservable = mapToObservable;\n\n    this.#mut_observables = [];\n\n    this.#mut_subscriptions = [];\n  }\n\n  override tryUpdate(updateToken: UpdateToken): void {\n    const par = this.parents[0];\n\n    const sn = par.getSnapshot();\n\n    if (par.updateToken !== updateToken || Optional.isNone(sn)) {\n      return; // skip update\n    }\n\n    const observable = this.#mapToObservable(sn.value);\n\n    this.#mut_observables = Arr.toPushed(this.#mut_observables, observable);\n\n    const subscription = observable.subscribe((curr) => {\n      this.startUpdate(curr);\n    });\n\n    this.#mut_subscriptions = Arr.toPushed(\n      this.#mut_subscriptions,\n      subscription,\n    );\n  }\n\n  override complete(): void {\n    for (const s of this.#mut_subscriptions) {\n      s.unsubscribe();\n    }\n\n    for (const o of this.#mut_observables) {\n      o.complete();\n    }\n\n    super.complete();\n  }\n}\n"],"names":[],"mappings":";;;;AAyGO,MAAM,QAAA,GACX,CACE,eAAA,KAEF,CAAC,qBACC,IAAI,uBAAA,CAAwB,kBAAkB,eAAe;AAM1D,MAAM,OAAA,GAAU;AAEvB,MAAM,gCACI,yBAAA,CAEV;AAAA,EACW,gBAAA;AAAA,EACT,gBAAA;AAAA,EACA,kBAAA;AAAA,EAEA,WAAA,CACE,kBACA,eAAA,EACA;AACA,IAAA,KAAA,CAAM;AAAA,MACJ,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,MAC1B,cAAc,QAAA,CAAS;AAAA,KACxB,CAAA;AAED,IAAA,IAAA,CAAK,gBAAA,GAAmB,eAAA;AAExB,IAAA,IAAA,CAAK,mBAAmB,EAAC;AAEzB,IAAA,IAAA,CAAK,qBAAqB,EAAC;AAAA,EAC7B;AAAA,EAES,UAAU,WAAA,EAAgC;AACjD,IAAA,MAAM,GAAA,GAAM,IAAA,CAAK,OAAA,CAAQ,CAAC,CAAA;AAE1B,IAAA,MAAM,EAAA,GAAK,IAAI,WAAA,EAAY;AAE3B,IAAA,IAAI,IAAI,WAAA,KAAgB,WAAA,IAAe,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAAG;AAC1D,MAAA;AAAA,IACF;AAEA,IAAA,MAAM,UAAA,GAAa,IAAA,CAAK,gBAAA,CAAiB,EAAA,CAAG,KAAK,CAAA;AAEjD,IAAA,IAAA,CAAK,gBAAA,GAAmB,GAAA,CAAI,QAAA,CAAS,IAAA,CAAK,kBAAkB,UAAU,CAAA;AAEtE,IAAA,MAAM,YAAA,GAAe,UAAA,CAAW,SAAA,CAAU,CAAC,IAAA,KAAS;AAClD,MAAA,IAAA,CAAK,YAAY,IAAI,CAAA;AAAA,IACvB,CAAC,CAAA;AAED,IAAA,IAAA,CAAK,qBAAqB,GAAA,CAAI,QAAA;AAAA,MAC5B,IAAA,CAAK,kBAAA;AAAA,MACL;AAAA,KACF;AAAA,EACF;AAAA,EAES,QAAA,GAAiB;AACxB,IAAA,KAAA,MAAW,CAAA,IAAK,KAAK,kBAAA,EAAoB;AACvC,MAAA,CAAA,CAAE,WAAA,EAAY;AAAA,IAChB;AAEA,IAAA,KAAA,MAAW,CAAA,IAAK,KAAK,gBAAA,EAAkB;AACrC,MAAA,CAAA,CAAE,QAAA,EAAS;AAAA,IACb;AAEA,IAAA,KAAA,CAAM,QAAA,EAAS;AAAA,EACjB;AACF;;;;"}

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

@@ -1,3 +1,4 @@
+import { type FixedLengthTuple } from 'ts-type-forge';
 import { type DropInitialValueOperator } from '../types/index.mjs';
 /**
  * Emits the previous and current values as a pair.
@@ -22,7 +23,7 @@ import { type DropInitialValueOperator } from '../types/index.mjs';
  *
  * const pairs$ = num$.pipe(pairwise());
  *
- * const valueHistory: (readonly [number, number])[] = [];
+ * const valueHistory: FixedLengthTuple<2, number>[] = [];
  *
  * pairs$.subscribe(([prev, curr]) => {
  *   valueHistory.push([prev, curr]);
@@ -52,5 +53,5 @@ import { type DropInitialValueOperator } from '../types/index.mjs';
  * ]);
  * ```
  */
-export declare const pairwise: <A>() => DropInitialValueOperator<A, readonly [A, A]>;
+export declare const pairwise: <A>() => DropInitialValueOperator<A, FixedLengthTuple<2, A>>;
 //# sourceMappingURL=pairwise.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"pairwise.d.mts","sourceRoot":"","sources":["../../../src/core/operators/pairwise.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAI9B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,OAAM,wBAAwB,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CACxE,CAAC"}
+{"version":3,"file":"pairwise.d.mts","sourceRoot":"","sources":["../../../src/core/operators/pairwise.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEtD,OAAO,EACL,KAAK,wBAAwB,EAI9B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,OAAM,wBAAwB,CACtD,CAAC,EACD,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAClB,CAAC"}

package/dist/core/operators/pairwise.mjs

@@ -2,86 +2,30 @@ import { Optional } from 'ts-data-forge';
 import { SyncChildObservableClass } from '../class/child-observable-class.mjs';
 import '../utils/id-maker.mjs';
 
-/**
- * Emits the previous and current values as a pair.
- * Does not emit until the source has emitted at least twice.
- *
- * @template A - The type of values from the source
- * @returns An operator that pairs consecutive values
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  num$      1     2     3     4
- * //  pairs$          [1,2] [2,3] [3,4]
- * //
- * //  Explanation:
- * //  - pairwise emits the current and previous values as a tuple
- * //  - Nothing is emitted for the first value (no previous value yet)
- * //  - Useful for tracking changes between consecutive values
- *
- * const num$ = source<number>();
- *
- * const pairs$ = num$.pipe(pairwise());
- *
- * const valueHistory: (readonly [number, number])[] = [];
- *
- * pairs$.subscribe(([prev, curr]) => {
- *   valueHistory.push([prev, curr]);
- * });
- *
- * num$.next(1); // nothing logged
- *
- * assert.deepStrictEqual(valueHistory, []);
- *
- * num$.next(2); // logs: 1, 2
- *
- * assert.deepStrictEqual(valueHistory, [[1, 2]]);
- *
- * num$.next(3); // logs: 2, 3
- *
- * assert.deepStrictEqual(valueHistory, [
- *   [1, 2],
- *   [2, 3],
- * ]);
- *
- * num$.next(4); // logs: 3, 4
- *
- * assert.deepStrictEqual(valueHistory, [
- *   [1, 2],
- *   [2, 3],
- *   [3, 4],
- * ]);
- * ```
- */
 const pairwise = () => f;
 const f = (parentObservable) => new PairwiseObservableClass(parentObservable);
 class PairwiseObservableClass extends SyncChildObservableClass {
-    #mut_previousValue;
-    constructor(parentObservable) {
-        super({
-            parents: [parentObservable],
-            initialValue: Optional.none,
-        });
-        // parentObservable.snapshot has value
-        // if parentObservable is InitializedObservable
-        this.#mut_previousValue = parentObservable.getSnapshot();
+  #mut_previousValue;
+  constructor(parentObservable) {
+    super({
+      parents: [parentObservable],
+      initialValue: Optional.none
+    });
+    this.#mut_previousValue = parentObservable.getSnapshot();
+  }
+  tryUpdate(updateToken) {
+    const par = this.parents[0];
+    const sn = par.getSnapshot();
+    if (par.updateToken !== updateToken || Optional.isNone(sn)) {
+      return;
     }
-    tryUpdate(updateToken) {
-        const par = this.parents[0];
-        const sn = par.getSnapshot();
-        if (par.updateToken !== updateToken || Optional.isNone(sn)) {
-            return; // skip update
-        }
-        const prev = this.#mut_previousValue;
-        const cond = !Optional.isNone(prev);
-        // 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], updateToken);
-        }
+    const prev = this.#mut_previousValue;
+    const cond = !Optional.isNone(prev);
+    this.#mut_previousValue = par.getSnapshot();
+    if (cond) {
+      this.setNext([prev.value, sn.value], updateToken);
     }
+  }
 }
 
 export { pairwise };

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,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;;;;"}
+{"version":3,"file":"pairwise.mjs","sources":["../../../src/core/operators/pairwise.mts"],"sourcesContent":["import { Optional } from 'ts-data-forge';\nimport { type FixedLengthTuple } from 'ts-type-forge';\nimport { SyncChildObservableClass } from '../class/index.mjs';\nimport {\n  type DropInitialValueOperator,\n  type Observable,\n  type PairwiseOperatorObservable,\n  type UpdateToken,\n} from '../types/index.mjs';\n\n/**\n * Emits the previous and current values as a pair.\n * Does not emit until the source has emitted at least twice.\n *\n * @template A - The type of values from the source\n * @returns An operator that pairs consecutive values\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  num$      1     2     3     4\n * //  pairs$          [1,2] [2,3] [3,4]\n * //\n * //  Explanation:\n * //  - pairwise emits the current and previous values as a tuple\n * //  - Nothing is emitted for the first value (no previous value yet)\n * //  - Useful for tracking changes between consecutive values\n *\n * const num$ = source<number>();\n *\n * const pairs$ = num$.pipe(pairwise());\n *\n * const valueHistory: FixedLengthTuple<2, number>[] = [];\n *\n * pairs$.subscribe(([prev, curr]) => {\n *   valueHistory.push([prev, curr]);\n * });\n *\n * num$.next(1); // nothing logged\n *\n * assert.deepStrictEqual(valueHistory, []);\n *\n * num$.next(2); // logs: 1, 2\n *\n * assert.deepStrictEqual(valueHistory, [[1, 2]]);\n *\n * num$.next(3); // logs: 2, 3\n *\n * assert.deepStrictEqual(valueHistory, [\n *   [1, 2],\n *   [2, 3],\n * ]);\n *\n * num$.next(4); // logs: 3, 4\n *\n * assert.deepStrictEqual(valueHistory, [\n *   [1, 2],\n *   [2, 3],\n *   [3, 4],\n * ]);\n * ```\n */\nexport const pairwise = <A,>(): DropInitialValueOperator<\n  A,\n  FixedLengthTuple<2, A>\n> => f;\n\nconst f = <A,>(\n  parentObservable: Observable<A>,\n): Observable<FixedLengthTuple<2, A>> =>\n  new PairwiseObservableClass(parentObservable);\n\nclass PairwiseObservableClass<A>\n  extends SyncChildObservableClass<FixedLengthTuple<2, A>, readonly [A]>\n  implements PairwiseOperatorObservable<A>\n{\n  #mut_previousValue: Optional<A>;\n\n  constructor(parentObservable: Observable<A>) {\n    super({\n      parents: [parentObservable],\n      initialValue: Optional.none,\n    });\n\n    // parentObservable.snapshot has value\n    // if parentObservable is InitializedObservable\n    this.#mut_previousValue = parentObservable.getSnapshot();\n  }\n\n  override tryUpdate(updateToken: UpdateToken): void {\n    const par = this.parents[0];\n\n    const sn = par.getSnapshot();\n\n    if (par.updateToken !== updateToken || Optional.isNone(sn)) {\n      return; // skip update\n    }\n\n    const prev = this.#mut_previousValue;\n\n    const cond = !Optional.isNone(prev);\n\n    // NOTE: Must update before setNext, otherwise Optional.isNone(prev) remains true when tryUpdate is called consecutively\n    this.#mut_previousValue = par.getSnapshot();\n\n    if (cond) {\n      this.setNext([prev.value, sn.value], updateToken);\n    }\n  }\n}\n"],"names":[],"mappings":";;;;AA+DO,MAAM,WAAW,MAGnB;AAEL,MAAM,CAAA,GAAI,CACR,gBAAA,KAEA,IAAI,wBAAwB,gBAAgB,CAAA;AAE9C,MAAM,gCACI,wBAAA,CAEV;AAAA,EACE,kBAAA;AAAA,EAEA,YAAY,gBAAA,EAAiC;AAC3C,IAAA,KAAA,CAAM;AAAA,MACJ,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,MAC1B,cAAc,QAAA,CAAS;AAAA,KACxB,CAAA;AAID,IAAA,IAAA,CAAK,kBAAA,GAAqB,iBAAiB,WAAA,EAAY;AAAA,EACzD;AAAA,EAES,UAAU,WAAA,EAAgC;AACjD,IAAA,MAAM,GAAA,GAAM,IAAA,CAAK,OAAA,CAAQ,CAAC,CAAA;AAE1B,IAAA,MAAM,EAAA,GAAK,IAAI,WAAA,EAAY;AAE3B,IAAA,IAAI,IAAI,WAAA,KAAgB,WAAA,IAAe,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAAG;AAC1D,MAAA;AAAA,IACF;AAEA,IAAA,MAAM,OAAO,IAAA,CAAK,kBAAA;AAElB,IAAA,MAAM,IAAA,GAAO,CAAC,QAAA,CAAS,MAAA,CAAO,IAAI,CAAA;AAGlC,IAAA,IAAA,CAAK,kBAAA,GAAqB,IAAI,WAAA,EAAY;AAE1C,IAAA,IAAI,IAAA,EAAM;AACR,MAAA,IAAA,CAAK,QAAQ,CAAC,IAAA,CAAK,OAAO,EAAA,CAAG,KAAK,GAAG,WAAW,CAAA;AAAA,IAClD;AAAA,EACF;AACF;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"scan.d.mts","sourceRoot":"","sources":["../../../src/core/operators/scan.mts"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,wBAAwB,EAC9B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,eAAO,MAAM,IAAI,GACd,CAAC,EAAE,CAAC,EACH,SAAS,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,CAAC,EAC/B,cAAc,CAAC,KACd,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAEkC,CAAC"}
+{"version":3,"file":"scan.d.mts","sourceRoot":"","sources":["../../../src/core/operators/scan.mts"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,wBAAwB,EAC9B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,eAAO,MAAM,IAAI,GACd,CAAC,EAAE,CAAC,WACM,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,CAAC,gBACjB,CAAC,KACd,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAEkC,CAAC"}

package/dist/core/operators/scan.mjs

@@ -2,76 +2,25 @@ import { Optional } from 'ts-data-forge';
 import { InitializedSyncChildObservableClass } from '../class/child-observable-class.mjs';
 import '../utils/id-maker.mjs';
 
-/**
- * Applies an accumulator function over the source observable and emits each intermediate result.
- * Similar to Array.reduce but emits accumulated value after each source emission.
- *
- * @template A - The type of values from the source
- * @template B - The type of the accumulated value
- * @param reducer - The accumulator function
- * @param initialValue - The initial accumulated value (seed)
- * @returns An operator that accumulates values
- *
- * @example
- * ```ts
- * //  Timeline (accumulating sum):
- * //
- * //  num$    1     2     3     4     5
- * //  sum$    1     3     6     10    15
- * //          |     |     |     |     |
- * //          0+1   1+2   3+3   6+4   10+5
- * //
- * //  Explanation:
- * //  - scan accumulates values over time using a reducer function
- * //  - Starting with seed value 0, each emission adds to the accumulator
- * //  - Similar to Array.reduce, but for streams
- *
- * const num$ = source<number>();
- *
- * const sum$ = num$.pipe(scan((acc, curr) => acc + curr, 0));
- *
- * const valueHistory: number[] = [];
- *
- * sum$.subscribe((x) => {
- *   valueHistory.push(x);
- * });
- *
- * assert.deepStrictEqual(valueHistory, [0]);
- *
- * num$.next(1); // logs: 1
- *
- * assert.deepStrictEqual(valueHistory, [0, 1]);
- *
- * num$.next(2); // logs: 3
- *
- * assert.deepStrictEqual(valueHistory, [0, 1, 3]);
- *
- * num$.next(3); // logs: 6
- *
- * assert.deepStrictEqual(valueHistory, [0, 1, 3, 6]);
- * ```
- */
 const scan = (reducer, initialValue) => (parentObservable) => new ScanObservableClass(parentObservable, reducer, initialValue);
 class ScanObservableClass extends InitializedSyncChildObservableClass {
-    #reducer;
-    constructor(parentObservable, reducer, initialValue) {
-        super({
-            parents: [parentObservable],
-            initialValue: Optional.some(initialValue),
-        });
-        this.#reducer = reducer;
-    }
-    tryUpdate(updateToken) {
-        const par = this.parents[0];
-        const psn = par.getSnapshot();
-        const sn = this.getSnapshot();
-        if (par.updateToken !== updateToken ||
-            Optional.isNone(psn) ||
-            Optional.isNone(sn)) {
-            return; // skip update
-        }
-        this.setNext(this.#reducer(sn.value, psn.value), updateToken);
+  #reducer;
+  constructor(parentObservable, reducer, initialValue) {
+    super({
+      parents: [parentObservable],
+      initialValue: Optional.some(initialValue)
+    });
+    this.#reducer = reducer;
+  }
+  tryUpdate(updateToken) {
+    const par = this.parents[0];
+    const psn = par.getSnapshot();
+    const sn = this.getSnapshot();
+    if (par.updateToken !== updateToken || Optional.isNone(psn) || Optional.isNone(sn)) {
+      return;
     }
+    this.setNext(this.#reducer(sn.value, psn.value), updateToken);
+  }
 }
 
 export { scan };

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,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;;;;"}
+{"version":3,"file":"scan.mjs","sources":["../../../src/core/operators/scan.mts"],"sourcesContent":["import { Optional } from 'ts-data-forge';\nimport { InitializedSyncChildObservableClass } from '../class/index.mjs';\nimport {\n  type Observable,\n  type ScanOperatorObservable,\n  type UpdateToken,\n  type WithInitialValueOperator,\n} from '../types/index.mjs';\n\n/**\n * Applies an accumulator function over the source observable and emits each intermediate result.\n * Similar to Array.reduce but emits accumulated value after each source emission.\n *\n * @template A - The type of values from the source\n * @template B - The type of the accumulated value\n * @param reducer - The accumulator function\n * @param initialValue - The initial accumulated value (seed)\n * @returns An operator that accumulates values\n *\n * @example\n * ```ts\n * //  Timeline (accumulating sum):\n * //\n * //  num$    1     2     3     4     5\n * //  sum$    1     3     6     10    15\n * //          |     |     |     |     |\n * //          0+1   1+2   3+3   6+4   10+5\n * //\n * //  Explanation:\n * //  - scan accumulates values over time using a reducer function\n * //  - Starting with seed value 0, each emission adds to the accumulator\n * //  - Similar to Array.reduce, but for streams\n *\n * const num$ = source<number>();\n *\n * const sum$ = num$.pipe(scan((acc, curr) => acc + curr, 0));\n *\n * const valueHistory: number[] = [];\n *\n * sum$.subscribe((x) => {\n *   valueHistory.push(x);\n * });\n *\n * assert.deepStrictEqual(valueHistory, [0]);\n *\n * num$.next(1); // logs: 1\n *\n * assert.deepStrictEqual(valueHistory, [0, 1]);\n *\n * num$.next(2); // logs: 3\n *\n * assert.deepStrictEqual(valueHistory, [0, 1, 3]);\n *\n * num$.next(3); // logs: 6\n *\n * assert.deepStrictEqual(valueHistory, [0, 1, 3, 6]);\n * ```\n */\nexport const scan =\n  <A, B>(\n    reducer: (acc: B, curr: A) => B,\n    initialValue: B,\n  ): WithInitialValueOperator<A, B> =>\n  (parentObservable) =>\n    new ScanObservableClass(parentObservable, reducer, initialValue);\n\nclass ScanObservableClass<A, B>\n  extends InitializedSyncChildObservableClass<B, readonly [A]>\n  implements ScanOperatorObservable<A, B>\n{\n  readonly #reducer: (acc: B, curr: A) => B;\n\n  constructor(\n    parentObservable: Observable<A>,\n    reducer: (acc: B, curr: A) => B,\n    initialValue: B,\n  ) {\n    super({\n      parents: [parentObservable],\n      initialValue: Optional.some(initialValue),\n    });\n\n    this.#reducer = reducer;\n  }\n\n  override tryUpdate(updateToken: UpdateToken): void {\n    const par = this.parents[0];\n\n    const psn = par.getSnapshot();\n\n    const sn = this.getSnapshot();\n\n    if (\n      par.updateToken !== updateToken ||\n      Optional.isNone(psn) ||\n      Optional.isNone(sn)\n    ) {\n      return; // skip update\n    }\n\n    this.setNext(this.#reducer(sn.value, psn.value), updateToken);\n  }\n}\n"],"names":[],"mappings":";;;;AA0DO,MAAM,IAAA,GACX,CACE,OAAA,EACA,YAAA,KAEF,CAAC,qBACC,IAAI,mBAAA,CAAoB,gBAAA,EAAkB,OAAA,EAAS,YAAY;AAEnE,MAAM,4BACI,mCAAA,CAEV;AAAA,EACW,QAAA;AAAA,EAET,WAAA,CACE,gBAAA,EACA,OAAA,EACA,YAAA,EACA;AACA,IAAA,KAAA,CAAM;AAAA,MACJ,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,MAC1B,YAAA,EAAc,QAAA,CAAS,IAAA,CAAK,YAAY;AAAA,KACzC,CAAA;AAED,IAAA,IAAA,CAAK,QAAA,GAAW,OAAA;AAAA,EAClB;AAAA,EAES,UAAU,WAAA,EAAgC;AACjD,IAAA,MAAM,GAAA,GAAM,IAAA,CAAK,OAAA,CAAQ,CAAC,CAAA;AAE1B,IAAA,MAAM,GAAA,GAAM,IAAI,WAAA,EAAY;AAE5B,IAAA,MAAM,EAAA,GAAK,KAAK,WAAA,EAAY;AAE5B,IAAA,IACE,GAAA,CAAI,WAAA,KAAgB,WAAA,IACpB,QAAA,CAAS,MAAA,CAAO,GAAG,CAAA,IACnB,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAClB;AACA,MAAA;AAAA,IACF;AAEA,IAAA,IAAA,CAAK,OAAA,CAAQ,KAAK,QAAA,CAAS,EAAA,CAAG,OAAO,GAAA,CAAI,KAAK,GAAG,WAAW,CAAA;AAAA,EAC9D;AACF;;;;"}

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

@@ -65,5 +65,5 @@ export declare const skipIfNoChange: <A>(eq?: (x: A, y: A) => boolean) => KeepIn
  * Alias for `skipIfNoChange`.
  * @see skipIfNoChange
  */
-export declare const distinctUntilChanged: <A>(eq?: (x: A, y: A) => boolean) => KeepInitialValueOperator<A, A>;
+export declare const distinctUntilChanged: typeof skipIfNoChange;
 //# sourceMappingURL=skip-if-no-change.d.mts.map

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}
+{"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,OAC1B,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,KAC1B,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAMQ,CAAC;AAEzC;;;GAGG;AACH,eAAO,MAAM,oBAAoB,uBAAiB,CAAC"}

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

@@ -2,102 +2,38 @@ import { Optional } from 'ts-data-forge';
 import { SyncChildObservableClass } from '../class/child-observable-class.mjs';
 import '../utils/id-maker.mjs';
 
-/**
- * Skips emissions if the value hasn't changed from the previous emission.
- * Uses a custom equality function or Object.is by default.
- *
- * @template A - The type of values from the source
- * @param eq - Equality comparison function (default: Object.is)
- * @returns An operator that skips duplicate consecutive values
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  num$      1     1     2     2     1     2     3     2
- * //  distinct$ 1           2           1     2     3     2
- * //
- * //  Explanation:
- * //  - skipIfNoChange filters out consecutive duplicate values
- * //  - Uses strict equality (===) for comparison
- * //  - Only emits when the value actually changes
- *
- * const num$ = source<number>();
- *
- * const distinct$ = num$.pipe(skipIfNoChange());
- *
- * const valueHistory: number[] = [];
- *
- * distinct$.subscribe((x) => {
- *   valueHistory.push(x);
- * });
- *
- * num$.next(1); // logs: 1
- *
- * assert.deepStrictEqual(valueHistory, [1]);
- *
- * num$.next(1); // nothing logged
- *
- * assert.deepStrictEqual(valueHistory, [1]);
- *
- * num$.next(2); // logs: 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(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)) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-((parentObservable) => new SkipIfNoChangeObservableClass(parentObservable, eq));
-/**
- * Alias for `skipIfNoChange`.
- * @see skipIfNoChange
- */
+const skipIfNoChange = (eq = (x, y) => Object.is(x, y)) => (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  ((parentObservable) => new SkipIfNoChangeObservableClass(
+    parentObservable,
+    eq
+  ))
+);
 const distinctUntilChanged = skipIfNoChange;
 class SkipIfNoChangeObservableClass extends SyncChildObservableClass {
-    #eq;
-    #mut_previousValue;
-    constructor(parentObservable, eq) {
-        super({
-            parents: [parentObservable],
-            initialValue: parentObservable.getSnapshot(),
-        });
-        // parentObservable.snapshot has value
-        // if parentObservable is InitializedObservable
-        this.#mut_previousValue = parentObservable.getSnapshot();
-        this.#eq = eq;
+  #eq;
+  #mut_previousValue;
+  constructor(parentObservable, eq) {
+    super({
+      parents: [parentObservable],
+      initialValue: parentObservable.getSnapshot()
+    });
+    this.#mut_previousValue = parentObservable.getSnapshot();
+    this.#eq = eq;
+  }
+  tryUpdate(updateToken) {
+    const par = this.parents[0];
+    const sn = par.getSnapshot();
+    if (par.updateToken !== updateToken || Optional.isNone(sn)) {
+      return;
     }
-    tryUpdate(updateToken) {
-        const par = this.parents[0];
-        const sn = par.getSnapshot();
-        if (par.updateToken !== updateToken || Optional.isNone(sn)) {
-            return; // skip update
-        }
-        const prev = this.#mut_previousValue;
-        const cond = Optional.isNone(prev) || !this.#eq(prev.value, sn.value);
-        // 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, updateToken);
-        }
+    const prev = this.#mut_previousValue;
+    const cond = Optional.isNone(prev) || !this.#eq(prev.value, sn.value);
+    this.#mut_previousValue = sn;
+    if (cond) {
+      this.setNext(sn.value, updateToken);
     }
+  }
 }
 
 export { distinctUntilChanged, skipIfNoChange };

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;;;;"}
+{"version":3,"file":"skip-if-no-change.mjs","sources":["../../../src/core/operators/skip-if-no-change.mts"],"sourcesContent":["import { Optional } from 'ts-data-forge';\nimport { SyncChildObservableClass } from '../class/index.mjs';\nimport {\n  type KeepInitialValueOperator,\n  type Observable,\n  type SkipIfNoChangeOperatorObservable,\n  type UpdateToken,\n} from '../types/index.mjs';\n\n/**\n * Skips emissions if the value hasn't changed from the previous emission.\n * Uses a custom equality function or Object.is by default.\n *\n * @template A - The type of values from the source\n * @param eq - Equality comparison function (default: Object.is)\n * @returns An operator that skips duplicate consecutive values\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  num$      1     1     2     2     1     2     3     2\n * //  distinct$ 1           2           1     2     3     2\n * //\n * //  Explanation:\n * //  - skipIfNoChange filters out consecutive duplicate values\n * //  - Uses strict equality (===) for comparison\n * //  - Only emits when the value actually changes\n *\n * const num$ = source<number>();\n *\n * const distinct$ = num$.pipe(skipIfNoChange());\n *\n * const valueHistory: number[] = [];\n *\n * distinct$.subscribe((x) => {\n *   valueHistory.push(x);\n * });\n *\n * num$.next(1); // logs: 1\n *\n * assert.deepStrictEqual(valueHistory, [1]);\n *\n * num$.next(1); // nothing logged\n *\n * assert.deepStrictEqual(valueHistory, [1]);\n *\n * num$.next(2); // logs: 2\n *\n * assert.deepStrictEqual(valueHistory, [1, 2]);\n *\n * num$.next(2); // nothing logged\n *\n * num$.next(1); // logs: 1\n *\n * assert.deepStrictEqual(valueHistory, [1, 2, 1]);\n *\n * num$.next(2); // logs: 2\n *\n * assert.deepStrictEqual(valueHistory, [1, 2, 1, 2]);\n *\n * num$.next(3); // logs: 3\n *\n * assert.deepStrictEqual(valueHistory, [1, 2, 1, 2, 3]);\n *\n * num$.next(2); // logs: 2\n *\n * assert.deepStrictEqual(valueHistory, [1, 2, 1, 2, 3, 2]);\n * ```\n */\nexport const skipIfNoChange = <A,>(\n  eq: (x: A, y: A) => boolean = (x, y) => Object.is(x, y),\n): KeepInitialValueOperator<A, A> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  ((parentObservable) =>\n    new SkipIfNoChangeObservableClass(\n      parentObservable,\n      eq,\n    )) as KeepInitialValueOperator<A, A>;\n\n/**\n * Alias for `skipIfNoChange`.\n * @see skipIfNoChange\n */\nexport const distinctUntilChanged = skipIfNoChange;\n\nclass SkipIfNoChangeObservableClass<A>\n  extends SyncChildObservableClass<A, readonly [A]>\n  implements SkipIfNoChangeOperatorObservable<A>\n{\n  readonly #eq: (x: A, y: A) => boolean;\n  #mut_previousValue: Optional<A>;\n\n  constructor(parentObservable: Observable<A>, eq: (x: A, y: A) => boolean) {\n    super({\n      parents: [parentObservable],\n      initialValue: parentObservable.getSnapshot(),\n    });\n\n    // parentObservable.snapshot has value\n    // if parentObservable is InitializedObservable\n    this.#mut_previousValue = parentObservable.getSnapshot();\n\n    this.#eq = eq;\n  }\n\n  override tryUpdate(updateToken: UpdateToken): void {\n    const par = this.parents[0];\n\n    const sn = par.getSnapshot();\n\n    if (par.updateToken !== updateToken || Optional.isNone(sn)) {\n      return; // skip update\n    }\n\n    const prev = this.#mut_previousValue;\n\n    const cond = Optional.isNone(prev) || !this.#eq(prev.value, sn.value);\n\n    // NOTE: Must update before setNext, otherwise Optional.isNone(prev) remains true when tryUpdate is called consecutively\n    this.#mut_previousValue = sn;\n\n    if (cond) {\n      this.setNext(sn.value, updateToken);\n    }\n  }\n}\n"],"names":[],"mappings":";;;;AAsEO,MAAM,cAAA,GAAiB,CAC5B,EAAA,GAA8B,CAAC,GAAG,CAAA,KAAM,MAAA,CAAO,EAAA,CAAG,CAAA,EAAG,CAAC,CAAA;AAAA;AAAA,GAGrD,CAAC,qBACA,IAAI,6BAAA;AAAA,IACF,gBAAA;AAAA,IACA;AAAA,GACF;AAAA;AAMG,MAAM,oBAAA,GAAuB;AAEpC,MAAM,sCACI,wBAAA,CAEV;AAAA,EACW,GAAA;AAAA,EACT,kBAAA;AAAA,EAEA,WAAA,CAAY,kBAAiC,EAAA,EAA6B;AACxE,IAAA,KAAA,CAAM;AAAA,MACJ,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,MAC1B,YAAA,EAAc,iBAAiB,WAAA;AAAY,KAC5C,CAAA;AAID,IAAA,IAAA,CAAK,kBAAA,GAAqB,iBAAiB,WAAA,EAAY;AAEvD,IAAA,IAAA,CAAK,GAAA,GAAM,EAAA;AAAA,EACb;AAAA,EAES,UAAU,WAAA,EAAgC;AACjD,IAAA,MAAM,GAAA,GAAM,IAAA,CAAK,OAAA,CAAQ,CAAC,CAAA;AAE1B,IAAA,MAAM,EAAA,GAAK,IAAI,WAAA,EAAY;AAE3B,IAAA,IAAI,IAAI,WAAA,KAAgB,WAAA,IAAe,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAAG;AAC1D,MAAA;AAAA,IACF;AAEA,IAAA,MAAM,OAAO,IAAA,CAAK,kBAAA;AAElB,IAAA,MAAM,IAAA,GAAO,QAAA,CAAS,MAAA,CAAO,IAAI,CAAA,IAAK,CAAC,IAAA,CAAK,GAAA,CAAI,IAAA,CAAK,KAAA,EAAO,EAAA,CAAG,KAAK,CAAA;AAGpE,IAAA,IAAA,CAAK,kBAAA,GAAqB,EAAA;AAE1B,IAAA,IAAI,IAAA,EAAM;AACR,MAAA,IAAA,CAAK,OAAA,CAAQ,EAAA,CAAG,KAAA,EAAO,WAAW,CAAA;AAAA,IACpC;AAAA,EACF;AACF;;;;"}