synstate 1.0.2 → 2.0.0

package/dist/core/class/observable-base-class.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"observable-base-class.mjs","sources":["../../../src/core/class/observable-base-class.mts"],"sourcesContent":[null],"names":[],"mappings":"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"}
+{"version":3,"file":"observable-base-class.mjs","sources":["../../../src/core/class/observable-base-class.mts"],"sourcesContent":["import { Arr, Optional } from 'ts-data-forge';\nimport { type MutableMap } from 'ts-type-forge';\nimport {\n  type ChildObservable,\n  type InitializedObservable,\n  type Observable,\n  type ObservableBase,\n  type Operator,\n  type Subscriber,\n  type SubscriberId,\n  type Subscription,\n  type UpdateToken,\n  type WithInitialValueOperator,\n} from '../types/index.mjs';\nimport {\n  issueObservableId,\n  issueSubscriberId,\n  issueUpdateToken,\n  toSubscriber,\n} from '../utils/index.mjs';\n\nexport class ObservableBaseClass<\n  A,\n  Kind extends ObservableBase<A>['kind'],\n  Depth extends ObservableBase<A>['depth'],\n> implements ObservableBase<A> {\n  #mut_children: readonly ChildObservable<unknown>[];\n  readonly #subscribers: MutableMap<SubscriberId, Subscriber<A>>;\n  #mut_currentValue: ReturnType<ObservableBase<A>['getSnapshot']>;\n  #mut_isCompleted: ObservableBase<A>['isCompleted'];\n  #mut_updateToken: ObservableBase<A>['updateToken'];\n  readonly id;\n  readonly kind: Kind;\n  readonly depth: Depth;\n\n  constructor({\n    kind,\n    depth,\n    initialValue,\n  }: Readonly<{\n    kind: Kind;\n    depth: Depth;\n    initialValue: ReturnType<ObservableBase<A>['getSnapshot']>;\n  }>) {\n    this.kind = kind;\n\n    this.depth = depth;\n\n    this.id = issueObservableId();\n\n    this.#mut_currentValue = initialValue;\n\n    this.#mut_children = [];\n\n    this.#subscribers = new Map<SubscriberId, Subscriber<A>>();\n\n    this.#mut_isCompleted = false;\n\n    this.#mut_updateToken = issueUpdateToken();\n  }\n\n  #addSubscriber(s: Subscriber<A>): SubscriberId {\n    // return the id of added subscriber\n    const id = issueSubscriberId();\n\n    this.#subscribers.set(id, s);\n\n    return id;\n  }\n\n  #removeSubscriber(id: SubscriberId): void {\n    this.#subscribers.delete(id);\n  }\n\n  addChild<B>(child: ChildObservable<B>): void {\n    this.#mut_children = Arr.toPushed(\n      this.#mut_children,\n\n      child as ChildObservable<unknown>,\n    );\n  }\n\n  getSnapshot(): ReturnType<ObservableBase<A>['getSnapshot']> {\n    return this.#mut_currentValue;\n  }\n\n  protected getCurrentValue(): ReturnType<ObservableBase<A>['getSnapshot']> {\n    return this.#mut_currentValue;\n  }\n\n  get isCompleted(): boolean {\n    return this.#mut_isCompleted;\n  }\n\n  get updateToken(): UpdateToken {\n    return this.#mut_updateToken;\n  }\n\n  get hasSubscriber(): boolean {\n    return this.#subscribers.size > 0;\n  }\n\n  get hasChild(): boolean {\n    return Arr.isNonEmpty(this.#mut_children);\n  }\n\n  hasActiveChild(): boolean {\n    return this.#mut_children.some((c) => !c.isCompleted);\n  }\n\n  protected setNext(nextValue: A, updateToken: UpdateToken): void {\n    this.#mut_updateToken = updateToken;\n\n    this.#mut_currentValue = Optional.some(nextValue);\n\n    for (const s of this.#subscribers.values()) {\n      s.onNext(nextValue);\n    }\n  }\n\n  // eslint-disable-next-line @typescript-eslint/class-methods-use-this\n  tryUpdate(_updateToken: UpdateToken): void {\n    throw new Error('not implemented');\n  }\n\n  tryComplete(): void {\n    if (!this.hasSubscriber && !this.hasActiveChild()) {\n      this.complete();\n    }\n  }\n\n  complete(): void {\n    if (this.isCompleted) return; // terminate only once\n\n    // change state\n    this.#mut_isCompleted = true;\n\n    // run subscribers for the current value\n    for (const s of this.#subscribers.values()) {\n      s.onComplete();\n    }\n\n    // remove all subscribers\n    this.#subscribers.clear();\n\n    // propagate to children\n    for (const o of this.#mut_children) {\n      o.tryComplete();\n    }\n  }\n\n  pipe<B>(operator: WithInitialValueOperator<A, B>): InitializedObservable<B>;\n  pipe<B>(operator: Operator<A, B>): Observable<B>;\n  pipe<B>(operator: Operator<A, B>): Observable<B> {\n    return operator(\n      // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      this as unknown as InitializedObservable<A>,\n    );\n  }\n\n  subscribe(onNext: (v: A) => void, onComplete?: () => void): Subscription {\n    // first emit\n    const curr = this.getSnapshot();\n\n    if (Optional.isSome(curr)) {\n      onNext(curr.value);\n    }\n\n    if (this.isCompleted) {\n      if (onComplete !== undefined) {\n        onComplete();\n      }\n\n      return { unsubscribe: () => {} };\n    }\n\n    const id: SubscriberId = this.#addSubscriber(\n      toSubscriber(onNext, onComplete),\n    );\n\n    return {\n      unsubscribe: () => {\n        this.#removeSubscriber(id);\n      },\n    };\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/core/class/root-observable-class.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"root-observable-class.d.mts","sourceRoot":"","sources":["../../../src/core/class/root-observable-class.mts"],"names":[],"mappings":"AAAA,OAAO,EAAO,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,cAAc,EACpB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAElE,qBAAa,mBAAmB,CAAC,CAAC,CAChC,SAAQ,mBAAmB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CACxC,YAAW,cAAc,CAAC,CAAC,CAAC;;IAG5B,SAAS,CAAC,QAAQ,CAAC,iBAAiB,EAAE,UAAU,CAAC,YAAY,CAAC,CAAC;gBAEnD,EACV,YAAY,GACb,EAAE,QAAQ,CAAC;QACV,YAAY,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC;KAC3B,CAAC;IAYF,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG,IAAI;IAiBjD,WAAW,CAAC,SAAS,EAAE,CAAC,GAAG,IAAI;CAShC"}
+{"version":3,"file":"root-observable-class.d.mts","sourceRoot":"","sources":["../../../src/core/class/root-observable-class.mts"],"names":[],"mappings":"AAAA,OAAO,EAAO,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,cAAc,EACpB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAElE,qBAAa,mBAAmB,CAAC,CAAC,CAChC,SAAQ,mBAAmB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CACxC,YAAW,cAAc,CAAC,CAAC,CAAC;;IAG5B,SAAS,CAAC,QAAQ,CAAC,iBAAiB,EAAE,UAAU,CAAC,YAAY,CAAC,CAAC;IAE/D,YAAY,EACV,YAAY,GACb,EAAE,QAAQ,CAAC;QACV,YAAY,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC;KAC3B,CAAC,EAUD;IAED,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG,IAAI,CAehD;IAED,WAAW,CAAC,SAAS,EAAE,CAAC,GAAG,IAAI,CAQ9B;CACF"}

package/dist/core/class/root-observable-class.mjs

@@ -4,31 +4,39 @@ import { binarySearch } from '../utils/utils.mjs';
 import { ObservableBaseClass } from './observable-base-class.mjs';
 
 class RootObservableClass extends ObservableBaseClass {
-    #mut_propagationOrder;
-    _descendantsIdSet;
-    constructor({ initialValue, }) {
-        super({
-            kind: 'root',
-            depth: 0,
-            initialValue,
-        });
-        this.#mut_propagationOrder = [];
-        this._descendantsIdSet = new Set();
-    }
-    addDescendant(child) {
-        if (this._descendantsIdSet.has(child.id))
-            return;
-        this._descendantsIdSet.add(child.id);
-        const insertPos = binarySearch(this.#mut_propagationOrder.map((a) => a.depth), child.depth);
-        this.#mut_propagationOrder = Arr.toInserted(this.#mut_propagationOrder, insertPos, child);
-    }
-    startUpdate(nextValue) {
-        const updateToken = issueUpdateToken();
-        this.setNext(nextValue, updateToken);
-        for (const p of this.#mut_propagationOrder) {
-            p.tryUpdate(updateToken);
-        }
+  #mut_propagationOrder;
+  _descendantsIdSet;
+  constructor({
+    initialValue
+  }) {
+    super({
+      kind: "root",
+      depth: 0,
+      initialValue
+    });
+    this.#mut_propagationOrder = [];
+    this._descendantsIdSet = /* @__PURE__ */ new Set();
+  }
+  addDescendant(child) {
+    if (this._descendantsIdSet.has(child.id)) return;
+    this._descendantsIdSet.add(child.id);
+    const insertPos = binarySearch(
+      this.#mut_propagationOrder.map((a) => a.depth),
+      child.depth
+    );
+    this.#mut_propagationOrder = Arr.toInserted(
+      this.#mut_propagationOrder,
+      insertPos,
+      child
+    );
+  }
+  startUpdate(nextValue) {
+    const updateToken = issueUpdateToken();
+    this.setNext(nextValue, updateToken);
+    for (const p of this.#mut_propagationOrder) {
+      p.tryUpdate(updateToken);
     }
+  }
 }
 
 export { RootObservableClass };

package/dist/core/class/root-observable-class.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"root-observable-class.mjs","sources":["../../../src/core/class/root-observable-class.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAWM,MAAO,mBACX,SAAQ,mBAAiC,CAAA;AAGzC,IAAA,qBAAqB;AACF,IAAA,iBAAiB;IAEpC,WAAA,CAAY,EACV,YAAY,GAGZ,EAAA;AACA,QAAA,KAAK,CAAC;AACJ,YAAA,IAAI,EAAE,MAAM;AACZ,YAAA,KAAK,EAAE,CAAC;YACR,YAAY;AACb,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,qBAAqB,GAAG,EAAE;AAE/B,QAAA,IAAI,CAAC,iBAAiB,GAAG,IAAI,GAAG,EAAgB;IAClD;AAEA,IAAA,aAAa,CAAI,KAAyB,EAAA;QACxC,IAAI,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;YAAE;QAE1C,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;QAEpC,MAAM,SAAS,GAAG,YAAY,CAC5B,IAAI,CAAC,qBAAqB,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,EAC9C,KAAK,CAAC,KAAK,CACZ;AAED,QAAA,IAAI,CAAC,qBAAqB,GAAG,GAAG,CAAC,UAAU,CACzC,IAAI,CAAC,qBAAqB,EAC1B,SAAS,EACT,KAAK,CACN;IACH;AAEA,IAAA,WAAW,CAAC,SAAY,EAAA;AACtB,QAAA,MAAM,WAAW,GAAG,gBAAgB,EAAE;AAEtC,QAAA,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,WAAW,CAAC;AAEpC,QAAA,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,qBAAqB,EAAE;AAC1C,YAAA,CAAC,CAAC,SAAS,CAAC,WAAW,CAAC;QAC1B;IACF;AACD;;;;"}
+{"version":3,"file":"root-observable-class.mjs","sources":["../../../src/core/class/root-observable-class.mts"],"sourcesContent":["import { Arr, Optional } from 'ts-data-forge';\nimport { type MutableSet } from 'ts-type-forge';\nimport {\n  isRootObservable,\n  type ChildObservable,\n  type ObservableId,\n  type RootObservable,\n} from '../types/index.mjs';\nimport { binarySearch, issueUpdateToken } from '../utils/index.mjs';\nimport { ObservableBaseClass } from './observable-base-class.mjs';\n\nexport class RootObservableClass<A>\n  extends ObservableBaseClass<A, 'root', 0>\n  implements RootObservable<A>\n{\n  #mut_propagationOrder: readonly ChildObservable<unknown>[];\n  protected readonly _descendantsIdSet: MutableSet<ObservableId>;\n\n  constructor({\n    initialValue,\n  }: Readonly<{\n    initialValue: Optional<A>;\n  }>) {\n    super({\n      kind: 'root',\n      depth: 0,\n      initialValue,\n    });\n\n    this.#mut_propagationOrder = [];\n\n    this._descendantsIdSet = new Set<ObservableId>();\n  }\n\n  addDescendant<B>(child: ChildObservable<B>): void {\n    if (this._descendantsIdSet.has(child.id)) return;\n\n    this._descendantsIdSet.add(child.id);\n\n    const insertPos = binarySearch(\n      this.#mut_propagationOrder.map((a) => a.depth),\n      child.depth,\n    );\n\n    this.#mut_propagationOrder = Arr.toInserted(\n      this.#mut_propagationOrder,\n      insertPos,\n      child,\n    );\n  }\n\n  startUpdate(nextValue: A): void {\n    const updateToken = issueUpdateToken();\n\n    this.setNext(nextValue, updateToken);\n\n    for (const p of this.#mut_propagationOrder) {\n      p.tryUpdate(updateToken);\n    }\n  }\n}\n\nif (import.meta.vitest !== undefined) {\n  test('isRootObservable', () => {\n    assert.isTrue(\n      isRootObservable(\n        new RootObservableClass({\n          initialValue: Optional.some(0),\n        }),\n      ),\n    );\n  });\n}\n"],"names":[],"mappings":";;;;;AAWO,MAAM,4BACH,mBAAA,CAEV;AAAA,EACE,qBAAA;AAAA,EACmB,iBAAA;AAAA,EAEnB,WAAA,CAAY;AAAA,IACV;AAAA,GACF,EAEI;AACF,IAAA,KAAA,CAAM;AAAA,MACJ,IAAA,EAAM,MAAA;AAAA,MACN,KAAA,EAAO,CAAA;AAAA,MACP;AAAA,KACD,CAAA;AAED,IAAA,IAAA,CAAK,wBAAwB,EAAC;AAE9B,IAAA,IAAA,CAAK,iBAAA,uBAAwB,GAAA,EAAkB;AAAA,EACjD;AAAA,EAEA,cAAiB,KAAA,EAAiC;AAChD,IAAA,IAAI,IAAA,CAAK,iBAAA,CAAkB,GAAA,CAAI,KAAA,CAAM,EAAE,CAAA,EAAG;AAE1C,IAAA,IAAA,CAAK,iBAAA,CAAkB,GAAA,CAAI,KAAA,CAAM,EAAE,CAAA;AAEnC,IAAA,MAAM,SAAA,GAAY,YAAA;AAAA,MAChB,KAAK,qBAAA,CAAsB,GAAA,CAAI,CAAC,CAAA,KAAM,EAAE,KAAK,CAAA;AAAA,MAC7C,KAAA,CAAM;AAAA,KACR;AAEA,IAAA,IAAA,CAAK,wBAAwB,GAAA,CAAI,UAAA;AAAA,MAC/B,IAAA,CAAK,qBAAA;AAAA,MACL,SAAA;AAAA,MACA;AAAA,KACF;AAAA,EACF;AAAA,EAEA,YAAY,SAAA,EAAoB;AAC9B,IAAA,MAAM,cAAc,gBAAA,EAAiB;AAErC,IAAA,IAAA,CAAK,OAAA,CAAQ,WAAW,WAAW,CAAA;AAEnC,IAAA,KAAA,MAAW,CAAA,IAAK,KAAK,qBAAA,EAAuB;AAC1C,MAAA,CAAA,CAAE,UAAU,WAAW,CAAA;AAAA,IACzB;AAAA,EACF;AACF;;;;"}

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

@@ -1,4 +1,4 @@
-import { type NonEmptyArray } from 'ts-type-forge';
+import { type NonEmptyTuple } from 'ts-type-forge';
 import { type CombineObservableRefined, type Observable } from '../types/index.mjs';
 /**
  * Combines multiple observables into a single observable that emits an array of their latest values.
@@ -57,10 +57,10 @@ import { type CombineObservableRefined, type Observable } from '../types/index.m
  * ]);
  * ```
  */
-export declare const combine: <const OS extends NonEmptyArray<Observable<unknown>>>(parents: OS) => CombineObservableRefined<OS>;
+export declare const combine: <const OS extends NonEmptyTuple<Observable<unknown>>>(parents: OS) => CombineObservableRefined<OS>;
 /**
  * Alias for `combine`.
  * @see combine
  */
-export declare const combineLatest: <const OS extends NonEmptyArray<Observable<unknown>>>(parents: OS) => CombineObservableRefined<OS>;
+export declare const combineLatest: typeof combine;
 //# sourceMappingURL=combine.d.mts.map

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,EAAE,MAAM,eAAe,CAAC;AAInD,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,EACzE,SAAS,EAAE,KACV,wBAAwB,CAAC,EAAE,CAIgB,CAAC;AAE/C;;;GAGG;AACH,eAAO,MAAM,aAAa,SAZI,EAAE,SAAS,aAAa,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,WAChE,EAAE,KACV,wBAAwB,CAAC,EAAE,CAUM,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,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"}

package/dist/core/combine/combine.mjs

@@ -1,122 +1,40 @@
-import { Optional, Arr } from 'ts-data-forge';
+import { Arr, Optional } from 'ts-data-forge';
 import { SyncChildObservableClass } from '../class/child-observable-class.mjs';
 import '../utils/id-maker.mjs';
-import { source } from '../create/source.mjs';
-import { withInitialValue } from '../operators/with-initial-value.mjs';
 
-/**
- * Combines multiple observables into a single observable that emits an array of their latest values.
- * Emits whenever any of the source observables emit, but only after all sources have emitted at least once.
- *
- * @template OS - Tuple type of source observables
- * @param parents - Array of observables to combine
- * @returns A combined observable emitting tuples of values
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  name$     "Alice"                 "Bob"
- * //  age$                25                        30
- * //  user$               ["Alice",25]  ["Bob",25]  ["Bob",30]
- * //
- * //  Explanation:
- * //  - combine waits for all sources to emit at least once
- * //  - Then emits the latest value from all sources whenever any source emits
- * //  - Always emits an array with the latest values from each source
- *
- * const name$ = source<string>();
- *
- * const age$ = source<number>();
- *
- * const user$ = combine([name$, age$]);
- *
- * const userHistory: (readonly [string, number])[] = [];
- *
- * user$.subscribe(([name_, age]) => {
- *   userHistory.push([name_, age]);
- * });
- *
- * name$.next('Alice'); // nothing logged (age$ hasn't emitted yet)
- *
- * assert.deepStrictEqual(userHistory, []);
- *
- * age$.next(25); // logs: { name: 'Alice', age: 25 }
- *
- * assert.deepStrictEqual(userHistory, [['Alice', 25]]);
- *
- * name$.next('Bob'); // logs: { name: 'Bob', age: 25 }
- *
- * assert.deepStrictEqual(userHistory, [
- *   ['Alice', 25],
- *   ['Bob', 25],
- * ]);
- *
- * age$.next(30); // logs: { name: 'Bob', age: 30 }
- *
- * assert.deepStrictEqual(userHistory, [
- *   ['Alice', 25],
- *   ['Bob', 25],
- *   ['Bob', 30],
- * ]);
- * ```
- */
-const combine = (parents) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-new CombineObservableClass(parents);
-/**
- * Alias for `combine`.
- * @see combine
- */
+const combine = (parents) => (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  new CombineObservableClass(
+    parents
+  )
+);
 const combineLatest = combine;
 class CombineObservableClass extends SyncChildObservableClass {
-    constructor(parents) {
-        const parentsValues = parents.map((p) => p.getSnapshot());
-        super({
-            parents,
-            initialValue: parentsValues.every(Optional.isSome)
-                ? Optional.some(
-                // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-                Arr.map(parentsValues, (c) => c.value))
-                : Optional.none,
-        });
+  constructor(parents) {
+    const parentsValues = Arr.map(
+      parents,
+      (p) => p.getSnapshot()
+    );
+    const initialValue = Arr.every(parentsValues, Optional.isSome) ? Optional.some(Arr.map(parentsValues, (c) => c.value)) : Optional.none;
+    super({
+      parents,
+      initialValue
+    });
+  }
+  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
+      );
+      this.setNext(nextValue, updateToken);
     }
-    tryUpdate(updateToken) {
-        if (this.parents.every((o) => o.updateToken !== updateToken))
-            return; // all parents are skipped
-        const parentValues = this.parents.map((a) => a.getSnapshot());
-        if (parentValues.every(Optional.isSome)) {
-            const nextValue = 
-            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-            Arr.map(parentValues, (a) => a.value);
-            this.setNext(nextValue, updateToken);
-        }
-    }
-}
-{
-    {
-        const s1 = source();
-        const s2 = source();
-        combine([s1, s2]);
-    }
-    {
-        const s1 = source().pipe(withInitialValue(1));
-        const s2 = source();
-        combine([s1, s2]);
-    }
-    {
-        const s1 = source().pipe(withInitialValue(1));
-        const s2 = source().pipe(withInitialValue(2));
-        combine([s1, s2]);
-        // Returns InitializedObservable if all OS are InitializedObservable
-    }
-    const r1 = source(1);
-    const r2 = source('a');
-    combine([r1, r2]);
-    combine([
-        r1.pipe(withInitialValue(0)),
-        r2.pipe(withInitialValue(0)),
-    ]);
+  }
 }
 
 export { combine, combineLatest };

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

@@ -1 +1 @@
-{"version":3,"file":"combine.mjs","sources":["../../../src/core/combine/combine.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;AAiBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwDG;AACI,MAAM,OAAO,GAAG,CACrB,OAAW;AAEX;AACA,IAAI,sBAAsB,CACxB,OAAO;AAGX;;;AAGG;AACI,MAAM,aAAa,GAAG;AAE7B,MAAM,sBACJ,SAAQ,wBAA8B,CAAA;AAGtC,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;;AAGK,IAAA,SAAS,CAAC,WAAwB,EAAA;AACzC,QAAA,IAAI,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,WAAW,KAAK,WAAW,CAAC;AAAE,YAAA,OAAO;AAErE,QAAA,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,WAAW,EAAE,CAAC;QAE7D,IAAI,YAAY,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE;AACvC,YAAA,MAAM,SAAS;;AAEb,YAAA,GAAG,CAAC,GAAG,CAAC,YAAY,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,CAAM;AAE5C,YAAA,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,WAAW,CAAC;;;AAGzC;AAED;IACE;AACE,QAAA,MAAM,EAAE,GAAkB,MAAM,EAAK;AAErC,QAAA,MAAM,EAAE,GAAkB,MAAM,EAAK;QAE1B,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC;;IAO7B;AACE,QAAA,MAAM,EAAE,GAA6B,MAAM,EAAK,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC;AAE1E,QAAA,MAAM,EAAE,GAAkB,MAAM,EAAK;QAE1B,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC;;IAO7B;AACE,QAAA,MAAM,EAAE,GAA6B,MAAM,EAAK,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC;AAE1E,QAAA,MAAM,EAAE,GAA6B,MAAM,EAAK,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC;QAE/D,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC;;;AAM7B,IAAA,MAAM,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC;AAEpB,IAAA,MAAM,EAAE,GAAG,MAAM,CAAC,GAAG,CAAC;IAEX,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC;IAEf,OAAO,CAAC;AAClB,QAAA,EAAE,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC;AAC5B,QAAA,EAAE,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC;AAC7B,KAAA;AAQH;;;;"}
+{"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;;;;"}

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

@@ -1,4 +1,4 @@
-import { type NonEmptyArray } from 'ts-type-forge';
+import { type NonEmptyTuple } from 'ts-type-forge';
 import { type MergeObservableRefined, type Observable } from '../types/index.mjs';
 /**
  * Merges multiple observables into a single observable that emits all values from all sources.
@@ -51,5 +51,5 @@ import { type MergeObservableRefined, type Observable } from '../types/index.mjs
  * @note To improve code readability, consider using `createState` instead of `merge`,
  * subscribing to `parents` and calling `setState` within it.
  */
-export declare const merge: <const OS extends NonEmptyArray<Observable<unknown>>>(parents: OS) => MergeObservableRefined<OS>;
+export declare const merge: <const OS extends NonEmptyTuple<Observable<unknown>>>(parents: OS) => MergeObservableRefined<OS>;
 //# sourceMappingURL=merge.d.mts.map

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,EACvE,SAAS,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,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"}

package/dist/core/combine/merge.mjs

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

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

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

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

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

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

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

package/dist/core/combine/zip.mjs

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