synstate 3.3.0 → 4.0.0

package/src/core/operators/debounce.mts

@@ -1,16 +1,27 @@
+// 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 type {
   DebounceOperatorObservable,
   KeepInitialValueOperator,
   Observable,
   TimerId,
+  UpdateToken,
 } from '../types/index.mjs';
 
 /**
  * Delays emissions from the source observable until a specified time has passed without another emission.
  * Useful for handling user input events like typing or scrolling.
  *
+ * Completing it, or its source completing, passes on the value its timer is
+ * still holding before the completion; `dispose()` drops that value.
+ *
  * @template A - The type of values from the source
  * @param milliSeconds - The debounce duration in milliseconds
  * @returns An operator that debounces the observable
@@ -97,50 +108,80 @@ export const debounce = <A,>(
 ): KeepInitialValueOperator<A, A> =>
   // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
   ((parentObservable) =>
-    createDebounceObservable(
+    new DebounceObservableClass(
       parentObservable,
       milliSeconds,
     )) as KeepInitialValueOperator<A, A>;
 
-const createDebounceObservable = <A,>(
-  parentObservable: Observable<A>,
-  milliSeconds: number,
-): DebounceOperatorObservable<A> => {
-  let mut_timerId: TimerId | undefined = undefined;
+class DebounceObservableClass<A>
+  extends AsyncChildObservableClass<A, readonly [A]>
+  implements DebounceOperatorObservable<A>
+{
+  readonly #milliSeconds: number;
+  #mut_timerId: TimerId | undefined;
 
-  const resetTimer = (): void => {
-    if (mut_timerId !== undefined) {
-      clearTimeout(mut_timerId);
-    }
-  };
+  /** The value the running timer will pass on. */
+  #mut_pending: Optional<A>;
 
-  return createAsyncChildObservable(
-    {
+  constructor(parentObservable: Observable<A>, milliSeconds: number) {
+    super({
       parents: [parentObservable],
       initialValue: parentObservable.getSnapshot(),
-      onComplete: resetTimer,
-    },
-    ({ startUpdate }) =>
-      (updateToken) => {
-        const sn = parentObservable.getSnapshot();
-
-        if (
-          parentObservable.updateToken !== updateToken ||
-          Optional.isNone(sn)
-        ) {
-          return; // skip update
-        }
-
-        resetTimer();
-
-        // set timer
-        mut_timerId = setTimeout(() => {
-          if (Optional.isNone(sn)) {
-            return;
-          }
-
-          startUpdate(sn.value);
-        }, milliSeconds);
-      },
-  );
-};
+    });
+
+    this.#mut_timerId = undefined;
+
+    this.#mut_pending = Optional.none;
+
+    this.#milliSeconds = milliSeconds;
+
+    this.attach();
+  }
+
+  #resetTimer(): void {
+    if (this.#mut_timerId !== undefined) {
+      clearTimeout(this.#mut_timerId);
+
+      this.#mut_timerId = undefined;
+    }
+
+    this.#mut_pending = Optional.none;
+  }
+
+  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.#resetTimer();
+
+    this.#mut_pending = sn;
+
+    // set timer
+    this.#mut_timerId = setTimeout(() => {
+      this.#mut_timerId = undefined;
+
+      this.#mut_pending = Optional.none;
+
+      this.startUpdate(sn.value);
+    }, this.#milliSeconds);
+  }
+
+  protected override flush(): void {
+    const pending = this.#mut_pending;
+
+    this.#resetTimer();
+
+    if (Optional.isSome(pending)) {
+      this.startUpdate(pending.value);
+    }
+  }
+
+  protected override teardown(): void {
+    this.#resetTimer();
+  }
+}

package/src/core/operators/filter.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 {
   asSafeUint,
   expectType,
@@ -7,13 +14,14 @@ import {
   pipe,
   SafeUint,
 } 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,
   FilterOperatorObservable,
   InitializedObservable,
   Observable,
+  UpdateToken,
 } from '../types/index.mjs';
 import { withInitialValue } from './with-initial-value.mjs';
 
@@ -83,15 +91,21 @@ export function filter<A>(
   predicate: (value: A, index: SafeUint | -1) => boolean,
 ): DropInitialValueOperator<A, A> {
   return (parentObservable) =>
-    createFilterObservable(parentObservable, predicate);
+    new FilterObservableClass(parentObservable, predicate);
 }
 
-const createFilterObservable = <A,>(
-  parentObservable: Observable<A>,
-  predicate: (x: A, index: SafeUint | -1) => boolean,
-): FilterOperatorObservable<A> =>
-  createSyncChildObservable(
-    {
+class FilterObservableClass<A>
+  extends SyncChildObservableClass<A, readonly [A]>
+  implements FilterOperatorObservable<A>
+{
+  readonly #predicate: (x: A, index: SafeUint | -1) => boolean;
+  #mut_index: SafeUint | -1;
+
+  constructor(
+    parentObservable: Observable<A>,
+    predicate: (x: A, index: SafeUint | -1) => boolean,
+  ) {
+    super({
       parents: [parentObservable],
       initialValue: pipe(parentObservable.getSnapshot()).map((sn) =>
         Optional.isNone(sn)
@@ -100,29 +114,32 @@ const createFilterObservable = <A,>(
             ? sn
             : Optional.none,
       ).value,
-    },
-    ({ 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);
-
-        if (predicate(sn.value, mut_index)) {
-          setNext(sn.value, updateToken);
-        }
-      };
-    },
-  );
+    });
+
+    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);
+    }
+  }
+}
 
 if (import.meta.vitest !== undefined) {
   test('type test', () => {

package/src/core/operators/index.mts

@@ -11,6 +11,7 @@ export * from './skip-while.mjs';
 export * from './switch-map.mjs';
 export * from './take-until.mjs';
 export * from './take-while.mjs';
+export * from './take.mjs';
 export * from './throttle.mjs';
 export * from './with-buffered-from.mjs';
 export * from './with-current-value-from.mjs';

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', () => {