synstate 1.0.1 → 2.0.0

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

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

@@ -2,74 +2,25 @@ 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.
- * Emits Result.ok when the promise resolves, or Result.err when it rejects.
- *
- * @template A - The type of the resolved value
- * @template E - The type of the error
- * @param promise - The promise to convert to observable
- * @returns An observable that emits the promise result
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  promise     [pending...]  -> resolved/rejected
- * //  data$                        Ok(value) or Err(error)
- * //
- * //  Explanation:
- * //  - fromPromise converts a Promise into an observable
- * //  - Emits a Result type: Ok(value) on success, Err(error) on failure
- * //  - Completes after emitting the result
- * //  - Useful for integrating async operations into reactive flows
- *
- * const fetchData = async (): Promise<Readonly<{ value: number }>> =>
- *   ({
- *     value: 42,
- *   }) as const;
- *
- * const data$ = fromPromise(fetchData());
- *
- * const valueHistory: Readonly<{ value: number }>[] = [];
- *
- * await new Promise<void>((resolve) => {
- *   data$.subscribe(
- *     (result) => {
- *       if (Result.isOk(result)) {
- *         valueHistory.push(result.value);
- *       }
- *     },
- *     () => {
- *       resolve();
- *     },
- *   );
- * });
- *
- * assert.deepStrictEqual(valueHistory, [{ value: 42 }]);
- * ```
- */
 const fromPromise = (promise) => new FromPromiseObservableClass(promise);
 class FromPromiseObservableClass extends RootObservableClass {
-    constructor(promise) {
-        super({ initialValue: Optional.none });
-        promise
-            .then((value) => {
-            if (this.isCompleted)
-                return;
-            this.startUpdate(Result.ok(value));
-        })
-            .catch((error) => {
-            if (this.isCompleted)
-                return;
-            this.startUpdate(Result.err(
-            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-            error));
-        })
-            .finally(() => {
-            this.complete();
-        });
-    }
+  constructor(promise) {
+    super({ initialValue: Optional.none });
+    promise.then((value) => {
+      if (this.isCompleted) return;
+      this.startUpdate(Result.ok(value));
+    }).catch((error) => {
+      if (this.isCompleted) return;
+      this.startUpdate(
+        Result.err(
+          // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+          error
+        )
+      );
+    }).finally(() => {
+      this.complete();
+    });
+  }
 }
 
 export { fromPromise };

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

@@ -1 +1 @@
-{"version":3,"file":"from-promise.mjs","sources":["../../../src/core/create/from-promise.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8CG;AACI,MAAM,WAAW,GAAG,CACzB,OAAmB,KACa,IAAI,0BAA0B,CAAC,OAAO;AAExE,MAAM,0BACJ,SAAQ,mBAAiC,CAAA;AAGzC,IAAA,WAAA,CAAY,OAAmB,EAAA;QAC7B,KAAK,CAAC,EAAE,YAAY,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC;QAEtC;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;AAEtB,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;AACD;;;;"}
+{"version":3,"file":"from-promise.mjs","sources":["../../../src/core/create/from-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.\n * Emits Result.ok when the promise resolves, or Result.err when it rejects.\n *\n * @template A - The type of the resolved value\n * @template E - The type of the error\n * @param promise - The promise to convert to observable\n * @returns An observable that emits the promise result\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  promise     [pending...]  -> resolved/rejected\n * //  data$                        Ok(value) or Err(error)\n * //\n * //  Explanation:\n * //  - fromPromise converts a Promise into an observable\n * //  - Emits a Result type: Ok(value) on success, Err(error) on failure\n * //  - Completes after emitting the result\n * //  - Useful for integrating async operations into reactive flows\n *\n * const fetchData = async (): Promise<Readonly<{ value: number }>> =>\n *   ({\n *     value: 42,\n *   }) as const;\n *\n * const data$ = fromPromise(fetchData());\n *\n * const valueHistory: Readonly<{ value: number }>[] = [];\n *\n * await new Promise<void>((resolve) => {\n *   data$.subscribe(\n *     (result) => {\n *       if (Result.isOk(result)) {\n *         valueHistory.push(result.value);\n *       }\n *     },\n *     () => {\n *       resolve();\n *     },\n *   );\n * });\n *\n * assert.deepStrictEqual(valueHistory, [{ value: 42 }]);\n * ```\n */\nexport const fromPromise = <A, E = unknown>(\n  promise: Promise<A>,\n): FromPromiseObservable<A, E> => new FromPromiseObservableClass(promise);\n\nclass FromPromiseObservableClass<A, E = unknown>\n  extends RootObservableClass<Result<A, E>>\n  implements FromPromiseObservable<A, E>\n{\n  constructor(promise: Promise<A>) {\n    super({ initialValue: Optional.none });\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        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"],"names":[],"mappings":";;;;AAmDO,MAAM,WAAA,GAAc,CACzB,OAAA,KACgC,IAAI,2BAA2B,OAAO;AAExE,MAAM,mCACI,mBAAA,CAEV;AAAA,EACE,YAAY,OAAA,EAAqB;AAC/B,IAAA,KAAA,CAAM,EAAE,YAAA,EAAc,QAAA,CAAS,IAAA,EAAM,CAAA;AAErC,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;AAEtB,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;AACF;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"from-subscribable.d.mts","sourceRoot":"","sources":["../../../src/core/create/from-subscribable.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,0BAA0B,EAC/B,KAAK,YAAY,EAClB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,EAAE,CAAC,GAAG,OAAO,EAC7C,cAAc,YAAY,CAAC,CAAC,CAAC,KAC5B,0BAA0B,CAAC,CAAC,EAAE,CAAC,CACiB,CAAC"}
+{"version":3,"file":"from-subscribable.d.mts","sourceRoot":"","sources":["../../../src/core/create/from-subscribable.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,0BAA0B,EAC/B,KAAK,YAAY,EAClB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,EAAE,CAAC,GAAG,OAAO,gBAC/B,YAAY,CAAC,CAAC,CAAC,KAC5B,0BAA0B,CAAC,CAAC,EAAE,CAAC,CACiB,CAAC"}

package/dist/core/create/from-subscribable.mjs

@@ -2,78 +2,27 @@ import { Optional, Result } from 'ts-data-forge';
 import '../utils/id-maker.mjs';
 import { RootObservableClass } from '../class/root-observable-class.mjs';
 
-/**
- * Converts any subscribable object into a SynState Observable.
- * Works with objects that have a subscribe(onNext, onError, onComplete) method.
- *
- * @template A - The type of values from the subscribable
- * @template E - The type of errors from the subscribable
- * @param subscribable - An object with a subscribe method
- * @returns An observable that wraps values in Result type
- *
- * @example
- * ```ts
- * //  Explanation:
- * //  - fromSubscribable converts any subscribable object into a SynState Observable
- * //  - Works with objects that have a subscribe(onNext, onError, onComplete) method
- * //  - Wraps values in Result type for error handling
- * //  - Useful for integrating with other reactive libraries or custom subscribables
- *
- * // Example: Converting a custom subscribable
- * const customSubscribable = {
- *   subscribe: (
- *     onNext: (value: number) => void,
- *     _onError?: (error: unknown) => void,
- *     onComplete?: () => void,
- *   ) => {
- *     setTimeout(() => {
- *       onNext(1);
- *
- *       onNext(2);
- *
- *       onNext(3);
- *
- *       onComplete?.();
- *     }, 0);
- *
- *     return { unsubscribe: () => {} };
- *   },
- * } as const;
- *
- * const observable$ = fromSubscribable<number>(customSubscribable);
- *
- * const valueHistory: number[] = [];
- *
- * await new Promise<void>((resolve) => {
- *   observable$.subscribe(
- *     (result) => {
- *       if (Result.isOk(result)) {
- *         valueHistory.push(result.value);
- *       }
- *     },
- *     () => {
- *       resolve();
- *     },
- *   );
- * });
- *
- * assert.deepStrictEqual(valueHistory, [1, 2, 3]);
- * ```
- */
 const fromSubscribable = (subscribable) => new FromSubscribableObservableClass(subscribable);
 class FromSubscribableObservableClass extends RootObservableClass {
-    constructor(subscribable) {
-        super({ initialValue: Optional.none });
-        subscribable.subscribe((nextValue) => {
-            this.startUpdate(Result.ok(nextValue));
-        }, (error) => {
-            this.startUpdate(Result.err(
+  constructor(subscribable) {
+    super({ initialValue: Optional.none });
+    subscribable.subscribe(
+      (nextValue) => {
+        this.startUpdate(Result.ok(nextValue));
+      },
+      (error) => {
+        this.startUpdate(
+          Result.err(
             // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-            error));
-        }, () => {
-            this.complete();
-        });
-    }
+            error
+          )
+        );
+      },
+      () => {
+        this.complete();
+      }
+    );
+  }
 }
 
 export { fromSubscribable };

package/dist/core/create/from-subscribable.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"from-subscribable.mjs","sources":["../../../src/core/create/from-subscribable.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDG;AACI,MAAM,gBAAgB,GAAG,CAC9B,YAA6B,KAE7B,IAAI,+BAA+B,CAAC,YAAY;AAElD,MAAM,+BACJ,SAAQ,mBAAiC,CAAA;AAGzC,IAAA,WAAA,CAAY,YAA6B,EAAA;QACvC,KAAK,CAAC,EAAE,YAAY,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC;AAEtC,QAAA,YAAY,CAAC,SAAS,CACpB,CAAC,SAAS,KAAI;YACZ,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC;AACxC,QAAA,CAAC,EACD,CAAC,KAAe,KAAI;AAClB,YAAA,IAAI,CAAC,WAAW,CACd,MAAM,CAAC,GAAG;;YAER,KAAU,CACX,CACF;QACH,CAAC,EACD,MAAK;YACH,IAAI,CAAC,QAAQ,EAAE;AACjB,QAAA,CAAC,CACF;IACH;AACD;;;;"}
+{"version":3,"file":"from-subscribable.mjs","sources":["../../../src/core/create/from-subscribable.mts"],"sourcesContent":["import { Optional, Result } from 'ts-data-forge';\nimport { RootObservableClass } from '../class/index.mjs';\nimport {\n  type FromSubscribableObservable,\n  type Subscribable,\n} from '../types/index.mjs';\n\n/**\n * Converts any subscribable object into a SynState Observable.\n * Works with objects that have a subscribe(onNext, onError, onComplete) method.\n *\n * @template A - The type of values from the subscribable\n * @template E - The type of errors from the subscribable\n * @param subscribable - An object with a subscribe method\n * @returns An observable that wraps values in Result type\n *\n * @example\n * ```ts\n * //  Explanation:\n * //  - fromSubscribable converts any subscribable object into a SynState Observable\n * //  - Works with objects that have a subscribe(onNext, onError, onComplete) method\n * //  - Wraps values in Result type for error handling\n * //  - Useful for integrating with other reactive libraries or custom subscribables\n *\n * // Example: Converting a custom subscribable\n * const customSubscribable = {\n *   subscribe: (\n *     onNext: (value: number) => void,\n *     _onError?: (error: unknown) => void,\n *     onComplete?: () => void,\n *   ) => {\n *     setTimeout(() => {\n *       onNext(1);\n *\n *       onNext(2);\n *\n *       onNext(3);\n *\n *       onComplete?.();\n *     }, 0);\n *\n *     return { unsubscribe: () => {} };\n *   },\n * } as const;\n *\n * const observable$ = fromSubscribable<number>(customSubscribable);\n *\n * const valueHistory: number[] = [];\n *\n * await new Promise<void>((resolve) => {\n *   observable$.subscribe(\n *     (result) => {\n *       if (Result.isOk(result)) {\n *         valueHistory.push(result.value);\n *       }\n *     },\n *     () => {\n *       resolve();\n *     },\n *   );\n * });\n *\n * assert.deepStrictEqual(valueHistory, [1, 2, 3]);\n * ```\n */\nexport const fromSubscribable = <A, E = unknown>(\n  subscribable: Subscribable<A>,\n): FromSubscribableObservable<A, E> =>\n  new FromSubscribableObservableClass(subscribable);\n\nclass FromSubscribableObservableClass<A, E = unknown>\n  extends RootObservableClass<Result<A, E>>\n  implements FromSubscribableObservable<A, E>\n{\n  constructor(subscribable: Subscribable<A>) {\n    super({ initialValue: Optional.none });\n\n    subscribable.subscribe(\n      (nextValue) => {\n        this.startUpdate(Result.ok(nextValue));\n      },\n      (error?: unknown) => {\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      () => {\n        this.complete();\n      },\n    );\n  }\n}\n"],"names":[],"mappings":";;;;AAiEO,MAAM,gBAAA,GAAmB,CAC9B,YAAA,KAEA,IAAI,gCAAgC,YAAY;AAElD,MAAM,wCACI,mBAAA,CAEV;AAAA,EACE,YAAY,YAAA,EAA+B;AACzC,IAAA,KAAA,CAAM,EAAE,YAAA,EAAc,QAAA,CAAS,IAAA,EAAM,CAAA;AAErC,IAAA,YAAA,CAAa,SAAA;AAAA,MACX,CAAC,SAAA,KAAc;AACb,QAAA,IAAA,CAAK,WAAA,CAAY,MAAA,CAAO,EAAA,CAAG,SAAS,CAAC,CAAA;AAAA,MACvC,CAAA;AAAA,MACA,CAAC,KAAA,KAAoB;AACnB,QAAA,IAAA,CAAK,WAAA;AAAA,UACH,MAAA,CAAO,GAAA;AAAA;AAAA,YAEL;AAAA;AACF,SACF;AAAA,MACF,CAAA;AAAA,MACA,MAAM;AACJ,QAAA,IAAA,CAAK,QAAA,EAAS;AAAA,MAChB;AAAA,KACF;AAAA,EACF;AACF;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"just.d.mts","sourceRoot":"","sources":["../../../src/core/create/just.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,IAAI,GAAI,KAAK,CAAC,CAAC,EAAG,OAAO,CAAC,KAAG,yBAAyB,CAAC,CAAC,CASpE,CAAC"}
+{"version":3,"file":"just.d.mts","sourceRoot":"","sources":["../../../src/core/create/just.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,IAAI,GAAI,KAAK,CAAC,CAAC,SAAU,CAAC,KAAG,yBAAyB,CAAC,CAAC,CASpE,CAAC"}

package/dist/core/create/just.mjs

@@ -2,42 +2,12 @@ import { Optional } from 'ts-data-forge';
 import '../utils/id-maker.mjs';
 import { RootObservableClass } from '../class/root-observable-class.mjs';
 
-/**
- * Creates an Observable that holds a single static value and immediately
- * completes. Useful inside `switchMap` to emit a fallback value when no
- * asynchronous work is needed.
- *
- * @template A - The type of the value
- * @param value - The value to emit
- * @returns An initialized Observable that holds the value and is already completed
- *
- * @example
- * ```ts
- * const greeting$ = just('hello');
- *
- * const valueHistory: string[] = [];
- *
- * greeting$.subscribe(
- *   (value) => {
- *     valueHistory.push(value);
- *   },
- *   () => {
- *     // onComplete — called immediately since just() completes right away
- *   },
- * );
- *
- * assert.deepStrictEqual(valueHistory, ['hello']);
- *
- * assert.strictEqual(greeting$.isCompleted, true);
- * ```
- */
 const just = (value) => {
-    const obs = new RootObservableClass({
-        initialValue: Optional.some(value),
-    });
-    obs.complete();
-    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-    return obs;
+  const obs = new RootObservableClass({
+    initialValue: Optional.some(value)
+  });
+  obs.complete();
+  return obs;
 };
 
 export { just };

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

@@ -1 +1 @@
-{"version":3,"file":"just.mjs","sources":["../../../src/core/create/just.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AACI,MAAM,IAAI,GAAG,CAAW,KAAQ,KAAkC;AACvE,IAAA,MAAM,GAAG,GAAG,IAAI,mBAAmB,CAAI;AACrC,QAAA,YAAY,EAAE,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC;AACnC,KAAA,CAAC;IAEF,GAAG,CAAC,QAAQ,EAAE;;AAGd,IAAA,OAAO,GAAmC;AAC5C;;;;"}
+{"version":3,"file":"just.mjs","sources":["../../../src/core/create/just.mts"],"sourcesContent":["import { Optional } from 'ts-data-forge';\nimport { RootObservableClass } from '../class/index.mjs';\nimport { type InitializedRootObservable } from '../types/index.mjs';\n\n/**\n * Creates an Observable that holds a single static value and immediately\n * completes. Useful inside `switchMap` to emit a fallback value when no\n * asynchronous work is needed.\n *\n * @template A - The type of the value\n * @param value - The value to emit\n * @returns An initialized Observable that holds the value and is already completed\n *\n * @example\n * ```ts\n * const greeting$ = just('hello');\n *\n * const valueHistory: string[] = [];\n *\n * greeting$.subscribe(\n *   (value) => {\n *     valueHistory.push(value);\n *   },\n *   () => {\n *     // onComplete — called immediately since just() completes right away\n *   },\n * );\n *\n * assert.deepStrictEqual(valueHistory, ['hello']);\n *\n * assert.strictEqual(greeting$.isCompleted, true);\n * ```\n */\nexport const just = <const A,>(value: A): InitializedRootObservable<A> => {\n  const obs = new RootObservableClass<A>({\n    initialValue: Optional.some(value),\n  });\n\n  obs.complete();\n\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  return obs as InitializedRootObservable<A>;\n};\n"],"names":[],"mappings":";;;;AAiCO,MAAM,IAAA,GAAO,CAAW,KAAA,KAA2C;AACxE,EAAA,MAAM,GAAA,GAAM,IAAI,mBAAA,CAAuB;AAAA,IACrC,YAAA,EAAc,QAAA,CAAS,IAAA,CAAK,KAAK;AAAA,GAClC,CAAA;AAED,EAAA,GAAA,CAAI,QAAA,EAAS;AAGb,EAAA,OAAO,GAAA;AACT;;;;"}