synstate 1.0.2 → 2.0.1

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

package/dist/core/predefined/operators/map-result-err.mjs

@@ -2,54 +2,7 @@ import { Result } from 'ts-data-forge';
 import '../../utils/id-maker.mjs';
 import { map } from '../../operators/map.mjs';
 
-/**
- * Transforms the error value (`Err`) of a `Result` type emitted by the source.
- * If the value is `Err`, the mapping function is applied; if `Ok`, it remains unchanged.
- *
- * @template R - The Result type from the source
- * @template E2 - The type of the mapped error value
- * @param mapFn - A function to transform the Err value
- * @returns An operator that maps the Err side of Result emissions
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  result$   Ok(1)    Err("bad")      Err("fail")
- * //  mapped$   Ok(1)    Err("BAD")      Err("FAIL")
- * //
- * //  Explanation:
- * //  - mapResultErr transforms the Err value of Result emissions
- * //  - Ok values pass through unchanged
- *
- * const result$ = source<Result<number, string>>();
- *
- * const mapped$ = result$.pipe(mapResultErr((e) => e.toUpperCase()));
- *
- * const valueHistory: Result<number, string>[] = [];
- *
- * mapped$.subscribe((v) => {
- *   valueHistory.push(v);
- * });
- *
- * result$.next(Result.ok(1));
- *
- * assert.deepStrictEqual(valueHistory, [Result.ok(1)]);
- *
- * result$.next(Result.err('bad'));
- *
- * assert.deepStrictEqual(valueHistory, [Result.ok(1), Result.err('BAD')]);
- *
- * result$.next(Result.err('fail'));
- *
- * assert.deepStrictEqual(valueHistory, [
- *   Result.ok(1),
- *   Result.err('BAD'),
- *   Result.err('FAIL'),
- * ]);
- * ```
- */
-const mapResultErr = (mapFn) => map((a) => Result.mapErr(a, mapFn));
+const mapResultErr = (mapFn) => map(Result.mapErr(mapFn));
 
 export { mapResultErr };
 //# sourceMappingURL=map-result-err.mjs.map

package/dist/core/predefined/operators/map-result-err.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"map-result-err.mjs","sources":["../../../../src/core/predefined/operators/map-result-err.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8CG;AACI,MAAM,YAAY,GAAG,CAC1B,KAAqC,KAErC,GAAG,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC;;;;"}
+{"version":3,"file":"map-result-err.mjs","sources":["../../../../src/core/predefined/operators/map-result-err.mts"],"sourcesContent":["import { Result, type UnknownResult } from 'ts-data-forge';\nimport { map } from '../../operators/index.mjs';\nimport { type KeepInitialValueOperator } from '../../types/index.mjs';\n\n/**\n * Transforms the error value (`Err`) of a `Result` type emitted by the source.\n * If the value is `Err`, the mapping function is applied; if `Ok`, it remains unchanged.\n *\n * @template R - The Result type from the source\n * @template E2 - The type of the mapped error value\n * @param mapFn - A function to transform the Err value\n * @returns An operator that maps the Err side of Result emissions\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  result$   Ok(1)    Err(\"bad\")      Err(\"fail\")\n * //  mapped$   Ok(1)    Err(\"BAD\")      Err(\"FAIL\")\n * //\n * //  Explanation:\n * //  - mapResultErr transforms the Err value of Result emissions\n * //  - Ok values pass through unchanged\n *\n * const result$ = source<Result<number, string>>();\n *\n * const mapped$ = result$.pipe(mapResultErr((e) => e.toUpperCase()));\n *\n * const valueHistory: Result<number, string>[] = [];\n *\n * mapped$.subscribe((v) => {\n *   valueHistory.push(v);\n * });\n *\n * result$.next(Result.ok(1));\n *\n * assert.deepStrictEqual(valueHistory, [Result.ok(1)]);\n *\n * result$.next(Result.err('bad'));\n *\n * assert.deepStrictEqual(valueHistory, [Result.ok(1), Result.err('BAD')]);\n *\n * result$.next(Result.err('fail'));\n *\n * assert.deepStrictEqual(valueHistory, [\n *   Result.ok(1),\n *   Result.err('BAD'),\n *   Result.err('FAIL'),\n * ]);\n * ```\n */\nexport const mapResultErr = <R extends UnknownResult, E2>(\n  mapFn: (x: Result.UnwrapErr<R>) => E2,\n): KeepInitialValueOperator<R, Result<Result.UnwrapOk<R>, E2>> =>\n  map(Result.mapErr(mapFn));\n"],"names":[],"mappings":";;;;AAmDO,MAAM,eAAe,CAC1B,KAAA,KAEA,IAAI,MAAA,CAAO,MAAA,CAAO,KAAK,CAAC;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"map-result-ok.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/map-result-ok.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,WAAW,GAAI,CAAC,SAAS,aAAa,EAAE,EAAE,EACrD,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,EAAE,KACnC,wBAAwB,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAC5B,CAAC"}
+{"version":3,"file":"map-result-ok.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/map-result-ok.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,WAAW,GAAI,CAAC,SAAS,aAAa,EAAE,EAAE,SAC9C,CAAC,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,EAAE,KACnC,wBAAwB,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CACtC,CAAC"}

package/dist/core/predefined/operators/map-result-ok.mjs

@@ -2,54 +2,7 @@ import { Result } from 'ts-data-forge';
 import '../../utils/id-maker.mjs';
 import { map } from '../../operators/map.mjs';
 
-/**
- * Transforms the success value (`Ok`) of a `Result` type emitted by the source.
- * If the value is `Ok`, the mapping function is applied; if `Err`, it remains unchanged.
- *
- * @template R - The Result type from the source
- * @template S2 - The type of the mapped success value
- * @param mapFn - A function to transform the Ok value
- * @returns An operator that maps the Ok side of Result emissions
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  result$   Ok(2)      Err("e")   Ok(5)
- * //  doubled$  Ok(4)      Err("e")   Ok(10)
- * //
- * //  Explanation:
- * //  - mapResultOk transforms the Ok value of Result emissions
- * //  - Err values pass through unchanged
- *
- * const result$ = source<Result<number, string>>();
- *
- * const doubled$ = result$.pipe(mapResultOk((x) => x * 2));
- *
- * const valueHistory: Result<number, string>[] = [];
- *
- * doubled$.subscribe((v) => {
- *   valueHistory.push(v);
- * });
- *
- * result$.next(Result.ok(2));
- *
- * assert.deepStrictEqual(valueHistory, [Result.ok(4)]);
- *
- * result$.next(Result.err('e'));
- *
- * assert.deepStrictEqual(valueHistory, [Result.ok(4), Result.err('e')]);
- *
- * result$.next(Result.ok(5));
- *
- * assert.deepStrictEqual(valueHistory, [
- *   Result.ok(4),
- *   Result.err('e'),
- *   Result.ok(10),
- * ]);
- * ```
- */
-const mapResultOk = (mapFn) => map((a) => Result.map(a, mapFn));
+const mapResultOk = (mapFn) => map(Result.map(mapFn));
 
 export { mapResultOk };
 //# sourceMappingURL=map-result-ok.mjs.map

package/dist/core/predefined/operators/map-result-ok.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"map-result-ok.mjs","sources":["../../../../src/core/predefined/operators/map-result-ok.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8CG;AACI,MAAM,WAAW,GAAG,CACzB,KAAoC,KAEpC,GAAG,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC;;;;"}
+{"version":3,"file":"map-result-ok.mjs","sources":["../../../../src/core/predefined/operators/map-result-ok.mts"],"sourcesContent":["import { Result, type UnknownResult } from 'ts-data-forge';\nimport { map } from '../../operators/index.mjs';\nimport { type KeepInitialValueOperator } from '../../types/index.mjs';\n\n/**\n * Transforms the success value (`Ok`) of a `Result` type emitted by the source.\n * If the value is `Ok`, the mapping function is applied; if `Err`, it remains unchanged.\n *\n * @template R - The Result type from the source\n * @template S2 - The type of the mapped success value\n * @param mapFn - A function to transform the Ok value\n * @returns An operator that maps the Ok side of Result emissions\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  result$   Ok(2)      Err(\"e\")   Ok(5)\n * //  doubled$  Ok(4)      Err(\"e\")   Ok(10)\n * //\n * //  Explanation:\n * //  - mapResultOk transforms the Ok value of Result emissions\n * //  - Err values pass through unchanged\n *\n * const result$ = source<Result<number, string>>();\n *\n * const doubled$ = result$.pipe(mapResultOk((x) => x * 2));\n *\n * const valueHistory: Result<number, string>[] = [];\n *\n * doubled$.subscribe((v) => {\n *   valueHistory.push(v);\n * });\n *\n * result$.next(Result.ok(2));\n *\n * assert.deepStrictEqual(valueHistory, [Result.ok(4)]);\n *\n * result$.next(Result.err('e'));\n *\n * assert.deepStrictEqual(valueHistory, [Result.ok(4), Result.err('e')]);\n *\n * result$.next(Result.ok(5));\n *\n * assert.deepStrictEqual(valueHistory, [\n *   Result.ok(4),\n *   Result.err('e'),\n *   Result.ok(10),\n * ]);\n * ```\n */\nexport const mapResultOk = <R extends UnknownResult, S2>(\n  mapFn: (x: Result.UnwrapOk<R>) => S2,\n): KeepInitialValueOperator<R, Result<S2, Result.UnwrapErr<R>>> =>\n  map(Result.map(mapFn));\n"],"names":[],"mappings":";;;;AAmDO,MAAM,cAAc,CACzB,KAAA,KAEA,IAAI,MAAA,CAAO,GAAA,CAAI,KAAK,CAAC;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"map-to.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/map-to.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,KAAG,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAClD,CAAC"}
+{"version":3,"file":"map-to.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/map-to.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,EAAE,CAAC,SAAS,CAAC,KAAG,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAClD,CAAC"}

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

@@ -2,46 +2,6 @@ import 'ts-data-forge';
 import '../../utils/id-maker.mjs';
 import { map } from '../../operators/map.mjs';
 
-/**
- * Maps all emitted values to a constant value, ignoring the source values.
- * Equivalent to `map(() => value)`.
- *
- * @template A - The type of values from the source
- * @template B - The type of the constant value
- * @param value - The constant value to emit
- * @returns An operator that always emits the given constant
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  click$    MouseEvent   MouseEvent   MouseEvent
- * //  count$    1            1            1
- * //
- * //  Explanation:
- * //  - mapTo maps all emitted values to a constant value
- * //  - Ignores the source values entirely
- * //  - Useful for converting events to signals
- *
- * const click$ = source<string>();
- *
- * const one$ = click$.pipe(mapTo(1));
- *
- * const valueHistory: number[] = [];
- *
- * one$.subscribe((value) => {
- *   valueHistory.push(value);
- * });
- *
- * click$.next('click1');
- *
- * click$.next('click2');
- *
- * click$.next('click3');
- *
- * assert.deepStrictEqual(valueHistory, [1, 1, 1]);
- * ```
- */
 const mapTo = (value) => map(() => value);
 
 export { mapTo };

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

@@ -1 +1 @@
-{"version":3,"file":"map-to.mjs","sources":["../../../../src/core/predefined/operators/map-to.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCG;AACI,MAAM,KAAK,GAAG,CAAO,KAAQ,KAClC,GAAG,CAAC,MAAM,KAAK;;;;"}
+{"version":3,"file":"map-to.mjs","sources":["../../../../src/core/predefined/operators/map-to.mts"],"sourcesContent":["import { map } from '../../operators/index.mjs';\nimport { type KeepInitialValueOperator } from '../../types/index.mjs';\n\n/**\n * Maps all emitted values to a constant value, ignoring the source values.\n * Equivalent to `map(() => value)`.\n *\n * @template A - The type of values from the source\n * @template B - The type of the constant value\n * @param value - The constant value to emit\n * @returns An operator that always emits the given constant\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  click$    MouseEvent   MouseEvent   MouseEvent\n * //  count$    1            1            1\n * //\n * //  Explanation:\n * //  - mapTo maps all emitted values to a constant value\n * //  - Ignores the source values entirely\n * //  - Useful for converting events to signals\n *\n * const click$ = source<string>();\n *\n * const one$ = click$.pipe(mapTo(1));\n *\n * const valueHistory: number[] = [];\n *\n * one$.subscribe((value) => {\n *   valueHistory.push(value);\n * });\n *\n * click$.next('click1');\n *\n * click$.next('click2');\n *\n * click$.next('click3');\n *\n * assert.deepStrictEqual(valueHistory, [1, 1, 1]);\n * ```\n */\nexport const mapTo = <A, B>(value: B): KeepInitialValueOperator<A, B> =>\n  map(() => value);\n"],"names":[],"mappings":";;;;AA2CO,MAAM,KAAA,GAAQ,CAAO,KAAA,KAC1B,GAAA,CAAI,MAAM,KAAK;;;;"}

package/dist/core/predefined/operators/pluck.d.mts

@@ -43,5 +43,5 @@ export declare const pluck: <A, K extends keyof A>(key: K) => KeepInitialValueOp
  * Alias for `pluck`.
  * @see pluck
  */
-export declare const getKey: <A, K extends keyof A>(key: K) => KeepInitialValueOperator<A, A[K]>;
+export declare const getKey: typeof pluck;
 //# sourceMappingURL=pluck.d.mts.map

package/dist/core/predefined/operators/pluck.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"pluck.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/pluck.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,EACxC,KAAK,CAAC,KACL,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAuB,CAAC;AAE3D;;;GAGG;AACH,eAAO,MAAM,MAAM,GARG,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,OACnC,CAAC,KACL,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAMR,CAAC"}
+{"version":3,"file":"pluck.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/pluck.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,OACnC,CAAC,KACL,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAuB,CAAC;AAE3D;;;GAGG;AACH,eAAO,MAAM,MAAM,cAAQ,CAAC"}

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

@@ -2,50 +2,7 @@ import 'ts-data-forge';
 import '../../utils/id-maker.mjs';
 import { map } from '../../operators/map.mjs';
 
-/**
- * Extracts a property value from each emitted object by key.
- * Equivalent to `map(value => value[key])`.
- *
- * @template A - The type of the emitted object
- * @template K - The key to extract
- * @param key - The property key to pluck
- * @returns An operator that emits the property value
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  user$   { name: "Alice", age: 25 }   { name: "Bob", age: 30 }
- * //  name$   "Alice"                       "Bob"
- * //
- * //  Explanation:
- * //  - getKey extracts a property value from each emitted object
- * //  - Equivalent to map(value => value[key])
- *
- * const user$ = source<Readonly<{ name: string; age: number }>>();
- *
- * const name$ = user$.pipe(getKey('name'));
- *
- * const valueHistory: string[] = [];
- *
- * name$.subscribe((n) => {
- *   valueHistory.push(n);
- * });
- *
- * user$.next({ name: 'Alice', age: 25 });
- *
- * assert.deepStrictEqual(valueHistory, ['Alice']);
- *
- * user$.next({ name: 'Bob', age: 30 });
- *
- * assert.deepStrictEqual(valueHistory, ['Alice', 'Bob']);
- * ```
- */
 const pluck = (key) => map((a) => a[key]);
-/**
- * Alias for `pluck`.
- * @see pluck
- */
 const getKey = pluck;
 
 export { getKey, pluck };

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

@@ -1 +1 @@
-{"version":3,"file":"pluck.mjs","sources":["../../../../src/core/predefined/operators/pluck.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCG;MACU,KAAK,GAAG,CACnB,GAAM,KACgC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC;AAEzD;;;AAGG;AACI,MAAM,MAAM,GAAG;;;;"}
+{"version":3,"file":"pluck.mjs","sources":["../../../../src/core/predefined/operators/pluck.mts"],"sourcesContent":["import { map } from '../../operators/index.mjs';\nimport { type KeepInitialValueOperator } from '../../types/index.mjs';\n\n/**\n * Extracts a property value from each emitted object by key.\n * Equivalent to `map(value => value[key])`.\n *\n * @template A - The type of the emitted object\n * @template K - The key to extract\n * @param key - The property key to pluck\n * @returns An operator that emits the property value\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  user$   { name: \"Alice\", age: 25 }   { name: \"Bob\", age: 30 }\n * //  name$   \"Alice\"                       \"Bob\"\n * //\n * //  Explanation:\n * //  - getKey extracts a property value from each emitted object\n * //  - Equivalent to map(value => value[key])\n *\n * const user$ = source<Readonly<{ name: string; age: number }>>();\n *\n * const name$ = user$.pipe(getKey('name'));\n *\n * const valueHistory: string[] = [];\n *\n * name$.subscribe((n) => {\n *   valueHistory.push(n);\n * });\n *\n * user$.next({ name: 'Alice', age: 25 });\n *\n * assert.deepStrictEqual(valueHistory, ['Alice']);\n *\n * user$.next({ name: 'Bob', age: 30 });\n *\n * assert.deepStrictEqual(valueHistory, ['Alice', 'Bob']);\n * ```\n */\nexport const pluck = <A, K extends keyof A>(\n  key: K,\n): KeepInitialValueOperator<A, A[K]> => map((a) => a[key]);\n\n/**\n * Alias for `pluck`.\n * @see pluck\n */\nexport const getKey = pluck;\n"],"names":[],"mappings":";;;;AA0CO,MAAM,KAAA,GAAQ,CACnB,GAAA,KACsC,GAAA,CAAI,CAAC,CAAA,KAAM,CAAA,CAAE,GAAG,CAAC;AAMlD,MAAM,MAAA,GAAS;;;;"}

package/dist/core/predefined/operators/skip.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"skip.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/skip.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,2BAA2B,EAAE,MAAM,eAAe,CAAC;AAEjE,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,EACpB,GAAG,2BAA2B,KAC7B,wBAAwB,CAAC,CAAC,EAAE,CAAC,CACyC,CAAC"}
+{"version":3,"file":"skip.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/skip.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,2BAA2B,EAAE,MAAM,eAAe,CAAC;AAEjE,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,KACjB,2BAA2B,KAC7B,wBAAwB,CAAC,CAAC,EAAE,CAAC,CACyC,CAAC"}

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

@@ -2,53 +2,6 @@ import { PositiveSafeInt } from 'ts-data-forge';
 import '../../utils/id-maker.mjs';
 import { skipWhile } from '../../operators/skip-while.mjs';
 
-/**
- * Skips the first `n` emissions from the source observable.
- * After `n` values are skipped, all subsequent values pass through.
- *
- * @template A - The type of values from the source
- * @param n - The number of values to skip
- * @returns An operator that skips the first n emissions
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  num$      1     2     3     4     5
- * //  skipped$              3     4     5
- * //            |skip 2|
- * //
- * //  Explanation:
- * //  - skip ignores the first n emissions from the source
- * //  - After n values are skipped, all subsequent values pass through
- *
- * const num$ = source<number>();
- *
- * const skipped$ = num$.pipe(skip(2));
- *
- * const valueHistory: number[] = [];
- *
- * skipped$.subscribe((x) => {
- *   valueHistory.push(x);
- * });
- *
- * num$.next(1); // skipped
- *
- * num$.next(2); // skipped
- *
- * assert.deepStrictEqual(valueHistory, []);
- *
- * num$.next(3); // logs: 3
- *
- * assert.deepStrictEqual(valueHistory, [3]);
- *
- * num$.next(4); // logs: 4
- *
- * num$.next(5); // logs: 5
- *
- * assert.deepStrictEqual(valueHistory, [3, 4, 5]);
- * ```
- */
 const skip = (n) => !PositiveSafeInt.is(n) ? idFn : skipWhile((_, index) => index + 1 <= n);
 const idFn = (value) => value;
 

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

@@ -1 +1 @@
-{"version":3,"file":"skip.mjs","sources":["../../../../src/core/predefined/operators/skip.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8CG;AACI,MAAM,IAAI,GAAG,CAClB,CAA8B,KAE9B,CAAC,eAAe,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,KAAK,KAAK,GAAG,CAAC,IAAI,CAAC;AAExE,MAAM,IAAI,GAAG,CAAK,KAAQ,KAAQ,KAAK;;;;"}
+{"version":3,"file":"skip.mjs","sources":["../../../../src/core/predefined/operators/skip.mts"],"sourcesContent":["import { PositiveSafeInt } from 'ts-data-forge';\nimport { type PositiveSafeIntWithSmallInt } from 'ts-type-forge';\nimport { skipWhile } from '../../operators/index.mjs';\nimport { type DropInitialValueOperator } from '../../types/index.mjs';\n\n/**\n * Skips the first `n` emissions from the source observable.\n * After `n` values are skipped, all subsequent values pass through.\n *\n * @template A - The type of values from the source\n * @param n - The number of values to skip\n * @returns An operator that skips the first n emissions\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  num$      1     2     3     4     5\n * //  skipped$              3     4     5\n * //            |skip 2|\n * //\n * //  Explanation:\n * //  - skip ignores the first n emissions from the source\n * //  - After n values are skipped, all subsequent values pass through\n *\n * const num$ = source<number>();\n *\n * const skipped$ = num$.pipe(skip(2));\n *\n * const valueHistory: number[] = [];\n *\n * skipped$.subscribe((x) => {\n *   valueHistory.push(x);\n * });\n *\n * num$.next(1); // skipped\n *\n * num$.next(2); // skipped\n *\n * assert.deepStrictEqual(valueHistory, []);\n *\n * num$.next(3); // logs: 3\n *\n * assert.deepStrictEqual(valueHistory, [3]);\n *\n * num$.next(4); // logs: 4\n *\n * num$.next(5); // logs: 5\n *\n * assert.deepStrictEqual(valueHistory, [3, 4, 5]);\n * ```\n */\nexport const skip = <A,>(\n  n: PositiveSafeIntWithSmallInt,\n): DropInitialValueOperator<A, A> =>\n  !PositiveSafeInt.is(n) ? idFn : skipWhile((_, index) => index + 1 <= n);\n\nconst idFn = <T,>(value: T): T => value;\n"],"names":[],"mappings":";;;;AAoDO,MAAM,IAAA,GAAO,CAClB,CAAA,KAEA,CAAC,gBAAgB,EAAA,CAAG,CAAC,CAAA,GAAI,IAAA,GAAO,UAAU,CAAC,CAAA,EAAG,KAAA,KAAU,KAAA,GAAQ,KAAK,CAAC;AAExE,MAAM,IAAA,GAAO,CAAK,KAAA,KAAgB,KAAA;;;;"}