synstate 1.0.2 → 2.0.1

package/dist/core/combine/merge.mjs

@@ -2,76 +2,28 @@ import { Optional } from 'ts-data-forge';
 import { SyncChildObservableClass } from '../class/child-observable-class.mjs';
 import '../utils/id-maker.mjs';
 
-/**
- * Merges multiple observables into a single observable that emits all values from all sources.
- * Emits whenever any source observable emits a value.
- *
- * @template OS - Tuple type of source observables
- * @param parents - Array of observables to merge
- * @returns A merged observable emitting values from any source
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  clicks$   c1              c2                c3
- * //  keys$               k1          k2                    k3
- * //  events$   c1        k1    c2    k2          c3        k3
- * //
- * //  Explanation:
- * //  - merge combines multiple observables into one
- * //  - Emits values from any source as they arrive
- * //  - Order is preserved based on emission time
- *
- * const clicks$ = source<string>();
- *
- * const keys$ = source<string>();
- *
- * const events$ = merge([clicks$, keys$]);
- *
- * const valueHistory: string[] = [];
- *
- * events$.subscribe((event_) => {
- *   valueHistory.push(event_);
- * });
- *
- * clicks$.next('c1');
- *
- * assert.deepStrictEqual(valueHistory, ['c1']);
- *
- * keys$.next('k1');
- *
- * assert.deepStrictEqual(valueHistory, ['c1', 'k1']);
- *
- * clicks$.next('c2');
- *
- * keys$.next('k2');
- *
- * assert.deepStrictEqual(valueHistory, ['c1', 'k1', 'c2', 'k2']);
- * ```
- *
- * @note To improve code readability, consider using `createState` instead of `merge`,
- * subscribing to `parents` and calling `setState` within it.
- */
-const merge = (parents) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-new MergeObservableClass(parents);
+const merge = (parents) => (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  new MergeObservableClass(parents)
+);
 class MergeObservableClass extends SyncChildObservableClass {
-    constructor(parents) {
-        super({
-            parents,
-            initialValue: Optional.none,
-        });
-    }
-    tryUpdate(updateToken) {
-        const parentToUse = this.parents.find((o) => o.updateToken === updateToken && Optional.isSome(o.getSnapshot()));
-        if (parentToUse === undefined)
-            return;
-        const nextValue = 
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-        Optional.unwrap(parentToUse.getSnapshot());
-        this.setNext(nextValue, updateToken);
-    }
+  constructor(parents) {
+    super({
+      parents,
+      initialValue: Optional.none
+    });
+  }
+  tryUpdate(updateToken) {
+    const parentToUse = this.parents.find(
+      (o) => o.updateToken === updateToken && Optional.isSome(o.getSnapshot())
+    );
+    if (parentToUse === void 0) return;
+    const nextValue = (
+      // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+      Optional.unwrap(parentToUse.getSnapshot())
+    );
+    this.setNext(nextValue, updateToken);
+  }
 }
 
 export { merge };

package/dist/core/combine/merge.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"merge.mjs","sources":["../../../src/core/combine/merge.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDG;AACI,MAAM,KAAK,GAAG,CACnB,OAAW;AAEX;AACA,IAAI,oBAAoB,CAAC,OAAO;AAElC,MAAM,oBACJ,SAAQ,wBAA4C,CAAA;AAGpD,IAAA,WAAA,CAAY,OAAgB,EAAA;AAC1B,QAAA,KAAK,CAAC;YACJ,OAAO;YACP,YAAY,EAAE,QAAQ,CAAC,IAAI;AAC5B,SAAA,CAAC;;AAGK,IAAA,SAAS,CAAC,WAAwB,EAAA;AACzC,QAAA,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CACnC,CAAC,CAAC,KAAK,CAAC,CAAC,WAAW,KAAK,WAAW,IAAI,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CACzE;QAED,IAAI,WAAW,KAAK,SAAS;YAAE;AAE/B,QAAA,MAAM,SAAS;;QAEb,QAAQ,CAAC,MAAM,CAAC,WAAW,CAAC,WAAW,EAAE,CAAoB;AAE/D,QAAA,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,WAAW,CAAC;;AAEvC;;;;"}
+{"version":3,"file":"merge.mjs","sources":["../../../src/core/combine/merge.mts"],"sourcesContent":["import { Optional, expectType } from 'ts-data-forge';\nimport { type ArrayElement, type NonEmptyTuple } from 'ts-type-forge';\nimport { SyncChildObservableClass } from '../class/index.mjs';\nimport { source } from '../create/index.mjs';\nimport {\n  type MergeObservable,\n  type MergeObservableRefined,\n  type NonEmptyUnknownList,\n  type Observable,\n  type SyncChildObservable,\n  type UpdateToken,\n  type Wrap,\n} from '../types/index.mjs';\n\n/**\n * Merges multiple observables into a single observable that emits all values from all sources.\n * Emits whenever any source observable emits a value.\n *\n * @template OS - Tuple type of source observables\n * @param parents - Array of observables to merge\n * @returns A merged observable emitting values from any source\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  clicks$   c1              c2                c3\n * //  keys$               k1          k2                    k3\n * //  events$   c1        k1    c2    k2          c3        k3\n * //\n * //  Explanation:\n * //  - merge combines multiple observables into one\n * //  - Emits values from any source as they arrive\n * //  - Order is preserved based on emission time\n *\n * const clicks$ = source<string>();\n *\n * const keys$ = source<string>();\n *\n * const events$ = merge([clicks$, keys$]);\n *\n * const valueHistory: string[] = [];\n *\n * events$.subscribe((event_) => {\n *   valueHistory.push(event_);\n * });\n *\n * clicks$.next('c1');\n *\n * assert.deepStrictEqual(valueHistory, ['c1']);\n *\n * keys$.next('k1');\n *\n * assert.deepStrictEqual(valueHistory, ['c1', 'k1']);\n *\n * clicks$.next('c2');\n *\n * keys$.next('k2');\n *\n * assert.deepStrictEqual(valueHistory, ['c1', 'k1', 'c2', 'k2']);\n * ```\n *\n * @note To improve code readability, consider using `createState` instead of `merge`,\n * subscribing to `parents` and calling `setState` within it.\n */\nexport const merge = <const OS extends NonEmptyTuple<Observable<unknown>>>(\n  parents: OS,\n): MergeObservableRefined<OS> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  new MergeObservableClass(parents) as MergeObservableRefined<OS>;\n\nclass MergeObservableClass<const P extends NonEmptyUnknownList>\n  extends SyncChildObservableClass<ArrayElement<P>, P>\n  implements MergeObservable<P>\n{\n  constructor(parents: Wrap<P>) {\n    super({\n      parents,\n      initialValue: Optional.none,\n    });\n  }\n\n  override tryUpdate(updateToken: UpdateToken): void {\n    const parentToUse = this.parents.find(\n      (o) => o.updateToken === updateToken && Optional.isSome(o.getSnapshot()),\n    );\n\n    if (parentToUse === undefined) return;\n\n    const nextValue =\n      // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      Optional.unwrap(parentToUse.getSnapshot()) as ArrayElement<P>;\n\n    this.setNext(nextValue, updateToken);\n  }\n}\n\nif (import.meta.vitest !== undefined) {\n  test('type test', () => {\n    expect(1).toBe(1); // dummy\n  });\n\n  const r1 = source(1);\n\n  const r2 = source('a');\n\n  const _m = merge([r1, r2]);\n\n  expectType<typeof _m, SyncChildObservable<number | string>>('<=');\n}\n"],"names":[],"mappings":";;;;AAiEO,MAAM,QAAQ,CACnB,OAAA;AAAA;AAAA,EAGA,IAAI,qBAAqB,OAAO;AAAA;AAElC,MAAM,6BACI,wBAAA,CAEV;AAAA,EACE,YAAY,OAAA,EAAkB;AAC5B,IAAA,KAAA,CAAM;AAAA,MACJ,OAAA;AAAA,MACA,cAAc,QAAA,CAAS;AAAA,KACxB,CAAA;AAAA,EAAA;AACH,EAES,UAAU,WAAA,EAAgC;AACjD,IAAA,MAAM,WAAA,GAAc,KAAK,OAAA,CAAQ,IAAA;AAAA,MAC/B,CAAC,MAAM,CAAA,CAAE,WAAA,KAAgB,eAAe,QAAA,CAAS,MAAA,CAAO,CAAA,CAAE,WAAA,EAAa;AAAA,KACzE;AAEA,IAAA,IAAI,gBAAgB,MAAA,EAAW;AAE/B,IAAA,MAAM,SAAA;AAAA;AAAA,MAEJ,QAAA,CAAS,MAAA,CAAO,WAAA,CAAY,WAAA,EAAa;AAAA,KAAA;AAE3C,IAAA,IAAA,CAAK,OAAA,CAAQ,WAAW,WAAW,CAAA;AAAA,EAAA;AAEvC;;;;"}

package/dist/core/combine/zip.d.mts

@@ -1,4 +1,4 @@
-import { type NonEmptyArray } from 'ts-type-forge';
+import { type NonEmptyTuple } from 'ts-type-forge';
 import { type Observable, type ZipObservableRefined } from '../types/index.mjs';
 /**
  * Combines multiple observables by pairing their emissions by index.
@@ -49,5 +49,5 @@ import { type Observable, type ZipObservableRefined } from '../types/index.mjs';
  * ]);
  * ```
  */
-export declare const zip: <const OS extends NonEmptyArray<Observable<unknown>>>(parents: OS) => ZipObservableRefined<OS>;
+export declare const zip: <const OS extends NonEmptyTuple<Observable<unknown>>>(parents: OS) => ZipObservableRefined<OS>;
 //# sourceMappingURL=zip.d.mts.map

package/dist/core/combine/zip.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"zip.d.mts","sourceRoot":"","sources":["../../../src/core/combine/zip.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAInD,OAAO,EAIL,KAAK,UAAU,EAMf,KAAK,oBAAoB,EAC1B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,eAAO,MAAM,GAAG,GAAI,KAAK,CAAC,EAAE,SAAS,aAAa,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,EACrE,SAAS,EAAE,KACV,oBAAoB,CAAC,EAAE,CAE8C,CAAC"}
+{"version":3,"file":"zip.d.mts","sourceRoot":"","sources":["../../../src/core/combine/zip.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,aAAa,EAAc,MAAM,eAAe,CAAC;AAI/D,OAAO,EAIL,KAAK,UAAU,EAMf,KAAK,oBAAoB,EAC1B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,eAAO,MAAM,GAAG,GAAI,KAAK,CAAC,EAAE,SAAS,aAAa,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,WAC5D,EAAE,KACV,oBAAoB,CAAC,EAAE,CAE8C,CAAC"}

package/dist/core/combine/zip.mjs

@@ -1,88 +1,43 @@
-import { Optional, Arr, createQueue } from 'ts-data-forge';
+import { Arr, Optional, createQueue } from 'ts-data-forge';
 import { SyncChildObservableClass } from '../class/child-observable-class.mjs';
 import '../utils/id-maker.mjs';
 
-/**
- * Combines multiple observables by pairing their emissions by index.
- * Waits for all sources to emit their nth value before emitting the nth tuple.
- * Completes when any source completes.
- *
- * @template OS - Tuple type of source observables
- * @param parents - Array of observables to zip
- * @returns A zipped observable emitting tuples of values
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  letters$  'A'       'B'       'C'
- * //  numbers$  1         2         3
- * //  zipped$   ['A',1]   ['B',2]   ['C',3]
- * //
- * //  Explanation:
- * //  - zip pairs values by their index from multiple sources
- * //  - Waits for all sources to emit at the same index
- * //  - Completes when any source completes
- *
- * const [letters$, setLetter] = createState<string>('A');
- *
- * const [numbers$, setNumber] = createState<number>(1);
- *
- * const zipped$ = zip([letters$, numbers$]);
- *
- * const valueHistory: (readonly [string, number])[] = [];
- *
- * zipped$.subscribe(([letter, num]) => {
- *   valueHistory.push([letter, num]);
- * });
- *
- * for (const letter of ['B', 'C']) {
- *   setLetter(letter);
- * }
- *
- * for (const num of [2, 3]) {
- *   setNumber(num);
- * }
- *
- * assert.deepStrictEqual(valueHistory, [
- *   ['A', 1],
- *   ['B', 2],
- *   ['C', 3],
- * ]);
- * ```
- */
-const zip = (parents) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-new ZipObservableClass(parents);
+const zip = (parents) => (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  new ZipObservableClass(parents)
+);
 class ZipObservableClass extends SyncChildObservableClass {
-    #queues;
-    constructor(parents) {
-        const parentsValues = parents.map((p) => p.getSnapshot());
-        super({
-            parents,
-            initialValue: parentsValues.every(Optional.isSome)
-                ? Optional.some(
-                // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-                Arr.map(parentsValues, (c) => c.value))
-                : Optional.none,
-        });
-        this.#queues = Arr.map(parents, () => createQueue());
+  #queues;
+  constructor(parents) {
+    const parentsValues = Arr.map(
+      parents,
+      (p) => p.getSnapshot()
+    );
+    const initialValue = Arr.every(parentsValues, Optional.isSome) ? Optional.some(Arr.map(parentsValues, (c) => c.value)) : Optional.none;
+    super({
+      parents,
+      initialValue
+    });
+    this.#queues = Arr.map(parents, () => createQueue());
+  }
+  tryUpdate(updateToken) {
+    const queues = this.#queues;
+    for (const [index, par] of this.parents.entries()) {
+      const sn = par.getSnapshot();
+      if (par.updateToken === updateToken && Optional.isSome(sn)) {
+        queues[index]?.enqueue(sn.value);
+      }
     }
-    tryUpdate(updateToken) {
-        const queues = this.#queues;
-        for (const [index, par] of this.parents.entries()) {
-            const sn = par.getSnapshot();
-            if (par.updateToken === updateToken && Optional.isSome(sn)) {
-                queues[index]?.enqueue(sn.value);
-            }
-        }
-        if (queues.every((list) => !list.isEmpty)) {
-            const nextValue = 
-            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-            Arr.map(queues, (q) => Optional.unwrap(q.dequeue()));
-            this.setNext(nextValue, updateToken);
-        }
+    if (queues.every((list) => !list.isEmpty)) {
+      const nextValue = (
+        // `Arr.map` has a single result element type, so it reports
+        // `A[number] | undefined` per position rather than `A[P]`.
+        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        Arr.map(queues, (q) => Optional.unwrap(q.dequeue()))
+      );
+      this.setNext(nextValue, updateToken);
     }
+  }
 }
 
 export { zip };

package/dist/core/combine/zip.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"zip.mjs","sources":["../../../src/core/combine/zip.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAkBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDG;AACI,MAAM,GAAG,GAAG,CACjB,OAAW;AAEX;AACA,IAAI,kBAAkB,CAAC,OAAO;AAEhC,MAAM,kBACJ,SAAQ,wBAA8B,CAAA;AAG7B,IAAA,OAAO;AAEhB,IAAA,WAAA,CAAY,OAAgB,EAAA;AAC1B,QAAA,MAAM,aAAa,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,WAAW,EAAE,CAAC;AAEzD,QAAA,KAAK,CAAC;YACJ,OAAO;YACP,YAAY,EAAE,aAAa,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM;kBAC7C,QAAQ,CAAC,IAAI;;AAEX,gBAAA,GAAG,CAAC,GAAG,CAAC,aAAa,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,CAAM;kBAE7C,QAAQ,CAAC,IAAI;AAClB,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,OAAO,GAAG,GAAG,CAAC,GAAG,CAAC,OAAO,EAAE,MAC9B,WAAW,EAAE,CACiB;;AAGzB,IAAA,SAAS,CAAC,WAAwB,EAAA;AACzC,QAAA,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO;AAE3B,QAAA,KAAK,MAAM,CAAC,KAAK,EAAE,GAAG,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE;AACjD,YAAA,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE;AAE5B,YAAA,IAAI,GAAG,CAAC,WAAW,KAAK,WAAW,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE;gBAC1D,MAAM,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,EAAE,CAAC,KAAK,CAAC;;;AAIpC,QAAA,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,IAAI,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE;AACzC,YAAA,MAAM,SAAS;;YAEb,GAAG,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAM;AAE3D,YAAA,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,WAAW,CAAC;;;AAGzC;;;;"}
+{"version":3,"file":"zip.mjs","sources":["../../../src/core/combine/zip.mts"],"sourcesContent":["import { Arr, Optional, createQueue, expectType } from 'ts-data-forge';\nimport { type NonEmptyTuple, type Tuple } from 'ts-type-forge';\nimport { SyncChildObservableClass } from '../class/index.mjs';\nimport { source } from '../create/index.mjs';\nimport { withInitialValue } from '../operators/index.mjs';\nimport {\n  type InitializedObservable,\n  type InitializedSyncChildObservable,\n  type NonEmptyUnknownList,\n  type Observable,\n  type SyncChildObservable,\n  type TupleToQueueTuple,\n  type UpdateToken,\n  type Wrap,\n  type ZipObservable,\n  type ZipObservableRefined,\n} from '../types/index.mjs';\n\n/**\n * Combines multiple observables by pairing their emissions by index.\n * Waits for all sources to emit their nth value before emitting the nth tuple.\n * Completes when any source completes.\n *\n * @template OS - Tuple type of source observables\n * @param parents - Array of observables to zip\n * @returns A zipped observable emitting tuples of values\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  letters$  'A'       'B'       'C'\n * //  numbers$  1         2         3\n * //  zipped$   ['A',1]   ['B',2]   ['C',3]\n * //\n * //  Explanation:\n * //  - zip pairs values by their index from multiple sources\n * //  - Waits for all sources to emit at the same index\n * //  - Completes when any source completes\n *\n * const [letters$, setLetter] = createState<string>('A');\n *\n * const [numbers$, setNumber] = createState<number>(1);\n *\n * const zipped$ = zip([letters$, numbers$]);\n *\n * const valueHistory: (readonly [string, number])[] = [];\n *\n * zipped$.subscribe(([letter, num]) => {\n *   valueHistory.push([letter, num]);\n * });\n *\n * for (const letter of ['B', 'C']) {\n *   setLetter(letter);\n * }\n *\n * for (const num of [2, 3]) {\n *   setNumber(num);\n * }\n *\n * assert.deepStrictEqual(valueHistory, [\n *   ['A', 1],\n *   ['B', 2],\n *   ['C', 3],\n * ]);\n * ```\n */\nexport const zip = <const OS extends NonEmptyTuple<Observable<unknown>>>(\n  parents: OS,\n): ZipObservableRefined<OS> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  new ZipObservableClass(parents) as unknown as ZipObservableRefined<OS>;\n\nclass ZipObservableClass<const A extends NonEmptyUnknownList>\n  extends SyncChildObservableClass<A, A>\n  implements ZipObservable<A>\n{\n  readonly #queues: TupleToQueueTuple<A>;\n\n  constructor(parents: Wrap<A>) {\n    const parentsValues: Tuple.MapTo<Optional<A[number]>, A> = Arr.map(\n      parents,\n      (p) => p.getSnapshot(),\n    );\n\n    // The annotation on `initialValue` is what replaces the type assertion.\n    // `Arr.map` carries a single result element type, so it reports `A[number]`\n    // at every position, and `Tuple.MapTo<A[number], A>` — the uniform mapping\n    // — is *not* assignable back to `A`. The positional\n    // `Readonly<{ [K in keyof A]: A[K] }>` is, and TypeScript accepts the\n    // uniform result into it because the two mapped types share `keyof A`. So\n    // it is the annotation, not an assertion, that records the position-wise\n    // fact the checker cannot derive on its own.\n    const initialValue: Optional<Readonly<{ [K in keyof A]: A[K] }>> =\n      Arr.every(parentsValues, Optional.isSome)\n        ? Optional.some(Arr.map(parentsValues, (c) => c.value))\n        : Optional.none;\n\n    super({\n      parents,\n      initialValue,\n    });\n\n    this.#queues = Arr.map(parents, () => createQueue());\n  }\n\n  override tryUpdate(updateToken: UpdateToken): void {\n    const queues = this.#queues;\n\n    for (const [index, par] of this.parents.entries()) {\n      const sn = par.getSnapshot();\n\n      if (par.updateToken === updateToken && Optional.isSome(sn)) {\n        queues[index]?.enqueue(sn.value);\n      }\n    }\n\n    if (queues.every((list) => !list.isEmpty)) {\n      const nextValue =\n        // `Arr.map` has a single result element type, so it reports\n        // `A[number] | undefined` per position rather than `A[P]`.\n        // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n        Arr.map(queues, (q) => Optional.unwrap(q.dequeue())) as A;\n\n      this.setNext(nextValue, updateToken);\n    }\n  }\n}\n\nif (import.meta.vitest !== undefined) {\n  test('type test', () => {\n    expect(1).toBe(1); // dummy\n  });\n\n  {\n    const s1: Observable<1> = source<1>();\n\n    const s2: Observable<2> = source<2>();\n\n    const _d = zip([s1, s2]);\n\n    expectType<typeof _d, ZipObservable<readonly [1, 2]>>('=');\n\n    expectType<typeof _d, Observable<readonly [1, 2]>>('<=');\n  }\n\n  {\n    const s1: InitializedObservable<1> = source<1>().pipe(withInitialValue(1));\n\n    const s2: Observable<2> = source<2>();\n\n    const _d = zip([s1, s2]);\n\n    expectType<typeof _d, ZipObservable<readonly [1, 2]>>('=');\n\n    expectType<typeof _d, Observable<readonly [1, 2]>>('<=');\n  }\n\n  {\n    const s1: InitializedObservable<1> = source<1>().pipe(withInitialValue(1));\n\n    const s2: InitializedObservable<2> = source<2>().pipe(withInitialValue(2));\n\n    const _d = zip([s1, s2]);\n\n    // Returns InitializedObservable if all OS are InitializedObservable\n    expectType<typeof _d, InitializedObservable<readonly [1, 2]>>('<=');\n  }\n\n  const r1 = source(1);\n\n  const r2 = source('a');\n\n  const _z = zip([r1, r2]);\n\n  const _zi = zip([\n    r1.pipe(withInitialValue(0)),\n    r2.pipe(withInitialValue('0')),\n  ] as const);\n\n  expectType<typeof _z, SyncChildObservable<readonly [number, string]>>('<=');\n\n  expectType<\n    typeof _zi,\n    InitializedSyncChildObservable<readonly [number, string]>\n  >('<=');\n}\n"],"names":[],"mappings":";;;;AAmEO,MAAM,MAAM,CACjB,OAAA;AAAA;AAAA,EAGA,IAAI,mBAAmB,OAAO;AAAA;AAEhC,MAAM,2BACI,wBAAA,CAEV;AAAA,EACW,OAAA;AAAA,EAET,YAAY,OAAA,EAAkB;AAC5B,IAAA,MAAM,gBAAqD,GAAA,CAAI,GAAA;AAAA,MAC7D,OAAA;AAAA,MACA,CAAC,CAAA,KAAM,CAAA,CAAE,WAAA;AAAY,KACvB;AAUA,IAAA,MAAM,eACJ,GAAA,CAAI,KAAA,CAAM,eAAe,QAAA,CAAS,MAAM,IACpC,QAAA,CAAS,IAAA,CAAK,GAAA,CAAI,GAAA,CAAI,eAAe,CAAC,CAAA,KAAM,EAAE,KAAK,CAAC,IACpD,QAAA,CAAS,IAAA;AAEf,IAAA,KAAA,CAAM;AAAA,MACJ,OAAA;AAAA,MACA;AAAA,KACD,CAAA;AAED,IAAA,IAAA,CAAK,UAAU,GAAA,CAAI,GAAA,CAAI,OAAA,EAAS,MAAM,aAAa,CAAA;AAAA,EAAA;AACrD,EAES,UAAU,WAAA,EAAgC;AACjD,IAAA,MAAM,SAAS,IAAA,CAAK,OAAA;AAEpB,IAAA,KAAA,MAAW,CAAC,KAAA,EAAO,GAAG,KAAK,IAAA,CAAK,OAAA,CAAQ,SAAQ,EAAG;AACjD,MAAA,MAAM,EAAA,GAAK,IAAI,WAAA,EAAY;AAE3B,MAAA,IAAI,IAAI,WAAA,KAAgB,WAAA,IAAe,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAAG;AAC1D,QAAA,MAAA,CAAO,KAAK,CAAA,EAAG,OAAA,CAAQ,EAAA,CAAG,KAAK,CAAA;AAAA,MAAA;AACjC,IAAA;AAGF,IAAA,IAAI,OAAO,KAAA,CAAM,CAAC,SAAS,CAAC,IAAA,CAAK,OAAO,CAAA,EAAG;AACzC,MAAA,MAAM,SAAA;AAAA;AAAA;AAAA;AAAA,QAIJ,GAAA,CAAI,GAAA,CAAI,MAAA,EAAQ,CAAC,CAAA,KAAM,SAAS,MAAA,CAAO,CAAA,CAAE,OAAA,EAAS,CAAC;AAAA,OAAA;AAErD,MAAA,IAAA,CAAK,OAAA,CAAQ,WAAW,WAAW,CAAA;AAAA,IAAA;AACrC,EAAA;AAEJ;;;;"}

package/dist/core/create/counter.d.mts

@@ -33,7 +33,7 @@ import { type CounterObservable } from '../types/index.mjs';
  *
  * subscription.unsubscribe();
  *
- * assert.isTrue(Arr.isArrayAtLeastLength(valueHistory, 3));
+ * assert.isTrue(Arr.isMinLengthArray(3, valueHistory));
  *
  * assert.deepStrictEqual(valueHistory[0], 0);
  *

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

@@ -1 +1 @@
-{"version":3,"file":"counter.d.mts","sourceRoot":"","sources":["../../../src/core/create/counter.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,iBAAiB,EAAgB,MAAM,oBAAoB,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,eAAO,MAAM,OAAO,GAClB,sBAAsB,MAAM,EAC5B,UAAU,QAAQ,CAAC;IACjB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC,KACD,iBAIA,CAAC"}
+{"version":3,"file":"counter.d.mts","sourceRoot":"","sources":["../../../src/core/create/counter.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,iBAAiB,EAAgB,MAAM,oBAAoB,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,eAAO,MAAM,OAAO,yBACI,MAAM,YAClB,QAAQ,CAAC;IACjB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC,KACD,iBAIA,CAAC"}

package/dist/core/create/counter.mjs

@@ -2,95 +2,56 @@ import { Optional, asSafeUint, SafeUint } from 'ts-data-forge';
 import '../utils/id-maker.mjs';
 import { RootObservableClass } from '../class/root-observable-class.mjs';
 
-/**
- * Creates an observable that emits incremental numbers at a specified interval.
- * Starts with 0 immediately after subscription, then emits 1, 2, 3, ... every interval.
- *
- * @param intervalMilliSeconds - The interval duration in milliseconds
- * @param startManually - If true, waits for manual start (default: false)
- * @returns An observable that emits sequential numbers
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  Time(s)   0     1     2     3     4     5
- * //  tick$     0     1     2     3     4     5     ...
- * //
- * //  Explanation:
- * //  - counter emits incrementing numbers at specified intervals
- * //  - Starts at 0 and continues indefinitely
- * //  - Useful for periodic tasks or animations
- *
- * const tick$ = counter(100);
- *
- * const valueHistory: number[] = [];
- *
- * const subscription = tick$.subscribe((count) => {
- *   valueHistory.push(count);
- * });
- *
- * await new Promise((resolve) => {
- *   setTimeout(resolve, 350);
- * });
- *
- * subscription.unsubscribe();
- *
- * assert.isTrue(Arr.isArrayAtLeastLength(valueHistory, 3));
- *
- * assert.deepStrictEqual(valueHistory[0], 0);
- *
- * assert.deepStrictEqual(valueHistory[1], 1);
- *
- * assert.deepStrictEqual(valueHistory[2], 2);
- * ```
- */
-const counter = (intervalMilliSeconds, options) => new CounterObservableClass(intervalMilliSeconds, options?.startManually ?? false);
+const counter = (intervalMilliSeconds, options) => new CounterObservableClass(
+  intervalMilliSeconds,
+  options?.startManually ?? false
+);
 class CounterObservableClass extends RootObservableClass {
-    #intervalMilliSeconds;
-    #mut_counter;
-    #mut_timerId0;
-    #mut_timerId;
-    #mut_isStarted;
-    constructor(intervalMilliSeconds, startManually) {
-        super({ initialValue: Optional.none });
-        this.#intervalMilliSeconds = intervalMilliSeconds;
-        this.#mut_counter = asSafeUint(0);
-        this.#mut_timerId0 = undefined;
-        this.#mut_timerId = undefined;
-        this.#mut_isStarted = false;
-        if (!startManually) {
-            this.start();
-        }
+  #intervalMilliSeconds;
+  #mut_counter;
+  #mut_timerId0;
+  #mut_timerId;
+  #mut_isStarted;
+  constructor(intervalMilliSeconds, startManually) {
+    super({ initialValue: Optional.none });
+    this.#intervalMilliSeconds = intervalMilliSeconds;
+    this.#mut_counter = asSafeUint(0);
+    this.#mut_timerId0 = void 0;
+    this.#mut_timerId = void 0;
+    this.#mut_isStarted = false;
+    if (!startManually) {
+      this.start();
     }
-    start() {
-        if (this.#mut_isStarted) {
-            console.warn('cannot start twice');
-            return;
-        }
-        this.#mut_isStarted = true;
-        if (this.isCompleted) {
-            console.warn('cannot restart stopped CounterObservable');
-            return;
-        }
-        this.#mut_timerId0 = setTimeout(() => {
-            this.startUpdate(this.#mut_counter);
-        }, 0);
-        this.#mut_timerId = setInterval(() => {
-            this.#mut_counter = SafeUint.add(1, this.#mut_counter);
-            this.startUpdate(this.#mut_counter);
-        }, this.#intervalMilliSeconds);
+  }
+  #resetTimer() {
+    if (this.#mut_timerId0 === void 0 || this.#mut_timerId === void 0) {
+      return;
     }
-    #resetTimer() {
-        if (this.#mut_timerId0 !== undefined && this.#mut_timerId !== undefined) {
-            clearInterval(this.#mut_timerId0);
-            clearInterval(this.#mut_timerId);
-        }
+    clearInterval(this.#mut_timerId0);
+    clearInterval(this.#mut_timerId);
+  }
+  start() {
+    if (this.#mut_isStarted) {
+      console.warn("cannot start twice");
+      return;
     }
-    complete() {
-        this.#resetTimer();
-        super.complete();
+    this.#mut_isStarted = true;
+    if (this.isCompleted) {
+      console.warn("cannot restart stopped CounterObservable");
+      return;
     }
+    this.#mut_timerId0 = setTimeout(() => {
+      this.startUpdate(this.#mut_counter);
+    }, 0);
+    this.#mut_timerId = setInterval(() => {
+      this.#mut_counter = SafeUint.add(1, this.#mut_counter);
+      this.startUpdate(this.#mut_counter);
+    }, this.#intervalMilliSeconds);
+  }
+  complete() {
+    this.#resetTimer();
+    super.complete();
+  }
 }
 
 export { counter };

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

@@ -1 +1 @@
-{"version":3,"file":"counter.mjs","sources":["../../../src/core/create/counter.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CG;MACU,OAAO,GAAG,CACrB,oBAA4B,EAC5B,OAEE,KAEF,IAAI,sBAAsB,CACxB,oBAAoB,EACpB,OAAO,EAAE,aAAa,IAAI,KAAK;AAGnC,MAAM,sBACJ,SAAQ,mBAA6B,CAAA;AAG5B,IAAA,qBAAqB;AAC9B,IAAA,YAAY;AACZ,IAAA,aAAa;AACb,IAAA,YAAY;AACZ,IAAA,cAAc;IAEd,WAAA,CAAY,oBAA4B,EAAE,aAAsB,EAAA;QAC9D,KAAK,CAAC,EAAE,YAAY,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC;AAEtC,QAAA,IAAI,CAAC,qBAAqB,GAAG,oBAAoB;AAEjD,QAAA,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,CAAC,CAAC;AAEjC,QAAA,IAAI,CAAC,aAAa,GAAG,SAAS;AAE9B,QAAA,IAAI,CAAC,YAAY,GAAG,SAAS;AAE7B,QAAA,IAAI,CAAC,cAAc,GAAG,KAAK;QAE3B,IAAI,CAAC,aAAa,EAAE;YAClB,IAAI,CAAC,KAAK,EAAE;QACd;IACF;IAEA,KAAK,GAAA;AACH,QAAA,IAAI,IAAI,CAAC,cAAc,EAAE;AACvB,YAAA,OAAO,CAAC,IAAI,CAAC,oBAAoB,CAAC;YAElC;QACF;AAEA,QAAA,IAAI,CAAC,cAAc,GAAG,IAAI;AAE1B,QAAA,IAAI,IAAI,CAAC,WAAW,EAAE;AACpB,YAAA,OAAO,CAAC,IAAI,CAAC,0CAA0C,CAAC;YAExD;QACF;AAEA,QAAA,IAAI,CAAC,aAAa,GAAG,UAAU,CAAC,MAAK;AACnC,YAAA,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,YAAY,CAAC;QACrC,CAAC,EAAE,CAAC,CAAC;AAEL,QAAA,IAAI,CAAC,YAAY,GAAG,WAAW,CAAC,MAAK;AACnC,YAAA,IAAI,CAAC,YAAY,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,YAAY,CAAC;AAEtD,YAAA,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,YAAY,CAAC;AACrC,QAAA,CAAC,EAAE,IAAI,CAAC,qBAAqB,CAAC;IAChC;IAEA,WAAW,GAAA;AACT,QAAA,IAAI,IAAI,CAAC,aAAa,KAAK,SAAS,IAAI,IAAI,CAAC,YAAY,KAAK,SAAS,EAAE;AACvE,YAAA,aAAa,CAAC,IAAI,CAAC,aAAa,CAAC;AAEjC,YAAA,aAAa,CAAC,IAAI,CAAC,YAAY,CAAC;QAClC;IACF;IAES,QAAQ,GAAA;QACf,IAAI,CAAC,WAAW,EAAE;QAElB,KAAK,CAAC,QAAQ,EAAE;IAClB;AACD;;;;"}
+{"version":3,"file":"counter.mjs","sources":["../../../src/core/create/counter.mts"],"sourcesContent":["import { asSafeUint, Optional, SafeUint } from 'ts-data-forge';\nimport { RootObservableClass } from '../class/index.mjs';\nimport { type CounterObservable, type TimerId } from '../types/index.mjs';\n\n/**\n * Creates an observable that emits incremental numbers at a specified interval.\n * Starts with 0 immediately after subscription, then emits 1, 2, 3, ... every interval.\n *\n * @param intervalMilliSeconds - The interval duration in milliseconds\n * @param startManually - If true, waits for manual start (default: false)\n * @returns An observable that emits sequential numbers\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  Time(s)   0     1     2     3     4     5\n * //  tick$     0     1     2     3     4     5     ...\n * //\n * //  Explanation:\n * //  - counter emits incrementing numbers at specified intervals\n * //  - Starts at 0 and continues indefinitely\n * //  - Useful for periodic tasks or animations\n *\n * const tick$ = counter(100);\n *\n * const valueHistory: number[] = [];\n *\n * const subscription = tick$.subscribe((count) => {\n *   valueHistory.push(count);\n * });\n *\n * await new Promise((resolve) => {\n *   setTimeout(resolve, 350);\n * });\n *\n * subscription.unsubscribe();\n *\n * assert.isTrue(Arr.isMinLengthArray(3, valueHistory));\n *\n * assert.deepStrictEqual(valueHistory[0], 0);\n *\n * assert.deepStrictEqual(valueHistory[1], 1);\n *\n * assert.deepStrictEqual(valueHistory[2], 2);\n * ```\n */\nexport const counter = (\n  intervalMilliSeconds: number,\n  options?: Readonly<{\n    startManually?: boolean;\n  }>,\n): CounterObservable =>\n  new CounterObservableClass(\n    intervalMilliSeconds,\n    options?.startManually ?? false,\n  );\n\nclass CounterObservableClass\n  extends RootObservableClass<SafeUint>\n  implements CounterObservable\n{\n  readonly #intervalMilliSeconds: number;\n  #mut_counter: SafeUint;\n  #mut_timerId0: TimerId | undefined;\n  #mut_timerId: TimerId | undefined;\n  #mut_isStarted: boolean;\n\n  constructor(intervalMilliSeconds: number, startManually: boolean) {\n    super({ initialValue: Optional.none });\n\n    this.#intervalMilliSeconds = intervalMilliSeconds;\n\n    this.#mut_counter = asSafeUint(0);\n\n    this.#mut_timerId0 = undefined;\n\n    this.#mut_timerId = undefined;\n\n    this.#mut_isStarted = false;\n\n    if (!startManually) {\n      this.start();\n    }\n  }\n\n  #resetTimer(): void {\n    if (this.#mut_timerId0 === undefined || this.#mut_timerId === undefined) {\n      return;\n    }\n\n    clearInterval(this.#mut_timerId0);\n\n    clearInterval(this.#mut_timerId);\n  }\n\n  start(): void {\n    if (this.#mut_isStarted) {\n      console.warn('cannot start twice');\n\n      return;\n    }\n\n    this.#mut_isStarted = true;\n\n    if (this.isCompleted) {\n      console.warn('cannot restart stopped CounterObservable');\n\n      return;\n    }\n\n    this.#mut_timerId0 = setTimeout(() => {\n      this.startUpdate(this.#mut_counter);\n    }, 0);\n\n    this.#mut_timerId = setInterval(() => {\n      this.#mut_counter = SafeUint.add(1, this.#mut_counter);\n\n      this.startUpdate(this.#mut_counter);\n    }, this.#intervalMilliSeconds);\n  }\n\n  override complete(): void {\n    this.#resetTimer();\n\n    super.complete();\n  }\n}\n"],"names":[],"mappings":";;;;AA+CO,MAAM,OAAA,GAAU,CACrB,oBAAA,EACA,OAAA,KAIA,IAAI,sBAAA;AAAA,EACF,oBAAA;AAAA,EACA,SAAS,aAAA,IAAiB;AAC5B;AAEF,MAAM,+BACI,mBAAA,CAEV;AAAA,EACW,qBAAA;AAAA,EACT,YAAA;AAAA,EACA,aAAA;AAAA,EACA,YAAA;AAAA,EACA,cAAA;AAAA,EAEA,WAAA,CAAY,sBAA8B,aAAA,EAAwB;AAChE,IAAA,KAAA,CAAM,EAAE,YAAA,EAAc,QAAA,CAAS,IAAA,EAAM,CAAA;AAErC,IAAA,IAAA,CAAK,qBAAA,GAAwB,oBAAA;AAE7B,IAAA,IAAA,CAAK,YAAA,GAAe,WAAW,CAAC,CAAA;AAEhC,IAAA,IAAA,CAAK,aAAA,GAAgB,MAAA;AAErB,IAAA,IAAA,CAAK,YAAA,GAAe,MAAA;AAEpB,IAAA,IAAA,CAAK,cAAA,GAAiB,KAAA;AAEtB,IAAA,IAAI,CAAC,aAAA,EAAe;AAClB,MAAA,IAAA,CAAK,KAAA,EAAM;AAAA,IACb;AAAA,EACF;AAAA,EAEA,WAAA,GAAoB;AAClB,IAAA,IAAI,IAAA,CAAK,aAAA,KAAkB,MAAA,IAAa,IAAA,CAAK,iBAAiB,MAAA,EAAW;AACvE,MAAA;AAAA,IACF;AAEA,IAAA,aAAA,CAAc,KAAK,aAAa,CAAA;AAEhC,IAAA,aAAA,CAAc,KAAK,YAAY,CAAA;AAAA,EACjC;AAAA,EAEA,KAAA,GAAc;AACZ,IAAA,IAAI,KAAK,cAAA,EAAgB;AACvB,MAAA,OAAA,CAAQ,KAAK,oBAAoB,CAAA;AAEjC,MAAA;AAAA,IACF;AAEA,IAAA,IAAA,CAAK,cAAA,GAAiB,IAAA;AAEtB,IAAA,IAAI,KAAK,WAAA,EAAa;AACpB,MAAA,OAAA,CAAQ,KAAK,0CAA0C,CAAA;AAEvD,MAAA;AAAA,IACF;AAEA,IAAA,IAAA,CAAK,aAAA,GAAgB,WAAW,MAAM;AACpC,MAAA,IAAA,CAAK,WAAA,CAAY,KAAK,YAAY,CAAA;AAAA,IACpC,GAAG,CAAC,CAAA;AAEJ,IAAA,IAAA,CAAK,YAAA,GAAe,YAAY,MAAM;AACpC,MAAA,IAAA,CAAK,YAAA,GAAe,QAAA,CAAS,GAAA,CAAI,CAAA,EAAG,KAAK,YAAY,CAAA;AAErD,MAAA,IAAA,CAAK,WAAA,CAAY,KAAK,YAAY,CAAA;AAAA,IACpC,CAAA,EAAG,KAAK,qBAAqB,CAAA;AAAA,EAC/B;AAAA,EAES,QAAA,GAAiB;AACxB,IAAA,IAAA,CAAK,WAAA,EAAY;AAEjB,IAAA,KAAA,CAAM,QAAA,EAAS;AAAA,EACjB;AACF;;;;"}

package/dist/core/create/from-abortable-promise.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"from-abortable-promise.d.mts","sourceRoot":"","sources":["../../../src/core/create/from-abortable-promise.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,oBAAoB,GAAI,CAAC,EAAE,CAAC,GAAG,OAAO,EAEjD,SAAS,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,KAC3C,qBAAqB,CAAC,CAAC,EAAE,CAAC,CACqB,CAAC"}
+{"version":3,"file":"from-abortable-promise.d.mts","sourceRoot":"","sources":["../../../src/core/create/from-abortable-promise.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,oBAAoB,GAAI,CAAC,EAAE,CAAC,GAAG,OAAO,WAExC,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,KAC3C,qBAAqB,CAAC,CAAC,EAAE,CAAC,CACqB,CAAC"}

package/dist/core/create/from-abortable-promise.mjs

@@ -2,68 +2,36 @@ import { Optional, Result } from 'ts-data-forge';
 import '../utils/id-maker.mjs';
 import { RootObservableClass } from '../class/root-observable-class.mjs';
 
-/**
- * Creates an observable from a Promise factory that receives an `AbortSignal`.
- * When the observable is completed (e.g., by `switchMap` switching to a new
- * inner observable), the `AbortController` is automatically aborted, cancelling
- * the in-flight request.
- *
- * Emits `Result.ok(value)` when the promise resolves, or `Result.err(error)`
- * when it rejects. Rejections caused by abort (`AbortError`) are silently
- * ignored and do not emit.
- *
- * @template A - The type of the resolved value
- * @template E - The type of the error (excluding AbortError)
- * @param factory - A function that receives an `AbortSignal` and returns a Promise
- * @returns An observable that emits the promise result
- *
- * @example
- * ```ts
- * const results$ = query.pipe(
- *   switchMap((q) =>
- *     fromAbortablePromise((signal) =>
- *       fetch(`/api/search?q=${q}`, { signal }).then((r) => r.json()),
- *     ),
- *   ),
- * );
- * ```
- */
-const fromAbortablePromise = (
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-factory) => new FromAbortablePromiseObservableClass(factory);
+const fromAbortablePromise = (factory) => new FromAbortablePromiseObservableClass(factory);
 class FromAbortablePromiseObservableClass extends RootObservableClass {
-    #abortController;
-    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-    constructor(factory) {
-        super({ initialValue: Optional.none });
-        this.#abortController = new AbortController();
-        const promise = factory(this.#abortController.signal);
-        promise
-            .then((value) => {
-            if (this.isCompleted)
-                return;
-            this.startUpdate(Result.ok(value));
-        })
-            .catch((error) => {
-            if (this.isCompleted)
-                return;
-            // Silently ignore AbortError — it means the observable was
-            // intentionally completed (e.g., by switchMap).
-            if (error instanceof DOMException && error.name === 'AbortError') {
-                return;
-            }
-            this.startUpdate(Result.err(
-            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-            error));
-        })
-            .finally(() => {
-            this.complete();
-        });
-    }
-    complete() {
-        this.#abortController.abort();
-        super.complete();
-    }
+  #abortController;
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  constructor(factory) {
+    super({ initialValue: Optional.none });
+    this.#abortController = new AbortController();
+    const promise = factory(this.#abortController.signal);
+    promise.then((value) => {
+      if (this.isCompleted) return;
+      this.startUpdate(Result.ok(value));
+    }).catch((error) => {
+      if (this.isCompleted) return;
+      if (error instanceof DOMException && error.name === "AbortError") {
+        return;
+      }
+      this.startUpdate(
+        Result.err(
+          // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+          error
+        )
+      );
+    }).finally(() => {
+      this.complete();
+    });
+  }
+  complete() {
+    this.#abortController.abort();
+    super.complete();
+  }
 }
 
 export { fromAbortablePromise };

package/dist/core/create/from-abortable-promise.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"from-abortable-promise.mjs","sources":["../../../src/core/create/from-abortable-promise.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;AACI,MAAM,oBAAoB,GAAG;AAClC;AACA,OAA4C,KAE5C,IAAI,mCAAmC,CAAC,OAAO;AAEjD,MAAM,mCACJ,SAAQ,mBAAiC,CAAA;AAGhC,IAAA,gBAAgB;;AAGzB,IAAA,WAAA,CAAY,OAA4C,EAAA;QACtD,KAAK,CAAC,EAAE,YAAY,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC;AAEtC,QAAA,IAAI,CAAC,gBAAgB,GAAG,IAAI,eAAe,EAAE;QAE7C,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC;QAErD;AACG,aAAA,IAAI,CAAC,CAAC,KAAK,KAAI;YACd,IAAI,IAAI,CAAC,WAAW;gBAAE;YAEtB,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;AACpC,QAAA,CAAC;AACA,aAAA,KAAK,CAAC,CAAC,KAAc,KAAI;YACxB,IAAI,IAAI,CAAC,WAAW;gBAAE;;;YAItB,IAAI,KAAK,YAAY,YAAY,IAAI,KAAK,CAAC,IAAI,KAAK,YAAY,EAAE;gBAChE;YACF;AAEA,YAAA,IAAI,CAAC,WAAW,CACd,MAAM,CAAC,GAAG;;YAER,KAAU,CACX,CACF;AACH,QAAA,CAAC;aACA,OAAO,CAAC,MAAK;YACZ,IAAI,CAAC,QAAQ,EAAE;AACjB,QAAA,CAAC,CAAC;IACN;IAES,QAAQ,GAAA;AACf,QAAA,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE;QAE7B,KAAK,CAAC,QAAQ,EAAE;IAClB;AACD;;;;"}
+{"version":3,"file":"from-abortable-promise.mjs","sources":["../../../src/core/create/from-abortable-promise.mts"],"sourcesContent":["import { Optional, Result } from 'ts-data-forge';\nimport { RootObservableClass } from '../class/index.mjs';\nimport { type FromPromiseObservable } from '../types/index.mjs';\n\n/**\n * Creates an observable from a Promise factory that receives an `AbortSignal`.\n * When the observable is completed (e.g., by `switchMap` switching to a new\n * inner observable), the `AbortController` is automatically aborted, cancelling\n * the in-flight request.\n *\n * Emits `Result.ok(value)` when the promise resolves, or `Result.err(error)`\n * when it rejects. Rejections caused by abort (`AbortError`) are silently\n * ignored and do not emit.\n *\n * @template A - The type of the resolved value\n * @template E - The type of the error (excluding AbortError)\n * @param factory - A function that receives an `AbortSignal` and returns a Promise\n * @returns An observable that emits the promise result\n *\n * @example\n * ```ts\n * const results$ = query.pipe(\n *   switchMap((q) =>\n *     fromAbortablePromise((signal) =>\n *       fetch(`/api/search?q=${q}`, { signal }).then((r) => r.json()),\n *     ),\n *   ),\n * );\n * ```\n */\nexport const fromAbortablePromise = <A, E = unknown>(\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n  factory: (signal: AbortSignal) => Promise<A>,\n): FromPromiseObservable<A, E> =>\n  new FromAbortablePromiseObservableClass(factory);\n\nclass FromAbortablePromiseObservableClass<A, E = unknown>\n  extends RootObservableClass<Result<A, E>>\n  implements FromPromiseObservable<A, E>\n{\n  readonly #abortController: AbortController;\n\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n  constructor(factory: (signal: AbortSignal) => Promise<A>) {\n    super({ initialValue: Optional.none });\n\n    this.#abortController = new AbortController();\n\n    const promise = factory(this.#abortController.signal);\n\n    promise\n      .then((value) => {\n        if (this.isCompleted) return;\n\n        this.startUpdate(Result.ok(value));\n      })\n      .catch((error: unknown) => {\n        if (this.isCompleted) return;\n\n        // Silently ignore AbortError — it means the observable was\n        // intentionally completed (e.g., by switchMap).\n        if (error instanceof DOMException && error.name === 'AbortError') {\n          return;\n        }\n\n        this.startUpdate(\n          Result.err(\n            // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n            error as E,\n          ),\n        );\n      })\n      .finally(() => {\n        this.complete();\n      });\n  }\n\n  override complete(): void {\n    this.#abortController.abort();\n\n    super.complete();\n  }\n}\n"],"names":[],"mappings":";;;;AA8BO,MAAM,oBAAA,GAAuB,CAElC,OAAA,KAEA,IAAI,oCAAoC,OAAO;AAEjD,MAAM,4CACI,mBAAA,CAEV;AAAA,EACW,gBAAA;AAAA;AAAA,EAGT,YAAY,OAAA,EAA8C;AACxD,IAAA,KAAA,CAAM,EAAE,YAAA,EAAc,QAAA,CAAS,IAAA,EAAM,CAAA;AAErC,IAAA,IAAA,CAAK,gBAAA,GAAmB,IAAI,eAAA,EAAgB;AAE5C,IAAA,MAAM,OAAA,GAAU,OAAA,CAAQ,IAAA,CAAK,gBAAA,CAAiB,MAAM,CAAA;AAEpD,IAAA,OAAA,CACG,IAAA,CAAK,CAAC,KAAA,KAAU;AACf,MAAA,IAAI,KAAK,WAAA,EAAa;AAEtB,MAAA,IAAA,CAAK,WAAA,CAAY,MAAA,CAAO,EAAA,CAAG,KAAK,CAAC,CAAA;AAAA,IACnC,CAAC,CAAA,CACA,KAAA,CAAM,CAAC,KAAA,KAAmB;AACzB,MAAA,IAAI,KAAK,WAAA,EAAa;AAItB,MAAA,IAAI,KAAA,YAAiB,YAAA,IAAgB,KAAA,CAAM,IAAA,KAAS,YAAA,EAAc;AAChE,QAAA;AAAA,MACF;AAEA,MAAA,IAAA,CAAK,WAAA;AAAA,QACH,MAAA,CAAO,GAAA;AAAA;AAAA,UAEL;AAAA;AACF,OACF;AAAA,IACF,CAAC,CAAA,CACA,OAAA,CAAQ,MAAM;AACb,MAAA,IAAA,CAAK,QAAA,EAAS;AAAA,IAChB,CAAC,CAAA;AAAA,EACL;AAAA,EAES,QAAA,GAAiB;AACxB,IAAA,IAAA,CAAK,iBAAiB,KAAA,EAAM;AAE5B,IAAA,KAAA,CAAM,QAAA,EAAS;AAAA,EACjB;AACF;;;;"}

package/dist/core/create/from-promise.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"from-promise.d.mts","sourceRoot":"","sources":["../../../src/core/create/from-promise.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,EAAE,CAAC,GAAG,OAAO,EACxC,SAAS,OAAO,CAAC,CAAC,CAAC,KAClB,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAA4C,CAAC"}
+{"version":3,"file":"from-promise.d.mts","sourceRoot":"","sources":["../../../src/core/create/from-promise.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,EAAE,CAAC,GAAG,OAAO,WAC/B,OAAO,CAAC,CAAC,CAAC,KAClB,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAA4C,CAAC"}