synstate 0.1.2 → 1.0.1

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

@@ -1 +1 @@
-{"version":3,"file":"with-buffered-from.mjs","sources":["../../../src/core/operators/with-buffered-from.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDG;AACI,MAAM,gBAAgB,GAAG,CAC9B,UAAyB;AAEzB;AACA,CAAC,CAAC,gBAAgB,KAChB,IAAI,+BAA+B,CACjC,gBAAgB,EAChB,UAAU,CACX;AAEL;;;AAGG;AACI,MAAM,YAAY,GAAG;AAE5B,MAAM,+BACJ,SAAQ,wBAAkE,CAAA;IAG1E,mBAAmB,GAAiB,EAAE;IAEtC,WAAA,CAAY,gBAA+B,EAAE,UAAyB,EAAA;AACpE,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,KAAK,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,gBAAgB,EAAE,UAAU,CAAC,CAAC;YACnD,YAAY,EAAE,IAAI,CAAC;AACjB,gBAAA,GAAG,EAAE,gBAAgB,CAAC,WAAW,EAAE;AACnC,gBAAA,EAAE,EAAE,UAAU,CAAC,WAAW,EAAE;AAC7B,aAAA,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,KACjB,QAAQ,CAAC,MAAM,CAAC,GAAG;kBACf,QAAQ,CAAC;AACX,kBAAE,QAAQ,CAAC,IAAI,CAAC;AACZ,oBAAA,GAAG,CAAC,KAAK;AACT,oBAAA,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC;iBAC7B,CAAC,CAChB,CAAC,KAAK;AACR,SAAA,CAAC;AAEF,QAAA,UAAU,CAAC,SAAS,CAAC,CAAC,KAAK,KAAI;AAC7B,YAAA,IAAI,CAAC,mBAAmB,GAAG,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,mBAAmB,EAAE,KAAK,CAAC;AAC1E,QAAA,CAAC,CAAC;IACJ;AAES,IAAA,SAAS,CAAC,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;QACT;AAEA,QAAA,IAAI,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,mBAAmB,CAAC,EAAE,aAAa,CAAC;QAEjE,IAAI,CAAC,YAAY,EAAE;IACrB;IAEA,YAAY,GAAA;AACV,QAAA,IAAI,CAAC,mBAAmB,GAAG,EAAE;IAC/B;AACD;;;;"}
+{"version":3,"file":"with-buffered-from.mjs","sources":["../../../src/core/operators/with-buffered-from.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDG;AACI,MAAM,gBAAgB,GAAG,CAC9B,UAAyB;AAEzB;AACA,CAAC,CAAC,gBAAgB,KAChB,IAAI,+BAA+B,CACjC,gBAAgB,EAChB,UAAU,CACX;AAEL;;;AAGG;AACI,MAAM,YAAY,GAAG;AAE5B,MAAM,+BACJ,SAAQ,wBAAkE,CAAA;IAG1E,mBAAmB,GAAiB,EAAE;IAEtC,WAAA,CAAY,gBAA+B,EAAE,UAAyB,EAAA;AACpE,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,KAAK,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,gBAAgB,EAAE,UAAU,CAAC,CAAC;YACnD,YAAY,EAAE,IAAI,CAAC;AACjB,gBAAA,GAAG,EAAE,gBAAgB,CAAC,WAAW,EAAE;AACnC,gBAAA,EAAE,EAAE,UAAU,CAAC,WAAW,EAAE;AAC7B,aAAA,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,KACjB,QAAQ,CAAC,MAAM,CAAC,GAAG;kBACf,QAAQ,CAAC;AACX,kBAAE,QAAQ,CAAC,IAAI,CAAC;AACZ,oBAAA,GAAG,CAAC,KAAK;AACT,oBAAA,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC;iBAC7B,CAAC,CAChB,CAAC,KAAK;AACR,SAAA,CAAC;AAEF,QAAA,UAAU,CAAC,SAAS,CAAC,CAAC,KAAK,KAAI;AAC7B,YAAA,IAAI,CAAC,mBAAmB,GAAG,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,mBAAmB,EAAE,KAAK,CAAC;AAC1E,QAAA,CAAC,CAAC;IACJ;AAES,IAAA,SAAS,CAAC,WAAwB,EAAA;QACzC,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAE3B,QAAA,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE;AAE5B,QAAA,IAAI,GAAG,CAAC,WAAW,KAAK,WAAW,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE;AAC1D,YAAA,OAAO;QACT;AAEA,QAAA,IAAI,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,mBAAmB,CAAC,EAAE,WAAW,CAAC;QAE/D,IAAI,CAAC,YAAY,EAAE;IACrB;IAEA,YAAY,GAAA;AACV,QAAA,IAAI,CAAC,mBAAmB,GAAG,EAAE;IAC/B;AACD;;;;"}

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

@@ -13,14 +13,15 @@ import { type DropInitialValueOperator, type Observable } from '../types/index.m
  * //  Timeline:
  * //
  * //  name$     "Alice"           "Bob"               "Charlie"
- * //  age$                25              30      35              40
- * //  result$             ["Alice",25]  ["Bob",30]  ["Bob",35]  ["Charlie",40]
+ * //  age$                25              30
+ * //  result$   (skip)          ["Bob",25]           ["Charlie",30]
  * //
  * //  Explanation:
  * //  - withCurrentValueFrom samples the current value from another observable
- * //  - Emits a tuple [sourceValue, sampledValue] each time the source emits
+ * //  - Emits a tuple [sourceValue, sampledValue] each time the SOURCE emits
+ * //  - Does NOT emit when the sampled observable (age$) emits
  * //  - Does not emit until both observables have emitted at least once
- * //  - Similar to combine, but only emits when the source (not the sampled) emits
+ * //  - "Alice" is skipped because age$ hasn't emitted yet
  *
  * const name$ = source<string>();
  *
@@ -28,27 +29,27 @@ import { type DropInitialValueOperator, type Observable } from '../types/index.m
  *
  * const result$ = name$.pipe(withCurrentValueFrom(age$));
  *
- * const mut_history: (readonly [string, number])[] = [];
+ * const valueHistory: (readonly [string, number])[] = [];
  *
  * result$.subscribe(([name_, currentAge]) => {
- *   mut_history.push([name_, currentAge]);
+ *   valueHistory.push([name_, currentAge]);
  * });
  *
  * name$.next('Alice'); // nothing logged (age$ hasn't emitted)
  *
- * assert.deepStrictEqual(mut_history, []);
+ * assert.deepStrictEqual(valueHistory, []);
  *
  * age$.next(25);
  *
  * name$.next('Bob'); // logs: Bob is 25 years old
  *
- * assert.deepStrictEqual(mut_history, [['Bob', 25]]);
+ * assert.deepStrictEqual(valueHistory, [['Bob', 25]]);
  *
  * age$.next(30);
  *
  * name$.next('Charlie'); // logs: Charlie is 30 years old
  *
- * assert.deepStrictEqual(mut_history, [
+ * assert.deepStrictEqual(valueHistory, [
  *   ['Bob', 25],
  *   ['Charlie', 30],
  * ]);

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

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

@@ -17,14 +17,15 @@ import { maxDepth } from '../utils/max-depth.mjs';
  * //  Timeline:
  * //
  * //  name$     "Alice"           "Bob"               "Charlie"
- * //  age$                25              30      35              40
- * //  result$             ["Alice",25]  ["Bob",30]  ["Bob",35]  ["Charlie",40]
+ * //  age$                25              30
+ * //  result$   (skip)          ["Bob",25]           ["Charlie",30]
  * //
  * //  Explanation:
  * //  - withCurrentValueFrom samples the current value from another observable
- * //  - Emits a tuple [sourceValue, sampledValue] each time the source emits
+ * //  - Emits a tuple [sourceValue, sampledValue] each time the SOURCE emits
+ * //  - Does NOT emit when the sampled observable (age$) emits
  * //  - Does not emit until both observables have emitted at least once
- * //  - Similar to combine, but only emits when the source (not the sampled) emits
+ * //  - "Alice" is skipped because age$ hasn't emitted yet
  *
  * const name$ = source<string>();
  *
@@ -32,27 +33,27 @@ import { maxDepth } from '../utils/max-depth.mjs';
  *
  * const result$ = name$.pipe(withCurrentValueFrom(age$));
  *
- * const mut_history: (readonly [string, number])[] = [];
+ * const valueHistory: (readonly [string, number])[] = [];
  *
  * result$.subscribe(([name_, currentAge]) => {
- *   mut_history.push([name_, currentAge]);
+ *   valueHistory.push([name_, currentAge]);
  * });
  *
  * name$.next('Alice'); // nothing logged (age$ hasn't emitted)
  *
- * assert.deepStrictEqual(mut_history, []);
+ * assert.deepStrictEqual(valueHistory, []);
  *
  * age$.next(25);
  *
  * name$.next('Bob'); // logs: Bob is 25 years old
  *
- * assert.deepStrictEqual(mut_history, [['Bob', 25]]);
+ * assert.deepStrictEqual(valueHistory, [['Bob', 25]]);
  *
  * age$.next(30);
  *
  * name$.next('Charlie'); // logs: Charlie is 30 years old
  *
- * assert.deepStrictEqual(mut_history, [
+ * assert.deepStrictEqual(valueHistory, [
  *   ['Bob', 25],
  *   ['Charlie', 30],
  * ]);
@@ -79,16 +80,16 @@ class WithCurrentValueFromObservableClass extends SyncChildObservableClass {
         });
         this.#observable = observable;
     }
-    tryUpdate(updaterSymbol) {
+    tryUpdate(updateToken) {
         const par = this.parents[0];
         const ps = par.getSnapshot();
-        if (par.updaterSymbol !== updaterSymbol || Optional.isNone(ps)) {
+        if (par.updateToken !== updateToken || Optional.isNone(ps)) {
             return; // skip update
         }
         const curr = this.#observable.getSnapshot();
         if (Optional.isNone(curr))
             return; // skip update
-        this.setNext([ps.value, curr.value], updaterSymbol);
+        this.setNext([ps.value, curr.value], updateToken);
     }
 }
 

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDG;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,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;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,aAAa,CAAC;IACrD;AACD;;;;"}
+{"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;;;;"}

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,54 @@
+import { type SafeUint } from 'ts-type-forge';
 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":"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"}

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":";;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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 { Optional, type UnknownOptional } 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,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"}

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 { Result, type UnknownResult } 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,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"}

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