synstate 2.0.1 → 3.0.0

package/src/core/create/timer.mts

@@ -1,5 +1,5 @@
 import { Optional } from 'ts-data-forge';
-import { RootObservableClass } from '../class/index.mjs';
+import { createRootObservable } from '../base/index.mjs';
 import { type TimerId, type TimerObservable } from '../types/index.mjs';
 
 /**
@@ -43,62 +43,47 @@ export const timer = (
   options?: Readonly<{
     startManually?: boolean;
   }>,
-): TimerObservable =>
-  new TimerObservableClass(milliSeconds, options?.startManually ?? false);
+): TimerObservable => {
+  let mut_timerId: TimerId | undefined = undefined;
 
-class TimerObservableClass
-  extends RootObservableClass<0>
-  implements TimerObservable
-{
-  readonly #milliSeconds: number;
-  #mut_timerId: TimerId | undefined;
-  #mut_isStarted: boolean;
+  let mut_isStarted = false;
 
-  constructor(milliSeconds: number, startManually: boolean) {
-    super({ initialValue: Optional.none });
-
-    this.#milliSeconds = milliSeconds;
-
-    this.#mut_timerId = undefined;
-
-    this.#mut_isStarted = false;
-
-    if (!startManually) {
-      this.start();
+  const resetTimer = (): void => {
+    if (mut_timerId !== undefined) {
+      clearTimeout(mut_timerId);
     }
-  }
+  };
 
-  #resetTimer(): void {
-    if (this.#mut_timerId !== undefined) {
-      clearTimeout(this.#mut_timerId);
-    }
-  }
+  const observable = createRootObservable<0, Readonly<{ start: () => void }>>(
+    { initialValue: Optional.none, onComplete: resetTimer },
+    ({ startUpdate, isCompleted, complete }) => ({
+      start: () => {
+        if (mut_isStarted) {
+          console.warn('cannot start twice');
 
-  start(): void {
-    if (this.#mut_isStarted) {
-      console.warn('cannot start twice');
+          return;
+        }
 
-      return;
-    }
+        mut_isStarted = true;
 
-    this.#mut_isStarted = true;
+        if (isCompleted()) {
+          console.warn('cannot restart stopped TimerObservable');
 
-    if (this.isCompleted) {
-      console.warn('cannot restart stopped TimerObservable');
+          return;
+        }
 
-      return;
-    }
+        mut_timerId = setTimeout(() => {
+          startUpdate(0);
 
-    this.#mut_timerId = setTimeout(() => {
-      this.startUpdate(0);
+          complete();
+        }, milliSeconds);
+      },
+    }),
+  );
 
-      this.complete();
-    }, this.#milliSeconds);
+  if (!(options?.startManually ?? false)) {
+    observable.start();
   }
 
-  override complete(): void {
-    this.#resetTimer();
-
-    super.complete();
-  }
-}
+  return observable;
+};

package/src/core/index.mts

@@ -1,4 +1,3 @@
-export * from './class/index.mjs';
 export * from './combine/index.mjs';
 export * from './create/index.mjs';
 export * from './operators/index.mjs';

package/src/core/operators/audit.mts

@@ -1,11 +1,10 @@
 import { Optional } from 'ts-data-forge';
-import { AsyncChildObservableClass } from '../class/index.mjs';
+import { createAsyncChildObservable } from '../base/index.mjs';
 import {
   type AuditOperatorObservable,
   type KeepInitialValueOperator,
   type Observable,
   type TimerId,
-  type UpdateToken,
 } from '../types/index.mjs';
 
 /**
@@ -107,66 +106,53 @@ export const audit = <A,>(
 ): KeepInitialValueOperator<A, A> =>
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   ((parentObservable) =>
-    new AuditObservableClass(
+    createAuditObservable(
       parentObservable,
       milliSeconds,
     )) as KeepInitialValueOperator<A, A>;
 
-class AuditObservableClass<A>
-  extends AsyncChildObservableClass<A, readonly [A]>
-  implements AuditOperatorObservable<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;
-  }
-
-  #resetTimer(): void {
-    if (this.#mut_timerId !== undefined) {
-      clearTimeout(this.#mut_timerId);
-    }
-  }
+const createAuditObservable = <A,>(
+  parentObservable: Observable<A>,
+  milliSeconds: number,
+): AuditOperatorObservable<A> => {
+  let mut_timerId: TimerId | undefined = undefined;
 
-  override tryUpdate(updateToken: UpdateToken): void {
-    const par = this.parents[0];
+  let mut_isSkipping = false;
 
-    if (
-      par.updateToken !== updateToken ||
-      Optional.isNone(par.getSnapshot()) ||
-      this.#mut_isSkipping
-    ) {
-      return; // skip update
+  const resetTimer = (): void => {
+    if (mut_timerId !== undefined) {
+      clearTimeout(mut_timerId);
     }
+  };
 
-    // 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);
-  }
-
-  override complete(): void {
-    this.#resetTimer();
-
-    super.complete();
-  }
-}
+  return createAsyncChildObservable(
+    {
+      parents: [parentObservable],
+      initialValue: parentObservable.getSnapshot(),
+      onComplete: resetTimer,
+    },
+    ({ startUpdate }) =>
+      (updateToken) => {
+        if (
+          mut_isSkipping ||
+          parentObservable.updateToken !== updateToken ||
+          Optional.isNone(parentObservable.getSnapshot())
+        ) {
+          return; // skip update
+        }
+
+        // set timer
+        mut_isSkipping = true;
+
+        mut_timerId = setTimeout(() => {
+          const sn = parentObservable.getSnapshot();
+
+          if (Optional.isNone(sn)) return;
+
+          startUpdate(sn.value);
+
+          mut_isSkipping = false;
+        }, milliSeconds);
+      },
+  );
+};

package/src/core/operators/debounce.mts

@@ -1,11 +1,10 @@
 import { Optional } from 'ts-data-forge';
-import { AsyncChildObservableClass } from '../class/index.mjs';
+import { createAsyncChildObservable } from '../base/index.mjs';
 import {
   type DebounceOperatorObservable,
   type KeepInitialValueOperator,
   type Observable,
   type TimerId,
-  type UpdateToken,
 } from '../types/index.mjs';
 
 /**
@@ -98,57 +97,48 @@ export const debounce = <A,>(
 ): KeepInitialValueOperator<A, A> =>
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   ((parentObservable) =>
-    new DebounceObservableClass(
+    createDebounceObservable(
       parentObservable,
       milliSeconds,
     )) as KeepInitialValueOperator<A, A>;
 
-class DebounceObservableClass<A>
-  extends AsyncChildObservableClass<A, readonly [A]>
-  implements DebounceOperatorObservable<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;
-  }
-
-  #resetTimer(): void {
-    if (this.#mut_timerId !== undefined) {
-      clearTimeout(this.#mut_timerId);
-    }
-  }
-
-  override tryUpdate(updateToken: UpdateToken): void {
-    const par = this.parents[0];
-
-    const sn = par.getSnapshot();
+const createDebounceObservable = <A,>(
+  parentObservable: Observable<A>,
+  milliSeconds: number,
+): DebounceOperatorObservable<A> => {
+  let mut_timerId: TimerId | undefined = undefined;
 
-    if (par.updateToken !== updateToken || Optional.isNone(sn)) {
-      return; // skip update
+  const resetTimer = (): void => {
+    if (mut_timerId !== undefined) {
+      clearTimeout(mut_timerId);
     }
+  };
 
-    this.#resetTimer();
+  return createAsyncChildObservable(
+    {
+      parents: [parentObservable],
+      initialValue: parentObservable.getSnapshot(),
+      onComplete: resetTimer,
+    },
+    ({ startUpdate }) =>
+      (updateToken) => {
+        const sn = parentObservable.getSnapshot();
 
-    // set timer
-    this.#mut_timerId = setTimeout(() => {
-      if (Optional.isNone(sn)) return;
+        if (
+          parentObservable.updateToken !== updateToken ||
+          Optional.isNone(sn)
+        ) {
+          return; // skip update
+        }
 
-      this.startUpdate(sn.value);
-    }, this.#milliSeconds);
-  }
+        resetTimer();
 
-  override complete(): void {
-    this.#resetTimer();
+        // set timer
+        mut_timerId = setTimeout(() => {
+          if (Optional.isNone(sn)) return;
 
-    super.complete();
-  }
-}
+          startUpdate(sn.value);
+        }, milliSeconds);
+      },
+  );
+};

package/src/core/operators/filter.mts

@@ -5,14 +5,13 @@ import {
   pipe,
   SafeUint,
 } from 'ts-data-forge';
-import { SyncChildObservableClass } from '../class/index.mjs';
+import { createSyncChildObservable } from '../base/index.mjs';
 import { source } from '../create/index.mjs';
 import {
   type DropInitialValueOperator,
   type FilterOperatorObservable,
   type InitializedObservable,
   type Observable,
-  type UpdateToken,
 } from '../types/index.mjs';
 import { withInitialValue } from './with-initial-value.mjs';
 
@@ -77,21 +76,15 @@ export function filter<A>(
   predicate: (value: A, index: SafeUint | -1) => boolean,
 ): DropInitialValueOperator<A, A> {
   return (parentObservable) =>
-    new FilterObservableClass(parentObservable, predicate);
+    createFilterObservable(parentObservable, predicate);
 }
 
-class FilterObservableClass<A>
-  extends SyncChildObservableClass<A, readonly [A]>
-  implements FilterOperatorObservable<A>
-{
-  readonly #predicate: (x: A, index: SafeUint | -1) => boolean;
-  #mut_index: SafeUint | -1;
-
-  constructor(
-    parentObservable: Observable<A>,
-    predicate: (x: A, index: SafeUint | -1) => boolean,
-  ) {
-    super({
+const createFilterObservable = <A,>(
+  parentObservable: Observable<A>,
+  predicate: (x: A, index: SafeUint | -1) => boolean,
+): FilterOperatorObservable<A> =>
+  createSyncChildObservable(
+    {
       parents: [parentObservable],
       initialValue: pipe(parentObservable.getSnapshot()).map((sn) =>
         Optional.isNone(sn)
@@ -100,30 +93,29 @@ class FilterObservableClass<A>
             ? sn
             : Optional.none,
       ).value,
-    });
-
-    this.#mut_index = -1;
-
-    this.#predicate = predicate;
-  }
-
-  override tryUpdate(updateToken: UpdateToken): void {
-    const par = this.parents[0];
-
-    const sn = par.getSnapshot();
-
-    if (par.updateToken !== updateToken || Optional.isNone(sn)) {
-      return; // skip update
-    }
-
-    this.#mut_index =
-      this.#mut_index === -1 ? asSafeUint(0) : SafeUint.add(1, this.#mut_index);
-
-    if (this.#predicate(sn.value, this.#mut_index)) {
-      this.setNext(sn.value, updateToken);
-    }
-  }
-}
+    },
+    ({ setNext }) => {
+      let mut_index: SafeUint | -1 = -1;
+
+      return (updateToken) => {
+        const sn = parentObservable.getSnapshot();
+
+        if (
+          parentObservable.updateToken !== updateToken ||
+          Optional.isNone(sn)
+        ) {
+          return; // skip update
+        }
+
+        mut_index =
+          mut_index === -1 ? asSafeUint(0) : SafeUint.add(1, mut_index);
+
+        if (predicate(sn.value, mut_index)) {
+          setNext(sn.value, updateToken);
+        }
+      };
+    },
+  );
 
 if (import.meta.vitest !== undefined) {
   test('type test', () => {

package/src/core/operators/map.mts

@@ -1,12 +1,11 @@
 import { Optional, SafeUint, asSafeUint, expectType } from 'ts-data-forge';
-import { SyncChildObservableClass } from '../class/index.mjs';
+import { createSyncChildObservable } from '../base/index.mjs';
 import { source } from '../create/index.mjs';
 import {
   type InitializedObservable,
   type KeepInitialValueOperator,
   type MapOperatorObservable,
   type Observable,
-  type UpdateToken,
 } from '../types/index.mjs';
 import { withInitialValue } from './with-initial-value.mjs';
 
@@ -53,51 +52,44 @@ export const map = <A, B>(
 ): KeepInitialValueOperator<A, B> =>
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   ((parentObservable) =>
-    new MapObservableClass(
-      parentObservable,
-      mapFn,
-    )) as KeepInitialValueOperator<A, B>;
+    createMapObservable(parentObservable, mapFn)) as KeepInitialValueOperator<
+    A,
+    B
+  >;
 
 /* implementation */
 
-class MapObservableClass<A, B>
-  extends SyncChildObservableClass<B, readonly [A]>
-  implements MapOperatorObservable<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({
+const createMapObservable = <A, B>(
+  parentObservable: Observable<A>,
+  mapFn: (x: A, index: SafeUint | -1) => B,
+): MapOperatorObservable<A, B> =>
+  createSyncChildObservable(
+    {
       parents: [parentObservable],
       initialValue: Optional.map(parentObservable.getSnapshot(), (x) =>
         mapFn(x, -1),
       ),
-    });
-
-    this.#mut_index = -1;
-
-    this.#mapFn = mapFn;
-  }
-
-  override tryUpdate(updateToken: UpdateToken): void {
-    const par = this.parents[0];
-
-    const sn = par.getSnapshot();
-
-    if (par.updateToken !== updateToken || 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), updateToken);
-  }
-}
+    },
+    ({ setNext }) => {
+      let mut_index: SafeUint | -1 = -1;
+
+      return (updateToken) => {
+        const sn = parentObservable.getSnapshot();
+
+        if (
+          parentObservable.updateToken !== updateToken ||
+          Optional.isNone(sn)
+        ) {
+          return; // skip update
+        }
+
+        mut_index =
+          mut_index === -1 ? asSafeUint(0) : SafeUint.add(1, mut_index);
+
+        setNext(mapFn(sn.value, mut_index), updateToken);
+      };
+    },
+  );
 
 if (import.meta.vitest !== undefined) {
   test('type test', () => {

package/src/core/operators/merge-map.mts

@@ -1,11 +1,10 @@
 import { Arr, Optional } from 'ts-data-forge';
-import { AsyncChildObservableClass } from '../class/index.mjs';
+import { createAsyncChildObservable } from '../base/index.mjs';
 import {
   type DropInitialValueOperator,
   type MergeMapOperatorObservable,
   type Observable,
   type Subscription,
-  type UpdateToken,
 } from '../types/index.mjs';
 
 /**
@@ -108,7 +107,7 @@ export const mergeMap =
     mapToObservable: (curr: A) => Observable<B>,
   ): DropInitialValueOperator<A, B> =>
   (parentObservable) =>
-    new MergeMapObservableClass(parentObservable, mapToObservable);
+    createMergeMapObservable(parentObservable, mapToObservable);
 
 /**
  * Alias for `mergeMap`.
@@ -116,62 +115,48 @@ export const mergeMap =
  */
 export const flatMap = mergeMap;
 
-class MergeMapObservableClass<A, B>
-  extends AsyncChildObservableClass<B, readonly [A]>
-  implements MergeMapOperatorObservable<A, B>
-{
-  readonly #mapToObservable: (curr: A) => Observable<B>;
-  #mut_observables: readonly Observable<B>[];
-  #mut_subscriptions: readonly Subscription[];
+const createMergeMapObservable = <A, B>(
+  parentObservable: Observable<A>,
+  mapToObservable: (curr: A) => Observable<B>,
+): MergeMapOperatorObservable<A, B> => {
+  let mut_observables: readonly Observable<B>[] = [];
 
-  constructor(
-    parentObservable: Observable<A>,
-    mapToObservable: (curr: A) => Observable<B>,
-  ) {
-    super({
+  let mut_subscriptions: readonly Subscription[] = [];
+
+  return createAsyncChildObservable(
+    {
       parents: [parentObservable],
       initialValue: Optional.none,
-    });
-
-    this.#mapToObservable = mapToObservable;
-
-    this.#mut_observables = [];
-
-    this.#mut_subscriptions = [];
-  }
-
-  override tryUpdate(updateToken: UpdateToken): void {
-    const par = this.parents[0];
-
-    const sn = par.getSnapshot();
-
-    if (par.updateToken !== updateToken || Optional.isNone(sn)) {
-      return; // skip update
-    }
-
-    const observable = this.#mapToObservable(sn.value);
-
-    this.#mut_observables = Arr.toPushed(this.#mut_observables, observable);
-
-    const subscription = observable.subscribe((curr) => {
-      this.startUpdate(curr);
-    });
-
-    this.#mut_subscriptions = Arr.toPushed(
-      this.#mut_subscriptions,
-      subscription,
-    );
-  }
-
-  override complete(): void {
-    for (const s of this.#mut_subscriptions) {
-      s.unsubscribe();
-    }
-
-    for (const o of this.#mut_observables) {
-      o.complete();
-    }
-
-    super.complete();
-  }
-}
+      onComplete: () => {
+        for (const s of mut_subscriptions) {
+          s.unsubscribe();
+        }
+
+        for (const o of mut_observables) {
+          o.complete();
+        }
+      },
+    },
+    ({ startUpdate }) =>
+      (updateToken) => {
+        const sn = parentObservable.getSnapshot();
+
+        if (
+          parentObservable.updateToken !== updateToken ||
+          Optional.isNone(sn)
+        ) {
+          return; // skip update
+        }
+
+        const observable = mapToObservable(sn.value);
+
+        mut_observables = Arr.toPushed(mut_observables, observable);
+
+        const subscription = observable.subscribe((curr) => {
+          startUpdate(curr);
+        });
+
+        mut_subscriptions = Arr.toPushed(mut_subscriptions, subscription);
+      },
+  );
+};