synstate 0.1.0 → 0.1.2

package/dist/core/operators/debounce-time.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"debounce-time.d.mts","sourceRoot":"","sources":["../../../src/core/operators/debounce-time.mts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,wBAAwB,EAG9B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,EAC5B,cAAc,MAAM,KACnB,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAMQ,CAAC"}
+{"version":3,"file":"debounce-time.d.mts","sourceRoot":"","sources":["../../../src/core/operators/debounce-time.mts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,wBAAwB,EAG9B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,EAC5B,cAAc,MAAM,KACnB,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAMQ,CAAC"}

package/dist/core/operators/debounce-time.mjs

@@ -12,12 +12,27 @@ import '../utils/id-maker.mjs';
  *
  * @example
  * ```ts
+ * //  Timeline (300ms debounce):
+ * //
+ * //  Time(ms)  0     100    200    300    400    500    600   ...   900   1000
+ * //  input$    'h'   'he'   'hel'  'hello'
+ * //  debounced$                                         'hello' (emitted after 300ms silence)
+ * //
+ * //  Explanation:
+ * //  - At 0ms: 'h' is emitted, timer starts
+ * //  - At 100ms: 'he' is emitted, timer resets
+ * //  - At 200ms: 'hel' is emitted, timer resets
+ * //  - At 300ms: 'hello' is emitted, timer resets
+ * //  - At 600ms: No new emission for 300ms, 'hello' is finally emitted
+ *
  * const input$ = source<string>();
  *
  * const debounced$ = input$.pipe(debounceTime(300));
  *
+ * const mut_history: string[] = [];
+ *
  * debounced$.subscribe((value) => {
- *   console.log(value);
+ *   mut_history.push(value);
  * });
  *
  * input$.next('h');
@@ -27,7 +42,12 @@ import '../utils/id-maker.mjs';
  * input$.next('hel');
  *
  * input$.next('hello');
- * // After 300ms of silence, logs: hello
+ *
+ * await new Promise((resolve) => {
+ *   setTimeout(resolve, 400);
+ * });
+ *
+ * assert.deepStrictEqual(mut_history, ['hello']);
  * ```
  */
 const debounceTime = (milliSeconds) => 

package/dist/core/operators/debounce-time.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"debounce-time.mjs","sources":["../../../src/core/operators/debounce-time.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;AACI,MAAM,YAAY,GAAG,CAC1B,YAAoB;AAEpB;AACA,CAAC,CAAC,gBAAgB,KAChB,IAAI,2BAA2B,CAC7B,gBAAgB,EAChB,YAAY,CACb;AAEL,MAAM,2BACJ,SAAQ,yBAA0C,CAAA;AAGzC,IAAA,aAAa;AACtB,IAAA,YAAY;IAEZ,WAAA,CAAY,gBAA+B,EAAE,YAAoB,EAAA;AAC/D,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;AAC3B,YAAA,YAAY,EAAE,gBAAgB,CAAC,WAAW,EAAE;AAC7C,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,YAAY,GAAG,SAAS;AAE7B,QAAA,IAAI,CAAC,aAAa,GAAG,YAAY;IACnC;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,IAAI,CAAC,WAAW,EAAE;;AAGlB,QAAA,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,MAAK;AAClC,YAAA,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;gBAAE;AAEzB,YAAA,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC,KAAK,CAAC;AAC5B,QAAA,CAAC,EAAE,IAAI,CAAC,aAAa,CAAC;IACxB;IAEA,WAAW,GAAA;AACT,QAAA,IAAI,IAAI,CAAC,YAAY,KAAK,SAAS,EAAE;AACnC,YAAA,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC;QACjC;IACF;IAES,QAAQ,GAAA;QACf,IAAI,CAAC,WAAW,EAAE;QAElB,KAAK,CAAC,QAAQ,EAAE;IAClB;AACD;;;;"}
+{"version":3,"file":"debounce-time.mjs","sources":["../../../src/core/operators/debounce-time.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CG;AACI,MAAM,YAAY,GAAG,CAC1B,YAAoB;AAEpB;AACA,CAAC,CAAC,gBAAgB,KAChB,IAAI,2BAA2B,CAC7B,gBAAgB,EAChB,YAAY,CACb;AAEL,MAAM,2BACJ,SAAQ,yBAA0C,CAAA;AAGzC,IAAA,aAAa;AACtB,IAAA,YAAY;IAEZ,WAAA,CAAY,gBAA+B,EAAE,YAAoB,EAAA;AAC/D,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;AAC3B,YAAA,YAAY,EAAE,gBAAgB,CAAC,WAAW,EAAE;AAC7C,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,YAAY,GAAG,SAAS;AAE7B,QAAA,IAAI,CAAC,aAAa,GAAG,YAAY;IACnC;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,IAAI,CAAC,WAAW,EAAE;;AAGlB,QAAA,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,MAAK;AAClC,YAAA,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;gBAAE;AAEzB,YAAA,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC,KAAK,CAAC;AAC5B,QAAA,CAAC,EAAE,IAAI,CAAC,aAAa,CAAC;IACxB;IAEA,WAAW,GAAA;AACT,QAAA,IAAI,IAAI,CAAC,YAAY,KAAK,SAAS,EAAE;AACnC,YAAA,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC;QACjC;IACF;IAES,QAAQ,GAAA;QACf,IAAI,CAAC,WAAW,EAAE;QAElB,KAAK,CAAC,QAAQ,EAAE;IAClB;AACD;;;;"}

package/dist/core/operators/filter.d.mts

@@ -10,17 +10,42 @@ import { type DropInitialValueOperator } from '../types/index.mjs';
  *
  * @example
  * ```ts
+ * //  Timeline:
+ * //
+ * //  num$          1     2     3     4     5     6
+ * //  even$               2           4           6
+ * //
+ * //  Explanation:
+ * //  - filter passes through only values that satisfy the predicate
+ * //  - Only even numbers (2, 4, 6) are emitted
+ *
  * const num$ = source<number>();
  *
  * const even$ = num$.pipe(filter((x) => x % 2 === 0));
  *
+ * const mut_history: number[] = [];
+ *
  * even$.subscribe((x) => {
- *   console.log(x);
+ *   mut_history.push(x);
  * });
  *
  * num$.next(1); // nothing logged
  *
  * num$.next(2); // logs: 2
+ *
+ * assert.deepStrictEqual(mut_history, [2]);
+ *
+ * num$.next(3); // nothing logged
+ *
+ * num$.next(4); // logs: 4
+ *
+ * assert.deepStrictEqual(mut_history, [2, 4]);
+ *
+ * num$.next(5);
+ *
+ * num$.next(6);
+ *
+ * assert.deepStrictEqual(mut_history, [2, 4, 6]);
  * ```
  */
 export declare function filter<A, B extends A>(predicate: (value: A, index: SafeUint | -1) => value is B): DropInitialValueOperator<A, B>;

package/dist/core/operators/filter.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"filter.d.mts","sourceRoot":"","sources":["../../../src/core/operators/filter.mts"],"names":[],"mappings":"AASA,OAAO,EACL,KAAK,wBAAwB,EAK9B,MAAM,oBAAoB,CAAC;AAG5B;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC,EACnC,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,GAAG,CAAC,CAAC,KAAK,KAAK,IAAI,CAAC,GACxD,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAElC,wBAAgB,MAAM,CAAC,CAAC,EACtB,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,GAAG,CAAC,CAAC,KAAK,OAAO,GACrD,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}
+{"version":3,"file":"filter.d.mts","sourceRoot":"","sources":["../../../src/core/operators/filter.mts"],"names":[],"mappings":"AASA,OAAO,EACL,KAAK,wBAAwB,EAK9B,MAAM,oBAAoB,CAAC;AAG5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC,EACnC,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,GAAG,CAAC,CAAC,KAAK,KAAK,IAAI,CAAC,GACxD,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAElC,wBAAgB,MAAM,CAAC,CAAC,EACtB,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,GAAG,CAAC,CAAC,KAAK,OAAO,GACrD,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"filter.mjs","sources":["../../../src/core/operators/filter.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAkDM,SAAU,MAAM,CACpB,SAAsD,EAAA;AAEtD,IAAA,OAAO,CAAC,gBAAgB,KACtB,IAAI,qBAAqB,CAAC,gBAAgB,EAAE,SAAS,CAAC;AAC1D;AAEA,MAAM,qBACJ,SAAQ,wBAAyC,CAAA;AAGxC,IAAA,UAAU;AACnB,IAAA,UAAU;IAEV,WAAA,CACE,gBAA+B,EAC/B,SAAkD,EAAA;AAElD,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,YAAY,EAAE,IAAI,CAAC,gBAAgB,CAAC,WAAW,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,KACxD,QAAQ,CAAC,MAAM,CAAC,EAAE;kBACd,QAAQ,CAAC;kBACT,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE;AACtB,sBAAE;AACF,sBAAE,QAAQ,CAAC,IAAI,CACpB,CAAC,KAAK;AACR,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,UAAU,GAAG,EAAE;AAEpB,QAAA,IAAI,CAAC,UAAU,GAAG,SAAS;;AAGpB,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;;AAGT,QAAA,IAAI,CAAC,UAAU;YACb,IAAI,CAAC,UAAU,KAAK,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,UAAU,CAAC;AAE3E,QAAA,IAAI,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,EAAE;YAC9C,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,CAAC;;;AAG1C;;;;"}
+{"version":3,"file":"filter.mjs","sources":["../../../src/core/operators/filter.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AA2EM,SAAU,MAAM,CACpB,SAAsD,EAAA;AAEtD,IAAA,OAAO,CAAC,gBAAgB,KACtB,IAAI,qBAAqB,CAAC,gBAAgB,EAAE,SAAS,CAAC;AAC1D;AAEA,MAAM,qBACJ,SAAQ,wBAAyC,CAAA;AAGxC,IAAA,UAAU;AACnB,IAAA,UAAU;IAEV,WAAA,CACE,gBAA+B,EAC/B,SAAkD,EAAA;AAElD,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,YAAY,EAAE,IAAI,CAAC,gBAAgB,CAAC,WAAW,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,KACxD,QAAQ,CAAC,MAAM,CAAC,EAAE;kBACd,QAAQ,CAAC;kBACT,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE;AACtB,sBAAE;AACF,sBAAE,QAAQ,CAAC,IAAI,CACpB,CAAC,KAAK;AACR,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,UAAU,GAAG,EAAE;AAEpB,QAAA,IAAI,CAAC,UAAU,GAAG,SAAS;;AAGpB,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;;AAGT,QAAA,IAAI,CAAC,UAAU;YACb,IAAI,CAAC,UAAU,KAAK,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,UAAU,CAAC;AAE3E,QAAA,IAAI,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,EAAE;YAC9C,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,CAAC;;;AAG1C;;;;"}

package/dist/core/operators/index.mjs

@@ -1,16 +1,16 @@
 export { auditTime } from './audit-time.mjs';
 export { debounceTime } from './debounce-time.mjs';
 export { filter } from './filter.mjs';
-export { attachIndex, getKey, map, mapOptional, mapResultErr, mapResultOk, mapTo, mapWithIndex, pluck, unwrapOptional, unwrapResultErr, unwrapResultOk, withIndex } from './map-with-index.mjs';
+export { mapWithIndex } from './map-with-index.mjs';
 export { flatMap, mergeMap } from './merge-map.mjs';
 export { pairwise } from './pairwise.mjs';
 export { scan } from './scan.mjs';
 export { distinctUntilChanged, skipIfNoChange } from './skip-if-no-change.mjs';
 export { skipUntil } from './skip-until.mjs';
-export { skip, skipWhile } from './skip-while.mjs';
+export { skipWhile } from './skip-while.mjs';
 export { switchMap } from './switch-map.mjs';
 export { takeUntil } from './take-until.mjs';
-export { take, takeWhile } from './take-while.mjs';
+export { takeWhile } from './take-while.mjs';
 export { throttleTime } from './throttle-time.mjs';
 export { withBuffered, withBufferedFrom } from './with-buffered-from.mjs';
 export { withCurrentValueFrom, withLatestFrom } from './with-current-value-from.mjs';

package/dist/core/operators/map-with-index.d.mts

@@ -1,4 +1,3 @@
-import { Optional, Result } from 'ts-data-forge';
 import { type KeepInitialValueOperator } from '../types/index.mjs';
 /**
  * Transforms each value emitted by the source using a mapping function that also receives the emission index.
@@ -10,30 +9,33 @@ import { type KeepInitialValueOperator } from '../types/index.mjs';
  *
  * @example
  * ```ts
- * const num$ = source<number>();
+ * //  Timeline:
+ * //
+ * //  num$      "a"      "b"      "c"
+ * //  indexed$  "0: a"   "1: b"   "2: c"
+ * //
+ * //  Explanation:
+ * //  - mapWithIndex transforms each value along with its index
+ * //  - Index starts at 0 and increments with each emission
+ *
+ * const num$ = source<string>();
  *
  * const indexed$ = num$.pipe(mapWithIndex((x, i) => `${i}: ${x}`));
  *
+ * const mut_history: string[] = [];
+ *
  * indexed$.subscribe((s) => {
- *   console.log(s);
+ *   mut_history.push(s);
  * });
  *
- * num$.next(10); // logs: 0: 10
+ * num$.next('a'); // 0: a
+ *
+ * num$.next('b'); // 1: b
+ *
+ * num$.next('c'); // 2: c
  *
- * num$.next(20); // logs: 1: 20
+ * assert.deepStrictEqual(mut_history, ['0: a', '1: b', '2: c']);
  * ```
  */
 export declare const mapWithIndex: <A, B>(mapFn: (x: A, index: SafeUint | -1) => B) => KeepInitialValueOperator<A, B>;
-export declare const map: <A, B>(mapFn: (x: A) => B) => KeepInitialValueOperator<A, B>;
-export declare const mapTo: <A, B>(value: B) => KeepInitialValueOperator<A, B>;
-export declare const pluck: <A, K extends keyof A>(key: K) => KeepInitialValueOperator<A, A[K]>;
-export declare const getKey: <A, K extends keyof A>(key: K) => KeepInitialValueOperator<A, A[K]>;
-export declare const attachIndex: <A>() => KeepInitialValueOperator<A, readonly [SafeUint | -1, A]>;
-export declare const withIndex: <A>() => KeepInitialValueOperator<A, readonly [SafeUint | -1, A]>;
-export declare const unwrapOptional: <O extends UnknownOptional>() => KeepInitialValueOperator<O, Optional.Unwrap<O> | undefined>;
-export declare const unwrapResultOk: <R extends UnknownResult>() => KeepInitialValueOperator<R, Result.UnwrapOk<R> | undefined>;
-export declare const unwrapResultErr: <R extends UnknownResult>() => KeepInitialValueOperator<R, Result.UnwrapErr<R> | undefined>;
-export declare const mapOptional: <O extends UnknownOptional, B>(mapFn: (x: Optional.Unwrap<O>) => B) => KeepInitialValueOperator<O, Optional<B>>;
-export declare const mapResultOk: <R extends UnknownResult, S2>(mapFn: (x: Result.UnwrapOk<R>) => S2) => KeepInitialValueOperator<R, Result<S2, Result.UnwrapErr<R>>>;
-export declare const mapResultErr: <R extends UnknownResult, E2>(mapFn: (x: Result.UnwrapErr<R>) => E2) => KeepInitialValueOperator<R, Result<Result.UnwrapOk<R>, E2>>;
 //# sourceMappingURL=map-with-index.d.mts.map

package/dist/core/operators/map-with-index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"map-with-index.d.mts","sourceRoot":"","sources":["../../../src/core/operators/map-with-index.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,MAAM,EAIP,MAAM,eAAe,CAAC;AAGvB,OAAO,EAEL,KAAK,wBAAwB,EAI9B,MAAM,oBAAoB,CAAC;AAG5B;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,EAAE,CAAC,EAC/B,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,KACvC,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAMQ,CAAC;AAIzC,eAAO,MAAM,GAAG,GAAI,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,KAAG,wBAAwB,CAAC,CAAC,EAAE,CAAC,CACvD,CAAC;AAEtB,eAAO,MAAM,KAAK,GAAI,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,KAAG,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAClD,CAAC;AAEnB,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,eAAO,MAAM,MAAM,GAJG,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,OACnC,CAAC,KACL,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAER,CAAC;AAE5B,eAAO,MAAM,WAAW,GAAI,CAAC,OAAM,wBAAwB,CACzD,CAAC,EACD,SAAS,CAAC,QAAQ,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CACe,CAAC;AAE7C,eAAO,MAAM,SAAS,GALM,CAAC,OAAM,wBAAwB,CACzD,CAAC,EACD,SAAS,CAAC,QAAQ,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAGO,CAAC;AAErC,eAAO,MAAM,cAAc,GACzB,CAAC,SAAS,eAAe,OACtB,wBAAwB,CAAC,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,SAAS,CAEA,CAAC;AAEhE,eAAO,MAAM,cAAc,GACzB,CAAC,SAAS,aAAa,OACpB,wBAAwB,CAAC,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,SAAS,CAEA,CAAC;AAEhE,eAAO,MAAM,eAAe,GAC1B,CAAC,SAAS,aAAa,OACpB,wBAAwB,CAAC,CAAC,EAAE,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,CACC,CAAC;AAElE,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;AAErC,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;AAEnC,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-with-index.d.mts","sourceRoot":"","sources":["../../../src/core/operators/map-with-index.mts"],"names":[],"mappings":"AAGA,OAAO,EAEL,KAAK,wBAAwB,EAI9B,MAAM,oBAAoB,CAAC;AAG5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,EAAE,CAAC,EAC/B,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,KACvC,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAMQ,CAAC"}

package/dist/core/operators/map-with-index.mjs

@@ -1,4 +1,4 @@
-import { Optional, asSafeUint, SafeUint, Result } from 'ts-data-forge';
+import { Optional, asSafeUint, SafeUint } from 'ts-data-forge';
 import { SyncChildObservableClass } from '../class/child-observable-class.mjs';
 import '../utils/id-maker.mjs';
 
@@ -12,39 +12,37 @@ import '../utils/id-maker.mjs';
  *
  * @example
  * ```ts
- * const num$ = source<number>();
+ * //  Timeline:
+ * //
+ * //  num$      "a"      "b"      "c"
+ * //  indexed$  "0: a"   "1: b"   "2: c"
+ * //
+ * //  Explanation:
+ * //  - mapWithIndex transforms each value along with its index
+ * //  - Index starts at 0 and increments with each emission
+ *
+ * const num$ = source<string>();
  *
  * const indexed$ = num$.pipe(mapWithIndex((x, i) => `${i}: ${x}`));
  *
+ * const mut_history: string[] = [];
+ *
  * indexed$.subscribe((s) => {
- *   console.log(s);
+ *   mut_history.push(s);
  * });
  *
- * num$.next(10); // logs: 0: 10
+ * num$.next('a'); // 0: a
+ *
+ * num$.next('b'); // 1: b
  *
- * num$.next(20); // logs: 1: 20
+ * num$.next('c'); // 2: c
+ *
+ * assert.deepStrictEqual(mut_history, ['0: a', '1: b', '2: c']);
  * ```
  */
 const mapWithIndex = (mapFn) => 
 // eslint-disable-next-line total-functions/no-unsafe-type-assertion
 ((parentObservable) => new MapWithIndexObservableClass(parentObservable, mapFn));
-/* Specialized operators */
-const map = (mapFn) => mapWithIndex(mapFn);
-const mapTo = (value) => map(() => value);
-const pluck = (key) => map((a) => a[key]);
-const getKey = pluck; // alias
-const attachIndex = () => mapWithIndex((a, i) => [i, a]);
-const withIndex = attachIndex; // alias
-const unwrapOptional = () => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-map(Optional.unwrap);
-const unwrapResultOk = () => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-map(Result.unwrapOk);
-const unwrapResultErr = () => map(Result.unwrapErr);
-const mapOptional = (mapFn) => map((a) => Optional.map(a, mapFn));
-const mapResultOk = (mapFn) => map((a) => Result.map(a, mapFn));
-const mapResultErr = (mapFn) => map((a) => Result.mapErr(a, mapFn));
 /* implementation */
 class MapWithIndexObservableClass extends SyncChildObservableClass {
     #mapFn;
@@ -69,5 +67,5 @@ class MapWithIndexObservableClass extends SyncChildObservableClass {
     }
 }
 
-export { attachIndex, getKey, map, mapOptional, mapResultErr, mapResultOk, mapTo, mapWithIndex, pluck, unwrapOptional, unwrapResultErr, unwrapResultOk, withIndex };
+export { mapWithIndex };
 //# sourceMappingURL=map-with-index.mjs.map

package/dist/core/operators/map-with-index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"map-with-index.mjs","sources":["../../../src/core/operators/map-with-index.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAkBA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACI,MAAM,YAAY,GAAG,CAC1B,KAAwC;AAExC;AACA,CAAC,CAAC,gBAAgB,KAChB,IAAI,2BAA2B,CAC7B,gBAAgB,EAChB,KAAK,CACN;AAEL;AAEO,MAAM,GAAG,GAAG,CAAO,KAAkB,KAC1C,YAAY,CAAC,KAAK;AAEb,MAAM,KAAK,GAAG,CAAO,KAAQ,KAClC,GAAG,CAAC,MAAM,KAAK;AAEV,MAAM,KAAK,GAAG,CACnB,GAAM,KACgC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC;AAElD,MAAM,MAAM,GAAG,MAAM;MAEf,WAAW,GAAG,MAGtB,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAU;AAEpC,MAAM,SAAS,GAAG,YAAY;AAE9B,MAAM,cAAc,GAAG;AAG5B;AACA,GAAG,CAAC,QAAQ,CAAC,MAA+C;AAEvD,MAAM,cAAc,GAAG;AAG5B;AACA,GAAG,CAAC,MAAM,CAAC,QAAiD;AAEvD,MAAM,eAAe,GAAG,MAG7B,GAAG,CAAC,MAAM,CAAC,SAAmD;MAEnD,WAAW,GAAG,CACzB,KAAmC,KAEnC,GAAG,CAAC,CAAC,CAAC,KAAK,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC;MAEtB,WAAW,GAAG,CACzB,KAAoC,KAEpC,GAAG,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC;MAEpB,YAAY,GAAG,CAC1B,KAAqC,KAErC,GAAG,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC;AAEpC;AAEA,MAAM,2BACJ,SAAQ,wBAAyC,CAAA;AAGxC,IAAA,MAAM;AACf,IAAA,UAAU;IAEV,WAAA,CACE,gBAA+B,EAC/B,KAAwC,EAAA;AAExC,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,YAAY,EAAE,QAAQ,CAAC,GAAG,CAAC,gBAAgB,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC,KAC3D,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CACb;AACF,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,UAAU,GAAG,EAAE;AAEpB,QAAA,IAAI,CAAC,MAAM,GAAG,KAAK;;AAGZ,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;;AAGT,QAAA,IAAI,CAAC,UAAU;YACb,IAAI,CAAC,UAAU,KAAK,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,UAAU,CAAC;AAE3E,QAAA,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,EAAE,aAAa,CAAC;;AAEtE;;;;"}
+{"version":3,"file":"map-with-index.mjs","sources":["../../../src/core/operators/map-with-index.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCG;AACI,MAAM,YAAY,GAAG,CAC1B,KAAwC;AAExC;AACA,CAAC,CAAC,gBAAgB,KAChB,IAAI,2BAA2B,CAC7B,gBAAgB,EAChB,KAAK,CACN;AAEL;AAEA,MAAM,2BACJ,SAAQ,wBAAyC,CAAA;AAGxC,IAAA,MAAM;AACf,IAAA,UAAU;IAEV,WAAA,CACE,gBAA+B,EAC/B,KAAwC,EAAA;AAExC,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,YAAY,EAAE,QAAQ,CAAC,GAAG,CAAC,gBAAgB,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC,KAC3D,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CACb;AACF,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,UAAU,GAAG,EAAE;AAEpB,QAAA,IAAI,CAAC,MAAM,GAAG,KAAK;;AAGZ,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;;AAGT,QAAA,IAAI,CAAC,UAAU;YACb,IAAI,CAAC,UAAU,KAAK,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,UAAU,CAAC;AAE3E,QAAA,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,EAAE,aAAa,CAAC;;AAEtE;;;;"}

package/dist/core/operators/merge-map.d.mts

@@ -10,16 +10,58 @@ import { type DropInitialValueOperator, type Observable } from '../types/index.m
  *
  * @example
  * ```ts
+ * //  Timeline:
+ * //
+ * //  ids$          1               2               3
+ * //  requests      fetch(1)        fetch(2)        fetch(3)
+ * //  users$        result1         result2         result3
+ * //                (parallel)      (parallel)      (parallel)
+ * //
+ * //  Explanation:
+ * //  - mergeMap runs all inner observables in parallel
+ * //  - Results are emitted as they arrive (may be out of order)
+ * //  - Does NOT cancel previous requests
+ * //  - All requests run concurrently and all results are emitted
+ *
  * const ids$ = source<number>();
  *
- * const users$ = ids$.pipe(mergeMap((id) => fromPromise(fetchUser(id))));
+ * const users$ = ids$.pipe(
+ *   mergeMap((id) => {
+ *     const result$ = source<{ id: number }>();
+ *
+ *     setTimeout(() => {
+ *       result$.next({ id });
+ *
+ *       result$.complete();
+ *     }, 10);
+ *
+ *     return result$;
+ *   }),
+ * );
  *
- * users$.subscribe((user) => {
- *   console.log(user);
+ * const mut_history: { id: number }[] = [];
+ *
+ * users$.subscribe((value) => {
+ *   mut_history.push(value);
  * });
- * // All requests run in parallel, results merged as they arrive
  *
- * const fetchUser = async (id: number): Promise<unknown> => ({ id });
+ * ids$.next(1);
+ *
+ * ids$.next(2);
+ *
+ * ids$.next(3);
+ *
+ * await new Promise((resolve) => {
+ *   setTimeout(resolve, 200);
+ * });
+ *
+ * assert.deepStrictEqual(mut_history.length, 3);
+ *
+ * assert.isTrue(mut_history.some((u) => u.id === 1));
+ *
+ * assert.isTrue(mut_history.some((u) => u.id === 2));
+ *
+ * assert.isTrue(mut_history.some((u) => u.id === 3));
  * ```
  *
  * @note To improve code readability, consider using `createState` instead of `mergeMap`,
@@ -27,7 +69,7 @@ import { type DropInitialValueOperator, type Observable } from '../types/index.m
  */
 export declare const mergeMap: <A, B>(mapToObservable: (curr: A) => Observable<B>) => DropInitialValueOperator<A, B>;
 /**
- * Alias for `mergeMap()`.
+ * Alias for `mergeMap`.
  * @see mergeMap
  */
 export declare const flatMap: <A, B>(mapToObservable: (curr: A) => Observable<B>) => DropInitialValueOperator<A, B>;

package/dist/core/operators/merge-map.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"merge-map.d.mts","sourceRoot":"","sources":["../../../src/core/operators/merge-map.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAE7B,KAAK,UAAU,EAGhB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,QAAQ,GAClB,CAAC,EAAE,CAAC,EACH,iBAAiB,CAAC,IAAI,EAAE,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,KAC1C,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAEgC,CAAC;AAEnE;;;GAGG;AACH,eAAO,MAAM,OAAO,GAVjB,CAAC,EAAE,CAAC,mBACc,CAAC,IAAI,EAAE,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,KAC1C,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAQH,CAAC"}
+{"version":3,"file":"merge-map.d.mts","sourceRoot":"","sources":["../../../src/core/operators/merge-map.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAE7B,KAAK,UAAU,EAGhB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AACH,eAAO,MAAM,QAAQ,GAClB,CAAC,EAAE,CAAC,EACH,iBAAiB,CAAC,IAAI,EAAE,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,KAC1C,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAEgC,CAAC;AAEnE;;;GAGG;AACH,eAAO,MAAM,OAAO,GAVjB,CAAC,EAAE,CAAC,mBACc,CAAC,IAAI,EAAE,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,KAC1C,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAQH,CAAC"}

package/dist/core/operators/merge-map.mjs

@@ -13,16 +13,58 @@ import '../utils/id-maker.mjs';
  *
  * @example
  * ```ts
+ * //  Timeline:
+ * //
+ * //  ids$          1               2               3
+ * //  requests      fetch(1)        fetch(2)        fetch(3)
+ * //  users$        result1         result2         result3
+ * //                (parallel)      (parallel)      (parallel)
+ * //
+ * //  Explanation:
+ * //  - mergeMap runs all inner observables in parallel
+ * //  - Results are emitted as they arrive (may be out of order)
+ * //  - Does NOT cancel previous requests
+ * //  - All requests run concurrently and all results are emitted
+ *
  * const ids$ = source<number>();
  *
- * const users$ = ids$.pipe(mergeMap((id) => fromPromise(fetchUser(id))));
+ * const users$ = ids$.pipe(
+ *   mergeMap((id) => {
+ *     const result$ = source<{ id: number }>();
+ *
+ *     setTimeout(() => {
+ *       result$.next({ id });
+ *
+ *       result$.complete();
+ *     }, 10);
+ *
+ *     return result$;
+ *   }),
+ * );
  *
- * users$.subscribe((user) => {
- *   console.log(user);
+ * const mut_history: { id: number }[] = [];
+ *
+ * users$.subscribe((value) => {
+ *   mut_history.push(value);
  * });
- * // All requests run in parallel, results merged as they arrive
  *
- * const fetchUser = async (id: number): Promise<unknown> => ({ id });
+ * ids$.next(1);
+ *
+ * ids$.next(2);
+ *
+ * ids$.next(3);
+ *
+ * await new Promise((resolve) => {
+ *   setTimeout(resolve, 200);
+ * });
+ *
+ * assert.deepStrictEqual(mut_history.length, 3);
+ *
+ * assert.isTrue(mut_history.some((u) => u.id === 1));
+ *
+ * assert.isTrue(mut_history.some((u) => u.id === 2));
+ *
+ * assert.isTrue(mut_history.some((u) => u.id === 3));
  * ```
  *
  * @note To improve code readability, consider using `createState` instead of `mergeMap`,
@@ -30,7 +72,7 @@ import '../utils/id-maker.mjs';
  */
 const mergeMap = (mapToObservable) => (parentObservable) => new MergeMapObservableClass(parentObservable, mapToObservable);
 /**
- * Alias for `mergeMap()`.
+ * Alias for `mergeMap`.
  * @see mergeMap
  */
 const flatMap = mergeMap;

package/dist/core/operators/merge-map.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"merge-map.mjs","sources":["../../../src/core/operators/merge-map.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;MACU,QAAQ,GACnB,CACE,eAA2C,KAE7C,CAAC,gBAAgB,KACf,IAAI,uBAAuB,CAAC,gBAAgB,EAAE,eAAe;AAEjE;;;AAGG;AACI,MAAM,OAAO,GAAG;AAEvB,MAAM,uBACJ,SAAQ,yBAA0C,CAAA;AAGzC,IAAA,gBAAgB;AACzB,IAAA,gBAAgB;AAChB,IAAA,kBAAkB;IAElB,WAAA,CACE,gBAA+B,EAC/B,eAA2C,EAAA;AAE3C,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,YAAY,EAAE,QAAQ,CAAC,IAAI;AAC5B,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,gBAAgB,GAAG,eAAe;AAEvC,QAAA,IAAI,CAAC,gBAAgB,GAAG,EAAE;AAE1B,QAAA,IAAI,CAAC,kBAAkB,GAAG,EAAE;IAC9B;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,UAAU,GAAG,IAAI,CAAC,gBAAgB,CAAC,EAAE,CAAC,KAAK,CAAC;AAElD,QAAA,IAAI,CAAC,gBAAgB,GAAG,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,gBAAgB,EAAE,UAAU,CAAC;QAEvE,MAAM,YAAY,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,IAAI,KAAI;AACjD,YAAA,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;AACxB,QAAA,CAAC,CAAC;AAEF,QAAA,IAAI,CAAC,kBAAkB,GAAG,GAAG,CAAC,QAAQ,CACpC,IAAI,CAAC,kBAAkB,EACvB,YAAY,CACb;IACH;IAES,QAAQ,GAAA;AACf,QAAA,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,kBAAkB,EAAE;YACvC,CAAC,CAAC,WAAW,EAAE;QACjB;AAEA,QAAA,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,gBAAgB,EAAE;YACrC,CAAC,CAAC,QAAQ,EAAE;QACd;QAEA,KAAK,CAAC,QAAQ,EAAE;IAClB;AACD;;;;"}
+{"version":3,"file":"merge-map.mjs","sources":["../../../src/core/operators/merge-map.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmEG;MACU,QAAQ,GACnB,CACE,eAA2C,KAE7C,CAAC,gBAAgB,KACf,IAAI,uBAAuB,CAAC,gBAAgB,EAAE,eAAe;AAEjE;;;AAGG;AACI,MAAM,OAAO,GAAG;AAEvB,MAAM,uBACJ,SAAQ,yBAA0C,CAAA;AAGzC,IAAA,gBAAgB;AACzB,IAAA,gBAAgB;AAChB,IAAA,kBAAkB;IAElB,WAAA,CACE,gBAA+B,EAC/B,eAA2C,EAAA;AAE3C,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,YAAY,EAAE,QAAQ,CAAC,IAAI;AAC5B,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,gBAAgB,GAAG,eAAe;AAEvC,QAAA,IAAI,CAAC,gBAAgB,GAAG,EAAE;AAE1B,QAAA,IAAI,CAAC,kBAAkB,GAAG,EAAE;IAC9B;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,UAAU,GAAG,IAAI,CAAC,gBAAgB,CAAC,EAAE,CAAC,KAAK,CAAC;AAElD,QAAA,IAAI,CAAC,gBAAgB,GAAG,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,gBAAgB,EAAE,UAAU,CAAC;QAEvE,MAAM,YAAY,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,IAAI,KAAI;AACjD,YAAA,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;AACxB,QAAA,CAAC,CAAC;AAEF,QAAA,IAAI,CAAC,kBAAkB,GAAG,GAAG,CAAC,QAAQ,CACpC,IAAI,CAAC,kBAAkB,EACvB,YAAY,CACb;IACH;IAES,QAAQ,GAAA;AACf,QAAA,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,kBAAkB,EAAE;YACvC,CAAC,CAAC,WAAW,EAAE;QACjB;AAEA,QAAA,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,gBAAgB,EAAE;YACrC,CAAC,CAAC,QAAQ,EAAE;QACd;QAEA,KAAK,CAAC,QAAQ,EAAE;IAClB;AACD;;;;"}

package/dist/core/operators/pairwise.d.mts

@@ -8,19 +8,48 @@ import { type DropInitialValueOperator } from '../types/index.mjs';
  *
  * @example
  * ```ts
+ * //  Timeline:
+ * //
+ * //  num$      1     2     3     4
+ * //  pairs$          [1,2] [2,3] [3,4]
+ * //
+ * //  Explanation:
+ * //  - pairwise emits the current and previous values as a tuple
+ * //  - Nothing is emitted for the first value (no previous value yet)
+ * //  - Useful for tracking changes between consecutive values
+ *
  * const num$ = source<number>();
  *
  * const pairs$ = num$.pipe(pairwise());
  *
+ * const mut_history: (readonly [number, number])[] = [];
+ *
  * pairs$.subscribe(([prev, curr]) => {
- *   console.log(prev, curr);
+ *   mut_history.push([prev, curr]);
  * });
  *
  * num$.next(1); // nothing logged
  *
+ * assert.deepStrictEqual(mut_history, []);
+ *
  * num$.next(2); // logs: 1, 2
  *
+ * assert.deepStrictEqual(mut_history, [[1, 2]]);
+ *
  * num$.next(3); // logs: 2, 3
+ *
+ * assert.deepStrictEqual(mut_history, [
+ *   [1, 2],
+ *   [2, 3],
+ * ]);
+ *
+ * num$.next(4); // logs: 3, 4
+ *
+ * assert.deepStrictEqual(mut_history, [
+ *   [1, 2],
+ *   [2, 3],
+ *   [3, 4],
+ * ]);
  * ```
  */
 export declare const pairwise: <A>() => DropInitialValueOperator<A, readonly [A, A]>;

package/dist/core/operators/pairwise.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"pairwise.d.mts","sourceRoot":"","sources":["../../../src/core/operators/pairwise.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAI9B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,OAAM,wBAAwB,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CACxE,CAAC"}
+{"version":3,"file":"pairwise.d.mts","sourceRoot":"","sources":["../../../src/core/operators/pairwise.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAI9B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,OAAM,wBAAwB,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CACxE,CAAC"}

package/dist/core/operators/pairwise.mjs

@@ -11,19 +11,48 @@ import '../utils/id-maker.mjs';
  *
  * @example
  * ```ts
+ * //  Timeline:
+ * //
+ * //  num$      1     2     3     4
+ * //  pairs$          [1,2] [2,3] [3,4]
+ * //
+ * //  Explanation:
+ * //  - pairwise emits the current and previous values as a tuple
+ * //  - Nothing is emitted for the first value (no previous value yet)
+ * //  - Useful for tracking changes between consecutive values
+ *
  * const num$ = source<number>();
  *
  * const pairs$ = num$.pipe(pairwise());
  *
+ * const mut_history: (readonly [number, number])[] = [];
+ *
  * pairs$.subscribe(([prev, curr]) => {
- *   console.log(prev, curr);
+ *   mut_history.push([prev, curr]);
  * });
  *
  * num$.next(1); // nothing logged
  *
+ * assert.deepStrictEqual(mut_history, []);
+ *
  * num$.next(2); // logs: 1, 2
  *
+ * assert.deepStrictEqual(mut_history, [[1, 2]]);
+ *
  * num$.next(3); // logs: 2, 3
+ *
+ * assert.deepStrictEqual(mut_history, [
+ *   [1, 2],
+ *   [2, 3],
+ * ]);
+ *
+ * num$.next(4); // logs: 3, 4
+ *
+ * assert.deepStrictEqual(mut_history, [
+ *   [1, 2],
+ *   [2, 3],
+ *   [3, 4],
+ * ]);
  * ```
  */
 const pairwise = () => f;

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

@@ -1 +1 @@
-{"version":3,"file":"pairwise.mjs","sources":["../../../src/core/operators/pairwise.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AASA;;;;;;;;;;;;;;;;;;;;;;;AAuBG;MACU,QAAQ,GAAG,MACtB;AAEF,MAAM,CAAC,GAAG,CAAK,gBAA+B,KAC5C,IAAI,uBAAuB,CAAC,gBAAgB,CAAC;AAE/C,MAAM,uBACJ,SAAQ,wBAAuD,CAAA;AAG/D,IAAA,kBAAkB;AAElB,IAAA,WAAA,CAAY,gBAA+B,EAAA;AACzC,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,YAAY,EAAE,QAAQ,CAAC,IAAI;AAC5B,SAAA,CAAC;;;AAIF,QAAA,IAAI,CAAC,kBAAkB,GAAG,gBAAgB,CAAC,WAAW,EAAE;IAC1D;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,MAAM,IAAI,GAAG,IAAI,CAAC,kBAAkB;QAEpC,MAAM,IAAI,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC;;AAGnC,QAAA,IAAI,CAAC,kBAAkB,GAAG,GAAG,CAAC,WAAW,EAAE;QAE3C,IAAI,IAAI,EAAE;AACR,YAAA,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,aAAa,CAAC;QACrD;IACF;AACD;;;;"}
+{"version":3,"file":"pairwise.mjs","sources":["../../../src/core/operators/pairwise.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDG;MACU,QAAQ,GAAG,MACtB;AAEF,MAAM,CAAC,GAAG,CAAK,gBAA+B,KAC5C,IAAI,uBAAuB,CAAC,gBAAgB,CAAC;AAE/C,MAAM,uBACJ,SAAQ,wBAAuD,CAAA;AAG/D,IAAA,kBAAkB;AAElB,IAAA,WAAA,CAAY,gBAA+B,EAAA;AACzC,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,YAAY,EAAE,QAAQ,CAAC,IAAI;AAC5B,SAAA,CAAC;;;AAIF,QAAA,IAAI,CAAC,kBAAkB,GAAG,gBAAgB,CAAC,WAAW,EAAE;IAC1D;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,MAAM,IAAI,GAAG,IAAI,CAAC,kBAAkB;QAEpC,MAAM,IAAI,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC;;AAGnC,QAAA,IAAI,CAAC,kBAAkB,GAAG,GAAG,CAAC,WAAW,EAAE;QAE3C,IAAI,IAAI,EAAE;AACR,YAAA,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,aAAa,CAAC;QACrD;IACF;AACD;;;;"}

package/dist/core/operators/scan.d.mts

@@ -11,19 +11,41 @@ import { type WithInitialValueOperator } from '../types/index.mjs';
  *
  * @example
  * ```ts
+ * //  Timeline (accumulating sum):
+ * //
+ * //  num$    1     2     3     4     5
+ * //  sum$    1     3     6     10    15
+ * //          |     |     |     |     |
+ * //          0+1   1+2   3+3   6+4   10+5
+ * //
+ * //  Explanation:
+ * //  - scan accumulates values over time using a reducer function
+ * //  - Starting with seed value 0, each emission adds to the accumulator
+ * //  - Similar to Array.reduce, but for streams
+ *
  * const num$ = source<number>();
  *
  * const sum$ = num$.pipe(scan((acc, curr) => acc + curr, 0));
  *
+ * const mut_history: number[] = [];
+ *
  * sum$.subscribe((x) => {
- *   console.log(x);
+ *   mut_history.push(x);
  * });
  *
+ * assert.deepStrictEqual(mut_history, [0]);
+ *
  * num$.next(1); // logs: 1
  *
+ * assert.deepStrictEqual(mut_history, [0, 1]);
+ *
  * num$.next(2); // logs: 3
  *
+ * assert.deepStrictEqual(mut_history, [0, 1, 3]);
+ *
  * num$.next(3); // logs: 6
+ *
+ * assert.deepStrictEqual(mut_history, [0, 1, 3, 6]);
  * ```
  */
 export declare const scan: <A, B>(reducer: (acc: B, curr: A) => B, initialValue: B) => WithInitialValueOperator<A, B>;

package/dist/core/operators/scan.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"scan.d.mts","sourceRoot":"","sources":["../../../src/core/operators/scan.mts"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,wBAAwB,EAC9B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,IAAI,GACd,CAAC,EAAE,CAAC,EACH,SAAS,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,CAAC,EAC/B,cAAc,CAAC,KACd,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAEkC,CAAC"}
+{"version":3,"file":"scan.d.mts","sourceRoot":"","sources":["../../../src/core/operators/scan.mts"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,wBAAwB,EAC9B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,eAAO,MAAM,IAAI,GACd,CAAC,EAAE,CAAC,EACH,SAAS,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,CAAC,EAC/B,cAAc,CAAC,KACd,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAEkC,CAAC"}

package/dist/core/operators/scan.mjs

@@ -14,19 +14,41 @@ import '../utils/id-maker.mjs';
  *
  * @example
  * ```ts
+ * //  Timeline (accumulating sum):
+ * //
+ * //  num$    1     2     3     4     5
+ * //  sum$    1     3     6     10    15
+ * //          |     |     |     |     |
+ * //          0+1   1+2   3+3   6+4   10+5
+ * //
+ * //  Explanation:
+ * //  - scan accumulates values over time using a reducer function
+ * //  - Starting with seed value 0, each emission adds to the accumulator
+ * //  - Similar to Array.reduce, but for streams
+ *
  * const num$ = source<number>();
  *
  * const sum$ = num$.pipe(scan((acc, curr) => acc + curr, 0));
  *
+ * const mut_history: number[] = [];
+ *
  * sum$.subscribe((x) => {
- *   console.log(x);
+ *   mut_history.push(x);
  * });
  *
+ * assert.deepStrictEqual(mut_history, [0]);
+ *
  * num$.next(1); // logs: 1
  *
+ * assert.deepStrictEqual(mut_history, [0, 1]);
+ *
  * num$.next(2); // logs: 3
  *
+ * assert.deepStrictEqual(mut_history, [0, 1, 3]);
+ *
  * num$.next(3); // logs: 6
+ *
+ * assert.deepStrictEqual(mut_history, [0, 1, 3, 6]);
  * ```
  */
 const scan = (reducer, initialValue) => (parentObservable) => new ScanObservableClass(parentObservable, reducer, initialValue);