synstate 0.1.2 → 1.0.0

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

@@ -27,21 +27,21 @@ import { type WithInitialValueOperator } from '../types/index.mjs';
  *
  * const initialized$ = num$.pipe(withInitialValue(0));
  *
- * const mut_history: number[] = [];
+ * const valueHistory: number[] = [];
  *
  * initialized$.subscribe((x) => {
- *   mut_history.push(x);
+ *   valueHistory.push(x);
  * });
  *
- * assert.deepStrictEqual(mut_history, [0]);
+ * assert.deepStrictEqual(valueHistory, [0]);
  *
  * num$.next(1); // logs: 1
  *
- * assert.deepStrictEqual(mut_history, [0, 1]);
+ * assert.deepStrictEqual(valueHistory, [0, 1]);
  *
  * num$.next(2); // logs: 2
  *
- * assert.deepStrictEqual(mut_history, [0, 1, 2]);
+ * assert.deepStrictEqual(valueHistory, [0, 1, 2]);
  * ```
  */
 export declare const withInitialValue: <A, I = A>(initialValue: I) => WithInitialValueOperator<A, A | I>;

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

@@ -30,21 +30,21 @@ import '../utils/id-maker.mjs';
  *
  * const initialized$ = num$.pipe(withInitialValue(0));
  *
- * const mut_history: number[] = [];
+ * const valueHistory: number[] = [];
  *
  * initialized$.subscribe((x) => {
- *   mut_history.push(x);
+ *   valueHistory.push(x);
  * });
  *
- * assert.deepStrictEqual(mut_history, [0]);
+ * assert.deepStrictEqual(valueHistory, [0]);
  *
  * num$.next(1); // logs: 1
  *
- * assert.deepStrictEqual(mut_history, [0, 1]);
+ * assert.deepStrictEqual(valueHistory, [0, 1]);
  *
  * num$.next(2); // logs: 2
  *
- * assert.deepStrictEqual(mut_history, [0, 1, 2]);
+ * assert.deepStrictEqual(valueHistory, [0, 1, 2]);
  * ```
  */
 const withInitialValue = (initialValue) => (parentObservable) => new WithInitialValueObservableClass(parentObservable, initialValue);
@@ -55,13 +55,13 @@ class WithInitialValueObservableClass extends InitializedSyncChildObservableClas
             initialValue: Optional.some(initialValue),
         });
     }
-    tryUpdate(updaterSymbol) {
+    tryUpdate(updateToken) {
         const par = this.parents[0];
         const sn = par.getSnapshot();
-        if (par.updaterSymbol !== updaterSymbol || Optional.isNone(sn)) {
+        if (par.updateToken !== updateToken || Optional.isNone(sn)) {
             return; // skip update
         }
-        this.setNext(sn.value, updaterSymbol);
+        this.setNext(sn.value, updateToken);
     }
 }
 

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,aAA4B,EAAA;QAC7C,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAE3B,QAAA,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE;AAE5B,QAAA,IAAI,GAAG,CAAC,aAAa,KAAK,aAAa,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE;AAC9D,YAAA,OAAO;;QAGT,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,CAAC;;AAExC;;;;"}
+{"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;;;;"}

package/dist/core/predefined/index.mjs

@@ -3,7 +3,6 @@ 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 { map } from './operators/map.mjs';
 export { getKey, pluck } from './operators/pluck.mjs';
 export { skip } from './operators/skip.mjs';
 export { take } from './operators/take.mjs';

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

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

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

@@ -1,4 +1,53 @@
 import { type KeepInitialValueOperator } from '../../types/index.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'],
+ * ]);
+ * ```
+ */
 export declare const withIndex: <A>() => KeepInitialValueOperator<A, readonly [SafeUint | -1, A]>;
 /**
  * Alias for `withIndex`.

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":"AACA,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE,eAAO,MAAM,SAAS,GAAI,CAAC,OAAM,wBAAwB,CACvD,CAAC,EACD,SAAS,CAAC,QAAQ,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CACe,CAAC;AAE7C;;;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":"AACA,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"}

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

@@ -1,8 +1,57 @@
 import 'ts-data-forge';
 import '../../utils/id-maker.mjs';
-import { mapWithIndex } from '../../operators/map-with-index.mjs';
+import { map } from '../../operators/map.mjs';
 
-const withIndex = () => mapWithIndex((a, i) => [i, a]);
+/**
+ * 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

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":";;;;MAGa,SAAS,GAAG,MAGpB,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAU;AAE3C;;;AAGG;AACI,MAAM,WAAW,GAAG;;;;"}
+{"version":3,"file":"attach-index.mjs","sources":["../../../../src/core/predefined/operators/attach-index.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDG;MACU,SAAS,GAAG,MAGpB,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAU;AAElC;;;AAGG;AACI,MAAM,WAAW,GAAG;;;;"}

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

@@ -3,7 +3,6 @@ export * from './map-optional.mjs';
 export * from './map-result-err.mjs';
 export * from './map-result-ok.mjs';
 export * from './map-to.mjs';
-export * from './map.mjs';
 export * from './pluck.mjs';
 export * from './skip.mjs';
 export * from './take.mjs';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","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,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.mts","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"}

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

@@ -3,7 +3,6 @@ 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 { map } from './map.mjs';
 export { getKey, pluck } from './pluck.mjs';
 export { skip } from './skip.mjs';
 export { take } from './take.mjs';

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

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

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

@@ -1,4 +1,51 @@
 import { Optional } from 'ts-data-forge';
 import { type KeepInitialValueOperator } from '../../types/index.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),
+ * ]);
+ * ```
+ */
 export declare const mapOptional: <O extends UnknownOptional, B>(mapFn: (x: Optional.Unwrap<O>) => B) => KeepInitialValueOperator<O, Optional<B>>;
 //# sourceMappingURL=map-optional.d.mts.map

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,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAGtE,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,MAAM,eAAe,CAAC;AAEzC,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"}

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

@@ -1,6 +1,54 @@
 import { Optional } from 'ts-data-forge';
-import { map } from './map.mjs';
+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));
 
 export { mapOptional };

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":";;;AAIO,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":[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;;;;"}

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

@@ -1,4 +1,51 @@
 import { Result } from 'ts-data-forge';
 import { type KeepInitialValueOperator } from '../../types/index.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'),
+ * ]);
+ * ```
+ */
 export declare const mapResultErr: <R extends UnknownResult, E2>(mapFn: (x: Result.UnwrapErr<R>) => E2) => KeepInitialValueOperator<R, Result<Result.UnwrapOk<R>, E2>>;
 //# sourceMappingURL=map-result-err.d.mts.map

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,MAAM,eAAe,CAAC;AACvC,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAGtE,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,MAAM,eAAe,CAAC;AAEvC,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"}

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

@@ -1,6 +1,54 @@
 import { Result } from 'ts-data-forge';
-import { map } from './map.mjs';
+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));
 
 export { mapResultErr };

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":";;;AAIO,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":[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;;;;"}

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

@@ -1,4 +1,51 @@
 import { Result } from 'ts-data-forge';
 import { type KeepInitialValueOperator } from '../../types/index.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),
+ * ]);
+ * ```
+ */
 export declare const mapResultOk: <R extends UnknownResult, S2>(mapFn: (x: Result.UnwrapOk<R>) => S2) => KeepInitialValueOperator<R, Result<S2, Result.UnwrapErr<R>>>;
 //# sourceMappingURL=map-result-ok.d.mts.map

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,MAAM,eAAe,CAAC;AACvC,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAGtE,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,MAAM,eAAe,CAAC;AAEvC,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"}

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

@@ -1,6 +1,54 @@
 import { Result } from 'ts-data-forge';
-import { map } from './map.mjs';
+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));
 
 export { mapResultOk };

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":";;;AAIO,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":[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;;;;"}

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

@@ -1,3 +1,43 @@
 import { type KeepInitialValueOperator } from '../../types/index.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]);
+ * ```
+ */
 export declare const mapTo: <A, B>(value: B) => KeepInitialValueOperator<A, B>;
 //# sourceMappingURL=map-to.d.mts.map

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":"AAAA,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAGtE,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,EAAE,OAAO,CAAC,KAAG,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAClD,CAAC"}