synstate 6.1.1 → 7.0.0

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

@@ -1,17 +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).
+// `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,
-  pipe,
-} from 'ts-data-forge';
+import { Optional, asSafeUint, expectType, type SafeUint } from 'ts-data-forge';
 import { SyncChildObservableClass } from '../class/index.mjs';
 import { source } from '../create/index.mjs';
 import type {
@@ -73,7 +67,7 @@ import { withInitialValue } from './with-initial-value.mjs';
  *
  * assert.deepStrictEqual(valueHistory, [1, 2, 3, 4]);
  *
- * num$.next(1); // logs: 1
+ * num$.next(1); // nothing logged (already completed)
  *
  * assert.deepStrictEqual(valueHistory, [1, 2, 3, 4]);
  * ```
@@ -98,21 +92,26 @@ class TakeWhileObservableClass<A>
     parentObservable: Observable<A>,
     predicate: (value: A, index: SafeUint | -1) => boolean,
   ) {
+    const parentSnapshot = parentObservable.getSnapshot();
+
+    const isTaking =
+      Optional.isNone(parentSnapshot) || predicate(parentSnapshot.value, -1);
+
     super({
       parents: [parentObservable],
-      initialValue: pipe(parentObservable.getSnapshot()).map((par) =>
-        Optional.isNone(par)
-          ? Optional.none
-          : predicate(par.value, -1)
-            ? par
-            : Optional.none,
-      ).value,
+      initialValue: isTaking ? parentSnapshot : Optional.none,
     });
 
     this.#mut_index = -1;
 
     this.#predicate = predicate;
 
+    // A parent value the predicate rejects ends it, as any later one would;
+    // `attach` then leaves it out of the graph.
+    if (!isTaking) {
+      this.complete();
+    }
+
     this.attach();
   }
 
@@ -125,8 +124,7 @@ class TakeWhileObservableClass<A>
       return; // skip update
     }
 
-    this.#mut_index =
-      this.#mut_index === -1 ? asSafeUint(0) : SafeUint.add(1, this.#mut_index);
+    this.#mut_index = asSafeUint(this.#mut_index + 1);
 
     if (this.#predicate(sn.value, this.#mut_index)) {
       this.setNext(sn.value, updateToken);

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

@@ -0,0 +1,51 @@
+import { createState } from '../../utils/index.mjs';
+import { takeWhile } from './take-while.mjs';
+
+describe(takeWhile, () => {
+  test('completes at once when the initial value fails the predicate', () => {
+    const [s$, setS] = createState(5);
+
+    const taken$ = s$.pipe(takeWhile((x) => x < 3));
+
+    const mut_events: string[] = [];
+
+    taken$.subscribe(
+      (x) => {
+        mut_events.push(`next ${x}`);
+      },
+      () => {
+        mut_events.push('complete');
+      },
+    );
+
+    assert.isTrue(taken$.isCompleted);
+
+    setS(1);
+
+    assert.deepStrictEqual(mut_events, ['complete']);
+  });
+
+  test('keeps taking after an initial value that passes the predicate', () => {
+    const [s$, setS] = createState(1);
+
+    const taken$ = s$.pipe(takeWhile((x) => x < 3));
+
+    const mut_history: number[] = [];
+
+    taken$.subscribe((x) => {
+      mut_history.push(x);
+    });
+
+    setS(2);
+
+    assert.isFalse(taken$.isCompleted);
+
+    setS(5);
+
+    assert.isTrue(taken$.isCompleted);
+
+    setS(1);
+
+    assert.deepStrictEqual(mut_history, [1, 2]);
+  });
+});

package/src/core/operators/take.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/operators/throttle.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
@@ -139,14 +139,15 @@ class ThrottleObservableClass<A>
       return; // skip update
     }
 
-    this.setNext(sn.value, updateToken);
-
+    // The window opens before `setNext`, which can lead back here: a value a
+    // subscriber writes to the parent falls inside it.
     this.#mut_isSkipping = true;
 
-    // set timer
     this.#mut_timerId = setTimeout(() => {
       this.#mut_isSkipping = false;
     }, this.#milliSeconds);
+
+    this.setNext(sn.value, updateToken);
   }
 
   protected override teardown(): void {

package/src/core/operators/with-buffered-from.mts

@@ -1,11 +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).
+// `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, pipe } from 'ts-data-forge';
+import { Optional, pipe } from 'ts-data-forge';
+import * as Arr from 'ts-data-forge/array';
 import { SyncChildObservableClass } from '../class/index.mjs';
 import type {
   KeepInitialValueOperator,
@@ -93,11 +94,13 @@ class WithBufferedFromObservableClass<A, B>
   #mut_bufferedValues: readonly B[];
 
   constructor(parentObservable: Observable<A>, observable: Observable<B>) {
+    const parentSnapshot = parentObservable.getSnapshot();
+
     super({
       parents: [parentObservable],
       depth: 1 + maxDepth([parentObservable, observable]),
       initialValue: pipe({
-        par: parentObservable.getSnapshot(),
+        par: parentSnapshot,
         me: observable.getSnapshot(),
       }).map(({ par, me }) =>
         Optional.isNone(par)
@@ -115,6 +118,12 @@ class WithBufferedFromObservableClass<A, B>
       this.#mut_bufferedValues = Arr.toPushed(this.#mut_bufferedValues, value);
     });
 
+    // `subscribe` has just pushed the buffered observable's current value,
+    // which the initial tuple already carries.
+    if (Optional.isSome(parentSnapshot)) {
+      this.#mut_bufferedValues = [];
+    }
+
     this.attach();
   }
 
@@ -127,9 +136,13 @@ class WithBufferedFromObservableClass<A, B>
       return; // skip update
     }
 
-    this.setNext([sn.value, this.#mut_bufferedValues], updateToken);
+    const buffered = this.#mut_bufferedValues;
 
+    // Emptied before `setNext`, which can lead back here: a value a subscriber
+    // writes to the buffered observable belongs to the next batch.
     this.#mut_bufferedValues = [];
+
+    this.setNext([sn.value, buffered], updateToken);
   }
 
   protected override teardown(): void {

package/src/core/operators/with-buffered-from.test.mts

@@ -1,3 +1,4 @@
+import { createState } from '../../utils/index.mjs';
 import { toNode } from '../class/index.mjs';
 import { source } from '../create/index.mjs';
 import { withBufferedFrom } from './with-buffered-from.mjs';
@@ -55,3 +56,29 @@ describe('withBufferedFrom teardown', () => {
     assert.deepStrictEqual(mut_history, [[1, ['A', 'B']]]);
   });
 });
+
+describe('withBufferedFrom initial value', () => {
+  test('reports the current value of the buffered observable once when both hold one (#2767)', () => {
+    const [data$] = createState('x');
+
+    const [trigger$, setTrigger] = createState(0);
+
+    const result$ = trigger$.pipe(withBufferedFrom(data$));
+
+    const mut_history: (readonly [number, readonly string[]])[] = [];
+
+    result$.subscribe((v) => {
+      mut_history.push(v);
+    });
+
+    setTrigger(1);
+
+    setTrigger(2);
+
+    assert.deepStrictEqual(mut_history, [
+      [0, ['x']],
+      [1, []],
+      [2, []],
+    ]);
+  });
+});

package/src/core/operators/with-current-value-from.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/operators/with-initial-value.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/predefined/operators/attach-index.mts

@@ -1,11 +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).
+// `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 } from 'ts-data-forge';
+import { Optional, asSafeUint, type SafeUint } from 'ts-data-forge';
 import { SyncChildObservableClass } from '../../class/index.mjs';
 import type {
   KeepInitialValueOperator,
@@ -112,8 +112,7 @@ class WithIndexObservableClass<A> extends SyncChildObservableClass<
       return; // skip update
     }
 
-    this.#mut_index =
-      this.#mut_index === -1 ? asSafeUint(0) : SafeUint.add(1, this.#mut_index);
+    this.#mut_index = asSafeUint(this.#mut_index + 1);
 
     this.setNext([this.#mut_index, sn.value], updateToken);
   }

package/src/core/predefined/operators/map-to.mts

@@ -4,10 +4,9 @@ import type { KeepInitialValueOperator } from '../../types/index.mjs';
 /**
  * Maps all emitted values to a constant value, ignoring the source values.
  * Emits on every source value although the value never changes — where
- * `map(() => value)` would stop every result after the first as equal — so
- * it is the one for turning events into a value. The value's type is
- * inferred as written, as with `as const`: `mapTo('reset')` gives
- * `'reset'`, not `string`.
+ * `map(() => value)` would stop every result after the first as equal — so it
+ * is the one for turning events into a value. The value's type is inferred as
+ * written, as with `as const`: `mapTo('reset')` gives `'reset'`, not `string`.
  *
  * @template A - The type of values from the source
  * @template B - The type of the constant value

package/src/core/predefined/operators/skip.mts

@@ -1,4 +1,4 @@
-import { PositiveSafeInt } from 'ts-data-forge';
+import { isPositiveSafeInt } from 'ts-data-forge';
 import type { PositiveSafeIntWithSmallInt } from 'ts-type-forge';
 import { skipWhile } from '../../operators/index.mjs';
 import type { DropInitialValueOperator } from '../../types/index.mjs';
@@ -53,6 +53,6 @@ import type { DropInitialValueOperator } from '../../types/index.mjs';
 export const skip = <A,>(
   n: PositiveSafeIntWithSmallInt,
 ): DropInitialValueOperator<A, A> =>
-  !PositiveSafeInt.is(n) ? idFn : skipWhile((_, index) => index + 1 <= n);
+  !isPositiveSafeInt(n) ? idFn : skipWhile((_, index) => index + 1 <= n);
 
 const idFn = <T,>(value: T): T => value;

package/src/core/scope/scope.mts

@@ -23,8 +23,8 @@ import {
  * disposed gives a scope that is born disposed, with a warning.
  *
  * Intended for authors of libraries built on synstate rather than for
- * application code; state defined at module level belongs to no scope and
- * lives as long as the page.
+ * application code; state defined at module level belongs to no scope and lives
+ * as long as the page.
  *
  * `run` and `dispose` read the scope they are called on, so call them on it
  * (`scope.dispose()`) rather than taking them off it.
@@ -50,8 +50,8 @@ export const getCurrentScope = (): Scope | undefined =>
 
 /**
  * Registers `cleanup` to be called when the current scope is disposed. Cleanups
- * run after the child scopes are disposed and before the owned observables
- * are, newest first.
+ * run after the child scopes are disposed and before the owned observables are,
+ * newest first.
  *
  * Outside every scope it warns and registers nothing.
  *
@@ -85,8 +85,8 @@ export const untracked = <R,>(body: () => R): R =>
  * A scope is created for every row and branch of a UI, so creating one has to
  * be cheap. It used to be a set of closures with a `Set` of children, a `Set`
  * of owned observables and a record in a `WeakMap`; it is now one object whose
- * methods live on the prototype and whose lists are arrays made when the
- * first entry arrives.
+ * methods live on the prototype and whose lists are arrays made when the first
+ * entry arrives.
  *
  * Whatever leaves a list on its own (a child scope disposed by itself, an
  * observable that completed) is not looked up and spliced out: it only counts

package/src/core/types/observable-family.mts

@@ -65,11 +65,10 @@ export type ScanOperatorObservable<A, B> = InitializedSyncChildObservable<
 
 // SyncChildObservable
 
-// The helpers stay in a namespace so their names do not crowd the module
-// scope. A namespace holding only types is erasable, so it passes
-// `erasableSyntaxOnly` (TS1294); the `expectType` assertions are call
-// statements, which is why they sit below it rather than beside the types
-// they check.
+// The helpers stay in a namespace so their names do not crowd the module scope.
+// A namespace holding only types is erasable, so it passes `erasableSyntaxOnly`
+// (TS1294); the `expectType` assertions are call statements, which is why they
+// sit below it rather than beside the types they check.
 namespace SynStateInternals {
   type Cast<A> = A extends NonEmptyUnknownList ? A : never;
 

package/src/core/types/observable.mts

@@ -32,8 +32,8 @@ type CreateObservableType<A, Kind extends ObservableKind> = Readonly<{
 
   /**
    * One more than the deepest observable this one is derived from; 0 for a
-   * root. An update reaches observables in ascending depth, so every parent
-   * has emitted before its child reads it.
+   * root. An update reaches observables in ascending depth, so every parent has
+   * emitted before its child reads it.
    */
   depth: Kind extends 'root' ? 0 : number;
 
@@ -173,9 +173,9 @@ export type Operator<A, B> =
   | KeepInitialValueOperator<A, B>;
 
 /**
- * Tells an observable made by synstate from any other value, by the brand
- * every observable carries. Checking for a `subscribe` method instead would
- * also accept plain values that happen to have one.
+ * Tells an observable made by synstate from any other value, by the brand every
+ * observable carries. Checking for a `subscribe` method instead would also
+ * accept plain values that happen to have one.
  *
  * @example
  *
@@ -223,8 +223,8 @@ export type WrapInitialized<A extends readonly unknown[]> = Readonly<{
 // type GetDestTypeOfOperator<Op extends Operator<unknown, unknown>> =
 //   Op extends Operator<unknown, infer B> ? B : never;
 
-// Only the members meant for users are public; the rest live on the
-// internal node types in `core/class` (#2117).
+// Only the members meant for users are public; the rest live on the internal
+// node types in `core/class` (#2117).
 expectType<
   keyof Observable<unknown>,
   | typeof observableBrand

package/src/core/utils/current-scope.mts

@@ -7,10 +7,10 @@ export type ScopeMember = Readonly<{
 }>;
 
 /**
- * The side of a scope the rest of the core talks to, on top of its public
- * face {@link Scope}. Kept out of the public API (`core/utils/**` is excluded
- * from index generation), so that only `createScope` and its siblings decide
- * what a scope owns.
+ * The side of a scope the rest of the core talks to, on top of its public face
+ * {@link Scope}. Kept out of the public API (`core/utils/**` is excluded from
+ * index generation), so that only `createScope` and its siblings decide what a
+ * scope owns.
  */
 export type ScopeInternals = Scope &
   Readonly<{
@@ -18,8 +18,8 @@ export type ScopeInternals = Scope &
     adopt: (node: ScopeMember) => void;
 
     /**
-     * Tells the scope that one of the nodes it adopted completed on its own,
-     * so that the scope can drop it and keep no reference to it. The node is
+     * Tells the scope that one of the nodes it adopted completed on its own, so
+     * that the scope can drop it and keep no reference to it. The node is
      * completed (`isCompleted`) by the time it calls this.
      */
     release: () => void;
@@ -28,8 +28,8 @@ export type ScopeInternals = Scope &
   }>;
 
 /**
- * The scope whose `run` is executing. A field rather than a module-level
- * `let`, so that the one place writing it is visibly this object.
+ * The scope whose `run` is executing. A field rather than a module-level `let`,
+ * so that the one place writing it is visibly this object.
  */
 const mut_slot: { current: ScopeInternals | undefined } = {
   current: undefined,

package/src/core/utils/id-maker.mts

@@ -12,8 +12,8 @@ export const notUpdatedYet: UpdateToken =
 /**
  * Issues the token of a write that opens no update, because nothing observes
  * the observable written to (`setNextIfUnobserved`). Nothing is ever queued
- * with it, so it is a token and not a queue, unlike the tokens
- * `openUpdate` issues.
+ * with it, so it is a token and not a queue, unlike the tokens `openUpdate`
+ * issues.
  */
 export const issueUnqueuedToken = (): UpdateToken =>
   // @sumi-expect-error banned-syntax/no-unsafe-type-assertion

package/src/core/utils/index.mts

@@ -3,3 +3,4 @@ export * from './id-maker.mjs';
 export * from './max-depth.mjs';
 export * from './observable-brand.mjs';
 export * from './observable-utils.mjs';
+export * from './rethrow-out-of-promise.mjs';

package/src/core/utils/observable-brand.mts

@@ -1,10 +1,10 @@
 /**
  * The key every observable carries, set to `true` by `assembleObservable`. It
- * lets `isObservable` tell an observable from any other value at run time —
- * a `subscribe` method is not enough, since plain values may have one — and,
- * as a type, makes the public observable types impossible to satisfy with an
- * object literal: an imitation passed to an operator would lack the internal
- * members propagation reads and fail at run time instead of at compile time.
+ * lets `isObservable` tell an observable from any other value at run time — a
+ * `subscribe` method is not enough, since plain values may have one — and, as a
+ * type, makes the public observable types impossible to satisfy with an object
+ * literal: an imitation passed to an operator would lack the internal members
+ * propagation reads and fail at run time instead of at compile time.
  *
  * `Symbol.for`, so that an observable made by another copy of synstate in the
  * same program is still recognized.

package/src/core/utils/rethrow-out-of-promise.mts

@@ -0,0 +1,16 @@
+/**
+ * Throws `error` again from a task of its own, for a `.catch` after each step
+ * of a promise chain that runs subscribers (`fromPromise`): after the step that
+ * emits and after the one that completes, so that neither exception replaces
+ * the other. A subscriber's exception then surfaces as an uncaught error, as
+ * one thrown during an update a timer started does (`debounce`, `timer`),
+ * rather than as a rejection or not at all.
+ */
+export const rethrowOutOfPromise = (error: unknown): void => {
+  setTimeout(() => {
+    // The subscriber's own exception, passed on unchanged.
+    // @sumi-expect-error exceptions/no-throw
+    // eslint-disable-next-line @typescript-eslint/only-throw-error -- the subscriber's own exception, passed on unchanged
+    throw error;
+  }, 0);
+};

package/src/utils/create-boolean-state.mts

@@ -18,8 +18,8 @@ import { createState } from './create-state.mjs';
  * import { useObservableValue } from 'synstate-react-hooks';
  *
  * // Menu drawer open/close state.
- * // setTrue and setFalse can be passed directly as callbacks
- * // — no need to create wrapper functions like `() => setState(true)`.
+ * // setTrue and setFalse can be passed directly as callbacks — no need to
+ * // create wrapper functions like `() => setState(true)`.
  * const [menuOpen$, { setTrue: openMenu, setFalse: closeMenu }] =
  *   createBooleanState(false);
  *

package/src/utils/create-reducer.mts

@@ -111,18 +111,18 @@ export const createReducer = <S, A>(
  */
 export type StateOptions<S> = Readonly<{
   /**
-   * Whether the next state is the same as the current one. When it says so,
-   * the update is not passed on — no subscriber, and nothing derived from
-   * the state, is told of it — and the current state is kept, along with its
-   * identity: `setState` and the like return the current state rather than
-   * the next.
+   * Whether the next state is the same as the current one. When it says so, the
+   * update is not passed on — no subscriber, and nothing derived from the
+   * state, is told of it — and the current state is kept, along with its
+   * identity: `setState` and the like return the current state rather than the
+   * next.
    *
    * Decide here, where the state is held, rather than downstream with
-   * `skipIfNoChange`: an update passed on here reaches whatever reads the
-   * state directly before any operator can thin it out.
+   * `skipIfNoChange`: an update passed on here reaches whatever reads the state
+   * directly before any operator can thin it out.
    *
-   * Defaults to `Object.is`, so writing the value already held passes
-   * nothing on. Pass `() => false` to pass on every update, equal or not.
+   * Defaults to `Object.is`, so writing the value already held passes nothing
+   * on. Pass `() => false` to pass on every update, equal or not.
    *
    * @param current - The state held now
    * @param next - The state the update would set
@@ -132,8 +132,8 @@ export type StateOptions<S> = Readonly<{
   /**
    * Whether an update keeps the parts of the state it did not change. With
    * `true`, the next state is compared with the current one before it is
-   * written, and every part of it deeply equal to the same part of the
-   * current state is replaced by that part (`replaceEqualDeep` of
+   * written, and every part of it deeply equal to the same part of the current
+   * state is replaced by that part (`replaceEqualDeep` of
    * ts-data-forge): a reader of an unchanged part keeps the object it has, so
    * `map`, comparing with `Object.is`, stops there. When the whole next state is
    * deeply equal, the current state is kept and nothing is passed on, so
@@ -146,14 +146,14 @@ export type StateOptions<S> = Readonly<{
    * arrays are walked into; a `Map`, a `Set`, a `Date` or a class instance is
    * compared and kept whole.
    *
-   * Prefer this over `keepEqualParts()` downstream: keeping the parts where
-   * the state is written means no update with nothing in it is passed on at
-   * all, and nothing downstream has anything to undo.
+   * Prefer this over `keepEqualParts()` downstream: keeping the parts where the
+   * state is written means no update with nothing in it is passed on at all,
+   * and nothing downstream has anything to undo.
    *
-   * Defaults to `false`: the next state is written as given. With it on,
-   * each update compares deeply every part of the next state that is not
-   * the very object of the current one; a state whose updates already keep
-   * what they do not change, as `{ ...prev, x }` does, gains nothing from it.
+   * Defaults to `false`: the next state is written as given. With it on, each
+   * update compares deeply every part of the next state that is not the very
+   * object of the current one; a state whose updates already keep what they do
+   * not change, as `{ ...prev, x }` does, gains nothing from it.
    */
   keepEqualParts?: boolean | ReplaceEqualDeepOptions;
 }>;

package/src/utils/create-state.mts

@@ -107,8 +107,8 @@ import { createStateSource } from './state-source.mjs';
  *
  * assert.strictEqual(report.getSnapshot().value, held);
  *
- * // An edited title: a new report and a new array, while the summary is
- * // the one held, so `summary` is not told of it.
+ * // An edited title: a new report and a new array, while the summary is the
+ * // one held, so `summary` is not told of it.
  * setReport({
  *   summary: { open: 1 },
  *   pulls: [{ number: 1, title: 'one (edited)' }],
@@ -146,8 +146,8 @@ export const createState = <S,>(
     options,
   );
 
-  // Each compares with the state the write started from, as `dispatch`
-  // does, and builds nothing on the way.
+  // Each compares with the state the write started from, as `dispatch` does,
+  // and builds nothing on the way.
   const updateState = (updateFn: (prev: S) => S): S => {
     const currentState = getSnapshot();
 

package/src/utils/create-state.test.mts

@@ -54,8 +54,8 @@ describe(createState, () => {
   });
 
   // What `equals` is for: whatever reads the state, directly or through
-  // anything derived from it, is told only of a real change, and an equal
-  // value written over the current one leaves the object that is there.
+  // anything derived from it, is told only of a real change, and an equal value
+  // written over the current one leaves the object that is there.
   test('keeps the current object when `equals` finds the next one equal to it', () => {
     const [state, setState, { getSnapshot }] = createState<readonly number[]>(
       [1, 2],

package/src/utils/state-source.mts

@@ -3,9 +3,9 @@ import { source, type InitializedSourceObservable } from '../core/index.mjs';
 import type { StateOptions } from './create-reducer.mjs';
 
 /**
- * What `createState` and `createReducer` are both built on: the source
- * holding the state, its current value, and `commit`, the one way either
- * writes it. `commit` writes `reduced` unless `equals` finds it the same as
+ * What `createState` and `createReducer` are both built on: the source holding
+ * the state, its current value, and `commit`, the one way either writes it.
+ * `commit` writes `reduced` unless `equals` finds it the same as
  * `currentState`, after keeping the parts of `currentState` it did not change
  * when `keepEqualParts` asks for that, and returns the state written, or
  * `currentState` when nothing was.