synstate 1.0.2 → 2.0.1

package/dist/core/operators/audit.mjs

@@ -2,142 +2,48 @@ import { Optional } from 'ts-data-forge';
 import { AsyncChildObservableClass } from '../class/child-observable-class.mjs';
 import '../utils/id-maker.mjs';
 
-/**
- * Ignores source values for duration milliseconds, then emits the most recent value from the source Observable, then repeats this process.
- *
- * Unlike `throttle` which emits the first value, `audit` emits the last value.
- *
- * @template A - The type of values from the source
- * @param milliSeconds - The audit time window in milliseconds
- * @returns An operator that audits emissions from the observable
- *
- * @example
- * ```ts
- * //  Timeline (250ms audit):
- * //
- * //  Time(x50ms)  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0
- * //
- * //  input$       0       2   3                   9   10  11  12  13  14
- * //               |- 250ms -> |- 250ms ->         |- 250ms -> |- 250ms ->
- * //  audited$               2           3                   11          14   (emitted at end of window)
- * //
- * //  Explanation:
- * //  - audit emits the LAST value received during each time window
- * //  - Unlike throttle (which emits the FIRST value), audit emits the LAST
- * //  - Useful when you want the most recent value after a burst of events
- *
- * const input$ = source<number>();
- *
- * const audited$ = input$.pipe(audit(250));
- *
- * const valueHistory: number[] = [];
- *
- * audited$.subscribe((value) => {
- *   valueHistory.push(value);
- * });
- *
- * const sleep = (ms: number): Promise<void> =>
- *   new Promise((resolve) => {
- *     setTimeout(resolve, ms);
- *   });
- *
- * input$.next(0);
- *
- * await sleep(200);
- *
- * input$.next(2);
- *
- * assert.deepStrictEqual(valueHistory, []);
- *
- * await sleep(100);
- *
- * assert.deepStrictEqual(valueHistory, [2]);
- *
- * input$.next(3);
- *
- * await sleep(300);
- *
- * assert.deepStrictEqual(valueHistory, [2, 3]);
- *
- * await sleep(300);
- *
- * input$.next(9);
- *
- * await sleep(100);
- *
- * input$.next(10);
- *
- * await sleep(100);
- *
- * input$.next(11);
- *
- * assert.deepStrictEqual(valueHistory, [2, 3]);
- *
- * await sleep(100);
- *
- * assert.deepStrictEqual(valueHistory, [2, 3, 11]);
- *
- * input$.next(12);
- *
- * await sleep(100);
- *
- * input$.next(13);
- *
- * assert.deepStrictEqual(valueHistory, [2, 3, 11]);
- *
- * await sleep(100);
- *
- * input$.next(14);
- *
- * assert.deepStrictEqual(valueHistory, [2, 3, 11]);
- *
- * await sleep(100);
- *
- * assert.deepStrictEqual(valueHistory, [2, 3, 11, 14]);
- * ```
- */
-const audit = (milliSeconds) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-((parentObservable) => new AuditObservableClass(parentObservable, milliSeconds));
+const audit = (milliSeconds) => (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  ((parentObservable) => new AuditObservableClass(
+    parentObservable,
+    milliSeconds
+  ))
+);
 class AuditObservableClass extends AsyncChildObservableClass {
-    #milliSeconds;
-    #mut_timerId;
-    #mut_isSkipping;
-    constructor(parentObservable, milliSeconds) {
-        super({
-            parents: [parentObservable],
-            initialValue: parentObservable.getSnapshot(),
-        });
-        this.#mut_isSkipping = false;
-        this.#mut_timerId = undefined;
-        this.#milliSeconds = milliSeconds;
+  #milliSeconds;
+  #mut_timerId;
+  #mut_isSkipping;
+  constructor(parentObservable, milliSeconds) {
+    super({
+      parents: [parentObservable],
+      initialValue: parentObservable.getSnapshot()
+    });
+    this.#mut_isSkipping = false;
+    this.#mut_timerId = void 0;
+    this.#milliSeconds = milliSeconds;
+  }
+  #resetTimer() {
+    if (this.#mut_timerId !== void 0) {
+      clearTimeout(this.#mut_timerId);
     }
-    tryUpdate(updateToken) {
-        const par = this.parents[0];
-        if (par.updateToken !== updateToken ||
-            Optional.isNone(par.getSnapshot()) ||
-            this.#mut_isSkipping) {
-            return; // skip update
-        }
-        // set timer
-        this.#mut_isSkipping = true;
-        this.#mut_timerId = setTimeout(() => {
-            const sn = par.getSnapshot();
-            if (Optional.isNone(sn))
-                return;
-            this.startUpdate(sn.value);
-            this.#mut_isSkipping = false;
-        }, this.#milliSeconds);
-    }
-    #resetTimer() {
-        if (this.#mut_timerId !== undefined) {
-            clearTimeout(this.#mut_timerId);
-        }
-    }
-    complete() {
-        this.#resetTimer();
-        super.complete();
+  }
+  tryUpdate(updateToken) {
+    const par = this.parents[0];
+    if (par.updateToken !== updateToken || Optional.isNone(par.getSnapshot()) || this.#mut_isSkipping) {
+      return;
     }
+    this.#mut_isSkipping = true;
+    this.#mut_timerId = setTimeout(() => {
+      const sn = par.getSnapshot();
+      if (Optional.isNone(sn)) return;
+      this.startUpdate(sn.value);
+      this.#mut_isSkipping = false;
+    }, this.#milliSeconds);
+  }
+  complete() {
+    this.#resetTimer();
+    super.complete();
+  }
 }
 
 export { audit };

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

@@ -1 +1 @@
-{"version":3,"file":"audit.mjs","sources":["../../../src/core/operators/audit.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6FG;AACI,MAAM,KAAK,GAAG,CACnB,YAAoB;AAEpB;AACA,CAAC,CAAC,gBAAgB,KAChB,IAAI,oBAAoB,CACtB,gBAAgB,EAChB,YAAY,CACb;AAEL,MAAM,oBACJ,SAAQ,yBAA0C,CAAA;AAGzC,IAAA,aAAa;AACtB,IAAA,YAAY;AACZ,IAAA,eAAe;IAEf,WAAA,CAAY,gBAA+B,EAAE,YAAoB,EAAA;AAC/D,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;AAC3B,YAAA,YAAY,EAAE,gBAAgB,CAAC,WAAW,EAAE;AAC7C,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,eAAe,GAAG,KAAK;AAE5B,QAAA,IAAI,CAAC,YAAY,GAAG,SAAS;AAE7B,QAAA,IAAI,CAAC,aAAa,GAAG,YAAY;IACnC;AAES,IAAA,SAAS,CAAC,WAAwB,EAAA;QACzC,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAE3B,QAAA,IACE,GAAG,CAAC,WAAW,KAAK,WAAW;AAC/B,YAAA,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC;YAClC,IAAI,CAAC,eAAe,EACpB;AACA,YAAA,OAAO;QACT;;AAGA,QAAA,IAAI,CAAC,eAAe,GAAG,IAAI;AAE3B,QAAA,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,MAAK;AAClC,YAAA,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE;AAE5B,YAAA,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;gBAAE;AAEzB,YAAA,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC,KAAK,CAAC;AAE1B,YAAA,IAAI,CAAC,eAAe,GAAG,KAAK;AAC9B,QAAA,CAAC,EAAE,IAAI,CAAC,aAAa,CAAC;IACxB;IAEA,WAAW,GAAA;AACT,QAAA,IAAI,IAAI,CAAC,YAAY,KAAK,SAAS,EAAE;AACnC,YAAA,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC;QACjC;IACF;IAES,QAAQ,GAAA;QACf,IAAI,CAAC,WAAW,EAAE;QAElB,KAAK,CAAC,QAAQ,EAAE;IAClB;AACD;;;;"}
+{"version":3,"file":"audit.mjs","sources":["../../../src/core/operators/audit.mts"],"sourcesContent":["import { Optional } from 'ts-data-forge';\nimport { AsyncChildObservableClass } from '../class/index.mjs';\nimport {\n  type AuditOperatorObservable,\n  type KeepInitialValueOperator,\n  type Observable,\n  type TimerId,\n  type UpdateToken,\n} from '../types/index.mjs';\n\n/**\n * Ignores source values for duration milliseconds, then emits the most recent value from the source Observable, then repeats this process.\n *\n * Unlike `throttle` which emits the first value, `audit` emits the last value.\n *\n * @template A - The type of values from the source\n * @param milliSeconds - The audit time window in milliseconds\n * @returns An operator that audits emissions from the observable\n *\n * @example\n * ```ts\n * //  Timeline (250ms audit):\n * //\n * //  Time(x50ms)  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0\n * //\n * //  input$       0       2   3                   9   10  11  12  13  14\n * //               |- 250ms -> |- 250ms ->         |- 250ms -> |- 250ms ->\n * //  audited$               2           3                   11          14   (emitted at end of window)\n * //\n * //  Explanation:\n * //  - audit emits the LAST value received during each time window\n * //  - Unlike throttle (which emits the FIRST value), audit emits the LAST\n * //  - Useful when you want the most recent value after a burst of events\n *\n * const input$ = source<number>();\n *\n * const audited$ = input$.pipe(audit(250));\n *\n * const valueHistory: number[] = [];\n *\n * audited$.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 * input$.next(0);\n *\n * await sleep(200);\n *\n * input$.next(2);\n *\n * assert.deepStrictEqual(valueHistory, []);\n *\n * await sleep(100);\n *\n * assert.deepStrictEqual(valueHistory, [2]);\n *\n * input$.next(3);\n *\n * await sleep(300);\n *\n * assert.deepStrictEqual(valueHistory, [2, 3]);\n *\n * await sleep(300);\n *\n * input$.next(9);\n *\n * await sleep(100);\n *\n * input$.next(10);\n *\n * await sleep(100);\n *\n * input$.next(11);\n *\n * assert.deepStrictEqual(valueHistory, [2, 3]);\n *\n * await sleep(100);\n *\n * assert.deepStrictEqual(valueHistory, [2, 3, 11]);\n *\n * input$.next(12);\n *\n * await sleep(100);\n *\n * input$.next(13);\n *\n * assert.deepStrictEqual(valueHistory, [2, 3, 11]);\n *\n * await sleep(100);\n *\n * input$.next(14);\n *\n * assert.deepStrictEqual(valueHistory, [2, 3, 11]);\n *\n * await sleep(100);\n *\n * assert.deepStrictEqual(valueHistory, [2, 3, 11, 14]);\n * ```\n */\nexport const audit = <A,>(\n  milliSeconds: number,\n): KeepInitialValueOperator<A, A> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  ((parentObservable) =>\n    new AuditObservableClass(\n      parentObservable,\n      milliSeconds,\n    )) as KeepInitialValueOperator<A, A>;\n\nclass AuditObservableClass<A>\n  extends AsyncChildObservableClass<A, readonly [A]>\n  implements AuditOperatorObservable<A>\n{\n  readonly #milliSeconds: number;\n  #mut_timerId: TimerId | undefined;\n  #mut_isSkipping: boolean;\n\n  constructor(parentObservable: Observable<A>, milliSeconds: number) {\n    super({\n      parents: [parentObservable],\n      initialValue: parentObservable.getSnapshot(),\n    });\n\n    this.#mut_isSkipping = false;\n\n    this.#mut_timerId = undefined;\n\n    this.#milliSeconds = milliSeconds;\n  }\n\n  #resetTimer(): void {\n    if (this.#mut_timerId !== undefined) {\n      clearTimeout(this.#mut_timerId);\n    }\n  }\n\n  override tryUpdate(updateToken: UpdateToken): void {\n    const par = this.parents[0];\n\n    if (\n      par.updateToken !== updateToken ||\n      Optional.isNone(par.getSnapshot()) ||\n      this.#mut_isSkipping\n    ) {\n      return; // skip update\n    }\n\n    // set timer\n    this.#mut_isSkipping = true;\n\n    this.#mut_timerId = setTimeout(() => {\n      const sn = par.getSnapshot();\n\n      if (Optional.isNone(sn)) return;\n\n      this.startUpdate(sn.value);\n\n      this.#mut_isSkipping = false;\n    }, this.#milliSeconds);\n  }\n\n  override complete(): void {\n    this.#resetTimer();\n\n    super.complete();\n  }\n}\n"],"names":[],"mappings":";;;;AAwGO,MAAM,QAAQ,CACnB,YAAA;AAAA;AAAA,GAGC,CAAC,qBACA,IAAI,oBAAA;AAAA,IACF,gBAAA;AAAA,IACA;AAAA,GACF;AAAA;AAEJ,MAAM,6BACI,yBAAA,CAEV;AAAA,EACW,aAAA;AAAA,EACT,YAAA;AAAA,EACA,eAAA;AAAA,EAEA,WAAA,CAAY,kBAAiC,YAAA,EAAsB;AACjE,IAAA,KAAA,CAAM;AAAA,MACJ,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,MAC1B,YAAA,EAAc,iBAAiB,WAAA;AAAY,KAC5C,CAAA;AAED,IAAA,IAAA,CAAK,eAAA,GAAkB,KAAA;AAEvB,IAAA,IAAA,CAAK,YAAA,GAAe,MAAA;AAEpB,IAAA,IAAA,CAAK,aAAA,GAAgB,YAAA;AAAA,EACvB;AAAA,EAEA,WAAA,GAAoB;AAClB,IAAA,IAAI,IAAA,CAAK,iBAAiB,MAAA,EAAW;AACnC,MAAA,YAAA,CAAa,KAAK,YAAY,CAAA;AAAA,IAChC;AAAA,EACF;AAAA,EAES,UAAU,WAAA,EAAgC;AACjD,IAAA,MAAM,GAAA,GAAM,IAAA,CAAK,OAAA,CAAQ,CAAC,CAAA;AAE1B,IAAA,IACE,GAAA,CAAI,WAAA,KAAgB,WAAA,IACpB,QAAA,CAAS,MAAA,CAAO,IAAI,WAAA,EAAa,CAAA,IACjC,IAAA,CAAK,eAAA,EACL;AACA,MAAA;AAAA,IACF;AAGA,IAAA,IAAA,CAAK,eAAA,GAAkB,IAAA;AAEvB,IAAA,IAAA,CAAK,YAAA,GAAe,WAAW,MAAM;AACnC,MAAA,MAAM,EAAA,GAAK,IAAI,WAAA,EAAY;AAE3B,MAAA,IAAI,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAAG;AAEzB,MAAA,IAAA,CAAK,WAAA,CAAY,GAAG,KAAK,CAAA;AAEzB,MAAA,IAAA,CAAK,eAAA,GAAkB,KAAA;AAAA,IACzB,CAAA,EAAG,KAAK,aAAa,CAAA;AAAA,EACvB;AAAA,EAES,QAAA,GAAiB;AACxB,IAAA,IAAA,CAAK,WAAA,EAAY;AAEjB,IAAA,KAAA,CAAM,QAAA,EAAS;AAAA,EACjB;AACF;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"debounce.d.mts","sourceRoot":"","sources":["../../../src/core/operators/debounce.mts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,wBAAwB,EAI9B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoFG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EACxB,cAAc,MAAM,KACnB,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAMQ,CAAC"}
+{"version":3,"file":"debounce.d.mts","sourceRoot":"","sources":["../../../src/core/operators/debounce.mts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,wBAAwB,EAI9B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoFG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,gBACV,MAAM,KACnB,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAMQ,CAAC"}

package/dist/core/operators/debounce.mjs

@@ -2,128 +2,45 @@ import { Optional } from 'ts-data-forge';
 import { AsyncChildObservableClass } from '../class/child-observable-class.mjs';
 import '../utils/id-maker.mjs';
 
-/**
- * Delays emissions from the source observable until a specified time has passed without another emission.
- * Useful for handling user input events like typing or scrolling.
- *
- * @template A - The type of values from the source
- * @param milliSeconds - The debounce duration in milliseconds
- * @returns An operator that debounces the observable
- *
- * @example
- * ```ts
- * //  Timeline (250ms debounce):
- * //
- * //  Time(x50ms)  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0
- * //
- * //  input$       0       2   3                   9   10  11  12  13  14
- * //                               |- 250ms ->                         |- 250ms ->
- * //  debounced$                   3                                             14   (emitted after 250ms silence)
- * //
- * //  Explanation:
- * //  - debounce emits the latest value AFTER a quiet period with no new emissions
- * //  - Unlike audit (which uses a fixed window), debounce resets the timer on every emission
- * //  - Useful for search-as-you-type and form validation
- *
- * const input$ = source<number>();
- *
- * const debounced$ = input$.pipe(debounce(250));
- *
- * const valueHistory: number[] = [];
- *
- * debounced$.subscribe((value) => {
- *   valueHistory.push(value);
- * });
- *
- * const sleep = (ms: number): Promise<void> =>
- *   new Promise((resolve) => {
- *     setTimeout(resolve, ms);
- *   });
- *
- * input$.next(0);
- *
- * await sleep(200);
- *
- * input$.next(2);
- *
- * await sleep(100);
- *
- * input$.next(3);
- *
- * assert.deepStrictEqual(valueHistory, []);
- *
- * await sleep(300);
- *
- * assert.deepStrictEqual(valueHistory, [3]);
- *
- * await sleep(300);
- *
- * input$.next(9);
- *
- * await sleep(100);
- *
- * input$.next(10);
- *
- * await sleep(100);
- *
- * input$.next(11);
- *
- * await sleep(100);
- *
- * input$.next(12);
- *
- * await sleep(100);
- *
- * input$.next(13);
- *
- * await sleep(100);
- *
- * input$.next(14);
- *
- * assert.deepStrictEqual(valueHistory, [3]);
- *
- * await sleep(300);
- *
- * assert.deepStrictEqual(valueHistory, [3, 14]);
- * ```
- */
-const debounce = (milliSeconds) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-((parentObservable) => new DebounceObservableClass(parentObservable, milliSeconds));
+const debounce = (milliSeconds) => (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  ((parentObservable) => new DebounceObservableClass(
+    parentObservable,
+    milliSeconds
+  ))
+);
 class DebounceObservableClass extends AsyncChildObservableClass {
-    #milliSeconds;
-    #mut_timerId;
-    constructor(parentObservable, milliSeconds) {
-        super({
-            parents: [parentObservable],
-            initialValue: parentObservable.getSnapshot(),
-        });
-        this.#mut_timerId = undefined;
-        this.#milliSeconds = milliSeconds;
+  #milliSeconds;
+  #mut_timerId;
+  constructor(parentObservable, milliSeconds) {
+    super({
+      parents: [parentObservable],
+      initialValue: parentObservable.getSnapshot()
+    });
+    this.#mut_timerId = void 0;
+    this.#milliSeconds = milliSeconds;
+  }
+  #resetTimer() {
+    if (this.#mut_timerId !== void 0) {
+      clearTimeout(this.#mut_timerId);
     }
-    tryUpdate(updateToken) {
-        const par = this.parents[0];
-        const sn = par.getSnapshot();
-        if (par.updateToken !== updateToken || Optional.isNone(sn)) {
-            return; // skip update
-        }
-        this.#resetTimer();
-        // set timer
-        this.#mut_timerId = setTimeout(() => {
-            if (Optional.isNone(sn))
-                return;
-            this.startUpdate(sn.value);
-        }, this.#milliSeconds);
-    }
-    #resetTimer() {
-        if (this.#mut_timerId !== undefined) {
-            clearTimeout(this.#mut_timerId);
-        }
-    }
-    complete() {
-        this.#resetTimer();
-        super.complete();
+  }
+  tryUpdate(updateToken) {
+    const par = this.parents[0];
+    const sn = par.getSnapshot();
+    if (par.updateToken !== updateToken || Optional.isNone(sn)) {
+      return;
     }
+    this.#resetTimer();
+    this.#mut_timerId = setTimeout(() => {
+      if (Optional.isNone(sn)) return;
+      this.startUpdate(sn.value);
+    }, this.#milliSeconds);
+  }
+  complete() {
+    this.#resetTimer();
+    super.complete();
+  }
 }
 
 export { debounce };

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

@@ -1 +1 @@
-{"version":3,"file":"debounce.mjs","sources":["../../../src/core/operators/debounce.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoFG;AACI,MAAM,QAAQ,GAAG,CACtB,YAAoB;AAEpB;AACA,CAAC,CAAC,gBAAgB,KAChB,IAAI,uBAAuB,CACzB,gBAAgB,EAChB,YAAY,CACb;AAEL,MAAM,uBACJ,SAAQ,yBAA0C,CAAA;AAGzC,IAAA,aAAa;AACtB,IAAA,YAAY;IAEZ,WAAA,CAAY,gBAA+B,EAAE,YAAoB,EAAA;AAC/D,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;AAC3B,YAAA,YAAY,EAAE,gBAAgB,CAAC,WAAW,EAAE;AAC7C,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,YAAY,GAAG,SAAS;AAE7B,QAAA,IAAI,CAAC,aAAa,GAAG,YAAY;IACnC;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,IAAI,CAAC,WAAW,EAAE;;AAGlB,QAAA,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,MAAK;AAClC,YAAA,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;gBAAE;AAEzB,YAAA,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC,KAAK,CAAC;AAC5B,QAAA,CAAC,EAAE,IAAI,CAAC,aAAa,CAAC;IACxB;IAEA,WAAW,GAAA;AACT,QAAA,IAAI,IAAI,CAAC,YAAY,KAAK,SAAS,EAAE;AACnC,YAAA,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC;QACjC;IACF;IAES,QAAQ,GAAA;QACf,IAAI,CAAC,WAAW,EAAE;QAElB,KAAK,CAAC,QAAQ,EAAE;IAClB;AACD;;;;"}
+{"version":3,"file":"debounce.mjs","sources":["../../../src/core/operators/debounce.mts"],"sourcesContent":["import { Optional } from 'ts-data-forge';\nimport { AsyncChildObservableClass } from '../class/index.mjs';\nimport {\n  type DebounceOperatorObservable,\n  type KeepInitialValueOperator,\n  type Observable,\n  type TimerId,\n  type UpdateToken,\n} from '../types/index.mjs';\n\n/**\n * Delays emissions from the source observable until a specified time has passed without another emission.\n * Useful for handling user input events like typing or scrolling.\n *\n * @template A - The type of values from the source\n * @param milliSeconds - The debounce duration in milliseconds\n * @returns An operator that debounces the observable\n *\n * @example\n * ```ts\n * //  Timeline (250ms debounce):\n * //\n * //  Time(x50ms)  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0\n * //\n * //  input$       0       2   3                   9   10  11  12  13  14\n * //                               |- 250ms ->                         |- 250ms ->\n * //  debounced$                   3                                             14   (emitted after 250ms silence)\n * //\n * //  Explanation:\n * //  - debounce emits the latest value AFTER a quiet period with no new emissions\n * //  - Unlike audit (which uses a fixed window), debounce resets the timer on every emission\n * //  - Useful for search-as-you-type and form validation\n *\n * const input$ = source<number>();\n *\n * const debounced$ = input$.pipe(debounce(250));\n *\n * const valueHistory: number[] = [];\n *\n * debounced$.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 * input$.next(0);\n *\n * await sleep(200);\n *\n * input$.next(2);\n *\n * await sleep(100);\n *\n * input$.next(3);\n *\n * assert.deepStrictEqual(valueHistory, []);\n *\n * await sleep(300);\n *\n * assert.deepStrictEqual(valueHistory, [3]);\n *\n * await sleep(300);\n *\n * input$.next(9);\n *\n * await sleep(100);\n *\n * input$.next(10);\n *\n * await sleep(100);\n *\n * input$.next(11);\n *\n * await sleep(100);\n *\n * input$.next(12);\n *\n * await sleep(100);\n *\n * input$.next(13);\n *\n * await sleep(100);\n *\n * input$.next(14);\n *\n * assert.deepStrictEqual(valueHistory, [3]);\n *\n * await sleep(300);\n *\n * assert.deepStrictEqual(valueHistory, [3, 14]);\n * ```\n */\nexport const debounce = <A,>(\n  milliSeconds: number,\n): KeepInitialValueOperator<A, A> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  ((parentObservable) =>\n    new DebounceObservableClass(\n      parentObservable,\n      milliSeconds,\n    )) as KeepInitialValueOperator<A, A>;\n\nclass DebounceObservableClass<A>\n  extends AsyncChildObservableClass<A, readonly [A]>\n  implements DebounceOperatorObservable<A>\n{\n  readonly #milliSeconds: number;\n  #mut_timerId: TimerId | undefined;\n\n  constructor(parentObservable: Observable<A>, milliSeconds: number) {\n    super({\n      parents: [parentObservable],\n      initialValue: parentObservable.getSnapshot(),\n    });\n\n    this.#mut_timerId = undefined;\n\n    this.#milliSeconds = milliSeconds;\n  }\n\n  #resetTimer(): void {\n    if (this.#mut_timerId !== undefined) {\n      clearTimeout(this.#mut_timerId);\n    }\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    this.#resetTimer();\n\n    // set timer\n    this.#mut_timerId = setTimeout(() => {\n      if (Optional.isNone(sn)) return;\n\n      this.startUpdate(sn.value);\n    }, this.#milliSeconds);\n  }\n\n  override complete(): void {\n    this.#resetTimer();\n\n    super.complete();\n  }\n}\n"],"names":[],"mappings":";;;;AA+FO,MAAM,WAAW,CACtB,YAAA;AAAA;AAAA,GAGC,CAAC,qBACA,IAAI,uBAAA;AAAA,IACF,gBAAA;AAAA,IACA;AAAA,GACF;AAAA;AAEJ,MAAM,gCACI,yBAAA,CAEV;AAAA,EACW,aAAA;AAAA,EACT,YAAA;AAAA,EAEA,WAAA,CAAY,kBAAiC,YAAA,EAAsB;AACjE,IAAA,KAAA,CAAM;AAAA,MACJ,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,MAC1B,YAAA,EAAc,iBAAiB,WAAA;AAAY,KAC5C,CAAA;AAED,IAAA,IAAA,CAAK,YAAA,GAAe,MAAA;AAEpB,IAAA,IAAA,CAAK,aAAA,GAAgB,YAAA;AAAA,EACvB;AAAA,EAEA,WAAA,GAAoB;AAClB,IAAA,IAAI,IAAA,CAAK,iBAAiB,MAAA,EAAW;AACnC,MAAA,YAAA,CAAa,KAAK,YAAY,CAAA;AAAA,IAChC;AAAA,EACF;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,IAAA,CAAK,WAAA,EAAY;AAGjB,IAAA,IAAA,CAAK,YAAA,GAAe,WAAW,MAAM;AACnC,MAAA,IAAI,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAAG;AAEzB,MAAA,IAAA,CAAK,WAAA,CAAY,GAAG,KAAK,CAAA;AAAA,IAC3B,CAAA,EAAG,KAAK,aAAa,CAAA;AAAA,EACvB;AAAA,EAES,QAAA,GAAiB;AACxB,IAAA,IAAA,CAAK,WAAA,EAAY;AAEjB,IAAA,KAAA,CAAM,QAAA,EAAS;AAAA,EACjB;AACF;;;;"}

package/dist/core/operators/filter.mjs

@@ -3,35 +3,32 @@ import { SyncChildObservableClass } from '../class/child-observable-class.mjs';
 import '../utils/id-maker.mjs';
 
 function filter(predicate) {
-    return (parentObservable) => new FilterObservableClass(parentObservable, predicate);
+  return (parentObservable) => new FilterObservableClass(parentObservable, predicate);
 }
 class FilterObservableClass extends SyncChildObservableClass {
-    #predicate;
-    #mut_index;
-    constructor(parentObservable, predicate) {
-        super({
-            parents: [parentObservable],
-            initialValue: pipe(parentObservable.getSnapshot()).map((sn) => Optional.isNone(sn)
-                ? Optional.none
-                : predicate(sn.value, -1)
-                    ? sn
-                    : Optional.none).value,
-        });
-        this.#mut_index = -1;
-        this.#predicate = predicate;
+  #predicate;
+  #mut_index;
+  constructor(parentObservable, predicate) {
+    super({
+      parents: [parentObservable],
+      initialValue: pipe(parentObservable.getSnapshot()).map(
+        (sn) => Optional.isNone(sn) ? Optional.none : predicate(sn.value, -1) ? sn : Optional.none
+      ).value
+    });
+    this.#mut_index = -1;
+    this.#predicate = predicate;
+  }
+  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
-        }
-        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, updateToken);
-        }
+    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, updateToken);
     }
+  }
 }
 
 export { filter };

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

@@ -1 +1 @@
-{"version":3,"file":"filter.mjs","sources":["../../../src/core/operators/filter.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AA2EM,SAAU,MAAM,CACpB,SAAsD,EAAA;AAEtD,IAAA,OAAO,CAAC,gBAAgB,KACtB,IAAI,qBAAqB,CAAC,gBAAgB,EAAE,SAAS,CAAC;AAC1D;AAEA,MAAM,qBACJ,SAAQ,wBAAyC,CAAA;AAGxC,IAAA,UAAU;AACnB,IAAA,UAAU;IAEV,WAAA,CACE,gBAA+B,EAC/B,SAAkD,EAAA;AAElD,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;AACtB,sBAAE;AACF,sBAAE,QAAQ,CAAC,IAAI,CACpB,CAAC,KAAK;AACR,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,UAAU,GAAG,EAAE;AAEpB,QAAA,IAAI,CAAC,UAAU,GAAG,SAAS;;AAGpB,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,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,EAAE;YAC9C,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC;;;AAGxC;;;;"}
+{"version":3,"file":"filter.mjs","sources":["../../../src/core/operators/filter.mts"],"sourcesContent":["import {\n  asSafeUint,\n  expectType,\n  Optional,\n  pipe,\n  SafeUint,\n} from 'ts-data-forge';\nimport { SyncChildObservableClass } from '../class/index.mjs';\nimport { source } from '../create/index.mjs';\nimport {\n  type DropInitialValueOperator,\n  type FilterOperatorObservable,\n  type InitializedObservable,\n  type Observable,\n  type UpdateToken,\n} from '../types/index.mjs';\nimport { withInitialValue } from './with-initial-value.mjs';\n\n/**\n * Filters values emitted by the source observable based on a predicate function.\n * Only values that satisfy the predicate will be emitted by the resulting observable.\n *\n * @template A - The type of values from the source\n * @template B - The narrowed type when using type guard\n * @param predicate - A function that tests each value (receives value and index)\n * @returns An operator that filters the observable\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  num$          1     2     3     4     5     6\n * //  even$               2           4           6\n * //\n * //  Explanation:\n * //  - filter passes through only values that satisfy the predicate\n * //  - Only even numbers (2, 4, 6) are emitted\n *\n * const num$ = source<number>();\n *\n * const even$ = num$.pipe(filter((x) => x % 2 === 0));\n *\n * const valueHistory: number[] = [];\n *\n * even$.subscribe((x) => {\n *   valueHistory.push(x);\n * });\n *\n * num$.next(1); // nothing logged\n *\n * num$.next(2); // logs: 2\n *\n * assert.deepStrictEqual(valueHistory, [2]);\n *\n * num$.next(3); // nothing logged\n *\n * num$.next(4); // logs: 4\n *\n * assert.deepStrictEqual(valueHistory, [2, 4]);\n *\n * num$.next(5);\n *\n * num$.next(6);\n *\n * assert.deepStrictEqual(valueHistory, [2, 4, 6]);\n * ```\n */\nexport function filter<A, B extends A>(\n  predicate: (value: A, index: SafeUint | -1) => value is B,\n): DropInitialValueOperator<A, B>;\n\nexport function filter<A>(\n  predicate: (value: A, index: SafeUint | -1) => boolean,\n): DropInitialValueOperator<A, A>;\n\nexport function filter<A>(\n  predicate: (value: A, index: SafeUint | -1) => boolean,\n): DropInitialValueOperator<A, A> {\n  return (parentObservable) =>\n    new FilterObservableClass(parentObservable, predicate);\n}\n\nclass FilterObservableClass<A>\n  extends SyncChildObservableClass<A, readonly [A]>\n  implements FilterOperatorObservable<A>\n{\n  readonly #predicate: (x: A, index: SafeUint | -1) => boolean;\n  #mut_index: SafeUint | -1;\n\n  constructor(\n    parentObservable: Observable<A>,\n    predicate: (x: A, index: SafeUint | -1) => boolean,\n  ) {\n    super({\n      parents: [parentObservable],\n      initialValue: pipe(parentObservable.getSnapshot()).map((sn) =>\n        Optional.isNone(sn)\n          ? Optional.none\n          : predicate(sn.value, -1)\n            ? sn\n            : Optional.none,\n      ).value,\n    });\n\n    this.#mut_index = -1;\n\n    this.#predicate = predicate;\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    this.#mut_index =\n      this.#mut_index === -1 ? asSafeUint(0) : SafeUint.add(1, this.#mut_index);\n\n    if (this.#predicate(sn.value, this.#mut_index)) {\n      this.setNext(sn.value, updateToken);\n    }\n  }\n}\n\nif (import.meta.vitest !== undefined) {\n  test('type test', () => {\n    expect(1).toBe(1); // dummy\n  });\n\n  {\n    const s: Observable<number> = source<number>();\n\n    const _d1 = s.pipe(filter((x) => x % 2 === 0));\n\n    expectType<typeof _d1, Observable<number>>('=');\n  }\n\n  {\n    const s = source<number>();\n\n    const m: InitializedObservable<number> = s.pipe(withInitialValue(0));\n\n    const _d = m.pipe(filter((x) => x % 2 === 0));\n\n    expectType<typeof _d, Observable<number>>('=');\n  }\n}\n"],"names":[],"mappings":";;;;AA2EO,SAAS,OACd,SAAA,EACgC;AAChC,EAAA,OAAO,CAAC,gBAAA,KACN,IAAI,qBAAA,CAAsB,kBAAkB,SAAS,CAAA;AACzD;AAEA,MAAM,8BACI,wBAAA,CAEV;AAAA,EACW,UAAA;AAAA,EACT,UAAA;AAAA,EAEA,WAAA,CACE,kBACA,SAAA,EACA;AACA,IAAA,KAAA,CAAM;AAAA,MACJ,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,MAC1B,YAAA,EAAc,IAAA,CAAK,gBAAA,CAAiB,WAAA,EAAa,CAAA,CAAE,GAAA;AAAA,QAAI,CAAC,EAAA,KACtD,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,GACd,QAAA,CAAS,IAAA,GACT,SAAA,CAAU,EAAA,CAAG,KAAA,EAAO,EAAE,CAAA,GACpB,KACA,QAAA,CAAS;AAAA,OACjB,CAAE;AAAA,KACH,CAAA;AAED,IAAA,IAAA,CAAK,UAAA,GAAa,EAAA;AAElB,IAAA,IAAA,CAAK,UAAA,GAAa,SAAA;AAAA,EAAA;AACpB,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,IAAA;AAGF,IAAA,IAAA,CAAK,UAAA,GACH,IAAA,CAAK,UAAA,KAAe,EAAA,GAAK,UAAA,CAAW,CAAC,CAAA,GAAI,QAAA,CAAS,GAAA,CAAI,CAAA,EAAG,IAAA,CAAK,UAAU,CAAA;AAE1E,IAAA,IAAI,KAAK,UAAA,CAAW,EAAA,CAAG,KAAA,EAAO,IAAA,CAAK,UAAU,CAAA,EAAG;AAC9C,MAAA,IAAA,CAAK,OAAA,CAAQ,EAAA,CAAG,KAAA,EAAO,WAAW,CAAA;AAAA,IAAA;AACpC,EAAA;AAEJ;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"map.d.mts","sourceRoot":"","sources":["../../../src/core/operators/map.mts"],"names":[],"mappings":"AAAA,OAAO,EAAY,QAAQ,EAA0B,MAAM,eAAe,CAAC;AAG3E,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"}
+{"version":3,"file":"map.d.mts","sourceRoot":"","sources":["../../../src/core/operators/map.mts"],"names":[],"mappings":"AAAA,OAAO,EAAY,QAAQ,EAA0B,MAAM,eAAe,CAAC;AAG3E,OAAO,EAEL,KAAK,wBAAwB,EAI9B,MAAM,oBAAoB,CAAC;AAG5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,GAAG,GAAI,CAAC,EAAE,CAAC,SACf,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.mjs

@@ -2,69 +2,36 @@ import { Optional, asSafeUint, SafeUint } from 'ts-data-forge';
 import { SyncChildObservableClass } from '../class/child-observable-class.mjs';
 import '../utils/id-maker.mjs';
 
-/**
- * Transforms each value emitted by the source using a mapping function that also receives the emission index.
- *
- * @template A - The type of values from the source
- * @template B - The type of mapped values
- * @param mapFn - A function that maps each value (receives value and index)
- * @returns An operator that maps values with index
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  num$      "A"      "B"      "C"
- * //  indexed$  "0: A"   "1: B"   "2: C"
- * //
- * //  Explanation:
- * //  - mapWithIndex transforms each value along with its index
- * //  - Index starts at 0 and increments with each emission
- *
- * const num$ = source<string>();
- *
- * const indexed$ = num$.pipe(map((x, i) => `${i}: ${x}`));
- *
- * const valueHistory: string[] = [];
- *
- * indexed$.subscribe((s) => {
- *   valueHistory.push(s);
- * });
- *
- * num$.next('A'); // 0: A
- *
- * num$.next('B'); // 1: B
- *
- * num$.next('C'); // 2: C
- *
- * assert.deepStrictEqual(valueHistory, ['0: A', '1: B', '2: C']);
- * ```
- */
-const map = (mapFn) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-((parentObservable) => new MapObservableClass(parentObservable, mapFn));
-/* implementation */
+const map = (mapFn) => (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  ((parentObservable) => new MapObservableClass(
+    parentObservable,
+    mapFn
+  ))
+);
 class MapObservableClass extends SyncChildObservableClass {
-    #mapFn;
-    #mut_index;
-    constructor(parentObservable, mapFn) {
-        super({
-            parents: [parentObservable],
-            initialValue: Optional.map(parentObservable.getSnapshot(), (x) => mapFn(x, -1)),
-        });
-        this.#mut_index = -1;
-        this.#mapFn = mapFn;
-    }
-    tryUpdate(updateToken) {
-        const par = this.parents[0];
-        const sn = par.getSnapshot();
-        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), updateToken);
+  #mapFn;
+  #mut_index;
+  constructor(parentObservable, mapFn) {
+    super({
+      parents: [parentObservable],
+      initialValue: Optional.map(
+        parentObservable.getSnapshot(),
+        (x) => mapFn(x, -1)
+      )
+    });
+    this.#mut_index = -1;
+    this.#mapFn = mapFn;
+  }
+  tryUpdate(updateToken) {
+    const par = this.parents[0];
+    const sn = par.getSnapshot();
+    if (par.updateToken !== updateToken || Optional.isNone(sn)) {
+      return;
     }
+    this.#mut_index = this.#mut_index === -1 ? asSafeUint(0) : SafeUint.add(1, this.#mut_index);
+    this.setNext(this.#mapFn(sn.value, this.#mut_index), updateToken);
+  }
 }
 
 export { map };

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

@@ -1 +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;;;;"}
+{"version":3,"file":"map.mjs","sources":["../../../src/core/operators/map.mts"],"sourcesContent":["import { Optional, SafeUint, asSafeUint, expectType } from 'ts-data-forge';\nimport { SyncChildObservableClass } from '../class/index.mjs';\nimport { source } from '../create/index.mjs';\nimport {\n  type InitializedObservable,\n  type KeepInitialValueOperator,\n  type MapOperatorObservable,\n  type Observable,\n  type UpdateToken,\n} from '../types/index.mjs';\nimport { withInitialValue } from './with-initial-value.mjs';\n\n/**\n * Transforms each value emitted by the source using a mapping function that also receives the emission index.\n *\n * @template A - The type of values from the source\n * @template B - The type of mapped values\n * @param mapFn - A function that maps each value (receives value and index)\n * @returns An operator that maps values with index\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  num$      \"A\"      \"B\"      \"C\"\n * //  indexed$  \"0: A\"   \"1: B\"   \"2: C\"\n * //\n * //  Explanation:\n * //  - mapWithIndex transforms each value along with its index\n * //  - Index starts at 0 and increments with each emission\n *\n * const num$ = source<string>();\n *\n * const indexed$ = num$.pipe(map((x, i) => `${i}: ${x}`));\n *\n * const valueHistory: string[] = [];\n *\n * indexed$.subscribe((s) => {\n *   valueHistory.push(s);\n * });\n *\n * num$.next('A'); // 0: A\n *\n * num$.next('B'); // 1: B\n *\n * num$.next('C'); // 2: C\n *\n * assert.deepStrictEqual(valueHistory, ['0: A', '1: B', '2: C']);\n * ```\n */\nexport const map = <A, B>(\n  mapFn: (x: A, index: SafeUint | -1) => B,\n): KeepInitialValueOperator<A, B> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  ((parentObservable) =>\n    new MapObservableClass(\n      parentObservable,\n      mapFn,\n    )) as KeepInitialValueOperator<A, B>;\n\n/* implementation */\n\nclass MapObservableClass<A, B>\n  extends SyncChildObservableClass<B, readonly [A]>\n  implements MapOperatorObservable<A, B>\n{\n  readonly #mapFn: (x: A, index: SafeUint | -1) => B;\n  #mut_index: SafeUint | -1;\n\n  constructor(\n    parentObservable: Observable<A>,\n    mapFn: (x: A, index: SafeUint | -1) => B,\n  ) {\n    super({\n      parents: [parentObservable],\n      initialValue: Optional.map(parentObservable.getSnapshot(), (x) =>\n        mapFn(x, -1),\n      ),\n    });\n\n    this.#mut_index = -1;\n\n    this.#mapFn = mapFn;\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    this.#mut_index =\n      this.#mut_index === -1 ? asSafeUint(0) : SafeUint.add(1, this.#mut_index);\n\n    this.setNext(this.#mapFn(sn.value, this.#mut_index), updateToken);\n  }\n}\n\nif (import.meta.vitest !== undefined) {\n  test('type test', () => {\n    expect(1).toBe(1); // dummy\n  });\n\n  {\n    const s: Observable<number> = source<number>();\n\n    const _d1 = s.pipe(map((x, i) => x + i));\n\n    expectType<typeof _d1, Observable<number>>('=');\n  }\n\n  {\n    const s = source<number>();\n\n    const m: InitializedObservable<number> = s.pipe(withInitialValue(0));\n\n    const _d = m.pipe(map((x, i) => x + i));\n\n    expectType<typeof _d, InitializedObservable<number>>('=');\n  }\n}\n"],"names":[],"mappings":";;;;AAkDO,MAAM,MAAM,CACjB,KAAA;AAAA;AAAA,GAGC,CAAC,qBACA,IAAI,kBAAA;AAAA,IACF,gBAAA;AAAA,IACA;AAAA,GACF;AAAA;AAIJ,MAAM,2BACI,wBAAA,CAEV;AAAA,EACW,MAAA;AAAA,EACT,UAAA;AAAA,EAEA,WAAA,CACE,kBACA,KAAA,EACA;AACA,IAAA,KAAA,CAAM;AAAA,MACJ,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,MAC1B,cAAc,QAAA,CAAS,GAAA;AAAA,QAAI,iBAAiB,WAAA,EAAY;AAAA,QAAG,CAAC,CAAA,KAC1D,KAAA,CAAM,CAAA,EAAG,EAAE;AAAA;AACb,KACD,CAAA;AAED,IAAA,IAAA,CAAK,UAAA,GAAa,EAAA;AAElB,IAAA,IAAA,CAAK,MAAA,GAAS,KAAA;AAAA,EAAA;AAChB,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,IAAA;AAGF,IAAA,IAAA,CAAK,UAAA,GACH,IAAA,CAAK,UAAA,KAAe,EAAA,GAAK,UAAA,CAAW,CAAC,CAAA,GAAI,QAAA,CAAS,GAAA,CAAI,CAAA,EAAG,IAAA,CAAK,UAAU,CAAA;AAE1E,IAAA,IAAA,CAAK,OAAA,CAAQ,KAAK,MAAA,CAAO,EAAA,CAAG,OAAO,IAAA,CAAK,UAAU,GAAG,WAAW,CAAA;AAAA,EAAA;AAEpE;;;;"}

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

@@ -99,5 +99,5 @@ export declare const mergeMap: <A, B>(mapToObservable: (curr: A) => Observable<B
  * Alias for `mergeMap`.
  * @see mergeMap
  */
-export declare const flatMap: <A, B>(mapToObservable: (curr: A) => Observable<B>) => DropInitialValueOperator<A, B>;
+export declare const flatMap: typeof mergeMap;
 //# sourceMappingURL=merge-map.d.mts.map

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}
+{"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,mBACc,CAAC,IAAI,EAAE,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,KAC1C,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAEgC,CAAC;AAEnE;;;GAGG;AACH,eAAO,MAAM,OAAO,iBAAW,CAAC"}