synstate 2.0.2 → 3.0.1

package/src/core/operators/pairwise.mts

@@ -1,11 +1,10 @@
 import { Optional } from 'ts-data-forge';
 import { type FixedLengthTuple } from 'ts-type-forge';
-import { SyncChildObservableClass } from '../class/index.mjs';
+import { createSyncChildObservable } from '../base/index.mjs';
 import {
   type DropInitialValueOperator,
   type Observable,
   type PairwiseOperatorObservable,
-  type UpdateToken,
 } from '../types/index.mjs';
 
 /**
@@ -69,43 +68,41 @@ export const pairwise = <A,>(): DropInitialValueOperator<
 const f = <A,>(
   parentObservable: Observable<A>,
 ): Observable<FixedLengthTuple<2, A>> =>
-  new PairwiseObservableClass(parentObservable);
+  createPairwiseObservable(parentObservable);
 
-class PairwiseObservableClass<A>
-  extends SyncChildObservableClass<FixedLengthTuple<2, A>, readonly [A]>
-  implements PairwiseOperatorObservable<A>
-{
-  #mut_previousValue: Optional<A>;
-
-  constructor(parentObservable: Observable<A>) {
-    super({
+const createPairwiseObservable = <A,>(
+  parentObservable: Observable<A>,
+): PairwiseOperatorObservable<A> =>
+  createSyncChildObservable<FixedLengthTuple<2, A>, readonly [A]>(
+    {
       parents: [parentObservable],
       initialValue: Optional.none,
-    });
-
-    // parentObservable.snapshot has value
-    // if parentObservable is InitializedObservable
-    this.#mut_previousValue = parentObservable.getSnapshot();
-  }
-
-  override tryUpdate(updateToken: UpdateToken): void {
-    const par = this.parents[0];
+    },
+    ({ setNext }) => {
+      // parentObservable.snapshot has value
+      // if parentObservable is InitializedObservable
+      let mut_previousValue: Optional<A> = parentObservable.getSnapshot();
 
-    const sn = par.getSnapshot();
+      return (updateToken) => {
+        const sn = parentObservable.getSnapshot();
 
-    if (par.updateToken !== updateToken || Optional.isNone(sn)) {
-      return; // skip update
-    }
+        if (
+          parentObservable.updateToken !== updateToken ||
+          Optional.isNone(sn)
+        ) {
+          return; // skip update
+        }
 
-    const prev = this.#mut_previousValue;
+        const prev = mut_previousValue;
 
-    const cond = !Optional.isNone(prev);
+        const cond = !Optional.isNone(prev);
 
-    // NOTE: Must update before setNext, otherwise Optional.isNone(prev) remains true when tryUpdate is called consecutively
-    this.#mut_previousValue = par.getSnapshot();
+        // NOTE: Must update before setNext, otherwise Optional.isNone(prev) remains true when tryUpdate is called consecutively
+        mut_previousValue = parentObservable.getSnapshot();
 
-    if (cond) {
-      this.setNext([prev.value, sn.value], updateToken);
-    }
-  }
-}
+        if (cond) {
+          setNext([prev.value, sn.value], updateToken);
+        }
+      };
+    },
+  );

package/src/core/operators/scan.mts

@@ -1,9 +1,8 @@
 import { Optional } from 'ts-data-forge';
-import { InitializedSyncChildObservableClass } from '../class/index.mjs';
+import { createInitializedSyncChildObservable } from '../base/index.mjs';
 import {
   type Observable,
   type ScanOperatorObservable,
-  type UpdateToken,
   type WithInitialValueOperator,
 } from '../types/index.mjs';
 
@@ -62,42 +61,32 @@ export const scan =
     initialValue: B,
   ): WithInitialValueOperator<A, B> =>
   (parentObservable) =>
-    new ScanObservableClass(parentObservable, reducer, initialValue);
+    createScanObservable(parentObservable, reducer, initialValue);
 
-class ScanObservableClass<A, B>
-  extends InitializedSyncChildObservableClass<B, readonly [A]>
-  implements ScanOperatorObservable<A, B>
-{
-  readonly #reducer: (acc: B, curr: A) => B;
-
-  constructor(
-    parentObservable: Observable<A>,
-    reducer: (acc: B, curr: A) => B,
-    initialValue: B,
-  ) {
-    super({
+const createScanObservable = <A, B>(
+  parentObservable: Observable<A>,
+  reducer: (acc: B, curr: A) => B,
+  initialValue: B,
+): ScanOperatorObservable<A, B> =>
+  createInitializedSyncChildObservable(
+    {
       parents: [parentObservable],
       initialValue: Optional.some(initialValue),
-    });
-
-    this.#reducer = reducer;
-  }
-
-  override tryUpdate(updateToken: UpdateToken): void {
-    const par = this.parents[0];
-
-    const psn = par.getSnapshot();
+    },
+    ({ setNext, getSnapshot }) =>
+      (updateToken) => {
+        const psn = parentObservable.getSnapshot();
 
-    const sn = this.getSnapshot();
+        const sn = getSnapshot();
 
-    if (
-      par.updateToken !== updateToken ||
-      Optional.isNone(psn) ||
-      Optional.isNone(sn)
-    ) {
-      return; // skip update
-    }
+        if (
+          parentObservable.updateToken !== updateToken ||
+          Optional.isNone(psn) ||
+          Optional.isNone(sn)
+        ) {
+          return; // skip update
+        }
 
-    this.setNext(this.#reducer(sn.value, psn.value), updateToken);
-  }
-}
+        setNext(reducer(sn.value, psn.value), updateToken);
+      },
+  );

package/src/core/operators/skip-if-no-change.mts

@@ -1,10 +1,9 @@
 import { Optional } from 'ts-data-forge';
-import { SyncChildObservableClass } from '../class/index.mjs';
+import { createSyncChildObservable } from '../base/index.mjs';
 import {
   type KeepInitialValueOperator,
   type Observable,
   type SkipIfNoChangeOperatorObservable,
-  type UpdateToken,
 } from '../types/index.mjs';
 
 /**
@@ -73,7 +72,7 @@ export const skipIfNoChange = <A,>(
 ): KeepInitialValueOperator<A, A> =>
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   ((parentObservable) =>
-    new SkipIfNoChangeObservableClass(
+    createSkipIfNoChangeObservable(
       parentObservable,
       eq,
     )) as KeepInitialValueOperator<A, A>;
@@ -84,44 +83,40 @@ export const skipIfNoChange = <A,>(
  */
 export const distinctUntilChanged = skipIfNoChange;
 
-class SkipIfNoChangeObservableClass<A>
-  extends SyncChildObservableClass<A, readonly [A]>
-  implements SkipIfNoChangeOperatorObservable<A>
-{
-  readonly #eq: (x: A, y: A) => boolean;
-  #mut_previousValue: Optional<A>;
-
-  constructor(parentObservable: Observable<A>, eq: (x: A, y: A) => boolean) {
-    super({
+const createSkipIfNoChangeObservable = <A,>(
+  parentObservable: Observable<A>,
+  eq: (x: A, y: A) => boolean,
+): SkipIfNoChangeOperatorObservable<A> =>
+  createSyncChildObservable(
+    {
       parents: [parentObservable],
       initialValue: parentObservable.getSnapshot(),
-    });
-
-    // parentObservable.snapshot has value
-    // if parentObservable is InitializedObservable
-    this.#mut_previousValue = parentObservable.getSnapshot();
-
-    this.#eq = eq;
-  }
-
-  override tryUpdate(updateToken: UpdateToken): void {
-    const par = this.parents[0];
+    },
+    ({ setNext }) => {
+      // parentObservable.snapshot has value
+      // if parentObservable is InitializedObservable
+      let mut_previousValue: Optional<A> = parentObservable.getSnapshot();
 
-    const sn = par.getSnapshot();
+      return (updateToken) => {
+        const sn = parentObservable.getSnapshot();
 
-    if (par.updateToken !== updateToken || Optional.isNone(sn)) {
-      return; // skip update
-    }
+        if (
+          parentObservable.updateToken !== updateToken ||
+          Optional.isNone(sn)
+        ) {
+          return; // skip update
+        }
 
-    const prev = this.#mut_previousValue;
+        const prev = mut_previousValue;
 
-    const cond = Optional.isNone(prev) || !this.#eq(prev.value, sn.value);
+        const cond = Optional.isNone(prev) || !eq(prev.value, sn.value);
 
-    // NOTE: Must update before setNext, otherwise Optional.isNone(prev) remains true when tryUpdate is called consecutively
-    this.#mut_previousValue = sn;
+        // NOTE: Must update before setNext, otherwise Optional.isNone(prev) remains true when tryUpdate is called consecutively
+        mut_previousValue = sn;
 
-    if (cond) {
-      this.setNext(sn.value, updateToken);
-    }
-  }
-}
+        if (cond) {
+          setNext(sn.value, updateToken);
+        }
+      };
+    },
+  );

package/src/core/operators/skip-until.mts

@@ -1,10 +1,9 @@
 import { Optional } from 'ts-data-forge';
-import { SyncChildObservableClass } from '../class/index.mjs';
+import { createSyncChildObservable } from '../base/index.mjs';
 import {
   type DropInitialValueOperator,
   type Observable,
   type SkipUntilOperatorObservable,
-  type UpdateToken,
 } from '../types/index.mjs';
 
 /**
@@ -60,45 +59,43 @@ import {
 export const skipUntil =
   <A,>(notifier: Observable<unknown>): DropInitialValueOperator<A, A> =>
   (parentObservable) =>
-    new SkipUntilObservableClass(parentObservable, notifier);
+    createSkipUntilObservable(parentObservable, notifier);
 
-class SkipUntilObservableClass<A>
-  extends SyncChildObservableClass<A, readonly [A]>
-  implements SkipUntilOperatorObservable<A>
-{
-  #mut_isSkipping: boolean;
+const createSkipUntilObservable = <A,>(
+  parentObservable: Observable<A>,
+  notifier: Observable<unknown>,
+): SkipUntilOperatorObservable<A> => {
+  let mut_isSkipping = true;
 
-  constructor(parentObservable: Observable<A>, notifier: Observable<unknown>) {
-    super({
+  const observable = createSyncChildObservable<A, readonly [A]>(
+    {
       parents: [parentObservable],
       initialValue: Optional.none,
-    });
+    },
+    ({ setNext }) =>
+      (updateToken) => {
+        const sn = parentObservable.getSnapshot();
 
-    this.#mut_isSkipping = true;
+        if (
+          mut_isSkipping ||
+          parentObservable.updateToken !== updateToken ||
+          Optional.isNone(sn)
+        ) {
+          return; // skip update
+        }
 
-    notifier.subscribe(
-      () => {
-        this.#mut_isSkipping = false;
+        setNext(sn.value, updateToken);
       },
-      () => {
-        this.#mut_isSkipping = false;
-      },
-    );
-  }
-
-  override tryUpdate(updateToken: UpdateToken): void {
-    const par = this.parents[0];
-
-    const sn = par.getSnapshot();
+  );
 
-    if (
-      par.updateToken !== updateToken ||
-      Optional.isNone(sn) ||
-      this.#mut_isSkipping
-    ) {
-      return; // skip update
-    }
+  notifier.subscribe(
+    () => {
+      mut_isSkipping = false;
+    },
+    () => {
+      mut_isSkipping = false;
+    },
+  );
 
-    this.setNext(sn.value, updateToken);
-  }
-}
+  return observable;
+};

package/src/core/operators/skip-while.mts

@@ -1,10 +1,9 @@
 import { Optional, SafeUint, asSafeUint, pipe } from 'ts-data-forge';
-import { SyncChildObservableClass } from '../class/index.mjs';
+import { createSyncChildObservable } from '../base/index.mjs';
 import {
   type DropInitialValueOperator,
   type Observable,
   type SkipWhileOperatorObservable,
-  type UpdateToken,
 } from '../types/index.mjs';
 
 /**
@@ -70,54 +69,46 @@ export const skipWhile =
     predicate: (value: A, index: SafeUint | -1) => boolean,
   ): DropInitialValueOperator<A, A> =>
   (parentObservable) =>
-    new SkipWhileObservableClass(parentObservable, predicate);
+    createSkipWhileObservable(parentObservable, predicate);
 
 /* implementation */
 
-class SkipWhileObservableClass<A>
-  extends SyncChildObservableClass<A, readonly [A]>
-  implements SkipWhileOperatorObservable<A>
-{
-  readonly #predicate: (value: A, index: SafeUint | -1) => boolean;
-  #mut_index: SafeUint | -1;
-  #mut_skipping: boolean;
-
-  constructor(
-    parentObservable: Observable<A>,
-    predicate: (value: A, index: SafeUint | -1) => boolean,
-  ) {
-    super({
+const createSkipWhileObservable = <A,>(
+  parentObservable: Observable<A>,
+  predicate: (value: A, index: SafeUint | -1) => boolean,
+): SkipWhileOperatorObservable<A> =>
+  createSyncChildObservable(
+    {
       parents: [parentObservable],
       initialValue: pipe(parentObservable.getSnapshot()).map((sn) =>
         Optional.isNone(sn) || predicate(sn.value, -1) ? Optional.none : sn,
       ).value,
-    });
-
-    this.#mut_index = -1;
-
-    this.#predicate = predicate;
-
-    this.#mut_skipping = true;
-  }
+    },
+    ({ setNext }) => {
+      let mut_index: SafeUint | -1 = -1;
 
-  override tryUpdate(updateToken: UpdateToken): void {
-    const par = this.parents[0];
+      let mut_skipping = true;
 
-    const sn = par.getSnapshot();
+      return (updateToken) => {
+        const sn = parentObservable.getSnapshot();
 
-    if (par.updateToken !== updateToken || Optional.isNone(sn)) {
-      return; // skip update
-    }
+        if (
+          parentObservable.updateToken !== updateToken ||
+          Optional.isNone(sn)
+        ) {
+          return; // skip update
+        }
 
-    this.#mut_index =
-      this.#mut_index === -1 ? asSafeUint(0) : SafeUint.add(1, this.#mut_index);
+        mut_index =
+          mut_index === -1 ? asSafeUint(0) : SafeUint.add(1, mut_index);
 
-    if (!this.#predicate(sn.value, this.#mut_index)) {
-      this.#mut_skipping = false;
-    }
+        if (!predicate(sn.value, mut_index)) {
+          mut_skipping = false;
+        }
 
-    if (!this.#mut_skipping) {
-      this.setNext(sn.value, updateToken);
-    }
-  }
-}
+        if (!mut_skipping) {
+          setNext(sn.value, updateToken);
+        }
+      };
+    },
+  );

package/src/core/operators/switch-map.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 DropInitialValueOperator,
   type Observable,
   type Subscription,
   type SwitchMapOperatorObservable,
-  type UpdateToken,
 } from '../types/index.mjs';
 
 /**
@@ -106,61 +105,50 @@ export const switchMap =
     mapToObservable: (curr: A) => Observable<B>,
   ): DropInitialValueOperator<A, B> =>
   (parentObservable) =>
-    new SwitchMapObservableClass(parentObservable, mapToObservable);
+    createSwitchMapObservable(parentObservable, mapToObservable);
 
-class SwitchMapObservableClass<A, B>
-  extends AsyncChildObservableClass<B, readonly [A]>
-  implements SwitchMapOperatorObservable<A, B>
-{
-  readonly #mapToObservable: (curr: A) => Observable<B>;
-  #mut_observable: Observable<B> | undefined;
-  #mut_subscription: Subscription | undefined;
+const createSwitchMapObservable = <A, B>(
+  parentObservable: Observable<A>,
+  mapToObservable: (curr: A) => Observable<B>,
+): SwitchMapOperatorObservable<A, B> => {
+  let mut_observable: Observable<B> | undefined = undefined;
 
-  constructor(
-    parentObservable: Observable<A>,
-    mapToObservable: (curr: A) => Observable<B>,
-  ) {
-    super({
+  let mut_subscription: Subscription | undefined = undefined;
+
+  return createAsyncChildObservable(
+    {
       parents: [parentObservable],
       initialValue: Optional.none,
-    });
-
-    this.#mapToObservable = mapToObservable;
-
-    this.#mut_observable = undefined;
-
-    this.#mut_subscription = undefined;
-  }
-
-  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_observable?.complete();
+      onComplete: () => {
+        mut_subscription?.unsubscribe();
 
-    this.#mut_subscription?.unsubscribe();
+        mut_observable?.complete();
+      },
+    },
+    ({ startUpdate }) =>
+      (updateToken) => {
+        const sn = parentObservable.getSnapshot();
 
-    const observable = this.#mapToObservable(sn.value);
+        if (
+          parentObservable.updateToken !== updateToken ||
+          Optional.isNone(sn)
+        ) {
+          return; // skip update
+        }
 
-    this.#mut_observable = observable;
+        mut_observable?.complete();
 
-    const subscription = observable.subscribe((curr) => {
-      this.startUpdate(curr);
-    });
+        mut_subscription?.unsubscribe();
 
-    this.#mut_subscription = subscription;
-  }
+        const observable = mapToObservable(sn.value);
 
-  override complete(): void {
-    this.#mut_subscription?.unsubscribe();
+        mut_observable = observable;
 
-    this.#mut_observable?.complete();
+        const subscription = observable.subscribe((curr) => {
+          startUpdate(curr);
+        });
 
-    super.complete();
-  }
-}
+        mut_subscription = subscription;
+      },
+  );
+};

package/src/core/operators/take-until.mts

@@ -1,10 +1,9 @@
 import { Optional } from 'ts-data-forge';
-import { SyncChildObservableClass } from '../class/index.mjs';
+import { createSyncChildObservable } from '../base/index.mjs';
 import {
   type KeepInitialValueOperator,
   type Observable,
   type TakeUntilOperatorObservable,
-  type UpdateToken,
 } from '../types/index.mjs';
 
 /**
@@ -60,40 +59,43 @@ export const takeUntil = <A,>(
 ): KeepInitialValueOperator<A, A> =>
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   ((parentObservable) =>
-    new TakeUntilObservableClass(
+    createTakeUntilObservable(
       parentObservable,
       notifier,
     )) as KeepInitialValueOperator<A, A>;
 
-class TakeUntilObservableClass<A>
-  extends SyncChildObservableClass<A, readonly [A]>
-  implements TakeUntilOperatorObservable<A>
-{
-  constructor(parentObservable: Observable<A>, notifier: Observable<unknown>) {
-    super({
+const createTakeUntilObservable = <A,>(
+  parentObservable: Observable<A>,
+  notifier: Observable<unknown>,
+): TakeUntilOperatorObservable<A> => {
+  const observable = createSyncChildObservable<A, readonly [A]>(
+    {
       parents: [parentObservable],
       initialValue: parentObservable.getSnapshot(),
-    });
+    },
+    ({ setNext }) =>
+      (updateToken) => {
+        const sn = parentObservable.getSnapshot();
 
-    notifier.subscribe(
-      () => {
-        this.complete();
-      },
-      () => {
-        this.complete();
-      },
-    );
-  }
+        if (
+          parentObservable.updateToken !== updateToken ||
+          Optional.isNone(sn)
+        ) {
+          return; // skip update
+        }
 
-  override tryUpdate(updateToken: UpdateToken): void {
-    const par = this.parents[0];
-
-    const sn = par.getSnapshot();
+        setNext(sn.value, updateToken);
+      },
+  );
 
-    if (par.updateToken !== updateToken || Optional.isNone(sn)) {
-      return; // skip update
-    }
+  notifier.subscribe(
+    () => {
+      observable.complete();
+    },
+    () => {
+      observable.complete();
+    },
+  );
 
-    this.setNext(sn.value, updateToken);
-  }
-}
+  return observable;
+};