synstate 2.0.1 → 3.0.0

package/dist/core/base/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../../src/core/base/index.mts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,8BAA8B,CAAC"}

package/dist/core/base/index.mjs

@@ -0,0 +1,3 @@
+export { createAsyncChildObservable, createInitializedSyncChildObservable, createSyncChildObservable } from './create-child-observable.mjs';
+export { createRootObservable } from './create-root-observable.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/core/{class → base}/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

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

@@ -1 +1 @@
-{"version":3,"file":"combine.d.mts","sourceRoot":"","sources":["../../../src/core/combine/combine.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,aAAa,EAAc,MAAM,eAAe,CAAC;AAI/D,OAAO,EAEL,KAAK,wBAAwB,EAI7B,KAAK,UAAU,EAIhB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,eAAO,MAAM,OAAO,GAAI,KAAK,CAAC,EAAE,SAAS,aAAa,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,WAChE,EAAE,KACV,wBAAwB,CAAC,EAAE,CAIgB,CAAC;AAE/C;;;GAGG;AACH,eAAO,MAAM,aAAa,gBAAU,CAAC"}
+{"version":3,"file":"combine.d.mts","sourceRoot":"","sources":["../../../src/core/combine/combine.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,aAAa,EAAc,MAAM,eAAe,CAAC;AAI/D,OAAO,EAEL,KAAK,wBAAwB,EAI7B,KAAK,UAAU,EAGhB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,eAAO,MAAM,OAAO,GAAI,KAAK,CAAC,EAAE,SAAS,aAAa,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,WAChE,EAAE,KACV,wBAAwB,CAAC,EAAE,CAE+C,CAAC;AAE9E;;;GAGG;AACH,eAAO,MAAM,aAAa,gBAAU,CAAC"}

package/dist/core/combine/combine.mjs

@@ -1,41 +1,42 @@
 import { Arr, Optional } from 'ts-data-forge';
-import { SyncChildObservableClass } from '../class/child-observable-class.mjs';
+import { createSyncChildObservable } from '../base/create-child-observable.mjs';
 import '../utils/id-maker.mjs';
 
 const combine = (parents) => (
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  new CombineObservableClass(
-    parents
-  )
+  createCombineObservable(parents)
 );
 const combineLatest = combine;
-class CombineObservableClass extends SyncChildObservableClass {
-  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({
+const createCombineObservable = (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;
+  return createSyncChildObservable(
+    {
       parents,
       initialValue
-    });
-  }
-  tryUpdate(updateToken) {
-    if (this.parents.every((o) => o.updateToken !== updateToken)) return;
-    const parentValues = Arr.map(
-      this.parents,
-      (a) => a.getSnapshot()
-    );
-    if (Arr.every(parentValues, Optional.isSome)) {
-      const nextValue = Arr.map(
-        parentValues,
-        (a) => a.value
+    },
+    ({ setNext }) => (updateToken) => {
+      if (parents.every((o) => o.updateToken !== updateToken)) return;
+      const parentValues = Arr.map(
+        parents,
+        (a) => a.getSnapshot()
       );
-      this.setNext(nextValue, updateToken);
+      if (Arr.every(parentValues, Optional.isSome)) {
+        const nextValue = Arr.map(
+          parentValues,
+          (a) => a.value
+        );
+        setNext(nextValue, updateToken);
+      }
     }
-  }
-}
+  );
+};
 
 export { combine, combineLatest };
 //# sourceMappingURL=combine.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"combine.mjs","sources":["../../../src/core/combine/combine.mts"],"sourcesContent":["import { Arr, expectType, Optional } 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 CombineObservable,\n  type CombineObservableRefined,\n  type InitializedObservable,\n  type InitializedSyncChildObservable,\n  type NonEmptyUnknownList,\n  type Observable,\n  type SyncChildObservable,\n  type UpdateToken,\n  type Wrap,\n} from '../types/index.mjs';\n\n/**\n * Combines multiple observables into a single observable that emits an array of their latest values.\n * Emits whenever any of the source observables emit, but only after all sources have emitted at least once.\n *\n * @template OS - Tuple type of source observables\n * @param parents - Array of observables to combine\n * @returns A combined observable emitting tuples of values\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  name$     \"Alice\"                 \"Bob\"\n * //  age$                25                        30\n * //  user$               [\"Alice\",25]  [\"Bob\",25]  [\"Bob\",30]\n * //\n * //  Explanation:\n * //  - combine waits for all sources to emit at least once\n * //  - Then emits the latest value from all sources whenever any source emits\n * //  - Always emits an array with the latest values from each source\n *\n * const name$ = source<string>();\n *\n * const age$ = source<number>();\n *\n * const user$ = combine([name$, age$]);\n *\n * const userHistory: (readonly [string, number])[] = [];\n *\n * user$.subscribe(([name_, age]) => {\n *   userHistory.push([name_, age]);\n * });\n *\n * name$.next('Alice'); // nothing logged (age$ hasn't emitted yet)\n *\n * assert.deepStrictEqual(userHistory, []);\n *\n * age$.next(25); // logs: { name: 'Alice', age: 25 }\n *\n * assert.deepStrictEqual(userHistory, [['Alice', 25]]);\n *\n * name$.next('Bob'); // logs: { name: 'Bob', age: 25 }\n *\n * assert.deepStrictEqual(userHistory, [\n *   ['Alice', 25],\n *   ['Bob', 25],\n * ]);\n *\n * age$.next(30); // logs: { name: 'Bob', age: 30 }\n *\n * assert.deepStrictEqual(userHistory, [\n *   ['Alice', 25],\n *   ['Bob', 25],\n *   ['Bob', 30],\n * ]);\n * ```\n */\nexport const combine = <const OS extends NonEmptyTuple<Observable<unknown>>>(\n  parents: OS,\n): CombineObservableRefined<OS> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  new CombineObservableClass(\n    parents,\n  ) as unknown as CombineObservableRefined<OS>;\n\n/**\n * Alias for `combine`.\n * @see combine\n */\nexport const combineLatest = combine;\n\nclass CombineObservableClass<const A extends NonEmptyUnknownList>\n  extends SyncChildObservableClass<A, A>\n  implements CombineObservable<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\n  override tryUpdate(updateToken: UpdateToken): void {\n    if (this.parents.every((o) => o.updateToken !== updateToken)) return; // all parents are skipped\n\n    // Same shape-preserving chain as the constructor: `Arr.map` (not the\n    // native one, which drops the tuple shape) into the uniform\n    // `Tuple.MapTo`, then a positional annotation to get back to `A`.\n    const parentValues: Tuple.MapTo<Optional<A[number]>, A> = Arr.map(\n      this.parents,\n      (a) => a.getSnapshot(),\n    );\n\n    if (Arr.every(parentValues, Optional.isSome)) {\n      const nextValue: Readonly<{ [K in keyof A]: A[K] }> = Arr.map(\n        parentValues,\n        (a) => a.value,\n      );\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 = combine([s1, s2]);\n\n    expectType<typeof _d, CombineObservable<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 = combine([s1, s2]);\n\n    expectType<typeof _d, CombineObservable<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 = combine([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 _c = combine([r1, r2]);\n\n  const _ci = combine([\n    r1.pipe(withInitialValue(0)),\n    r2.pipe(withInitialValue(0)),\n  ]);\n\n  expectType<typeof _c, SyncChildObservable<readonly [number, string]>>('<=');\n\n  expectType<\n    typeof _ci,\n    InitializedSyncChildObservable<readonly [number, number | string]>\n  >('<=');\n}\n"],"names":[],"mappings":";;;;AA0EO,MAAM,UAAU,CACrB,OAAA;AAAA;AAAA,EAGA,IAAI,sBAAA;AAAA,IACF;AAAA;AACF;AAMK,MAAM,aAAA,GAAgB;AAE7B,MAAM,+BACI,wBAAA,CAEV;AAAA,EACE,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;AAAA,EAAA;AACH,EAES,UAAU,WAAA,EAAgC;AACjD,IAAA,IAAI,IAAA,CAAK,QAAQ,KAAA,CAAM,CAAC,MAAM,CAAA,CAAE,WAAA,KAAgB,WAAW,CAAA,EAAG;AAK9D,IAAA,MAAM,eAAoD,GAAA,CAAI,GAAA;AAAA,MAC5D,IAAA,CAAK,OAAA;AAAA,MACL,CAAC,CAAA,KAAM,CAAA,CAAE,WAAA;AAAY,KACvB;AAEA,IAAA,IAAI,GAAA,CAAI,KAAA,CAAM,YAAA,EAAc,QAAA,CAAS,MAAM,CAAA,EAAG;AAC5C,MAAA,MAAM,YAAgD,GAAA,CAAI,GAAA;AAAA,QACxD,YAAA;AAAA,QACA,CAAC,MAAM,CAAA,CAAE;AAAA,OACX;AAEA,MAAA,IAAA,CAAK,OAAA,CAAQ,WAAW,WAAW,CAAA;AAAA,IAAA;AACrC,EAAA;AAEJ;;;;"}
+{"version":3,"file":"combine.mjs","sources":["../../../src/core/combine/combine.mts"],"sourcesContent":["import { Arr, expectType, Optional } from 'ts-data-forge';\nimport { type NonEmptyTuple, type Tuple } from 'ts-type-forge';\nimport { createSyncChildObservable } from '../base/index.mjs';\nimport { source } from '../create/index.mjs';\nimport { withInitialValue } from '../operators/index.mjs';\nimport {\n  type CombineObservable,\n  type CombineObservableRefined,\n  type InitializedObservable,\n  type InitializedSyncChildObservable,\n  type NonEmptyUnknownList,\n  type Observable,\n  type SyncChildObservable,\n  type Wrap,\n} from '../types/index.mjs';\n\n/**\n * Combines multiple observables into a single observable that emits an array of their latest values.\n * Emits whenever any of the source observables emit, but only after all sources have emitted at least once.\n *\n * @template OS - Tuple type of source observables\n * @param parents - Array of observables to combine\n * @returns A combined observable emitting tuples of values\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  name$     \"Alice\"                 \"Bob\"\n * //  age$                25                        30\n * //  user$               [\"Alice\",25]  [\"Bob\",25]  [\"Bob\",30]\n * //\n * //  Explanation:\n * //  - combine waits for all sources to emit at least once\n * //  - Then emits the latest value from all sources whenever any source emits\n * //  - Always emits an array with the latest values from each source\n *\n * const name$ = source<string>();\n *\n * const age$ = source<number>();\n *\n * const user$ = combine([name$, age$]);\n *\n * const userHistory: (readonly [string, number])[] = [];\n *\n * user$.subscribe(([name_, age]) => {\n *   userHistory.push([name_, age]);\n * });\n *\n * name$.next('Alice'); // nothing logged (age$ hasn't emitted yet)\n *\n * assert.deepStrictEqual(userHistory, []);\n *\n * age$.next(25); // logs: { name: 'Alice', age: 25 }\n *\n * assert.deepStrictEqual(userHistory, [['Alice', 25]]);\n *\n * name$.next('Bob'); // logs: { name: 'Bob', age: 25 }\n *\n * assert.deepStrictEqual(userHistory, [\n *   ['Alice', 25],\n *   ['Bob', 25],\n * ]);\n *\n * age$.next(30); // logs: { name: 'Bob', age: 30 }\n *\n * assert.deepStrictEqual(userHistory, [\n *   ['Alice', 25],\n *   ['Bob', 25],\n *   ['Bob', 30],\n * ]);\n * ```\n */\nexport const combine = <const OS extends NonEmptyTuple<Observable<unknown>>>(\n  parents: OS,\n): CombineObservableRefined<OS> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  createCombineObservable(parents) as unknown as CombineObservableRefined<OS>;\n\n/**\n * Alias for `combine`.\n * @see combine\n */\nexport const combineLatest = combine;\n\nconst createCombineObservable = <const A extends NonEmptyUnknownList>(\n  parents: Wrap<A>,\n): CombineObservable<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] }>> = Arr.every(\n    parentsValues,\n    Optional.isSome,\n  )\n    ? Optional.some(Arr.map(parentsValues, (c) => c.value))\n    : Optional.none;\n\n  return createSyncChildObservable<A, A>(\n    {\n      parents,\n      initialValue,\n    },\n    ({ setNext }) =>\n      (updateToken) => {\n        if (parents.every((o) => o.updateToken !== updateToken)) return; // all parents are skipped\n\n        // Same shape-preserving chain as the initial value: `Arr.map` (not the\n        // native one, which drops the tuple shape) into the uniform\n        // `Tuple.MapTo`, then a positional annotation to get back to `A`.\n        const parentValues: Tuple.MapTo<Optional<A[number]>, A> = Arr.map(\n          parents,\n          (a) => a.getSnapshot(),\n        );\n\n        if (Arr.every(parentValues, Optional.isSome)) {\n          const nextValue: Readonly<{ [K in keyof A]: A[K] }> = Arr.map(\n            parentValues,\n            (a) => a.value,\n          );\n\n          setNext(nextValue, updateToken);\n        }\n      },\n  );\n};\n\nif (import.meta.vitest !== undefined) {\n  test('type test', () => {\n    expect(1).toBe(1); // dummy\n  });\n\n  {\n    const s1: Observable<1> = source<1>();\n\n    const s2: Observable<2> = source<2>();\n\n    const _d = combine([s1, s2]);\n\n    expectType<typeof _d, CombineObservable<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 = combine([s1, s2]);\n\n    expectType<typeof _d, CombineObservable<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 = combine([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 _c = combine([r1, r2]);\n\n  const _ci = combine([\n    r1.pipe(withInitialValue(0)),\n    r2.pipe(withInitialValue(0)),\n  ]);\n\n  expectType<typeof _c, SyncChildObservable<readonly [number, string]>>('<=');\n\n  expectType<\n    typeof _ci,\n    InitializedSyncChildObservable<readonly [number, number | string]>\n  >('<=');\n}\n"],"names":[],"mappings":";;;;AAyEO,MAAM,UAAU,CACrB,OAAA;AAAA;AAAA,EAGA,wBAAwB,OAAO;AAAA;AAM1B,MAAM,aAAA,GAAgB;AAE7B,MAAM,uBAAA,GAA0B,CAC9B,OAAA,KACyB;AACzB,EAAA,MAAM,gBAAqD,GAAA,CAAI,GAAA;AAAA,IAC7D,OAAA;AAAA,IACA,CAAC,CAAA,KAAM,CAAA,CAAE,WAAA;AAAY,GACvB;AAUA,EAAA,MAAM,eAA6D,GAAA,CAAI,KAAA;AAAA,IACrE,aAAA;AAAA,IACA,QAAA,CAAS;AAAA,GACX,GACI,QAAA,CAAS,IAAA,CAAK,GAAA,CAAI,GAAA,CAAI,aAAA,EAAe,CAAC,CAAA,KAAM,CAAA,CAAE,KAAK,CAAC,CAAA,GACpD,QAAA,CAAS,IAAA;AAEb,EAAA,OAAO,yBAAA;AAAA,IACL;AAAA,MACE,OAAA;AAAA,MACA;AAAA,KACF;AAAA,IACA,CAAC,EAAE,OAAA,EAAQ,KACT,CAAC,WAAA,KAAgB;AACf,MAAA,IAAI,QAAQ,KAAA,CAAM,CAAC,MAAM,CAAA,CAAE,WAAA,KAAgB,WAAW,CAAA,EAAG;AAKzD,MAAA,MAAM,eAAoD,GAAA,CAAI,GAAA;AAAA,QAC5D,OAAA;AAAA,QACA,CAAC,CAAA,KAAM,CAAA,CAAE,WAAA;AAAY,OACvB;AAEA,MAAA,IAAI,GAAA,CAAI,KAAA,CAAM,YAAA,EAAc,QAAA,CAAS,MAAM,CAAA,EAAG;AAC5C,QAAA,MAAM,YAAgD,GAAA,CAAI,GAAA;AAAA,UACxD,YAAA;AAAA,UACA,CAAC,MAAM,CAAA,CAAE;AAAA,SACX;AAEA,QAAA,OAAA,CAAQ,WAAW,WAAW,CAAA;AAAA,MAAA;AAChC,IAAA;AACF,GACJ;AACF,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"merge.d.mts","sourceRoot":"","sources":["../../../src/core/combine/merge.mts"],"names":[],"mappings":"AACA,OAAO,EAAqB,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAGtE,OAAO,EAEL,KAAK,sBAAsB,EAE3B,KAAK,UAAU,EAIhB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,eAAO,MAAM,KAAK,GAAI,KAAK,CAAC,EAAE,SAAS,aAAa,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,WAC9D,EAAE,KACV,sBAAsB,CAAC,EAAE,CAEqC,CAAC"}
+{"version":3,"file":"merge.d.mts","sourceRoot":"","sources":["../../../src/core/combine/merge.mts"],"names":[],"mappings":"AACA,OAAO,EAAqB,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAGtE,OAAO,EAEL,KAAK,sBAAsB,EAE3B,KAAK,UAAU,EAGhB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,eAAO,MAAM,KAAK,GAAI,KAAK,CAAC,EAAE,SAAS,aAAa,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,WAC9D,EAAE,KACV,sBAAsB,CAAC,EAAE,CAEkC,CAAC"}

package/dist/core/combine/merge.mjs

@@ -1,20 +1,18 @@
 import { Optional } from 'ts-data-forge';
-import { SyncChildObservableClass } from '../class/child-observable-class.mjs';
+import { createSyncChildObservable } from '../base/create-child-observable.mjs';
 import '../utils/id-maker.mjs';
 
 const merge = (parents) => (
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  new MergeObservableClass(parents)
+  createMergeObservable(parents)
 );
-class MergeObservableClass extends SyncChildObservableClass {
-  constructor(parents) {
-    super({
-      parents,
-      initialValue: Optional.none
-    });
-  }
-  tryUpdate(updateToken) {
-    const parentToUse = this.parents.find(
+const createMergeObservable = (parents) => createSyncChildObservable(
+  {
+    parents,
+    initialValue: Optional.none
+  },
+  ({ setNext }) => (updateToken) => {
+    const parentToUse = parents.find(
       (o) => o.updateToken === updateToken && Optional.isSome(o.getSnapshot())
     );
     if (parentToUse === void 0) return;
@@ -22,9 +20,9 @@ class MergeObservableClass extends SyncChildObservableClass {
       // eslint-disable-next-line total-functions/no-unsafe-type-assertion
       Optional.unwrap(parentToUse.getSnapshot())
     );
-    this.setNext(nextValue, updateToken);
+    setNext(nextValue, updateToken);
   }
-}
+);
 
 export { merge };
 //# sourceMappingURL=merge.mjs.map

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

@@ -1 +1 @@
-{"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;;;;"}
+{"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 { createSyncChildObservable } from '../base/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 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  createMergeObservable(parents) as MergeObservableRefined<OS>;\n\nconst createMergeObservable = <const P extends NonEmptyUnknownList>(\n  parents: Wrap<P>,\n): MergeObservable<P> =>\n  createSyncChildObservable<ArrayElement<P>, P>(\n    {\n      parents,\n      initialValue: Optional.none,\n    },\n    ({ setNext }) =>\n      (updateToken) => {\n        const parentToUse = parents.find(\n          (o) =>\n            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        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":";;;;AAgEO,MAAM,QAAQ,CACnB,OAAA;AAAA;AAAA,EAGA,sBAAsB,OAAO;AAAA;AAE/B,MAAM,qBAAA,GAAwB,CAC5B,OAAA,KAEA,yBAAA;AAAA,EACE;AAAA,IACE,OAAA;AAAA,IACA,cAAc,QAAA,CAAS;AAAA,GACzB;AAAA,EACA,CAAC,EAAE,OAAA,EAAQ,KACT,CAAC,WAAA,KAAgB;AACf,IAAA,MAAM,cAAc,OAAA,CAAQ,IAAA;AAAA,MAC1B,CAAC,MACC,CAAA,CAAE,WAAA,KAAgB,eAAe,QAAA,CAAS,MAAA,CAAO,CAAA,CAAE,WAAA,EAAa;AAAA,KACpE;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,OAAA,CAAQ,WAAW,WAAW,CAAA;AAAA,EAAA;AAEpC,CAAA;;;;"}

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,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"}
+{"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,EAKf,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,CAE2C,CAAC"}

package/dist/core/combine/zip.mjs

@@ -1,44 +1,45 @@
 import { Arr, Optional, createQueue } from 'ts-data-forge';
-import { SyncChildObservableClass } from '../class/child-observable-class.mjs';
+import { createSyncChildObservable } from '../base/create-child-observable.mjs';
 import '../utils/id-maker.mjs';
 
 const zip = (parents) => (
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  new ZipObservableClass(parents)
+  createZipObservable(parents)
 );
-class ZipObservableClass extends SyncChildObservableClass {
-  #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({
+const createZipObservable = (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;
+  const queues = Arr.map(parents, () => createQueue());
+  return createSyncChildObservable(
+    {
       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);
+    },
+    ({ setNext }) => (updateToken) => {
+      for (const [index, par] of 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 = (
+          // `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()))
+        );
+        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 };
 //# sourceMappingURL=zip.mjs.map

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

@@ -1 +1 @@
-{"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;;;;"}
+{"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 { createSyncChildObservable } from '../base/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 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  createZipObservable(parents) as unknown as ZipObservableRefined<OS>;\n\nconst createZipObservable = <const A extends NonEmptyUnknownList>(\n  parents: Wrap<A>,\n): ZipObservable<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] }>> = Arr.every(\n    parentsValues,\n    Optional.isSome,\n  )\n    ? Optional.some(Arr.map(parentsValues, (c) => c.value))\n    : Optional.none;\n\n  const queues: TupleToQueueTuple<A> = Arr.map(parents, () => createQueue());\n\n  return createSyncChildObservable<A, A>(\n    {\n      parents,\n      initialValue,\n    },\n    ({ setNext }) =>\n      (updateToken) => {\n        for (const [index, par] of 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          setNext(nextValue, updateToken);\n        }\n      },\n  );\n};\n\nif (import.meta.vitest !== undefined) {\n  test('type test', () => {\n    expect(1).toBe(1); // dummy\n  });\n\n  {\n    const 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  ]);\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":";;;;AAkEO,MAAM,MAAM,CACjB,OAAA;AAAA;AAAA,EAGA,oBAAoB,OAAO;AAAA;AAE7B,MAAM,mBAAA,GAAsB,CAC1B,OAAA,KACqB;AACrB,EAAA,MAAM,gBAAqD,GAAA,CAAI,GAAA;AAAA,IAC7D,OAAA;AAAA,IACA,CAAC,CAAA,KAAM,CAAA,CAAE,WAAA;AAAY,GACvB;AAUA,EAAA,MAAM,eAA6D,GAAA,CAAI,KAAA;AAAA,IACrE,aAAA;AAAA,IACA,QAAA,CAAS;AAAA,GACX,GACI,QAAA,CAAS,IAAA,CAAK,GAAA,CAAI,GAAA,CAAI,aAAA,EAAe,CAAC,CAAA,KAAM,CAAA,CAAE,KAAK,CAAC,CAAA,GACpD,QAAA,CAAS,IAAA;AAEb,EAAA,MAAM,SAA+B,GAAA,CAAI,GAAA,CAAI,OAAA,EAAS,MAAM,aAAa,CAAA;AAEzE,EAAA,OAAO,yBAAA;AAAA,IACL;AAAA,MACE,OAAA;AAAA,MACA;AAAA,KACF;AAAA,IACA,CAAC,EAAE,OAAA,EAAQ,KACT,CAAC,WAAA,KAAgB;AACf,MAAA,KAAA,MAAW,CAAC,KAAA,EAAO,GAAG,CAAA,IAAK,OAAA,CAAQ,SAAQ,EAAG;AAC5C,QAAA,MAAM,EAAA,GAAK,IAAI,WAAA,EAAY;AAE3B,QAAA,IAAI,IAAI,WAAA,KAAgB,WAAA,IAAe,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAAG;AAC1D,UAAA,MAAA,CAAO,KAAK,CAAA,EAAG,OAAA,CAAQ,EAAA,CAAG,KAAK,CAAA;AAAA,QAAA;AACjC,MAAA;AAGF,MAAA,IAAI,OAAO,KAAA,CAAM,CAAC,SAAS,CAAC,IAAA,CAAK,OAAO,CAAA,EAAG;AACzC,QAAA,MAAM,SAAA;AAAA;AAAA;AAAA;AAAA,UAIJ,GAAA,CAAI,GAAA,CAAI,MAAA,EAAQ,CAAC,CAAA,KAAM,SAAS,MAAA,CAAO,CAAA,CAAE,OAAA,EAAS,CAAC;AAAA,SAAA;AAErD,QAAA,OAAA,CAAQ,WAAW,WAAW,CAAA;AAAA,MAAA;AAChC,IAAA;AACF,GACJ;AACF,CAAA;;;;"}

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,yBACI,MAAM,YAClB,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,iBA0DF,CAAC"}

package/dist/core/create/counter.mjs

@@ -1,58 +1,47 @@
-import { Optional, asSafeUint, SafeUint } from 'ts-data-forge';
+import { asSafeUint, SafeUint, Optional } from 'ts-data-forge';
 import '../utils/id-maker.mjs';
-import { RootObservableClass } from '../class/root-observable-class.mjs';
+import { createRootObservable } from '../base/create-root-observable.mjs';
 
-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 = void 0;
-    this.#mut_timerId = void 0;
-    this.#mut_isStarted = false;
-    if (!startManually) {
-      this.start();
-    }
-  }
-  #resetTimer() {
-    if (this.#mut_timerId0 === void 0 || this.#mut_timerId === void 0) {
-      return;
-    }
-    clearInterval(this.#mut_timerId0);
-    clearInterval(this.#mut_timerId);
-  }
-  start() {
-    if (this.#mut_isStarted) {
-      console.warn("cannot start twice");
-      return;
-    }
-    this.#mut_isStarted = true;
-    if (this.isCompleted) {
-      console.warn("cannot restart stopped CounterObservable");
+const counter = (intervalMilliSeconds, options) => {
+  let mut_counter = asSafeUint(0);
+  let mut_timerId0 = void 0;
+  let mut_timerId = void 0;
+  let mut_isStarted = false;
+  const resetTimer = () => {
+    if (mut_timerId0 === void 0 || mut_timerId === void 0) {
       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();
+    clearInterval(mut_timerId0);
+    clearInterval(mut_timerId);
+  };
+  const observable = createRootObservable(
+    { initialValue: Optional.none, onComplete: resetTimer },
+    ({ startUpdate, isCompleted }) => ({
+      start: () => {
+        if (mut_isStarted) {
+          console.warn("cannot start twice");
+          return;
+        }
+        mut_isStarted = true;
+        if (isCompleted()) {
+          console.warn("cannot restart stopped CounterObservable");
+          return;
+        }
+        mut_timerId0 = setTimeout(() => {
+          startUpdate(mut_counter);
+        }, 0);
+        mut_timerId = setInterval(() => {
+          mut_counter = SafeUint.add(1, mut_counter);
+          startUpdate(mut_counter);
+        }, intervalMilliSeconds);
+      }
+    })
+  );
+  if (!(options?.startManually ?? false)) {
+    observable.start();
   }
-}
+  return observable;
+};
 
 export { counter };
 //# sourceMappingURL=counter.mjs.map

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

@@ -1 +1 @@
-{"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;;;;"}
+{"version":3,"file":"counter.mjs","sources":["../../../src/core/create/counter.mts"],"sourcesContent":["import { asSafeUint, Optional, SafeUint } from 'ts-data-forge';\nimport { createRootObservable } from '../base/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  let mut_counter: SafeUint = asSafeUint(0);\n\n  let mut_timerId0: TimerId | undefined = undefined;\n\n  let mut_timerId: TimerId | undefined = undefined;\n\n  let mut_isStarted = false;\n\n  const resetTimer = (): void => {\n    if (mut_timerId0 === undefined || mut_timerId === undefined) {\n      return;\n    }\n\n    clearInterval(mut_timerId0);\n\n    clearInterval(mut_timerId);\n  };\n\n  const observable = createRootObservable<\n    SafeUint,\n    Readonly<{ start: () => void }>\n  >(\n    { initialValue: Optional.none, onComplete: resetTimer },\n    ({ startUpdate, isCompleted }) => ({\n      start: () => {\n        if (mut_isStarted) {\n          console.warn('cannot start twice');\n\n          return;\n        }\n\n        mut_isStarted = true;\n\n        if (isCompleted()) {\n          console.warn('cannot restart stopped CounterObservable');\n\n          return;\n        }\n\n        mut_timerId0 = setTimeout(() => {\n          startUpdate(mut_counter);\n        }, 0);\n\n        mut_timerId = setInterval(() => {\n          mut_counter = SafeUint.add(1, mut_counter);\n\n          startUpdate(mut_counter);\n        }, intervalMilliSeconds);\n      },\n    }),\n  );\n\n  if (!(options?.startManually ?? false)) {\n    observable.start();\n  }\n\n  return observable;\n};\n"],"names":[],"mappings":";;;;AA+CO,MAAM,OAAA,GAAU,CACrB,oBAAA,EACA,OAAA,KAGsB;AACtB,EAAA,IAAI,WAAA,GAAwB,WAAW,CAAC,CAAA;AAExC,EAAA,IAAI,YAAA,GAAoC,MAAA;AAExC,EAAA,IAAI,WAAA,GAAmC,MAAA;AAEvC,EAAA,IAAI,aAAA,GAAgB,KAAA;AAEpB,EAAA,MAAM,aAAa,MAAY;AAC7B,IAAA,IAAI,YAAA,KAAiB,MAAA,IAAa,WAAA,KAAgB,MAAA,EAAW;AAC3D,MAAA;AAAA,IACF;AAEA,IAAA,aAAA,CAAc,YAAY,CAAA;AAE1B,IAAA,aAAA,CAAc,WAAW,CAAA;AAAA,EAC3B,CAAA;AAEA,EAAA,MAAM,UAAA,GAAa,oBAAA;AAAA,IAIjB,EAAE,YAAA,EAAc,QAAA,CAAS,IAAA,EAAM,YAAY,UAAA,EAAW;AAAA,IACtD,CAAC,EAAE,WAAA,EAAa,WAAA,EAAY,MAAO;AAAA,MACjC,OAAO,MAAM;AACX,QAAA,IAAI,aAAA,EAAe;AACjB,UAAA,OAAA,CAAQ,KAAK,oBAAoB,CAAA;AAEjC,UAAA;AAAA,QACF;AAEA,QAAA,aAAA,GAAgB,IAAA;AAEhB,QAAA,IAAI,aAAY,EAAG;AACjB,UAAA,OAAA,CAAQ,KAAK,0CAA0C,CAAA;AAEvD,UAAA;AAAA,QACF;AAEA,QAAA,YAAA,GAAe,WAAW,MAAM;AAC9B,UAAA,WAAA,CAAY,WAAW,CAAA;AAAA,QACzB,GAAG,CAAC,CAAA;AAEJ,QAAA,WAAA,GAAc,YAAY,MAAM;AAC9B,UAAA,WAAA,GAAc,QAAA,CAAS,GAAA,CAAI,CAAA,EAAG,WAAW,CAAA;AAEzC,UAAA,WAAA,CAAY,WAAW,CAAA;AAAA,QACzB,GAAG,oBAAoB,CAAA;AAAA,MACzB;AAAA,KACF;AAAA,GACF;AAEA,EAAA,IAAI,EAAE,OAAA,EAAS,aAAA,IAAiB,KAAA,CAAA,EAAQ;AACtC,IAAA,UAAA,CAAW,KAAA,EAAM;AAAA,EACnB;AAEA,EAAA,OAAO,UAAA;AACT;;;;"}

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,WAExC,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,CA0C5B,CAAC"}

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

@@ -1,38 +1,39 @@
-import { Optional, Result } from 'ts-data-forge';
+import { Result, Optional } from 'ts-data-forge';
 import '../utils/id-maker.mjs';
-import { RootObservableClass } from '../class/root-observable-class.mjs';
+import { createRootObservable } from '../base/create-root-observable.mjs';
 
-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;
-      if (error instanceof DOMException && error.name === "AbortError") {
-        return;
+const fromAbortablePromise = (factory) => {
+  const abortController = new AbortController();
+  return createRootObservable(
+    {
+      initialValue: Optional.none,
+      onComplete: () => {
+        abortController.abort();
       }
-      this.startUpdate(
-        Result.err(
-          // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-          error
-        )
-      );
-    }).finally(() => {
-      this.complete();
-    });
-  }
-  complete() {
-    this.#abortController.abort();
-    super.complete();
-  }
-}
+    },
+    ({ startUpdate, isCompleted, complete }) => {
+      const promise = factory(abortController.signal);
+      promise.then((value) => {
+        if (isCompleted()) return;
+        startUpdate(Result.ok(value));
+      }).catch((error) => {
+        if (isCompleted()) return;
+        if (error instanceof DOMException && error.name === "AbortError") {
+          return;
+        }
+        startUpdate(
+          Result.err(
+            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+            error
+          )
+        );
+      }).finally(() => {
+        complete();
+      });
+      return {};
+    }
+  );
+};
 
 export { fromAbortablePromise };
 //# sourceMappingURL=from-abortable-promise.mjs.map

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":["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;;;;"}
+{"version":3,"file":"from-abortable-promise.mjs","sources":["../../../src/core/create/from-abortable-promise.mts"],"sourcesContent":["import { Optional, Result } from 'ts-data-forge';\nimport { createRootObservable } from '../base/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  const abortController = new AbortController();\n\n  return createRootObservable<Result<A, E>>(\n    {\n      initialValue: Optional.none,\n      onComplete: () => {\n        abortController.abort();\n      },\n    },\n    ({ startUpdate, isCompleted, complete }) => {\n      const promise = factory(abortController.signal);\n\n      promise\n        .then((value) => {\n          if (isCompleted()) return;\n\n          startUpdate(Result.ok(value));\n        })\n        .catch((error: unknown) => {\n          if (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          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          complete();\n        });\n\n      return {};\n    },\n  );\n};\n"],"names":[],"mappings":";;;;AA8BO,MAAM,oBAAA,GAAuB,CAElC,OAAA,KACgC;AAChC,EAAA,MAAM,eAAA,GAAkB,IAAI,eAAA,EAAgB;AAE5C,EAAA,OAAO,oBAAA;AAAA,IACL;AAAA,MACE,cAAc,QAAA,CAAS,IAAA;AAAA,MACvB,YAAY,MAAM;AAChB,QAAA,eAAA,CAAgB,KAAA,EAAM;AAAA,MACxB;AAAA,KACF;AAAA,IACA,CAAC,EAAE,WAAA,EAAa,WAAA,EAAa,UAAS,KAAM;AAC1C,MAAA,MAAM,OAAA,GAAU,OAAA,CAAQ,eAAA,CAAgB,MAAM,CAAA;AAE9C,MAAA,OAAA,CACG,IAAA,CAAK,CAAC,KAAA,KAAU;AACf,QAAA,IAAI,aAAY,EAAG;AAEnB,QAAA,WAAA,CAAY,MAAA,CAAO,EAAA,CAAG,KAAK,CAAC,CAAA;AAAA,MAC9B,CAAC,CAAA,CACA,KAAA,CAAM,CAAC,KAAA,KAAmB;AACzB,QAAA,IAAI,aAAY,EAAG;AAInB,QAAA,IAAI,KAAA,YAAiB,YAAA,IAAgB,KAAA,CAAM,IAAA,KAAS,YAAA,EAAc;AAChE,UAAA;AAAA,QACF;AAEA,QAAA,WAAA;AAAA,UACE,MAAA,CAAO,GAAA;AAAA;AAAA,YAEL;AAAA;AACF,SACF;AAAA,MACF,CAAC,CAAA,CACA,OAAA,CAAQ,MAAM;AACb,QAAA,QAAA,EAAS;AAAA,MACX,CAAC,CAAA;AAEH,MAAA,OAAO,EAAC;AAAA,IACV;AAAA,GACF;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,WAC/B,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,CA0B1B,CAAC"}