synstate 0.1.1 → 1.0.0

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

@@ -1,93 +0,0 @@
-import { Optional } from 'ts-data-forge';
-import { AsyncChildObservableClass } from '../class/child-observable-class.mjs';
-import '../utils/id-maker.mjs';
-
-/**
- * Delays emissions from the source observable until a specified time has passed without another emission.
- * Useful for handling user input events like typing or scrolling.
- *
- * @template A - The type of values from the source
- * @param milliSeconds - The debounce duration in milliseconds
- * @returns An operator that debounces the observable
- *
- * @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) => {
- *   mut_history.push(value);
- * });
- *
- * input$.next('h');
- *
- * input$.next('he');
- *
- * input$.next('hel');
- *
- * input$.next('hello');
- *
- * await new Promise((resolve) => {
- *   setTimeout(resolve, 400);
- * });
- *
- * assert.deepStrictEqual(mut_history, ['hello']);
- * ```
- */
-const debounceTime = (milliSeconds) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-((parentObservable) => new DebounceTimeObservableClass(parentObservable, milliSeconds));
-class DebounceTimeObservableClass extends AsyncChildObservableClass {
-    #milliSeconds;
-    #mut_timerId;
-    constructor(parentObservable, milliSeconds) {
-        super({
-            parents: [parentObservable],
-            initialValue: parentObservable.getSnapshot(),
-        });
-        this.#mut_timerId = undefined;
-        this.#milliSeconds = milliSeconds;
-    }
-    tryUpdate(updaterSymbol) {
-        const par = this.parents[0];
-        const sn = par.getSnapshot();
-        if (par.updaterSymbol !== updaterSymbol || Optional.isNone(sn)) {
-            return; // skip update
-        }
-        this.#resetTimer();
-        // set timer
-        this.#mut_timerId = setTimeout(() => {
-            if (Optional.isNone(sn))
-                return;
-            this.startUpdate(sn.value);
-        }, this.#milliSeconds);
-    }
-    #resetTimer() {
-        if (this.#mut_timerId !== undefined) {
-            clearTimeout(this.#mut_timerId);
-        }
-    }
-    complete() {
-        this.#resetTimer();
-        super.complete();
-    }
-}
-
-export { debounceTime };
-//# sourceMappingURL=debounce-time.mjs.map

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

@@ -1 +0,0 @@
-{"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/map-with-index.d.mts

@@ -1,54 +0,0 @@
-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.
- *
- * @template A - The type of values from the source
- * @template B - The type of mapped values
- * @param mapFn - A function that maps each value (receives value and index)
- * @returns An operator that maps values with index
- *
- * @example
- * ```ts
- * //  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) => {
- *   mut_history.push(s);
- * });
- *
- * num$.next('a'); // 0: a
- *
- * num$.next('b'); // 1: b
- *
- * num$.next('c'); // 2: c
- *
- * 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 +0,0 @@
-{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;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"}

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

@@ -1,88 +0,0 @@
-import { Optional, asSafeUint, SafeUint, Result } from 'ts-data-forge';
-import { SyncChildObservableClass } from '../class/child-observable-class.mjs';
-import '../utils/id-maker.mjs';
-
-/**
- * Transforms each value emitted by the source using a mapping function that also receives the emission index.
- *
- * @template A - The type of values from the source
- * @template B - The type of mapped values
- * @param mapFn - A function that maps each value (receives value and index)
- * @returns An operator that maps values with index
- *
- * @example
- * ```ts
- * //  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) => {
- *   mut_history.push(s);
- * });
- *
- * num$.next('a'); // 0: a
- *
- * num$.next('b'); // 1: b
- *
- * 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;
-    #mut_index;
-    constructor(parentObservable, mapFn) {
-        super({
-            parents: [parentObservable],
-            initialValue: Optional.map(parentObservable.getSnapshot(), (x) => mapFn(x, -1)),
-        });
-        this.#mut_index = -1;
-        this.#mapFn = mapFn;
-    }
-    tryUpdate(updaterSymbol) {
-        const par = this.parents[0];
-        const sn = par.getSnapshot();
-        if (par.updaterSymbol !== updaterSymbol || Optional.isNone(sn)) {
-            return; // skip update
-        }
-        this.#mut_index =
-            this.#mut_index === -1 ? asSafeUint(0) : SafeUint.add(1, this.#mut_index);
-        this.setNext(this.#mapFn(sn.value, this.#mut_index), updaterSymbol);
-    }
-}
-
-export { attachIndex, getKey, map, mapOptional, mapResultErr, mapResultOk, mapTo, mapWithIndex, pluck, unwrapOptional, unwrapResultErr, unwrapResultOk, withIndex };
-//# sourceMappingURL=map-with-index.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"map-with-index.mjs","sources":["../../../src/core/operators/map-with-index.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAkBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCG;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;;;;"}

package/dist/core/operators/throttle-time.d.mts

@@ -1,62 +0,0 @@
-import { type KeepInitialValueOperator } from '../types/index.mjs';
-/**
- * Emits the first value, then ignores subsequent values for a specified duration.
- * After the duration, the next emission is allowed through.
- *
- * @template A - The type of values from the source
- * @param milliSeconds - The throttle duration in milliseconds
- * @returns An operator that throttles emissions
- *
- * @example
- * ```ts
- * //  Timeline (1000ms throttle):
- * //
- * //  Time(ms)  0    100   200   300   ...   1000  1100  1200  ...   2000  2100
- * //  scroll$   e1   e2    e3    e4          e5    e6    e7          e8    e9
- * //  throttled$ e1                          e5                      e8
- * //             |-------1000ms------>       |------1000ms------>    |------1000ms------>
- * //
- * //  Explanation:
- * //  - throttleTime emits the first value immediately, then ignores subsequent values
- * //    for the specified duration (1000ms)
- * //  - At 0ms: e1 is emitted immediately
- * //  - At 100-300ms: e2, e3, e4 are ignored (within 1000ms window)
- * //  - At 1000ms: e5 is emitted (1000ms has passed since e1)
- * //  - At 1100-1200ms: e6, e7 are ignored
- * //  - At 2000ms: e8 is emitted (1000ms has passed since e5)
- *
- * const scroll$ = source<number>();
- *
- * const throttled$ = scroll$.pipe(throttleTime(200));
- *
- * const mut_history: number[] = [];
- *
- * throttled$.subscribe((value) => {
- *   mut_history.push(value);
- * });
- *
- * scroll$.next(1);
- *
- * assert.deepStrictEqual(mut_history, [1]);
- *
- * await new Promise((resolve) => {
- *   setTimeout(resolve, 50);
- * });
- *
- * scroll$.next(2);
- *
- * scroll$.next(3);
- *
- * assert.deepStrictEqual(mut_history, [1]);
- *
- * await new Promise((resolve) => {
- *   setTimeout(resolve, 200);
- * });
- *
- * scroll$.next(4);
- *
- * assert.deepStrictEqual(mut_history, [1, 4]);
- * ```
- */
-export declare const throttleTime: <A>(milliSeconds: number) => KeepInitialValueOperator<A, A>;
-//# sourceMappingURL=throttle-time.d.mts.map

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

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

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

@@ -1,107 +0,0 @@
-import { Optional } from 'ts-data-forge';
-import { SyncChildObservableClass } from '../class/child-observable-class.mjs';
-import '../utils/id-maker.mjs';
-
-/**
- * Emits the first value, then ignores subsequent values for a specified duration.
- * After the duration, the next emission is allowed through.
- *
- * @template A - The type of values from the source
- * @param milliSeconds - The throttle duration in milliseconds
- * @returns An operator that throttles emissions
- *
- * @example
- * ```ts
- * //  Timeline (1000ms throttle):
- * //
- * //  Time(ms)  0    100   200   300   ...   1000  1100  1200  ...   2000  2100
- * //  scroll$   e1   e2    e3    e4          e5    e6    e7          e8    e9
- * //  throttled$ e1                          e5                      e8
- * //             |-------1000ms------>       |------1000ms------>    |------1000ms------>
- * //
- * //  Explanation:
- * //  - throttleTime emits the first value immediately, then ignores subsequent values
- * //    for the specified duration (1000ms)
- * //  - At 0ms: e1 is emitted immediately
- * //  - At 100-300ms: e2, e3, e4 are ignored (within 1000ms window)
- * //  - At 1000ms: e5 is emitted (1000ms has passed since e1)
- * //  - At 1100-1200ms: e6, e7 are ignored
- * //  - At 2000ms: e8 is emitted (1000ms has passed since e5)
- *
- * const scroll$ = source<number>();
- *
- * const throttled$ = scroll$.pipe(throttleTime(200));
- *
- * const mut_history: number[] = [];
- *
- * throttled$.subscribe((value) => {
- *   mut_history.push(value);
- * });
- *
- * scroll$.next(1);
- *
- * assert.deepStrictEqual(mut_history, [1]);
- *
- * await new Promise((resolve) => {
- *   setTimeout(resolve, 50);
- * });
- *
- * scroll$.next(2);
- *
- * scroll$.next(3);
- *
- * assert.deepStrictEqual(mut_history, [1]);
- *
- * await new Promise((resolve) => {
- *   setTimeout(resolve, 200);
- * });
- *
- * scroll$.next(4);
- *
- * assert.deepStrictEqual(mut_history, [1, 4]);
- * ```
- */
-const throttleTime = (milliSeconds) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-((parentObservable) => new ThrottleTimeObservableClass(parentObservable, milliSeconds));
-class ThrottleTimeObservableClass extends SyncChildObservableClass {
-    #milliSeconds;
-    #mut_timerId;
-    #mut_isSkipping;
-    constructor(parentObservable, milliSeconds) {
-        super({
-            parents: [parentObservable],
-            initialValue: parentObservable.getSnapshot(),
-        });
-        this.#mut_timerId = undefined;
-        this.#mut_isSkipping = false;
-        this.#milliSeconds = milliSeconds;
-    }
-    tryUpdate(updaterSymbol) {
-        const par = this.parents[0];
-        const sn = par.getSnapshot();
-        if (par.updaterSymbol !== updaterSymbol ||
-            Optional.isNone(sn) ||
-            this.#mut_isSkipping) {
-            return; // skip update
-        }
-        this.setNext(sn.value, updaterSymbol);
-        this.#mut_isSkipping = true;
-        // set timer
-        this.#mut_timerId = setTimeout(() => {
-            this.#mut_isSkipping = false;
-        }, this.#milliSeconds);
-    }
-    #resetTimer() {
-        if (this.#mut_timerId !== undefined) {
-            clearTimeout(this.#mut_timerId);
-        }
-    }
-    complete() {
-        this.#resetTimer();
-        super.complete();
-    }
-}
-
-export { throttleTime };
-//# sourceMappingURL=throttle-time.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"throttle-time.mjs","sources":["../../../src/core/operators/throttle-time.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0DG;AACI,MAAM,YAAY,GAAG,CAC1B,YAAoB;AAEpB;AACA,CAAC,CAAC,gBAAgB,KAChB,IAAI,2BAA2B,CAC7B,gBAAgB,EAChB,YAAY,CACb;AAEL,MAAM,2BACJ,SAAQ,wBAAyC,CAAA;AAGxC,IAAA,aAAa;AACtB,IAAA,YAAY;AACZ,IAAA,eAAe;IAEf,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,eAAe,GAAG,KAAK;AAE5B,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,IACE,GAAG,CAAC,aAAa,KAAK,aAAa;AACnC,YAAA,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;YACnB,IAAI,CAAC,eAAe,EACpB;AACA,YAAA,OAAO;QACT;QAEA,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,CAAC;AAErC,QAAA,IAAI,CAAC,eAAe,GAAG,IAAI;;AAG3B,QAAA,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,MAAK;AAClC,YAAA,IAAI,CAAC,eAAe,GAAG,KAAK;AAC9B,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/src/core/create/from-array.mts

@@ -1,76 +0,0 @@
-import { Optional } from 'ts-data-forge';
-import { RootObservableClass } from '../class/index.mjs';
-import { type FromArrayObservable } from '../types/index.mjs';
-
-/**
- * Creates an observable that emits all values from an array sequentially, then completes.
- *
- * @template A - The type of array elements
- * @param values - The array of values to emit
- * @param startManually - If true, waits for manual start (default: false)
- * @returns An observable that emits array values
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  nums$     1     2     3     | (completes)
- * //
- * //  Explanation:
- * //  - fromArray creates an observable from an array
- * //  - Emits all values synchronously, then completes
- *
- * const nums$ = fromArray([1, 2, 3]);
- *
- * const mut_history: number[] = [];
- *
- * await new Promise<void>((resolve) => {
- *   nums$.subscribe(
- *     (x) => {
- *       mut_history.push(x);
- *     },
- *     () => {
- *       resolve();
- *     },
- *   );
- * });
- *
- * assert.deepStrictEqual(mut_history, [1, 2, 3]);
- * ```
- */
-export const fromArray = <A,>(
-  values: readonly A[],
-  startManually: boolean = false,
-): FromArrayObservable<A> =>
-  new FromArrayObservableClass<A>(values, startManually);
-
-class FromArrayObservableClass<A>
-  extends RootObservableClass<A>
-  implements FromArrayObservable<A>
-{
-  readonly #values: readonly A[];
-
-  constructor(values: readonly A[], startManually: boolean = false) {
-    super({ initialValue: Optional.none });
-
-    this.#values = values;
-
-    if (!startManually) {
-      setTimeout(() => {
-        this.emit();
-      }, 0);
-    }
-  }
-
-  emit(): this {
-    if (this.isCompleted) return this;
-
-    for (const v of this.#values) {
-      this.startUpdate(v);
-    }
-
-    this.complete();
-
-    return this;
-  }
-}

package/src/core/create/of.mts

@@ -1,73 +0,0 @@
-import { Optional } from 'ts-data-forge';
-import { RootObservableClass } from '../class/index.mjs';
-import { type OfObservable } from '../types/index.mjs';
-
-/**
- * Creates an observable that emits a single value and then completes.
- *
- * @template A - The type of the value
- * @param value - The value to emit
- * @param startManually - If true, waits for manual start (default: false)
- * @returns An observable that emits the value
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  num$    42  | (completes immediately)
- * //
- * //  Explanation:
- * //  - of creates an observable that emits a single value, then completes
- * //  - Useful for converting a static value into an observable
- *
- * const num$ = of(42);
- *
- * const mut_history: number[] = [];
- *
- * await new Promise<void>((resolve) => {
- *   num$.subscribe(
- *     (x) => {
- *       mut_history.push(x);
- *     },
- *     () => {
- *       resolve();
- *     },
- *   );
- * });
- *
- * assert.deepStrictEqual(mut_history, [42]);
- * ```
- */
-export const of = <A,>(
-  value: A,
-  startManually: boolean = false,
-): OfObservable<A> => new OfObservableClass<A>(value, startManually);
-
-class OfObservableClass<A>
-  extends RootObservableClass<A>
-  implements OfObservable<A>
-{
-  readonly #value: A;
-
-  constructor(value: A, startManually: boolean = false) {
-    super({ initialValue: Optional.none });
-
-    this.#value = value;
-
-    if (!startManually) {
-      setTimeout(() => {
-        this.emit();
-      }, 0);
-    }
-  }
-
-  emit(): this {
-    if (this.isCompleted) return this;
-
-    this.startUpdate(this.#value);
-
-    this.complete();
-
-    return this;
-  }
-}