wenay-react2 1.0.20 → 1.0.21

package/lib/common/src/styles/tokens.js

@@ -0,0 +1,40 @@
+// TS mirror of design tokens (src/style/tokens.css). Values must match CSS.
+// For inline styles, ag-grid themes (styleGrid.ts, grid/agGrid4/theme.ts), and layers (z-index).
+export const tokens = {
+    color: {
+        bgDark: '#131821',
+        bgLight: '#17202e',
+        scrollbarTrack: 'rgba(255, 255, 255, 0)',
+        scrollbarThumb: '#1d262c',
+        scrollbarThumbAlt: '#4c4562',
+        textBase: '#c4c4c4',
+        textTheme: '#5D9FFA',
+        borderCommon: 'rgb(50, 62, 71)',
+    },
+    menu: {
+        bgColor: 'rgba(12, 12, 12, 0.91)',
+        blur: '10px',
+        border: '1px solid rgba(255, 255, 255, 0.41)',
+        activeBackground: 'rgba(255, 255, 255, 0.23)',
+        itemColor: '#fff',
+        itemHoverColor: '#101010',
+        itemHoverBgColor: '#fff',
+    },
+    font: {
+        family: 'Roboto',
+        sizeBase: '12px',
+    },
+    zIndex: {
+        /** CSS variable --wenay-z-modal; fallback in ModalProvider */
+        modal: 9999,
+    },
+    /** ag-grid theme params shared by GridStyleDefault (legacy) and agGrid4 buildAgTheme */
+    grid: {
+        fontFamily: 'Roboto',
+        textColor: 'rgba(214,214,214,0.9)',
+        tabTextColor: 'rgba(227,227,227,0.9)',
+        fontSize: '10px',
+        spacing: '3px',
+        backgroundColor: 'rgb(19,24,33)',
+    },
+};

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

@@ -6,9 +6,15 @@ declare const optionsDef: {
     sync: boolean;
 };
 type options = Partial<typeof optionsDef>;
+/**
+ * @deprecated v1: does not support row removal and silently loses data while the grid is not ready.
+ * Use `useAgGrid`/`createGridBuffer` (grid/agGrid4) - buffer + attach/sync,
+ * or at least `applyTransactionAsyncUpdate2`.
+ */
 export declare function applyTransactionAsyncUpdate<T>(grid: GridReadyEvent<T, any> | null | undefined, newData: (Partial<T>)[], getId: (...a: any[]) => string, bufTable: {
     [id: string]: Partial<T>;
 }, option?: options): void;
+/** @deprecated No-op stub: always returns {}. Never implemented; will be removed in a major version. */
 export declare function getUpdateTable<T>(grid: GridReadyEvent<T, any> | null | undefined, newData: (Partial<T>)[], getId: (...a: any[]) => string, bufTable: {
     [id: string]: Partial<T>;
 }, option?: options): {};
@@ -42,5 +48,6 @@ export declare function applyTransactionAsyncUpdate2<T>(params: params<T>): void
 type UnUndefined<T extends (any | undefined)> = T extends undefined ? never : T;
 type t1<T = any> = ColDef<T>["comparator"];
 type paramsCompare<TData = any> = Parameters<Extract<UnUndefined<t1>, (...args: any) => any>>;
+/** @deprecated Duplicate of `numericComparator` from grid/agGrid4 (core.ts) - use that instead. */
 export declare function getComparatorGrid<T = any>(func?: (...param: paramsCompare<T>) => [a: number, b: number]): t1;
 export {};

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

@@ -1,4 +1,4 @@
-// обертка для упрощения работы с гридом через точку памяти
+// Wrapper to simplify working with the grid through a memory point
 const optionsDef = {
     update: true,
     add: true,
@@ -9,7 +9,7 @@ function applyTransactionAsyncUpdate3({ getId, bufTable, option, newData, grid,
     const op = { ...optionsDef, ...(option ?? {}) };
     if (!grid?.api.getRowNode)
         return;
-    // определяем какие строки надо добавить, а какие только обновить
+    // Determine which rows must be added and which only need updates
     const arrNew = [];
     const arr = newData.map(e => {
         const id = getId(e);
@@ -31,16 +31,22 @@ function applyTransactionAsyncUpdate3({ getId, bufTable, option, newData, grid,
         });
         return;
     }
-    // remove применяем один раз и независимо: иначе при пустых add/update удаление терялось, а при обоих — дублировалось
+    // Apply remove once and independently: otherwise removal was lost with empty add/update and duplicated with both
     if ((arrNew.length && op.add) || remove?.length)
         grid.api.applyTransaction({ add: (arrNew.length && op.add) ? arrNew : [], remove: remove });
     if (arr.length && op.update)
         grid.api.applyTransactionAsync({ update: arr });
 }
-// тут нет удаления но эта версия может использовать где то
+// There is no removal here, but this version may still be used somewhere
+/**
+ * @deprecated v1: does not support row removal and silently loses data while the grid is not ready.
+ * Use `useAgGrid`/`createGridBuffer` (grid/agGrid4) - buffer + attach/sync,
+ * or at least `applyTransactionAsyncUpdate2`.
+ */
 export function applyTransactionAsyncUpdate(grid, newData, getId, bufTable, option) {
     return applyTransactionAsyncUpdate3({ getId, option, newData, grid, bufTable });
 }
+/** @deprecated No-op stub: always returns {}. Never implemented; will be removed in a major version. */
 export function getUpdateTable(grid, newData, getId, bufTable, option) {
     return {};
 }
@@ -57,7 +63,7 @@ export function applyTransactionAsyncUpdate2(params) {
     const g = resolveGrid(params);
     if (g && params.onlyMemo != true) {
         if (params.synchronization) {
-            // === СИНХРОНИЗАЦИЯ: bufTable — истина ===
+            // === SYNCHRONIZATION: bufTable is the source of truth ===
             const bufIds = new Set(Object.keys(bufTable));
             const gridIds = new Set();
             const arrAdd = [];
@@ -106,17 +112,18 @@ export function applyTransactionAsyncUpdate2(params) {
         });
     }
 }
+/** @deprecated Duplicate of `numericComparator` from grid/agGrid4 (core.ts) - use that instead. */
 export function getComparatorGrid(func) {
     return (...param) => {
-        const [a1, b1, modeA, modeB, inv] = param; // Распаковка параметров в функцию
-        const [a, b] = func ? func(...param) : [a1, b1]; // Использование преобразующей функции func, если передана
+        const [a1, b1, modeA, modeB, inv] = param; // Unpack parameters into the function
+        const [a, b] = func ? func(...param) : [a1, b1]; // Use the transforming func if provided
         return ((typeof a == "number" && !Number.isNaN(a)) &&
-            (typeof b == "number" && !Number.isNaN(b))) // Если оба a и b - валидные числа
-            ? a - b // Разница между числами
+            (typeof b == "number" && !Number.isNaN(b))) // If both a and b are valid numbers
+            ? a - b // Difference between numbers
             : a == b
-                ? 0 // Если значения равны, возвращаем 0
+                ? 0 // If values are equal, return 0
                 : (!Number.isNaN(b) && b != undefined)
-                    ? (inv ? -1 : 1) // Если b существует: порядок определяется inv
-                    : (inv ? 1 : -1); // Если b отсутствует: порядок определяется inv
+                    ? (inv ? -1 : 1) // If b exists: order is determined by inv
+                    : (inv ? 1 : -1); // If b is missing: order is determined by inv
     };
 }

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

@@ -1,3 +1,9 @@
+/**
+ * Wraps an array of promise thunks with progress callbacks.
+ * CONTRACT: countOk/countError counters are correct only when thunks are run
+ * STRICTLY SEQUENTIALLY (one after another). During parallel execution (Promise.all),
+ * counter values in callbacks are a race and must not be relied on.
+ */
 export declare function ArrayPromise<T = unknown>({ arr, catchF, thenF }: {
     arr: (() => Promise<T>)[];
     thenF?: (data: T, i: number, countOk: number, countError: number, count: number) => unknown;

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

@@ -1,3 +1,9 @@
+/**
+ * Wraps an array of promise thunks with progress callbacks.
+ * CONTRACT: countOk/countError counters are correct only when thunks are run
+ * STRICTLY SEQUENTIALLY (one after another). During parallel execution (Promise.all),
+ * counter values in callbacks are a race and must not be relied on.
+ */
 export function ArrayPromise({ arr, catchF, thenF }) {
     let ok = 0, countError = 0;
     const count = arr.length;
@@ -8,7 +14,7 @@ export function ArrayPromise({ arr, catchF, thenF }) {
     const b = (error, i) => {
         ++countError;
         if (catchF)
-            return catchF?.(error, i, ok, countError, count);
+            return catchF(error, i, ok, countError, count);
         else
             throw error;
     };

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

@@ -1,19 +1,21 @@
 import { renderBy } from "../../updateBy";
-const HostName = location.toString();
+function getHostName() {
+    return typeof location != "undefined" ? location.toString() : "wenay-react2";
+}
 export class CSaveToCache {
     async set(key, value) {
         const t = new Response(JSON.stringify(value));
-        if (window.caches) {
+        if (typeof caches != "undefined") {
             const Cache = await caches.open(key);
-            await Cache.put(HostName, t);
+            await Cache.put(getHostName(), t);
             return true;
         }
         return false;
     }
     async get(key) {
-        if (window.caches) {
+        if (typeof caches != "undefined") {
             const Cache = await caches.open(key);
-            const cachedResponse = await Cache.match(HostName);
+            const cachedResponse = await Cache.match(getHostName());
             if (cachedResponse) {
                 return (await cachedResponse.json());
             }
@@ -21,7 +23,7 @@ export class CSaveToCache {
         return null;
     }
     async delete(key) {
-        if (window.caches) {
+        if (typeof caches != "undefined") {
             return await caches.delete(key);
         }
         return false;
@@ -29,14 +31,14 @@ export class CSaveToCache {
 }
 export class CSaveToLocalStorage {
     async set(key, value) {
-        if (window.localStorage) {
+        if (typeof localStorage != "undefined") {
             await localStorage.setItem(key, JSON.stringify(value));
             return true;
         }
         return false;
     }
     async get(key) {
-        if (window.localStorage) {
+        if (typeof localStorage != "undefined") {
             const st = await localStorage.getItem(key);
             if (st) {
                 try {
@@ -50,14 +52,14 @@ export class CSaveToLocalStorage {
         return null;
     }
     async delete(key) {
-        if (window.localStorage) {
+        if (typeof localStorage != "undefined") {
             localStorage.removeItem(key);
             return true;
         }
         return false;
     }
     async deleteAll() {
-        if (window.localStorage) {
+        if (typeof localStorage != "undefined") {
             await localStorage.clear();
             return true;
         }
@@ -66,14 +68,12 @@ export class CSaveToLocalStorage {
 }
 export const CacheG = new CSaveToCache();
 export const CacheLocal = new CSaveToLocalStorage();
-async function addDataToMap(data, map) {
-    if (data) {
-        for (let [k, v] of data) {
-            const tr = (map.get(k) || map.set(k, v).get(k));
-            if (tr && typeof tr === 'object') {
-                Object.assign(tr, v);
-                renderBy(tr);
-            }
+function addDataToMap(data, map) {
+    for (let [k, v] of data) {
+        const tr = map.has(k) ? map.get(k) : map.set(k, v).get(k);
+        if (tr && typeof tr === 'object') {
+            Object.assign(tr, v);
+            renderBy(tr);
         }
     }
 }
@@ -93,17 +93,20 @@ export const ObjectStringToDate = (obj) => {
             });
     }
 };
+// module-level constant: this runs for every string of every cached object on load
+const ISO_DATE_RE = /^(-?(?:[1-9][0-9]*)?[0-9]{4})-(1[0-2]|0[1-9])-(3[01]|0[1-9]|[12][0-9])T(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])(\.[0-9]+)?(Z)?$/;
 function isDate(_date) {
-    const _regExp = new RegExp('^(-?(?:[1-9][0-9]*)?[0-9]{4})-(1[0-2]|0[1-9])-(3[01]|0[1-9]|[12][0-9])T(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])(.[0-9]+)?(Z)?$');
-    return _regExp.test(_date);
+    return ISO_DATE_RE.test(_date);
 }
 export function CacheFuncMapBase(arr, Save) {
     return {
         async load() {
             for (let [k, v] of arr) {
                 const t = await Save.get(k);
+                if (!t)
+                    continue;
                 ObjectStringToDate(t);
-                await addDataToMap(t, v);
+                addDataToMap(t, v);
             }
         },
         async save() {

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

@@ -7,5 +7,5 @@ interface IStepInputElement extends HTMLElement {
 export declare function SetAutoStepForElement(element: IStepInputElement, params?: {
     minStep?: number | undefined;
     maxStep?: number;
-}): void;
+}): () => void;
 export {};

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

@@ -1,7 +1,18 @@
 /// <reference lib="dom" />
-// задать автоматическое управление шагом для элемента input
+// Set automatic step control for an input element
 import { GetDblPrecision, GetDblPrecision2, NormalizeDouble } from "wenay-common2";
+// step is a power of 0.1 (0.1, 0.01, ...) - resilient to float noise,
+// unlike the previous Math.log10(step)%1==0
+function isPowerOfTenth(step) {
+    if (!(step > 0 && step < 1))
+        return false;
+    const digits = Math.round(-Math.log10(step));
+    return Math.abs(Math.pow(0.1, digits) - step) < step * 1e-9;
+}
+// Own handlers on the element: repeated calls remove previous ones (like the old on* overwrite)
+const appliedHandlers = new WeakMap();
 export function SetAutoStepForElement(element, params = { maxStep: 1 }) {
+    appliedHandlers.get(element)?.();
     function parse(valueStr) { let val = parseFloat(valueStr); return isNaN(val) ? null : val; }
     const { minStep, maxStep = 1 } = params;
     const maxDigits = minStep ? GetDblPrecision(minStep) : undefined;
@@ -16,7 +27,7 @@ export function SetAutoStepForElement(element, params = { maxStep: 1 }) {
         //function NormalizeDouble(value :number, digits :number) { let factor=Math.pow(10, digits); return Math.round(value * factor)/factor;  }
         //if (dotPos===valueStr.length-1) dotPos--;
         //let digits= GetDblPrecision2(parseFloat(valueStr), minDigits, 10);
-        let dotPos = valueStr.search(/\.|,/); // Находим точку или запятую
+        let dotPos = valueStr.search(/\.|,/); // Find a dot or comma
         let digits = (dotPos >= 0) ? valueStr.length - dotPos - 1 : 0;
         digits = Math.max(digits, minDigits);
         if (digits > 10)
@@ -34,20 +45,15 @@ export function SetAutoStepForElement(element, params = { maxStep: 1 }) {
         //if (Math.abs(min) < step) min= Math.floor(Math.abs(min)/step)*step * Math.sign(min);
         if (_min != null) {
             if (Math.abs(_min) % step != 0)
-                _min = Math.floor(Math.abs(_min) / step) * step * Math.sign(minDefault);
+                _min = Math.floor(Math.abs(_min) / step) * step * Math.sign(_min);
             element.min = _min + "";
         }
-        //console.log("step:",element.step+"->"+step," min:",element.min+"->"+min);
-        //console.log("minDefault:",_minDefault,parseFloat(_minDefault));
         element.step = step + "";
-        //console.log("dotPos:",dotPos," _digits:",_digits, "minDigits:",minDigits);
-        return step; ////lib.GetDblPrecision($fee[0].value)); }
+        return step;
     }
-    let modeAuto = !_step || (_step < 1 && Math.log10(_step - Math.trunc(_step)) % 1 == 0); // является степенью 0.1
-    const modeAuto0 = modeAuto;
+    let modeAuto = !_step || isPowerOfTenth(_step);
     if (modeAuto) {
         calculateStep((_step ? (Math.round(parseFloat(element.value) / _step) * _step) : element.value) + "");
-        //console.log(element.value, step);
     }
     if (_step && minDefault && Math.abs(minDefault % _step) > 1e-10)
         modeAuto = false;
@@ -55,16 +61,13 @@ export function SetAutoStepForElement(element, params = { maxStep: 1 }) {
         modeAuto = false;
     else
         modeAuto ||= (_step != null && (minStep == null || _step > minStep));
-    //console.log("###",{value: element.value, modeAuto0, modeAuto, _step, _digits});
-    //element.onkeydown= (e)=> { if (_step) element.step = "0.00000001"; /*String(_step/10);*/  console.log("keydown", {value: element.value}); }
-    //element.onkeyup= ()=>{ if (_step) element.step= _step+"";  console.log("keyup", {modeAuto, value: element.value, step: calculateStep(element.value), _digits});  if (modeAuto) calculateStep(element.value); }// console.log(element.step); }//  console.log(element.value, element.step); }
-    element.onkeyup = () => { if (modeAuto)
-        calculateStep(element.value); }; // console.log(element.step); }//  console.log(element.value, element.step); }
-    element.onchange = () => {
+    // addEventListener instead of on*=: do not overwrite other handlers; return a disposer
+    const onKeyUp = () => { if (modeAuto)
+        calculateStep(element.value); };
+    const onChange = () => {
         let digits = _digits;
         if (digits != null)
             element.value = parseFloat(element.value).toFixed(digits);
-        //console.log("change", {value: element.value, digits, minDigits});
         if (minDefault != null && parseFloat(element.value) < minDefault) {
             element.step = stepDefault + "";
             element.value = minDefault + "";
@@ -72,8 +75,16 @@ export function SetAutoStepForElement(element, params = { maxStep: 1 }) {
             _digits = null;
         }
         element.setAttribute("value", element.value);
-    }; //Math.round($fee[0].value/$fee[0].step)*$fee[0].step; }
-    //element.onkeyup();
+    };
+    element.addEventListener("keyup", onKeyUp);
+    element.addEventListener("change", onChange);
+    const dispose = () => {
+        element.removeEventListener("keyup", onKeyUp);
+        element.removeEventListener("change", onChange);
+        appliedHandlers.delete(element);
+    };
+    appliedHandlers.set(element, dispose);
+    return dispose;
 }
 //import * as Time from "./Time"
 //import {const_Date} from "./Time";

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

@@ -36,20 +36,19 @@ export function deepMergeWithMap(target, source, visited = new Map()) {
     }
     return target;
 }
-const map = new Map();
+// WeakSet: a strict Map kept every def object alive forever
+const merged = new WeakSet();
 export function staticGetAdd(key, def, options = { reversDeep: false }) {
-    if (options.deepAutoMerge && !map.get(def)) {
-        map.set(def, true);
-        if (options.deepAutoMerge) {
-            if (!options.reversDeep)
-                staticProps.set(key, deepMergeWithMap(staticProps.get(key) ?? {}, def));
-            else
-                staticProps.set(key, deepMergeWithMap(deepClone(def), staticProps.get(key) ?? {}));
-        }
+    if (options.deepAutoMerge && !merged.has(def)) {
+        merged.add(def);
+        if (!options.reversDeep)
+            staticProps.set(key, deepMergeWithMap(staticProps.get(key) ?? {}, def));
+        else
+            staticProps.set(key, deepMergeWithMap(deepClone(def), staticProps.get(key) ?? {}));
     }
     if (options.abs)
         staticProps.set(key, def);
-    const t = (staticProps.get(key) || staticProps.set(key, def).get(key));
+    const t = (staticProps.has(key) ? staticProps.get(key) : staticProps.set(key, def).get(key));
     return t; // Object.assign(def, t) // t //
 }
 export function staticGetById(key, def, id) {

package/lib/common/updateBy.d.ts

@@ -1,3 +1,4 @@
+import React from "react";
 type Listener = (a?: any) => void;
 interface ObserverState {
     listeners: Set<Listener>;
@@ -8,9 +9,27 @@ export declare const mapWait: Map<object, {
     refreshAsync: (ms: number, func: () => any) => void;
     refreshAsync2: (ms: number, func: () => any) => Promise<void>;
 }>;
+/**
+ * Ветка Dispatch<SetStateAction<T>>: listener получает тот же мутированный объект,
+ * setState(тот же ref) React бэйлаутит без ререндера — используйте (a: T) => void.
+ */
+export type UpdateCallback<T extends object> = React.Dispatch<React.SetStateAction<T>> | ((a: T) => void);
 export declare function renderBy(a: object, ms?: number): void;
 export declare function renderByRevers(a: object, ms?: number, reverse?: boolean): void;
 export declare function renderByLast(a: object, ms?: number): void;
-export declare function useUpdateBy<T extends object>(a: T, f?: React.Dispatch<React.SetStateAction<T>> | ((a: T) => void)): void;
-export declare function updateBy<T extends object>(a: T, f?: React.Dispatch<React.SetStateAction<T>> | ((a: T) => void)): void;
+export declare function useUpdateBy<T extends object>(a: T, f?: UpdateCallback<T>): void;
+export declare function updateBy<T extends object>(a: T, f?: UpdateCallback<T>): void;
+export type UpdateApi<T extends object> = {
+    object: T;
+    emit(ms?: number): void;
+    render(ms?: number): void;
+    renderReverse(ms?: number, reverse?: boolean): void;
+    renderLast(ms?: number): void;
+    on(listener: (obj: T) => void): () => void;
+    subscribe(listener: (obj: T) => void): () => void;
+    use(f?: UpdateCallback<T>): void;
+    useSubscribe(f?: UpdateCallback<T>): void;
+};
+export declare function createUpdateApi<T extends object>(obj: T): UpdateApi<T>;
+export declare function useUpdateByApi<T extends object>(obj: T, f?: UpdateCallback<T>): UpdateApi<T>;
 export {};

package/lib/common/updateBy.js

@@ -1,7 +1,16 @@
-import { useLayoutEffect, useSyncExternalStore } from "react";
-import { waitRun } from "wenay-common2";
+import { useCallback, useLayoutEffect, useSyncExternalStore } from "react";
+import { UseListen, waitRun } from "wenay-common2";
 export const map3 = new WeakMap();
 export const mapWait = new Map();
+const updateListens = new WeakMap();
+function getUpdateListen(obj) {
+    let listen = updateListens.get(obj);
+    if (!listen) {
+        listen = UseListen();
+        updateListens.set(obj, listen);
+    }
+    return listen;
+}
 function getObserverState(obj) {
     let state = map3.get(obj);
     if (!state) {
@@ -10,68 +19,64 @@ function getObserverState(obj) {
     }
     return state;
 }
+// reverse/lastOnly действуют только на React-подписчиков (useUpdateBy);
+// императивные on-подписчики вызываются всегда все, в порядке подписки
 function triggerUpdate(obj, reverse = false, lastOnly = false) {
-    const state = map3.get(obj);
-    if (!state || state.listeners.size === 0)
+    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);
     if (lastOnly) {
         const last = listenersArray.at(-1);
         if (last)
             last(obj);
+        listen?.[0](obj);
         return;
     }
     if (reverse) {
         listenersArray.reverse();
     }
     listenersArray.forEach(listener => listener(obj));
+    listen?.[0](obj);
 }
-export function renderBy(a, ms) {
+function schedule(a, ms, reverse = false, lastOnly = false) {
     if (ms) {
         (mapWait.get(a) || mapWait.set(a, waitRun()).get(a))
             .refreshAsync(ms, () => {
             mapWait.delete(a);
-            triggerUpdate(a);
+            triggerUpdate(a, reverse, lastOnly);
         });
     }
     else
-        triggerUpdate(a);
+        triggerUpdate(a, reverse, lastOnly);
+}
+export function renderBy(a, ms) {
+    schedule(a, ms);
 }
 export function renderByRevers(a, ms, reverse = true) {
-    if (ms) {
-        (mapWait.get(a) || mapWait.set(a, waitRun()).get(a))
-            .refreshAsync(ms, () => {
-            mapWait.delete(a);
-            triggerUpdate(a, reverse);
-        });
-    }
-    else
-        triggerUpdate(a, reverse);
+    schedule(a, ms, reverse);
 }
 export function renderByLast(a, ms) {
-    if (ms) {
-        (mapWait.get(a) || mapWait.set(a, waitRun()).get(a))
-            .refreshAsync(ms, () => {
-            mapWait.delete(a);
-            triggerUpdate(a, false, true);
-        });
-    }
-    else
-        triggerUpdate(a, false, true);
+    schedule(a, ms, false, true);
 }
 export function useUpdateBy(a, f) {
-    useSyncExternalStore((listener) => {
+    // стабильный subscribe: без useCallback React переподписывается на каждый рендер,
+    // а удаление state из map3 при этом сбрасывало бы version → лишний форс-ререндер
+    const subscribe = useCallback((listener) => {
         if (f)
             return () => { };
         const state = getObserverState(a);
         state.listeners.add(listener);
         return () => {
             state.listeners.delete(listener);
-            if (state.listeners.size === 0)
-                map3.delete(a);
         };
-    }, () => (f ? 0 : getObserverState(a).version));
+    }, [a, f]);
+    useSyncExternalStore(subscribe, 
+    // getSnapshot must be pure: only read the version, subscribe creates the state
+    () => (f ? 0 : (map3.get(a)?.version ?? 0)));
     useLayoutEffect(() => {
         if (!f)
             return;
@@ -79,11 +84,41 @@ export function useUpdateBy(a, f) {
         state.listeners.add(f);
         return () => {
             state.listeners.delete(f);
-            if (state.listeners.size === 0)
-                map3.delete(a);
         };
     }, [a, f]);
 }
 export function updateBy(a, f) {
     useUpdateBy(a, f);
 }
+const apiCache = new WeakMap();
+export function createUpdateApi(obj) {
+    const cached = apiCache.get(obj);
+    if (cached)
+        return cached;
+    const [, listen] = getUpdateListen(obj);
+    const api = {
+        object: obj,
+        emit(ms) { renderBy(obj, ms); },
+        render(ms) { renderBy(obj, ms); },
+        renderReverse(ms, reverse = true) { renderByRevers(obj, ms, reverse); },
+        renderLast(ms) { renderByLast(obj, ms); },
+        on(listener) {
+            return listen.on((value) => listener(value));
+        },
+        subscribe(listener) {
+            return api.on(listener);
+        },
+        use(f) {
+            useUpdateBy(obj, f);
+        },
+        useSubscribe(f) {
+            useUpdateBy(obj, f);
+        },
+    };
+    apiCache.set(obj, api);
+    return api;
+}
+export function useUpdateByApi(obj, f) {
+    useUpdateBy(obj, f);
+    return createUpdateApi(obj);
+}

package/lib/index.js

@@ -1,3 +1 @@
 export * from "./common/api";
-import { test } from "./common/api";
-test();