synstate 0.1.2 → 1.0.0

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

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/predefined/operators/map.mts

@@ -1,5 +0,0 @@
-import { mapWithIndex } from '../../operators/index.mjs';
-import { type KeepInitialValueOperator } from '../../types/index.mjs';
-
-export const map = <A, B>(mapFn: (x: A) => B): KeepInitialValueOperator<A, B> =>
-  mapWithIndex(mapFn);