wenay-react2 1.0.41 → 1.0.43

package/lib/common/src/utils/searchHistory.js

@@ -7,9 +7,11 @@ export function createSearchHistory(opts) {
     const max = Math.max(1, opts.max ?? 8);
     const st = memoryGetOrCreate(opts.key, { items: [] });
     const stApi = createUpdateApi(st);
-    function normalize() {
+    /** Pure derivation - reads must not rewrite the persisted object (a getter that
+     *  mutates state silently marks nothing dirty and surprises memoryCache diffing). */
+    function normalized() {
         const seen = new Set();
-        st.items = st.items
+        return st.items
             .map(normalizeSearchHistoryItem)
             .filter(Boolean)
             .filter(item => {
@@ -20,20 +22,19 @@ export function createSearchHistory(opts) {
             return true;
         })
             .slice(0, max);
-        return st.items;
     }
     function emit() {
-        normalize();
+        st.items = normalized(); // normalization happens on WRITE, announced below
         stApi.render();
         memoryMarkDirty(opts.key);
     }
     return {
         get items() {
-            return normalize().slice();
+            return normalized();
         },
         use() {
             stApi.use();
-            return normalize().slice();
+            return normalized();
         },
         add(value) {
             const item = normalizeSearchHistoryItem(value);

package/lib/common/src/utils/structEqual.d.ts

@@ -0,0 +1,12 @@
+/** Structural deep equality for plain config/data trees (objects, arrays, primitives).
+ *
+ *  Replacement for the `JSON.stringify(a) == JSON.stringify(b)` idiom, with the same
+ *  tolerance but none of its key-order sensitivity:
+ *  - object key ORDER does not matter (stringify's false-positive "changed");
+ *  - object props with `undefined` values count as absent (JSON drops them);
+ *  - `NaN` equals `NaN` (JSON serializes both to `null`);
+ *  - no serialization cost, early exit on first difference.
+ *
+ *  Not for class instances / Maps / Sets / cycles - data that would not survive
+ *  JSON round-tripping did not work with the stringify idiom either. */
+export declare function structEqual(a: unknown, b: unknown): boolean;

package/lib/common/src/utils/structEqual.js

@@ -0,0 +1,40 @@
+/** Structural deep equality for plain config/data trees (objects, arrays, primitives).
+ *
+ *  Replacement for the `JSON.stringify(a) == JSON.stringify(b)` idiom, with the same
+ *  tolerance but none of its key-order sensitivity:
+ *  - object key ORDER does not matter (stringify's false-positive "changed");
+ *  - object props with `undefined` values count as absent (JSON drops them);
+ *  - `NaN` equals `NaN` (JSON serializes both to `null`);
+ *  - no serialization cost, early exit on first difference.
+ *
+ *  Not for class instances / Maps / Sets / cycles - data that would not survive
+ *  JSON round-tripping did not work with the stringify idiom either. */
+export function structEqual(a, b) {
+    if (a === b)
+        return true;
+    if (typeof a == 'number' && typeof b == 'number')
+        return Number.isNaN(a) && Number.isNaN(b);
+    if (typeof a != 'object' || typeof b != 'object' || a == null || b == null)
+        return false;
+    const aArr = Array.isArray(a);
+    if (aArr != Array.isArray(b))
+        return false;
+    if (aArr) {
+        const x = a, y = b;
+        if (x.length != y.length)
+            return false;
+        for (let i = 0; i < x.length; i++)
+            if (!structEqual(x[i], y[i]))
+                return false;
+        return true;
+    }
+    const ao = a, bo = b;
+    const ka = Object.keys(ao).filter(k => ao[k] !== undefined);
+    const kb = Object.keys(bo).filter(k => bo[k] !== undefined);
+    if (ka.length != kb.length)
+        return false;
+    for (const k of ka)
+        if (!structEqual(ao[k], bo[k]))
+            return false;
+    return true;
+}

package/lib/common/updateBy.d.ts

@@ -2,7 +2,10 @@ import React from "react";
 type Listener = (a?: any) => void;
 interface ObserverState {
     listeners: Set<Listener>;
+    callbacks: Set<Listener>;
     version: number;
+    running: boolean;
+    pending: boolean;
 }
 export declare const map3: WeakMap<object, ObserverState>;
 export declare const mapWait: Map<object, {

package/lib/common/updateBy.js

@@ -1,4 +1,4 @@
-import { useCallback, useLayoutEffect, useSyncExternalStore } from "react";
+import React, { useCallback, useLayoutEffect, useSyncExternalStore } from "react";
 import { listen as createListen, waitRun } from "wenay-common2";
 export const map3 = new WeakMap();
 export const mapWait = new Map();
@@ -14,34 +14,59 @@ function getUpdateListen(obj) {
 function getObserverState(obj) {
     let state = map3.get(obj);
     if (!state) {
-        state = { listeners: new Set(), version: 0 };
+        state = { listeners: new Set(), callbacks: new Set(), version: 0, running: false, pending: false };
         map3.set(obj, state);
     }
     return state;
 }
-// reverse/lastOnly действуют только на React-подписчиков (useUpdateBy);
-// императивные on-подписчики вызываются всегда все, в порядке подписки
-function triggerUpdate(obj, reverse = false, lastOnly = false) {
+// reverse/lastOnly действуют только на React-подписчиков (useSyncExternalStore);
+// императивные f-колбэки вызываются всегда все, в порядке подписки, ДО React-нотификаторов
+function runTriggerPass(obj, state, reverse, lastOnly) {
     const listen = updateListens.get(obj);
-    let state = map3.get(obj);
-    if ((!state || state.listeners.size === 0) && !listen?.[1].count())
-        return;
-    state ??= getObserverState(obj);
     state.version += 1;
-    let listenersArray = Array.from(state.listeners);
+    // императивные f-колбэки: всегда все, в порядке подписки
+    Array.from(state.callbacks).forEach(callback => callback(obj));
+    const listenersArray = Array.from(state.listeners);
     if (lastOnly) {
         const last = listenersArray.at(-1);
         if (last)
             last(obj);
-        listen?.[0](obj);
-        return;
     }
-    if (reverse) {
-        listenersArray.reverse();
+    else {
+        if (reverse) {
+            listenersArray.reverse();
+        }
+        listenersArray.forEach(listener => listener(obj));
     }
-    listenersArray.forEach(listener => listener(obj));
     listen?.[0](obj);
 }
+const MAX_TRIGGER_PASSES = 100;
+function triggerUpdate(obj, reverse = false, lastOnly = false) {
+    const listen = updateListens.get(obj);
+    let state = map3.get(obj);
+    if ((!state || (state.listeners.size === 0 && state.callbacks.size === 0)) && !listen?.[1].count())
+        return;
+    state ??= getObserverState(obj);
+    // реентерабельность: синхронный renderBy по тому же объекту изнутри слушателя
+    // коалесцируется — помечаем pending и выходим, текущая итерация сделает ещё проход
+    if (state.running) {
+        state.pending = true;
+        return;
+    }
+    state.running = true;
+    try {
+        for (let pass = 0; pass < MAX_TRIGGER_PASSES; pass++) {
+            state.pending = false;
+            runTriggerPass(obj, state, reverse, lastOnly);
+            if (!state.pending)
+                break;
+        }
+    }
+    finally {
+        state.running = false;
+        state.pending = false;
+    }
+}
 function schedule(a, ms, reverse = false, lastOnly = false) {
     if (ms) {
         (mapWait.get(a) || mapWait.set(a, waitRun()).get(a))
@@ -63,29 +88,39 @@ export function renderByLast(a, ms) {
     schedule(a, ms, false, true);
 }
 export function useUpdateBy(a, f) {
+    // f прокидывается через ref: inline-колбэк (новая identity на каждый рендер)
+    // не должен вызывать переподписку — регистрируется одна стабильная обёртка на (a)
+    const fRef = React.useRef(f);
+    fRef.current = f;
+    const hasF = !!f;
     // стабильный subscribe: без useCallback React переподписывается на каждый рендер,
     // а удаление state из map3 при этом сбрасывало бы version → лишний форс-ререндер
     const subscribe = useCallback((listener) => {
-        if (f)
+        if (hasF)
             return () => { };
         const state = getObserverState(a);
         state.listeners.add(listener);
         return () => {
             state.listeners.delete(listener);
         };
-    }, [a, f]);
+    }, [a, hasF]);
     useSyncExternalStore(subscribe, 
     // getSnapshot must be pure: only read the version, subscribe creates the state
-    () => (f ? 0 : (map3.get(a)?.version ?? 0)));
+    () => (hasF ? 0 : (map3.get(a)?.version ?? 0)));
     useLayoutEffect(() => {
-        if (!f)
+        if (!hasF)
             return;
         const state = getObserverState(a);
-        state.listeners.add(f);
+        // обёртка передаёт тот же мутированный объект — для ветки Dispatch<SetStateAction<T>>
+        // setState(тот же ref) React бэйлаутит без ререндера (см. UpdateCallback)
+        const wrapper = (obj) => {
+            fRef.current?.(obj);
+        };
+        state.callbacks.add(wrapper);
         return () => {
-            state.listeners.delete(f);
+            state.callbacks.delete(wrapper);
         };
-    }, [a, f]);
+    }, [a, hasF]);
 }
 export function updateBy(a, f) {
     useUpdateBy(a, f);