synstate 3.3.0 → 4.0.0

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

@@ -1,16 +1,31 @@
+// Sumi bans classes, `this`, method syntax and writes to `this` outside a
+// `mut_` binding; an observable is a class (`ObservableBaseClass` says why),
+// so those rules are waived here (D-63).
+// @sumi-expect-error-file classes/no-class
+// @sumi-expect-error-file banned-syntax/no-this
+// @sumi-expect-error-file functions/prefer-arrow-function
+// @sumi-expect-error-file mutation/no-mutation-without-mut-prefix
 import { Arr, Optional } from 'ts-data-forge';
-import { createAsyncChildObservable } from '../base/index.mjs';
+import { AsyncChildObservableClass } from '../class/index.mjs';
+import { createScope, getCurrentScope } from '../scope/index.mjs';
 import type {
   DropInitialValueOperator,
   MergeMapOperatorObservable,
   Observable,
+  Scope,
   Subscription,
+  UpdateToken,
 } from '../types/index.mjs';
 
 /**
  * Projects each source value to an observable and merges all inner observables.
  * Unlike `switchMap`, does not cancel previous inner observables.
  *
+ * Each projection runs in a scope of its own (see `createScope`): what it
+ * creates is disposed when `mergeMap` completes. An observable it only
+ * returns — one created outside the projection and shared with others — is
+ * unsubscribed and left running.
+ *
  * @template A - The type of values from the source
  * @template B - The type of values from the projected observable
  * @param mapToObservable - A function that maps each source value to an observable
@@ -98,16 +113,13 @@ import type {
  *   'C3',
  * ]);
  * ```
- *
- * @note To improve code readability, consider using `createState` instead of `mergeMap`,
- * subscribing to `parentObservable` and calling `setState` within it.
  */
 export const mergeMap =
   <A, B>(
     mapToObservable: (curr: A) => Observable<B>,
   ): DropInitialValueOperator<A, B> =>
   (parentObservable) =>
-    createMergeMapObservable(parentObservable, mapToObservable);
+    new MergeMapObservableClass(parentObservable, mapToObservable);
 
 /**
  * Alias for `mergeMap`.
@@ -115,48 +127,71 @@ export const mergeMap =
  */
 export const flatMap = mergeMap;
 
-const createMergeMapObservable = <A, B>(
-  parentObservable: Observable<A>,
-  mapToObservable: (curr: A) => Observable<B>,
-): MergeMapOperatorObservable<A, B> => {
-  let mut_observables: readonly Observable<B>[] = [];
+class MergeMapObservableClass<A, B>
+  extends AsyncChildObservableClass<B, readonly [A]>
+  implements MergeMapOperatorObservable<A, B>
+{
+  readonly #mapToObservable: (curr: A) => Observable<B>;
+
+  /** See `SwitchMapObservableClass`. */
+  readonly #ownerScope: Scope | undefined;
 
-  let mut_subscriptions: readonly Subscription[] = [];
+  #mut_innerScopes: readonly Scope[];
+  #mut_subscriptions: readonly Subscription[];
 
-  return createAsyncChildObservable(
-    {
+  constructor(
+    parentObservable: Observable<A>,
+    mapToObservable: (curr: A) => Observable<B>,
+  ) {
+    super({
       parents: [parentObservable],
       initialValue: Optional.none,
-      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);
-      },
-  );
-};
+    });
+
+    this.#mapToObservable = mapToObservable;
+
+    this.#ownerScope = getCurrentScope();
+
+    this.#mut_innerScopes = [];
+
+    this.#mut_subscriptions = [];
+
+    this.attach();
+  }
+
+  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 innerScope = createScope(this.#ownerScope);
+
+    this.#mut_innerScopes = Arr.toPushed(this.#mut_innerScopes, innerScope);
+
+    const observable = innerScope.run(() => this.#mapToObservable(sn.value));
+
+    const subscription = observable.subscribe((curr) => {
+      this.startUpdate(curr);
+    });
+
+    this.#mut_subscriptions = Arr.toPushed(
+      this.#mut_subscriptions,
+      subscription,
+    );
+  }
+
+  /** Releases the inner observables, and only those this operator made. */
+  protected override teardown(): void {
+    for (const s of this.#mut_subscriptions) {
+      s.unsubscribe();
+    }
+
+    for (const scope of this.#mut_innerScopes) {
+      scope.dispose();
+    }
+  }
+}

package/src/core/operators/pairwise.mts

@@ -1,10 +1,18 @@
+// Sumi bans classes, `this`, method syntax and writes to `this` outside a
+// `mut_` binding; an observable is a class (`ObservableBaseClass` says why),
+// so those rules are waived here (D-63).
+// @sumi-expect-error-file classes/no-class
+// @sumi-expect-error-file banned-syntax/no-this
+// @sumi-expect-error-file functions/prefer-arrow-function
+// @sumi-expect-error-file mutation/no-mutation-without-mut-prefix
 import { Optional } from 'ts-data-forge';
 import type { FixedLengthTuple } from 'ts-type-forge';
-import { createSyncChildObservable } from '../base/index.mjs';
+import { SyncChildObservableClass } from '../class/index.mjs';
 import type {
   DropInitialValueOperator,
   Observable,
   PairwiseOperatorObservable,
+  UpdateToken,
 } from '../types/index.mjs';
 
 /**
@@ -68,41 +76,43 @@ export const pairwise = <A,>(): DropInitialValueOperator<
 const f = <A,>(
   parentObservable: Observable<A>,
 ): Observable<FixedLengthTuple<2, A>> =>
-  createPairwiseObservable(parentObservable);
+  new PairwiseObservableClass(parentObservable);
 
-const createPairwiseObservable = <A,>(
-  parentObservable: Observable<A>,
-): PairwiseOperatorObservable<A> =>
-  createSyncChildObservable<FixedLengthTuple<2, A>, readonly [A]>(
-    {
+class PairwiseObservableClass<A>
+  extends SyncChildObservableClass<FixedLengthTuple<2, A>, readonly [A]>
+  implements PairwiseOperatorObservable<A>
+{
+  #mut_previousValue: Optional<A>;
+
+  constructor(parentObservable: Observable<A>) {
+    super({
       parents: [parentObservable],
       initialValue: Optional.none,
-    },
-    ({ setNext }) => {
-      // parentObservable.snapshot has value
-      // if parentObservable is InitializedObservable
-      let mut_previousValue: Optional<A> = parentObservable.getSnapshot();
+    });
+
+    // parentObservable.snapshot has value
+    // if parentObservable is InitializedObservable
+    this.#mut_previousValue = parentObservable.getSnapshot();
+
+    this.attach();
+  }
 
-      return (updateToken) => {
-        const sn = parentObservable.getSnapshot();
+  override tryUpdate(updateToken: UpdateToken): void {
+    const par = this.parents[0];
 
-        if (
-          parentObservable.updateToken !== updateToken ||
-          Optional.isNone(sn)
-        ) {
-          return; // skip update
-        }
+    const sn = par.getSnapshot();
 
-        const prev = mut_previousValue;
+    if (par.updateToken !== updateToken || Optional.isNone(sn)) {
+      return; // skip update
+    }
 
-        const cond = !Optional.isNone(prev);
+    const prev = this.#mut_previousValue;
 
-        // NOTE: Must update before setNext, otherwise Optional.isNone(prev) remains true when tryUpdate is called consecutively
-        mut_previousValue = parentObservable.getSnapshot();
+    // NOTE: Must update before setNext, otherwise Optional.isNone(prev) remains true when tryUpdate is called consecutively
+    this.#mut_previousValue = sn;
 
-        if (cond) {
-          setNext([prev.value, sn.value], updateToken);
-        }
-      };
-    },
-  );
+    if (Optional.isSome(prev)) {
+      this.setNext([prev.value, sn.value], updateToken);
+    }
+  }
+}

package/src/core/operators/scan.mts

@@ -1,8 +1,16 @@
+// Sumi bans classes, `this`, method syntax and writes to `this` outside a
+// `mut_` binding; an observable is a class (`ObservableBaseClass` says why),
+// so those rules are waived here (D-63).
+// @sumi-expect-error-file classes/no-class
+// @sumi-expect-error-file banned-syntax/no-this
+// @sumi-expect-error-file functions/prefer-arrow-function
+// @sumi-expect-error-file mutation/no-mutation-without-mut-prefix
 import { Optional } from 'ts-data-forge';
-import { createInitializedSyncChildObservable } from '../base/index.mjs';
+import { InitializedSyncChildObservableClass } from '../class/index.mjs';
 import type {
   Observable,
   ScanOperatorObservable,
+  UpdateToken,
   WithInitialValueOperator,
 } from '../types/index.mjs';
 
@@ -61,32 +69,41 @@ export const scan =
     initialValue: B,
   ): WithInitialValueOperator<A, B> =>
   (parentObservable) =>
-    createScanObservable(parentObservable, reducer, initialValue);
+    new ScanObservableClass(parentObservable, reducer, initialValue);
 
-const createScanObservable = <A, B>(
-  parentObservable: Observable<A>,
-  reducer: (acc: B, curr: A) => B,
-  initialValue: B,
-): ScanOperatorObservable<A, B> =>
-  createInitializedSyncChildObservable(
-    {
+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({
       parents: [parentObservable],
       initialValue: Optional.some(initialValue),
-    },
-    ({ setNext, getSnapshot }) =>
-      (updateToken) => {
-        const psn = parentObservable.getSnapshot();
+    });
+
+    this.#reducer = reducer;
+
+    this.attach();
+  }
+
+  override tryUpdate(updateToken: UpdateToken): void {
+    const par = this.parents[0];
 
-        const sn = getSnapshot();
+    const psn = par.getSnapshot();
 
-        if (
-          parentObservable.updateToken !== updateToken ||
-          Optional.isNone(psn) ||
-          Optional.isNone(sn)
-        ) {
-          return; // skip update
-        }
+    if (par.updateToken !== updateToken || Optional.isNone(psn)) {
+      return; // skip update
+    }
 
-        setNext(reducer(sn.value, psn.value), updateToken);
-      },
-  );
+    this.setNext(
+      this.#reducer(this.getSnapshot().value, psn.value),
+      updateToken,
+    );
+  }
+}

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

@@ -1,9 +1,17 @@
+// Sumi bans classes, `this`, method syntax and writes to `this` outside a
+// `mut_` binding; an observable is a class (`ObservableBaseClass` says why),
+// so those rules are waived here (D-63).
+// @sumi-expect-error-file classes/no-class
+// @sumi-expect-error-file banned-syntax/no-this
+// @sumi-expect-error-file functions/prefer-arrow-function
+// @sumi-expect-error-file mutation/no-mutation-without-mut-prefix
 import { Optional } from 'ts-data-forge';
-import { createSyncChildObservable } from '../base/index.mjs';
+import { SyncChildObservableClass } from '../class/index.mjs';
 import type {
   KeepInitialValueOperator,
   Observable,
   SkipIfNoChangeOperatorObservable,
+  UpdateToken,
 } from '../types/index.mjs';
 
 /**
@@ -72,7 +80,7 @@ export const skipIfNoChange = <A,>(
 ): KeepInitialValueOperator<A, A> =>
   // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
   ((parentObservable) =>
-    createSkipIfNoChangeObservable(
+    new SkipIfNoChangeObservableClass(
       parentObservable,
       eq,
     )) as KeepInitialValueOperator<A, A>;
@@ -83,40 +91,46 @@ export const skipIfNoChange = <A,>(
  */
 export const distinctUntilChanged = skipIfNoChange;
 
-const createSkipIfNoChangeObservable = <A,>(
-  parentObservable: Observable<A>,
-  eq: (x: A, y: A) => boolean,
-): SkipIfNoChangeOperatorObservable<A> =>
-  createSyncChildObservable(
-    {
+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({
       parents: [parentObservable],
       initialValue: parentObservable.getSnapshot(),
-    },
-    ({ setNext }) => {
-      // parentObservable.snapshot has value
-      // if parentObservable is InitializedObservable
-      let mut_previousValue: Optional<A> = parentObservable.getSnapshot();
+    });
+
+    // parentObservable.snapshot has value
+    // if parentObservable is InitializedObservable
+    this.#mut_previousValue = parentObservable.getSnapshot();
+
+    this.#eq = eq;
+
+    this.attach();
+  }
+
+  override tryUpdate(updateToken: UpdateToken): void {
+    const par = this.parents[0];
 
-      return (updateToken) => {
-        const sn = parentObservable.getSnapshot();
+    const sn = par.getSnapshot();
 
-        if (
-          parentObservable.updateToken !== updateToken ||
-          Optional.isNone(sn)
-        ) {
-          return; // skip update
-        }
+    if (par.updateToken !== updateToken || Optional.isNone(sn)) {
+      return; // skip update
+    }
 
-        const prev = mut_previousValue;
+    const prev = this.#mut_previousValue;
 
-        const cond = Optional.isNone(prev) || !eq(prev.value, sn.value);
+    const cond = Optional.isNone(prev) || !this.#eq(prev.value, sn.value);
 
-        // NOTE: Must update before setNext, otherwise Optional.isNone(prev) remains true when tryUpdate is called consecutively
-        mut_previousValue = sn;
+    // NOTE: Must update before setNext, otherwise Optional.isNone(prev) remains true when tryUpdate is called consecutively
+    this.#mut_previousValue = sn;
 
-        if (cond) {
-          setNext(sn.value, updateToken);
-        }
-      };
-    },
-  );
+    if (cond) {
+      this.setNext(sn.value, updateToken);
+    }
+  }
+}

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

@@ -1,9 +1,18 @@
+// Sumi bans classes, `this`, method syntax and writes to `this` outside a
+// `mut_` binding; an observable is a class (`ObservableBaseClass` says why),
+// so those rules are waived here (D-63).
+// @sumi-expect-error-file classes/no-class
+// @sumi-expect-error-file banned-syntax/no-this
+// @sumi-expect-error-file functions/prefer-arrow-function
+// @sumi-expect-error-file mutation/no-mutation-without-mut-prefix
 import { Optional } from 'ts-data-forge';
-import { createSyncChildObservable } from '../base/index.mjs';
+import { SyncChildObservableClass } from '../class/index.mjs';
 import type {
   DropInitialValueOperator,
   Observable,
   SkipUntilOperatorObservable,
+  Subscription,
+  UpdateToken,
 } from '../types/index.mjs';
 
 /**
@@ -59,43 +68,60 @@ import type {
 export const skipUntil =
   <A,>(notifier: Observable<unknown>): DropInitialValueOperator<A, A> =>
   (parentObservable) =>
-    createSkipUntilObservable(parentObservable, notifier);
+    new SkipUntilObservableClass(parentObservable, notifier);
 
-const createSkipUntilObservable = <A,>(
-  parentObservable: Observable<A>,
-  notifier: Observable<unknown>,
-): SkipUntilOperatorObservable<A> => {
-  let mut_isSkipping = true;
+class SkipUntilObservableClass<A>
+  extends SyncChildObservableClass<A, readonly [A]>
+  implements SkipUntilOperatorObservable<A>
+{
+  #mut_isSkipping: boolean;
+  #mut_subscription: Subscription | undefined;
 
-  const observable = createSyncChildObservable<A, readonly [A]>(
-    {
+  constructor(parentObservable: Observable<A>, notifier: Observable<unknown>) {
+    super({
       parents: [parentObservable],
       initialValue: Optional.none,
-    },
-    ({ setNext }) =>
-      (updateToken) => {
-        const sn = parentObservable.getSnapshot();
+    });
 
-        if (
-          mut_isSkipping ||
-          parentObservable.updateToken !== updateToken ||
-          Optional.isNone(sn)
-        ) {
-          return; // skip update
-        }
+    // A notifier that already holds a value, or has completed, would stop
+    // the skipping inside `subscribe`, before the subscription is stored.
+    this.#mut_isSkipping =
+      Optional.isNone(notifier.getSnapshot()) && !notifier.isCompleted;
 
-        setNext(sn.value, updateToken);
-      },
-  );
+    this.#mut_subscription = undefined;
 
-  notifier.subscribe(
-    () => {
-      mut_isSkipping = false;
-    },
-    () => {
-      mut_isSkipping = false;
-    },
-  );
+    if (this.#mut_isSkipping) {
+      const stopSkipping = (): void => {
+        this.#mut_isSkipping = false;
 
-  return observable;
-};
+        this.#mut_subscription?.unsubscribe();
+
+        this.#mut_subscription = undefined;
+      };
+
+      this.#mut_subscription = notifier.subscribe(stopSkipping, stopSkipping);
+    }
+
+    this.attach();
+  }
+
+  override tryUpdate(updateToken: UpdateToken): void {
+    const par = this.parents[0];
+
+    const sn = par.getSnapshot();
+
+    if (
+      this.#mut_isSkipping ||
+      par.updateToken !== updateToken ||
+      Optional.isNone(sn)
+    ) {
+      return; // skip update
+    }
+
+    this.setNext(sn.value, updateToken);
+  }
+
+  protected override teardown(): void {
+    this.#mut_subscription?.unsubscribe();
+  }
+}

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

@@ -1,9 +1,17 @@
+// Sumi bans classes, `this`, method syntax and writes to `this` outside a
+// `mut_` binding; an observable is a class (`ObservableBaseClass` says why),
+// so those rules are waived here (D-63).
+// @sumi-expect-error-file classes/no-class
+// @sumi-expect-error-file banned-syntax/no-this
+// @sumi-expect-error-file functions/prefer-arrow-function
+// @sumi-expect-error-file mutation/no-mutation-without-mut-prefix
 import { Optional, SafeUint, asSafeUint, pipe } from 'ts-data-forge';
-import { createSyncChildObservable } from '../base/index.mjs';
+import { SyncChildObservableClass } from '../class/index.mjs';
 import type {
   DropInitialValueOperator,
   Observable,
   SkipWhileOperatorObservable,
+  UpdateToken,
 } from '../types/index.mjs';
 
 /**
@@ -69,46 +77,56 @@ export const skipWhile =
     predicate: (value: A, index: SafeUint | -1) => boolean,
   ): DropInitialValueOperator<A, A> =>
   (parentObservable) =>
-    createSkipWhileObservable(parentObservable, predicate);
+    new SkipWhileObservableClass(parentObservable, predicate);
 
 /* implementation */
 
-const createSkipWhileObservable = <A,>(
-  parentObservable: Observable<A>,
-  predicate: (value: A, index: SafeUint | -1) => boolean,
-): SkipWhileOperatorObservable<A> =>
-  createSyncChildObservable(
-    {
+class SkipWhileObservableClass<A>
+  extends SyncChildObservableClass<A, readonly [A]>
+  implements SkipWhileOperatorObservable<A>
+{
+  readonly #predicate: (value: A, index: SafeUint | -1) => boolean;
+  #mut_index: SafeUint | -1;
+  #mut_isSkipping: boolean;
+
+  constructor(
+    parentObservable: Observable<A>,
+    predicate: (value: A, index: SafeUint | -1) => boolean,
+  ) {
+    super({
       parents: [parentObservable],
       initialValue: pipe(parentObservable.getSnapshot()).map((sn) =>
         Optional.isNone(sn) || predicate(sn.value, -1) ? Optional.none : sn,
       ).value,
-    },
-    ({ setNext }) => {
-      let mut_index: SafeUint | -1 = -1;
+    });
+
+    this.#mut_index = -1;
+
+    this.#mut_isSkipping = true;
+
+    this.#predicate = predicate;
+
+    this.attach();
+  }
 
-      let mut_skipping = true;
+  override tryUpdate(updateToken: UpdateToken): void {
+    const par = this.parents[0];
 
-      return (updateToken) => {
-        const sn = parentObservable.getSnapshot();
+    const sn = par.getSnapshot();
 
-        if (
-          parentObservable.updateToken !== updateToken ||
-          Optional.isNone(sn)
-        ) {
-          return; // skip update
-        }
+    if (par.updateToken !== updateToken || Optional.isNone(sn)) {
+      return; // skip update
+    }
 
-        mut_index =
-          mut_index === -1 ? asSafeUint(0) : SafeUint.add(1, mut_index);
+    this.#mut_index =
+      this.#mut_index === -1 ? asSafeUint(0) : SafeUint.add(1, this.#mut_index);
 
-        if (!predicate(sn.value, mut_index)) {
-          mut_skipping = false;
-        }
+    if (!this.#predicate(sn.value, this.#mut_index)) {
+      this.#mut_isSkipping = false;
+    }
 
-        if (!mut_skipping) {
-          setNext(sn.value, updateToken);
-        }
-      };
-    },
-  );
+    if (!this.#mut_isSkipping) {
+      this.setNext(sn.value, updateToken);
+    }
+  }
+}