synstate 2.0.1 → 3.0.0

package/src/core/combine/merge.mts

@@ -1,6 +1,6 @@
 import { Optional, expectType } from 'ts-data-forge';
 import { type ArrayElement, type NonEmptyTuple } from 'ts-type-forge';
-import { SyncChildObservableClass } from '../class/index.mjs';
+import { createSyncChildObservable } from '../base/index.mjs';
 import { source } from '../create/index.mjs';
 import {
   type MergeObservable,
@@ -8,7 +8,6 @@ import {
   type NonEmptyUnknownList,
   type Observable,
   type SyncChildObservable,
-  type UpdateToken,
   type Wrap,
 } from '../types/index.mjs';
 
@@ -67,33 +66,32 @@ export const merge = <const OS extends NonEmptyTuple<Observable<unknown>>>(
   parents: OS,
 ): MergeObservableRefined<OS> =>
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  new MergeObservableClass(parents) as MergeObservableRefined<OS>;
+  createMergeObservable(parents) as MergeObservableRefined<OS>;
 
-class MergeObservableClass<const P extends NonEmptyUnknownList>
-  extends SyncChildObservableClass<ArrayElement<P>, P>
-  implements MergeObservable<P>
-{
-  constructor(parents: Wrap<P>) {
-    super({
+const createMergeObservable = <const P extends NonEmptyUnknownList>(
+  parents: Wrap<P>,
+): MergeObservable<P> =>
+  createSyncChildObservable<ArrayElement<P>, P>(
+    {
       parents,
       initialValue: Optional.none,
-    });
-  }
+    },
+    ({ setNext }) =>
+      (updateToken) => {
+        const parentToUse = parents.find(
+          (o) =>
+            o.updateToken === updateToken && Optional.isSome(o.getSnapshot()),
+        );
 
-  override tryUpdate(updateToken: UpdateToken): void {
-    const parentToUse = this.parents.find(
-      (o) => o.updateToken === updateToken && Optional.isSome(o.getSnapshot()),
-    );
+        if (parentToUse === undefined) return;
 
-    if (parentToUse === undefined) return;
+        const nextValue =
+          // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+          Optional.unwrap(parentToUse.getSnapshot()) as ArrayElement<P>;
 
-    const nextValue =
-      // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-      Optional.unwrap(parentToUse.getSnapshot()) as ArrayElement<P>;
-
-    this.setNext(nextValue, updateToken);
-  }
-}
+        setNext(nextValue, updateToken);
+      },
+  );
 
 if (import.meta.vitest !== undefined) {
   test('type test', () => {

package/src/core/combine/zip.mts

@@ -1,6 +1,6 @@
 import { Arr, Optional, createQueue, expectType } from 'ts-data-forge';
 import { type NonEmptyTuple, type Tuple } from 'ts-type-forge';
-import { SyncChildObservableClass } from '../class/index.mjs';
+import { createSyncChildObservable } from '../base/index.mjs';
 import { source } from '../create/index.mjs';
 import { withInitialValue } from '../operators/index.mjs';
 import {
@@ -10,7 +10,6 @@ import {
   type Observable,
   type SyncChildObservable,
   type TupleToQueueTuple,
-  type UpdateToken,
   type Wrap,
   type ZipObservable,
   type ZipObservableRefined,
@@ -69,63 +68,60 @@ export const zip = <const OS extends NonEmptyTuple<Observable<unknown>>>(
   parents: OS,
 ): ZipObservableRefined<OS> =>
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  new ZipObservableClass(parents) as unknown as ZipObservableRefined<OS>;
-
-class ZipObservableClass<const A extends NonEmptyUnknownList>
-  extends SyncChildObservableClass<A, A>
-  implements ZipObservable<A>
-{
-  readonly #queues: TupleToQueueTuple<A>;
-
-  constructor(parents: Wrap<A>) {
-    const parentsValues: Tuple.MapTo<Optional<A[number]>, A> = Arr.map(
-      parents,
-      (p) => p.getSnapshot(),
-    );
-
-    // The annotation on `initialValue` is what replaces the type assertion.
-    // `Arr.map` carries a single result element type, so it reports `A[number]`
-    // at every position, and `Tuple.MapTo<A[number], A>` — the uniform mapping
-    // — is *not* assignable back to `A`. The positional
-    // `Readonly<{ [K in keyof A]: A[K] }>` is, and TypeScript accepts the
-    // uniform result into it because the two mapped types share `keyof A`. So
-    // it is the annotation, not an assertion, that records the position-wise
-    // fact the checker cannot derive on its own.
-    const initialValue: Optional<Readonly<{ [K in keyof A]: A[K] }>> =
-      Arr.every(parentsValues, Optional.isSome)
-        ? Optional.some(Arr.map(parentsValues, (c) => c.value))
-        : Optional.none;
-
-    super({
+  createZipObservable(parents) as unknown as ZipObservableRefined<OS>;
+
+const createZipObservable = <const A extends NonEmptyUnknownList>(
+  parents: Wrap<A>,
+): ZipObservable<A> => {
+  const parentsValues: Tuple.MapTo<Optional<A[number]>, A> = Arr.map(
+    parents,
+    (p) => p.getSnapshot(),
+  );
+
+  // The annotation on `initialValue` is what replaces the type assertion.
+  // `Arr.map` carries a single result element type, so it reports `A[number]`
+  // at every position, and `Tuple.MapTo<A[number], A>` — the uniform mapping
+  // — is *not* assignable back to `A`. The positional
+  // `Readonly<{ [K in keyof A]: A[K] }>` is, and TypeScript accepts the
+  // uniform result into it because the two mapped types share `keyof A`. So
+  // it is the annotation, not an assertion, that records the position-wise
+  // fact the checker cannot derive on its own.
+  const initialValue: Optional<Readonly<{ [K in keyof A]: A[K] }>> = Arr.every(
+    parentsValues,
+    Optional.isSome,
+  )
+    ? Optional.some(Arr.map(parentsValues, (c) => c.value))
+    : Optional.none;
+
+  const queues: TupleToQueueTuple<A> = Arr.map(parents, () => createQueue());
+
+  return createSyncChildObservable<A, A>(
+    {
       parents,
       initialValue,
-    });
-
-    this.#queues = Arr.map(parents, () => createQueue());
-  }
-
-  override tryUpdate(updateToken: UpdateToken): void {
-    const queues = this.#queues;
-
-    for (const [index, par] of this.parents.entries()) {
-      const sn = par.getSnapshot();
-
-      if (par.updateToken === updateToken && Optional.isSome(sn)) {
-        queues[index]?.enqueue(sn.value);
-      }
-    }
-
-    if (queues.every((list) => !list.isEmpty)) {
-      const nextValue =
-        // `Arr.map` has a single result element type, so it reports
-        // `A[number] | undefined` per position rather than `A[P]`.
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-        Arr.map(queues, (q) => Optional.unwrap(q.dequeue())) as A;
-
-      this.setNext(nextValue, updateToken);
-    }
-  }
-}
+    },
+    ({ setNext }) =>
+      (updateToken) => {
+        for (const [index, par] of parents.entries()) {
+          const sn = par.getSnapshot();
+
+          if (par.updateToken === updateToken && Optional.isSome(sn)) {
+            queues[index]?.enqueue(sn.value);
+          }
+        }
+
+        if (queues.every((list) => !list.isEmpty)) {
+          const nextValue =
+            // `Arr.map` has a single result element type, so it reports
+            // `A[number] | undefined` per position rather than `A[P]`.
+            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+            Arr.map(queues, (q) => Optional.unwrap(q.dequeue())) as A;
+
+          setNext(nextValue, updateToken);
+        }
+      },
+  );
+};
 
 if (import.meta.vitest !== undefined) {
   test('type test', () => {
@@ -176,7 +172,7 @@ if (import.meta.vitest !== undefined) {
   const _zi = zip([
     r1.pipe(withInitialValue(0)),
     r2.pipe(withInitialValue('0')),
-  ] as const);
+  ]);
 
   expectType<typeof _z, SyncChildObservable<readonly [number, string]>>('<=');
 

package/src/core/create/counter.mts

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

package/src/core/create/from-abortable-promise.mts

@@ -1,5 +1,5 @@
 import { Optional, Result } from 'ts-data-forge';
-import { RootObservableClass } from '../class/index.mjs';
+import { createRootObservable } from '../base/index.mjs';
 import { type FromPromiseObservable } from '../types/index.mjs';
 
 /**
@@ -31,53 +31,46 @@ import { type FromPromiseObservable } from '../types/index.mjs';
 export const fromAbortablePromise = <A, E = unknown>(
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   factory: (signal: AbortSignal) => Promise<A>,
-): FromPromiseObservable<A, E> =>
-  new FromAbortablePromiseObservableClass(factory);
+): FromPromiseObservable<A, E> => {
+  const abortController = new AbortController();
 
-class FromAbortablePromiseObservableClass<A, E = unknown>
-  extends RootObservableClass<Result<A, E>>
-  implements FromPromiseObservable<A, E>
-{
-  readonly #abortController: AbortController;
+  return createRootObservable<Result<A, E>>(
+    {
+      initialValue: Optional.none,
+      onComplete: () => {
+        abortController.abort();
+      },
+    },
+    ({ startUpdate, isCompleted, complete }) => {
+      const promise = factory(abortController.signal);
 
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  constructor(factory: (signal: AbortSignal) => Promise<A>) {
-    super({ initialValue: Optional.none });
-
-    this.#abortController = new AbortController();
-
-    const promise = factory(this.#abortController.signal);
-
-    promise
-      .then((value) => {
-        if (this.isCompleted) return;
-
-        this.startUpdate(Result.ok(value));
-      })
-      .catch((error: unknown) => {
-        if (this.isCompleted) return;
+      promise
+        .then((value) => {
+          if (isCompleted()) return;
 
-        // Silently ignore AbortError — it means the observable was
-        // intentionally completed (e.g., by switchMap).
-        if (error instanceof DOMException && error.name === 'AbortError') {
-          return;
-        }
+          startUpdate(Result.ok(value));
+        })
+        .catch((error: unknown) => {
+          if (isCompleted()) return;
 
-        this.startUpdate(
-          Result.err(
-            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-            error as E,
-          ),
-        );
-      })
-      .finally(() => {
-        this.complete();
-      });
-  }
+          // Silently ignore AbortError — it means the observable was
+          // intentionally completed (e.g., by switchMap).
+          if (error instanceof DOMException && error.name === 'AbortError') {
+            return;
+          }
 
-  override complete(): void {
-    this.#abortController.abort();
+          startUpdate(
+            Result.err(
+              // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+              error as E,
+            ),
+          );
+        })
+        .finally(() => {
+          complete();
+        });
 
-    super.complete();
-  }
-}
+      return {};
+    },
+  );
+};

package/src/core/create/from-promise.mts

@@ -1,5 +1,5 @@
 import { Optional, Result } from 'ts-data-forge';
-import { RootObservableClass } from '../class/index.mjs';
+import { createRootObservable } from '../base/index.mjs';
 import { type FromPromiseObservable } from '../types/index.mjs';
 
 /**
@@ -51,33 +51,30 @@ import { type FromPromiseObservable } from '../types/index.mjs';
  */
 export const fromPromise = <A, E = unknown>(
   promise: Promise<A>,
-): FromPromiseObservable<A, E> => new FromPromiseObservableClass(promise);
+): FromPromiseObservable<A, E> =>
+  createRootObservable<Result<A, E>>(
+    { initialValue: Optional.none },
+    ({ startUpdate, isCompleted, complete }) => {
+      promise
+        .then((value) => {
+          if (isCompleted()) return;
 
-class FromPromiseObservableClass<A, E = unknown>
-  extends RootObservableClass<Result<A, E>>
-  implements FromPromiseObservable<A, E>
-{
-  constructor(promise: Promise<A>) {
-    super({ initialValue: Optional.none });
+          startUpdate(Result.ok(value));
+        })
+        .catch((error: unknown) => {
+          if (isCompleted()) return;
 
-    promise
-      .then((value) => {
-        if (this.isCompleted) return;
+          startUpdate(
+            Result.err(
+              // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+              error as E,
+            ),
+          );
+        })
+        .finally(() => {
+          complete();
+        });
 
-        this.startUpdate(Result.ok(value));
-      })
-      .catch((error: unknown) => {
-        if (this.isCompleted) return;
-
-        this.startUpdate(
-          Result.err(
-            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-            error as E,
-          ),
-        );
-      })
-      .finally(() => {
-        this.complete();
-      });
-  }
-}
+      return {};
+    },
+  );

package/src/core/create/from-subscribable.mts

@@ -1,5 +1,5 @@
 import { Optional, Result } from 'ts-data-forge';
-import { RootObservableClass } from '../class/index.mjs';
+import { createRootObservable } from '../base/index.mjs';
 import {
   type FromSubscribableObservable,
   type Subscribable,
@@ -66,30 +66,26 @@ import {
 export const fromSubscribable = <A, E = unknown>(
   subscribable: Subscribable<A>,
 ): FromSubscribableObservable<A, E> =>
-  new FromSubscribableObservableClass(subscribable);
+  createRootObservable<Result<A, E>>(
+    { initialValue: Optional.none },
+    ({ startUpdate, complete }) => {
+      subscribable.subscribe(
+        (nextValue) => {
+          startUpdate(Result.ok(nextValue));
+        },
+        (error?: unknown) => {
+          startUpdate(
+            Result.err(
+              // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+              error as E,
+            ),
+          );
+        },
+        () => {
+          complete();
+        },
+      );
 
-class FromSubscribableObservableClass<A, E = unknown>
-  extends RootObservableClass<Result<A, E>>
-  implements FromSubscribableObservable<A, E>
-{
-  constructor(subscribable: Subscribable<A>) {
-    super({ initialValue: Optional.none });
-
-    subscribable.subscribe(
-      (nextValue) => {
-        this.startUpdate(Result.ok(nextValue));
-      },
-      (error?: unknown) => {
-        this.startUpdate(
-          Result.err(
-            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-            error as E,
-          ),
-        );
-      },
-      () => {
-        this.complete();
-      },
-    );
-  }
-}
+      return {};
+    },
+  );

package/src/core/create/just.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 InitializedRootObservable } from '../types/index.mjs';
 
 /**
@@ -32,9 +32,10 @@ import { type InitializedRootObservable } from '../types/index.mjs';
  * ```
  */
 export const just = <const A,>(value: A): InitializedRootObservable<A> => {
-  const obs = new RootObservableClass<A>({
-    initialValue: Optional.some(value),
-  });
+  const obs = createRootObservable<A>(
+    { initialValue: Optional.some(value) },
+    () => ({}),
+  );
 
   obs.complete();
 

package/src/core/create/source.mts

@@ -1,5 +1,5 @@
 import { Arr, Optional } from 'ts-data-forge';
-import { RootObservableClass } from '../class/index.mjs';
+import { createRootObservable } from '../base/index.mjs';
 import {
   type InitializedSourceObservable,
   type SourceObservable,
@@ -51,24 +51,18 @@ export function source<const A>(
 export function source<const A>(): SourceObservable<A>;
 
 export function source<const A>(...args: readonly A[]): SourceObservable<A> {
-  return new SourceObservableClass<A>(...args);
-}
-
-class SourceObservableClass<A>
-  extends RootObservableClass<A>
-  implements SourceObservable<A>
-{
-  constructor(...args: readonly A[]) {
-    super({
+  return createRootObservable<A, Readonly<{ next: (nextValue: A) => void }>>(
+    {
       initialValue: Arr.isNonEmpty(args)
         ? Optional.some(args[0])
         : Optional.none,
-    });
-  }
-
-  next(nextValue: A): void {
-    if (this.isCompleted) return;
+    },
+    ({ startUpdate, isCompleted }) => ({
+      next: (nextValue: A) => {
+        if (isCompleted()) return;
 
-    this.startUpdate(nextValue);
-  }
+        startUpdate(nextValue);
+      },
+    }),
+  );
 }