synstate 2.0.1 → 3.0.0

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

@@ -1,34 +1,33 @@
 import { Optional } from 'ts-data-forge';
-import { SyncChildObservableClass } from '../class/child-observable-class.mjs';
+import { createSyncChildObservable } from '../base/create-child-observable.mjs';
 import '../utils/id-maker.mjs';
 
-const skipUntil = (notifier) => (parentObservable) => new SkipUntilObservableClass(parentObservable, notifier);
-class SkipUntilObservableClass extends SyncChildObservableClass {
-  #mut_isSkipping;
-  constructor(parentObservable, notifier) {
-    super({
+const skipUntil = (notifier) => (parentObservable) => createSkipUntilObservable(parentObservable, notifier);
+const createSkipUntilObservable = (parentObservable, notifier) => {
+  let mut_isSkipping = true;
+  const observable = createSyncChildObservable(
+    {
       parents: [parentObservable],
       initialValue: Optional.none
-    });
-    this.#mut_isSkipping = true;
-    notifier.subscribe(
-      () => {
-        this.#mut_isSkipping = false;
-      },
-      () => {
-        this.#mut_isSkipping = false;
+    },
+    ({ setNext }) => (updateToken) => {
+      const sn = parentObservable.getSnapshot();
+      if (mut_isSkipping || parentObservable.updateToken !== updateToken || Optional.isNone(sn)) {
+        return;
       }
-    );
-  }
-  tryUpdate(updateToken) {
-    const par = this.parents[0];
-    const sn = par.getSnapshot();
-    if (par.updateToken !== updateToken || Optional.isNone(sn) || this.#mut_isSkipping) {
-      return;
+      setNext(sn.value, updateToken);
     }
-    this.setNext(sn.value, updateToken);
-  }
-}
+  );
+  notifier.subscribe(
+    () => {
+      mut_isSkipping = false;
+    },
+    () => {
+      mut_isSkipping = false;
+    }
+  );
+  return observable;
+};
 
 export { skipUntil };
 //# sourceMappingURL=skip-until.mjs.map

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

@@ -1 +1 @@
-{"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;;;;"}
+{"version":3,"file":"skip-until.mjs","sources":["../../../src/core/operators/skip-until.mts"],"sourcesContent":["import { Optional } from 'ts-data-forge';\nimport { createSyncChildObservable } from '../base/index.mjs';\nimport {\n  type DropInitialValueOperator,\n  type Observable,\n  type SkipUntilOperatorObservable,\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    createSkipUntilObservable(parentObservable, notifier);\n\nconst createSkipUntilObservable = <A,>(\n  parentObservable: Observable<A>,\n  notifier: Observable<unknown>,\n): SkipUntilOperatorObservable<A> => {\n  let mut_isSkipping = true;\n\n  const observable = createSyncChildObservable<A, readonly [A]>(\n    {\n      parents: [parentObservable],\n      initialValue: Optional.none,\n    },\n    ({ setNext }) =>\n      (updateToken) => {\n        const sn = parentObservable.getSnapshot();\n\n        if (\n          mut_isSkipping ||\n          parentObservable.updateToken !== updateToken ||\n          Optional.isNone(sn)\n        ) {\n          return; // skip update\n        }\n\n        setNext(sn.value, updateToken);\n      },\n  );\n\n  notifier.subscribe(\n    () => {\n      mut_isSkipping = false;\n    },\n    () => {\n      mut_isSkipping = false;\n    },\n  );\n\n  return observable;\n};\n"],"names":[],"mappings":";;;;AA0DO,MAAM,YACX,CAAK,QAAA,KACL,CAAC,gBAAA,KACC,yBAAA,CAA0B,kBAAkB,QAAQ;AAExD,MAAM,yBAAA,GAA4B,CAChC,gBAAA,EACA,QAAA,KACmC;AACnC,EAAA,IAAI,cAAA,GAAiB,IAAA;AAErB,EAAA,MAAM,UAAA,GAAa,yBAAA;AAAA,IACjB;AAAA,MACE,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,MAC1B,cAAc,QAAA,CAAS;AAAA,KACzB;AAAA,IACA,CAAC,EAAE,OAAA,EAAQ,KACT,CAAC,WAAA,KAAgB;AACf,MAAA,MAAM,EAAA,GAAK,iBAAiB,WAAA,EAAY;AAExC,MAAA,IACE,kBACA,gBAAA,CAAiB,WAAA,KAAgB,eACjC,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAClB;AACA,QAAA;AAAA,MACF;AAEA,MAAA,OAAA,CAAQ,EAAA,CAAG,OAAO,WAAW,CAAA;AAAA,IAC/B;AAAA,GACJ;AAEA,EAAA,QAAA,CAAS,SAAA;AAAA,IACP,MAAM;AACJ,MAAA,cAAA,GAAiB,KAAA;AAAA,IACnB,CAAA;AAAA,IACA,MAAM;AACJ,MAAA,cAAA,GAAiB,KAAA;AAAA,IACnB;AAAA,GACF;AAEA,EAAA,OAAO,UAAA;AACT,CAAA;;;;"}

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,aACW,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,EAG9B,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,CAEwB,CAAC"}

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

@@ -1,38 +1,33 @@
-import { pipe, Optional, asSafeUint, SafeUint } from 'ts-data-forge';
-import { SyncChildObservableClass } from '../class/child-observable-class.mjs';
+import { Optional, asSafeUint, SafeUint, pipe } from 'ts-data-forge';
+import { createSyncChildObservable } from '../base/create-child-observable.mjs';
 import '../utils/id-maker.mjs';
 
-const skipWhile = (predicate) => (parentObservable) => new SkipWhileObservableClass(parentObservable, predicate);
-class SkipWhileObservableClass extends SyncChildObservableClass {
-  #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;
+const skipWhile = (predicate) => (parentObservable) => createSkipWhileObservable(parentObservable, predicate);
+const createSkipWhileObservable = (parentObservable, predicate) => createSyncChildObservable(
+  {
+    parents: [parentObservable],
+    initialValue: pipe(parentObservable.getSnapshot()).map(
+      (sn) => Optional.isNone(sn) || predicate(sn.value, -1) ? Optional.none : sn
+    ).value
+  },
+  ({ setNext }) => {
+    let mut_index = -1;
+    let mut_skipping = true;
+    return (updateToken) => {
+      const sn = parentObservable.getSnapshot();
+      if (parentObservable.updateToken !== updateToken || Optional.isNone(sn)) {
+        return;
+      }
+      mut_index = mut_index === -1 ? asSafeUint(0) : SafeUint.add(1, mut_index);
+      if (!predicate(sn.value, mut_index)) {
+        mut_skipping = false;
+      }
+      if (!mut_skipping) {
+        setNext(sn.value, updateToken);
+      }
+    };
   }
-  tryUpdate(updateToken) {
-    const par = this.parents[0];
-    const sn = par.getSnapshot();
-    if (par.updateToken !== updateToken || Optional.isNone(sn)) {
-      return;
-    }
-    this.#mut_index = this.#mut_index === -1 ? asSafeUint(0) : SafeUint.add(1, this.#mut_index);
-    if (!this.#predicate(sn.value, this.#mut_index)) {
-      this.#mut_skipping = false;
-    }
-    if (!this.#mut_skipping) {
-      this.setNext(sn.value, updateToken);
-    }
-  }
-}
+);
 
 export { skipWhile };
 //# sourceMappingURL=skip-while.mjs.map

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

@@ -1 +1 @@
-{"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;;;;"}
+{"version":3,"file":"skip-while.mjs","sources":["../../../src/core/operators/skip-while.mts"],"sourcesContent":["import { Optional, SafeUint, asSafeUint, pipe } from 'ts-data-forge';\nimport { createSyncChildObservable } from '../base/index.mjs';\nimport {\n  type DropInitialValueOperator,\n  type Observable,\n  type SkipWhileOperatorObservable,\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    createSkipWhileObservable(parentObservable, predicate);\n\n/* implementation */\n\nconst createSkipWhileObservable = <A,>(\n  parentObservable: Observable<A>,\n  predicate: (value: A, index: SafeUint | -1) => boolean,\n): SkipWhileOperatorObservable<A> =>\n  createSyncChildObservable(\n    {\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    ({ setNext }) => {\n      let mut_index: SafeUint | -1 = -1;\n\n      let mut_skipping = true;\n\n      return (updateToken) => {\n        const sn = parentObservable.getSnapshot();\n\n        if (\n          parentObservable.updateToken !== updateToken ||\n          Optional.isNone(sn)\n        ) {\n          return; // skip update\n        }\n\n        mut_index =\n          mut_index === -1 ? asSafeUint(0) : SafeUint.add(1, mut_index);\n\n        if (!predicate(sn.value, mut_index)) {\n          mut_skipping = false;\n        }\n\n        if (!mut_skipping) {\n          setNext(sn.value, updateToken);\n        }\n      };\n    },\n  );\n"],"names":[],"mappings":";;;;AAkEO,MAAM,YACX,CACE,SAAA,KAEF,CAAC,gBAAA,KACC,yBAAA,CAA0B,kBAAkB,SAAS;AAIzD,MAAM,yBAAA,GAA4B,CAChC,gBAAA,EACA,SAAA,KAEA,yBAAA;AAAA,EACE;AAAA,IACE,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,IAC1B,YAAA,EAAc,IAAA,CAAK,gBAAA,CAAiB,WAAA,EAAa,CAAA,CAAE,GAAA;AAAA,MAAI,CAAC,EAAA,KACtD,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,IAAK,SAAA,CAAU,EAAA,CAAG,KAAA,EAAO,EAAE,CAAA,GAAI,QAAA,CAAS,IAAA,GAAO;AAAA,KACnE,CAAE;AAAA,GACJ;AAAA,EACA,CAAC,EAAE,OAAA,EAAQ,KAAM;AACf,IAAA,IAAI,SAAA,GAA2B,EAAA;AAE/B,IAAA,IAAI,YAAA,GAAe,IAAA;AAEnB,IAAA,OAAO,CAAC,WAAA,KAAgB;AACtB,MAAA,MAAM,EAAA,GAAK,iBAAiB,WAAA,EAAY;AAExC,MAAA,IACE,iBAAiB,WAAA,KAAgB,WAAA,IACjC,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAClB;AACA,QAAA;AAAA,MACF;AAEA,MAAA,SAAA,GACE,SAAA,KAAc,KAAK,UAAA,CAAW,CAAC,IAAI,QAAA,CAAS,GAAA,CAAI,GAAG,SAAS,CAAA;AAE9D,MAAA,IAAI,CAAC,SAAA,CAAU,EAAA,CAAG,KAAA,EAAO,SAAS,CAAA,EAAG;AACnC,QAAA,YAAA,GAAe,KAAA;AAAA,MACjB;AAEA,MAAA,IAAI,CAAC,YAAA,EAAc;AACjB,QAAA,OAAA,CAAQ,EAAA,CAAG,OAAO,WAAW,CAAA;AAAA,MAC/B;AAAA,IACF,CAAA;AAAA,EACF;AACF,CAAA;;;;"}

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,mBACc,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,EAGhB,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,CAE8B,CAAC"}

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

@@ -1,42 +1,36 @@
 import { Optional } from 'ts-data-forge';
-import { AsyncChildObservableClass } from '../class/child-observable-class.mjs';
+import { createAsyncChildObservable } from '../base/create-child-observable.mjs';
 import '../utils/id-maker.mjs';
 
-const switchMap = (mapToObservable) => (parentObservable) => new SwitchMapObservableClass(parentObservable, mapToObservable);
-class SwitchMapObservableClass extends AsyncChildObservableClass {
-  #mapToObservable;
-  #mut_observable;
-  #mut_subscription;
-  constructor(parentObservable, mapToObservable) {
-    super({
+const switchMap = (mapToObservable) => (parentObservable) => createSwitchMapObservable(parentObservable, mapToObservable);
+const createSwitchMapObservable = (parentObservable, mapToObservable) => {
+  let mut_observable = void 0;
+  let mut_subscription = void 0;
+  return createAsyncChildObservable(
+    {
       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;
+      initialValue: Optional.none,
+      onComplete: () => {
+        mut_subscription?.unsubscribe();
+        mut_observable?.complete();
+      }
+    },
+    ({ startUpdate }) => (updateToken) => {
+      const sn = parentObservable.getSnapshot();
+      if (parentObservable.updateToken !== updateToken || Optional.isNone(sn)) {
+        return;
+      }
+      mut_observable?.complete();
+      mut_subscription?.unsubscribe();
+      const observable = mapToObservable(sn.value);
+      mut_observable = observable;
+      const subscription = observable.subscribe((curr) => {
+        startUpdate(curr);
+      });
+      mut_subscription = subscription;
     }
-    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 };
 //# sourceMappingURL=switch-map.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"switch-map.mjs","sources":["../../../src/core/operators/switch-map.mts"],"sourcesContent":["import { Optional } from 'ts-data-forge';\nimport { AsyncChildObservableClass } from '../class/index.mjs';\nimport {\n  type DropInitialValueOperator,\n  type Observable,\n  type Subscription,\n  type SwitchMapOperatorObservable,\n  type UpdateToken,\n} from '../types/index.mjs';\n\n/**\n * Projects each source value to an observable, subscribes to it, and emits its values.\n * When a new value arrives from the source, the previous inner observable is unsubscribed.\n *\n * @template A - The type of values from the source\n * @template B - The type of values from the projected observable\n * @param mapToObservable - A function that maps each source value to an observable\n * @returns An operator that switches to new observables\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  input$      A                          B              C\n * //  inner A     A1    A2    A3\n * //  inner B                                B1    B2      (switched!)\n * //  inner C                                              C1    C2    C3\n * //  result$     A1    A2    A3              B1    B2      C1    C2    C3\n * //\n * //  Explanation:\n * //  - switchMap creates an inner observable for each source value\n * //  - When a new source value arrives, the previous inner is unsubscribed\n * //  - A's inner completes normally (all 3 values emitted)\n * //  - B's inner is interrupted by C (only 2 values emitted)\n * //  - C's inner completes normally (all 3 values emitted)\n *\n * const input$ = source<string>();\n *\n * const result$ = input$.pipe(\n *   switchMap((letter) => {\n *     const inner$ = source<string>();\n *\n *     setTimeout(() => {\n *       inner$.next(`${letter}1`);\n *     }, 10);\n *\n *     setTimeout(() => {\n *       inner$.next(`${letter}2`);\n *     }, 110);\n *\n *     setTimeout(() => {\n *       inner$.next(`${letter}3`);\n *     }, 210);\n *\n *     return inner$;\n *   }),\n * );\n *\n * const valueHistory: string[] = [];\n *\n * result$.subscribe((value) => {\n *   valueHistory.push(value);\n * });\n *\n * const sleep = (ms: number): Promise<void> =>\n *   new Promise((resolve) => {\n *     setTimeout(resolve, ms);\n *   });\n *\n * // Emit A - inner emits A1, A2, A3 at 10ms, 110ms, 210ms\n * input$.next('A');\n *\n * await sleep(250);\n *\n * assert.deepStrictEqual(valueHistory, ['A1', 'A2', 'A3']);\n *\n * // Emit B - inner starts emitting B1, B2 at 10ms, 110ms\n * input$.next('B');\n *\n * await sleep(150);\n *\n * assert.deepStrictEqual(valueHistory, ['A1', 'A2', 'A3', 'B1', 'B2']);\n *\n * // Emit C - switches away from B (B3 cancelled), C's inner starts\n * input$.next('C');\n *\n * await sleep(250);\n *\n * assert.deepStrictEqual(valueHistory, [\n *   'A1',\n *   'A2',\n *   'A3',\n *   'B1',\n *   'B2',\n *   'C1',\n *   'C2',\n *   'C3',\n * ]);\n * ```\n *\n * @note To improve code readability, consider using `createState` instead of `switchMap`,\n * subscribe to `parentObservable` and call `setState` within it.\n */\nexport const switchMap =\n  <A, B>(\n    mapToObservable: (curr: A) => Observable<B>,\n  ): DropInitialValueOperator<A, B> =>\n  (parentObservable) =>\n    new SwitchMapObservableClass(parentObservable, mapToObservable);\n\nclass SwitchMapObservableClass<A, B>\n  extends AsyncChildObservableClass<B, readonly [A]>\n  implements SwitchMapOperatorObservable<A, B>\n{\n  readonly #mapToObservable: (curr: A) => Observable<B>;\n  #mut_observable: Observable<B> | undefined;\n  #mut_subscription: Subscription | undefined;\n\n  constructor(\n    parentObservable: Observable<A>,\n    mapToObservable: (curr: A) => Observable<B>,\n  ) {\n    super({\n      parents: [parentObservable],\n      initialValue: Optional.none,\n    });\n\n    this.#mapToObservable = mapToObservable;\n\n    this.#mut_observable = undefined;\n\n    this.#mut_subscription = undefined;\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_observable?.complete();\n\n    this.#mut_subscription?.unsubscribe();\n\n    const observable = this.#mapToObservable(sn.value);\n\n    this.#mut_observable = observable;\n\n    const subscription = observable.subscribe((curr) => {\n      this.startUpdate(curr);\n    });\n\n    this.#mut_subscription = subscription;\n  }\n\n  override complete(): void {\n    this.#mut_subscription?.unsubscribe();\n\n    this.#mut_observable?.complete();\n\n    super.complete();\n  }\n}\n"],"names":[],"mappings":";;;;AAuGO,MAAM,SAAA,GACX,CACE,eAAA,KAEF,CAAC,qBACC,IAAI,wBAAA,CAAyB,kBAAkB,eAAe;AAElE,MAAM,iCACI,yBAAA,CAEV;AAAA,EACW,gBAAA;AAAA,EACT,eAAA;AAAA,EACA,iBAAA;AAAA,EAEA,WAAA,CACE,kBACA,eAAA,EACA;AACA,IAAA,KAAA,CAAM;AAAA,MACJ,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,MAC1B,cAAc,QAAA,CAAS;AAAA,KACxB,CAAA;AAED,IAAA,IAAA,CAAK,gBAAA,GAAmB,eAAA;AAExB,IAAA,IAAA,CAAK,eAAA,GAAkB,MAAA;AAEvB,IAAA,IAAA,CAAK,iBAAA,GAAoB,MAAA;AAAA,EAC3B;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,iBAAiB,QAAA,EAAS;AAE/B,IAAA,IAAA,CAAK,mBAAmB,WAAA,EAAY;AAEpC,IAAA,MAAM,UAAA,GAAa,IAAA,CAAK,gBAAA,CAAiB,EAAA,CAAG,KAAK,CAAA;AAEjD,IAAA,IAAA,CAAK,eAAA,GAAkB,UAAA;AAEvB,IAAA,MAAM,YAAA,GAAe,UAAA,CAAW,SAAA,CAAU,CAAC,IAAA,KAAS;AAClD,MAAA,IAAA,CAAK,YAAY,IAAI,CAAA;AAAA,IACvB,CAAC,CAAA;AAED,IAAA,IAAA,CAAK,iBAAA,GAAoB,YAAA;AAAA,EAC3B;AAAA,EAES,QAAA,GAAiB;AACxB,IAAA,IAAA,CAAK,mBAAmB,WAAA,EAAY;AAEpC,IAAA,IAAA,CAAK,iBAAiB,QAAA,EAAS;AAE/B,IAAA,KAAA,CAAM,QAAA,EAAS;AAAA,EACjB;AACF;;;;"}
+{"version":3,"file":"switch-map.mjs","sources":["../../../src/core/operators/switch-map.mts"],"sourcesContent":["import { Optional } from 'ts-data-forge';\nimport { createAsyncChildObservable } from '../base/index.mjs';\nimport {\n  type DropInitialValueOperator,\n  type Observable,\n  type Subscription,\n  type SwitchMapOperatorObservable,\n} from '../types/index.mjs';\n\n/**\n * Projects each source value to an observable, subscribes to it, and emits its values.\n * When a new value arrives from the source, the previous inner observable is unsubscribed.\n *\n * @template A - The type of values from the source\n * @template B - The type of values from the projected observable\n * @param mapToObservable - A function that maps each source value to an observable\n * @returns An operator that switches to new observables\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  input$      A                          B              C\n * //  inner A     A1    A2    A3\n * //  inner B                                B1    B2      (switched!)\n * //  inner C                                              C1    C2    C3\n * //  result$     A1    A2    A3              B1    B2      C1    C2    C3\n * //\n * //  Explanation:\n * //  - switchMap creates an inner observable for each source value\n * //  - When a new source value arrives, the previous inner is unsubscribed\n * //  - A's inner completes normally (all 3 values emitted)\n * //  - B's inner is interrupted by C (only 2 values emitted)\n * //  - C's inner completes normally (all 3 values emitted)\n *\n * const input$ = source<string>();\n *\n * const result$ = input$.pipe(\n *   switchMap((letter) => {\n *     const inner$ = source<string>();\n *\n *     setTimeout(() => {\n *       inner$.next(`${letter}1`);\n *     }, 10);\n *\n *     setTimeout(() => {\n *       inner$.next(`${letter}2`);\n *     }, 110);\n *\n *     setTimeout(() => {\n *       inner$.next(`${letter}3`);\n *     }, 210);\n *\n *     return inner$;\n *   }),\n * );\n *\n * const valueHistory: string[] = [];\n *\n * result$.subscribe((value) => {\n *   valueHistory.push(value);\n * });\n *\n * const sleep = (ms: number): Promise<void> =>\n *   new Promise((resolve) => {\n *     setTimeout(resolve, ms);\n *   });\n *\n * // Emit A - inner emits A1, A2, A3 at 10ms, 110ms, 210ms\n * input$.next('A');\n *\n * await sleep(250);\n *\n * assert.deepStrictEqual(valueHistory, ['A1', 'A2', 'A3']);\n *\n * // Emit B - inner starts emitting B1, B2 at 10ms, 110ms\n * input$.next('B');\n *\n * await sleep(150);\n *\n * assert.deepStrictEqual(valueHistory, ['A1', 'A2', 'A3', 'B1', 'B2']);\n *\n * // Emit C - switches away from B (B3 cancelled), C's inner starts\n * input$.next('C');\n *\n * await sleep(250);\n *\n * assert.deepStrictEqual(valueHistory, [\n *   'A1',\n *   'A2',\n *   'A3',\n *   'B1',\n *   'B2',\n *   'C1',\n *   'C2',\n *   'C3',\n * ]);\n * ```\n *\n * @note To improve code readability, consider using `createState` instead of `switchMap`,\n * subscribe to `parentObservable` and call `setState` within it.\n */\nexport const switchMap =\n  <A, B>(\n    mapToObservable: (curr: A) => Observable<B>,\n  ): DropInitialValueOperator<A, B> =>\n  (parentObservable) =>\n    createSwitchMapObservable(parentObservable, mapToObservable);\n\nconst createSwitchMapObservable = <A, B>(\n  parentObservable: Observable<A>,\n  mapToObservable: (curr: A) => Observable<B>,\n): SwitchMapOperatorObservable<A, B> => {\n  let mut_observable: Observable<B> | undefined = undefined;\n\n  let mut_subscription: Subscription | undefined = undefined;\n\n  return createAsyncChildObservable(\n    {\n      parents: [parentObservable],\n      initialValue: Optional.none,\n      onComplete: () => {\n        mut_subscription?.unsubscribe();\n\n        mut_observable?.complete();\n      },\n    },\n    ({ startUpdate }) =>\n      (updateToken) => {\n        const sn = parentObservable.getSnapshot();\n\n        if (\n          parentObservable.updateToken !== updateToken ||\n          Optional.isNone(sn)\n        ) {\n          return; // skip update\n        }\n\n        mut_observable?.complete();\n\n        mut_subscription?.unsubscribe();\n\n        const observable = mapToObservable(sn.value);\n\n        mut_observable = observable;\n\n        const subscription = observable.subscribe((curr) => {\n          startUpdate(curr);\n        });\n\n        mut_subscription = subscription;\n      },\n  );\n};\n"],"names":[],"mappings":";;;;AAsGO,MAAM,YACX,CACE,eAAA,KAEF,CAAC,gBAAA,KACC,yBAAA,CAA0B,kBAAkB,eAAe;AAE/D,MAAM,yBAAA,GAA4B,CAChC,gBAAA,EACA,eAAA,KACsC;AACtC,EAAA,IAAI,cAAA,GAA4C,MAAA;AAEhD,EAAA,IAAI,gBAAA,GAA6C,MAAA;AAEjD,EAAA,OAAO,0BAAA;AAAA,IACL;AAAA,MACE,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,MAC1B,cAAc,QAAA,CAAS,IAAA;AAAA,MACvB,YAAY,MAAM;AAChB,QAAA,gBAAA,EAAkB,WAAA,EAAY;AAE9B,QAAA,cAAA,EAAgB,QAAA,EAAS;AAAA,MAC3B;AAAA,KACF;AAAA,IACA,CAAC,EAAE,WAAA,EAAY,KACb,CAAC,WAAA,KAAgB;AACf,MAAA,MAAM,EAAA,GAAK,iBAAiB,WAAA,EAAY;AAExC,MAAA,IACE,iBAAiB,WAAA,KAAgB,WAAA,IACjC,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAClB;AACA,QAAA;AAAA,MACF;AAEA,MAAA,cAAA,EAAgB,QAAA,EAAS;AAEzB,MAAA,gBAAA,EAAkB,WAAA,EAAY;AAE9B,MAAA,MAAM,UAAA,GAAa,eAAA,CAAgB,EAAA,CAAG,KAAK,CAAA;AAE3C,MAAA,cAAA,GAAiB,UAAA;AAEjB,MAAA,MAAM,YAAA,GAAe,UAAA,CAAW,SAAA,CAAU,CAAC,IAAA,KAAS;AAClD,QAAA,WAAA,CAAY,IAAI,CAAA;AAAA,MAClB,CAAC,CAAA;AAED,MAAA,gBAAA,GAAmB,YAAA;AAAA,IACrB;AAAA,GACJ;AACF,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"take-until.d.mts","sourceRoot":"","sources":["../../../src/core/operators/take-until.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,UAAU,EAGhB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,YACf,UAAU,CAAC,OAAO,CAAC,KAC5B,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAMQ,CAAC"}
+{"version":3,"file":"take-until.d.mts","sourceRoot":"","sources":["../../../src/core/operators/take-until.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,UAAU,EAEhB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,YACf,UAAU,CAAC,OAAO,CAAC,KAC5B,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAMQ,CAAC"}

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

@@ -1,38 +1,38 @@
 import { Optional } from 'ts-data-forge';
-import { SyncChildObservableClass } from '../class/child-observable-class.mjs';
+import { createSyncChildObservable } from '../base/create-child-observable.mjs';
 import '../utils/id-maker.mjs';
 
 const takeUntil = (notifier) => (
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  ((parentObservable) => new TakeUntilObservableClass(
+  ((parentObservable) => createTakeUntilObservable(
     parentObservable,
     notifier
   ))
 );
-class TakeUntilObservableClass extends SyncChildObservableClass {
-  constructor(parentObservable, notifier) {
-    super({
+const createTakeUntilObservable = (parentObservable, notifier) => {
+  const observable = createSyncChildObservable(
+    {
       parents: [parentObservable],
       initialValue: parentObservable.getSnapshot()
-    });
-    notifier.subscribe(
-      () => {
-        this.complete();
-      },
-      () => {
-        this.complete();
+    },
+    ({ setNext }) => (updateToken) => {
+      const sn = parentObservable.getSnapshot();
+      if (parentObservable.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;
+      setNext(sn.value, updateToken);
     }
-    this.setNext(sn.value, updateToken);
-  }
-}
+  );
+  notifier.subscribe(
+    () => {
+      observable.complete();
+    },
+    () => {
+      observable.complete();
+    }
+  );
+  return observable;
+};
 
 export { takeUntil };
 //# sourceMappingURL=take-until.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"take-until.mjs","sources":["../../../src/core/operators/take-until.mts"],"sourcesContent":["import { Optional } from 'ts-data-forge';\nimport { SyncChildObservableClass } from '../class/index.mjs';\nimport {\n  type KeepInitialValueOperator,\n  type Observable,\n  type TakeUntilOperatorObservable,\n  type UpdateToken,\n} from '../types/index.mjs';\n\n/**\n * Emits values from the source until the notifier observable emits.\n * When the notifier emits, this observable completes.\n *\n * @template A - The type of values from the source\n * @param notifier - An observable that signals when to complete\n * @returns An operator that takes values until notifier emits\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  num$          1         2         stop      3 (ignored)\n * //  stopNotifier                      X\n * //  limited$      1         2         |------- (completed)\n * //\n * //  Explanation:\n * //  - takeUntil completes the observable when the notifier emits\n * //  - After stop() is called, no further values are emitted\n * //  - Useful for cleanup and cancellation patterns\n *\n * const num$ = source<number>();\n *\n * const [stopNotifier, stop_] = createEventEmitter();\n *\n * const limited$ = num$.pipe(takeUntil(stopNotifier));\n *\n * const valueHistory: number[] = [];\n *\n * limited$.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 * assert.deepStrictEqual(valueHistory, [1, 2]);\n *\n * stop_();\n *\n * num$.next(3); // nothing logged (completed)\n *\n * assert.deepStrictEqual(valueHistory, [1, 2]);\n * ```\n */\nexport const takeUntil = <A,>(\n  notifier: Observable<unknown>,\n): KeepInitialValueOperator<A, A> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  ((parentObservable) =>\n    new TakeUntilObservableClass(\n      parentObservable,\n      notifier,\n    )) as KeepInitialValueOperator<A, A>;\n\nclass TakeUntilObservableClass<A>\n  extends SyncChildObservableClass<A, readonly [A]>\n  implements TakeUntilOperatorObservable<A>\n{\n  constructor(parentObservable: Observable<A>, notifier: Observable<unknown>) {\n    super({\n      parents: [parentObservable],\n      initialValue: parentObservable.getSnapshot(),\n    });\n\n    notifier.subscribe(\n      () => {\n        this.complete();\n      },\n      () => {\n        this.complete();\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 (par.updateToken !== updateToken || Optional.isNone(sn)) {\n      return; // skip update\n    }\n\n    this.setNext(sn.value, updateToken);\n  }\n}\n"],"names":[],"mappings":";;;;AAyDO,MAAM,YAAY,CACvB,QAAA;AAAA;AAAA,GAGC,CAAC,qBACA,IAAI,wBAAA;AAAA,IACF,gBAAA;AAAA,IACA;AAAA,GACF;AAAA;AAEJ,MAAM,iCACI,wBAAA,CAEV;AAAA,EACE,WAAA,CAAY,kBAAiC,QAAA,EAA+B;AAC1E,IAAA,KAAA,CAAM;AAAA,MACJ,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,MAC1B,YAAA,EAAc,iBAAiB,WAAA;AAAY,KAC5C,CAAA;AAED,IAAA,QAAA,CAAS,SAAA;AAAA,MACP,MAAM;AACJ,QAAA,IAAA,CAAK,QAAA,EAAS;AAAA,MAChB,CAAA;AAAA,MACA,MAAM;AACJ,QAAA,IAAA,CAAK,QAAA,EAAS;AAAA,MAChB;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,IAAI,IAAI,WAAA,KAAgB,WAAA,IAAe,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAAG;AAC1D,MAAA;AAAA,IACF;AAEA,IAAA,IAAA,CAAK,OAAA,CAAQ,EAAA,CAAG,KAAA,EAAO,WAAW,CAAA;AAAA,EACpC;AACF;;;;"}
+{"version":3,"file":"take-until.mjs","sources":["../../../src/core/operators/take-until.mts"],"sourcesContent":["import { Optional } from 'ts-data-forge';\nimport { createSyncChildObservable } from '../base/index.mjs';\nimport {\n  type KeepInitialValueOperator,\n  type Observable,\n  type TakeUntilOperatorObservable,\n} from '../types/index.mjs';\n\n/**\n * Emits values from the source until the notifier observable emits.\n * When the notifier emits, this observable completes.\n *\n * @template A - The type of values from the source\n * @param notifier - An observable that signals when to complete\n * @returns An operator that takes values until notifier emits\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  num$          1         2         stop      3 (ignored)\n * //  stopNotifier                      X\n * //  limited$      1         2         |------- (completed)\n * //\n * //  Explanation:\n * //  - takeUntil completes the observable when the notifier emits\n * //  - After stop() is called, no further values are emitted\n * //  - Useful for cleanup and cancellation patterns\n *\n * const num$ = source<number>();\n *\n * const [stopNotifier, stop_] = createEventEmitter();\n *\n * const limited$ = num$.pipe(takeUntil(stopNotifier));\n *\n * const valueHistory: number[] = [];\n *\n * limited$.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 * assert.deepStrictEqual(valueHistory, [1, 2]);\n *\n * stop_();\n *\n * num$.next(3); // nothing logged (completed)\n *\n * assert.deepStrictEqual(valueHistory, [1, 2]);\n * ```\n */\nexport const takeUntil = <A,>(\n  notifier: Observable<unknown>,\n): KeepInitialValueOperator<A, A> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  ((parentObservable) =>\n    createTakeUntilObservable(\n      parentObservable,\n      notifier,\n    )) as KeepInitialValueOperator<A, A>;\n\nconst createTakeUntilObservable = <A,>(\n  parentObservable: Observable<A>,\n  notifier: Observable<unknown>,\n): TakeUntilOperatorObservable<A> => {\n  const observable = createSyncChildObservable<A, readonly [A]>(\n    {\n      parents: [parentObservable],\n      initialValue: parentObservable.getSnapshot(),\n    },\n    ({ setNext }) =>\n      (updateToken) => {\n        const sn = parentObservable.getSnapshot();\n\n        if (\n          parentObservable.updateToken !== updateToken ||\n          Optional.isNone(sn)\n        ) {\n          return; // skip update\n        }\n\n        setNext(sn.value, updateToken);\n      },\n  );\n\n  notifier.subscribe(\n    () => {\n      observable.complete();\n    },\n    () => {\n      observable.complete();\n    },\n  );\n\n  return observable;\n};\n"],"names":[],"mappings":";;;;AAwDO,MAAM,YAAY,CACvB,QAAA;AAAA;AAAA,GAGC,CAAC,gBAAA,KACA,yBAAA;AAAA,IACE,gBAAA;AAAA,IACA;AAAA,GACF;AAAA;AAEJ,MAAM,yBAAA,GAA4B,CAChC,gBAAA,EACA,QAAA,KACmC;AACnC,EAAA,MAAM,UAAA,GAAa,yBAAA;AAAA,IACjB;AAAA,MACE,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,MAC1B,YAAA,EAAc,iBAAiB,WAAA;AAAY,KAC7C;AAAA,IACA,CAAC,EAAE,OAAA,EAAQ,KACT,CAAC,WAAA,KAAgB;AACf,MAAA,MAAM,EAAA,GAAK,iBAAiB,WAAA,EAAY;AAExC,MAAA,IACE,iBAAiB,WAAA,KAAgB,WAAA,IACjC,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAClB;AACA,QAAA;AAAA,MACF;AAEA,MAAA,OAAA,CAAQ,EAAA,CAAG,OAAO,WAAW,CAAA;AAAA,IAC/B;AAAA,GACJ;AAEA,EAAA,QAAA,CAAS,SAAA;AAAA,IACP,MAAM;AACJ,MAAA,UAAA,CAAW,QAAA,EAAS;AAAA,IACtB,CAAA;AAAA,IACA,MAAM;AACJ,MAAA,UAAA,CAAW,QAAA,EAAS;AAAA,IACtB;AAAA,GACF;AAEA,EAAA,OAAO,UAAA;AACT,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"take-while.d.mts","sourceRoot":"","sources":["../../../src/core/operators/take-while.mts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAIT,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,KAAK,wBAAwB,EAK9B,MAAM,oBAAoB,CAAC;AAG5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;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"}
+{"version":3,"file":"take-while.d.mts","sourceRoot":"","sources":["../../../src/core/operators/take-while.mts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAIT,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,KAAK,wBAAwB,EAI9B,MAAM,oBAAoB,CAAC;AAG5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;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,CAEwB,CAAC"}

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

@@ -1,35 +1,31 @@
-import { pipe, Optional, asSafeUint, SafeUint } from 'ts-data-forge';
-import { SyncChildObservableClass } from '../class/child-observable-class.mjs';
+import { Optional, asSafeUint, SafeUint, pipe } from 'ts-data-forge';
+import { createSyncChildObservable } from '../base/create-child-observable.mjs';
 import '../utils/id-maker.mjs';
 
-const takeWhile = (predicate) => (parentObservable) => new TakeWhileObservableClass(parentObservable, predicate);
-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;
+const takeWhile = (predicate) => (parentObservable) => createTakeWhileObservable(parentObservable, predicate);
+const createTakeWhileObservable = (parentObservable, predicate) => createSyncChildObservable(
+  {
+    parents: [parentObservable],
+    initialValue: pipe(parentObservable.getSnapshot()).map(
+      (par) => Optional.isNone(par) ? Optional.none : predicate(par.value, -1) ? par : Optional.none
+    ).value
+  },
+  ({ setNext, complete }) => {
+    let mut_index = -1;
+    return (updateToken) => {
+      const sn = parentObservable.getSnapshot();
+      if (parentObservable.updateToken !== updateToken || Optional.isNone(sn)) {
+        return;
+      }
+      mut_index = mut_index === -1 ? asSafeUint(0) : SafeUint.add(1, mut_index);
+      if (predicate(sn.value, mut_index)) {
+        setNext(sn.value, updateToken);
+      } else {
+        complete();
+      }
+    };
   }
-  tryUpdate(updateToken) {
-    const par = this.parents[0];
-    const sn = par.getSnapshot();
-    if (par.updateToken !== updateToken || Optional.isNone(sn)) {
-      return;
-    }
-    this.#mut_index = this.#mut_index === -1 ? asSafeUint(0) : SafeUint.add(1, this.#mut_index);
-    if (this.#predicate(sn.value, this.#mut_index)) {
-      this.setNext(sn.value, updateToken);
-    } else {
-      this.complete();
-    }
-  }
-}
+);
 
 export { takeWhile };
 //# sourceMappingURL=take-while.mjs.map

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

@@ -1 +1 @@
-{"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;;;;"}
+{"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 { createSyncChildObservable } from '../base/index.mjs';\nimport { source } from '../create/index.mjs';\nimport {\n  type DropInitialValueOperator,\n  type InitializedObservable,\n  type Observable,\n  type TakeWhileOperatorObservable,\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    createTakeWhileObservable(parentObservable, predicate);\n\n/* implementation */\n\nconst createTakeWhileObservable = <A,>(\n  parentObservable: Observable<A>,\n  predicate: (value: A, index: SafeUint | -1) => boolean,\n): TakeWhileOperatorObservable<A> =>\n  createSyncChildObservable(\n    {\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    ({ setNext, complete }) => {\n      let mut_index: SafeUint | -1 = -1;\n\n      return (updateToken) => {\n        const sn = parentObservable.getSnapshot();\n\n        if (\n          parentObservable.updateToken !== updateToken ||\n          Optional.isNone(sn)\n        ) {\n          return; // skip update\n        }\n\n        mut_index =\n          mut_index === -1 ? asSafeUint(0) : SafeUint.add(1, mut_index);\n\n        if (predicate(sn.value, mut_index)) {\n          setNext(sn.value, updateToken);\n        } else {\n          complete();\n        }\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":";;;;AAwEO,MAAM,YACX,CACE,SAAA,KAEF,CAAC,gBAAA,KACC,yBAAA,CAA0B,kBAAkB,SAAS;AAIzD,MAAM,yBAAA,GAA4B,CAChC,gBAAA,EACA,SAAA,KAEA,yBAAA;AAAA,EACE;AAAA,IACE,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,IAC1B,YAAA,EAAc,IAAA,CAAK,gBAAA,CAAiB,WAAA,EAAa,CAAA,CAAE,GAAA;AAAA,MAAI,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,KACjB,CAAE;AAAA,GACJ;AAAA,EACA,CAAC,EAAE,OAAA,EAAS,QAAA,EAAS,KAAM;AACzB,IAAA,IAAI,SAAA,GAA2B,EAAA;AAE/B,IAAA,OAAO,CAAC,WAAA,KAAgB;AACtB,MAAA,MAAM,EAAA,GAAK,iBAAiB,WAAA,EAAY;AAExC,MAAA,IACE,iBAAiB,WAAA,KAAgB,WAAA,IACjC,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAClB;AACA,QAAA;AAAA,MAAA;AAGF,MAAA,SAAA,GACE,SAAA,KAAc,KAAK,UAAA,CAAW,CAAC,IAAI,QAAA,CAAS,GAAA,CAAI,GAAG,SAAS,CAAA;AAE9D,MAAA,IAAI,SAAA,CAAU,EAAA,CAAG,KAAA,EAAO,SAAS,CAAA,EAAG;AAClC,QAAA,OAAA,CAAQ,EAAA,CAAG,OAAO,WAAW,CAAA;AAAA,MAAA,CAC/B,MAAO;AACL,QAAA,QAAA,EAAS;AAAA,MAAA;AACX,IAAA,CACF;AAAA,EAAA;AAEJ,CAAA;;;;"}

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,gBACV,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,EAI9B,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

@@ -1,49 +1,41 @@
 import { Optional } from 'ts-data-forge';
-import { SyncChildObservableClass } from '../class/child-observable-class.mjs';
+import { createSyncChildObservable } from '../base/create-child-observable.mjs';
 import '../utils/id-maker.mjs';
 
 const throttle = (milliSeconds) => (
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  ((parentObservable) => new ThrottleObservableClass(
+  ((parentObservable) => createThrottleObservable(
     parentObservable,
     milliSeconds
   ))
 );
-class ThrottleObservableClass extends SyncChildObservableClass {
-  #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);
+const createThrottleObservable = (parentObservable, milliSeconds) => {
+  let mut_timerId = void 0;
+  let mut_isSkipping = false;
+  const resetTimer = () => {
+    if (mut_timerId !== void 0) {
+      clearTimeout(mut_timerId);
     }
-  }
-  tryUpdate(updateToken) {
-    const par = this.parents[0];
-    const sn = par.getSnapshot();
-    if (par.updateToken !== updateToken || Optional.isNone(sn) || this.#mut_isSkipping) {
-      return;
+  };
+  return createSyncChildObservable(
+    {
+      parents: [parentObservable],
+      initialValue: parentObservable.getSnapshot(),
+      onComplete: resetTimer
+    },
+    ({ setNext }) => (updateToken) => {
+      const sn = parentObservable.getSnapshot();
+      if (mut_isSkipping || parentObservable.updateToken !== updateToken || Optional.isNone(sn)) {
+        return;
+      }
+      setNext(sn.value, updateToken);
+      mut_isSkipping = true;
+      mut_timerId = setTimeout(() => {
+        mut_isSkipping = false;
+      }, milliSeconds);
     }
-    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 };
 //# sourceMappingURL=throttle.mjs.map

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

@@ -1 +1 @@
-{"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;;;;"}
+{"version":3,"file":"throttle.mjs","sources":["../../../src/core/operators/throttle.mts"],"sourcesContent":["import { Optional } from 'ts-data-forge';\nimport { createSyncChildObservable } from '../base/index.mjs';\nimport {\n  type KeepInitialValueOperator,\n  type Observable,\n  type ThrottleOperatorObservable,\n  type TimerId,\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    createThrottleObservable(\n      parentObservable,\n      milliSeconds,\n    )) as KeepInitialValueOperator<A, A>;\n\nconst createThrottleObservable = <A,>(\n  parentObservable: Observable<A>,\n  milliSeconds: number,\n): ThrottleOperatorObservable<A> => {\n  let mut_timerId: TimerId | undefined = undefined;\n\n  let mut_isSkipping = false;\n\n  const resetTimer = (): void => {\n    if (mut_timerId !== undefined) {\n      clearTimeout(mut_timerId);\n    }\n  };\n\n  return createSyncChildObservable(\n    {\n      parents: [parentObservable],\n      initialValue: parentObservable.getSnapshot(),\n      onComplete: resetTimer,\n    },\n    ({ setNext }) =>\n      (updateToken) => {\n        const sn = parentObservable.getSnapshot();\n\n        if (\n          mut_isSkipping ||\n          parentObservable.updateToken !== updateToken ||\n          Optional.isNone(sn)\n        ) {\n          return; // skip update\n        }\n\n        setNext(sn.value, updateToken);\n\n        mut_isSkipping = true;\n\n        // set timer\n        mut_timerId = setTimeout(() => {\n          mut_isSkipping = false;\n        }, milliSeconds);\n      },\n  );\n};\n"],"names":[],"mappings":";;;;AAuFO,MAAM,WAAW,CACtB,YAAA;AAAA;AAAA,GAGC,CAAC,gBAAA,KACA,wBAAA;AAAA,IACE,gBAAA;AAAA,IACA;AAAA,GACF;AAAA;AAEJ,MAAM,wBAAA,GAA2B,CAC/B,gBAAA,EACA,YAAA,KACkC;AAClC,EAAA,IAAI,WAAA,GAAmC,MAAA;AAEvC,EAAA,IAAI,cAAA,GAAiB,KAAA;AAErB,EAAA,MAAM,aAAa,MAAY;AAC7B,IAAA,IAAI,gBAAgB,MAAA,EAAW;AAC7B,MAAA,YAAA,CAAa,WAAW,CAAA;AAAA,IAC1B;AAAA,EACF,CAAA;AAEA,EAAA,OAAO,yBAAA;AAAA,IACL;AAAA,MACE,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,MAC1B,YAAA,EAAc,iBAAiB,WAAA,EAAY;AAAA,MAC3C,UAAA,EAAY;AAAA,KACd;AAAA,IACA,CAAC,EAAE,OAAA,EAAQ,KACT,CAAC,WAAA,KAAgB;AACf,MAAA,MAAM,EAAA,GAAK,iBAAiB,WAAA,EAAY;AAExC,MAAA,IACE,kBACA,gBAAA,CAAiB,WAAA,KAAgB,eACjC,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAClB;AACA,QAAA;AAAA,MACF;AAEA,MAAA,OAAA,CAAQ,EAAA,CAAG,OAAO,WAAW,CAAA;AAE7B,MAAA,cAAA,GAAiB,IAAA;AAGjB,MAAA,WAAA,GAAc,WAAW,MAAM;AAC7B,QAAA,cAAA,GAAiB,KAAA;AAAA,MACnB,GAAG,YAAY,CAAA;AAAA,IACjB;AAAA,GACJ;AACF,CAAA;;;;"}