synstate 3.3.0 → 4.0.0

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
@@ -96,59 +111,80 @@ import type {
  *   'C3',
  * ]);
  * ```
- *
- * @note To improve code readability, consider using `createState` instead of `switchMap`,
- * subscribe to `parentObservable` and call `setState` within it.
  */
 export const switchMap =
   <A, B>(
     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

@@ -0,0 +1,133 @@
+import { toNode } from '../class/index.mjs';
+import { source } from '../create/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', () => {
+    const notifier$ = source<undefined>();
+
+    const result$ = source<number>().pipe(takeUntil(notifier$));
+
+    assert.isTrue(toNode(notifier$).hasSubscriber);
+
+    result$.complete();
+
+    assert.isFalse(toNode(notifier$).hasSubscriber);
+  });
+
+  test('when the parent completes', () => {
+    const notifier$ = source<undefined>();
+
+    const num$ = source<number>();
+
+    num$.pipe(takeUntil(notifier$));
+
+    num$.complete();
+
+    assert.isFalse(toNode(notifier$).hasSubscriber);
+  });
+
+  test('not when the downstream completes', () => {
+    const notifier$ = source<undefined>();
+
+    const num$ = source<number>();
+
+    const result$ = num$.pipe(takeUntil(notifier$));
+
+    const taken$ = result$.pipe(take(1));
+
+    taken$.subscribe(() => {});
+
+    // `take(n)` completes on the emission after its `n`th.
+    num$.next(1);
+
+    num$.next(2);
+
+    assert.isTrue(taken$.isCompleted);
+
+    // Completion flows only downstream, so `takeUntil` is still running.
+    assert.isFalse(result$.isCompleted);
+
+    assert.isTrue(toNode(notifier$).hasSubscriber);
+  });
+
+  test('when the notifier emits', () => {
+    const notifier$ = source<undefined>();
+
+    const result$ = source<number>().pipe(takeUntil(notifier$));
+
+    notifier$.next(undefined);
+
+    assert.isTrue(result$.isCompleted);
+
+    assert.isFalse(toNode(notifier$).hasSubscriber);
+  });
+
+  test('when the notifier has already emitted', () => {
+    const notifier$ = source<number>(0);
+
+    const result$ = source<number>().pipe(takeUntil(notifier$));
+
+    assert.isTrue(result$.isCompleted);
+
+    assert.isFalse(toNode(notifier$).hasSubscriber);
+  });
+});
+
+describe('skipUntil releases the notifier', () => {
+  test('when the notifier emits', () => {
+    const notifier$ = source<undefined>();
+
+    const num$ = source<number>();
+
+    const result$ = num$.pipe(skipUntil(notifier$));
+
+    const mut_history: number[] = [];
+
+    result$.subscribe((x) => {
+      mut_history.push(x);
+    });
+
+    num$.next(1);
+
+    notifier$.next(undefined);
+
+    assert.isFalse(toNode(notifier$).hasSubscriber);
+
+    num$.next(2);
+
+    assert.deepStrictEqual(mut_history, [2]);
+  });
+
+  test('when the notifier has already emitted', () => {
+    const notifier$ = source<number>(0);
+
+    const num$ = source<number>();
+
+    const result$ = num$.pipe(skipUntil(notifier$));
+
+    const mut_history: number[] = [];
+
+    result$.subscribe((x) => {
+      mut_history.push(x);
+    });
+
+    assert.isFalse(toNode(notifier$).hasSubscriber);
+
+    num$.next(1);
+
+    assert.deepStrictEqual(mut_history, [1]);
+  });
+
+  test('when the result is completed before the notifier emits', () => {
+    const notifier$ = source<undefined>();
+
+    const result$ = source<number>().pipe(skipUntil(notifier$));
+
+    result$.complete();
+
+    assert.isFalse(toNode(notifier$).hasSubscriber);
+  });
+});

package/src/core/operators/take-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 {
   KeepInitialValueOperator,
   Observable,
+  Subscription,
   TakeUntilOperatorObservable,
+  UpdateToken,
 } from '../types/index.mjs';
 
 /**
@@ -59,43 +68,52 @@ export const takeUntil = <A,>(
 ): KeepInitialValueOperator<A, A> =>
   // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
   ((parentObservable) =>
-    createTakeUntilObservable(
+    new TakeUntilObservableClass(
       parentObservable,
       notifier,
     )) as KeepInitialValueOperator<A, A>;
 
-const createTakeUntilObservable = <A,>(
-  parentObservable: Observable<A>,
-  notifier: Observable<unknown>,
-): TakeUntilOperatorObservable<A> => {
-  const observable = createSyncChildObservable<A, readonly [A]>(
-    {
+class TakeUntilObservableClass<A>
+  extends SyncChildObservableClass<A, readonly [A]>
+  implements TakeUntilOperatorObservable<A>
+{
+  /** Unset only while the `subscribe` in the constructor runs. */
+  readonly #subscription: Subscription | undefined;
+
+  constructor(parentObservable: Observable<A>, notifier: Observable<unknown>) {
+    super({
       parents: [parentObservable],
       initialValue: parentObservable.getSnapshot(),
-    },
-    ({ setNext }) =>
-      (updateToken) => {
-        const sn = parentObservable.getSnapshot();
+    });
+
+    const complete = (): void => {
+      this.complete();
+    };
+
+    // A notifier that already holds a value completes this observable inside
+    // `subscribe`, before the subscription is stored.
+    this.#subscription = notifier.subscribe(complete, complete);
+
+    if (this.isCompleted) {
+      this.#subscription.unsubscribe();
+    }
+
+    this.attach();
+  }
+
+  override tryUpdate(updateToken: UpdateToken): void {
+    const par = this.parents[0];
 
-        if (
-          parentObservable.updateToken !== updateToken ||
-          Optional.isNone(sn)
-        ) {
-          return; // skip update
-        }
+    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;
-};
+  protected override teardown(): void {
+    this.#subscription?.unsubscribe();
+  }
+}

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

@@ -1,3 +1,10 @@
+// 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,
@@ -5,13 +12,14 @@ import {
   expectType,
   pipe,
 } from 'ts-data-forge';
-import { createSyncChildObservable } from '../base/index.mjs';
+import { SyncChildObservableClass } from '../class/index.mjs';
 import { source } from '../create/index.mjs';
 import type {
   DropInitialValueOperator,
   InitializedObservable,
   Observable,
   TakeWhileOperatorObservable,
+  UpdateToken,
 } from '../types/index.mjs';
 import { withInitialValue } from './with-initial-value.mjs';
 
@@ -75,16 +83,22 @@ export const takeWhile =
     predicate: (value: A, index: SafeUint | -1) => boolean,
   ): DropInitialValueOperator<A, A> =>
   (parentObservable) =>
-    createTakeWhileObservable(parentObservable, predicate);
+    new TakeWhileObservableClass(parentObservable, predicate);
 
 /* implementation */
 
-const createTakeWhileObservable = <A,>(
-  parentObservable: Observable<A>,
-  predicate: (value: A, index: SafeUint | -1) => boolean,
-): TakeWhileOperatorObservable<A> =>
-  createSyncChildObservable(
-    {
+class TakeWhileObservableClass<A>
+  extends SyncChildObservableClass<A, readonly [A]>
+  implements TakeWhileOperatorObservable<A>
+{
+  readonly #predicate: (value: A, index: SafeUint | -1) => boolean;
+  #mut_index: SafeUint | -1;
+
+  constructor(
+    parentObservable: Observable<A>,
+    predicate: (value: A, index: SafeUint | -1) => boolean,
+  ) {
+    super({
       parents: [parentObservable],
       initialValue: pipe(parentObservable.getSnapshot()).map((par) =>
         Optional.isNone(par)
@@ -93,31 +107,34 @@ const createTakeWhileObservable = <A,>(
             ? par
             : Optional.none,
       ).value,
-    },
-    ({ setNext, complete }) => {
-      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);
-        } else {
-          complete();
-        }
-      };
-    },
-  );
+    });
+
+    this.#mut_index = -1;
+
+    this.#predicate = predicate;
+
+    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
+    }
+
+    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);
+    } else {
+      this.complete();
+    }
+  }
+}
 
 if (import.meta.vitest !== undefined) {
   test('type test', () => {

package/src/core/operators/take.mts

@@ -0,0 +1,138 @@
+// 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, expectType } from 'ts-data-forge';
+import type { PositiveSafeIntWithSmallInt } from 'ts-type-forge';
+import { SyncChildObservableClass } from '../class/index.mjs';
+import { source } from '../create/index.mjs';
+import type {
+  DropInitialValueOperator,
+  InitializedObservable,
+  Observable,
+  TakeOperatorObservable,
+  UpdateToken,
+} from '../types/index.mjs';
+import { withInitialValue } from './with-initial-value.mjs';
+
+/**
+ * Takes only the first `n` emissions from the source observable, then completes.
+ * It completes in the same update as the `n`th emission, after passing that
+ * value on. The initial value is passed on and not counted.
+ *
+ * @template A - The type of values from the source
+ * @param n - The number of values to take
+ * @returns An operator that takes the first n emissions
+ *
+ * @example
+ * ```ts
+ * //  Timeline:
+ * //
+ * //  num$    1     2     3     4 (ignored)
+ * //  taken$  1     2     3|(completes)
+ * //
+ * //  Explanation:
+ * //  - take emits only the first n values, completing with the nth
+ * //  - Subsequent emissions from the source are ignored
+ *
+ * const num$ = source<number>();
+ *
+ * const taken$ = num$.pipe(take(3));
+ *
+ * const valueHistory: number[] = [];
+ *
+ * taken$.subscribe((x) => {
+ *   valueHistory.push(x);
+ * });
+ *
+ * num$.next(1);
+ *
+ * num$.next(2);
+ *
+ * num$.next(3);
+ *
+ * assert.deepStrictEqual(valueHistory, [1, 2, 3]);
+ *
+ * assert.isTrue(taken$.isCompleted);
+ *
+ * num$.next(4); // ignored (already completed)
+ *
+ * assert.deepStrictEqual(valueHistory, [1, 2, 3]);
+ * ```
+ */
+export const take =
+  <A,>(n: PositiveSafeIntWithSmallInt): DropInitialValueOperator<A, A> =>
+  (parentObservable) =>
+    new TakeObservableClass(parentObservable, n);
+
+/* implementation */
+
+class TakeObservableClass<A>
+  extends SyncChildObservableClass<A, readonly [A]>
+  implements TakeOperatorObservable<A>
+{
+  readonly #n: PositiveSafeIntWithSmallInt;
+  #mut_count: number;
+
+  constructor(parentObservable: Observable<A>, n: PositiveSafeIntWithSmallInt) {
+    super({
+      parents: [parentObservable],
+      initialValue: parentObservable.getSnapshot(),
+    });
+
+    this.#mut_count = 0;
+
+    this.#n = n;
+
+    this.attach();
+  }
+
+  override tryUpdate(updateToken: UpdateToken): void {
+    const par = this.parents[0];
+
+    const sn = par.getSnapshot();
+
+    if (
+      this.#mut_count >= this.#n ||
+      par.updateToken !== updateToken ||
+      Optional.isNone(sn)
+    ) {
+      return; // skip update
+    }
+
+    this.#mut_count += 1;
+
+    this.setNext(sn.value, updateToken);
+
+    if (this.#mut_count >= this.#n) {
+      this.completeAfterPropagation();
+    }
+  }
+}
+
+if (import.meta.vitest !== undefined) {
+  test('type test', () => {
+    expect(1).toBe(1); // dummy
+  });
+
+  {
+    const s: Observable<number> = source<number>();
+
+    const _d1 = s.pipe(take(3));
+
+    expectType<typeof _d1, Observable<number>>('=');
+  }
+
+  {
+    const s = source<number>();
+
+    const m: InitializedObservable<number> = s.pipe(withInitialValue(0));
+
+    const _d = m.pipe(take(3));
+
+    expectType<typeof _d, Observable<number>>('=');
+  }
+}