synstate 4.1.0 → 5.0.0

package/dist/utils/create-reducer.d.mts

@@ -1,3 +1,4 @@
+import { type ReplaceEqualDeepOptions } from 'ts-data-forge';
 import type { Reducer } from 'ts-type-forge';
 import { type InitializedObservable } from '../core/index.mjs';
 /**
@@ -9,7 +10,8 @@ import { type InitializedObservable } from '../core/index.mjs';
  * @param reducer - A pure function that takes current state and action, returns new state
  * @param initialState - The initial value of the state
  * @param options - {@link StateOptions}: `equals` (default `Object.is`),
- *   to pass on only the dispatches that change the state
+ *   to pass on only the dispatches that change the state, and
+ *   `keepEqualParts`, to keep the parts of the state a dispatch did not change
  * @returns A 3-element tuple: `[state, dispatch, { getSnapshot, initialState }]`.
  *   `dispatch` returns the state it leaves; once `state` is completed, that
  *   is the state held.
@@ -102,5 +104,32 @@ export type StateOptions<S> = Readonly<{
      * @param next - The state the update would set
      */
     equals?: (current: S, next: S) => boolean;
+    /**
+     * 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
+     * ts-data-forge): a reader of an unchanged part keeps the object it has, so
+     * `skipIfNoChange()` with `Object.is` stops it. When the whole next state is
+     * deeply equal, the current state is kept and nothing is passed on, so
+     * `equals` can stay `Object.is`.
+     *
+     * This is for a state written whole from a source that answers with a new
+     * object every time, a server polled for a report, say. Array items are
+     * matched by index; pass `{ key }` to match them by key, an item for which
+     * `key` returns `undefined` being matched by index. Only plain objects and
+     * 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.
+     *
+     * 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;
 }>;
 //# sourceMappingURL=create-reducer.d.mts.map

package/dist/utils/create-reducer.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"create-reducer.d.mts","sourceRoot":"","sources":["../../src/utils/create-reducer.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAU,KAAK,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2EG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,EAAE,CAAC,WACvB,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,gBACR,CAAC,YACL,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KACjC,SAAS,CACV,KAAK,EAAE,qBAAqB,CAAC,CAAC,CAAC,EAC/B,QAAQ,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,EAC1B,KAAK,EAAE,QAAQ,CAAC;IACd,WAAW,EAAE,MAAM,CAAC,CAAC;IACrB,YAAY,EAAE,CAAC,CAAC;CACjB,CAAC,CAoBH,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,QAAQ,CAAC;IACrC;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC;CAC3C,CAAC,CAAC"}
+{"version":3,"file":"create-reducer.d.mts","sourceRoot":"","sources":["../../src/utils/create-reducer.mts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAC/E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAU,KAAK,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4EG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,EAAE,CAAC,WACvB,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,gBACR,CAAC,YACL,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KACjC,SAAS,CACV,KAAK,EAAE,qBAAqB,CAAC,CAAC,CAAC,EAC/B,QAAQ,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,EAC1B,KAAK,EAAE,QAAQ,CAAC;IACd,WAAW,EAAE,MAAM,CAAC,CAAC;IACrB,YAAY,EAAE,CAAC,CAAC;CACjB,CAAC,CA8BH,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,QAAQ,CAAC;IACrC;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC;IAE1C;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,cAAc,CAAC,EAAE,OAAO,GAAG,uBAAuB,CAAC;CACpD,CAAC,CAAC"}

package/dist/utils/create-reducer.mjs

@@ -1,3 +1,4 @@
+import { replaceEqualDeep } from 'ts-data-forge';
 import { source } from '../core/index.mjs';
 
 
@@ -73,14 +74,20 @@ import { source } from '../core/index.mjs';
 
 
 
+
 
 
 export const createReducer = (reducer, initialState, options) => {
     const state = source(initialState);
     const equals = options?.equals ?? Object.is;
+    const keepEqualParts = options?.keepEqualParts ?? false;
+    const keepOptions = typeof keepEqualParts === 'boolean' ? undefined : keepEqualParts;
     const dispatch = (action) => {
         const currentState = state.getSnapshot().value;
-        const nextState = reducer(currentState, action);
+        const reduced = reducer(currentState, action);
+        const nextState = keepEqualParts === false
+            ? reduced
+            : replaceEqualDeep(currentState, reduced, keepOptions);
 
         return equals(currentState, nextState)
             ? currentState

package/dist/utils/create-reducer.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"create-reducer.mjs","sourceRoot":"","sources":["../../src/utils/create-reducer.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAA8B,MAAM,mBAAmB,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2EG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAC3B,OAAsB,EACtB,YAAe,EACf,OAAkC,EAQlC,EAAE;IACF,MAAM,KAAK,GAAG,MAAM,CAAI,YAAY,CAAC,CAAC;IAEtC,MAAM,MAAM,GAAG,OAAO,EAAE,MAAM,IAAI,MAAM,CAAC,EAAE,CAAC;IAE5C,MAAM,QAAQ,GAAG,CAAC,MAAS,EAAK,EAAE;QAChC,MAAM,YAAY,GAAG,KAAK,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC;QAE/C,MAAM,SAAS,GAAG,OAAO,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;QAEhD,8DAA8D;QAC9D,OAAO,MAAM,CAAC,YAAY,EAAE,SAAS,CAAC;YACpC,CAAC,CAAC,YAAY;YACd,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IAC5B,CAAC,CAAC;IAEF,MAAM,WAAW,GAAG,GAAM,EAAE,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC;IAEvD,OAAO,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,WAAW,EAAE,YAAY,EAAE,CAAU,CAAC;AACnE,CAAC,CAAC"}
+{"version":3,"file":"create-reducer.mjs","sourceRoot":"","sources":["../../src/utils/create-reducer.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAgC,MAAM,eAAe,CAAC;AAE/E,OAAO,EAAE,MAAM,EAA8B,MAAM,mBAAmB,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4EG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAC3B,OAAsB,EACtB,YAAe,EACf,OAAkC,EAQlC,EAAE;IACF,MAAM,KAAK,GAAG,MAAM,CAAI,YAAY,CAAC,CAAC;IAEtC,MAAM,MAAM,GAAG,OAAO,EAAE,MAAM,IAAI,MAAM,CAAC,EAAE,CAAC;IAE5C,MAAM,cAAc,GAAG,OAAO,EAAE,cAAc,IAAI,KAAK,CAAC;IAExD,MAAM,WAAW,GACf,OAAO,cAAc,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,cAAc,CAAC;IAEnE,MAAM,QAAQ,GAAG,CAAC,MAAS,EAAK,EAAE;QAChC,MAAM,YAAY,GAAG,KAAK,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC;QAE/C,MAAM,OAAO,GAAG,OAAO,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;QAE9C,MAAM,SAAS,GACb,cAAc,KAAK,KAAK;YACtB,CAAC,CAAC,OAAO;YACT,CAAC,CAAC,gBAAgB,CAAC,YAAY,EAAE,OAAO,EAAE,WAAW,CAAC,CAAC;QAE3D,8DAA8D;QAC9D,OAAO,MAAM,CAAC,YAAY,EAAE,SAAS,CAAC;YACpC,CAAC,CAAC,YAAY;YACd,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IAC5B,CAAC,CAAC;IAEF,MAAM,WAAW,GAAG,GAAM,EAAE,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC;IAEvD,OAAO,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,WAAW,EAAE,YAAY,EAAE,CAAU,CAAC;AACnE,CAAC,CAAC"}

package/dist/utils/create-state.d.mts

@@ -7,7 +7,8 @@ import { type StateOptions } from './create-reducer.mjs';
  * @template S - The type of the state
  * @param initialState - The initial value of the state
  * @param options - {@link StateOptions}: `equals` (default `Object.is`),
- *   to pass on only the updates that change the state
+ *   to pass on only the updates that change the state, and `keepEqualParts`,
+ *   to keep the parts of the state an update did not change
  * @returns A 3-element tuple: `[state, setState, { updateState, resetState, getSnapshot, initialState }]`
  *
  * @example
@@ -67,6 +68,57 @@ import { type StateOptions } from './create-reducer.mjs';
  * ]);
  * ```
  *
+ * @example
+ * ```ts
+ * type PullReport = DeepReadonly<{
+ *   summary: { open: number };
+ *   pulls: { number: number; title: string }[];
+ * }>;
+ *
+ * const [report, setReport] = createState<PullReport>(
+ *   { summary: { open: 0 }, pulls: [] },
+ *   { keepEqualParts: true },
+ * );
+ *
+ * const summary = report.pipe(map((r) => r.summary)).pipe(skipIfNoChange());
+ *
+ * const summaryHistory: unknown[] = [];
+ *
+ * summary.subscribe((value) => {
+ *   summaryHistory.push(value);
+ * });
+ *
+ * // A server answers each poll with the whole report, a new object every
+ * // time. What did not change keeps the object already held.
+ * setReport({
+ *   summary: { open: 1 },
+ *   pulls: [{ number: 1, title: 'one' }],
+ * });
+ *
+ * const held = report.getSnapshot().value;
+ *
+ * // An answer that changes nothing is not passed on at all.
+ * setReport({
+ *   summary: { open: 1 },
+ *   pulls: [{ number: 1, title: 'one' }],
+ * });
+ *
+ * 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.
+ * setReport({
+ *   summary: { open: 1 },
+ *   pulls: [{ number: 1, title: 'one (edited)' }],
+ * });
+ *
+ * assert.notStrictEqual(report.getSnapshot().value, held);
+ *
+ * assert.strictEqual(report.getSnapshot().value.summary, held.summary);
+ *
+ * assert.deepStrictEqual(summaryHistory, [{ open: 0 }, { open: 1 }]);
+ * ```
+ *
  * @note Do not call `setState`, `updateState` or `resetState` from a subscriber or a projection while another
  * update is propagating: the write propagates immediately, so subscribers can
  * see an intermediate state, and it logs a `console.warn` (once per

package/dist/utils/create-state.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"create-state.d.mts","sourceRoot":"","sources":["../../src/utils/create-state.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,EAAiB,KAAK,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAuBxE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,gBACb,CAAC,YACL,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KACjC,SAAS,CACV,KAAK,EAAE,qBAAqB,CAAC,CAAC,CAAC,EAC/B,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,EACrB,KAAK,EAAE,QAAQ,CAAC;IACd,WAAW,EAAE,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC7C,UAAU,EAAE,MAAM,CAAC,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC,CAAC;IACrB,YAAY,EAAE,CAAC,CAAC;CACjB,CAAC,CA0BH,CAAC"}
+{"version":3,"file":"create-state.d.mts","sourceRoot":"","sources":["../../src/utils/create-state.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,EAAiB,KAAK,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAuBxE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6HG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,gBACb,CAAC,YACL,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KACjC,SAAS,CACV,KAAK,EAAE,qBAAqB,CAAC,CAAC,CAAC,EAC/B,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,EACrB,KAAK,EAAE,QAAQ,CAAC;IACd,WAAW,EAAE,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC7C,UAAU,EAAE,MAAM,CAAC,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC,CAAC;IACrB,YAAY,EAAE,CAAC,CAAC;CACjB,CAAC,CA0BH,CAAC"}

package/dist/utils/create-state.mjs

@@ -60,6 +60,58 @@ const reducer = (state, action) => {
 
 
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 

package/dist/utils/create-state.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"create-state.mjs","sourceRoot":"","sources":["../../src/utils/create-state.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAqB,MAAM,sBAAsB,CAAC;AAaxE,MAAM,OAAO,GAAG,CAAK,KAAQ,EAAE,MAAiB,EAAK,EAAE;IACrD,QAAQ,MAAM,CAAC,IAAI,EAAE,CAAC;QACpB,KAAK,KAAK;YACR,OAAO,MAAM,CAAC,SAAS,CAAC;QAE1B,KAAK,QAAQ;YACX,OAAO,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAClC,CAAC;AACH,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CACzB,YAAe,EACf,OAAkC,EAUlC,EAAE;IACF,MAAM,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,WAAW,EAAE,CAAC,GAAG,aAAa,CACtD,OAAO,EACP,YAAY,EACZ,OAAO,CACR,CAAC;IAEF,MAAM,WAAW,GAAG,CAAC,QAAwB,EAAK,EAAE,CAClD,QAAQ,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC,CAAC;IAEzC,MAAM,QAAQ,GAAG,CAAC,SAAY,EAAK,EAAE,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC;IAE3E,MAAM,UAAU,GAAG,GAAM,EAAE,CACzB,QAAQ,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,CAAC,CAAC;IAErD,OAAO;QACL,KAAK;QACL,QAAQ;QACR;YACE,WAAW;YACX,UAAU;YACV,WAAW;YACX,YAAY;SACb;KACO,CAAC;AACb,CAAC,CAAC"}
+{"version":3,"file":"create-state.mjs","sourceRoot":"","sources":["../../src/utils/create-state.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAqB,MAAM,sBAAsB,CAAC;AAaxE,MAAM,OAAO,GAAG,CAAK,KAAQ,EAAE,MAAiB,EAAK,EAAE;IACrD,QAAQ,MAAM,CAAC,IAAI,EAAE,CAAC;QACpB,KAAK,KAAK;YACR,OAAO,MAAM,CAAC,SAAS,CAAC;QAE1B,KAAK,QAAQ;YACX,OAAO,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAClC,CAAC;AACH,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6HG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CACzB,YAAe,EACf,OAAkC,EAUlC,EAAE;IACF,MAAM,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,WAAW,EAAE,CAAC,GAAG,aAAa,CACtD,OAAO,EACP,YAAY,EACZ,OAAO,CACR,CAAC;IAEF,MAAM,WAAW,GAAG,CAAC,QAAwB,EAAK,EAAE,CAClD,QAAQ,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC,CAAC;IAEzC,MAAM,QAAQ,GAAG,CAAC,SAAY,EAAK,EAAE,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC;IAE3E,MAAM,UAAU,GAAG,GAAM,EAAE,CACzB,QAAQ,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,CAAC,CAAC;IAErD,OAAO;QACL,KAAK;QACL,QAAQ;QACR;YACE,WAAW;YACX,UAAU;YACV,WAAW;YACX,YAAY;SACb;KACO,CAAC;AACb,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "synstate",
-  "version": "4.1.0",
+  "version": "5.0.0",
   "description": "Type-safe State Management Library for TypeScript/JavaScript",
   "repository": {
     "type": "git",
@@ -29,20 +29,20 @@
     "LICENSE"
   ],
   "dependencies": {
-    "ts-data-forge": "^14.9.0",
+    "ts-data-forge": "^14.10.0",
     "ts-std-forge": "^0.5.2",
     "ts-type-forge": "^9.2.2"
   },
   "devDependencies": {
     "@reduxjs/toolkit": "2.13.0",
-    "@sumi-lang/cli": "0.0.7",
+    "@sumi-lang/cli": "0.1.0",
     "@types/react": "19.3.0",
     "@vitest/browser-playwright": "5.0.3",
     "argparse": "3.0.2",
-    "eslint-config-typed": "5.19.0",
-    "eslint-plugin-ts-data-forge": "0.10.0",
-    "eslint-plugin-ts-fortress": "1.3.5",
-    "eslint-plugin-ts-type-forge": "0.8.10",
+    "eslint-config-typed": "5.19.1",
+    "eslint-plugin-ts-data-forge": "0.10.2",
+    "eslint-plugin-ts-fortress": "1.3.7",
+    "eslint-plugin-ts-type-forge": "0.8.12",
     "jotai": "3.0.1",
     "mobx": "7.0.6",
     "playwright": "1.64.0",
@@ -51,8 +51,8 @@
     "prettier-plugin-packagejson": "3.0.2",
     "react": "19.3.0",
     "rxjs": "7.8.2",
-    "synstate-react-hooks": "4.1.0",
-    "synstate-react-hooks-compat": "4.1.0",
+    "synstate-react-hooks": "5.0.0",
+    "synstate-react-hooks-compat": "5.0.0",
     "ts-repo-utils": "10.7.1",
     "valtio": "2.3.2",
     "zustand": "5.0.15"

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

@@ -2,7 +2,7 @@
 // @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, hasKey, isRecord, type Optional, type Some } from 'ts-data-forge';
+import { hasKey, isRecord, type Optional, type Some } from 'ts-data-forge';
 import { panic } from 'ts-std-forge';
 import type { MutableSet } from 'ts-type-forge';
 import type {
@@ -21,11 +21,7 @@ import type {
 import { maxDepth } from '../utils/index.mjs';
 import { ManagerObservableClass } from './manager-observable-class.mjs';
 import { ObservableBaseClass } from './observable-base-class.mjs';
-import {
-  toNode,
-  type ChildNode,
-  type ManagerNode,
-} from './observable-node.mjs';
+import { toNode, type ChildNode } from './observable-node.mjs';
 import { runAfterPropagation } from './propagation-state.mjs';
 
 type ChildObservableConfig<A, P extends NonEmptyUnknownList> = Readonly<{
@@ -57,7 +53,6 @@ export class SyncChildObservableClass<A, const P extends NonEmptyUnknownList>
 {
   #mut_isAttached: boolean;
   readonly parents: Wrap<P>;
-  readonly managers: readonly ManagerNode[];
 
   constructor({
     parents,
@@ -72,17 +67,14 @@ export class SyncChildObservableClass<A, const P extends NonEmptyUnknownList>
 
     this.parents = parents;
 
-    this.managers = managersOf(parents);
-
     this.#mut_isAttached = false;
   }
 
   /**
-   * Joins the current scope and registers this observable to its parents
-   * and the managers it is reached from. Completed parents never update
-   * again, so a child created under them is complete from the start
-   * (#2248), as is one its constructor completed; registering it would only
-   * leave a reference in each parent.
+   * Joins the current scope and registers this observable to its parents.
+   * Completed parents never update again, so a child created under them is
+   * complete from the start (#2248), as is one its constructor completed;
+   * registering it would only leave a reference in each parent.
    */
   protected attach(): void {
     this.adoptIntoCurrentScope();
@@ -90,7 +82,7 @@ export class SyncChildObservableClass<A, const P extends NonEmptyUnknownList>
     if (this.isCompleted || this.parents.every((p) => p.isCompleted)) {
       this.complete();
     } else {
-      registerChild(this, this.managers);
+      registerChild(this);
 
       this.#mut_isAttached = true;
     }
@@ -103,7 +95,7 @@ export class SyncChildObservableClass<A, const P extends NonEmptyUnknownList>
 
     this.#mut_isAttached = false;
 
-    unregisterChild(this, this.managers);
+    unregisterChild(this);
   }
 
   override tryComplete(): void {
@@ -170,7 +162,7 @@ export class AsyncChildObservableClass<A, const P extends NonEmptyUnknownList>
     if (this.isCompleted || this.parents.every((p) => p.isCompleted)) {
       this.complete();
     } else {
-      registerChild(this, managersOf(this.parents));
+      registerChild(this);
 
       this.#mut_isAttached = true;
     }
@@ -183,7 +175,7 @@ export class AsyncChildObservableClass<A, const P extends NonEmptyUnknownList>
 
     this.#mut_isAttached = false;
 
-    unregisterChild(this, managersOf(this.parents));
+    unregisterChild(this);
   }
 
   override tryComplete(): void {
@@ -247,11 +239,8 @@ const shouldComplete = (
   !child.isCompleted &&
   (child.parents.every((p) => p.isCompleted) || child.canEmitNoMore());
 
-/** Registers a child to its parents and to `managers`. */
-const registerChild = (
-  child: ChildNode,
-  managers: readonly ManagerNode[],
-): void => {
+/** Registers a child to its parents. */
+const registerChild = (child: ChildNode): void => {
   if (checksCircularDependency) {
     detectCircularDependency(child);
   }
@@ -259,42 +248,19 @@ const registerChild = (
   for (const p of child.parents) {
     toNode(p).addChild(child);
   }
-
-  for (const m of managers) {
-    m.addDescendant(child);
-  }
 };
 
 /**
  * Undoes {@link registerChild} for a completed child: its parents forget it,
- * and every manager it registered to stops propagating updates to it.
- * Without this a completed node stayed reachable for as long as its root
- * lived, and ran its `tryUpdate` on every update (#2134).
+ * so that no update puts it in its queue again. Without this a completed
+ * node stayed reachable for as long as its root lived (#2134).
  */
-const unregisterChild = (
-  child: ChildNode,
-  managers: readonly ManagerNode[],
-): void => {
+const unregisterChild = (child: ChildNode): void => {
   for (const p of child.parents) {
     toNode(p).deleteChild(child);
   }
-
-  for (const m of managers) {
-    m.deleteDescendant(child);
-  }
 };
 
-/**
- * The managers the descendants of `parents` register to, shared with the
- * parent when there is one.
- */
-const managersOf = (
-  parents: readonly Observable<unknown>[],
-): readonly ManagerNode[] =>
-  Arr.isFixedLengthArray(1, parents)
-    ? toNode(parents[0]).managers
-    : Array.from(new Set(parents.flatMap((p) => toNode(p).managers)));
-
 const isDevelopmentProcess = (): boolean => {
   const proc: unknown = Reflect.get(globalThis, 'process');
 

package/src/core/class/create-child-observable.mts

@@ -61,7 +61,10 @@ export type AsyncChildObservableTools<A> = Readonly<{
  * hooks the factory calls, which read the state `init` creates.
  */
 export type SyncChildObservableHooks = Readonly<{
-  /** Called with the token of every update that reaches this observable. */
+  /**
+   * Called with the token of every update in which a parent of this
+   * observable emitted.
+   */
   tryUpdate: (updateToken: UpdateToken) => void;
 
   /**
@@ -124,10 +127,10 @@ export type InitializedChildObservableConfig<
  * other synchronous operators are built with it.
  *
  * `init` runs during construction and receives the tools. It returns
- * `tryUpdate`, which is called with the token of every update that reaches
- * this observable — a parent that did not emit in that update has a different
- * `updateToken`; to emit, call `setNext` with the token received — or an
- * object holding `tryUpdate` and the other hooks
+ * `tryUpdate`, which is called with the token of every update in which some
+ * parent of this observable emitted — a parent that did not emit in that
+ * update has a different `updateToken`; to emit, call `setNext` with the
+ * token received — or an object holding `tryUpdate` and the other hooks
  * ({@link SyncChildObservableHooks}). State the hooks share can live inside
  * `init`, next to the teardown it registers with the `onComplete` tool.
  * `init` may complete the observable; it is then never registered to its

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

@@ -1,137 +1,32 @@
 // @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 type { Optional } from 'ts-data-forge';
-import type { MutableSet } from 'ts-type-forge';
-import type { ManagerObservableKind, UpdateToken } from '../types/index.mjs';
-import { issueUpdateToken } from '../utils/index.mjs';
+import type { ManagerObservableKind } from '../types/index.mjs';
 import { ObservableBaseClass } from './observable-base-class.mjs';
-import type { ChildNode, ManagerNode } from './observable-node.mjs';
-import { beginPropagation, endPropagation } from './propagation-state.mjs';
+import {
+  beginPropagation,
+  closeUpdate,
+  drainUpdate,
+  endPropagation,
+  openUpdate,
+} from './propagation-state.mjs';
 
 /**
  * The base of the observables that start updates of their own: a root, and
  * an async child (`debounce`, `switchMap`), which emits later than its
- * parents do. Every descendant registers to the managers it is reached from,
- * and an update reaches them in ascending depth, so that each sees its
- * parents' values of that update (no glitch).
+ * parents do. Its update visits, shallowest first, the nodes its value
+ * reaches: each node that emits puts its children in the update's queue
+ * (`propagation-state.mts`), so that each sees its parents' values of that
+ * update (no glitch) and a node no value reached is not visited.
  */
 export class ManagerObservableClass<
   A,
   Kind extends ManagerObservableKind,
   Depth extends number,
 > extends ObservableBaseClass<A, Kind, Depth> {
-  /**
-   * The descendants, by depth: the set at index `i` holds those at
-   * `depth + 1 + i`, in the order they registered. Depths below a live node
-   * never skip one (every live node has a live parent one level up), so the
-   * array has few holes; a hole is `undefined`, never a gap left for V8 to
-   * treat as a holey array.
-   *
-   * An update walks this array and its sets in place. Adding or removing a
-   * node is O(1) and there is no flat order to rebuild; only the first node
-   * of a depth replaces the array with a longer copy. A node deleted during
-   * the walk is skipped by the set's iterator; a node registered during it is
-   * also put in `#mut_joinedDuringUpdate` and skipped, so an update visits the
-   * nodes that existed when it began.
-   */
-  #mut_propagationOrder: readonly (MutableSet<ChildNode> | undefined)[];
-
-  /** Whether this node is propagating an update of its own. */
-  #mut_isPropagating: boolean;
-
-  /**
-   * The descendants that registered while this node propagated the update
-   * under way, which that update does not visit; made when the first one
-   * arrives. Kept on the manager rather than in a module, so that it also
-   * holds for a node another copy of synstate registered.
-   */
-  #mut_joinedDuringUpdate: MutableSet<ChildNode> | undefined;
-
-  /** The managers this node's descendants register to: itself. */
-  readonly managers: readonly ManagerNode[];
-
-  constructor(
-    config: Readonly<{
-      kind: Kind;
-      depth: Depth;
-      initialValue: Optional<A>;
-    }>,
-  ) {
-    super(config);
-
-    this.managers = [this];
-
-    this.#mut_propagationOrder = [];
-
-    this.#mut_isPropagating = false;
-
-    this.#mut_joinedDuringUpdate = undefined;
-  }
-
-  /**
-   * Runs `tryUpdate` on the descendants, shallowest first, skipping those
-   * registered after this update began.
-   */
-  #propagate(updateToken: UpdateToken): void {
-    for (const bucket of this.#mut_propagationOrder) {
-      if (bucket !== undefined) {
-        for (const c of bucket) {
-          // Read for each node, since the set is made when the first joins.
-          if (this.#mut_joinedDuringUpdate?.has(c) !== true) {
-            c.tryUpdate(updateToken);
-          }
-        }
-      }
-    }
-  }
-
-  addDescendant(child: ChildNode): void {
-    const descendants = this.#mut_propagationOrder;
-
-    const index = child.depth - this.depth - 1;
-
-    const mut_bucket = descendants[index];
-
-    if (mut_bucket === undefined) {
-      // The first node of its depth: rare, so the array is copied rather than
-      // written, which also leaves a walk already under way on the old one.
-      this.#mut_propagationOrder = Array.from(
-        { length: Math.max(descendants.length, index + 1) },
-        (_, i) => (i === index ? new Set([child]) : descendants[i]),
-      );
-    } else {
-      mut_bucket.add(child);
-    }
-
-    if (!this.#mut_isPropagating) {
-      return;
-    }
-
-    this.#mut_joinedDuringUpdate ??= new Set();
-
-    this.#mut_joinedDuringUpdate.add(child);
-  }
-
-  deleteDescendant(child: ChildNode): void {
-    // An emptied set stays, to be reused by the next node of its depth.
-    this.#mut_propagationOrder[child.depth - this.depth - 1]?.delete(child);
-  }
-
   /** Emits `nextValue` and propagates it to the descendants. */
   protected startUpdate(nextValue: A): void {
-    const updateToken = issueUpdateToken();
-
-    // A write to this same manager from inside its own update starts an inner
-    // one; what joins during it joined during the outer one too.
-    const wasPropagating = this.#mut_isPropagating;
-
-    const joinedBefore = this.#mut_joinedDuringUpdate;
-
-    this.#mut_isPropagating = true;
-
-    this.#mut_joinedDuringUpdate = undefined;
+    const updateToken = openUpdate(this.depth);
 
     beginPropagation(updateToken);
 
@@ -142,23 +37,9 @@ export class ManagerObservableClass<
     try {
       this.setNext(nextValue, updateToken);
 
-      this.#propagate(updateToken);
+      drainUpdate(updateToken);
     } finally {
-      // Widened: TypeScript would take the write above for the value.
-      const joinedNow = this.#mut_joinedDuringUpdate as
-        MutableSet<ChildNode> | undefined;
-
-      this.#mut_isPropagating = wasPropagating;
-
-      this.#mut_joinedDuringUpdate = joinedBefore;
-
-      if (wasPropagating && joinedNow !== undefined) {
-        this.#mut_joinedDuringUpdate ??= new Set();
-
-        for (const c of joinedNow) {
-          this.#mut_joinedDuringUpdate.add(c);
-        }
-      }
+      closeUpdate(updateToken);
 
       endPropagation();
     }