synstate 3.4.0 → 4.0.0

package/src/core/operators/inner-ownership.test.mts

@@ -0,0 +1,280 @@
+import { source } from '../create/index.mjs';
+import { createScope } from '../scope/index.mjs';
+import { map } from './map.mjs';
+import { mergeMap } from './merge-map.mjs';
+import { switchMap } from './switch-map.mjs';
+
+describe('switchMap releases only the inner observables its projection created (#2335)', () => {
+  test('a shared inner survives a switch', () => {
+    const user$ = source<'a' | 'b'>();
+
+    const a$ = source<number>();
+
+    const b$ = source<number>();
+
+    const current$ = user$.pipe(switchMap((u) => (u === 'a' ? a$ : b$)));
+
+    const mut_current: number[] = [];
+
+    current$.subscribe((v) => {
+      mut_current.push(v);
+    });
+
+    const mut_others: number[] = [];
+
+    a$.subscribe((v) => {
+      mut_others.push(v);
+    });
+
+    user$.next('a');
+
+    a$.next(1);
+
+    user$.next('b');
+
+    assert.isFalse(a$.isCompleted);
+
+    a$.next(2);
+
+    b$.next(3);
+
+    assert.deepStrictEqual(mut_others, [1, 2]);
+
+    assert.deepStrictEqual(mut_current, [1, 3]);
+  });
+
+  test('a shared inner survives the completion of switchMap', () => {
+    const user$ = source<'a'>();
+
+    const a$ = source<number>();
+
+    const current$ = user$.pipe(switchMap(() => a$));
+
+    current$.subscribe(() => {});
+
+    user$.next('a');
+
+    current$.complete();
+
+    assert.isFalse(a$.isCompleted);
+
+    const mut_others: number[] = [];
+
+    a$.subscribe((v) => {
+      mut_others.push(v);
+    });
+
+    a$.next(1);
+
+    assert.deepStrictEqual(mut_others, [1]);
+  });
+
+  test('a node derived in the projection from a shared observable is released, and the shared one survives', () => {
+    const user$ = source<number>();
+
+    const shared$ = source<number>();
+
+    const mut_derived: { isCompleted: boolean }[] = [];
+
+    const current$ = user$.pipe(
+      switchMap((u) => {
+        const derived$ = shared$.pipe(map((x) => x + u));
+
+        mut_derived.push(derived$);
+
+        return derived$;
+      }),
+    );
+
+    current$.subscribe(() => {});
+
+    user$.next(1);
+
+    user$.next(2);
+
+    assert.deepStrictEqual(
+      mut_derived.map((o) => o.isCompleted),
+      [true, false],
+    );
+
+    assert.isFalse(shared$.isCompleted);
+
+    current$.complete();
+
+    assert.deepStrictEqual(
+      mut_derived.map((o) => o.isCompleted),
+      [true, true],
+    );
+
+    assert.isFalse(shared$.isCompleted);
+  });
+
+  test('every node the projection created is released on a switch, not only the returned one', () => {
+    const user$ = source<number>();
+
+    const mut_created: { isCompleted: boolean }[] = [];
+
+    const current$ = user$.pipe(
+      switchMap((u) => {
+        const inner$ = source<number>();
+
+        const mapped$ = inner$.pipe(map((x) => x + u));
+
+        mut_created.push(inner$, mapped$);
+
+        return mapped$;
+      }),
+    );
+
+    current$.subscribe(() => {});
+
+    user$.next(1);
+
+    user$.next(2);
+
+    assert.deepStrictEqual(
+      mut_created.map((o) => o.isCompleted),
+      [true, true, false, false],
+    );
+
+    current$.complete();
+
+    assert.deepStrictEqual(
+      mut_created.map((o) => o.isCompleted),
+      [true, true, true, true],
+    );
+  });
+});
+
+describe('the scope switchMap and mergeMap were created in (#2335)', () => {
+  test('disposing it releases what their projections created, and the shared inners survive', () => {
+    const user$ = source<number>();
+
+    const shared$ = source<number>();
+
+    const mut_created: { isCompleted: boolean }[] = [];
+
+    const scope = createScope();
+
+    scope.run(() => {
+      user$
+        .pipe(
+          switchMap(() => {
+            const inner$ = source<number>();
+
+            mut_created.push(inner$);
+
+            return inner$;
+          }),
+        )
+        .subscribe(() => {});
+
+      user$.pipe(mergeMap(() => shared$)).subscribe(() => {});
+    });
+
+    user$.next(1);
+
+    assert.deepStrictEqual(
+      mut_created.map((o) => o.isCompleted),
+      [false],
+    );
+
+    scope.dispose();
+
+    assert.deepStrictEqual(
+      mut_created.map((o) => o.isCompleted),
+      [true],
+    );
+
+    assert.isFalse(shared$.isCompleted);
+
+    assert.isFalse(user$.isCompleted);
+  });
+});
+
+describe('mergeMap releases only the inner observables its projection created (#2335)', () => {
+  test('a shared inner survives the completion of mergeMap', () => {
+    const user$ = source<'a' | 'b'>();
+
+    const a$ = source<number>();
+
+    const b$ = source<number>();
+
+    const merged$ = user$.pipe(mergeMap((u) => (u === 'a' ? a$ : b$)));
+
+    const mut_merged: number[] = [];
+
+    merged$.subscribe((v) => {
+      mut_merged.push(v);
+    });
+
+    user$.next('a');
+
+    user$.next('b');
+
+    a$.next(1);
+
+    b$.next(2);
+
+    assert.deepStrictEqual(mut_merged, [1, 2]);
+
+    merged$.complete();
+
+    assert.isFalse(a$.isCompleted);
+
+    assert.isFalse(b$.isCompleted);
+
+    const mut_others: number[] = [];
+
+    a$.subscribe((v) => {
+      mut_others.push(v);
+    });
+
+    a$.next(3);
+
+    // A new subscriber receives the current value first.
+    assert.deepStrictEqual(mut_others, [1, 3]);
+
+    assert.deepStrictEqual(mut_merged, [1, 2]);
+  });
+
+  test('every node the projection created is released on completion', () => {
+    const user$ = source<number>();
+
+    const shared$ = source<number>();
+
+    const mut_created: { isCompleted: boolean }[] = [];
+
+    const merged$ = user$.pipe(
+      mergeMap((u) => {
+        const inner$ = source<number>();
+
+        const derived$ = shared$.pipe(map((x) => x + u));
+
+        mut_created.push(inner$, derived$);
+
+        return inner$;
+      }),
+    );
+
+    merged$.subscribe(() => {});
+
+    user$.next(1);
+
+    user$.next(2);
+
+    assert.deepStrictEqual(
+      mut_created.map((o) => o.isCompleted),
+      [false, false, false, false],
+    );
+
+    merged$.complete();
+
+    assert.deepStrictEqual(
+      mut_created.map((o) => o.isCompleted),
+      [true, true, true, true],
+    );
+
+    assert.isFalse(shared$.isCompleted);
+  });
+});

package/src/core/operators/map.mts

@@ -1,11 +1,19 @@
+// 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, expectType } from 'ts-data-forge';
-import { createSyncChildObservable } from '../base/index.mjs';
+import { SyncChildObservableClass } from '../class/index.mjs';
 import { source } from '../create/index.mjs';
 import type {
   InitializedObservable,
   KeepInitialValueOperator,
   MapOperatorObservable,
   Observable,
+  UpdateToken,
 } from '../types/index.mjs';
 import { withInitialValue } from './with-initial-value.mjs';
 
@@ -52,44 +60,53 @@ export const map = <A, B>(
 ): KeepInitialValueOperator<A, B> =>
   // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
   ((parentObservable) =>
-    createMapObservable(parentObservable, mapFn)) as KeepInitialValueOperator<
-    A,
-    B
-  >;
+    new MapObservableClass(
+      parentObservable,
+      mapFn,
+    )) as KeepInitialValueOperator<A, B>;
 
 /* implementation */
 
-const createMapObservable = <A, B>(
-  parentObservable: Observable<A>,
-  mapFn: (x: A, index: SafeUint | -1) => B,
-): MapOperatorObservable<A, B> =>
-  createSyncChildObservable(
-    {
+class MapObservableClass<A, B>
+  extends SyncChildObservableClass<B, readonly [A]>
+  implements MapOperatorObservable<A, B>
+{
+  readonly #mapFn: (x: A, index: SafeUint | -1) => B;
+  #mut_index: SafeUint | -1;
+
+  constructor(
+    parentObservable: Observable<A>,
+    mapFn: (x: A, index: SafeUint | -1) => B,
+  ) {
+    super({
       parents: [parentObservable],
       initialValue: Optional.map(parentObservable.getSnapshot(), (x) =>
         mapFn(x, -1),
       ),
-    },
-    ({ setNext }) => {
-      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);
-
-        setNext(mapFn(sn.value, mut_index), updateToken);
-      };
-    },
-  );
+    });
+
+    this.#mut_index = -1;
+
+    this.#mapFn = mapFn;
+
+    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);
+
+    this.setNext(this.#mapFn(sn.value, this.#mut_index), updateToken);
+  }
+}
 
 if (import.meta.vitest !== undefined) {
   test('type test', () => {

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
@@ -104,7 +119,7 @@ export const mergeMap =
     mapToObservable: (curr: A) => Observable<B>,
   ): DropInitialValueOperator<A, B> =>
   (parentObservable) =>
-    createMergeMapObservable(parentObservable, mapToObservable);
+    new MergeMapObservableClass(parentObservable, mapToObservable);
 
 /**
  * Alias for `mergeMap`.
@@ -112,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);
+    }
+  }
+}