wenay-react2 1.0.1

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

@@ -0,0 +1 @@
+export * from './styleGrid';

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

@@ -0,0 +1 @@
+export * from './styleGrid';

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

@@ -0,0 +1,20 @@
+import { CellClassParams } from "ag-grid-community";
+import type { Theme, ThemeDefaultParams } from "ag-grid-community";
+import { provideGlobalGridOptions } from "ag-grid-community";
+export { AllCommunityModule, ModuleRegistry } from "ag-grid-community";
+export declare function GridStyleDefault(): {
+    theme: Theme<ThemeDefaultParams>;
+    provideGlobalGridOptions: typeof provideGlobalGridOptions;
+};
+export declare const StyleGridDefault: {
+    fontFamily: string;
+    fontStyle: string;
+    fontWeight: string;
+    fontSize: string;
+    textAlign: string;
+};
+export declare function StyleCSSHeadGridEdit(name: string, rules: string): void;
+export declare function StyleCSSHeadGrid(): void;
+export type tCallFuncAgGrid<T> = (params: CellClassParams & {
+    data: T;
+}) => {};

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

@@ -0,0 +1,50 @@
+import { colorSchemeDarkBlue, iconSetMaterial, provideGlobalGridOptions, themeAlpine } from "ag-grid-community";
+import { AllCommunityModule, ModuleRegistry } from "ag-grid-community";
+export { AllCommunityModule, ModuleRegistry } from "ag-grid-community";
+// import 'ag-grid-community/styles/ag-grid.css';
+// import 'ag-grid-community/styles/ag-theme-alpine.css';
+// Register all community features
+ModuleRegistry.registerModules([AllCommunityModule]);
+export function GridStyleDefault() {
+    const theme = themeAlpine
+        .withPart(colorSchemeDarkBlue)
+        .withPart(iconSetMaterial)
+        .withParams({
+        '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)'
+    });
+    // Mark all grids as using legacy themes
+    provideGlobalGridOptions({ theme: theme });
+    return { theme, provideGlobalGridOptions };
+}
+export const StyleGridDefault = {
+    //    'color':'#1d262c',
+    'fontFamily': 'Roboto',
+    'fontStyle': 'normal',
+    'fontWeight': '400',
+    'fontSize': '12px',
+    // 'paddingLeft': '1px',
+    // 'paddingRight': '1px',
+    // 'lineHeight': '12px',
+    // 'paddingTop': '10px',
+    // 'paddingBottom': '3px',
+    //    'background-color': 'whitesmoke',
+    'textAlign': 'center',
+    // "justifyContent":'center'
+};
+export function StyleCSSHeadGridEdit(name, rules) {
+    let style = document.createElement('style');
+    style.type = 'text/css';
+    document.getElementsByTagName('head')[0].appendChild(style);
+    style.sheet?.insertRule(name + "{" + rules + "}", 0);
+}
+export function StyleCSSHeadGrid() {
+    // уменьшаем отступы с боков для заголовков
+    StyleCSSHeadGridEdit('.ag-theme-alpine-dark .ag-theme-alpine .ag-header-cell, .ag-theme-alpine-dark .ag-header-group-cell', "padding-left: 3px; padding-right: 3px;");
+    // выравнивание в заголовке по центру
+    StyleCSSHeadGridEdit('.ag-header-cell-label', 'justify-content: center');
+}

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

@@ -0,0 +1,42 @@
+import { ColDef, GridReadyEvent } from "ag-grid-community";
+declare const optionsDef: {
+    update: boolean;
+    add: boolean;
+    updateBuffer: boolean;
+    sync: boolean;
+};
+type options = Partial<typeof optionsDef>;
+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;
+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): {};
+type CommonParams<T> = {
+    getId: (...a: any[]) => string;
+    bufTable: {
+        [id: string]: Partial<T>;
+    };
+    option?: options;
+};
+type params<T> = CommonParams<T> & ({
+    newData: (Partial<T>)[];
+    synchronization?: never;
+    gridRef?: React.RefObject<GridReadyEvent<T, any> | null | undefined>;
+    grid?: GridReadyEvent<T, any> | null | undefined;
+} | ({
+    newData?: never;
+    synchronization: true;
+} & ({
+    grid: GridReadyEvent<T, any> | null | undefined;
+    gridRef?: never;
+} | {
+    gridRef: React.RefObject<GridReadyEvent<T, any> | null | undefined>;
+    grid?: never;
+})));
+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<UnUndefined<t1>>;
+export declare function getComparatorGrid<T = any>(func?: (...param: paramsCompare<T>) => [a: number, b: number]): t1;
+export {};

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

@@ -0,0 +1,97 @@
+const optionsDef = {
+    update: true,
+    add: true,
+    updateBuffer: true,
+    sync: false
+};
+export function applyTransactionAsyncUpdate(grid, newData, getId, bufTable, option) {
+    // Установка параметров (объединение переданных опций с настройками по умолчанию)
+    const op = { ...optionsDef, ...(option ?? {}) };
+    // Проверка наличия сетки и доступа к данным через API
+    if (grid?.api.getRowNode) {
+        const arrNew = []; // Массив для новых данных (добавляемые строки)
+        // Основная обработка данных (map используется для обновления или создания записей)
+        const arr = newData.map(e => {
+            // Получение ID для текущей строки
+            const id = getId(e);
+            const newData = { ...(bufTable[id] ?? {}), ...e };
+            if (op.updateBuffer)
+                bufTable[id] = newData;
+            // Попытка найти существующую строку по ID
+            const a = grid.api.getRowNode(id)?.data;
+            if (!a) {
+                // Если строка не найдена - добавить в массив для добавления
+                arrNew.push(newData);
+                return null; // Новая строка обрабатывается отдельно
+            }
+            // Если строка найдена - обновить данные в буфере
+            return newData;
+        }) // Убираем `null` и оставляем только существующие строки
+            .filter(e => e);
+        if (op.sync) {
+            grid.api.applyTransaction({ add: op.add ? arrNew : [], update: op.update ? arr : [] });
+            return;
+        }
+        // Добавление новых строк (если есть элементы)
+        if (arrNew.length && op.add) {
+            // добавление элементов должно быть синхронно, т.к. может прейти его update до исполнения
+            grid.api.applyTransaction({ add: arrNew });
+        }
+        // Асинхронное обновление существующих строк
+        if (arr.length && op.update) {
+            grid.api.applyTransactionAsync({ update: arr });
+        }
+    }
+}
+const map = new WeakMap();
+export function getUpdateTable(grid, newData, getId, bufTable, option) {
+    return {};
+}
+export function applyTransactionAsyncUpdate2(params) {
+    const { grid, gridRef, newData, getId, bufTable } = params;
+    // Установка параметров (объединение переданных опций с настройками по умолчанию)
+    const op = { ...optionsDef, ...(params.option ?? {}) };
+    // Проверка наличия сетки и доступа к данным через API
+    if (grid?.api.getRowNode) {
+        if (!newData) {
+            applyTransactionAsyncUpdate(grid, Object.values(bufTable), getId, bufTable, op);
+        }
+        else
+            applyTransactionAsyncUpdate(grid, newData, getId, bufTable, op);
+    }
+    else if (gridRef?.current?.api.getRowNode) {
+        if (!newData) {
+            applyTransactionAsyncUpdate(gridRef.current, Object.values(bufTable), getId, bufTable, op);
+        }
+        else
+            applyTransactionAsyncUpdate(gridRef.current, newData, getId, bufTable, op);
+    }
+    else {
+        if (map.get(bufTable))
+            map.set(bufTable, new Set());
+        const m = map.get(bufTable);
+        if (newData)
+            newData.forEach(e => {
+                // Получение ID для текущей строки
+                const id = getId(e);
+                // m? - это странно, но так надо
+                m?.add(id);
+                if (op.updateBuffer)
+                    bufTable[id] = { ...(bufTable[id] ?? {}), ...e };
+            }); // Убираем `null` и оставляем только существующие строки
+    }
+}
+export function getComparatorGrid(func) {
+    return (...param) => {
+        const [a1, b1, modeA, modeB, inv] = param; // Распаковка параметров в функцию
+        const [a, b] = func ? func(...param) : [a1, b1]; // Использование преобразующей функции func, если передана
+        return ((typeof a == "number" && !Number.isNaN(a)) &&
+            (typeof b == "number" && !Number.isNaN(b))) // Если оба a и b - валидные числа
+            ? a - b // Разница между числами
+            : a == b
+                ? 0 // Если значения равны, возвращаем 0
+                : (!Number.isNaN(b) && b != undefined)
+                    ? (inv ? -1 : 1) // Если b существует: порядок определяется inv
+                    : (inv ? 1 : -1); // Если b отсутствует: порядок определяется inv
+    };
+}

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

@@ -0,0 +1,5 @@
+export declare function ArrayPromise<T = unknown>({ arr, catchF, thenF }: {
+    arr: (() => Promise<T>)[];
+    thenF?: (data: T, i: number, countOk: number, countError: number, count: number) => unknown;
+    catchF?: (error: unknown, i: number, countOk: number, countError: number, count: number) => unknown;
+}): (() => Promise<unknown>)[];

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

@@ -0,0 +1,16 @@
+export function ArrayPromise({ arr, catchF, thenF }) {
+    let ok = 0, countError = 0;
+    const count = arr.length;
+    const a = (data, i) => {
+        ++ok;
+        return thenF?.(data, i, ok, countError, count) ?? data;
+    };
+    const b = (error, i) => {
+        ++countError;
+        if (catchF)
+            return catchF?.(error, i, ok, countError, count);
+        else
+            throw error;
+    };
+    return arr.map((e, i) => () => e().then(r => a(r, i)).catch((er) => b(er, i)));
+}

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

@@ -0,0 +1,31 @@
+export interface IServerSaveBasePromise {
+    set(key: string, value: object): Promise<boolean>;
+    get<T extends (object)>(key: string): Promise<T | null>;
+    delete(key: string): Promise<boolean>;
+}
+export declare class CSaveToCache implements IServerSaveBasePromise {
+    set(key: string, value: object): Promise<boolean>;
+    get<T extends object>(key: string): Promise<T | null>;
+    delete<T extends object>(key: string): Promise<boolean>;
+}
+export declare class CSaveToLocalStorage implements IServerSaveBasePromise {
+    set(key: string, value: object): Promise<boolean>;
+    get<T extends object>(key: string): Promise<T | null>;
+    delete<T extends object>(key: string): Promise<boolean>;
+    deleteAll(): Promise<boolean>;
+}
+export declare const CacheG: CSaveToCache;
+export declare const CacheLocal: CSaveToLocalStorage;
+export declare const ObjectStringToDate: (obj: unknown) => void;
+export declare function CacheFuncMapBase(arr: [k: string, v: Map<string, unknown>][], Save: IServerSaveBasePromise): {
+    load(): Promise<void>;
+    save(): Promise<void>;
+    clear(): Promise<void>;
+    getArr: [k: string, v: Map<string, unknown>][];
+};
+export declare function CacheFuncMap(arr: [k: string, v: Map<string, unknown>][]): {
+    load(): Promise<void>;
+    save(): Promise<void>;
+    clear(): Promise<void>;
+    getArr: [k: string, v: Map<string, unknown>][];
+};

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

@@ -0,0 +1,119 @@
+import { renderBy } from "../../updateBy";
+const HostName = location.toString();
+export class CSaveToCache {
+    async set(key, value) {
+        const t = new Response(JSON.stringify(value));
+        if (window.caches) {
+            const Cache = await caches.open(key);
+            await Cache.put(HostName, t);
+            return true;
+        }
+        return false;
+    }
+    async get(key) {
+        if (window.caches) {
+            const Cache = await caches.open(key);
+            const cachedResponse = await Cache.match(HostName);
+            if (cachedResponse) {
+                return (await cachedResponse.json());
+            }
+        }
+        return null;
+    }
+    async delete(key) {
+        if (window.caches) {
+            return await caches.delete(key);
+        }
+        return false;
+    }
+}
+export class CSaveToLocalStorage {
+    async set(key, value) {
+        const t = new Response(JSON.stringify(value));
+        if (window.localStorage) {
+            await localStorage.setItem(key, JSON.stringify(value));
+            return true;
+        }
+        return false;
+    }
+    async get(key) {
+        if (window.localStorage) {
+            const st = await localStorage.getItem(key);
+            if (st)
+                return JSON.parse(st);
+        }
+        return null;
+    }
+    async delete(key) {
+        if (window.localStorage) {
+            localStorage.removeItem(key);
+            return true;
+        }
+        return false;
+    }
+    async deleteAll() {
+        if (window.localStorage) {
+            await localStorage.clear();
+            return true;
+        }
+        return false;
+    }
+}
+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);
+            }
+        }
+    }
+}
+export const ObjectStringToDate = (obj) => {
+    if (typeof obj == "object" && obj) {
+        if (Array.isArray(obj))
+            obj.forEach(ObjectStringToDate);
+        else
+            Object.entries(obj).forEach(([k, v]) => {
+                if (typeof v == "string") {
+                    if (isDate(v)) {
+                        obj[k] = new Date(v);
+                    }
+                }
+                if (typeof v == "object")
+                    ObjectStringToDate(v);
+            });
+    }
+};
+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);
+}
+export function CacheFuncMapBase(arr, Save) {
+    return {
+        async load() {
+            for (let [k, v] of arr) {
+                const t = await Save.get(k);
+                ObjectStringToDate(t);
+                await addDataToMap(t, v);
+            }
+        },
+        async save() {
+            for (let [k, v] of arr) {
+                await Save.set(k, [...v.entries()]);
+            }
+        },
+        async clear() {
+            for (let [k, v] of arr) {
+                await Save.delete(k);
+            }
+        },
+        getArr: arr
+    };
+}
+export function CacheFuncMap(arr) {
+    return CacheFuncMapBase(arr, CacheLocal);
+}

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

@@ -0,0 +1,6 @@
+export * from './applyTransactionAsyncUpdate';
+export * from './arrayPromise';
+export * from './cache';
+export * from './inputAutoStep';
+export * from './mapMemory';
+export * from './pageVisibilityContext';

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

@@ -0,0 +1,6 @@
+export * from './applyTransactionAsyncUpdate';
+export * from './arrayPromise';
+export * from './cache';
+export * from './inputAutoStep';
+export * from './mapMemory';
+export * from './pageVisibilityContext';

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

@@ -0,0 +1,4 @@
+export declare function SetAutoStepForElement(element: HTMLInputElement, params?: {
+    minStep?: number | undefined;
+    maxStep?: number;
+}): void;

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

@@ -0,0 +1,79 @@
+/// <reference lib="dom" />
+// задать автоматическое управление шагом для элемента input
+import { GetDblPrecision, GetDblPrecision2, NormalizeDouble } from "wenay-common2";
+export function SetAutoStepForElement(element, params = { maxStep: 1 }) {
+    function parse(valueStr) { let val = parseFloat(valueStr); return isNaN(val) ? null : val; }
+    const { minStep, maxStep = 1 } = params;
+    const maxDigits = minStep ? GetDblPrecision(minStep) : undefined;
+    const stepDefault = parse(element.step);
+    const minDefault = parse(element.min);
+    const maxDefault = parse(element.max);
+    const minDigits = maxStep > 0 ? Math.max(0, -Math.round(Math.log10(maxStep))) : 0;
+    let _digits = null;
+    let _step = parse(element.step);
+    let _min = parse(element.min);
+    function calculateStep(valueStr) {
+        //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 digits = (dotPos >= 0) ? valueStr.length - dotPos - 1 : 0;
+        digits = Math.max(digits, minDigits);
+        if (digits > 10)
+            digits = GetDblPrecision2(parseFloat(valueStr), minDigits, 10);
+        if (maxDigits != null)
+            digits = Math.min(digits, maxDigits);
+        let step = NormalizeDouble(Math.pow(0.1, digits), digits);
+        if (minStep)
+            step = NormalizeDouble(Math.round(step / minStep) * minStep, digits);
+        if (maxDefault != null && minDefault != null)
+            if (maxDefault - minDefault < step * 2)
+                return _step;
+        _digits = digits;
+        _step = step;
+        //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);
+            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)); }
+    }
+    let modeAuto = !_step || (_step < 1 && Math.log10(_step - Math.trunc(_step)) % 1 == 0); // является степенью 0.1
+    const modeAuto0 = modeAuto;
+    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;
+    else if (_step && maxDefault && Math.abs(maxDefault % _step) > 1e-10)
+        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 = () => {
+        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 + "";
+            element.min = minDefault + "";
+            _digits = null;
+        }
+        element.setAttribute("value", element.value);
+    }; //Math.round($fee[0].value/$fee[0].step)*$fee[0].step; }
+    //element.onkeyup();
+}
+//import * as Time from "./Time"
+//import {const_Date} from "./Time";

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

@@ -0,0 +1,26 @@
+export declare function staticSet(key: any, data: object): void;
+export declare function staticGet(key: any): object | undefined;
+export declare function deepMergeWithMap(target: any, source: any, visited?: Map<any, any>): any;
+export declare function staticGetAdd<T extends object>(key: any, def: T, options?: {
+    abs?: boolean;
+    deepAutoMerge?: boolean;
+    reversDeep?: boolean;
+}): T;
+export declare function staticGetById<T extends object>(key: any, def: T, id: string | number): T;
+export declare const MemoryMap: {
+    rnd: Map<string, {
+        position: {
+            x: number;
+            y: number;
+        };
+        size: {
+            height: number | string;
+            width: number | string;
+        };
+    }>;
+    resize: Map<string, {
+        height?: number | string;
+        width?: number | string;
+    }>;
+    other: Map<string, object>;
+};

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

@@ -0,0 +1,72 @@
+import { deepClone } from "wenay-common2";
+import { ExRNDMap3, mapResiReact } from "../components";
+const staticProps = new Map();
+export function staticSet(key, data) {
+    if (!staticProps.has(key))
+        staticProps.set(key, data);
+}
+export function staticGet(key) {
+    return staticProps.get(key);
+}
+function isObject(item) {
+    return item !== null && typeof item === 'object' && !Array.isArray(item);
+}
+export function deepMergeWithMap(target, source, visited = new Map()) {
+    if (isObject(target) && isObject(source)) {
+        for (const key in source) {
+            if (isObject(source[key])) {
+                if (!target[key]) {
+                    target[key] = {};
+                }
+                // Check if the source object has already been visited
+                if (!visited.has(source[key])) {
+                    visited.set(source[key], {});
+                    deepMergeWithMap(target[key], source[key], visited);
+                }
+                else {
+                    target[key] = visited.get(source[key]);
+                }
+            }
+            else {
+                target[key] = source[key];
+            }
+        }
+    }
+    return target;
+}
+const map = new Map;
+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.abs)
+        staticProps.set(key, def);
+    const t = (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;
+    }
+    return el.data;
+}
+// export const Cash = CashFuncMapCash(
+//     [
+//         ["mapResiReact", mapResiReact],
+//         ["ExRNDMap3", ExRNDMap3],
+//         ["staticProps", staticProps]
+//     ]
+// )
+export const MemoryMap = {
+    rnd: ExRNDMap3,
+    resize: mapResiReact,
+    other: staticProps
+};

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

@@ -0,0 +1,5 @@
+import React from "react";
+export declare const PageVisibilityContext: React.Context<boolean>;
+export declare function PageVisibilityProvider({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,18 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useEffect, useState } from "react";
+export const PageVisibilityContext = createContext(true);
+export function PageVisibilityProvider({ children }) {
+    const [isVisible, setIsVisible] = useState(typeof document !== 'undefined' ? !document.hidden : true);
+    useEffect(() => {
+        if (typeof document === 'undefined')
+            return;
+        const handleVisibilityChange = () => {
+            setIsVisible(!document.hidden);
+        };
+        document.addEventListener('visibilitychange', handleVisibilityChange);
+        return () => {
+            document.removeEventListener('visibilitychange', handleVisibilityChange);
+        };
+    }, []);
+    return (_jsx(PageVisibilityContext.Provider, { value: isVisible, children: children }));
+}

package/lib/common/updateBy.d.ts

@@ -0,0 +1,12 @@
+type tFunc2 = Map<object, (a?: any) => void>;
+export declare const map3: WeakMap<object, tFunc2>;
+export declare const mapWait: Map<object, {
+    refreshAsync: (ms: number, func: () => any) => void;
+    refreshAsync2: (ms: number, func: () => any) => Promise<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 {};