synstate 0.1.1 → 1.0.0

package/src/core/operators/audit-time.mts

@@ -1,136 +0,0 @@
-import { Optional } from 'ts-data-forge';
-import { AsyncChildObservableClass } from '../class/index.mjs';
-import {
-  type AuditTimeOperatorObservable,
-  type KeepInitialValueOperator,
-  type Observable,
-  type UpdaterSymbol,
-} from '../types/index.mjs';
-
-/**
- * Emits the last value from the source observable after a specified time window has passed.
- * Unlike throttleTime which emits the first value, auditTime emits the last value.
- *
- * @template A - The type of values from the source
- * @param milliSeconds - The audit time window in milliseconds
- * @returns An operator that audits emissions from the observable
- *
- * @example
- * ```ts
- * //  Timeline (1000ms audit):
- * //
- * //  Time(ms)  0    100   200   300   400   ...   1000  1100
- * //  input$    e1   e2    e3    e4    e5
- * //  audited$                                      e5 (emitted at end of window)
- * //            |-------1000ms window------>        ^
- * //
- * //  Explanation:
- * //  - auditTime emits the LAST value received during each time window
- * //  - Unlike throttleTime (which emits the FIRST value), audit emits the LAST
- * //  - At 0-1000ms: e1-e5 are received
- * //  - At 1000ms: e5 (the last value in the window) is emitted
- * //  - Useful when you want the most recent value after a burst of events
- *
- * const input$ = source<number>();
- *
- * const audited$ = input$.pipe(auditTime(200));
- *
- * const mut_history: number[] = [];
- *
- * audited$.subscribe((value) => {
- *   mut_history.push(value);
- * });
- *
- * input$.next(1);
- *
- * input$.next(2);
- *
- * input$.next(3);
- *
- * assert.deepStrictEqual(mut_history, []);
- *
- * await new Promise((resolve) => {
- *   setTimeout(resolve, 250);
- * });
- *
- * assert.deepStrictEqual(mut_history, [3]);
- *
- * input$.next(4);
- *
- * input$.next(5);
- *
- * await new Promise((resolve) => {
- *   setTimeout(resolve, 250);
- * });
- *
- * assert.deepStrictEqual(mut_history, [3, 5]);
- * ```
- */
-export const auditTime = <A,>(
-  milliSeconds: number,
-): KeepInitialValueOperator<A, A> =>
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  ((parentObservable) =>
-    new AuditTimeObservableClass(
-      parentObservable,
-      milliSeconds,
-    )) as KeepInitialValueOperator<A, A>;
-
-class AuditTimeObservableClass<A>
-  extends AsyncChildObservableClass<A, readonly [A]>
-  implements AuditTimeOperatorObservable<A>
-{
-  readonly #milliSeconds: number;
-  #mut_timerId: TimerId | undefined;
-  #mut_isSkipping: boolean;
-
-  constructor(parentObservable: Observable<A>, milliSeconds: number) {
-    super({
-      parents: [parentObservable],
-      initialValue: parentObservable.getSnapshot(),
-    });
-
-    this.#mut_isSkipping = false;
-
-    this.#mut_timerId = undefined;
-
-    this.#milliSeconds = milliSeconds;
-  }
-
-  override tryUpdate(updaterSymbol: UpdaterSymbol): void {
-    const par = this.parents[0];
-
-    if (
-      par.updaterSymbol !== updaterSymbol ||
-      Optional.isNone(par.getSnapshot()) ||
-      this.#mut_isSkipping
-    ) {
-      return; // skip update
-    }
-
-    // set timer
-    this.#mut_isSkipping = true;
-
-    this.#mut_timerId = setTimeout(() => {
-      const sn = par.getSnapshot();
-
-      if (Optional.isNone(sn)) return;
-
-      this.startUpdate(sn.value);
-
-      this.#mut_isSkipping = false;
-    }, this.#milliSeconds);
-  }
-
-  #resetTimer(): void {
-    if (this.#mut_timerId !== undefined) {
-      clearTimeout(this.#mut_timerId);
-    }
-  }
-
-  override complete(): void {
-    this.#resetTimer();
-
-    super.complete();
-  }
-}

package/src/core/operators/debounce-time.mts

@@ -1,116 +0,0 @@
-import { Optional } from 'ts-data-forge';
-import { AsyncChildObservableClass } from '../class/index.mjs';
-import {
-  type DebounceTimeOperatorObservable,
-  type KeepInitialValueOperator,
-  type Observable,
-  type UpdaterSymbol,
-} from '../types/index.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']);
- * ```
- */
-export const debounceTime = <A,>(
-  milliSeconds: number,
-): KeepInitialValueOperator<A, A> =>
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  ((parentObservable) =>
-    new DebounceTimeObservableClass(
-      parentObservable,
-      milliSeconds,
-    )) as KeepInitialValueOperator<A, A>;
-
-class DebounceTimeObservableClass<A>
-  extends AsyncChildObservableClass<A, readonly [A]>
-  implements DebounceTimeOperatorObservable<A>
-{
-  readonly #milliSeconds: number;
-  #mut_timerId: TimerId | undefined;
-
-  constructor(parentObservable: Observable<A>, milliSeconds: number) {
-    super({
-      parents: [parentObservable],
-      initialValue: parentObservable.getSnapshot(),
-    });
-
-    this.#mut_timerId = undefined;
-
-    this.#milliSeconds = milliSeconds;
-  }
-
-  override tryUpdate(updaterSymbol: UpdaterSymbol): void {
-    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(): void {
-    if (this.#mut_timerId !== undefined) {
-      clearTimeout(this.#mut_timerId);
-    }
-  }
-
-  override complete(): void {
-    this.#resetTimer();
-
-    super.complete();
-  }
-}

package/src/core/operators/map-with-index.mts

@@ -1,183 +0,0 @@
-import {
-  Optional,
-  Result,
-  SafeUint,
-  asSafeUint,
-  expectType,
-} from 'ts-data-forge';
-import { SyncChildObservableClass } from '../class/index.mjs';
-import { source } from '../create/index.mjs';
-import {
-  type InitializedObservable,
-  type KeepInitialValueOperator,
-  type MapWithIndexOperatorObservable,
-  type Observable,
-  type UpdaterSymbol,
-} from '../types/index.mjs';
-import { withInitialValue } from './with-initial-value.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 const mapWithIndex = <A, B>(
-  mapFn: (x: A, index: SafeUint | -1) => B,
-): KeepInitialValueOperator<A, B> =>
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  ((parentObservable) =>
-    new MapWithIndexObservableClass(
-      parentObservable,
-      mapFn,
-    )) as KeepInitialValueOperator<A, B>;
-
-/* Specialized operators */
-
-export const map = <A, B>(mapFn: (x: A) => B): KeepInitialValueOperator<A, B> =>
-  mapWithIndex(mapFn);
-
-export const mapTo = <A, B>(value: B): KeepInitialValueOperator<A, B> =>
-  map(() => value);
-
-export const pluck = <A, K extends keyof A>(
-  key: K,
-): KeepInitialValueOperator<A, A[K]> => map((a) => a[key]);
-
-export const getKey = pluck; // alias
-
-export const attachIndex = <A,>(): KeepInitialValueOperator<
-  A,
-  readonly [SafeUint | -1, A]
-> => mapWithIndex((a, i) => [i, a] as const);
-
-export const withIndex = attachIndex; // alias
-
-export const unwrapOptional = <
-  O extends UnknownOptional,
->(): KeepInitialValueOperator<O, Optional.Unwrap<O> | undefined> =>
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  map(Optional.unwrap as Fn<O, Optional.Unwrap<O> | undefined>);
-
-export const unwrapResultOk = <
-  R extends UnknownResult,
->(): KeepInitialValueOperator<R, Result.UnwrapOk<R> | undefined> =>
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  map(Result.unwrapOk as Fn<R, Result.UnwrapOk<R> | undefined>);
-
-export const unwrapResultErr = <
-  R extends UnknownResult,
->(): KeepInitialValueOperator<R, Result.UnwrapErr<R> | undefined> =>
-  map(Result.unwrapErr as Fn<R, Result.UnwrapErr<R> | undefined>);
-
-export const mapOptional = <O extends UnknownOptional, B>(
-  mapFn: (x: Optional.Unwrap<O>) => B,
-): KeepInitialValueOperator<O, Optional<B>> =>
-  map((a) => Optional.map(a, mapFn));
-
-export const mapResultOk = <R extends UnknownResult, S2>(
-  mapFn: (x: Result.UnwrapOk<R>) => S2,
-): KeepInitialValueOperator<R, Result<S2, Result.UnwrapErr<R>>> =>
-  map((a) => Result.map(a, mapFn));
-
-export const mapResultErr = <R extends UnknownResult, E2>(
-  mapFn: (x: Result.UnwrapErr<R>) => E2,
-): KeepInitialValueOperator<R, Result<Result.UnwrapOk<R>, E2>> =>
-  map((a) => Result.mapErr(a, mapFn));
-
-/* implementation */
-
-class MapWithIndexObservableClass<A, B>
-  extends SyncChildObservableClass<B, readonly [A]>
-  implements MapWithIndexOperatorObservable<A, B>
-{
-  readonly #mapFn: (x: A, index: SafeUint | -1) => B;
-  #mut_index: SafeUint | -1;
-
-  constructor(
-    parentObservable: Observable<A>,
-    mapFn: (x: A, index: SafeUint | -1) => B,
-  ) {
-    super({
-      parents: [parentObservable],
-      initialValue: Optional.map(parentObservable.getSnapshot(), (x) =>
-        mapFn(x, -1),
-      ),
-    });
-
-    this.#mut_index = -1;
-
-    this.#mapFn = mapFn;
-  }
-
-  override tryUpdate(updaterSymbol: UpdaterSymbol): void {
-    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);
-  }
-}
-
-if (import.meta.vitest !== undefined) {
-  test('type test', () => {
-    expect(1).toBe(1); // dummy
-  });
-
-  {
-    const s: Observable<number> = source<number>();
-
-    const _d1 = s.pipe(map((x) => x + 1));
-
-    expectType<typeof _d1, Observable<number>>('=');
-  }
-
-  {
-    const s = source<number>();
-
-    const m: InitializedObservable<number> = s.pipe(withInitialValue(0));
-
-    const _d = m.pipe(map((x) => x + 1));
-
-    expectType<typeof _d, InitializedObservable<number>>('=');
-  }
-}