synstate 3.4.0 → 4.1.0

package/src/core/create/empty.test.mts

@@ -0,0 +1,65 @@
+import { Arr, Optional } from 'ts-data-forge';
+import { createState } from '../../utils/index.mjs';
+import { switchMap } from '../operators/index.mjs';
+import { empty } from './empty.mjs';
+
+describe(empty, () => {
+  test('holds no value and is already completed', () => {
+    const nothing$ = empty<number>();
+
+    assert.isTrue(nothing$.isCompleted);
+
+    assert.isTrue(Optional.isNone(nothing$.getSnapshot()));
+  });
+
+  test('passes nothing on to a subscriber, and completes it at once', () => {
+    const nothing$ = empty<number>();
+
+    const mut_seen: number[] = [];
+
+    const mut_completed = { value: false };
+
+    nothing$.subscribe(
+      (value) => {
+        mut_seen.push(value);
+      },
+      () => {
+        mut_completed.value = true;
+      },
+    );
+
+    assert.deepStrictEqual(mut_seen, []);
+
+    assert.isTrue(mut_completed.value);
+  });
+
+  test('switched to, it passes nothing on, and switchMap goes on', () => {
+    const [on$, setOn] = createState(true);
+
+    const [count$, setCount] = createState(0);
+
+    const followed$ = on$.pipe(
+      switchMap((isOn) => (isOn ? count$ : empty<number>())),
+    );
+
+    const mut_seen: number[] = [];
+
+    followed$.subscribe((value) => {
+      mut_seen.push(value);
+    });
+
+    setOn(false);
+
+    const seenBefore = Arr.length(mut_seen);
+
+    setCount(1);
+
+    assert.strictEqual(Arr.length(mut_seen), seenBefore);
+
+    setOn(true);
+
+    assert.deepStrictEqual(Arr.last(mut_seen), Optional.some(1));
+
+    assert.isFalse(followed$.isCompleted);
+  });
+});

package/src/core/create/from-abortable-promise.mts

@@ -1,5 +1,12 @@
+// 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, Result } from 'ts-data-forge';
-import { createRootObservable } from '../base/index.mjs';
+import { RootObservableClass } from '../class/index.mjs';
 import type { FromPromiseObservable } from '../types/index.mjs';
 
 /**
@@ -72,50 +79,55 @@ import type { FromPromiseObservable } from '../types/index.mjs';
 export const fromAbortablePromise = <A, E = unknown>(
   // @sumi-expect-error readonly/require-readonly-parameter
   factory: (signal: AbortSignal) => Promise<A>,
-): FromPromiseObservable<A, E> => {
-  const abortController = new AbortController();
+): FromPromiseObservable<A, E> =>
+  new FromAbortablePromiseObservableClass(factory);
 
-  return createRootObservable<Result<A, E>>(
-    {
-      initialValue: Optional.none,
-      onComplete: () => {
-        abortController.abort();
-      },
-    },
-    ({ startUpdate, isCompleted, complete }) => {
-      const promise = factory(abortController.signal);
+class FromAbortablePromiseObservableClass<A, E = unknown>
+  extends RootObservableClass<Result<A, E>>
+  implements FromPromiseObservable<A, E>
+{
+  readonly #abortController: AbortController;
 
-      promise
-        .then((value) => {
-          if (isCompleted()) {
-            return;
-          }
+  // @sumi-expect-error readonly/require-readonly-parameter
+  constructor(factory: (signal: AbortSignal) => Promise<A>) {
+    super({ initialValue: Optional.none });
+
+    this.#abortController = new AbortController();
+
+    const promise = factory(this.#abortController.signal);
+
+    promise
+      .then((value) => {
+        if (this.isCompleted) {
+          return;
+        }
 
-          startUpdate(Result.ok(value));
-        })
-        .catch((error: unknown) => {
-          if (isCompleted()) {
-            return;
-          }
+        this.startUpdate(Result.ok(value));
+      })
+      .catch((error: unknown) => {
+        if (this.isCompleted) {
+          return;
+        }
 
-          // Silently ignore AbortError — it means the observable was
-          // intentionally completed (e.g., by switchMap).
-          if (error instanceof DOMException && error.name === 'AbortError') {
-            return;
-          }
+        // Silently ignore AbortError — it means the observable was
+        // intentionally completed (e.g., by switchMap).
+        if (error instanceof DOMException && error.name === 'AbortError') {
+          return;
+        }
 
-          startUpdate(
-            Result.err(
-              // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
-              error as E,
-            ),
-          );
-        })
-        .finally(() => {
-          complete();
-        });
+        this.startUpdate(
+          Result.err(
+            // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
+            error as E,
+          ),
+        );
+      })
+      .finally(() => {
+        this.complete();
+      });
+  }
 
-      return {};
-    },
-  );
-};
+  protected override teardown(): void {
+    this.#abortController.abort();
+  }
+}

package/src/core/create/from-promise.mts

@@ -1,5 +1,11 @@
+// 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
 import { Optional, Result } from 'ts-data-forge';
-import { createRootObservable } from '../base/index.mjs';
+import { RootObservableClass } from '../class/index.mjs';
 import type { FromPromiseObservable } from '../types/index.mjs';
 
 /**
@@ -51,34 +57,37 @@ import type { FromPromiseObservable } from '../types/index.mjs';
  */
 export const fromPromise = <A, E = unknown>(
   promise: Promise<A>,
-): FromPromiseObservable<A, E> =>
-  createRootObservable<Result<A, E>>(
-    { initialValue: Optional.none },
-    ({ startUpdate, isCompleted, complete }) => {
-      promise
-        .then((value) => {
-          if (isCompleted()) {
-            return;
-          }
+): FromPromiseObservable<A, E> => new FromPromiseObservableClass(promise);
 
-          startUpdate(Result.ok(value));
-        })
-        .catch((error: unknown) => {
-          if (isCompleted()) {
-            return;
-          }
+class FromPromiseObservableClass<A, E = unknown>
+  extends RootObservableClass<Result<A, E>>
+  implements FromPromiseObservable<A, E>
+{
+  constructor(promise: Promise<A>) {
+    super({ initialValue: Optional.none });
 
-          startUpdate(
-            Result.err(
-              // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
-              error as E,
-            ),
-          );
-        })
-        .finally(() => {
-          complete();
-        });
+    promise
+      .then((value) => {
+        if (this.isCompleted) {
+          return;
+        }
 
-      return {};
-    },
-  );
+        this.startUpdate(Result.ok(value));
+      })
+      .catch((error: unknown) => {
+        if (this.isCompleted) {
+          return;
+        }
+
+        this.startUpdate(
+          Result.err(
+            // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
+            error as E,
+          ),
+        );
+      })
+      .finally(() => {
+        this.complete();
+      });
+  }
+}

package/src/core/create/from-subscribable.mts

@@ -1,5 +1,12 @@
+// 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, Result } from 'ts-data-forge';
-import { createRootObservable } from '../base/index.mjs';
+import { RootObservableClass } from '../class/index.mjs';
 import type {
   FromSubscribableObservable,
   Subscribable,
@@ -66,54 +73,64 @@ import type {
  */
 export const fromSubscribable = <A, E = unknown>(
   subscribable: Subscribable<A>,
-): FromSubscribableObservable<A, E> => {
-  let mut_subscription: Subscription | undefined = undefined;
+): FromSubscribableObservable<A, E> =>
+  new FromSubscribableObservableClass(subscribable);
 
-  // Set once the subscribable has completed: its subscription is over, so
-  // completing this observable must not unsubscribe from it again.
-  let mut_isSourceCompleted = false;
+class FromSubscribableObservableClass<A, E = unknown>
+  extends RootObservableClass<Result<A, E>>
+  implements FromSubscribableObservable<A, E>
+{
+  readonly #mut_subscription: Subscription | undefined;
 
-  const unsubscribe = (): void => {
-    if (!mut_isSourceCompleted) {
-      mut_subscription?.unsubscribe();
-    }
+  /**
+   * Set once the subscribable has completed: its subscription is over, so
+   * completing this observable must not unsubscribe from it again.
+   */
+  #mut_isSourceCompleted: boolean;
+
+  constructor(subscribable: Subscribable<A>) {
+    super({ initialValue: Optional.none });
 
-    mut_subscription = undefined;
-  };
+    this.#mut_subscription = undefined;
 
-  return createRootObservable<Result<A, E>>(
-    { initialValue: Optional.none, onComplete: unsubscribe },
-    ({ startUpdate, isCompleted, complete }) => {
-      const subscription = subscribable.subscribe(
-        (nextValue) => {
-          startUpdate(Result.ok(nextValue));
-        },
-        (error?: unknown) => {
-          startUpdate(
-            Result.err(
-              // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
-              error as E,
-            ),
-          );
-        },
-        () => {
-          mut_isSourceCompleted = true;
+    this.#mut_isSourceCompleted = false;
 
-          complete();
-        },
-      );
+    const subscription = subscribable.subscribe(
+      (nextValue) => {
+        this.startUpdate(Result.ok(nextValue));
+      },
+      (error?: unknown) => {
+        this.startUpdate(
+          Result.err(
+            // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
+            error as E,
+          ),
+        );
+      },
+      () => {
+        this.#mut_isSourceCompleted = true;
 
-      // `subscribe` may have completed this observable before returning
-      // the subscription, so `unsubscribe` above had nothing to release.
-      if (isCompleted()) {
-        if (!mut_isSourceCompleted) {
-          subscription.unsubscribe();
-        }
-      } else {
-        mut_subscription = subscription;
-      }
+        this.complete();
+      },
+    );
+
+    // `subscribe` may have completed this observable already.
+    if (this.isCompleted) {
+      this.#unsubscribe(subscription);
+    } else {
+      this.#mut_subscription = subscription;
+    }
+  }
 
-      return {};
-    },
-  );
-};
+  #unsubscribe(subscription: Subscription): void {
+    if (!this.#mut_isSourceCompleted) {
+      subscription.unsubscribe();
+    }
+  }
+
+  protected override teardown(): void {
+    if (this.#mut_subscription !== undefined) {
+      this.#unsubscribe(this.#mut_subscription);
+    }
+  }
+}

package/src/core/create/from-subscribable.test.mts

@@ -1,5 +1,5 @@
 import { Result } from 'ts-data-forge';
-import { take } from '../predefined/index.mjs';
+import { take } from '../operators/index.mjs';
 import type { Subscribable } from '../types/index.mjs';
 import { fromSubscribable } from './from-subscribable.mjs';
 
@@ -71,7 +71,7 @@ describe(fromSubscribable, () => {
     expect(unsubscribe).not.toHaveBeenCalled();
   });
 
-  test('a child that completes with nothing else using it unsubscribes from the subscribable', () => {
+  test('a child that completes leaves the subscribable subscribed until the observable is completed', () => {
     const { subscribable, emit, unsubscribe } = createManualSubscribable();
 
     const observable$ = fromSubscribable(subscribable);
@@ -86,7 +86,12 @@ describe(fromSubscribable, () => {
 
     assert.isTrue(taken$.isCompleted);
 
-    assert.isTrue(observable$.isCompleted);
+    // Completion flows only downstream.
+    assert.isFalse(observable$.isCompleted);
+
+    expect(unsubscribe).not.toHaveBeenCalled();
+
+    observable$.complete();
 
     expect(unsubscribe).toHaveBeenCalledExactlyOnceWith();
   });

package/src/core/create/index.mts

@@ -1,4 +1,5 @@
 export * from './counter.mjs';
+export * from './empty.mjs';
 export * from './from-abortable-promise.mjs';
 export * from './from-promise.mjs';
 export * from './from-subscribable.mjs';

package/src/core/create/just.mts

@@ -1,5 +1,5 @@
 import { Optional } from 'ts-data-forge';
-import { createRootObservable } from '../base/index.mjs';
+import { RootObservableClass } from '../class/index.mjs';
 import type { InitializedRootObservable } from '../types/index.mjs';
 
 /**
@@ -32,10 +32,9 @@ import type { InitializedRootObservable } from '../types/index.mjs';
  * ```
  */
 export const just = <const A,>(value: A): InitializedRootObservable<A> => {
-  const obs = createRootObservable<A>(
-    { initialValue: Optional.some(value) },
-    () => ({}),
-  );
+  const obs = new RootObservableClass<A>({
+    initialValue: Optional.some(value),
+  });
 
   obs.complete();
 

package/src/core/create/source.mts

@@ -1,5 +1,11 @@
+// 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
 import { Arr, Optional } from 'ts-data-forge';
-import { createRootObservable } from '../base/index.mjs';
+import { RootObservableClass } from '../class/index.mjs';
 import type {
   InitializedSourceObservable,
   SourceObservable,
@@ -58,28 +64,31 @@ export function source<const A>(
 export function source<const A>(): SourceObservable<A>;
 
 export function source<const A>(...args: readonly A[]): SourceObservable<A> {
-  return createRootObservable<
-    A,
-    Readonly<{ next: (nextValue: A) => A | undefined }>
-  >(
-    {
+  return new SourceObservableClass<A>(...args);
+}
+
+class SourceObservableClass<A>
+  extends RootObservableClass<A>
+  implements SourceObservable<A>
+{
+  constructor(...args: readonly A[]) {
+    super({
       initialValue: Arr.isNonEmpty(args)
         ? Optional.some(args[0])
         : Optional.none,
-    },
-    ({ startUpdate, getSnapshot, isCompleted }) => ({
-      // Returns the value held after the call: `nextValue`, or, once
-      // completed, the value already there — `undefined` only on a source
-      // that never had one, whose `next` is typed `void`.
-      next: (nextValue: A) => {
-        if (isCompleted()) {
-          return Optional.unwrap(getSnapshot());
-        }
+    });
+  }
+
+  // Returns the value held after the call: `nextValue`, or, once completed,
+  // the value already there — `undefined` only on a source that never had
+  // one, whose `next` is typed `void`.
+  next(nextValue: A): A | undefined {
+    if (this.isCompleted) {
+      return Optional.unwrap(this.getSnapshot());
+    }
 
-        startUpdate(nextValue);
+    this.startUpdate(nextValue);
 
-        return nextValue;
-      },
-    }),
-  );
+    return nextValue;
+  }
 }

package/src/core/create/timer.mts

@@ -1,5 +1,12 @@
+// 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 { createRootObservable } from '../base/index.mjs';
+import { RootObservableClass } from '../class/index.mjs';
 import type { TimerId, TimerObservable } from '../types/index.mjs';
 
 /**
@@ -44,46 +51,58 @@ export const timer = (
     startManually?: boolean;
   }>,
 ): TimerObservable => {
-  let mut_timerId: TimerId | undefined = undefined;
+  const observable = new TimerObservableClass(milliSeconds);
 
-  let mut_isStarted = false;
+  if (!(options?.startManually ?? false)) {
+    observable.start();
+  }
 
-  const resetTimer = (): void => {
-    if (mut_timerId !== undefined) {
-      clearTimeout(mut_timerId);
-    }
-  };
+  return observable;
+};
 
-  const observable = createRootObservable<0, Readonly<{ start: () => void }>>(
-    { initialValue: Optional.none, onComplete: resetTimer },
-    ({ startUpdate, isCompleted, complete }) => ({
-      start: () => {
-        if (mut_isStarted) {
-          console.warn('cannot start twice');
+class TimerObservableClass
+  extends RootObservableClass<0>
+  implements TimerObservable
+{
+  readonly #milliSeconds: number;
+  #mut_timerId: TimerId | undefined;
+  #mut_isStarted: boolean;
 
-          return;
-        }
+  constructor(milliSeconds: number) {
+    super({ initialValue: Optional.none });
 
-        mut_isStarted = true;
+    this.#milliSeconds = milliSeconds;
 
-        if (isCompleted()) {
-          console.warn('cannot restart stopped TimerObservable');
+    this.#mut_timerId = undefined;
 
-          return;
-        }
+    this.#mut_isStarted = false;
+  }
 
-        mut_timerId = setTimeout(() => {
-          startUpdate(0);
+  start(): void {
+    if (this.#mut_isStarted) {
+      console.warn('cannot start twice');
 
-          complete();
-        }, milliSeconds);
-      },
-    }),
-  );
+      return;
+    }
 
-  if (!(options?.startManually ?? false)) {
-    observable.start();
+    this.#mut_isStarted = true;
+
+    if (this.isCompleted) {
+      console.warn('cannot restart stopped TimerObservable');
+
+      return;
+    }
+
+    this.#mut_timerId = setTimeout(() => {
+      this.startUpdate(0);
+
+      this.complete();
+    }, this.#milliSeconds);
   }
 
-  return observable;
-};
+  protected override teardown(): void {
+    if (this.#mut_timerId !== undefined) {
+      clearTimeout(this.#mut_timerId);
+    }
+  }
+}

package/src/core/index.mts

@@ -1,5 +1,7 @@
+export * from './authoring.mjs';
 export * from './combine/index.mjs';
 export * from './create/index.mjs';
 export * from './operators/index.mjs';
 export * from './predefined/index.mjs';
+export * from './scope/index.mjs';
 export * from './types/index.mjs';