synstate 6.1.0 → 6.2.1

package/src/core/class/observable-base-class.mts

@@ -1,6 +1,6 @@
 // Sumi bans classes, `this`, method syntax and writes to `this` outside a
-// `mut_` binding. The observables are classes (why is on
-// `ObservableBaseClass` below), so those four rules are waived here (D-63).
+// `mut_` binding. The observables are classes (why is on `ObservableBaseClass`
+// below), so those four 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
@@ -23,6 +23,7 @@ import type {
 } from '../types/index.mjs';
 import {
   getCurrentScopeInternals,
+  issueUnqueuedToken,
   notUpdatedYet,
   observableBrand,
   toSubscriber,
@@ -34,25 +35,23 @@ import { enqueueChildren } from './propagation-state.mjs';
 /**
  * The base of every observable, and the reason an observable is a class.
  *
- * A node is created for every derived value of a UI, so creating one has to
- * be cheap, and most of its cost was its methods: each observable used to be
- * a set of closures made for it, a dozen or more per node (#2421). Sharing
- * the methods among all nodes removes that cost, and a shared method has to
- * read the node it is called on from `this`. Once `this` is unavoidable, a
- * class is the plainest way to say it: the methods live once on the
- * prototype, `this` is typed, a creator or operator is a subclass that
- * overrides `tryUpdate` (and `flush` / `teardown` where it holds something),
- * and assigning every field in the constructor gives the nodes of one class
- * one shape for V8. The collections (`children`, subscribers) are made when
- * the first one arrives.
+ * A node is created for every derived value of a UI, so creating one has to be
+ * cheap, and most of its cost was its methods: each observable used to be a set
+ * of closures made for it, a dozen or more per node (#2421). Sharing the
+ * methods among all nodes removes that cost, and a shared method has to read
+ * the node it is called on from `this`. Once `this` is unavoidable, a class is
+ * the plainest way to say it: the methods live once on the prototype, `this` is
+ * typed, a creator or operator is a subclass that overrides `tryUpdate` (and
+ * `flush` / `teardown` where it holds something), and assigning every field in
+ * the constructor gives the nodes of one class one shape for V8. The
+ * collections (`children`, subscribers) are made when the first one arrives.
  *
  * The methods read the observable they are called on, so taking one off it
  * (`const { subscribe } = obs$`) is not supported.
  *
- * A node reaches another node only through its methods and its public
- * fields, never through a `#private` one: the other node may be an instance
- * of another copy of synstate in the same program, whose classes are not
- * these.
+ * A node reaches another node only through its methods and its public fields,
+ * never through a `#private` one: the other node may be an instance of another
+ * copy of synstate in the same program, whose classes are not these.
  */
 export class ObservableBaseClass<
   A,
@@ -143,8 +142,8 @@ export class ObservableBaseClass<
   }
 
   addChild(child: ChildNode): void {
-    // A set, not an array: a completed child removes itself, and that has to
-    // be O(1) for a UI that creates and completes derived nodes on every mount.
+    // A set, not an array: a completed child removes itself, and that has to be
+    // O(1) for a UI that creates and completes derived nodes on every mount.
     if (this.#mut_children === undefined) {
       this.#mut_children = new Set<ChildNode>([child]);
     } else {
@@ -157,10 +156,10 @@ export class ObservableBaseClass<
   }
 
   /**
-   * Stores `nextValue` as the current value, queues the children for the
-   * update `updateToken`, and notifies subscribers. The children are queued
-   * first, so that a child a subscriber creates, which starts from this
-   * value, is not visited for it again.
+   * Stores `nextValue` as the current value, queues the children for the update
+   * `updateToken`, and notifies subscribers. The children are queued first, so
+   * that a child a subscriber creates, which starts from this value, is not
+   * visited for it again.
    */
   protected setNext(nextValue: A, updateToken: UpdateToken): void {
     this.#mut_updateToken = updateToken;
@@ -178,6 +177,25 @@ export class ObservableBaseClass<
     }
   }
 
+  /**
+   * Stores `nextValue` and returns `true` when nothing observes this observable
+   * — no child to queue and no subscriber to call — so that the caller need not
+   * open an update; returns `false`, storing nothing, otherwise. The value
+   * still gets a token of its own, so that whoever stored the last one sees
+   * that it emitted.
+   */
+  protected setNextIfUnobserved(nextValue: A): boolean {
+    if (this.hasChild || this.hasSubscriber) {
+      return false;
+    }
+
+    this.#mut_updateToken = issueUnqueuedToken();
+
+    this.#mut_snapshot = Optional.some(nextValue);
+
+    return true;
+  }
+
   /**
    * Called with the token of every update that reaches this observable; a
    * parent that did not emit in that update has a different `updateToken`.
@@ -200,9 +218,9 @@ export class ObservableBaseClass<
 
   /**
    * Completes the observable: an async child first passes on what it still
-   * holds (`flush`), then it is disposed. Completing never reaches the
-   * parents: an upstream observable may be shared, and only whoever owns it
-   * decides when it ends (#2133).
+   * holds (`flush`), then it is disposed. Completing never reaches the parents:
+   * an upstream observable may be shared, and only whoever owns it decides when
+   * it ends (#2133).
    */
   complete(): void {
     if (this.#mut_isCompleted) {
@@ -215,8 +233,8 @@ export class ObservableBaseClass<
   }
 
   /**
-   * Completes the observable without passing on anything it still holds,
-   * runs its teardown, and takes it out of the graph.
+   * Completes the observable without passing on anything it still holds, runs
+   * its teardown, and takes it out of the graph.
    */
   dispose(): void {
     // A completed node is reached again through every parent that completes
@@ -255,8 +273,8 @@ export class ObservableBaseClass<
   }
 
   /**
-   * Passes on what the observable still holds, at the beginning of
-   * `complete()` and never in `dispose()` (`debounce`'s pending value).
+   * Passes on what the observable still holds, at the beginning of `complete()`
+   * and never in `dispose()` (`debounce`'s pending value).
    */
   // eslint-disable-next-line @typescript-eslint/class-methods-use-this
   protected flush(): void {}

package/src/core/class/observable-node.mts

@@ -38,10 +38,9 @@ export type ChildNode = NodeInternals &
   }>;
 
 /**
- * The one place a public observable is seen as the node it is. Every
- * observable is built by a synstate class, and the public types carry a
- * brand an object literal cannot supply, so this holds for every value of
- * those types.
+ * The one place a public observable is seen as the node it is. Every observable
+ * is built by a synstate class, and the public types carry a brand an object
+ * literal cannot supply, so this holds for every value of those types.
  */
 export const toNode = <A,>(observable: Observable<A>): ObservableNode<A> =>
   // @sumi-expect-error banned-syntax/no-unsafe-type-assertion

package/src/core/class/propagation-state.mts

@@ -18,8 +18,9 @@ import type { UpdateToken } from '../types/index.mjs';
 import type { ChildNode } from './observable-node.mjs';
 
 /**
- * How many `startUpdate` calls are running, across every observable, and
- * the token of the outermost one.
+ * How many updates are propagating, across every observable, and the token of
+ * the outermost one. A write nothing observes opens none
+ * (`setNextIfUnobserved`).
  */
 const mut_propagation: {
   depth: number;
@@ -27,15 +28,14 @@ const mut_propagation: {
 } = { depth: 0, outermostToken: undefined };
 
 /**
- * Work deferred by {@link runAfterPropagation}, run once the outermost
- * `startUpdate` has reached every descendant.
+ * Work deferred by {@link runAfterPropagation}, run once the outermost update
+ * has reached every descendant.
  */
 const mut_afterPropagation: (() => void)[] = [];
 
 /**
- * Whether some observable's update is propagating right now. A root written
- * to while one is, is written to from inside a subscriber or a projection
- * (#2336).
+ * Whether some observable's update is propagating right now. A root written to
+ * while one is, is written to from inside a subscriber or a projection (#2336).
  */
 export const isPropagating = (): boolean => mut_propagation.depth > 0;
 
@@ -57,7 +57,10 @@ export const runAfterPropagation = (task: () => void): void => {
   }
 };
 
-/** Brackets one `startUpdate`; see {@link endPropagation}. */
+/**
+ * Brackets one update a `startUpdate` opens (a write nothing observes opens
+ * none); see {@link endPropagation}.
+ */
 export const beginPropagation = (updateToken: UpdateToken): void => {
   if (mut_propagation.depth === 0) {
     mut_propagation.outermostToken = updateToken;
@@ -67,8 +70,7 @@ export const beginPropagation = (updateToken: UpdateToken): void => {
 };
 
 /**
- * Ends one `startUpdate`, and runs the deferred work once the outermost one
- * has ended.
+ * Ends one update, and runs the deferred work once the outermost one has ended.
  */
 export const endPropagation = (): void => {
   mut_propagation.depth -= 1;
@@ -87,11 +89,11 @@ export const endPropagation = (): void => {
 };
 
 /**
- * The buckets of this copy's open updates, one set per nesting level: a
- * bucket per depth below the node that started the update, holding the
- * queued nodes and how many of its slots are in use. Kept from update to
- * update, so that an update allocates nothing but its token; emptying a
- * bucket is setting its length to 0.
+ * The buckets of this copy's open updates, one set per nesting level: a bucket
+ * per depth below the node that started the update, holding the queued nodes
+ * and how many of its slots are in use. Kept from update to update, so that an
+ * update allocates nothing but its token; emptying a bucket is setting its
+ * length to 0.
  */
 const mut_bucketSets: Bucket[][] = [];
 
@@ -121,9 +123,9 @@ export const openUpdate = (depth: number): UpdateToken => {
 
 /**
  * How many updates of one copy may be open at once, one inside another. An
- * update opens inside another only when a subscriber or projection writes to
- * a root while the outer one is propagating; a chain of such writes this deep
- * is a loop that would otherwise run until the stack overflows.
+ * update opens inside another only when a subscriber or projection writes to a
+ * root while the outer one is propagating; a chain of such writes this deep is
+ * a loop that would otherwise run until the stack overflows.
  */
 export const maxUpdateNesting = 100;
 
@@ -169,10 +171,10 @@ type Bucket = {
  *
  * A queued node is marked with the token of the update that queued it
  * (`queuedFor`), which is how an update queues a node once. The mark is not
- * cleared after the visit: a later update has another token. An update does
- * not overwrite the mark of an update that is still open — one it is nested
- * in, or one of another copy of synstate — and remembers the nodes it
- * queues despite such a mark in a set of its own instead.
+ * cleared after the visit: a later update has another token. An update does not
+ * overwrite the mark of an update that is still open — one it is nested in, or
+ * one of another copy of synstate — and remembers the nodes it queues despite
+ * such a mark in a set of its own instead.
  */
 class UpdateQueue {
   readonly #base: number;
@@ -248,8 +250,8 @@ class UpdateQueue {
       }
 
       if (mark !== undefined && toQueue(mark).isOpen) {
-        // Another open update has queued `child` and may not have visited
-        // it yet: leave its mark alone.
+        // Another open update has queued `child` and may not have visited it
+        // yet: leave its mark alone.
         if (this.#mut_queuedDespiteMark === undefined) {
           this.#mut_queuedDespiteMark = new Set<ChildNode>();
         } else if (this.#mut_queuedDespiteMark.has(child)) {
@@ -270,8 +272,8 @@ class UpdateQueue {
 
     const mut_buckets = this.#mut_buckets;
 
-    // `size` grows while the buckets are visited, always past `index`, which
-    // a `range` built at the start would miss.
+    // `size` grows while the buckets are visited, always past `index`, which a
+    // `range` built at the start would miss.
     // eslint-disable-next-line ts-data-forge/prefer-range-for-loop
     for (let mut_index = 0; mut_index < this.#mut_size; mut_index += 1) {
       const mut_bucket = mut_buckets[mut_index];
@@ -280,9 +282,9 @@ class UpdateQueue {
         continue;
       }
 
-      // A node visited here queues only deeper nodes, so this bucket does
-      // not grow while it is visited. Its length is kept until the end, so
-      // that `close` can clear what an exception leaves.
+      // A node visited here queues only deeper nodes, so this bucket does not
+      // grow while it is visited. Its length is kept until the end, so that
+      // `close` can clear what an exception leaves.
       const { nodes: mut_nodes, length } = mut_bucket;
 
       // eslint-disable-next-line ts-data-forge/prefer-range-for-loop

package/src/core/class/remove-completed.test.mts

@@ -202,8 +202,8 @@ describe('a completed observable leaves the propagation graph', () => {
 
     const mut_got: number[] = [];
 
-    // Subscribed on a child, so the node is created while the update of `s`
-    // is under way.
+    // Subscribed on a child, so the node is created while the update of `s` is
+    // under way.
     s.pipe(map((x) => x)).subscribe((x) => {
       if (x === 1) {
         s.pipe(

package/src/core/class/root-observable-class.mts

@@ -16,11 +16,11 @@ export class RootObservableClass<A>
   implements RootObservable<A>
 {
   /**
-   * The outermost update propagating when this root was created. A root
-   * created while an update propagates (inside a `switchMap` projection,
-   * say) may emit while it is created, as `fromSubscribable` does for a
-   * synchronous source. Nothing is derived from it yet, so that is its
-   * initial value rather than a write (#2336).
+   * The outermost update propagating when this root was created. A root created
+   * while an update propagates (inside a `switchMap` projection, say) may emit
+   * while it is created, as `fromSubscribable` does for a synchronous source.
+   * Nothing is derived from it yet, so that is its initial value rather than a
+   * write (#2336).
    */
   readonly #createdDuring: UpdateToken | undefined;
   #mut_hasWarned: boolean;
@@ -64,10 +64,10 @@ export class RootObservableClass<A>
 
 /**
  * Shown once per root observable, the first time it is written to (`next`,
- * `setState`, `dispatch`, …) while another update is still propagating —
- * from a subscriber or a projection. The write still propagates immediately,
- * as it always has; the warning is there because the pattern is wrong, not
- * because anything was refused.
+ * `setState`, `dispatch`, …) while another update is still propagating — from a
+ * subscriber or a projection. The write still propagates immediately, as it
+ * always has; the warning is there because the pattern is wrong, not because
+ * anything was refused.
  */
 export const writeDuringPropagationWarning =
   'synstate: an observable was written to (next / setState / dispatch) while an update was propagating, so subscribers can see intermediate states. Derive the value with map / combine instead of writing from a subscriber or a projection.';

package/src/core/class/unobserved-write.test.mts

@@ -0,0 +1,194 @@
+import type { FixedLengthTuple } from 'ts-type-forge';
+import { createState } from '../../utils/index.mjs';
+import { derive, merge } from '../combine/index.mjs';
+import { source } from '../create/index.mjs';
+import { debounce, map, switchMap } from '../operators/index.mjs';
+import { writeDuringPropagationWarning } from './root-observable-class.mjs';
+
+// A write to an observable with no child and no subscriber stores the value
+// without opening an update (`ManagerObservableClass.startUpdate`). These pin
+// what that must not change.
+describe('a write nothing observes', () => {
+  test('is held, and a later subscriber receives the last one', () => {
+    const s$ = source<number>(0);
+
+    s$.next(1);
+
+    s$.next(2);
+
+    const mut_history: number[] = [];
+
+    s$.subscribe((v) => {
+      mut_history.push(v);
+    });
+
+    assert.deepStrictEqual(mut_history, [2]);
+  });
+
+  test('gets a token of its own each time', () => {
+    const s$ = source<number>(0);
+
+    const before = s$.updateToken;
+
+    s$.next(1);
+
+    const first = s$.updateToken;
+
+    s$.next(2);
+
+    assert.notStrictEqual(first, before);
+
+    assert.notStrictEqual(s$.updateToken, first);
+  });
+
+  test('is held after the last subscriber leaves', () => {
+    const [s$, setS] = createState(0);
+
+    const subscription = s$.subscribe(() => {});
+
+    subscription.unsubscribe();
+
+    assert.strictEqual(setS(5), 5);
+
+    const mut_history: number[] = [];
+
+    s$.subscribe((v) => {
+      mut_history.push(v);
+    });
+
+    assert.deepStrictEqual(mut_history, [5]);
+  });
+
+  test('is where a child created later starts, and later writes reach it', () => {
+    const s$ = source<number>(0);
+
+    s$.next(3);
+
+    const mut_history: number[] = [];
+
+    s$.pipe(map((x) => x * 10)).subscribe((v) => {
+      mut_history.push(v);
+    });
+
+    s$.next(4);
+
+    assert.deepStrictEqual(mut_history, [30, 40]);
+  });
+
+  test('is not taken for an emission of an update another parent starts', () => {
+    const a$ = source<number>(0);
+
+    const b$ = source<number>(0);
+
+    a$.next(5);
+
+    const mut_merged: number[] = [];
+
+    merge([a$, b$]).subscribe((v) => {
+      mut_merged.push(v);
+    });
+
+    const mut_derived: FixedLengthTuple<2, number>[] = [];
+
+    derive([a$, b$], (a, b) => [a, b] as const).subscribe((v) => {
+      mut_derived.push(v);
+    });
+
+    b$.next(1);
+
+    a$.next(6);
+
+    // merge passes on the parents that emitted in an update: only b$, then only
+    // a$, never the value a$ was given while nothing observed it.
+    assert.deepStrictEqual(mut_merged, [1, 6]);
+
+    assert.deepStrictEqual(mut_derived, [
+      [5, 0],
+      [5, 1],
+      [6, 1],
+    ]);
+  });
+
+  test('by an async child is held, as a root write is', () => {
+    vi.useFakeTimers();
+
+    const s$ = source<number>(0);
+
+    const debounced$ = s$.pipe(debounce(100));
+
+    const subscription = debounced$.subscribe(() => {});
+
+    subscription.unsubscribe();
+
+    // debounced$ keeps its parent, but has no observer of its own when the
+    // timer fires.
+    s$.next(1);
+
+    vi.runAllTimers();
+
+    const mut_history: number[] = [];
+
+    debounced$.subscribe((v) => {
+      mut_history.push(v);
+    });
+
+    s$.next(2);
+
+    vi.runAllTimers();
+
+    assert.deepStrictEqual(mut_history, [1, 2]);
+
+    vi.useRealTimers();
+  });
+
+  test('by a switchMap inner after the switchMap lost its observers is held', () => {
+    const selector$ = source<number>(0);
+
+    const branch$ = source<number>(10);
+
+    const switched$ = selector$.pipe(switchMap(() => branch$));
+
+    const subscription = switched$.subscribe(() => {});
+
+    // switchMap follows an inner once the selector emits.
+    selector$.next(1);
+
+    subscription.unsubscribe();
+
+    branch$.next(11);
+
+    const mut_history: number[] = [];
+
+    switched$.pipe(map((x) => x * 2)).subscribe((v) => {
+      mut_history.push(v);
+    });
+
+    branch$.next(12);
+
+    assert.deepStrictEqual(mut_history, [22, 24]);
+  });
+
+  test('from a subscriber still warns as a write during propagation', () => {
+    const [a$, setA] = createState(0);
+
+    const [, setB] = createState(0);
+
+    a$.subscribe((a) => {
+      setB(a);
+    });
+
+    const warn = vi.fn();
+
+    vi.stubGlobal('console', { ...console, warn });
+
+    setA(1);
+
+    // cspell:disable-next-line
+    vi.unstubAllGlobals();
+
+    assert.deepStrictEqual(
+      warn.mock.calls.map((args: readonly unknown[]) => args[0]),
+      [writeDuringPropagationWarning],
+    );
+  });
+});

package/src/core/combine/derive.mts

@@ -1,6 +1,6 @@
 // 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).
+// `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
@@ -20,14 +20,13 @@ import type {
 
 /**
  * Derives one value from the latest values of several observables: one
- * observable that calls `project` with them, as arguments, and emits the
- * result unless it equals the one already held.
+ * observable that calls `project` with them, as arguments, and emits the result
+ * unless it equals the one already held.
  *
- * It emits once every parent has a value, and then whenever any of them
- * emits, as `combine` does; but where `combine(parents).pipe(map(fn))` is two
- * observables and a tuple per update, `derive` is one, and passes the values
- * as arguments (a rest parameter in `project` collects them into an array
- * again).
+ * It emits once every parent has a value, and then whenever any of them emits,
+ * as `combine` does; but where `combine(parents).pipe(map(fn))` is two
+ * observables and a tuple per update, `derive` is one, and passes the values as
+ * arguments (a rest parameter in `project` collects them into an array again).
  * The comparison is `Object.is` unless `equals` says otherwise.
  *
  * @template OS - Tuple type of the parent observables
@@ -83,8 +82,8 @@ export const derive = <const OS extends NonEmptyTuple<Observable<unknown>>, B>(
   // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
   new DeriveObservableClass(
     parents,
-    // `project` is called with the values of `parents`, position by
-    // position, which the checker cannot follow through an index.
+    // `project` is called with the values of `parents`, position by position,
+    // which the checker cannot follow through an index.
     // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
     project as (...values: readonly unknown[]) => B,
     options?.equals ?? Object.is,

package/src/core/combine/merge.mts

@@ -1,6 +1,6 @@
 // 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).
+// `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

package/src/core/combine/zip.mts

@@ -1,6 +1,6 @@
 // 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).
+// `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
@@ -26,9 +26,9 @@ import type {
 /**
  * Combines multiple observables by pairing their emissions by index.
  * Waits for all sources to emit their nth value before emitting the nth tuple.
- * Completes once a completed source has no value left to pair, as RxJS's
- * `zip` does: at once if it completes with nothing queued, otherwise after
- * the tuple that takes its last queued value.
+ * Completes once a completed source has no value left to pair, as RxJS's `zip`
+ * does: at once if it completes with nothing queued, otherwise after the tuple
+ * that takes its last queued value.
  *
  * @template OS - Tuple type of source observables
  * @param parents - Array of observables to zip
@@ -156,8 +156,8 @@ class ZipObservableClass<const A extends NonEmptyUnknownList>
   }
 
   /**
-   * No tuple can be completed any more once a completed source has nothing
-   * left to pair (#2343).
+   * No tuple can be completed any more once a completed source has nothing left
+   * to pair (#2343).
    */
   override canEmitNoMore(): boolean {
     return this.parents.some(

package/src/core/create/counter.mts

@@ -1,6 +1,6 @@
 // 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).
+// `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
@@ -12,9 +12,9 @@ import type { CounterObservable, TimerId } from '../types/index.mjs';
 
 /**
  * Creates an observable that emits incremental numbers at a specified interval.
- * Emits 0 in the macrotask right after `start()` (which runs at creation
- * unless `startManually` is set), then 1, 2, 3, ... every interval. A
- * subscriber added after that 0 has been emitted does not receive it.
+ * Emits 0 in the macrotask right after `start()` (which runs at creation unless
+ * `startManually` is set), then 1, 2, 3, ... every interval. A subscriber added
+ * after that 0 has been emitted does not receive it.
  *
  * @param intervalMilliSeconds - The interval duration in milliseconds
  * @param options - Optional settings

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

@@ -1,6 +1,6 @@
 // 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).
+// `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

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

@@ -1,6 +1,6 @@
 // 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).
+// `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

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

@@ -1,6 +1,6 @@
 // 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).
+// `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