synstate 1.0.2 → 2.0.1

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

@@ -2,93 +2,33 @@ import { pipe, Optional, asSafeUint, SafeUint } from 'ts-data-forge';
 import { SyncChildObservableClass } from '../class/child-observable-class.mjs';
 import '../utils/id-maker.mjs';
 
-/**
- * Emits values from the source observable while the predicate returns true.
- * Completes immediately when the predicate returns false.
- *
- * @template A - The type of values from the source
- * @param predicate - Function to test each value
- * @returns An operator that takes values while the predicate is true
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  num$      1     2     3     4     5     6     1     2 (ignored)
- * //  taken$    1     2     3     4     | (completes)
- * //
- * //  Explanation:
- * //  - takeWhile emits values while the predicate returns true
- * //  - Completes immediately when the predicate returns false
- * //  - No further values are emitted after completion
- *
- * const num$ = source<number>();
- *
- * const taken$ = num$.pipe(takeWhile((x) => x < 5));
- *
- * const valueHistory: number[] = [];
- *
- * taken$.subscribe((x) => {
- *   valueHistory.push(x);
- * });
- *
- * num$.next(1); // logs: 1
- *
- * assert.deepStrictEqual(valueHistory, [1]);
- *
- * num$.next(2); // logs: 2
- *
- * num$.next(3); // logs: 3
- *
- * num$.next(4); // logs: 4
- *
- * assert.deepStrictEqual(valueHistory, [1, 2, 3, 4]);
- *
- * num$.next(5); // nothing logged (completes)
- *
- * assert.deepStrictEqual(valueHistory, [1, 2, 3, 4]);
- *
- * num$.next(6); // nothing logged (already completed)
- *
- * assert.deepStrictEqual(valueHistory, [1, 2, 3, 4]);
- *
- * num$.next(1); // logs: 1
- *
- * assert.deepStrictEqual(valueHistory, [1, 2, 3, 4]);
- * ```
- */
 const takeWhile = (predicate) => (parentObservable) => new TakeWhileObservableClass(parentObservable, predicate);
-/* implementation */
 class TakeWhileObservableClass extends SyncChildObservableClass {
-    #predicate;
-    #mut_index;
-    constructor(parentObservable, predicate) {
-        super({
-            parents: [parentObservable],
-            initialValue: pipe(parentObservable.getSnapshot()).map((par) => Optional.isNone(par)
-                ? Optional.none
-                : predicate(par.value, -1)
-                    ? par
-                    : Optional.none).value,
-        });
-        this.#mut_index = -1;
-        this.#predicate = predicate;
+  #predicate;
+  #mut_index;
+  constructor(parentObservable, predicate) {
+    super({
+      parents: [parentObservable],
+      initialValue: pipe(parentObservable.getSnapshot()).map(
+        (par) => Optional.isNone(par) ? Optional.none : predicate(par.value, -1) ? par : 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);
-        }
-        else {
-            this.complete();
-        }
+    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);
+    } else {
+      this.complete();
     }
+  }
 }
 
 export { takeWhile };

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

@@ -1 +1 @@
-{"version":3,"file":"take-while.mjs","sources":["../../../src/core/operators/take-while.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAkBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDG;AACI,MAAM,SAAS,GACpB,CACE,SAAsD,KAExD,CAAC,gBAAgB,KACf,IAAI,wBAAwB,CAAC,gBAAgB,EAAE,SAAS;AAE5D;AAEA,MAAM,wBACJ,SAAQ,wBAAyC,CAAA;AAGxC,IAAA,UAAU;AACnB,IAAA,UAAU;IAEV,WAAA,CACE,gBAA+B,EAC/B,SAAsD,EAAA;AAEtD,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,YAAY,EAAE,IAAI,CAAC,gBAAgB,CAAC,WAAW,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,KACzD,QAAQ,CAAC,MAAM,CAAC,GAAG;kBACf,QAAQ,CAAC;kBACT,SAAS,CAAC,GAAG,CAAC,KAAK,EAAE,EAAE;AACvB,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;;aAC9B;YACL,IAAI,CAAC,QAAQ,EAAE;;;AAGpB;;;;"}
+{"version":3,"file":"take-while.mjs","sources":["../../../src/core/operators/take-while.mts"],"sourcesContent":["import {\n  Optional,\n  SafeUint,\n  asSafeUint,\n  expectType,\n  pipe,\n} from 'ts-data-forge';\nimport { SyncChildObservableClass } from '../class/index.mjs';\nimport { source } from '../create/index.mjs';\nimport {\n  type DropInitialValueOperator,\n  type InitializedObservable,\n  type Observable,\n  type TakeWhileOperatorObservable,\n  type UpdateToken,\n} from '../types/index.mjs';\nimport { withInitialValue } from './with-initial-value.mjs';\n\n/**\n * Emits values from the source observable while the predicate returns true.\n * Completes immediately when the predicate returns false.\n *\n * @template A - The type of values from the source\n * @param predicate - Function to test each value\n * @returns An operator that takes values while the predicate is true\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  num$      1     2     3     4     5     6     1     2 (ignored)\n * //  taken$    1     2     3     4     | (completes)\n * //\n * //  Explanation:\n * //  - takeWhile emits values while the predicate returns true\n * //  - Completes immediately when the predicate returns false\n * //  - No further values are emitted after completion\n *\n * const num$ = source<number>();\n *\n * const taken$ = num$.pipe(takeWhile((x) => x < 5));\n *\n * const valueHistory: number[] = [];\n *\n * taken$.subscribe((x) => {\n *   valueHistory.push(x);\n * });\n *\n * num$.next(1); // logs: 1\n *\n * assert.deepStrictEqual(valueHistory, [1]);\n *\n * num$.next(2); // logs: 2\n *\n * num$.next(3); // logs: 3\n *\n * num$.next(4); // logs: 4\n *\n * assert.deepStrictEqual(valueHistory, [1, 2, 3, 4]);\n *\n * num$.next(5); // nothing logged (completes)\n *\n * assert.deepStrictEqual(valueHistory, [1, 2, 3, 4]);\n *\n * num$.next(6); // nothing logged (already completed)\n *\n * assert.deepStrictEqual(valueHistory, [1, 2, 3, 4]);\n *\n * num$.next(1); // logs: 1\n *\n * assert.deepStrictEqual(valueHistory, [1, 2, 3, 4]);\n * ```\n */\nexport const takeWhile =\n  <A,>(\n    predicate: (value: A, index: SafeUint | -1) => boolean,\n  ): DropInitialValueOperator<A, A> =>\n  (parentObservable) =>\n    new TakeWhileObservableClass(parentObservable, predicate);\n\n/* implementation */\n\nclass TakeWhileObservableClass<A>\n  extends SyncChildObservableClass<A, readonly [A]>\n  implements TakeWhileOperatorObservable<A>\n{\n  readonly #predicate: (value: A, index: SafeUint | -1) => boolean;\n  #mut_index: SafeUint | -1;\n\n  constructor(\n    parentObservable: Observable<A>,\n    predicate: (value: A, index: SafeUint | -1) => boolean,\n  ) {\n    super({\n      parents: [parentObservable],\n      initialValue: pipe(parentObservable.getSnapshot()).map((par) =>\n        Optional.isNone(par)\n          ? Optional.none\n          : predicate(par.value, -1)\n            ? par\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    } else {\n      this.complete();\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(takeWhile((_, index) => index + 1 <= 3));\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(takeWhile((_, index) => index + 1 <= 3));\n\n    expectType<typeof _d, Observable<number>>('=');\n  }\n}\n"],"names":[],"mappings":";;;;AAyEO,MAAM,SAAA,GACX,CACE,SAAA,KAEF,CAAC,qBACC,IAAI,wBAAA,CAAyB,kBAAkB,SAAS;AAI5D,MAAM,iCACI,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,GAAA,KACtD,QAAA,CAAS,MAAA,CAAO,GAAG,CAAA,GACf,QAAA,CAAS,IAAA,GACT,SAAA,CAAU,GAAA,CAAI,KAAA,EAAO,EAAE,CAAA,GACrB,MACA,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,CACpC,MAAO;AACL,MAAA,IAAA,CAAK,QAAA,EAAS;AAAA,IAAA;AAChB,EAAA;AAEJ;;;;"}

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

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

package/dist/core/operators/throttle.mjs

@@ -2,124 +2,47 @@ import { Optional } from 'ts-data-forge';
 import { SyncChildObservableClass } from '../class/child-observable-class.mjs';
 import '../utils/id-maker.mjs';
 
-/**
- * Emits the first value, then ignores subsequent values for a specified duration.
- * After the duration, the next emission is allowed through.
- *
- * @template A - The type of values from the source
- * @param milliSeconds - The throttle duration in milliseconds
- * @returns An operator that throttles emissions
- *
- * @example
- * ```ts
- * //  Timeline (250ms throttle):
- * //
- * //  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 ->
- * //  throttled$   0           3                   9          12           (emitted at start of window)
- * //
- * //  Explanation:
- * //  - throttle emits the FIRST value received, then ignores subsequent values
- * //    for the specified duration (250ms)
- * //  - Unlike audit (which emits the LAST value), throttle emits the FIRST
- * //  - Useful for rate-limiting scroll/resize events
- *
- * const input$ = source<number>();
- *
- * const throttled$ = input$.pipe(throttle(250));
- *
- * const valueHistory: number[] = [];
- *
- * throttled$.subscribe((value) => {
- *   valueHistory.push(value);
- * });
- *
- * const sleep = (ms: number): Promise<void> =>
- *   new Promise((resolve) => {
- *     setTimeout(resolve, ms);
- *   });
- *
- * input$.next(0);
- *
- * assert.deepStrictEqual(valueHistory, [0]);
- *
- * await sleep(200);
- *
- * input$.next(2);
- *
- * assert.deepStrictEqual(valueHistory, [0]);
- *
- * await sleep(100);
- *
- * input$.next(3);
- *
- * assert.deepStrictEqual(valueHistory, [0, 3]);
- *
- * await sleep(300);
- *
- * input$.next(9);
- *
- * assert.deepStrictEqual(valueHistory, [0, 3, 9]);
- *
- * await sleep(100);
- *
- * input$.next(10);
- *
- * await sleep(100);
- *
- * input$.next(11);
- *
- * assert.deepStrictEqual(valueHistory, [0, 3, 9]);
- *
- * await sleep(100);
- *
- * input$.next(12);
- *
- * assert.deepStrictEqual(valueHistory, [0, 3, 9, 12]);
- * ```
- */
-const throttle = (milliSeconds) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-((parentObservable) => new ThrottleObservableClass(parentObservable, milliSeconds));
+const throttle = (milliSeconds) => (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  ((parentObservable) => new ThrottleObservableClass(
+    parentObservable,
+    milliSeconds
+  ))
+);
 class ThrottleObservableClass extends SyncChildObservableClass {
-    #milliSeconds;
-    #mut_timerId;
-    #mut_isSkipping;
-    constructor(parentObservable, milliSeconds) {
-        super({
-            parents: [parentObservable],
-            initialValue: parentObservable.getSnapshot(),
-        });
-        this.#mut_timerId = undefined;
-        this.#mut_isSkipping = false;
-        this.#milliSeconds = milliSeconds;
+  #milliSeconds;
+  #mut_timerId;
+  #mut_isSkipping;
+  constructor(parentObservable, milliSeconds) {
+    super({
+      parents: [parentObservable],
+      initialValue: parentObservable.getSnapshot()
+    });
+    this.#mut_timerId = void 0;
+    this.#mut_isSkipping = false;
+    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) ||
-            this.#mut_isSkipping) {
-            return; // skip update
-        }
-        this.setNext(sn.value, updateToken);
-        this.#mut_isSkipping = true;
-        // set timer
-        this.#mut_timerId = setTimeout(() => {
-            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];
+    const sn = par.getSnapshot();
+    if (par.updateToken !== updateToken || Optional.isNone(sn) || this.#mut_isSkipping) {
+      return;
     }
+    this.setNext(sn.value, updateToken);
+    this.#mut_isSkipping = true;
+    this.#mut_timerId = setTimeout(() => {
+      this.#mut_isSkipping = false;
+    }, this.#milliSeconds);
+  }
+  complete() {
+    this.#resetTimer();
+    super.complete();
+  }
 }
 
 export { throttle };

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

@@ -1 +1 @@
-{"version":3,"file":"throttle.mjs","sources":["../../../src/core/operators/throttle.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6EG;AACI,MAAM,QAAQ,GAAG,CACtB,YAAoB;AAEpB;AACA,CAAC,CAAC,gBAAgB,KAChB,IAAI,uBAAuB,CACzB,gBAAgB,EAChB,YAAY,CACb;AAEL,MAAM,uBACJ,SAAQ,wBAAyC,CAAA;AAGxC,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,YAAY,GAAG,SAAS;AAE7B,QAAA,IAAI,CAAC,eAAe,GAAG,KAAK;AAE5B,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,IACE,GAAG,CAAC,WAAW,KAAK,WAAW;AAC/B,YAAA,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;YACnB,IAAI,CAAC,eAAe,EACpB;AACA,YAAA,OAAO;QACT;QAEA,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC;AAEnC,QAAA,IAAI,CAAC,eAAe,GAAG,IAAI;;AAG3B,QAAA,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,MAAK;AAClC,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":"throttle.mjs","sources":["../../../src/core/operators/throttle.mts"],"sourcesContent":["import { Optional } from 'ts-data-forge';\nimport { SyncChildObservableClass } from '../class/index.mjs';\nimport {\n  type KeepInitialValueOperator,\n  type Observable,\n  type ThrottleOperatorObservable,\n  type TimerId,\n  type UpdateToken,\n} from '../types/index.mjs';\n\n/**\n * Emits the first value, then ignores subsequent values for a specified duration.\n * After the duration, the next emission is allowed through.\n *\n * @template A - The type of values from the source\n * @param milliSeconds - The throttle duration in milliseconds\n * @returns An operator that throttles emissions\n *\n * @example\n * ```ts\n * //  Timeline (250ms throttle):\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 * //  throttled$   0           3                   9          12           (emitted at start of window)\n * //\n * //  Explanation:\n * //  - throttle emits the FIRST value received, then ignores subsequent values\n * //    for the specified duration (250ms)\n * //  - Unlike audit (which emits the LAST value), throttle emits the FIRST\n * //  - Useful for rate-limiting scroll/resize events\n *\n * const input$ = source<number>();\n *\n * const throttled$ = input$.pipe(throttle(250));\n *\n * const valueHistory: number[] = [];\n *\n * throttled$.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 * assert.deepStrictEqual(valueHistory, [0]);\n *\n * await sleep(200);\n *\n * input$.next(2);\n *\n * assert.deepStrictEqual(valueHistory, [0]);\n *\n * await sleep(100);\n *\n * input$.next(3);\n *\n * assert.deepStrictEqual(valueHistory, [0, 3]);\n *\n * await sleep(300);\n *\n * input$.next(9);\n *\n * assert.deepStrictEqual(valueHistory, [0, 3, 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, [0, 3, 9]);\n *\n * await sleep(100);\n *\n * input$.next(12);\n *\n * assert.deepStrictEqual(valueHistory, [0, 3, 9, 12]);\n * ```\n */\nexport const throttle = <A,>(\n  milliSeconds: number,\n): KeepInitialValueOperator<A, A> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  ((parentObservable) =>\n    new ThrottleObservableClass(\n      parentObservable,\n      milliSeconds,\n    )) as KeepInitialValueOperator<A, A>;\n\nclass ThrottleObservableClass<A>\n  extends SyncChildObservableClass<A, readonly [A]>\n  implements ThrottleOperatorObservable<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_timerId = undefined;\n\n    this.#mut_isSkipping = false;\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 (\n      par.updateToken !== updateToken ||\n      Optional.isNone(sn) ||\n      this.#mut_isSkipping\n    ) {\n      return; // skip update\n    }\n\n    this.setNext(sn.value, updateToken);\n\n    this.#mut_isSkipping = true;\n\n    // set timer\n    this.#mut_timerId = setTimeout(() => {\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":";;;;AAwFO,MAAM,WAAW,CACtB,YAAA;AAAA;AAAA,GAGC,CAAC,qBACA,IAAI,uBAAA;AAAA,IACF,gBAAA;AAAA,IACA;AAAA,GACF;AAAA;AAEJ,MAAM,gCACI,wBAAA,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,YAAA,GAAe,MAAA;AAEpB,IAAA,IAAA,CAAK,eAAA,GAAkB,KAAA;AAEvB,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,IACE,GAAA,CAAI,gBAAgB,WAAA,IACpB,QAAA,CAAS,OAAO,EAAE,CAAA,IAClB,KAAK,eAAA,EACL;AACA,MAAA;AAAA,IACF;AAEA,IAAA,IAAA,CAAK,OAAA,CAAQ,EAAA,CAAG,KAAA,EAAO,WAAW,CAAA;AAElC,IAAA,IAAA,CAAK,eAAA,GAAkB,IAAA;AAGvB,IAAA,IAAA,CAAK,YAAA,GAAe,WAAW,MAAM;AACnC,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/with-buffered-from.d.mts

@@ -57,5 +57,5 @@ export declare const withBufferedFrom: <A, B>(observable: Observable<B>) => Keep
  * Alias for `withBufferedFrom`.
  * @see withBufferedFrom
  */
-export declare const withBuffered: <A, B>(observable: Observable<B>) => KeepInitialValueOperator<A, readonly [A, readonly B[]]>;
+export declare const withBuffered: typeof withBufferedFrom;
 //# sourceMappingURL=with-buffered-from.d.mts.map

package/dist/core/operators/with-buffered-from.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"with-buffered-from.d.mts","sourceRoot":"","sources":["../../../src/core/operators/with-buffered-from.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,UAAU,EAGhB,MAAM,oBAAoB,CAAC;AAG5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,EAAE,CAAC,EACnC,YAAY,UAAU,CAAC,CAAC,CAAC,KACxB,wBAAwB,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC,CAMQ,CAAC;AAElE;;;GAGG;AACH,eAAO,MAAM,YAAY,GAdQ,CAAC,EAAE,CAAC,cACvB,UAAU,CAAC,CAAC,CAAC,KACxB,wBAAwB,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC,CAYb,CAAC"}
+{"version":3,"file":"with-buffered-from.d.mts","sourceRoot":"","sources":["../../../src/core/operators/with-buffered-from.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,UAAU,EAGhB,MAAM,oBAAoB,CAAC;AAG5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,EAAE,CAAC,cACvB,UAAU,CAAC,CAAC,CAAC,KACxB,wBAAwB,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC,CAMQ,CAAC;AAElE;;;GAGG;AACH,eAAO,MAAM,YAAY,yBAAmB,CAAC"}

package/dist/core/operators/with-buffered-from.mjs

@@ -3,99 +3,46 @@ import { SyncChildObservableClass } from '../class/child-observable-class.mjs';
 import '../utils/id-maker.mjs';
 import { maxDepth } from '../utils/max-depth.mjs';
 
-/**
- * Buffers values from the source observable and emits them along with the parent value
- * when the parent emits. The buffer is cleared after each emission.
- *
- * @template A - The type of values from the parent observable
- * @template B - The type of values from the source observable
- * @param observable - The observable whose values will be buffered
- * @returns An operator that emits tuples of [parentValue, bufferedValues]
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  data$       d1    d2    d3    d4    d5    d6    d7    d8
- * //  trigger$                T1                T2                T3
- * //  result$                 [T1,[d1,d2,d3]]   [T2,[d4,d5,d6]]   [T3,[d7,d8]]
- * //
- * //  Explanation:
- * //  - withBufferedFrom collects values from the source observable
- * //  - When the trigger emits, it emits a tuple of [triggerValue, bufferedValues]
- * //  - Buffer is cleared after each emission
- * //  - Useful for batching data collection triggered by events
- *
- * const data$ = source<string>();
- *
- * const trigger$ = source<number>();
- *
- * const result$ = trigger$.pipe(withBufferedFrom(data$));
- *
- * const valueHistory: (readonly [number, readonly string[]])[] = [];
- *
- * result$.subscribe(([triggerValue, bufferedData]) => {
- *   valueHistory.push([triggerValue, bufferedData]);
- * });
- *
- * data$.next('A');
- *
- * data$.next('B');
- *
- * trigger$.next(1);
- *
- * assert.deepStrictEqual(valueHistory, [[1, ['A', 'B']]]);
- *
- * data$.next('C');
- *
- * trigger$.next(2);
- *
- * assert.deepStrictEqual(valueHistory, [
- *   [1, ['A', 'B']],
- *   [2, ['C']],
- * ]);
- * ```
- */
-const withBufferedFrom = (observable) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-((parentObservable) => new WithBufferedFromObservableClass(parentObservable, observable));
-/**
- * Alias for `withBufferedFrom`.
- * @see withBufferedFrom
- */
+const withBufferedFrom = (observable) => (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  ((parentObservable) => new WithBufferedFromObservableClass(
+    parentObservable,
+    observable
+  ))
+);
 const withBuffered = withBufferedFrom;
 class WithBufferedFromObservableClass extends SyncChildObservableClass {
-    #mut_bufferedValues = [];
-    constructor(parentObservable, observable) {
-        super({
-            parents: [parentObservable],
-            depth: 1 + maxDepth([parentObservable, observable]),
-            initialValue: pipe({
-                par: parentObservable.getSnapshot(),
-                me: observable.getSnapshot(),
-            }).map(({ par, me }) => Optional.isNone(par)
-                ? Optional.none
-                : Optional.some([
-                    par.value,
-                    Optional.isNone(me) ? [] : [me.value],
-                ])).value,
-        });
-        observable.subscribe((value) => {
-            this.#mut_bufferedValues = Arr.toPushed(this.#mut_bufferedValues, value);
-        });
-    }
-    tryUpdate(updateToken) {
-        const par = this.parents[0];
-        const sn = par.getSnapshot();
-        if (par.updateToken !== updateToken || Optional.isNone(sn)) {
-            return; // skip update
-        }
-        this.setNext([sn.value, this.#mut_bufferedValues], updateToken);
-        this.#clearBuffer();
-    }
-    #clearBuffer() {
-        this.#mut_bufferedValues = [];
+  #mut_bufferedValues = [];
+  constructor(parentObservable, observable) {
+    super({
+      parents: [parentObservable],
+      depth: 1 + maxDepth([parentObservable, observable]),
+      initialValue: pipe({
+        par: parentObservable.getSnapshot(),
+        me: observable.getSnapshot()
+      }).map(
+        ({ par, me }) => Optional.isNone(par) ? Optional.none : Optional.some([
+          par.value,
+          Optional.isNone(me) ? [] : [me.value]
+        ])
+      ).value
+    });
+    observable.subscribe((value) => {
+      this.#mut_bufferedValues = Arr.toPushed(this.#mut_bufferedValues, value);
+    });
+  }
+  #clearBuffer() {
+    this.#mut_bufferedValues = [];
+  }
+  tryUpdate(updateToken) {
+    const par = this.parents[0];
+    const sn = par.getSnapshot();
+    if (par.updateToken !== updateToken || Optional.isNone(sn)) {
+      return;
     }
+    this.setNext([sn.value, this.#mut_bufferedValues], updateToken);
+    this.#clearBuffer();
+  }
 }
 
 export { withBuffered, withBufferedFrom };

package/dist/core/operators/with-buffered-from.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"with-buffered-from.mjs","sources":["../../../src/core/operators/with-buffered-from.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDG;AACI,MAAM,gBAAgB,GAAG,CAC9B,UAAyB;AAEzB;AACA,CAAC,CAAC,gBAAgB,KAChB,IAAI,+BAA+B,CACjC,gBAAgB,EAChB,UAAU,CACX;AAEL;;;AAGG;AACI,MAAM,YAAY,GAAG;AAE5B,MAAM,+BACJ,SAAQ,wBAAkE,CAAA;IAG1E,mBAAmB,GAAiB,EAAE;IAEtC,WAAA,CAAY,gBAA+B,EAAE,UAAyB,EAAA;AACpE,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,KAAK,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,gBAAgB,EAAE,UAAU,CAAC,CAAC;YACnD,YAAY,EAAE,IAAI,CAAC;AACjB,gBAAA,GAAG,EAAE,gBAAgB,CAAC,WAAW,EAAE;AACnC,gBAAA,EAAE,EAAE,UAAU,CAAC,WAAW,EAAE;AAC7B,aAAA,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,KACjB,QAAQ,CAAC,MAAM,CAAC,GAAG;kBACf,QAAQ,CAAC;AACX,kBAAE,QAAQ,CAAC,IAAI,CAAC;AACZ,oBAAA,GAAG,CAAC,KAAK;AACT,oBAAA,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC;iBAC7B,CAAC,CAChB,CAAC,KAAK;AACR,SAAA,CAAC;AAEF,QAAA,UAAU,CAAC,SAAS,CAAC,CAAC,KAAK,KAAI;AAC7B,YAAA,IAAI,CAAC,mBAAmB,GAAG,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,mBAAmB,EAAE,KAAK,CAAC;AAC1E,QAAA,CAAC,CAAC;IACJ;AAES,IAAA,SAAS,CAAC,WAAwB,EAAA;QACzC,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAE3B,QAAA,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE;AAE5B,QAAA,IAAI,GAAG,CAAC,WAAW,KAAK,WAAW,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE;AAC1D,YAAA,OAAO;QACT;AAEA,QAAA,IAAI,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,mBAAmB,CAAC,EAAE,WAAW,CAAC;QAE/D,IAAI,CAAC,YAAY,EAAE;IACrB;IAEA,YAAY,GAAA;AACV,QAAA,IAAI,CAAC,mBAAmB,GAAG,EAAE;IAC/B;AACD;;;;"}
+{"version":3,"file":"with-buffered-from.mjs","sources":["../../../src/core/operators/with-buffered-from.mts"],"sourcesContent":["import { Arr, Optional, pipe } from 'ts-data-forge';\nimport { SyncChildObservableClass } from '../class/index.mjs';\nimport {\n  type KeepInitialValueOperator,\n  type Observable,\n  type UpdateToken,\n  type WithBufferedFromOperatorObservable,\n} from '../types/index.mjs';\nimport { maxDepth } from '../utils/index.mjs';\n\n/**\n * Buffers values from the source observable and emits them along with the parent value\n * when the parent emits. The buffer is cleared after each emission.\n *\n * @template A - The type of values from the parent observable\n * @template B - The type of values from the source observable\n * @param observable - The observable whose values will be buffered\n * @returns An operator that emits tuples of [parentValue, bufferedValues]\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  data$       d1    d2    d3    d4    d5    d6    d7    d8\n * //  trigger$                T1                T2                T3\n * //  result$                 [T1,[d1,d2,d3]]   [T2,[d4,d5,d6]]   [T3,[d7,d8]]\n * //\n * //  Explanation:\n * //  - withBufferedFrom collects values from the source observable\n * //  - When the trigger emits, it emits a tuple of [triggerValue, bufferedValues]\n * //  - Buffer is cleared after each emission\n * //  - Useful for batching data collection triggered by events\n *\n * const data$ = source<string>();\n *\n * const trigger$ = source<number>();\n *\n * const result$ = trigger$.pipe(withBufferedFrom(data$));\n *\n * const valueHistory: (readonly [number, readonly string[]])[] = [];\n *\n * result$.subscribe(([triggerValue, bufferedData]) => {\n *   valueHistory.push([triggerValue, bufferedData]);\n * });\n *\n * data$.next('A');\n *\n * data$.next('B');\n *\n * trigger$.next(1);\n *\n * assert.deepStrictEqual(valueHistory, [[1, ['A', 'B']]]);\n *\n * data$.next('C');\n *\n * trigger$.next(2);\n *\n * assert.deepStrictEqual(valueHistory, [\n *   [1, ['A', 'B']],\n *   [2, ['C']],\n * ]);\n * ```\n */\nexport const withBufferedFrom = <A, B>(\n  observable: Observable<B>,\n): KeepInitialValueOperator<A, readonly [A, readonly B[]]> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  ((parentObservable) =>\n    new WithBufferedFromObservableClass(\n      parentObservable,\n      observable,\n    )) as KeepInitialValueOperator<A, readonly [A, readonly B[]]>;\n\n/**\n * Alias for `withBufferedFrom`.\n * @see withBufferedFrom\n */\nexport const withBuffered = withBufferedFrom;\n\nclass WithBufferedFromObservableClass<A, B>\n  extends SyncChildObservableClass<readonly [A, readonly B[]], readonly [A]>\n  implements WithBufferedFromOperatorObservable<A, B>\n{\n  #mut_bufferedValues: readonly B[] = [];\n\n  constructor(parentObservable: Observable<A>, observable: Observable<B>) {\n    super({\n      parents: [parentObservable],\n      depth: 1 + maxDepth([parentObservable, observable]),\n      initialValue: pipe({\n        par: parentObservable.getSnapshot(),\n        me: observable.getSnapshot(),\n      }).map(({ par, me }) =>\n        Optional.isNone(par)\n          ? Optional.none\n          : Optional.some([\n              par.value,\n              Optional.isNone(me) ? [] : [me.value],\n            ] as const),\n      ).value,\n    });\n\n    observable.subscribe((value) => {\n      this.#mut_bufferedValues = Arr.toPushed(this.#mut_bufferedValues, value);\n    });\n  }\n\n  #clearBuffer(): void {\n    this.#mut_bufferedValues = [];\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.setNext([sn.value, this.#mut_bufferedValues], updateToken);\n\n    this.#clearBuffer();\n  }\n}\n"],"names":[],"mappings":";;;;;AA+DO,MAAM,mBAAmB,CAC9B,UAAA;AAAA;AAAA,GAGC,CAAC,qBACA,IAAI,+BAAA;AAAA,IACF,gBAAA;AAAA,IACA;AAAA,GACF;AAAA;AAMG,MAAM,YAAA,GAAe;AAE5B,MAAM,wCACI,wBAAA,CAEV;AAAA,EACE,sBAAoC,EAAC;AAAA,EAErC,WAAA,CAAY,kBAAiC,UAAA,EAA2B;AACtE,IAAA,KAAA,CAAM;AAAA,MACJ,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,MAC1B,OAAO,CAAA,GAAI,QAAA,CAAS,CAAC,gBAAA,EAAkB,UAAU,CAAC,CAAA;AAAA,MAClD,cAAc,IAAA,CAAK;AAAA,QACjB,GAAA,EAAK,iBAAiB,WAAA,EAAY;AAAA,QAClC,EAAA,EAAI,WAAW,WAAA;AAAY,OAC5B,CAAA,CAAE,GAAA;AAAA,QAAI,CAAC,EAAE,GAAA,EAAK,EAAA,EAAG,KAChB,QAAA,CAAS,MAAA,CAAO,GAAG,CAAA,GACf,QAAA,CAAS,IAAA,GACT,QAAA,CAAS,IAAA,CAAK;AAAA,UACZ,GAAA,CAAI,KAAA;AAAA,UACJ,QAAA,CAAS,OAAO,EAAE,CAAA,GAAI,EAAC,GAAI,CAAC,GAAG,KAAK;AAAA,SAC5B;AAAA,OAChB,CAAE;AAAA,KACH,CAAA;AAED,IAAA,UAAA,CAAW,SAAA,CAAU,CAAC,KAAA,KAAU;AAC9B,MAAA,IAAA,CAAK,mBAAA,GAAsB,GAAA,CAAI,QAAA,CAAS,IAAA,CAAK,qBAAqB,KAAK,CAAA;AAAA,IACzE,CAAC,CAAA;AAAA,EACH;AAAA,EAEA,YAAA,GAAqB;AACnB,IAAA,IAAA,CAAK,sBAAsB,EAAC;AAAA,EAC9B;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,QAAQ,CAAC,EAAA,CAAG,OAAO,IAAA,CAAK,mBAAmB,GAAG,WAAW,CAAA;AAE9D,IAAA,IAAA,CAAK,YAAA,EAAa;AAAA,EACpB;AACF;;;;"}

package/dist/core/operators/with-current-value-from.d.mts

@@ -60,5 +60,5 @@ export declare const withCurrentValueFrom: <A, B>(observable: Observable<B>) =>
  * Alias for `withCurrentValueFrom`.
  * @see withCurrentValueFrom
  */
-export declare const withLatestFrom: <A, B>(observable: Observable<B>) => DropInitialValueOperator<A, readonly [A, B]>;
+export declare const withLatestFrom: typeof withCurrentValueFrom;
 //# sourceMappingURL=with-current-value-from.d.mts.map

package/dist/core/operators/with-current-value-from.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"with-current-value-from.d.mts","sourceRoot":"","sources":["../../../src/core/operators/with-current-value-from.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,UAAU,EAGhB,MAAM,oBAAoB,CAAC;AAG5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,eAAO,MAAM,oBAAoB,GAC9B,CAAC,EAAE,CAAC,EACH,YAAY,UAAU,CAAC,CAAC,CAAC,KACxB,wBAAwB,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAEyB,CAAC;AAE1E;;;GAGG;AACH,eAAO,MAAM,cAAc,GAVxB,CAAC,EAAE,CAAC,cACS,UAAU,CAAC,CAAC,CAAC,KACxB,wBAAwB,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAQE,CAAC"}
+{"version":3,"file":"with-current-value-from.d.mts","sourceRoot":"","sources":["../../../src/core/operators/with-current-value-from.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,UAAU,EAGhB,MAAM,oBAAoB,CAAC;AAG5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,eAAO,MAAM,oBAAoB,GAC9B,CAAC,EAAE,CAAC,cACS,UAAU,CAAC,CAAC,CAAC,KACxB,wBAAwB,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAEyB,CAAC;AAE1E;;;GAGG;AACH,eAAO,MAAM,cAAc,6BAAuB,CAAC"}

package/dist/core/operators/with-current-value-from.mjs

@@ -3,94 +3,33 @@ import { SyncChildObservableClass } from '../class/child-observable-class.mjs';
 import '../utils/id-maker.mjs';
 import { maxDepth } from '../utils/max-depth.mjs';
 
-/**
- * Samples the current value from another observable each time the source emits.
- * Emits a tuple of [sourceValue, sampledValue].
- *
- * @template A - The type of values from the source observable
- * @template B - The type of values from the sampled observable
- * @param observable - The observable to sample from
- * @returns An operator that emits tuples of source and sampled values
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  name$     "Alice"           "Bob"               "Charlie"
- * //  age$                25              30
- * //  result$   (skip)          ["Bob",25]           ["Charlie",30]
- * //
- * //  Explanation:
- * //  - withCurrentValueFrom samples the current value from another observable
- * //  - Emits a tuple [sourceValue, sampledValue] each time the SOURCE emits
- * //  - Does NOT emit when the sampled observable (age$) emits
- * //  - Does not emit until both observables have emitted at least once
- * //  - "Alice" is skipped because age$ hasn't emitted yet
- *
- * const name$ = source<string>();
- *
- * const age$ = source<number>();
- *
- * const result$ = name$.pipe(withCurrentValueFrom(age$));
- *
- * const valueHistory: (readonly [string, number])[] = [];
- *
- * result$.subscribe(([name_, currentAge]) => {
- *   valueHistory.push([name_, currentAge]);
- * });
- *
- * name$.next('Alice'); // nothing logged (age$ hasn't emitted)
- *
- * assert.deepStrictEqual(valueHistory, []);
- *
- * age$.next(25);
- *
- * name$.next('Bob'); // logs: Bob is 25 years old
- *
- * assert.deepStrictEqual(valueHistory, [['Bob', 25]]);
- *
- * age$.next(30);
- *
- * name$.next('Charlie'); // logs: Charlie is 30 years old
- *
- * assert.deepStrictEqual(valueHistory, [
- *   ['Bob', 25],
- *   ['Charlie', 30],
- * ]);
- * ```
- */
 const withCurrentValueFrom = (observable) => (parentObservable) => new WithCurrentValueFromObservableClass(parentObservable, observable);
-/**
- * Alias for `withCurrentValueFrom`.
- * @see withCurrentValueFrom
- */
 const withLatestFrom = withCurrentValueFrom;
 class WithCurrentValueFromObservableClass extends SyncChildObservableClass {
-    #observable;
-    constructor(parentObservable, observable) {
-        super({
-            parents: [parentObservable],
-            depth: 1 + maxDepth([parentObservable, observable]),
-            initialValue: pipe({
-                par: parentObservable.getSnapshot(),
-                me: observable.getSnapshot(),
-            }).map(({ me, par }) => Optional.isNone(par) || Optional.isNone(me)
-                ? Optional.none
-                : Optional.some([par.value, me.value])).value,
-        });
-        this.#observable = observable;
-    }
-    tryUpdate(updateToken) {
-        const par = this.parents[0];
-        const ps = par.getSnapshot();
-        if (par.updateToken !== updateToken || Optional.isNone(ps)) {
-            return; // skip update
-        }
-        const curr = this.#observable.getSnapshot();
-        if (Optional.isNone(curr))
-            return; // skip update
-        this.setNext([ps.value, curr.value], updateToken);
+  #observable;
+  constructor(parentObservable, observable) {
+    super({
+      parents: [parentObservable],
+      depth: 1 + maxDepth([parentObservable, observable]),
+      initialValue: pipe({
+        par: parentObservable.getSnapshot(),
+        me: observable.getSnapshot()
+      }).map(
+        ({ me, par }) => Optional.isNone(par) || Optional.isNone(me) ? Optional.none : Optional.some([par.value, me.value])
+      ).value
+    });
+    this.#observable = observable;
+  }
+  tryUpdate(updateToken) {
+    const par = this.parents[0];
+    const ps = par.getSnapshot();
+    if (par.updateToken !== updateToken || Optional.isNone(ps)) {
+      return;
     }
+    const curr = this.#observable.getSnapshot();
+    if (Optional.isNone(curr)) return;
+    this.setNext([ps.value, curr.value], updateToken);
+  }
 }
 
 export { withCurrentValueFrom, withLatestFrom };