wenay-react2 1.0.35 → 1.0.37

package/lib/common/src/menu/menuMouse.js

@@ -1,33 +1,201 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { GetMenuR } from "./menuR";
-import { MenuBase } from "./menu";
-function GetMouseMenuApi(data) {
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from "react";
+import { Menu } from "./menu";
+import { OutsideClickArea } from "../hooks/useOutside";
+function normalizeItems(items) {
+    return (items ?? []).filter(Boolean);
+}
+function anchorPoint(anchor) {
+    if ("clientX" in anchor)
+        return { x: anchor.clientX, y: anchor.clientY };
+    return anchor;
+}
+function anchorLayerId(anchor) {
+    const target = "clientX" in anchor ? anchor.target : undefined;
+    return target instanceof Element
+        ? target.closest("[data-wenay-menu-layer-id]")?.getAttribute("data-wenay-menu-layer-id") ?? undefined
+        : undefined;
+}
+function preventNative(anchor) {
+    if ("clientX" in anchor) {
+        anchor.preventDefault?.();
+        anchor.stopPropagation?.();
+    }
+}
+export function createContextMenu(data) {
     const { name = "mouse" } = data ?? {};
-    const { MenuR, bb } = GetMenuR();
-    const value = {
-        status: true,
-        clicks: 0
-    };
+    const value = { status: true, clicks: 0 };
     const menuMouse = {
         name,
         get value() { return value; }
     };
     const map = new Map();
-    function other() {
+    const state = { open: false, items: [], point: { x: 0, y: 0 }, seq: 0 };
+    const listeners = new Set();
+    const layers = new Set();
+    let layerSeq = 0;
+    function emit() {
+        state.seq += 1;
+        for (const cb of [...listeners])
+            cb();
+    }
+    function subscribe(cb) {
+        listeners.add(cb);
+        return () => { listeners.delete(cb); };
+    }
+    function legacyItems() {
         if (map.has("only"))
-            return map.get("only");
-        const t = [];
-        map.forEach(e => { t.unshift(...e); });
-        return t;
+            return normalizeItems(map.get("only"));
+        const items = [];
+        map.forEach(e => { items.unshift(...e); });
+        return normalizeItems(items);
+    }
+    function hasQueuedItems(other) {
+        return !!other || map.size > 0;
+    }
+    function close() {
+        if (!state.open && state.items.length == 0)
+            return;
+        state.open = false;
+        state.items = [];
+        state.layerId = undefined;
+        emit();
+    }
+    function openAt(anchor, items, opts = {}) {
+        preventNative(anchor);
+        const nextItems = normalizeItems(items);
+        if (nextItems.length == 0) {
+            close();
+            return false;
+        }
+        state.open = true;
+        state.items = nextItems;
+        state.point = anchorPoint(anchor);
+        state.source = opts.source;
+        state.layerId = opts.layerId ?? anchorLayerId(anchor) ?? [...layers][0];
+        emit();
+        return true;
+    }
+    function openAtPoint(point, items, opts = {}) {
+        return openAt(point, items, opts);
+    }
+    function getState() {
+        return {
+            open: state.open,
+            items: state.items.slice(),
+            point: { ...state.point },
+            source: state.source,
+            layerId: state.layerId,
+            seq: state.seq,
+        };
+    }
+    function bb(b) {
+        if (b != undefined) {
+            if (b) {
+                state.open = true;
+                emit();
+            }
+            else {
+                close();
+            }
+            return;
+        }
+        return state.open;
     }
-    function ReactMouse(agr) {
-        const datum = menuMouse.value; //staticGetAdd(menuMouse.name, menuMouse.value
-        // JSX instead of a direct call: MenuR's hooks must live in its own fiber,
-        // a direct call ties them to whichever component renders ReactMouse
-        return _jsx(MenuR, { ...agr, other: agr.other ?? other, statusOn: datum.status, onConsume: () => { map.clear(); } });
+    function Layer({ children, other, statusOn, onUnClick, onConsume, zIndex, className }) {
+        const [, forceRender] = useState(0);
+        const [layerId] = useState(() => `${name}-${++layerSeq}`);
+        const layerRef = useRef(null);
+        const timeEvent = useRef(Date.now());
+        const touchXY = useRef({ x: 0, y: 0 });
+        const touchTime = useRef(null);
+        const enabled = statusOn ?? menuMouse.value.status;
+        useEffect(() => {
+            layers.add(layerId);
+            return () => {
+                layers.delete(layerId);
+                if (state.layerId == layerId)
+                    close();
+            };
+        }, [layerId]);
+        useEffect(() => subscribe(() => forceRender(v => v + 1)), []);
+        function queuedItems() {
+            return other ? normalizeItems(other()) : legacyItems();
+        }
+        function openQueued(anchor) {
+            const opened = openAt(anchor, queuedItems(), { source: "layer", layerId });
+            if (opened) {
+                map.clear();
+                onConsume?.();
+            }
+            return opened;
+        }
+        function handleClose() {
+            if (!state.open)
+                return;
+            close();
+            onUnClick?.(false);
+        }
+        function relativePoint() {
+            const rect = layerRef.current?.getBoundingClientRect();
+            return {
+                x: state.point.x - (rect?.left ?? 0),
+                y: state.point.y - (rect?.top ?? 0),
+            };
+        }
+        return _jsxs("div", { "data-wenay-menu-layer": "root", "data-wenay-menu-layer-id": layerId, className: "maxSize", style: { position: "relative" }, ref: layerRef, onContextMenu: e => {
+                if (!enabled)
+                    return;
+                e.preventDefault();
+                e.stopPropagation();
+                if (!state.open || hasQueuedItems(other))
+                    openQueued(e);
+            }, onTouchStart: e => {
+                if (touchXY.current.x == 0)
+                    touchXY.current.x = e.touches[0].screenX;
+                if (touchXY.current.y == 0)
+                    touchXY.current.y = e.touches[0].screenY;
+                touchTime.current = Date.now();
+            }, onTouchMove: e => {
+                const x2 = e.touches[0].screenX;
+                const y2 = e.touches[0].screenY;
+                const pX = Math.max(1, Math.abs(e.touches[0].pageX));
+                const pY = Math.max(1, Math.abs(e.touches[0].pageY));
+                if ((Math.abs(x2 - touchXY.current.x) / pX > 0.05) || (Math.abs(y2 - touchXY.current.y) / pY > 0.05)) {
+                    touchTime.current = null;
+                }
+            }, onTouchEnd: e => {
+                if (!enabled)
+                    return;
+                if (touchTime.current && Date.now() - touchTime.current > 300) {
+                    touchTime.current = null;
+                    touchXY.current.x = touchXY.current.y = 0;
+                    if (!state.open || hasQueuedItems(other)) {
+                        openQueued({ clientX: e.changedTouches[0].clientX, clientY: e.changedTouches[0].clientY, target: e.target, preventDefault: () => e.preventDefault(), stopPropagation: () => e.stopPropagation() });
+                    }
+                }
+            }, onDoubleClick: () => {
+                timeEvent.current = Date.now();
+            }, onMouseUp: event => {
+                if (!enabled)
+                    return;
+                if (event.button == 2 || Date.now() - timeEvent.current < 300) {
+                    if (!state.open || hasQueuedItems(other))
+                        openQueued(event);
+                }
+            }, children: [children, state.open && enabled && state.layerId == layerId && _jsx(OutsideClickArea, { outsideClick: handleClose, children: _jsx(Menu, { className: className, data: state.items, coordinate: relativePoint(), zIndex: zIndex }) })] });
     }
     return {
-        bb, get map() { return map; }, get menuMouse() { return menuMouse; }, ReactMouse, ReactMenu: MenuBase
+        bb,
+        get map() { return map; },
+        get menuMouse() { return menuMouse; },
+        getState,
+        subscribe,
+        openAt,
+        openAtPoint,
+        close,
+        Layer,
+        MenuView: Menu,
     };
 }
-export const mouseMenuApi = GetMouseMenuApi();
+export const contextMenu = createContextMenu();

package/lib/common/src/menu/menuR.d.ts

@@ -1,6 +1,6 @@
 import React from "react";
-import { tMenuReact } from "./menu";
-export declare function GetMenuR(): {
+import { MenuItem } from "./menu";
+export declare function createRightClickMenu(): {
     /**
      * Manage the global `bb` variable that prevents opening multiple
      * menus.
@@ -9,7 +9,7 @@ export declare function GetMenuR(): {
     MenuR: ({ children, other, statusOn, onUnClick, onConsume, zIndex, className }: {
         children: React.ReactElement;
         zIndex?: number;
-        other?: () => (tMenuReact)[];
+        other?: () => (MenuItem)[];
         statusOn?: boolean;
         onUnClick?: (e: boolean) => void;
         onConsume?: () => void;

package/lib/common/src/menu/menuR.js

@@ -1,9 +1,9 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import React, { useEffect, useRef } from "react";
-import { MenuBase } from "./menu";
-import { DivOutsideClick } from "../hooks/useOutside";
+import { Menu } from "./menu";
+import { OutsideClickArea } from "../hooks/useOutside";
 // Wrapper function for creating MenuR and managing the global `bb` variable.
-export function GetMenuR() {
+export function createRightClickMenu() {
     let bb = false; // Global activity flag that prevents opening multiple menus.
     // Main MenuR component
     function MenuR({ children, other = () => [], statusOn = true, onUnClick, onConsume, zIndex, className }) {
@@ -92,13 +92,13 @@ export function GetMenuR() {
                 }
             }, children: [children /* Child element whose events are tracked */, show.status && statusOn && (
                 // Show the context menu
-                _jsx(DivOutsideClick, { outsideClick: () => {
+                _jsx(OutsideClickArea, { outsideClick: () => {
                         if (!bb)
                             return; // Menu is already inactive; do not call close handler
                         bb = false; // Menu is no longer active
                         onUnClick?.(false); // Call close handler
                         setShow({ status: false }); // Hide the menu
-                    }, children: _jsx(MenuBase, { className: className, data: [
+                    }, children: _jsx(Menu, { className: className, data: [
                             ...(show.plusMenu ?? []),
                             ...(show.menu ?? [])
                         ], coordinate: { ...show.coordinate }, zIndex: zIndex }) }))] }));

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

@@ -16,6 +16,6 @@ export declare const StyleGridDefault: {
 };
 export declare function StyleCSSHeadGridEdit(name: string, rules: string): void;
 export declare function StyleCSSHeadGrid(): void;
-export type tCallFuncAgGrid<T> = (params: CellClassParams & {
+export type AgGridClassRule<T> = (params: CellClassParams & {
     data: T;
 }) => CSSProperties | Record<string, any>;

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

@@ -19,7 +19,7 @@ export declare const tokens: {
         readonly itemHoverBgColor: "#fff";
         readonly shadow: "0 0 20px 14px rgba(34, 60, 80, 0.2)";
     };
-    /** DivRnd3 window chrome (--wnd-*). Defaults = legacy look; apps re-skin via :root[data-theme].
+    /** FloatingWindow window chrome (--wnd-*). Defaults = legacy look; apps re-skin via :root[data-theme].
      *  --wnd-header-height/color/font-size/letter-spacing/transform are intentionally undeclared
      *  (inherit/auto) until a theme sets them. */
     readonly wnd: {

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

@@ -21,7 +21,7 @@ export const tokens = {
         itemHoverBgColor: '#fff',
         shadow: '0 0 20px 14px rgba(34, 60, 80, 0.2)',
     },
-    /** DivRnd3 window chrome (--wnd-*). Defaults = legacy look; apps re-skin via :root[data-theme].
+    /** FloatingWindow window chrome (--wnd-*). Defaults = legacy look; apps re-skin via :root[data-theme].
      *  --wnd-header-height/color/font-size/letter-spacing/transform are intentionally undeclared
      *  (inherit/auto) until a theme sets them. */
     wnd: {

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

@@ -1,24 +1,24 @@
-export type tDirtyListener = (scope?: string, key?: string) => void;
-export interface IServerSaveBasePromise {
+export type DirtyListener = (scope?: string, key?: string) => void;
+export interface CacheStorage {
     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 {
+export declare class BrowserCacheStorage implements CacheStorage {
     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 {
+export declare class LocalStorageCache implements CacheStorage {
     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): {
+export declare const browserCacheStorage: BrowserCacheStorage;
+export declare const localStorageCache: LocalStorageCache;
+export declare const restoreDates: (obj: unknown) => void;
+export declare function createCacheMapWithStorage(arr: [k: string, v: Map<string, unknown>][], Save: CacheStorage): {
     load(): Promise<void>;
     save(): Promise<void>;
     saveDebounced(delay?: number): void;
@@ -27,12 +27,12 @@ export declare function CacheFuncMapBase(arr: [k: string, v: Map<string, unknown
     /** Manual announcement for state the observable maps cannot see (plain Map entries). */
     markDirty: (scope?: string, key?: string) => void;
     /** Subscribe to this instance's dirty events (coalesced, async); returns unsubscribe. */
-    onDirty(cb: tDirtyListener): () => void;
+    onDirty(cb: DirtyListener): () => void;
     /** Cheap hint (e.g. a beforeunload guard); the save diff is the source of truth. */
     isDirty(): boolean;
     getArr: [k: string, v: Map<string, unknown>][];
 };
-export declare function CacheFuncMap(arr: [k: string, v: Map<string, unknown>][]): {
+export declare function createCacheMap(arr: [k: string, v: Map<string, unknown>][]): {
     load(): Promise<void>;
     save(): Promise<void>;
     saveDebounced(delay?: number): void;
@@ -41,7 +41,7 @@ export declare function CacheFuncMap(arr: [k: string, v: Map<string, unknown>][]
     /** Manual announcement for state the observable maps cannot see (plain Map entries). */
     markDirty: (scope?: string, key?: string) => void;
     /** Subscribe to this instance's dirty events (coalesced, async); returns unsubscribe. */
-    onDirty(cb: tDirtyListener): () => void;
+    onDirty(cb: DirtyListener): () => void;
     /** Cheap hint (e.g. a beforeunload guard); the save diff is the source of truth. */
     isDirty(): boolean;
     getArr: [k: string, v: Map<string, unknown>][];

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

@@ -0,0 +1,37 @@
+import type { GridReadyEvent } from "ag-grid-community";
+import type { RefObject } from "react";
+declare const defaultGridRowsOptions: {
+    update: boolean;
+    add: boolean;
+    updateBuffer: boolean;
+    sync: boolean;
+};
+export type GridRowsOptions = Partial<typeof defaultGridRowsOptions>;
+type CommonGridRowsParams<T> = {
+    getId: (...a: any[]) => string;
+    bufTable: {
+        [id: string]: Partial<T>;
+    };
+    option?: GridRowsOptions;
+};
+export type ApplyGridRowsParams<T> = CommonGridRowsParams<T> & ({
+    newData?: (Partial<T>)[];
+    removeData?: (Partial<T>)[];
+    synchronization?: never;
+    gridRef?: RefObject<GridReadyEvent<T, any> | null | undefined>;
+    grid?: GridReadyEvent<T, any> | null | undefined;
+    onlyMemo?: boolean;
+} | ({
+    newData?: never;
+    removeData?: never;
+    synchronization: true;
+    onlyMemo?: never;
+} & ({
+    grid: GridReadyEvent<T, any> | null | undefined;
+    gridRef?: never;
+} | {
+    gridRef: RefObject<GridReadyEvent<T, any> | null | undefined>;
+    grid?: never;
+})));
+export declare function applyGridRows<T>(params: ApplyGridRowsParams<T>): void;
+export {};

package/lib/common/src/utils/{applyTransactionAsyncUpdate.js → gridRows.js}

@@ -1,15 +1,13 @@
-// Wrapper to simplify working with the grid through a memory point
-const optionsDef = {
+const defaultGridRowsOptions = {
     update: true,
     add: true,
     updateBuffer: true,
     sync: false,
 };
-function applyTransactionAsyncUpdate3({ getId, bufTable, option, newData, grid, remove }) {
-    const op = { ...optionsDef, ...(option ?? {}) };
+function applyGridRowsCore({ getId, bufTable, option, newData, grid, remove }) {
+    const op = { ...defaultGridRowsOptions, ...(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,25 +29,11 @@ function applyTransactionAsyncUpdate3({ getId, bufTable, option, newData, grid,
         });
         return;
     }
-    // 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 {};
-}
 function resolveGrid(params) {
     if (params.grid?.api?.getRowNode)
         return params.grid;
@@ -57,13 +41,12 @@ function resolveGrid(params) {
         return params.gridRef.current;
     return null;
 }
-export function applyTransactionAsyncUpdate2(params) {
+export function applyGridRows(params) {
     const { getId, bufTable, newData, removeData } = params;
-    const op = { ...optionsDef, ...(params.option ?? {}) };
+    const op = { ...defaultGridRowsOptions, ...(params.option ?? {}) };
     const g = resolveGrid(params);
     if (g && params.onlyMemo != true) {
         if (params.synchronization) {
-            // === SYNCHRONIZATION: bufTable is the source of truth ===
             const bufIds = new Set(Object.keys(bufTable));
             const gridIds = new Set();
             const arrAdd = [];
@@ -99,7 +82,7 @@ export function applyTransactionAsyncUpdate2(params) {
                     toRemove.push(existing);
             });
             if (newData?.length || toRemove.length)
-                applyTransactionAsyncUpdate3({ grid: g, newData: newData ?? [], getId, bufTable, option: op, remove: toRemove });
+                applyGridRowsCore({ grid: g, newData: newData ?? [], getId, bufTable, option: op, remove: toRemove });
         }
     }
     else {
@@ -112,18 +95,3 @@ 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; // 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))) // If both a and b are valid numbers
-            ? a - b // Difference between numbers
-            : a == b
-                ? 0 // If values are equal, return 0
-                : (!Number.isNaN(b) && b != undefined)
-                    ? (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/index.d.ts

@@ -1,8 +1,8 @@
-export * from './applyTransactionAsyncUpdate';
+export * from './gridRows';
 export * from './arrayPromise';
 export * from './cache';
 export * from './callbackHub';
 export * from './inputAutoStep';
-export * from './mapMemory';
+export * from './memoryStore';
 export * from './observableMap';
 export * from './pageVisibilityContext';

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

@@ -1,8 +1,8 @@
-export * from './applyTransactionAsyncUpdate';
+export * from './gridRows';
 export * from './arrayPromise';
 export * from './cache';
 export * from './callbackHub';
 export * from './inputAutoStep';
-export * from './mapMemory';
+export * from './memoryStore';
 export * from './observableMap';
 export * from './pageVisibilityContext';

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

@@ -1,10 +1,10 @@
-interface IStepInputElement extends HTMLElement {
+interface StepInputElement extends HTMLElement {
     value: string;
     step: string;
     min: string;
     max: string;
 }
-export declare function SetAutoStepForElement(element: IStepInputElement, params?: {
+export declare function setAutoStepForElement(element: StepInputElement, params?: {
     minStep?: number | undefined;
     maxStep?: number;
 }): () => void;

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

@@ -1,78 +1,69 @@
 /// <reference lib="dom" />
-// 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
+import { decimals, round } from "wenay-common2";
 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 }) {
+export function setAutoStepForElement(element, params = { maxStep: 1 }) {
     appliedHandlers.get(element)?.();
-    function parse(valueStr) { let val = parseFloat(valueStr); return isNaN(val) ? null : val; }
+    function parse(valueStr) { const val = parseFloat(valueStr); return isNaN(val) ? null : val; }
     const { minStep, maxStep = 1 } = params;
-    const maxDigits = minStep ? GetDblPrecision(minStep) : undefined;
+    const maxDigits = minStep ? decimals(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);
+    let digitsCurrent = null;
+    let stepCurrent = parse(element.step);
+    let minCurrent = 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(/\.|,/); // Find a dot or comma
-        let digits = (dotPos >= 0) ? valueStr.length - dotPos - 1 : 0;
+        const 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);
+            digits = decimals(parseFloat(valueStr), 10, minDigits);
         if (maxDigits != null)
             digits = Math.min(digits, maxDigits);
-        let step = NormalizeDouble(Math.pow(0.1, digits), digits);
+        let step = round(Math.pow(0.1, digits), digits);
         if (minStep)
-            step = NormalizeDouble(Math.round(step / minStep) * minStep, digits);
+            step = round(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(_min);
-            element.min = _min + "";
+                return stepCurrent;
+        digitsCurrent = digits;
+        stepCurrent = step;
+        if (minCurrent != null) {
+            if (Math.abs(minCurrent) % step != 0)
+                minCurrent = Math.floor(Math.abs(minCurrent) / step) * step * Math.sign(minCurrent);
+            element.min = minCurrent + "";
         }
         element.step = step + "";
         return step;
     }
-    let modeAuto = !_step || isPowerOfTenth(_step);
+    let modeAuto = !stepCurrent || isPowerOfTenth(stepCurrent);
     if (modeAuto) {
-        calculateStep((_step ? (Math.round(parseFloat(element.value) / _step) * _step) : element.value) + "");
+        calculateStep((stepCurrent ? (Math.round(parseFloat(element.value) / stepCurrent) * stepCurrent) : element.value) + "");
     }
-    if (_step && minDefault && Math.abs(minDefault % _step) > 1e-10)
+    if (stepCurrent && minDefault && Math.abs(minDefault % stepCurrent) > 1e-10)
         modeAuto = false;
-    else if (_step && maxDefault && Math.abs(maxDefault % _step) > 1e-10)
+    else if (stepCurrent && maxDefault && Math.abs(maxDefault % stepCurrent) > 1e-10)
         modeAuto = false;
     else
-        modeAuto ||= (_step != null && (minStep == null || _step > minStep));
-    // addEventListener instead of on*=: do not overwrite other handlers; return a disposer
+        modeAuto ||= (stepCurrent != null && (minStep == null || stepCurrent > minStep));
     const onKeyUp = () => { if (modeAuto)
         calculateStep(element.value); };
     const onChange = () => {
-        let digits = _digits;
+        const digits = digitsCurrent;
         if (digits != null)
             element.value = parseFloat(element.value).toFixed(digits);
         if (minDefault != null && parseFloat(element.value) < minDefault) {
             element.step = stepDefault + "";
             element.value = minDefault + "";
             element.min = minDefault + "";
-            _digits = null;
+            digitsCurrent = null;
         }
         element.setAttribute("value", element.value);
     };
@@ -86,5 +77,3 @@ export function SetAutoStepForElement(element, params = { maxStep: 1 }) {
     appliedHandlers.set(element, dispose);
     return dispose;
 }
-//import * as Time from "./Time"
-//import {const_Date} from "./Time";