synstate 1.0.1 → 2.0.0

package/dist/core/create/source.mjs

@@ -3,21 +3,18 @@ import '../utils/id-maker.mjs';
 import { RootObservableClass } from '../class/root-observable-class.mjs';
 
 function source(...args) {
-    return new SourceObservableClass(...args);
+  return new SourceObservableClass(...args);
 }
 class SourceObservableClass extends RootObservableClass {
-    constructor(...args) {
-        super({
-            initialValue: Arr.isNonEmpty(args)
-                ? Optional.some(args[0])
-                : Optional.none,
-        });
-    }
-    next(nextValue) {
-        if (this.isCompleted)
-            return;
-        this.startUpdate(nextValue);
-    }
+  constructor(...args) {
+    super({
+      initialValue: Arr.isNonEmpty(args) ? Optional.some(args[0]) : Optional.none
+    });
+  }
+  next(nextValue) {
+    if (this.isCompleted) return;
+    this.startUpdate(nextValue);
+  }
 }
 
 export { source };

package/dist/core/create/source.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"source.mjs","sources":["../../../src/core/create/source.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAoDM,SAAU,MAAM,CAAU,GAAG,IAAkB,EAAA;AACnD,IAAA,OAAO,IAAI,qBAAqB,CAAI,GAAG,IAAI,CAAC;AAC9C;AAEA,MAAM,qBACJ,SAAQ,mBAAsB,CAAA;AAG9B,IAAA,WAAA,CAAY,GAAG,IAAkB,EAAA;AAC/B,QAAA,KAAK,CAAC;AACJ,YAAA,YAAY,EAAE,GAAG,CAAC,UAAU,CAAC,IAAI;kBAC7B,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;kBACrB,QAAQ,CAAC,IAAI;AAClB,SAAA,CAAC;IACJ;AAEA,IAAA,IAAI,CAAC,SAAY,EAAA;QACf,IAAI,IAAI,CAAC,WAAW;YAAE;AAEtB,QAAA,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC;IAC7B;AACD;;;;"}
+{"version":3,"file":"source.mjs","sources":["../../../src/core/create/source.mts"],"sourcesContent":["import { Arr, Optional } from 'ts-data-forge';\nimport { RootObservableClass } from '../class/index.mjs';\nimport {\n  type InitializedSourceObservable,\n  type SourceObservable,\n} from '../types/index.mjs';\n\n/**\n * Creates a new Observable source that can manually emit values.\n * This is the primary way to create root observables that start reactive chains.\n *\n * @template A - The type of values emitted by the source\n * @returns A SourceObservable that can emit values via `.next()` method\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  count$    1     2     3     ...\n * //\n * //  Explanation:\n * //  - source creates a new observable that you can manually emit values to\n * //  - Use .next() to emit values\n * //  - Foundation for building custom observables\n *\n * const count$ = source<number>();\n *\n * const valueHistory: number[] = [];\n *\n * count$.subscribe((value) => {\n *   valueHistory.push(value);\n * });\n *\n * count$.next(1); // logs: 1\n *\n * assert.deepStrictEqual(valueHistory, [1]);\n *\n * count$.next(2); // logs: 2\n *\n * assert.deepStrictEqual(valueHistory, [1, 2]);\n *\n * count$.next(3); // logs: 3\n *\n * assert.deepStrictEqual(valueHistory, [1, 2, 3]);\n * ```\n */\nexport function source<const A>(\n  initialValue: A,\n): InitializedSourceObservable<A>;\n\nexport function source<const A>(): SourceObservable<A>;\n\nexport function source<const A>(...args: readonly A[]): SourceObservable<A> {\n  return new SourceObservableClass<A>(...args);\n}\n\nclass SourceObservableClass<A>\n  extends RootObservableClass<A>\n  implements SourceObservable<A>\n{\n  constructor(...args: readonly A[]) {\n    super({\n      initialValue: Arr.isNonEmpty(args)\n        ? Optional.some(args[0])\n        : Optional.none,\n    });\n  }\n\n  next(nextValue: A): void {\n    if (this.isCompleted) return;\n\n    this.startUpdate(nextValue);\n  }\n}\n"],"names":[],"mappings":";;;;AAoDO,SAAS,UAAmB,IAAA,EAAyC;AAC1E,EAAA,OAAO,IAAI,qBAAA,CAAyB,GAAG,IAAI,CAAA;AAC7C;AAEA,MAAM,8BACI,mBAAA,CAEV;AAAA,EACE,eAAe,IAAA,EAAoB;AACjC,IAAA,KAAA,CAAM;AAAA,MACJ,YAAA,EAAc,GAAA,CAAI,UAAA,CAAW,IAAI,CAAA,GAC7B,QAAA,CAAS,IAAA,CAAK,IAAA,CAAK,CAAC,CAAC,CAAA,GACrB,QAAA,CAAS;AAAA,KACd,CAAA;AAAA,EACH;AAAA,EAEA,KAAK,SAAA,EAAoB;AACvB,IAAA,IAAI,KAAK,WAAA,EAAa;AAEtB,IAAA,IAAA,CAAK,YAAY,SAAS,CAAA;AAAA,EAC5B;AACF;;;;"}

package/dist/core/create/timer.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"timer.d.mts","sourceRoot":"","sources":["../../../src/core/create/timer.mts"],"names":[],"mappings":"AAEA,OAAO,EAAgB,KAAK,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAExE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,KAAK,GAChB,cAAc,MAAM,EACpB,UAAU,QAAQ,CAAC;IACjB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC,KACD,eACsE,CAAC"}
+{"version":3,"file":"timer.d.mts","sourceRoot":"","sources":["../../../src/core/create/timer.mts"],"names":[],"mappings":"AAEA,OAAO,EAAgB,KAAK,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAExE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,KAAK,iBACF,MAAM,YACV,QAAQ,CAAC;IACjB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC,KACD,eACsE,CAAC"}

package/dist/core/create/timer.mjs

@@ -2,80 +2,44 @@ import { Optional } from 'ts-data-forge';
 import '../utils/id-maker.mjs';
 import { RootObservableClass } from '../class/root-observable-class.mjs';
 
-/**
- * Creates an observable that emits 0 after a specified delay and then completes.
- *
- * @param milliSeconds - The delay in milliseconds before emission
- * @param startManually - If true, waits for manual start (default: false)
- * @returns An observable that emits after delay
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  Time(ms)  0     ...   1000
- * //  delayed$                X (emits and completes)
- * //
- * //  Explanation:
- * //  - timer emits once after the specified delay, then completes
- * //  - Useful for delayed actions or timeouts
- *
- * const delayed$ = timer(100);
- *
- * const valueHistory: number[] = [];
- *
- * await new Promise<void>((resolve) => {
- *   delayed$.subscribe(
- *     () => {
- *       valueHistory.push(1);
- *     },
- *     () => {
- *       resolve();
- *     },
- *   );
- * });
- *
- * assert.deepStrictEqual(valueHistory, [1]);
- * ```
- */
 const timer = (milliSeconds, options) => new TimerObservableClass(milliSeconds, options?.startManually ?? false);
 class TimerObservableClass extends RootObservableClass {
-    #milliSeconds;
-    #mut_timerId;
-    #mut_isStarted;
-    constructor(milliSeconds, startManually) {
-        super({ initialValue: Optional.none });
-        this.#milliSeconds = milliSeconds;
-        this.#mut_timerId = undefined;
-        this.#mut_isStarted = false;
-        if (!startManually) {
-            this.start();
-        }
+  #milliSeconds;
+  #mut_timerId;
+  #mut_isStarted;
+  constructor(milliSeconds, startManually) {
+    super({ initialValue: Optional.none });
+    this.#milliSeconds = milliSeconds;
+    this.#mut_timerId = void 0;
+    this.#mut_isStarted = false;
+    if (!startManually) {
+      this.start();
     }
-    start() {
-        if (this.#mut_isStarted) {
-            console.warn('cannot start twice');
-            return;
-        }
-        this.#mut_isStarted = true;
-        if (this.isCompleted) {
-            console.warn('cannot restart stopped TimerObservable');
-            return;
-        }
-        this.#mut_timerId = setTimeout(() => {
-            this.startUpdate(0);
-            this.complete();
-        }, this.#milliSeconds);
+  }
+  #resetTimer() {
+    if (this.#mut_timerId !== void 0) {
+      clearTimeout(this.#mut_timerId);
     }
-    #resetTimer() {
-        if (this.#mut_timerId !== undefined) {
-            clearTimeout(this.#mut_timerId);
-        }
+  }
+  start() {
+    if (this.#mut_isStarted) {
+      console.warn("cannot start twice");
+      return;
     }
-    complete() {
-        this.#resetTimer();
-        super.complete();
+    this.#mut_isStarted = true;
+    if (this.isCompleted) {
+      console.warn("cannot restart stopped TimerObservable");
+      return;
     }
+    this.#mut_timerId = setTimeout(() => {
+      this.startUpdate(0);
+      this.complete();
+    }, this.#milliSeconds);
+  }
+  complete() {
+    this.#resetTimer();
+    super.complete();
+  }
 }
 
 export { timer };

package/dist/core/create/timer.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"timer.mjs","sources":["../../../src/core/create/timer.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCG;MACU,KAAK,GAAG,CACnB,YAAoB,EACpB,OAEE,KAEF,IAAI,oBAAoB,CAAC,YAAY,EAAE,OAAO,EAAE,aAAa,IAAI,KAAK;AAExE,MAAM,oBACJ,SAAQ,mBAAsB,CAAA;AAGrB,IAAA,aAAa;AACtB,IAAA,YAAY;AACZ,IAAA,cAAc;IAEd,WAAA,CAAY,YAAoB,EAAE,aAAsB,EAAA;QACtD,KAAK,CAAC,EAAE,YAAY,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC;AAEtC,QAAA,IAAI,CAAC,aAAa,GAAG,YAAY;AAEjC,QAAA,IAAI,CAAC,YAAY,GAAG,SAAS;AAE7B,QAAA,IAAI,CAAC,cAAc,GAAG,KAAK;QAE3B,IAAI,CAAC,aAAa,EAAE;YAClB,IAAI,CAAC,KAAK,EAAE;QACd;IACF;IAEA,KAAK,GAAA;AACH,QAAA,IAAI,IAAI,CAAC,cAAc,EAAE;AACvB,YAAA,OAAO,CAAC,IAAI,CAAC,oBAAoB,CAAC;YAElC;QACF;AAEA,QAAA,IAAI,CAAC,cAAc,GAAG,IAAI;AAE1B,QAAA,IAAI,IAAI,CAAC,WAAW,EAAE;AACpB,YAAA,OAAO,CAAC,IAAI,CAAC,wCAAwC,CAAC;YAEtD;QACF;AAEA,QAAA,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,MAAK;AAClC,YAAA,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;YAEnB,IAAI,CAAC,QAAQ,EAAE;AACjB,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":"timer.mjs","sources":["../../../src/core/create/timer.mts"],"sourcesContent":["import { Optional } from 'ts-data-forge';\nimport { RootObservableClass } from '../class/index.mjs';\nimport { type TimerId, type TimerObservable } from '../types/index.mjs';\n\n/**\n * Creates an observable that emits 0 after a specified delay and then completes.\n *\n * @param milliSeconds - The delay in milliseconds before emission\n * @param startManually - If true, waits for manual start (default: false)\n * @returns An observable that emits after delay\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  Time(ms)  0     ...   1000\n * //  delayed$                X (emits and completes)\n * //\n * //  Explanation:\n * //  - timer emits once after the specified delay, then completes\n * //  - Useful for delayed actions or timeouts\n *\n * const delayed$ = timer(100);\n *\n * const valueHistory: number[] = [];\n *\n * await new Promise<void>((resolve) => {\n *   delayed$.subscribe(\n *     () => {\n *       valueHistory.push(1);\n *     },\n *     () => {\n *       resolve();\n *     },\n *   );\n * });\n *\n * assert.deepStrictEqual(valueHistory, [1]);\n * ```\n */\nexport const timer = (\n  milliSeconds: number,\n  options?: Readonly<{\n    startManually?: boolean;\n  }>,\n): TimerObservable =>\n  new TimerObservableClass(milliSeconds, options?.startManually ?? false);\n\nclass TimerObservableClass\n  extends RootObservableClass<0>\n  implements TimerObservable\n{\n  readonly #milliSeconds: number;\n  #mut_timerId: TimerId | undefined;\n  #mut_isStarted: boolean;\n\n  constructor(milliSeconds: number, startManually: boolean) {\n    super({ initialValue: Optional.none });\n\n    this.#milliSeconds = milliSeconds;\n\n    this.#mut_timerId = undefined;\n\n    this.#mut_isStarted = false;\n\n    if (!startManually) {\n      this.start();\n    }\n  }\n\n  #resetTimer(): void {\n    if (this.#mut_timerId !== undefined) {\n      clearTimeout(this.#mut_timerId);\n    }\n  }\n\n  start(): void {\n    if (this.#mut_isStarted) {\n      console.warn('cannot start twice');\n\n      return;\n    }\n\n    this.#mut_isStarted = true;\n\n    if (this.isCompleted) {\n      console.warn('cannot restart stopped TimerObservable');\n\n      return;\n    }\n\n    this.#mut_timerId = setTimeout(() => {\n      this.startUpdate(0);\n\n      this.complete();\n    }, this.#milliSeconds);\n  }\n\n  override complete(): void {\n    this.#resetTimer();\n\n    super.complete();\n  }\n}\n"],"names":[],"mappings":";;;;AAwCO,MAAM,KAAA,GAAQ,CACnB,YAAA,EACA,OAAA,KAIA,IAAI,oBAAA,CAAqB,YAAA,EAAc,OAAA,EAAS,aAAA,IAAiB,KAAK;AAExE,MAAM,6BACI,mBAAA,CAEV;AAAA,EACW,aAAA;AAAA,EACT,YAAA;AAAA,EACA,cAAA;AAAA,EAEA,WAAA,CAAY,cAAsB,aAAA,EAAwB;AACxD,IAAA,KAAA,CAAM,EAAE,YAAA,EAAc,QAAA,CAAS,IAAA,EAAM,CAAA;AAErC,IAAA,IAAA,CAAK,aAAA,GAAgB,YAAA;AAErB,IAAA,IAAA,CAAK,YAAA,GAAe,MAAA;AAEpB,IAAA,IAAA,CAAK,cAAA,GAAiB,KAAA;AAEtB,IAAA,IAAI,CAAC,aAAA,EAAe;AAClB,MAAA,IAAA,CAAK,KAAA,EAAM;AAAA,IACb;AAAA,EACF;AAAA,EAEA,WAAA,GAAoB;AAClB,IAAA,IAAI,IAAA,CAAK,iBAAiB,MAAA,EAAW;AACnC,MAAA,YAAA,CAAa,KAAK,YAAY,CAAA;AAAA,IAChC;AAAA,EACF;AAAA,EAEA,KAAA,GAAc;AACZ,IAAA,IAAI,KAAK,cAAA,EAAgB;AACvB,MAAA,OAAA,CAAQ,KAAK,oBAAoB,CAAA;AAEjC,MAAA;AAAA,IACF;AAEA,IAAA,IAAA,CAAK,cAAA,GAAiB,IAAA;AAEtB,IAAA,IAAI,KAAK,WAAA,EAAa;AACpB,MAAA,OAAA,CAAQ,KAAK,wCAAwC,CAAA;AAErD,MAAA;AAAA,IACF;AAEA,IAAA,IAAA,CAAK,YAAA,GAAe,WAAW,MAAM;AACnC,MAAA,IAAA,CAAK,YAAY,CAAC,CAAA;AAElB,MAAA,IAAA,CAAK,QAAA,EAAS;AAAA,IAChB,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/audit.d.mts.map

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

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 };