synstate 2.0.2 → 3.0.1

package/dist/core/operators/throttle.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"throttle.mjs","sources":["../../../src/core/operators/throttle.mts"],"sourcesContent":["import { Optional } from 'ts-data-forge';\nimport { SyncChildObservableClass } from '../class/index.mjs';\nimport {\n  type KeepInitialValueOperator,\n  type Observable,\n  type ThrottleOperatorObservable,\n  type TimerId,\n  type UpdateToken,\n} from '../types/index.mjs';\n\n/**\n * Emits the first value, then ignores subsequent values for a specified duration.\n * After the duration, the next emission is allowed through.\n *\n * @template A - The type of values from the source\n * @param milliSeconds - The throttle duration in milliseconds\n * @returns An operator that throttles emissions\n *\n * @example\n * ```ts\n * //  Timeline (250ms throttle):\n * //\n * //  Time(x50ms)  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0\n * //\n * //  input$       0       2   3                   9   10  11  12  13  14\n * //               |- 250ms -> |- 250ms ->         |- 250ms ->    |- 250ms ->\n * //  throttled$   0           3                   9          12           (emitted at start of window)\n * //\n * //  Explanation:\n * //  - throttle emits the FIRST value received, then ignores subsequent values\n * //    for the specified duration (250ms)\n * //  - Unlike audit (which emits the LAST value), throttle emits the FIRST\n * //  - Useful for rate-limiting scroll/resize events\n *\n * const input$ = source<number>();\n *\n * const throttled$ = input$.pipe(throttle(250));\n *\n * const valueHistory: number[] = [];\n *\n * throttled$.subscribe((value) => {\n *   valueHistory.push(value);\n * });\n *\n * const sleep = (ms: number): Promise<void> =>\n *   new Promise((resolve) => {\n *     setTimeout(resolve, ms);\n *   });\n *\n * input$.next(0);\n *\n * assert.deepStrictEqual(valueHistory, [0]);\n *\n * await sleep(200);\n *\n * input$.next(2);\n *\n * assert.deepStrictEqual(valueHistory, [0]);\n *\n * await sleep(100);\n *\n * input$.next(3);\n *\n * assert.deepStrictEqual(valueHistory, [0, 3]);\n *\n * await sleep(300);\n *\n * input$.next(9);\n *\n * assert.deepStrictEqual(valueHistory, [0, 3, 9]);\n *\n * await sleep(100);\n *\n * input$.next(10);\n *\n * await sleep(100);\n *\n * input$.next(11);\n *\n * assert.deepStrictEqual(valueHistory, [0, 3, 9]);\n *\n * await sleep(100);\n *\n * input$.next(12);\n *\n * assert.deepStrictEqual(valueHistory, [0, 3, 9, 12]);\n * ```\n */\nexport const throttle = <A,>(\n  milliSeconds: number,\n): KeepInitialValueOperator<A, A> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  ((parentObservable) =>\n    new ThrottleObservableClass(\n      parentObservable,\n      milliSeconds,\n    )) as KeepInitialValueOperator<A, A>;\n\nclass ThrottleObservableClass<A>\n  extends SyncChildObservableClass<A, readonly [A]>\n  implements ThrottleOperatorObservable<A>\n{\n  readonly #milliSeconds: number;\n  #mut_timerId: TimerId | undefined;\n  #mut_isSkipping: boolean;\n\n  constructor(parentObservable: Observable<A>, milliSeconds: number) {\n    super({\n      parents: [parentObservable],\n      initialValue: parentObservable.getSnapshot(),\n    });\n\n    this.#mut_timerId = undefined;\n\n    this.#mut_isSkipping = false;\n\n    this.#milliSeconds = milliSeconds;\n  }\n\n  #resetTimer(): void {\n    if (this.#mut_timerId !== undefined) {\n      clearTimeout(this.#mut_timerId);\n    }\n  }\n\n  override tryUpdate(updateToken: UpdateToken): void {\n    const par = this.parents[0];\n\n    const sn = par.getSnapshot();\n\n    if (\n      par.updateToken !== updateToken ||\n      Optional.isNone(sn) ||\n      this.#mut_isSkipping\n    ) {\n      return; // skip update\n    }\n\n    this.setNext(sn.value, updateToken);\n\n    this.#mut_isSkipping = true;\n\n    // set timer\n    this.#mut_timerId = setTimeout(() => {\n      this.#mut_isSkipping = false;\n    }, this.#milliSeconds);\n  }\n\n  override complete(): void {\n    this.#resetTimer();\n\n    super.complete();\n  }\n}\n"],"names":[],"mappings":";;;;AAwFO,MAAM,WAAW,CACtB,YAAA;AAAA;AAAA,GAGC,CAAC,qBACA,IAAI,uBAAA;AAAA,IACF,gBAAA;AAAA,IACA;AAAA,GACF;AAAA;AAEJ,MAAM,gCACI,wBAAA,CAEV;AAAA,EACW,aAAA;AAAA,EACT,YAAA;AAAA,EACA,eAAA;AAAA,EAEA,WAAA,CAAY,kBAAiC,YAAA,EAAsB;AACjE,IAAA,KAAA,CAAM;AAAA,MACJ,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,MAC1B,YAAA,EAAc,iBAAiB,WAAA;AAAY,KAC5C,CAAA;AAED,IAAA,IAAA,CAAK,YAAA,GAAe,MAAA;AAEpB,IAAA,IAAA,CAAK,eAAA,GAAkB,KAAA;AAEvB,IAAA,IAAA,CAAK,aAAA,GAAgB,YAAA;AAAA,EACvB;AAAA,EAEA,WAAA,GAAoB;AAClB,IAAA,IAAI,IAAA,CAAK,iBAAiB,MAAA,EAAW;AACnC,MAAA,YAAA,CAAa,KAAK,YAAY,CAAA;AAAA,IAChC;AAAA,EACF;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,IACE,GAAA,CAAI,gBAAgB,WAAA,IACpB,QAAA,CAAS,OAAO,EAAE,CAAA,IAClB,KAAK,eAAA,EACL;AACA,MAAA;AAAA,IACF;AAEA,IAAA,IAAA,CAAK,OAAA,CAAQ,EAAA,CAAG,KAAA,EAAO,WAAW,CAAA;AAElC,IAAA,IAAA,CAAK,eAAA,GAAkB,IAAA;AAGvB,IAAA,IAAA,CAAK,YAAA,GAAe,WAAW,MAAM;AACnC,MAAA,IAAA,CAAK,eAAA,GAAkB,KAAA;AAAA,IACzB,CAAA,EAAG,KAAK,aAAa,CAAA;AAAA,EACvB;AAAA,EAES,QAAA,GAAiB;AACxB,IAAA,IAAA,CAAK,WAAA,EAAY;AAEjB,IAAA,KAAA,CAAM,QAAA,EAAS;AAAA,EACjB;AACF;;;;"}
+{"version":3,"file":"throttle.mjs","sourceRoot":"","sources":["../../../src/core/operators/throttle.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAQ9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6EG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CACtB,YAAoB,EACY,EAAE;AAClC,oEAAoE;AACpE,CAAC,CAAC,gBAAgB,EAAE,EAAE,CACpB,wBAAwB,CACtB,gBAAgB,EAChB,YAAY,CACb,CAAmC,CAAC;AAEzC,MAAM,wBAAwB,GAAG,CAC/B,gBAA+B,EAC/B,YAAoB,EACW,EAAE;IACjC,IAAI,WAAW,GAAwB,SAAS,CAAC;IAEjD,IAAI,cAAc,GAAG,KAAK,CAAC;IAE3B,MAAM,UAAU,GAAG,GAAS,EAAE;QAC5B,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;YAC9B,YAAY,CAAC,WAAW,CAAC,CAAC;QAC5B,CAAC;IACH,CAAC,CAAC;IAEF,OAAO,yBAAyB,CAC9B;QACE,OAAO,EAAE,CAAC,gBAAgB,CAAC;QAC3B,YAAY,EAAE,gBAAgB,CAAC,WAAW,EAAE;QAC5C,UAAU,EAAE,UAAU;KACvB,EACD,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CACd,CAAC,WAAW,EAAE,EAAE;QACd,MAAM,EAAE,GAAG,gBAAgB,CAAC,WAAW,EAAE,CAAC;QAE1C,IACE,cAAc;YACd,gBAAgB,CAAC,WAAW,KAAK,WAAW;YAC5C,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EACnB,CAAC;YACD,OAAO,CAAC,cAAc;QACxB,CAAC;QAED,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;QAE/B,cAAc,GAAG,IAAI,CAAC;QAEtB,YAAY;QACZ,WAAW,GAAG,UAAU,CAAC,GAAG,EAAE;YAC5B,cAAc,GAAG,KAAK,CAAC;QACzB,CAAC,EAAE,YAAY,CAAC,CAAC;IACnB,CAAC,CACJ,CAAC;AACJ,CAAC,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"with-buffered-from.d.mts","sourceRoot":"","sources":["../../../src/core/operators/with-buffered-from.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,UAAU,EAGhB,MAAM,oBAAoB,CAAC;AAG5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,EAAE,CAAC,cACvB,UAAU,CAAC,CAAC,CAAC,KACxB,wBAAwB,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC,CAMQ,CAAC;AAElE;;;GAGG;AACH,eAAO,MAAM,YAAY,yBAAmB,CAAC"}
+{"version":3,"file":"with-buffered-from.d.mts","sourceRoot":"","sources":["../../../src/core/operators/with-buffered-from.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,UAAU,EAEhB,MAAM,oBAAoB,CAAC;AAG5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,EAAE,CAAC,cACvB,UAAU,CAAC,CAAC,CAAC,KACxB,wBAAwB,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC,CAMQ,CAAC;AAElE;;;GAGG;AACH,eAAO,MAAM,YAAY,yBAAmB,CAAC"}

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

@@ -1,49 +1,96 @@
-import { pipe, Optional, Arr } from 'ts-data-forge';
-import { SyncChildObservableClass } from '../class/child-observable-class.mjs';
-import '../utils/id-maker.mjs';
-import { maxDepth } from '../utils/max-depth.mjs';
-
-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
+import { Arr, Optional, pipe } from 'ts-data-forge';
+import { createSyncChildObservable } from '../base/index.mjs';
+import { maxDepth } from '../utils/index.mjs';
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const withBufferedFrom = (observable) => 
+
+((parentObservable) => createWithBufferedFromObservable(parentObservable, observable));
+
+
+
+
+export const withBuffered = withBufferedFrom;
+const createWithBufferedFromObservable = (parentObservable, observable) => {
+    let mut_bufferedValues = [];
+    const clearBuffer = () => {
+        mut_bufferedValues = [];
+    };
+    const result = createSyncChildObservable({
+        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,
+    }, ({ setNext }) => (updateToken) => {
+        const sn = parentObservable.getSnapshot();
+        if (parentObservable.updateToken !== updateToken ||
+            Optional.isNone(sn)) {
+            return;
+        }
+        setNext([sn.value, mut_bufferedValues], updateToken);
+        clearBuffer();
     });
     observable.subscribe((value) => {
-      this.#mut_bufferedValues = Arr.toPushed(this.#mut_bufferedValues, value);
+        mut_bufferedValues = Arr.toPushed(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 };
-//# sourceMappingURL=with-buffered-from.mjs.map
+    return result;
+};
+//# sourceMappingURL=with-buffered-from.mjs.map

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":["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;;;;"}
+{"version":3,"file":"with-buffered-from.mjs","sourceRoot":"","sources":["../../../src/core/operators/with-buffered-from.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAM9D,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAC9B,UAAyB,EACgC,EAAE;AAC3D,oEAAoE;AACpE,CAAC,CAAC,gBAAgB,EAAE,EAAE,CACpB,gCAAgC,CAC9B,gBAAgB,EAChB,UAAU,CACX,CAA4D,CAAC;AAElE;;;GAGG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,gBAAgB,CAAC;AAE7C,MAAM,gCAAgC,GAAG,CACvC,gBAA+B,EAC/B,UAAyB,EACiB,EAAE;IAC5C,IAAI,kBAAkB,GAAiB,EAAE,CAAC;IAE1C,MAAM,WAAW,GAAG,GAAS,EAAE;QAC7B,kBAAkB,GAAG,EAAE,CAAC;IAC1B,CAAC,CAAC;IAEF,MAAM,MAAM,GAAG,yBAAyB,CAItC;QACE,OAAO,EAAE,CAAC,gBAAgB,CAAC;QAC3B,KAAK,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,gBAAgB,EAAE,UAAU,CAAC,CAAC;QACnD,YAAY,EAAE,IAAI,CAAC;YACjB,GAAG,EAAE,gBAAgB,CAAC,WAAW,EAAE;YACnC,EAAE,EAAE,UAAU,CAAC,WAAW,EAAE;SAC7B,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,CACrB,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC;YAClB,CAAC,CAAC,QAAQ,CAAC,IAAI;YACf,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC;gBACZ,GAAG,CAAC,KAAK;gBACT,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC;aAC7B,CAAC,CAChB,CAAC,KAAK;KACR,EACD,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CACd,CAAC,WAAW,EAAE,EAAE;QACd,MAAM,EAAE,GAAG,gBAAgB,CAAC,WAAW,EAAE,CAAC;QAE1C,IACE,gBAAgB,CAAC,WAAW,KAAK,WAAW;YAC5C,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EACnB,CAAC;YACD,OAAO,CAAC,cAAc;QACxB,CAAC;QAED,OAAO,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,kBAAkB,CAAC,EAAE,WAAW,CAAC,CAAC;QAErD,WAAW,EAAE,CAAC;IAChB,CAAC,CACJ,CAAC;IAEF,UAAU,CAAC,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE;QAC7B,kBAAkB,GAAG,GAAG,CAAC,QAAQ,CAAC,kBAAkB,EAAE,KAAK,CAAC,CAAC;IAC/D,CAAC,CAAC,CAAC;IAEH,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC"}

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,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"}
+{"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,EAEhB,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,CAEsB,CAAC;AAEvE;;;GAGG;AACH,eAAO,MAAM,cAAc,6BAAuB,CAAC"}

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

@@ -1,36 +1,86 @@
-import { pipe, Optional } from 'ts-data-forge';
-import { SyncChildObservableClass } from '../class/child-observable-class.mjs';
-import '../utils/id-maker.mjs';
-import { maxDepth } from '../utils/max-depth.mjs';
-
-const withCurrentValueFrom = (observable) => (parentObservable) => new WithCurrentValueFromObservableClass(parentObservable, observable);
-const withLatestFrom = withCurrentValueFrom;
-class WithCurrentValueFromObservableClass extends SyncChildObservableClass {
-  #observable;
-  constructor(parentObservable, observable) {
-    super({
-      parents: [parentObservable],
-      depth: 1 + maxDepth([parentObservable, observable]),
-      initialValue: pipe({
+import { Optional, pipe } from 'ts-data-forge';
+import { createSyncChildObservable } from '../base/index.mjs';
+import { maxDepth } from '../utils/index.mjs';
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const withCurrentValueFrom = (observable) => (parentObservable) => createWithCurrentValueFromObservable(parentObservable, observable);
+
+
+
+
+export const withLatestFrom = withCurrentValueFrom;
+const createWithCurrentValueFromObservable = (parentObservable, observable) => createSyncChildObservable({
+    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;
+        me: observable.getSnapshot(),
+    }).map(({ me, par }) => Optional.isNone(par) || Optional.isNone(me)
+        ? Optional.none
+        : Optional.some([par.value, me.value])).value,
+}, ({ setNext }) => (updateToken) => {
+    const ps = parentObservable.getSnapshot();
+    if (parentObservable.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 };
-//# sourceMappingURL=with-current-value-from.mjs.map
+    const curr = observable.getSnapshot();
+    if (Optional.isNone(curr))
+        return;
+    setNext([ps.value, curr.value], updateToken);
+});
+//# sourceMappingURL=with-current-value-from.mjs.map

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":["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;;;;"}
+{"version":3,"file":"with-current-value-from.mjs","sourceRoot":"","sources":["../../../src/core/operators/with-current-value-from.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAM9D,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAC/B,CACE,UAAyB,EACqB,EAAE,CAClD,CAAC,gBAAgB,EAAE,EAAE,CACnB,oCAAoC,CAAC,gBAAgB,EAAE,UAAU,CAAC,CAAC;AAEvE;;;GAGG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,oBAAoB,CAAC;AAEnD,MAAM,oCAAoC,GAAG,CAC3C,gBAA+B,EAC/B,UAAyB,EACqB,EAAE,CAChD,yBAAyB,CACvB;IACE,OAAO,EAAE,CAAC,gBAAgB,CAAC;IAC3B,KAAK,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,gBAAgB,EAAE,UAAU,CAAC,CAAC;IACnD,YAAY,EAAE,IAAI,CAAC;QACjB,GAAG,EAAE,gBAAgB,CAAC,WAAW,EAAE;QACnC,EAAE,EAAE,UAAU,CAAC,WAAW,EAAE;KAC7B,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,CACrB,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;QACzC,CAAC,CAAC,QAAQ,CAAC,IAAI;QACf,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAU,CAAC,CAClD,CAAC,KAAK;CACR,EACD,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CACd,CAAC,WAAW,EAAE,EAAE;IACd,MAAM,EAAE,GAAG,gBAAgB,CAAC,WAAW,EAAE,CAAC;IAE1C,IACE,gBAAgB,CAAC,WAAW,KAAK,WAAW;QAC5C,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EACnB,CAAC;QACD,OAAO,CAAC,cAAc;IACxB,CAAC;IAED,MAAM,IAAI,GAAG,UAAU,CAAC,WAAW,EAAE,CAAC;IAEtC,IAAI,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC;QAAE,OAAO,CAAC,cAAc;IAEjD,OAAO,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC,CAAC;AAC/C,CAAC,CACJ,CAAC"}

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,gBAAgB,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,EAGL,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,CAEI,CAAC"}

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

@@ -1,24 +1,71 @@
 import { Optional } from 'ts-data-forge';
-import { InitializedSyncChildObservableClass } from '../class/child-observable-class.mjs';
-import '../utils/id-maker.mjs';
-
-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;
+import { createInitializedSyncChildObservable } from '../base/index.mjs';
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const withInitialValue = (initialValue) => (parentObservable) => createWithInitialValueObservable(parentObservable, initialValue);
+const createWithInitialValueObservable = (parentObservable, initialValue) => createInitializedSyncChildObservable({
+    parents: [parentObservable],
+    initialValue: Optional.some(initialValue),
+}, ({ setNext }) => (updateToken) => {
+    const sn = parentObservable.getSnapshot();
+    if (parentObservable.updateToken !== updateToken ||
+        Optional.isNone(sn)) {
+        return;
     }
-    this.setNext(sn.value, updateToken);
-  }
-}
+    setNext(sn.value, updateToken);
+});
+
+
+
+
+
+
+
+
+
 
-export { withInitialValue };
-//# sourceMappingURL=with-initial-value.mjs.map
+//# sourceMappingURL=with-initial-value.mjs.map

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":["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;;;;"}
+{"version":3,"file":"with-initial-value.mjs","sourceRoot":"","sources":["../../../src/core/operators/with-initial-value.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EAAE,oCAAoC,EAAE,MAAM,mBAAmB,CAAC;AACzE,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAQ7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAC3B,CAAW,YAAe,EAAsC,EAAE,CAClE,CAAC,gBAAgB,EAAE,EAAE,CACnB,gCAAgC,CAAC,gBAAgB,EAAE,YAAY,CAAC,CAAC;AAErE,MAAM,gCAAgC,GAAG,CACvC,gBAA+B,EAC/B,YAAe,EAC2B,EAAE,CAC5C,oCAAoC,CAClC;IACE,OAAO,EAAE,CAAC,gBAAgB,CAAC;IAC3B,YAAY,EAAE,QAAQ,CAAC,IAAI,CAAC,YAAY,CAAC;CAC1C,EACD,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CACd,CAAC,WAAW,EAAE,EAAE;IACd,MAAM,EAAE,GAAG,gBAAgB,CAAC,WAAW,EAAE,CAAC;IAE1C,IACE,gBAAgB,CAAC,WAAW,KAAK,WAAW;QAC5C,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EACnB,CAAC;QACD,OAAO,CAAC,cAAc;IACxB,CAAC;IAED,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;AACjC,CAAC,CACJ,CAAC;AAEJ,IAAI,OAAO,IAAI,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;IACrC,IAAI,CAAC,WAAW,EAAE,GAAG,EAAE;QACrB,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ;IAC7B,CAAC,CAAC,CAAC;IAEH,CAAC;QACC,MAAM,CAAC,GAAG,MAAM,EAAU,CAAC;QAE3B,MAAM,EAAE,GAAkC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC;QAEtE,UAAU,CAA2C,GAAG,CAAC,CAAC;IAC5D,CAAC;AACH,CAAC"}

package/dist/core/predefined/index.mjs

@@ -1,12 +1,2 @@
-export { attachIndex, withIndex } from './operators/attach-index.mjs';
-export { mapOptional } from './operators/map-optional.mjs';
-export { mapResultErr } from './operators/map-result-err.mjs';
-export { mapResultOk } from './operators/map-result-ok.mjs';
-export { mapTo } from './operators/map-to.mjs';
-export { getKey, pluck } from './operators/pluck.mjs';
-export { skip } from './operators/skip.mjs';
-export { take } from './operators/take.mjs';
-export { unwrapOptional } from './operators/unwrap-optional.mjs';
-export { unwrapResultErr } from './operators/unwrap-result-err.mjs';
-export { unwrapResultOk } from './operators/unwrap-result-ok.mjs';
-//# sourceMappingURL=index.mjs.map
+export * from './operators/index.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/core/predefined/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;"}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../../src/core/predefined/index.mts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC"}

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

@@ -1,9 +1,57 @@
-import 'ts-data-forge';
-import '../../utils/id-maker.mjs';
-import { map } from '../../operators/map.mjs';
+import { map } from '../../operators/index.mjs';
 
-const withIndex = () => map((a, i) => [i, a]);
-const attachIndex = withIndex;
 
-export { attachIndex, withIndex };
-//# sourceMappingURL=attach-index.mjs.map
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const withIndex = () => map((a, i) => [i, a]);
+
+
+
+
+export const attachIndex = withIndex;
+//# sourceMappingURL=attach-index.mjs.map

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":["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;;;;"}
+{"version":3,"file":"attach-index.mjs","sourceRoot":"","sources":["../../../../src/core/predefined/operators/attach-index.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAE,MAAM,2BAA2B,CAAC;AAGhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,GAGvB,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAU,CAAC,CAAC;AAEpC;;;GAGG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,SAAS,CAAC"}

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

@@ -1,12 +1,12 @@
-export { attachIndex, withIndex } from './attach-index.mjs';
-export { mapOptional } from './map-optional.mjs';
-export { mapResultErr } from './map-result-err.mjs';
-export { mapResultOk } from './map-result-ok.mjs';
-export { mapTo } from './map-to.mjs';
-export { getKey, pluck } from './pluck.mjs';
-export { skip } from './skip.mjs';
-export { take } from './take.mjs';
-export { unwrapOptional } from './unwrap-optional.mjs';
-export { unwrapResultErr } from './unwrap-result-err.mjs';
-export { unwrapResultOk } from './unwrap-result-ok.mjs';
-//# sourceMappingURL=index.mjs.map
+export * from './attach-index.mjs';
+export * from './map-optional.mjs';
+export * from './map-result-err.mjs';
+export * from './map-result-ok.mjs';
+export * from './map-to.mjs';
+export * from './pluck.mjs';
+export * from './skip.mjs';
+export * from './take.mjs';
+export * from './unwrap-optional.mjs';
+export * from './unwrap-result-err.mjs';
+export * from './unwrap-result-ok.mjs';
+//# sourceMappingURL=index.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;"}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../../../src/core/predefined/operators/index.mts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC"}