wenay-react2 1.0.19 → 1.0.21

package/lib/common/src/styles/tokens.d.ts

@@ -0,0 +1,39 @@
+export declare const tokens: {
+    readonly color: {
+        readonly bgDark: "#131821";
+        readonly bgLight: "#17202e";
+        readonly scrollbarTrack: "rgba(255, 255, 255, 0)";
+        readonly scrollbarThumb: "#1d262c";
+        readonly scrollbarThumbAlt: "#4c4562";
+        readonly textBase: "#c4c4c4";
+        readonly textTheme: "#5D9FFA";
+        readonly borderCommon: "rgb(50, 62, 71)";
+    };
+    readonly menu: {
+        readonly bgColor: "rgba(12, 12, 12, 0.91)";
+        readonly blur: "10px";
+        readonly border: "1px solid rgba(255, 255, 255, 0.41)";
+        readonly activeBackground: "rgba(255, 255, 255, 0.23)";
+        readonly itemColor: "#fff";
+        readonly itemHoverColor: "#101010";
+        readonly itemHoverBgColor: "#fff";
+    };
+    readonly font: {
+        readonly family: "Roboto";
+        readonly sizeBase: "12px";
+    };
+    readonly zIndex: {
+        /** CSS variable --wenay-z-modal; fallback in ModalProvider */
+        readonly modal: 9999;
+    };
+    /** ag-grid theme params shared by GridStyleDefault (legacy) and agGrid4 buildAgTheme */
+    readonly grid: {
+        readonly fontFamily: "Roboto";
+        readonly textColor: "rgba(214,214,214,0.9)";
+        readonly tabTextColor: "rgba(227,227,227,0.9)";
+        readonly fontSize: "10px";
+        readonly spacing: "3px";
+        readonly backgroundColor: "rgb(19,24,33)";
+    };
+};
+export type Tokens = typeof tokens;

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);
@@ -27,19 +27,26 @@ function applyTransactionAsyncUpdate3({ getId, bufTable, option, newData, grid,
         grid.api.applyTransaction({
             add: op.add ? arrNew : [],
             update: op.update ? arr : [],
+            remove: remove,
         });
         return;
     }
-    if (arrNew.length && op.add)
-        grid.api.applyTransaction({ add: arrNew, remove: remove }); // для удаления важно только получить ид
+    // 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, remove: remove });
+        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 });
 }
-const map = new WeakMap();
+/** @deprecated No-op stub: always returns {}. Never implemented; will be removed in a major version. */
 export function getUpdateTable(grid, newData, getId, bufTable, option) {
     return {};
 }
@@ -56,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 = [];
@@ -91,13 +98,11 @@ export function applyTransactionAsyncUpdate2(params) {
                 if (existing)
                     toRemove.push(existing);
             });
-            if (newData?.length)
-                applyTransactionAsyncUpdate3({ grid: g, newData, getId, bufTable, option: op, remove: toRemove });
+            if (newData?.length || toRemove.length)
+                applyTransactionAsyncUpdate3({ grid: g, newData: newData ?? [], getId, bufTable, option: op, remove: toRemove });
         }
     }
     else {
-        if (!map.has(bufTable))
-            map.set(bufTable, new Set());
         newData?.forEach(e => {
             const id = getId(e);
             bufTable[id] = { ...(bufTable[id] ?? {}), ...e };
@@ -107,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,30 +31,35 @@ export class CSaveToCache {
 }
 export class CSaveToLocalStorage {
     async set(key, value) {
-        const t = new Response(JSON.stringify(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)
-                return JSON.parse(st);
+            if (st) {
+                try {
+                    return JSON.parse(st);
+                }
+                catch {
+                    return null;
+                }
+            }
         }
         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;
         }
@@ -61,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);
         }
     }
 }
@@ -88,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,29 +36,29 @@ 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) {
-    const t = map.get(key);
-    const el = { __id: id, data: def };
-    if ((el && el.__id != id) || !el) {
-        return staticGetAdd(key, el, { abs: true }).data;
+    const stored = staticProps.get(key);
+    if (!stored || stored.__id !== id) {
+        const fresh = { __id: id, data: def };
+        staticProps.set(key, fresh);
+        return fresh.data;
     }
-    return el.data;
+    return stored.data;
 }
 export const Cash = CacheFuncMap([
     ["mapResiReact", mapResiReact],

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 {};