synstate 1.0.1 → 2.0.0

package/dist/core/operators/with-buffered-from.mjs

@@ -3,99 +3,46 @@ import { SyncChildObservableClass } from '../class/child-observable-class.mjs';
 import '../utils/id-maker.mjs';
 import { maxDepth } from '../utils/max-depth.mjs';
 
-/**
- * Buffers values from the source observable and emits them along with the parent value
- * when the parent emits. The buffer is cleared after each emission.
- *
- * @template A - The type of values from the parent observable
- * @template B - The type of values from the source observable
- * @param observable - The observable whose values will be buffered
- * @returns An operator that emits tuples of [parentValue, bufferedValues]
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  data$       d1    d2    d3    d4    d5    d6    d7    d8
- * //  trigger$                T1                T2                T3
- * //  result$                 [T1,[d1,d2,d3]]   [T2,[d4,d5,d6]]   [T3,[d7,d8]]
- * //
- * //  Explanation:
- * //  - withBufferedFrom collects values from the source observable
- * //  - When the trigger emits, it emits a tuple of [triggerValue, bufferedValues]
- * //  - Buffer is cleared after each emission
- * //  - Useful for batching data collection triggered by events
- *
- * const data$ = source<string>();
- *
- * const trigger$ = source<number>();
- *
- * const result$ = trigger$.pipe(withBufferedFrom(data$));
- *
- * const valueHistory: (readonly [number, readonly string[]])[] = [];
- *
- * result$.subscribe(([triggerValue, bufferedData]) => {
- *   valueHistory.push([triggerValue, bufferedData]);
- * });
- *
- * data$.next('A');
- *
- * data$.next('B');
- *
- * trigger$.next(1);
- *
- * assert.deepStrictEqual(valueHistory, [[1, ['A', 'B']]]);
- *
- * data$.next('C');
- *
- * trigger$.next(2);
- *
- * assert.deepStrictEqual(valueHistory, [
- *   [1, ['A', 'B']],
- *   [2, ['C']],
- * ]);
- * ```
- */
-const withBufferedFrom = (observable) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-((parentObservable) => new WithBufferedFromObservableClass(parentObservable, observable));
-/**
- * Alias for `withBufferedFrom`.
- * @see withBufferedFrom
- */
+const withBufferedFrom = (observable) => (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  ((parentObservable) => new WithBufferedFromObservableClass(
+    parentObservable,
+    observable
+  ))
+);
 const withBuffered = withBufferedFrom;
 class WithBufferedFromObservableClass extends SyncChildObservableClass {
-    #mut_bufferedValues = [];
-    constructor(parentObservable, observable) {
-        super({
-            parents: [parentObservable],
-            depth: 1 + maxDepth([parentObservable, observable]),
-            initialValue: pipe({
-                par: parentObservable.getSnapshot(),
-                me: observable.getSnapshot(),
-            }).map(({ par, me }) => Optional.isNone(par)
-                ? Optional.none
-                : Optional.some([
-                    par.value,
-                    Optional.isNone(me) ? [] : [me.value],
-                ])).value,
-        });
-        observable.subscribe((value) => {
-            this.#mut_bufferedValues = Arr.toPushed(this.#mut_bufferedValues, value);
-        });
-    }
-    tryUpdate(updateToken) {
-        const par = this.parents[0];
-        const sn = par.getSnapshot();
-        if (par.updateToken !== updateToken || Optional.isNone(sn)) {
-            return; // skip update
-        }
-        this.setNext([sn.value, this.#mut_bufferedValues], updateToken);
-        this.#clearBuffer();
-    }
-    #clearBuffer() {
-        this.#mut_bufferedValues = [];
+  #mut_bufferedValues = [];
+  constructor(parentObservable, observable) {
+    super({
+      parents: [parentObservable],
+      depth: 1 + maxDepth([parentObservable, observable]),
+      initialValue: pipe({
+        par: parentObservable.getSnapshot(),
+        me: observable.getSnapshot()
+      }).map(
+        ({ par, me }) => Optional.isNone(par) ? Optional.none : Optional.some([
+          par.value,
+          Optional.isNone(me) ? [] : [me.value]
+        ])
+      ).value
+    });
+    observable.subscribe((value) => {
+      this.#mut_bufferedValues = Arr.toPushed(this.#mut_bufferedValues, value);
+    });
+  }
+  #clearBuffer() {
+    this.#mut_bufferedValues = [];
+  }
+  tryUpdate(updateToken) {
+    const par = this.parents[0];
+    const sn = par.getSnapshot();
+    if (par.updateToken !== updateToken || Optional.isNone(sn)) {
+      return;
     }
+    this.setNext([sn.value, this.#mut_bufferedValues], updateToken);
+    this.#clearBuffer();
+  }
 }
 
 export { withBuffered, withBufferedFrom };

package/dist/core/operators/with-buffered-from.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"with-buffered-from.mjs","sources":["../../../src/core/operators/with-buffered-from.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDG;AACI,MAAM,gBAAgB,GAAG,CAC9B,UAAyB;AAEzB;AACA,CAAC,CAAC,gBAAgB,KAChB,IAAI,+BAA+B,CACjC,gBAAgB,EAChB,UAAU,CACX;AAEL;;;AAGG;AACI,MAAM,YAAY,GAAG;AAE5B,MAAM,+BACJ,SAAQ,wBAAkE,CAAA;IAG1E,mBAAmB,GAAiB,EAAE;IAEtC,WAAA,CAAY,gBAA+B,EAAE,UAAyB,EAAA;AACpE,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,KAAK,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,gBAAgB,EAAE,UAAU,CAAC,CAAC;YACnD,YAAY,EAAE,IAAI,CAAC;AACjB,gBAAA,GAAG,EAAE,gBAAgB,CAAC,WAAW,EAAE;AACnC,gBAAA,EAAE,EAAE,UAAU,CAAC,WAAW,EAAE;AAC7B,aAAA,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,KACjB,QAAQ,CAAC,MAAM,CAAC,GAAG;kBACf,QAAQ,CAAC;AACX,kBAAE,QAAQ,CAAC,IAAI,CAAC;AACZ,oBAAA,GAAG,CAAC,KAAK;AACT,oBAAA,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC;iBAC7B,CAAC,CAChB,CAAC,KAAK;AACR,SAAA,CAAC;AAEF,QAAA,UAAU,CAAC,SAAS,CAAC,CAAC,KAAK,KAAI;AAC7B,YAAA,IAAI,CAAC,mBAAmB,GAAG,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,mBAAmB,EAAE,KAAK,CAAC;AAC1E,QAAA,CAAC,CAAC;IACJ;AAES,IAAA,SAAS,CAAC,WAAwB,EAAA;QACzC,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAE3B,QAAA,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE;AAE5B,QAAA,IAAI,GAAG,CAAC,WAAW,KAAK,WAAW,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE;AAC1D,YAAA,OAAO;QACT;AAEA,QAAA,IAAI,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,mBAAmB,CAAC,EAAE,WAAW,CAAC;QAE/D,IAAI,CAAC,YAAY,EAAE;IACrB;IAEA,YAAY,GAAA;AACV,QAAA,IAAI,CAAC,mBAAmB,GAAG,EAAE;IAC/B;AACD;;;;"}
+{"version":3,"file":"with-buffered-from.mjs","sources":["../../../src/core/operators/with-buffered-from.mts"],"sourcesContent":["import { Arr, Optional, pipe } from 'ts-data-forge';\nimport { SyncChildObservableClass } from '../class/index.mjs';\nimport {\n  type KeepInitialValueOperator,\n  type Observable,\n  type UpdateToken,\n  type WithBufferedFromOperatorObservable,\n} from '../types/index.mjs';\nimport { maxDepth } from '../utils/index.mjs';\n\n/**\n * Buffers values from the source observable and emits them along with the parent value\n * when the parent emits. The buffer is cleared after each emission.\n *\n * @template A - The type of values from the parent observable\n * @template B - The type of values from the source observable\n * @param observable - The observable whose values will be buffered\n * @returns An operator that emits tuples of [parentValue, bufferedValues]\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  data$       d1    d2    d3    d4    d5    d6    d7    d8\n * //  trigger$                T1                T2                T3\n * //  result$                 [T1,[d1,d2,d3]]   [T2,[d4,d5,d6]]   [T3,[d7,d8]]\n * //\n * //  Explanation:\n * //  - withBufferedFrom collects values from the source observable\n * //  - When the trigger emits, it emits a tuple of [triggerValue, bufferedValues]\n * //  - Buffer is cleared after each emission\n * //  - Useful for batching data collection triggered by events\n *\n * const data$ = source<string>();\n *\n * const trigger$ = source<number>();\n *\n * const result$ = trigger$.pipe(withBufferedFrom(data$));\n *\n * const valueHistory: (readonly [number, readonly string[]])[] = [];\n *\n * result$.subscribe(([triggerValue, bufferedData]) => {\n *   valueHistory.push([triggerValue, bufferedData]);\n * });\n *\n * data$.next('A');\n *\n * data$.next('B');\n *\n * trigger$.next(1);\n *\n * assert.deepStrictEqual(valueHistory, [[1, ['A', 'B']]]);\n *\n * data$.next('C');\n *\n * trigger$.next(2);\n *\n * assert.deepStrictEqual(valueHistory, [\n *   [1, ['A', 'B']],\n *   [2, ['C']],\n * ]);\n * ```\n */\nexport const withBufferedFrom = <A, B>(\n  observable: Observable<B>,\n): KeepInitialValueOperator<A, readonly [A, readonly B[]]> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  ((parentObservable) =>\n    new WithBufferedFromObservableClass(\n      parentObservable,\n      observable,\n    )) as KeepInitialValueOperator<A, readonly [A, readonly B[]]>;\n\n/**\n * Alias for `withBufferedFrom`.\n * @see withBufferedFrom\n */\nexport const withBuffered = withBufferedFrom;\n\nclass WithBufferedFromObservableClass<A, B>\n  extends SyncChildObservableClass<readonly [A, readonly B[]], readonly [A]>\n  implements WithBufferedFromOperatorObservable<A, B>\n{\n  #mut_bufferedValues: readonly B[] = [];\n\n  constructor(parentObservable: Observable<A>, observable: Observable<B>) {\n    super({\n      parents: [parentObservable],\n      depth: 1 + maxDepth([parentObservable, observable]),\n      initialValue: pipe({\n        par: parentObservable.getSnapshot(),\n        me: observable.getSnapshot(),\n      }).map(({ par, me }) =>\n        Optional.isNone(par)\n          ? Optional.none\n          : Optional.some([\n              par.value,\n              Optional.isNone(me) ? [] : [me.value],\n            ] as const),\n      ).value,\n    });\n\n    observable.subscribe((value) => {\n      this.#mut_bufferedValues = Arr.toPushed(this.#mut_bufferedValues, value);\n    });\n  }\n\n  #clearBuffer(): void {\n    this.#mut_bufferedValues = [];\n  }\n\n  override tryUpdate(updateToken: UpdateToken): void {\n    const par = this.parents[0];\n\n    const sn = par.getSnapshot();\n\n    if (par.updateToken !== updateToken || Optional.isNone(sn)) {\n      return; // skip update\n    }\n\n    this.setNext([sn.value, this.#mut_bufferedValues], updateToken);\n\n    this.#clearBuffer();\n  }\n}\n"],"names":[],"mappings":";;;;;AA+DO,MAAM,mBAAmB,CAC9B,UAAA;AAAA;AAAA,GAGC,CAAC,qBACA,IAAI,+BAAA;AAAA,IACF,gBAAA;AAAA,IACA;AAAA,GACF;AAAA;AAMG,MAAM,YAAA,GAAe;AAE5B,MAAM,wCACI,wBAAA,CAEV;AAAA,EACE,sBAAoC,EAAC;AAAA,EAErC,WAAA,CAAY,kBAAiC,UAAA,EAA2B;AACtE,IAAA,KAAA,CAAM;AAAA,MACJ,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,MAC1B,OAAO,CAAA,GAAI,QAAA,CAAS,CAAC,gBAAA,EAAkB,UAAU,CAAC,CAAA;AAAA,MAClD,cAAc,IAAA,CAAK;AAAA,QACjB,GAAA,EAAK,iBAAiB,WAAA,EAAY;AAAA,QAClC,EAAA,EAAI,WAAW,WAAA;AAAY,OAC5B,CAAA,CAAE,GAAA;AAAA,QAAI,CAAC,EAAE,GAAA,EAAK,EAAA,EAAG,KAChB,QAAA,CAAS,MAAA,CAAO,GAAG,CAAA,GACf,QAAA,CAAS,IAAA,GACT,QAAA,CAAS,IAAA,CAAK;AAAA,UACZ,GAAA,CAAI,KAAA;AAAA,UACJ,QAAA,CAAS,OAAO,EAAE,CAAA,GAAI,EAAC,GAAI,CAAC,GAAG,KAAK;AAAA,SAC5B;AAAA,OAChB,CAAE;AAAA,KACH,CAAA;AAED,IAAA,UAAA,CAAW,SAAA,CAAU,CAAC,KAAA,KAAU;AAC9B,MAAA,IAAA,CAAK,mBAAA,GAAsB,GAAA,CAAI,QAAA,CAAS,IAAA,CAAK,qBAAqB,KAAK,CAAA;AAAA,IACzE,CAAC,CAAA;AAAA,EACH;AAAA,EAEA,YAAA,GAAqB;AACnB,IAAA,IAAA,CAAK,sBAAsB,EAAC;AAAA,EAC9B;AAAA,EAES,UAAU,WAAA,EAAgC;AACjD,IAAA,MAAM,GAAA,GAAM,IAAA,CAAK,OAAA,CAAQ,CAAC,CAAA;AAE1B,IAAA,MAAM,EAAA,GAAK,IAAI,WAAA,EAAY;AAE3B,IAAA,IAAI,IAAI,WAAA,KAAgB,WAAA,IAAe,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAAG;AAC1D,MAAA;AAAA,IACF;AAEA,IAAA,IAAA,CAAK,QAAQ,CAAC,EAAA,CAAG,OAAO,IAAA,CAAK,mBAAmB,GAAG,WAAW,CAAA;AAE9D,IAAA,IAAA,CAAK,YAAA,EAAa;AAAA,EACpB;AACF;;;;"}

package/dist/core/operators/with-current-value-from.d.mts

@@ -60,5 +60,5 @@ export declare const withCurrentValueFrom: <A, B>(observable: Observable<B>) =>
  * Alias for `withCurrentValueFrom`.
  * @see withCurrentValueFrom
  */
-export declare const withLatestFrom: <A, B>(observable: Observable<B>) => DropInitialValueOperator<A, readonly [A, B]>;
+export declare const withLatestFrom: typeof withCurrentValueFrom;
 //# sourceMappingURL=with-current-value-from.d.mts.map

package/dist/core/operators/with-current-value-from.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"with-current-value-from.d.mts","sourceRoot":"","sources":["../../../src/core/operators/with-current-value-from.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,UAAU,EAGhB,MAAM,oBAAoB,CAAC;AAG5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,eAAO,MAAM,oBAAoB,GAC9B,CAAC,EAAE,CAAC,EACH,YAAY,UAAU,CAAC,CAAC,CAAC,KACxB,wBAAwB,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAEyB,CAAC;AAE1E;;;GAGG;AACH,eAAO,MAAM,cAAc,GAVxB,CAAC,EAAE,CAAC,cACS,UAAU,CAAC,CAAC,CAAC,KACxB,wBAAwB,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAQE,CAAC"}
+{"version":3,"file":"with-current-value-from.d.mts","sourceRoot":"","sources":["../../../src/core/operators/with-current-value-from.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,UAAU,EAGhB,MAAM,oBAAoB,CAAC;AAG5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,eAAO,MAAM,oBAAoB,GAC9B,CAAC,EAAE,CAAC,cACS,UAAU,CAAC,CAAC,CAAC,KACxB,wBAAwB,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAEyB,CAAC;AAE1E;;;GAGG;AACH,eAAO,MAAM,cAAc,6BAAuB,CAAC"}

package/dist/core/operators/with-current-value-from.mjs

@@ -3,94 +3,33 @@ import { SyncChildObservableClass } from '../class/child-observable-class.mjs';
 import '../utils/id-maker.mjs';
 import { maxDepth } from '../utils/max-depth.mjs';
 
-/**
- * Samples the current value from another observable each time the source emits.
- * Emits a tuple of [sourceValue, sampledValue].
- *
- * @template A - The type of values from the source observable
- * @template B - The type of values from the sampled observable
- * @param observable - The observable to sample from
- * @returns An operator that emits tuples of source and sampled values
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  name$     "Alice"           "Bob"               "Charlie"
- * //  age$                25              30
- * //  result$   (skip)          ["Bob",25]           ["Charlie",30]
- * //
- * //  Explanation:
- * //  - withCurrentValueFrom samples the current value from another observable
- * //  - Emits a tuple [sourceValue, sampledValue] each time the SOURCE emits
- * //  - Does NOT emit when the sampled observable (age$) emits
- * //  - Does not emit until both observables have emitted at least once
- * //  - "Alice" is skipped because age$ hasn't emitted yet
- *
- * const name$ = source<string>();
- *
- * const age$ = source<number>();
- *
- * const result$ = name$.pipe(withCurrentValueFrom(age$));
- *
- * const valueHistory: (readonly [string, number])[] = [];
- *
- * result$.subscribe(([name_, currentAge]) => {
- *   valueHistory.push([name_, currentAge]);
- * });
- *
- * name$.next('Alice'); // nothing logged (age$ hasn't emitted)
- *
- * assert.deepStrictEqual(valueHistory, []);
- *
- * age$.next(25);
- *
- * name$.next('Bob'); // logs: Bob is 25 years old
- *
- * assert.deepStrictEqual(valueHistory, [['Bob', 25]]);
- *
- * age$.next(30);
- *
- * name$.next('Charlie'); // logs: Charlie is 30 years old
- *
- * assert.deepStrictEqual(valueHistory, [
- *   ['Bob', 25],
- *   ['Charlie', 30],
- * ]);
- * ```
- */
 const withCurrentValueFrom = (observable) => (parentObservable) => new WithCurrentValueFromObservableClass(parentObservable, observable);
-/**
- * Alias for `withCurrentValueFrom`.
- * @see withCurrentValueFrom
- */
 const withLatestFrom = withCurrentValueFrom;
 class WithCurrentValueFromObservableClass extends SyncChildObservableClass {
-    #observable;
-    constructor(parentObservable, observable) {
-        super({
-            parents: [parentObservable],
-            depth: 1 + maxDepth([parentObservable, observable]),
-            initialValue: pipe({
-                par: parentObservable.getSnapshot(),
-                me: observable.getSnapshot(),
-            }).map(({ me, par }) => Optional.isNone(par) || Optional.isNone(me)
-                ? Optional.none
-                : Optional.some([par.value, me.value])).value,
-        });
-        this.#observable = observable;
-    }
-    tryUpdate(updateToken) {
-        const par = this.parents[0];
-        const ps = par.getSnapshot();
-        if (par.updateToken !== updateToken || Optional.isNone(ps)) {
-            return; // skip update
-        }
-        const curr = this.#observable.getSnapshot();
-        if (Optional.isNone(curr))
-            return; // skip update
-        this.setNext([ps.value, curr.value], updateToken);
+  #observable;
+  constructor(parentObservable, observable) {
+    super({
+      parents: [parentObservable],
+      depth: 1 + maxDepth([parentObservable, observable]),
+      initialValue: pipe({
+        par: parentObservable.getSnapshot(),
+        me: observable.getSnapshot()
+      }).map(
+        ({ me, par }) => Optional.isNone(par) || Optional.isNone(me) ? Optional.none : Optional.some([par.value, me.value])
+      ).value
+    });
+    this.#observable = observable;
+  }
+  tryUpdate(updateToken) {
+    const par = this.parents[0];
+    const ps = par.getSnapshot();
+    if (par.updateToken !== updateToken || Optional.isNone(ps)) {
+      return;
     }
+    const curr = this.#observable.getSnapshot();
+    if (Optional.isNone(curr)) return;
+    this.setNext([ps.value, curr.value], updateToken);
+  }
 }
 
 export { withCurrentValueFrom, withLatestFrom };

package/dist/core/operators/with-current-value-from.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"with-current-value-from.mjs","sources":["../../../src/core/operators/with-current-value-from.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuDG;MACU,oBAAoB,GAC/B,CACE,UAAyB,KAE3B,CAAC,gBAAgB,KACf,IAAI,mCAAmC,CAAC,gBAAgB,EAAE,UAAU;AAExE;;;AAGG;AACI,MAAM,cAAc,GAAG;AAE9B,MAAM,mCACJ,SAAQ,wBAAuD,CAAA;AAGtD,IAAA,WAAW;IAEpB,WAAA,CAAY,gBAA+B,EAAE,UAAyB,EAAA;AACpE,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,KAAK,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,gBAAgB,EAAE,UAAU,CAAC,CAAC;YACnD,YAAY,EAAE,IAAI,CAAC;AACjB,gBAAA,GAAG,EAAE,gBAAgB,CAAC,WAAW,EAAE;AACnC,gBAAA,EAAE,EAAE,UAAU,CAAC,WAAW,EAAE;aAC7B,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,GAAG,EAAE,KACjB,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE;kBACtC,QAAQ,CAAC;AACX,kBAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAU,CAAC,CAClD,CAAC,KAAK;AACR,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,WAAW,GAAG,UAAU;IAC/B;AAES,IAAA,SAAS,CAAC,WAAwB,EAAA;QACzC,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAE3B,QAAA,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE;AAE5B,QAAA,IAAI,GAAG,CAAC,WAAW,KAAK,WAAW,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE;AAC1D,YAAA,OAAO;QACT;QAEA,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE;AAE3C,QAAA,IAAI,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC;AAAE,YAAA,OAAO;AAElC,QAAA,IAAI,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC;IACnD;AACD;;;;"}
+{"version":3,"file":"with-current-value-from.mjs","sources":["../../../src/core/operators/with-current-value-from.mts"],"sourcesContent":["import { Optional, pipe } from 'ts-data-forge';\nimport { SyncChildObservableClass } from '../class/index.mjs';\nimport {\n  type DropInitialValueOperator,\n  type Observable,\n  type UpdateToken,\n  type WithCurrentValueFromOperatorObservable,\n} from '../types/index.mjs';\nimport { maxDepth } from '../utils/index.mjs';\n\n/**\n * Samples the current value from another observable each time the source emits.\n * Emits a tuple of [sourceValue, sampledValue].\n *\n * @template A - The type of values from the source observable\n * @template B - The type of values from the sampled observable\n * @param observable - The observable to sample from\n * @returns An operator that emits tuples of source and sampled values\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  name$     \"Alice\"           \"Bob\"               \"Charlie\"\n * //  age$                25              30\n * //  result$   (skip)          [\"Bob\",25]           [\"Charlie\",30]\n * //\n * //  Explanation:\n * //  - withCurrentValueFrom samples the current value from another observable\n * //  - Emits a tuple [sourceValue, sampledValue] each time the SOURCE emits\n * //  - Does NOT emit when the sampled observable (age$) emits\n * //  - Does not emit until both observables have emitted at least once\n * //  - \"Alice\" is skipped because age$ hasn't emitted yet\n *\n * const name$ = source<string>();\n *\n * const age$ = source<number>();\n *\n * const result$ = name$.pipe(withCurrentValueFrom(age$));\n *\n * const valueHistory: (readonly [string, number])[] = [];\n *\n * result$.subscribe(([name_, currentAge]) => {\n *   valueHistory.push([name_, currentAge]);\n * });\n *\n * name$.next('Alice'); // nothing logged (age$ hasn't emitted)\n *\n * assert.deepStrictEqual(valueHistory, []);\n *\n * age$.next(25);\n *\n * name$.next('Bob'); // logs: Bob is 25 years old\n *\n * assert.deepStrictEqual(valueHistory, [['Bob', 25]]);\n *\n * age$.next(30);\n *\n * name$.next('Charlie'); // logs: Charlie is 30 years old\n *\n * assert.deepStrictEqual(valueHistory, [\n *   ['Bob', 25],\n *   ['Charlie', 30],\n * ]);\n * ```\n */\nexport const withCurrentValueFrom =\n  <A, B>(\n    observable: Observable<B>,\n  ): DropInitialValueOperator<A, readonly [A, B]> =>\n  (parentObservable) =>\n    new WithCurrentValueFromObservableClass(parentObservable, observable);\n\n/**\n * Alias for `withCurrentValueFrom`.\n * @see withCurrentValueFrom\n */\nexport const withLatestFrom = withCurrentValueFrom;\n\nclass WithCurrentValueFromObservableClass<A, B>\n  extends SyncChildObservableClass<readonly [A, B], readonly [A]>\n  implements WithCurrentValueFromOperatorObservable<A, B>\n{\n  readonly #observable: Observable<B>;\n\n  constructor(parentObservable: Observable<A>, observable: Observable<B>) {\n    super({\n      parents: [parentObservable],\n      depth: 1 + maxDepth([parentObservable, observable]),\n      initialValue: pipe({\n        par: parentObservable.getSnapshot(),\n        me: observable.getSnapshot(),\n      }).map(({ me, par }) =>\n        Optional.isNone(par) || Optional.isNone(me)\n          ? Optional.none\n          : Optional.some([par.value, me.value] as const),\n      ).value,\n    });\n\n    this.#observable = observable;\n  }\n\n  override tryUpdate(updateToken: UpdateToken): void {\n    const par = this.parents[0];\n\n    const ps = par.getSnapshot();\n\n    if (par.updateToken !== updateToken || Optional.isNone(ps)) {\n      return; // skip update\n    }\n\n    const curr = this.#observable.getSnapshot();\n\n    if (Optional.isNone(curr)) return; // skip update\n\n    this.setNext([ps.value, curr.value], updateToken);\n  }\n}\n"],"names":[],"mappings":";;;;;AAkEO,MAAM,oBAAA,GACX,CACE,UAAA,KAEF,CAAC,qBACC,IAAI,mCAAA,CAAoC,kBAAkB,UAAU;AAMjE,MAAM,cAAA,GAAiB;AAE9B,MAAM,4CACI,wBAAA,CAEV;AAAA,EACW,WAAA;AAAA,EAET,WAAA,CAAY,kBAAiC,UAAA,EAA2B;AACtE,IAAA,KAAA,CAAM;AAAA,MACJ,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,MAC1B,OAAO,CAAA,GAAI,QAAA,CAAS,CAAC,gBAAA,EAAkB,UAAU,CAAC,CAAA;AAAA,MAClD,cAAc,IAAA,CAAK;AAAA,QACjB,GAAA,EAAK,iBAAiB,WAAA,EAAY;AAAA,QAClC,EAAA,EAAI,WAAW,WAAA;AAAY,OAC5B,CAAA,CAAE,GAAA;AAAA,QAAI,CAAC,EAAE,EAAA,EAAI,GAAA,OACZ,QAAA,CAAS,MAAA,CAAO,GAAG,CAAA,IAAK,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,GACtC,QAAA,CAAS,OACT,QAAA,CAAS,IAAA,CAAK,CAAC,GAAA,CAAI,KAAA,EAAO,EAAA,CAAG,KAAK,CAAU;AAAA,OAClD,CAAE;AAAA,KACH,CAAA;AAED,IAAA,IAAA,CAAK,WAAA,GAAc,UAAA;AAAA,EACrB;AAAA,EAES,UAAU,WAAA,EAAgC;AACjD,IAAA,MAAM,GAAA,GAAM,IAAA,CAAK,OAAA,CAAQ,CAAC,CAAA;AAE1B,IAAA,MAAM,EAAA,GAAK,IAAI,WAAA,EAAY;AAE3B,IAAA,IAAI,IAAI,WAAA,KAAgB,WAAA,IAAe,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAAG;AAC1D,MAAA;AAAA,IACF;AAEA,IAAA,MAAM,IAAA,GAAO,IAAA,CAAK,WAAA,CAAY,WAAA,EAAY;AAE1C,IAAA,IAAI,QAAA,CAAS,MAAA,CAAO,IAAI,CAAA,EAAG;AAE3B,IAAA,IAAA,CAAK,QAAQ,CAAC,EAAA,CAAG,OAAO,IAAA,CAAK,KAAK,GAAG,WAAW,CAAA;AAAA,EAClD;AACF;;;;"}

package/dist/core/operators/with-initial-value.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"with-initial-value.d.mts","sourceRoot":"","sources":["../../../src/core/operators/with-initial-value.mts"],"names":[],"mappings":"AAGA,OAAO,EAIL,KAAK,wBAAwB,EAE9B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,eAAO,MAAM,gBAAgB,GAC1B,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,cAAc,CAAC,KAAG,wBAAwB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAEO,CAAC"}
+{"version":3,"file":"with-initial-value.d.mts","sourceRoot":"","sources":["../../../src/core/operators/with-initial-value.mts"],"names":[],"mappings":"AAGA,OAAO,EAIL,KAAK,wBAAwB,EAE9B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,eAAO,MAAM,gBAAgB,GAC1B,CAAC,EAAE,CAAC,GAAG,CAAC,gBAAgB,CAAC,KAAG,wBAAwB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAEO,CAAC"}

package/dist/core/operators/with-initial-value.mjs

@@ -2,67 +2,22 @@ import { Optional } from 'ts-data-forge';
 import { InitializedSyncChildObservableClass } from '../class/child-observable-class.mjs';
 import '../utils/id-maker.mjs';
 
-/**
- * Provides an initial value for an observable that doesn't have one.
- * The resulting observable will immediately emit the initial value upon subscription,
- * and then emit all subsequent values from the source.
- *
- * @template A - The type of values from the source
- * @template I - The type of the initial value (defaults to A)
- * @param initialValue - The initial value to emit
- * @returns An operator that sets the initial value
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  num$             1    2    3
- * //  withInitial$ 0   1    2    3
- * //               ^
- * //               initial value
- * //
- * //  Explanation:
- * //  - withInitialValue provides an initial value before the source emits
- * //  - Converts an uninitialized observable to an initialized one
- * //  - Useful when you need a default value immediately
- *
- * const num$ = source<number>();
- *
- * const initialized$ = num$.pipe(withInitialValue(0));
- *
- * const valueHistory: number[] = [];
- *
- * initialized$.subscribe((x) => {
- *   valueHistory.push(x);
- * });
- *
- * assert.deepStrictEqual(valueHistory, [0]);
- *
- * num$.next(1); // logs: 1
- *
- * assert.deepStrictEqual(valueHistory, [0, 1]);
- *
- * num$.next(2); // logs: 2
- *
- * assert.deepStrictEqual(valueHistory, [0, 1, 2]);
- * ```
- */
 const withInitialValue = (initialValue) => (parentObservable) => new WithInitialValueObservableClass(parentObservable, initialValue);
 class WithInitialValueObservableClass extends InitializedSyncChildObservableClass {
-    constructor(parentObservable, initialValue) {
-        super({
-            parents: [parentObservable],
-            initialValue: Optional.some(initialValue),
-        });
-    }
-    tryUpdate(updateToken) {
-        const par = this.parents[0];
-        const sn = par.getSnapshot();
-        if (par.updateToken !== updateToken || Optional.isNone(sn)) {
-            return; // skip update
-        }
-        this.setNext(sn.value, updateToken);
+  constructor(parentObservable, initialValue) {
+    super({
+      parents: [parentObservable],
+      initialValue: Optional.some(initialValue)
+    });
+  }
+  tryUpdate(updateToken) {
+    const par = this.parents[0];
+    const sn = par.getSnapshot();
+    if (par.updateToken !== updateToken || Optional.isNone(sn)) {
+      return;
     }
+    this.setNext(sn.value, updateToken);
+  }
 }
 
 export { withInitialValue };

package/dist/core/operators/with-initial-value.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"with-initial-value.mjs","sources":["../../../src/core/operators/with-initial-value.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CG;AACI,MAAM,gBAAgB,GAC3B,CAAW,YAAe,KAC1B,CAAC,gBAAgB,KACf,IAAI,+BAA+B,CAAC,gBAAgB,EAAE,YAAY;AAEtE,MAAM,+BACJ,SAAQ,mCAAwD,CAAA;IAGhE,WAAA,CAAY,gBAA+B,EAAE,YAAe,EAAA;AAC1D,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;AAC3B,YAAA,YAAY,EAAE,QAAQ,CAAC,IAAI,CAAC,YAAY,CAAC;AAC1C,SAAA,CAAC;;AAGK,IAAA,SAAS,CAAC,WAAwB,EAAA;QACzC,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAE3B,QAAA,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE;AAE5B,QAAA,IAAI,GAAG,CAAC,WAAW,KAAK,WAAW,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE;AAC1D,YAAA,OAAO;;QAGT,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC;;AAEtC;;;;"}
+{"version":3,"file":"with-initial-value.mjs","sources":["../../../src/core/operators/with-initial-value.mts"],"sourcesContent":["import { expectType, Optional } from 'ts-data-forge';\nimport { InitializedSyncChildObservableClass } from '../class/index.mjs';\nimport { source } from '../create/index.mjs';\nimport {\n  type InitializedObservable,\n  type Observable,\n  type UpdateToken,\n  type WithInitialValueOperator,\n  type WithInitialValueOperatorObservable,\n} from '../types/index.mjs';\n\n/**\n * Provides an initial value for an observable that doesn't have one.\n * The resulting observable will immediately emit the initial value upon subscription,\n * and then emit all subsequent values from the source.\n *\n * @template A - The type of values from the source\n * @template I - The type of the initial value (defaults to A)\n * @param initialValue - The initial value to emit\n * @returns An operator that sets the initial value\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  num$             1    2    3\n * //  withInitial$ 0   1    2    3\n * //               ^\n * //               initial value\n * //\n * //  Explanation:\n * //  - withInitialValue provides an initial value before the source emits\n * //  - Converts an uninitialized observable to an initialized one\n * //  - Useful when you need a default value immediately\n *\n * const num$ = source<number>();\n *\n * const initialized$ = num$.pipe(withInitialValue(0));\n *\n * const valueHistory: number[] = [];\n *\n * initialized$.subscribe((x) => {\n *   valueHistory.push(x);\n * });\n *\n * assert.deepStrictEqual(valueHistory, [0]);\n *\n * num$.next(1); // logs: 1\n *\n * assert.deepStrictEqual(valueHistory, [0, 1]);\n *\n * num$.next(2); // logs: 2\n *\n * assert.deepStrictEqual(valueHistory, [0, 1, 2]);\n * ```\n */\nexport const withInitialValue =\n  <A, I = A>(initialValue: I): WithInitialValueOperator<A, A | I> =>\n  (parentObservable) =>\n    new WithInitialValueObservableClass(parentObservable, initialValue);\n\nclass WithInitialValueObservableClass<A, I>\n  extends InitializedSyncChildObservableClass<A | I, readonly [A]>\n  implements WithInitialValueOperatorObservable<A, I>\n{\n  constructor(parentObservable: Observable<A>, initialValue: I) {\n    super({\n      parents: [parentObservable],\n      initialValue: Optional.some(initialValue),\n    });\n  }\n\n  override tryUpdate(updateToken: UpdateToken): void {\n    const par = this.parents[0];\n\n    const sn = par.getSnapshot();\n\n    if (par.updateToken !== updateToken || Optional.isNone(sn)) {\n      return; // skip update\n    }\n\n    this.setNext(sn.value, updateToken);\n  }\n}\n\nif (import.meta.vitest !== undefined) {\n  test('type test', () => {\n    expect(1).toBe(1); // dummy\n  });\n\n  {\n    const s = source<number>();\n\n    const _d: InitializedObservable<number> = s.pipe(withInitialValue(0));\n\n    expectType<typeof _d, InitializedObservable<number>>('=');\n  }\n}\n"],"names":[],"mappings":";;;;AAwDO,MAAM,gBAAA,GACX,CAAW,YAAA,KACX,CAAC,qBACC,IAAI,+BAAA,CAAgC,kBAAkB,YAAY;AAEtE,MAAM,wCACI,mCAAA,CAEV;AAAA,EACE,WAAA,CAAY,kBAAiC,YAAA,EAAiB;AAC5D,IAAA,KAAA,CAAM;AAAA,MACJ,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,MAC1B,YAAA,EAAc,QAAA,CAAS,IAAA,CAAK,YAAY;AAAA,KACzC,CAAA;AAAA,EAAA;AACH,EAES,UAAU,WAAA,EAAgC;AACjD,IAAA,MAAM,GAAA,GAAM,IAAA,CAAK,OAAA,CAAQ,CAAC,CAAA;AAE1B,IAAA,MAAM,EAAA,GAAK,IAAI,WAAA,EAAY;AAE3B,IAAA,IAAI,IAAI,WAAA,KAAgB,WAAA,IAAe,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAAG;AAC1D,MAAA;AAAA,IAAA;AAGF,IAAA,IAAA,CAAK,OAAA,CAAQ,EAAA,CAAG,KAAA,EAAO,WAAW,CAAA;AAAA,EAAA;AAEtC;;;;"}

package/dist/core/predefined/operators/attach-index.d.mts

@@ -54,5 +54,5 @@ export declare const withIndex: <A>() => KeepInitialValueOperator<A, readonly [S
  * Alias for `withIndex`.
  * @see withIndex
  */
-export declare const attachIndex: <A>() => KeepInitialValueOperator<A, readonly [SafeUint | -1, A]>;
+export declare const attachIndex: typeof withIndex;
 //# sourceMappingURL=attach-index.d.mts.map

package/dist/core/predefined/operators/attach-index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"attach-index.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/attach-index.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9C,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,OAAM,wBAAwB,CACvD,CAAC,EACD,SAAS,CAAC,QAAQ,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CACM,CAAC;AAEpC;;;GAGG;AACH,eAAO,MAAM,WAAW,GATE,CAAC,OAAM,wBAAwB,CACvD,CAAC,EACD,SAAS,CAAC,QAAQ,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAOO,CAAC"}
+{"version":3,"file":"attach-index.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/attach-index.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9C,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,OAAM,wBAAwB,CACvD,CAAC,EACD,SAAS,CAAC,QAAQ,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CACM,CAAC;AAEpC;;;GAGG;AACH,eAAO,MAAM,WAAW,kBAAY,CAAC"}

package/dist/core/predefined/operators/attach-index.mjs

@@ -2,60 +2,7 @@ import 'ts-data-forge';
 import '../../utils/id-maker.mjs';
 import { map } from '../../operators/map.mjs';
 
-/**
- * Attaches a sequential index to each emitted value, producing `[index, value]` tuples.
- * Index starts at 0 and increments with each emission.
- *
- * @template A - The type of values from the source
- * @returns An operator that emits `[index, value]` tuples
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  letter$    "A"      "B"      "C"
- * //  indexed$   [0,"A"]  [1,"B"]  [2,"C"]
- * //
- * //  Explanation:
- * //  - attachIndex attaches a sequential index to each emitted value
- * //  - Produces [index, value] tuples
- * //  - Index starts at 0 and increments with each emission
- *
- * const letter$ = source<string>();
- *
- * const indexed$ = letter$.pipe(attachIndex());
- *
- * const valueHistory: (readonly [number, string])[] = [];
- *
- * indexed$.subscribe(([i, letter]) => {
- *   valueHistory.push([i, letter]);
- * });
- *
- * letter$.next('A');
- *
- * assert.deepStrictEqual(valueHistory, [[0, 'A']]);
- *
- * letter$.next('B');
- *
- * assert.deepStrictEqual(valueHistory, [
- *   [0, 'A'],
- *   [1, 'B'],
- * ]);
- *
- * letter$.next('C');
- *
- * assert.deepStrictEqual(valueHistory, [
- *   [0, 'A'],
- *   [1, 'B'],
- *   [2, 'C'],
- * ]);
- * ```
- */
 const withIndex = () => map((a, i) => [i, a]);
-/**
- * Alias for `withIndex`.
- * @see withIndex
- */
 const attachIndex = withIndex;
 
 export { attachIndex, withIndex };

package/dist/core/predefined/operators/attach-index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"attach-index.mjs","sources":["../../../../src/core/predefined/operators/attach-index.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDG;MACU,SAAS,GAAG,MAGpB,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAU;AAElC;;;AAGG;AACI,MAAM,WAAW,GAAG;;;;"}
+{"version":3,"file":"attach-index.mjs","sources":["../../../../src/core/predefined/operators/attach-index.mts"],"sourcesContent":["import { type SafeUint } from 'ts-type-forge';\nimport { map } from '../../operators/index.mjs';\nimport { type KeepInitialValueOperator } from '../../types/index.mjs';\n\n/**\n * Attaches a sequential index to each emitted value, producing `[index, value]` tuples.\n * Index starts at 0 and increments with each emission.\n *\n * @template A - The type of values from the source\n * @returns An operator that emits `[index, value]` tuples\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  letter$    \"A\"      \"B\"      \"C\"\n * //  indexed$   [0,\"A\"]  [1,\"B\"]  [2,\"C\"]\n * //\n * //  Explanation:\n * //  - attachIndex attaches a sequential index to each emitted value\n * //  - Produces [index, value] tuples\n * //  - Index starts at 0 and increments with each emission\n *\n * const letter$ = source<string>();\n *\n * const indexed$ = letter$.pipe(attachIndex());\n *\n * const valueHistory: (readonly [number, string])[] = [];\n *\n * indexed$.subscribe(([i, letter]) => {\n *   valueHistory.push([i, letter]);\n * });\n *\n * letter$.next('A');\n *\n * assert.deepStrictEqual(valueHistory, [[0, 'A']]);\n *\n * letter$.next('B');\n *\n * assert.deepStrictEqual(valueHistory, [\n *   [0, 'A'],\n *   [1, 'B'],\n * ]);\n *\n * letter$.next('C');\n *\n * assert.deepStrictEqual(valueHistory, [\n *   [0, 'A'],\n *   [1, 'B'],\n *   [2, 'C'],\n * ]);\n * ```\n */\nexport const withIndex = <A,>(): KeepInitialValueOperator<\n  A,\n  readonly [SafeUint | -1, A]\n> => map((a, i) => [i, a] as const);\n\n/**\n * Alias for `withIndex`.\n * @see withIndex\n */\nexport const attachIndex = withIndex;\n"],"names":[],"mappings":";;;;AAqDO,MAAM,SAAA,GAAY,MAGpB,GAAA,CAAI,CAAC,GAAG,CAAA,KAAM,CAAC,CAAA,EAAG,CAAC,CAAU;AAM3B,MAAM,WAAA,GAAc;;;;"}

package/dist/core/predefined/operators/map-optional.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"map-optional.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/map-optional.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,KAAK,eAAe,EAAE,MAAM,eAAe,CAAC;AAE/D,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,eAAe,EAAE,CAAC,EACtD,OAAO,CAAC,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,KAClC,wBAAwB,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CACN,CAAC"}
+{"version":3,"file":"map-optional.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/map-optional.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,KAAK,eAAe,EAAE,MAAM,eAAe,CAAC;AAE/D,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,eAAe,EAAE,CAAC,SAC/C,CAAC,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,KAClC,wBAAwB,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAA6B,CAAC"}

package/dist/core/predefined/operators/map-optional.mjs

@@ -2,54 +2,7 @@ import { Optional } from 'ts-data-forge';
 import '../../utils/id-maker.mjs';
 import { map } from '../../operators/map.mjs';
 
-/**
- * Transforms the inner value of an `Optional` type emitted by the source.
- * If the value is `Some`, the mapping function is applied; if `None`, it remains `None`.
- *
- * @template O - The Optional type from the source
- * @template B - The type of the mapped inner value
- * @param mapFn - A function to transform the unwrapped value
- * @returns An operator that maps the inner value of Optional emissions
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  value$    Some(2)    None       Some(5)
- * //  doubled$  Some(4)    None       Some(10)
- * //
- * //  Explanation:
- * //  - mapOptional transforms the inner value of Optional emissions
- * //  - Some values are mapped; None values pass through unchanged
- *
- * const value$ = source<Optional<number>>();
- *
- * const doubled$ = value$.pipe(mapOptional((x) => x * 2));
- *
- * const valueHistory: Optional<number>[] = [];
- *
- * doubled$.subscribe((v) => {
- *   valueHistory.push(v);
- * });
- *
- * value$.next(Optional.some(2));
- *
- * assert.deepStrictEqual(valueHistory, [Optional.some(4)]);
- *
- * value$.next(Optional.none);
- *
- * assert.deepStrictEqual(valueHistory, [Optional.some(4), Optional.none]);
- *
- * value$.next(Optional.some(5));
- *
- * assert.deepStrictEqual(valueHistory, [
- *   Optional.some(4),
- *   Optional.none,
- *   Optional.some(10),
- * ]);
- * ```
- */
-const mapOptional = (mapFn) => map((a) => Optional.map(a, mapFn));
+const mapOptional = (mapFn) => map(Optional.map(mapFn));
 
 export { mapOptional };
 //# sourceMappingURL=map-optional.mjs.map

package/dist/core/predefined/operators/map-optional.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"map-optional.mjs","sources":["../../../../src/core/predefined/operators/map-optional.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8CG;AACI,MAAM,WAAW,GAAG,CACzB,KAAmC,KAEnC,GAAG,CAAC,CAAC,CAAC,KAAK,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC;;;;"}
+{"version":3,"file":"map-optional.mjs","sources":["../../../../src/core/predefined/operators/map-optional.mts"],"sourcesContent":["import { Optional, type UnknownOptional } from 'ts-data-forge';\nimport { map } from '../../operators/index.mjs';\nimport { type KeepInitialValueOperator } from '../../types/index.mjs';\n\n/**\n * Transforms the inner value of an `Optional` type emitted by the source.\n * If the value is `Some`, the mapping function is applied; if `None`, it remains `None`.\n *\n * @template O - The Optional type from the source\n * @template B - The type of the mapped inner value\n * @param mapFn - A function to transform the unwrapped value\n * @returns An operator that maps the inner value of Optional emissions\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  value$    Some(2)    None       Some(5)\n * //  doubled$  Some(4)    None       Some(10)\n * //\n * //  Explanation:\n * //  - mapOptional transforms the inner value of Optional emissions\n * //  - Some values are mapped; None values pass through unchanged\n *\n * const value$ = source<Optional<number>>();\n *\n * const doubled$ = value$.pipe(mapOptional((x) => x * 2));\n *\n * const valueHistory: Optional<number>[] = [];\n *\n * doubled$.subscribe((v) => {\n *   valueHistory.push(v);\n * });\n *\n * value$.next(Optional.some(2));\n *\n * assert.deepStrictEqual(valueHistory, [Optional.some(4)]);\n *\n * value$.next(Optional.none);\n *\n * assert.deepStrictEqual(valueHistory, [Optional.some(4), Optional.none]);\n *\n * value$.next(Optional.some(5));\n *\n * assert.deepStrictEqual(valueHistory, [\n *   Optional.some(4),\n *   Optional.none,\n *   Optional.some(10),\n * ]);\n * ```\n */\nexport const mapOptional = <O extends UnknownOptional, B>(\n  mapFn: (x: Optional.Unwrap<O>) => B,\n): KeepInitialValueOperator<O, Optional<B>> => map(Optional.map(mapFn));\n"],"names":[],"mappings":";;;;AAmDO,MAAM,cAAc,CACzB,KAAA,KAC6C,IAAI,QAAA,CAAS,GAAA,CAAI,KAAK,CAAC;;;;"}

package/dist/core/predefined/operators/map-result-err.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"map-result-err.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/map-result-err.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAE3D,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,aAAa,EAAE,EAAE,EACtD,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,EAAE,KACpC,wBAAwB,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CACxB,CAAC"}
+{"version":3,"file":"map-result-err.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/map-result-err.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAE3D,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,aAAa,EAAE,EAAE,SAC/C,CAAC,CAAC,EAAE,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,EAAE,KACpC,wBAAwB,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAClC,CAAC"}