synstate 1.0.1 → 2.0.0

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

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

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

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

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

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

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

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

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

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

package/dist/core/operators/skip-until.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"skip-until.d.mts","sourceRoot":"","sources":["../../../src/core/operators/skip-until.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,UAAU,EAGhB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,eAAO,MAAM,SAAS,GACnB,CAAC,EAAG,UAAU,UAAU,CAAC,OAAO,CAAC,KAAG,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAER,CAAC"}
+{"version":3,"file":"skip-until.d.mts","sourceRoot":"","sources":["../../../src/core/operators/skip-until.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,UAAU,EAGhB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,eAAO,MAAM,SAAS,GACnB,CAAC,YAAa,UAAU,CAAC,OAAO,CAAC,KAAG,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAER,CAAC"}

package/dist/core/operators/skip-until.mjs

@@ -2,81 +2,32 @@ import { Optional } from 'ts-data-forge';
 import { SyncChildObservableClass } from '../class/child-observable-class.mjs';
 import '../utils/id-maker.mjs';
 
-/**
- * Skips all values from the source observable until the notifier observable emits.
- *
- * @template A - The type of values from the source
- * @param notifier - An observable that signals when to start emitting
- * @returns An operator that skips values until the notifier emits
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  num$          1     2     3     start   4     5     6
- * //  startNotifier                   X
- * //  skipped$                                4     5     6
- * //                |------ skipped -------|
- * //
- * //  Explanation:
- * //  - skipUntil ignores all values until the notifier emits
- * //  - After the notifier emits, all subsequent values are passed through
- * //  - Opposite of takeUntil (which completes when notifier emits)
- *
- * const num$ = source<number>();
- *
- * const [startNotifier, start_] = createEventEmitter();
- *
- * const skipped$ = num$.pipe(skipUntil(startNotifier));
- *
- * const valueHistory: number[] = [];
- *
- * skipped$.subscribe((x) => {
- *   valueHistory.push(x);
- * });
- *
- * num$.next(1); // nothing logged
- *
- * num$.next(2); // nothing logged
- *
- * assert.deepStrictEqual(valueHistory, []);
- *
- * start_();
- *
- * num$.next(4); // logs: 4
- *
- * assert.deepStrictEqual(valueHistory, [4]);
- *
- * num$.next(5); // logs: 5
- *
- * assert.deepStrictEqual(valueHistory, [4, 5]);
- * ```
- */
 const skipUntil = (notifier) => (parentObservable) => new SkipUntilObservableClass(parentObservable, notifier);
 class SkipUntilObservableClass extends SyncChildObservableClass {
-    #mut_isSkipping;
-    constructor(parentObservable, notifier) {
-        super({
-            parents: [parentObservable],
-            initialValue: Optional.none,
-        });
-        this.#mut_isSkipping = true;
-        notifier.subscribe(() => {
-            this.#mut_isSkipping = false;
-        }, () => {
-            this.#mut_isSkipping = false;
-        });
-    }
-    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);
+  #mut_isSkipping;
+  constructor(parentObservable, notifier) {
+    super({
+      parents: [parentObservable],
+      initialValue: Optional.none
+    });
+    this.#mut_isSkipping = true;
+    notifier.subscribe(
+      () => {
+        this.#mut_isSkipping = false;
+      },
+      () => {
+        this.#mut_isSkipping = false;
+      }
+    );
+  }
+  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);
+  }
 }
 
 export { skipUntil };

package/dist/core/operators/skip-until.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"skip-until.mjs","sources":["../../../src/core/operators/skip-until.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDG;MACU,SAAS,GACpB,CAAK,QAA6B,KAClC,CAAC,gBAAgB,KACf,IAAI,wBAAwB,CAAC,gBAAgB,EAAE,QAAQ;AAE3D,MAAM,wBACJ,SAAQ,wBAAyC,CAAA;AAGjD,IAAA,eAAe;IAEf,WAAA,CAAY,gBAA+B,EAAE,QAA6B,EAAA;AACxE,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,YAAY,EAAE,QAAQ,CAAC,IAAI;AAC5B,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,eAAe,GAAG,IAAI;AAE3B,QAAA,QAAQ,CAAC,SAAS,CAChB,MAAK;AACH,YAAA,IAAI,CAAC,eAAe,GAAG,KAAK;QAC9B,CAAC,EACD,MAAK;AACH,YAAA,IAAI,CAAC,eAAe,GAAG,KAAK;AAC9B,QAAA,CAAC,CACF;IACH;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;IACrC;AACD;;;;"}
+{"version":3,"file":"skip-until.mjs","sources":["../../../src/core/operators/skip-until.mts"],"sourcesContent":["import { Optional } from 'ts-data-forge';\nimport { SyncChildObservableClass } from '../class/index.mjs';\nimport {\n  type DropInitialValueOperator,\n  type Observable,\n  type SkipUntilOperatorObservable,\n  type UpdateToken,\n} from '../types/index.mjs';\n\n/**\n * Skips all values from the source observable until the notifier observable emits.\n *\n * @template A - The type of values from the source\n * @param notifier - An observable that signals when to start emitting\n * @returns An operator that skips values until the notifier emits\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  num$          1     2     3     start   4     5     6\n * //  startNotifier                   X\n * //  skipped$                                4     5     6\n * //                |------ skipped -------|\n * //\n * //  Explanation:\n * //  - skipUntil ignores all values until the notifier emits\n * //  - After the notifier emits, all subsequent values are passed through\n * //  - Opposite of takeUntil (which completes when notifier emits)\n *\n * const num$ = source<number>();\n *\n * const [startNotifier, start_] = createEventEmitter();\n *\n * const skipped$ = num$.pipe(skipUntil(startNotifier));\n *\n * const valueHistory: number[] = [];\n *\n * skipped$.subscribe((x) => {\n *   valueHistory.push(x);\n * });\n *\n * num$.next(1); // nothing logged\n *\n * num$.next(2); // nothing logged\n *\n * assert.deepStrictEqual(valueHistory, []);\n *\n * start_();\n *\n * num$.next(4); // logs: 4\n *\n * assert.deepStrictEqual(valueHistory, [4]);\n *\n * num$.next(5); // logs: 5\n *\n * assert.deepStrictEqual(valueHistory, [4, 5]);\n * ```\n */\nexport const skipUntil =\n  <A,>(notifier: Observable<unknown>): DropInitialValueOperator<A, A> =>\n  (parentObservable) =>\n    new SkipUntilObservableClass(parentObservable, notifier);\n\nclass SkipUntilObservableClass<A>\n  extends SyncChildObservableClass<A, readonly [A]>\n  implements SkipUntilOperatorObservable<A>\n{\n  #mut_isSkipping: boolean;\n\n  constructor(parentObservable: Observable<A>, notifier: Observable<unknown>) {\n    super({\n      parents: [parentObservable],\n      initialValue: Optional.none,\n    });\n\n    this.#mut_isSkipping = true;\n\n    notifier.subscribe(\n      () => {\n        this.#mut_isSkipping = false;\n      },\n      () => {\n        this.#mut_isSkipping = false;\n      },\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}\n"],"names":[],"mappings":";;;;AA2DO,MAAM,SAAA,GACX,CAAK,QAAA,KACL,CAAC,qBACC,IAAI,wBAAA,CAAyB,kBAAkB,QAAQ;AAE3D,MAAM,iCACI,wBAAA,CAEV;AAAA,EACE,eAAA;AAAA,EAEA,WAAA,CAAY,kBAAiC,QAAA,EAA+B;AAC1E,IAAA,KAAA,CAAM;AAAA,MACJ,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,MAC1B,cAAc,QAAA,CAAS;AAAA,KACxB,CAAA;AAED,IAAA,IAAA,CAAK,eAAA,GAAkB,IAAA;AAEvB,IAAA,QAAA,CAAS,SAAA;AAAA,MACP,MAAM;AACJ,QAAA,IAAA,CAAK,eAAA,GAAkB,KAAA;AAAA,MACzB,CAAA;AAAA,MACA,MAAM;AACJ,QAAA,IAAA,CAAK,eAAA,GAAkB,KAAA;AAAA,MACzB;AAAA,KACF;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;AAAA,EACpC;AACF;;;;"}

package/dist/core/operators/skip-while.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"skip-while.d.mts","sourceRoot":"","sources":["../../../src/core/operators/skip-while.mts"],"names":[],"mappings":"AAAA,OAAO,EAAY,QAAQ,EAAoB,MAAM,eAAe,CAAC;AAErE,OAAO,EACL,KAAK,wBAAwB,EAI9B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,eAAO,MAAM,SAAS,GACnB,CAAC,EACA,WAAW,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,GAAG,CAAC,CAAC,KAAK,OAAO,KACrD,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAE2B,CAAC"}
+{"version":3,"file":"skip-while.d.mts","sourceRoot":"","sources":["../../../src/core/operators/skip-while.mts"],"names":[],"mappings":"AAAA,OAAO,EAAY,QAAQ,EAAoB,MAAM,eAAe,CAAC;AAErE,OAAO,EACL,KAAK,wBAAwB,EAI9B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,eAAO,MAAM,SAAS,GACnB,CAAC,aACW,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,GAAG,CAAC,CAAC,KAAK,OAAO,KACrD,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAE2B,CAAC"}

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

@@ -2,98 +2,36 @@ import { pipe, Optional, asSafeUint, SafeUint } from 'ts-data-forge';
 import { SyncChildObservableClass } from '../class/child-observable-class.mjs';
 import '../utils/id-maker.mjs';
 
-/**
- * Skips values from the source observable while the predicate returns true.
- * Once the predicate returns false, all subsequent values pass through.
- *
- * @template A - The type of values from the source
- * @param predicate - Function to test each value
- * @returns An operator that skips values while the predicate is true
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  num$        1     2     3     4     5     6     7     1     2
- * //  skipped$                            5     6     7     1     2
- * //              |-------- skip --------|
- * //
- * //  Explanation:
- * //  - skipWhile skips values while the predicate returns true
- * //  - Once the predicate returns false, all subsequent values pass through
- * //  - Unlike filter, the predicate is never checked again after the first false
- *
- * const num$ = source<number>();
- *
- * const skipped$ = num$.pipe(skipWhile((x) => x < 5));
- *
- * const valueHistory: number[] = [];
- *
- * skipped$.subscribe((x) => {
- *   valueHistory.push(x);
- * });
- *
- * num$.next(1); // nothing logged
- *
- * num$.next(2); // nothing logged
- *
- * num$.next(3); // nothing logged
- *
- * num$.next(4); // nothing logged
- *
- * num$.next(5); // logs: 5
- *
- * assert.deepStrictEqual(valueHistory, [5]);
- *
- * num$.next(6); // logs: 6
- *
- * assert.deepStrictEqual(valueHistory, [5, 6]);
- *
- * num$.next(7); // logs: 7
- *
- * assert.deepStrictEqual(valueHistory, [5, 6, 7]);
- *
- * num$.next(1); // logs: 1
- *
- * num$.next(2); // logs: 2
- *
- * assert.deepStrictEqual(valueHistory, [5, 6, 7, 1, 2]);
- * ```
- */
 const skipWhile = (predicate) => (parentObservable) => new SkipWhileObservableClass(parentObservable, predicate);
-/* implementation */
 class SkipWhileObservableClass extends SyncChildObservableClass {
-    #predicate;
-    #mut_index;
-    #mut_skipping;
-    constructor(parentObservable, predicate) {
-        super({
-            parents: [parentObservable],
-            initialValue: pipe(parentObservable.getSnapshot()).map((sn) => Optional.isNone(sn)
-                ? Optional.none
-                : predicate(sn.value, -1)
-                    ? Optional.none
-                    : sn).value,
-        });
-        this.#mut_index = -1;
-        this.#predicate = predicate;
-        this.#mut_skipping = true;
+  #predicate;
+  #mut_index;
+  #mut_skipping;
+  constructor(parentObservable, predicate) {
+    super({
+      parents: [parentObservable],
+      initialValue: pipe(parentObservable.getSnapshot()).map(
+        (sn) => Optional.isNone(sn) || predicate(sn.value, -1) ? Optional.none : sn
+      ).value
+    });
+    this.#mut_index = -1;
+    this.#predicate = predicate;
+    this.#mut_skipping = true;
+  }
+  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.#mut_skipping = false;
-        }
-        if (!this.#mut_skipping) {
-            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.#mut_skipping = false;
     }
+    if (!this.#mut_skipping) {
+      this.setNext(sn.value, updateToken);
+    }
+  }
 }
 
 export { skipWhile };

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

@@ -1 +1 @@
-{"version":3,"file":"skip-while.mjs","sources":["../../../src/core/operators/skip-while.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDG;MACU,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;AACV,IAAA,aAAa;IAEb,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,EAAE,KACxD,QAAQ,CAAC,MAAM,CAAC,EAAE;kBACd,QAAQ,CAAC;kBACT,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE;sBACpB,QAAQ,CAAC;AACX,sBAAE,EAAE,CACT,CAAC,KAAK;AACR,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,UAAU,GAAG,EAAE;AAEpB,QAAA,IAAI,CAAC,UAAU,GAAG,SAAS;AAE3B,QAAA,IAAI,CAAC,aAAa,GAAG,IAAI;IAC3B;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,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,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,EAAE;AAC/C,YAAA,IAAI,CAAC,aAAa,GAAG,KAAK;QAC5B;AAEA,QAAA,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE;YACvB,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC;QACrC;IACF;AACD;;;;"}
+{"version":3,"file":"skip-while.mjs","sources":["../../../src/core/operators/skip-while.mts"],"sourcesContent":["import { Optional, SafeUint, asSafeUint, pipe } from 'ts-data-forge';\nimport { SyncChildObservableClass } from '../class/index.mjs';\nimport {\n  type DropInitialValueOperator,\n  type Observable,\n  type SkipWhileOperatorObservable,\n  type UpdateToken,\n} from '../types/index.mjs';\n\n/**\n * Skips values from the source observable while the predicate returns true.\n * Once the predicate returns false, all subsequent values pass through.\n *\n * @template A - The type of values from the source\n * @param predicate - Function to test each value\n * @returns An operator that skips values while the predicate is true\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  num$        1     2     3     4     5     6     7     1     2\n * //  skipped$                            5     6     7     1     2\n * //              |-------- skip --------|\n * //\n * //  Explanation:\n * //  - skipWhile skips values while the predicate returns true\n * //  - Once the predicate returns false, all subsequent values pass through\n * //  - Unlike filter, the predicate is never checked again after the first false\n *\n * const num$ = source<number>();\n *\n * const skipped$ = num$.pipe(skipWhile((x) => x < 5));\n *\n * const valueHistory: number[] = [];\n *\n * skipped$.subscribe((x) => {\n *   valueHistory.push(x);\n * });\n *\n * num$.next(1); // nothing logged\n *\n * num$.next(2); // nothing logged\n *\n * num$.next(3); // nothing logged\n *\n * num$.next(4); // nothing logged\n *\n * num$.next(5); // logs: 5\n *\n * assert.deepStrictEqual(valueHistory, [5]);\n *\n * num$.next(6); // logs: 6\n *\n * assert.deepStrictEqual(valueHistory, [5, 6]);\n *\n * num$.next(7); // logs: 7\n *\n * assert.deepStrictEqual(valueHistory, [5, 6, 7]);\n *\n * num$.next(1); // logs: 1\n *\n * num$.next(2); // logs: 2\n *\n * assert.deepStrictEqual(valueHistory, [5, 6, 7, 1, 2]);\n * ```\n */\nexport const skipWhile =\n  <A,>(\n    predicate: (value: A, index: SafeUint | -1) => boolean,\n  ): DropInitialValueOperator<A, A> =>\n  (parentObservable) =>\n    new SkipWhileObservableClass(parentObservable, predicate);\n\n/* implementation */\n\nclass SkipWhileObservableClass<A>\n  extends SyncChildObservableClass<A, readonly [A]>\n  implements SkipWhileOperatorObservable<A>\n{\n  readonly #predicate: (value: A, index: SafeUint | -1) => boolean;\n  #mut_index: SafeUint | -1;\n  #mut_skipping: boolean;\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((sn) =>\n        Optional.isNone(sn) || predicate(sn.value, -1) ? Optional.none : sn,\n      ).value,\n    });\n\n    this.#mut_index = -1;\n\n    this.#predicate = predicate;\n\n    this.#mut_skipping = true;\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.#mut_skipping = false;\n    }\n\n    if (!this.#mut_skipping) {\n      this.setNext(sn.value, updateToken);\n    }\n  }\n}\n"],"names":[],"mappings":";;;;AAmEO,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,EACA,aAAA;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,IAAK,SAAA,CAAU,EAAA,CAAG,KAAA,EAAO,EAAE,CAAA,GAAI,QAAA,CAAS,IAAA,GAAO;AAAA,OACnE,CAAE;AAAA,KACH,CAAA;AAED,IAAA,IAAA,CAAK,UAAA,GAAa,EAAA;AAElB,IAAA,IAAA,CAAK,UAAA,GAAa,SAAA;AAElB,IAAA,IAAA,CAAK,aAAA,GAAgB,IAAA;AAAA,EACvB;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,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,CAAC,IAAA,CAAK,UAAA,CAAW,GAAG,KAAA,EAAO,IAAA,CAAK,UAAU,CAAA,EAAG;AAC/C,MAAA,IAAA,CAAK,aAAA,GAAgB,KAAA;AAAA,IACvB;AAEA,IAAA,IAAI,CAAC,KAAK,aAAA,EAAe;AACvB,MAAA,IAAA,CAAK,OAAA,CAAQ,EAAA,CAAG,KAAA,EAAO,WAAW,CAAA;AAAA,IACpC;AAAA,EACF;AACF;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"switch-map.d.mts","sourceRoot":"","sources":["../../../src/core/operators/switch-map.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,UAAU,EAIhB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4FG;AACH,eAAO,MAAM,SAAS,GACnB,CAAC,EAAE,CAAC,EACH,iBAAiB,CAAC,IAAI,EAAE,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,KAC1C,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAEiC,CAAC"}
+{"version":3,"file":"switch-map.d.mts","sourceRoot":"","sources":["../../../src/core/operators/switch-map.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,UAAU,EAIhB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4FG;AACH,eAAO,MAAM,SAAS,GACnB,CAAC,EAAE,CAAC,mBACc,CAAC,IAAI,EAAE,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,KAC1C,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAEiC,CAAC"}

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

@@ -2,133 +2,40 @@ import { Optional } from 'ts-data-forge';
 import { AsyncChildObservableClass } from '../class/child-observable-class.mjs';
 import '../utils/id-maker.mjs';
 
-/**
- * Projects each source value to an observable, subscribes to it, and emits its values.
- * When a new value arrives from the source, the previous inner observable is unsubscribed.
- *
- * @template A - The type of values from the source
- * @template B - The type of values from the projected observable
- * @param mapToObservable - A function that maps each source value to an observable
- * @returns An operator that switches to new observables
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  input$      A                          B              C
- * //  inner A     A1    A2    A3
- * //  inner B                                B1    B2      (switched!)
- * //  inner C                                              C1    C2    C3
- * //  result$     A1    A2    A3              B1    B2      C1    C2    C3
- * //
- * //  Explanation:
- * //  - switchMap creates an inner observable for each source value
- * //  - When a new source value arrives, the previous inner is unsubscribed
- * //  - A's inner completes normally (all 3 values emitted)
- * //  - B's inner is interrupted by C (only 2 values emitted)
- * //  - C's inner completes normally (all 3 values emitted)
- *
- * const input$ = source<string>();
- *
- * const result$ = input$.pipe(
- *   switchMap((letter) => {
- *     const inner$ = source<string>();
- *
- *     setTimeout(() => {
- *       inner$.next(`${letter}1`);
- *     }, 10);
- *
- *     setTimeout(() => {
- *       inner$.next(`${letter}2`);
- *     }, 110);
- *
- *     setTimeout(() => {
- *       inner$.next(`${letter}3`);
- *     }, 210);
- *
- *     return inner$;
- *   }),
- * );
- *
- * const valueHistory: string[] = [];
- *
- * result$.subscribe((value) => {
- *   valueHistory.push(value);
- * });
- *
- * const sleep = (ms: number): Promise<void> =>
- *   new Promise((resolve) => {
- *     setTimeout(resolve, ms);
- *   });
- *
- * // Emit A - inner emits A1, A2, A3 at 10ms, 110ms, 210ms
- * input$.next('A');
- *
- * await sleep(250);
- *
- * assert.deepStrictEqual(valueHistory, ['A1', 'A2', 'A3']);
- *
- * // Emit B - inner starts emitting B1, B2 at 10ms, 110ms
- * input$.next('B');
- *
- * await sleep(150);
- *
- * assert.deepStrictEqual(valueHistory, ['A1', 'A2', 'A3', 'B1', 'B2']);
- *
- * // Emit C - switches away from B (B3 cancelled), C's inner starts
- * input$.next('C');
- *
- * await sleep(250);
- *
- * assert.deepStrictEqual(valueHistory, [
- *   'A1',
- *   'A2',
- *   'A3',
- *   'B1',
- *   'B2',
- *   'C1',
- *   'C2',
- *   'C3',
- * ]);
- * ```
- *
- * @note To improve code readability, consider using `createState` instead of `switchMap`,
- * subscribe to `parentObservable` and call `setState` within it.
- */
 const switchMap = (mapToObservable) => (parentObservable) => new SwitchMapObservableClass(parentObservable, mapToObservable);
 class SwitchMapObservableClass extends AsyncChildObservableClass {
-    #mapToObservable;
-    #mut_observable;
-    #mut_subscription;
-    constructor(parentObservable, mapToObservable) {
-        super({
-            parents: [parentObservable],
-            initialValue: Optional.none,
-        });
-        this.#mapToObservable = mapToObservable;
-        this.#mut_observable = undefined;
-        this.#mut_subscription = undefined;
-    }
-    tryUpdate(updateToken) {
-        const par = this.parents[0];
-        const sn = par.getSnapshot();
-        if (par.updateToken !== updateToken || Optional.isNone(sn)) {
-            return; // skip update
-        }
-        this.#mut_observable?.complete();
-        this.#mut_subscription?.unsubscribe();
-        const observable = this.#mapToObservable(sn.value);
-        this.#mut_observable = observable;
-        const subscription = observable.subscribe((curr) => {
-            this.startUpdate(curr);
-        });
-        this.#mut_subscription = subscription;
-    }
-    complete() {
-        this.#mut_subscription?.unsubscribe();
-        this.#mut_observable?.complete();
-        super.complete();
+  #mapToObservable;
+  #mut_observable;
+  #mut_subscription;
+  constructor(parentObservable, mapToObservable) {
+    super({
+      parents: [parentObservable],
+      initialValue: Optional.none
+    });
+    this.#mapToObservable = mapToObservable;
+    this.#mut_observable = void 0;
+    this.#mut_subscription = void 0;
+  }
+  tryUpdate(updateToken) {
+    const par = this.parents[0];
+    const sn = par.getSnapshot();
+    if (par.updateToken !== updateToken || Optional.isNone(sn)) {
+      return;
     }
+    this.#mut_observable?.complete();
+    this.#mut_subscription?.unsubscribe();
+    const observable = this.#mapToObservable(sn.value);
+    this.#mut_observable = observable;
+    const subscription = observable.subscribe((curr) => {
+      this.startUpdate(curr);
+    });
+    this.#mut_subscription = subscription;
+  }
+  complete() {
+    this.#mut_subscription?.unsubscribe();
+    this.#mut_observable?.complete();
+    super.complete();
+  }
 }
 
 export { switchMap };