synstate 3.4.0 → 4.0.0

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,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 { createSyncChildObservable } from '../base/index.mjs';
+import { SyncChildObservableClass } from '../class/index.mjs';
 import type {
   DropInitialValueOperator,
   Observable,
   SkipUntilOperatorObservable,
   Subscription,
+  UpdateToken,
 } from '../types/index.mjs';
 
 /**
@@ -60,54 +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> => {
-  // A notifier that already holds a value, or has completed, would call
-  // `stopSkipping` inside `subscribe`, before the subscription is stored.
-  let mut_isSkipping =
-    Optional.isNone(notifier.getSnapshot()) && !notifier.isCompleted;
+class SkipUntilObservableClass<A>
+  extends SyncChildObservableClass<A, readonly [A]>
+  implements SkipUntilOperatorObservable<A>
+{
+  #mut_isSkipping: boolean;
+  #mut_subscription: Subscription | undefined;
 
-  let mut_subscription: Subscription | undefined = undefined;
+  constructor(parentObservable: Observable<A>, notifier: Observable<unknown>) {
+    super({
+      parents: [parentObservable],
+      initialValue: Optional.none,
+    });
 
-  const stopSkipping = (): void => {
-    mut_isSkipping = false;
+    // 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;
 
-    mut_subscription?.unsubscribe();
+    this.#mut_subscription = undefined;
 
-    mut_subscription = undefined;
-  };
+    if (this.#mut_isSkipping) {
+      const stopSkipping = (): void => {
+        this.#mut_isSkipping = false;
 
-  const observable = createSyncChildObservable<A, readonly [A]>(
-    {
-      parents: [parentObservable],
-      initialValue: Optional.none,
-      onComplete: () => {
-        mut_subscription?.unsubscribe();
-      },
-    },
-    ({ setNext }) =>
-      (updateToken) => {
-        const sn = parentObservable.getSnapshot();
+        this.#mut_subscription?.unsubscribe();
+
+        this.#mut_subscription = undefined;
+      };
 
-        if (
-          mut_isSkipping ||
-          parentObservable.updateToken !== updateToken ||
-          Optional.isNone(sn)
-        ) {
-          return; // skip update
-        }
+      this.#mut_subscription = notifier.subscribe(stopSkipping, stopSkipping);
+    }
 
-        setNext(sn.value, updateToken);
-      },
-  );
+    this.attach();
+  }
+
+  override tryUpdate(updateToken: UpdateToken): void {
+    const par = this.parents[0];
+
+    const sn = par.getSnapshot();
 
-  if (mut_isSkipping) {
-    mut_subscription = notifier.subscribe(stopSkipping, stopSkipping);
+    if (
+      this.#mut_isSkipping ||
+      par.updateToken !== updateToken ||
+      Optional.isNone(sn)
+    ) {
+      return; // skip update
+    }
+
+    this.setNext(sn.value, updateToken);
   }
 
-  return observable;
-};
+  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);
+    }
+  }
+}

package/src/core/operators/switch-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 { 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,
   Observable,
+  Scope,
   Subscription,
   SwitchMapOperatorObservable,
+  UpdateToken,
 } from '../types/index.mjs';
 
 /**
  * Projects each source value to an observable, subscribes to it, and emits its values.
  * When a new value arrives from the source, the previous inner observable is unsubscribed.
  *
+ * The projection runs in a scope of its own (see `createScope`): what it
+ * creates is disposed when the next value switches away from it and when
+ * `switchMap` 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
@@ -102,50 +117,74 @@ export const switchMap =
     mapToObservable: (curr: A) => Observable<B>,
   ): DropInitialValueOperator<A, B> =>
   (parentObservable) =>
-    createSwitchMapObservable(parentObservable, mapToObservable);
+    new SwitchMapObservableClass(parentObservable, mapToObservable);
+
+class SwitchMapObservableClass<A, B>
+  extends AsyncChildObservableClass<B, readonly [A]>
+  implements SwitchMapOperatorObservable<A, B>
+{
+  readonly #mapToObservable: (curr: A) => Observable<B>;
 
-const createSwitchMapObservable = <A, B>(
-  parentObservable: Observable<A>,
-  mapToObservable: (curr: A) => Observable<B>,
-): SwitchMapOperatorObservable<A, B> => {
-  let mut_observable: Observable<B> | undefined = undefined;
+  /**
+   * The scope the operator was created in, so that each inner scope is
+   * disposed with it; the projection itself runs during propagation, when the
+   * current scope is whatever happens to be running.
+   */
+  readonly #ownerScope: Scope | undefined;
 
-  let mut_subscription: Subscription | undefined = undefined;
+  #mut_innerScope: Scope | undefined;
+  #mut_subscription: Subscription | undefined;
 
-  return createAsyncChildObservable(
-    {
+  constructor(
+    parentObservable: Observable<A>,
+    mapToObservable: (curr: A) => Observable<B>,
+  ) {
+    super({
       parents: [parentObservable],
       initialValue: Optional.none,
-      onComplete: () => {
-        mut_subscription?.unsubscribe();
+    });
+
+    this.#mapToObservable = mapToObservable;
+
+    this.#ownerScope = getCurrentScope();
+
+    this.#mut_innerScope = undefined;
+
+    this.#mut_subscription = undefined;
+
+    this.attach();
+  }
+
+  /** Releases the inner observable, and only the one this operator made. */
+  #releaseInner(): void {
+    this.#mut_subscription?.unsubscribe();
+
+    this.#mut_innerScope?.dispose();
+  }
+
+  override tryUpdate(updateToken: UpdateToken): void {
+    const par = this.parents[0];
 
-        mut_observable?.complete();
-      },
-    },
-    ({ startUpdate }) =>
-      (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_observable?.complete();
+    this.#releaseInner();
 
-        mut_subscription?.unsubscribe();
+    const innerScope = createScope(this.#ownerScope);
 
-        const observable = mapToObservable(sn.value);
+    this.#mut_innerScope = innerScope;
 
-        mut_observable = observable;
+    const observable = innerScope.run(() => this.#mapToObservable(sn.value));
 
-        const subscription = observable.subscribe((curr) => {
-          startUpdate(curr);
-        });
+    this.#mut_subscription = observable.subscribe((curr) => {
+      this.startUpdate(curr);
+    });
+  }
 
-        mut_subscription = subscription;
-      },
-  );
-};
+  protected override teardown(): void {
+    this.#releaseInner();
+  }
+}

package/src/core/operators/take-until-skip-until-teardown.test.mts

@@ -1,7 +1,8 @@
+import { toNode } from '../class/index.mjs';
 import { source } from '../create/index.mjs';
-import { take } from '../predefined/index.mjs';
 import { skipUntil } from './skip-until.mjs';
 import { takeUntil } from './take-until.mjs';
+import { take } from './take.mjs';
 
 describe('takeUntil releases the notifier', () => {
   test('when the result is completed before the notifier emits', () => {
@@ -9,11 +10,11 @@ describe('takeUntil releases the notifier', () => {
 
     const result$ = source<number>().pipe(takeUntil(notifier$));
 
-    assert.isTrue(notifier$.hasSubscriber);
+    assert.isTrue(toNode(notifier$).hasSubscriber);
 
     result$.complete();
 
-    assert.isFalse(notifier$.hasSubscriber);
+    assert.isFalse(toNode(notifier$).hasSubscriber);
   });
 
   test('when the parent completes', () => {
@@ -25,15 +26,17 @@ describe('takeUntil releases the notifier', () => {
 
     num$.complete();
 
-    assert.isFalse(notifier$.hasSubscriber);
+    assert.isFalse(toNode(notifier$).hasSubscriber);
   });
 
-  test('when the downstream completes', () => {
+  test('not when the downstream completes', () => {
     const notifier$ = source<undefined>();
 
     const num$ = source<number>();
 
-    const taken$ = num$.pipe(takeUntil(notifier$)).pipe(take(1));
+    const result$ = num$.pipe(takeUntil(notifier$));
+
+    const taken$ = result$.pipe(take(1));
 
     taken$.subscribe(() => {});
 
@@ -44,7 +47,10 @@ describe('takeUntil releases the notifier', () => {
 
     assert.isTrue(taken$.isCompleted);
 
-    assert.isFalse(notifier$.hasSubscriber);
+    // Completion flows only downstream, so `takeUntil` is still running.
+    assert.isFalse(result$.isCompleted);
+
+    assert.isTrue(toNode(notifier$).hasSubscriber);
   });
 
   test('when the notifier emits', () => {
@@ -56,7 +62,7 @@ describe('takeUntil releases the notifier', () => {
 
     assert.isTrue(result$.isCompleted);
 
-    assert.isFalse(notifier$.hasSubscriber);
+    assert.isFalse(toNode(notifier$).hasSubscriber);
   });
 
   test('when the notifier has already emitted', () => {
@@ -66,7 +72,7 @@ describe('takeUntil releases the notifier', () => {
 
     assert.isTrue(result$.isCompleted);
 
-    assert.isFalse(notifier$.hasSubscriber);
+    assert.isFalse(toNode(notifier$).hasSubscriber);
   });
 });
 
@@ -88,7 +94,7 @@ describe('skipUntil releases the notifier', () => {
 
     notifier$.next(undefined);
 
-    assert.isFalse(notifier$.hasSubscriber);
+    assert.isFalse(toNode(notifier$).hasSubscriber);
 
     num$.next(2);
 
@@ -108,7 +114,7 @@ describe('skipUntil releases the notifier', () => {
       mut_history.push(x);
     });
 
-    assert.isFalse(notifier$.hasSubscriber);
+    assert.isFalse(toNode(notifier$).hasSubscriber);
 
     num$.next(1);
 
@@ -122,6 +128,6 @@ describe('skipUntil releases the notifier', () => {
 
     result$.complete();
 
-    assert.isFalse(notifier$.hasSubscriber);
+    assert.isFalse(toNode(notifier$).hasSubscriber);
   });
 });