@mi-avalon/libs 0.0.24 → 0.0.26

package/dist/utils/calc.js

@@ -1,92 +1,366 @@
 class CMX {
+    static factorialCache = new Map();
     /**
-     ** 加
-     **/
-    add = function (arg1, arg2) {
-        let r1, r2, m, c;
-        try {
-            r1 = arg1.toString().split('.')[1].length;
-        }
-        catch (e) {
-            r1 = 0;
-        }
-        try {
-            r2 = arg2.toString().split('.')[1].length;
-        }
-        catch (e) {
-            r2 = 0;
-        }
-        c = Math.abs(r1 - r2);
-        m = Math.pow(10, Math.max(r1, r2));
-        if (c > 0) {
-            let cm = Math.pow(10, c);
-            if (r1 > r2) {
-                arg1 = Number(arg1.toString().replace('.', ''));
-                arg2 = Number(arg2.toString().replace('.', '')) * cm;
-            }
-            else {
-                arg1 = Number(arg1.toString().replace('.', '')) * cm;
-                arg2 = Number(arg2.toString().replace('.', ''));
+     * 获取数字的小数位数长度
+     * @private
+     * @param num 要检查的数字
+     * @returns 小数位数长度
+     */
+    static getDecimalLength(num) {
+        const str = num.toString();
+        const decimalIndex = str.indexOf('.');
+        return decimalIndex === -1 ? 0 : str.length - decimalIndex - 1;
+    }
+    /**
+     * 将数字转换为整数（移除小数点）
+     * @private
+     * @param num 要转换的数字
+     * @param decimalPlaces 需要补零的小数位数
+     * @returns 转换后的整数值
+     */
+    static toInteger(num, decimalPlaces) {
+        const str = num.toString().replace('.', '');
+        return Number(str) * Math.pow(10, decimalPlaces);
+    }
+    /**
+     * 精确加法运算（支持多个参数）
+     * @param args 要相加的数字序列
+     * @returns 所有数字的和
+     * @example
+     * cmx.add(0.1, 0.2) // 返回 0.3
+     * cmx.add(1, 2, 3) // 返回 6
+     */
+    add(...args) {
+        if (args.length < 2)
+            return args[0] || 0;
+        return args.reduce((acc, current) => {
+            // 获取两个数的小数位数
+            const r1 = CMX.getDecimalLength(acc);
+            const r2 = CMX.getDecimalLength(current);
+            // 计算最大小数位数和对应的10的幂
+            const maxDecimal = Math.max(r1, r2);
+            const m = Math.pow(10, maxDecimal);
+            // 将两个数调整为相同小数位数的整数
+            const adjusted1 = CMX.toInteger(acc, maxDecimal - r1);
+            const adjusted2 = CMX.toInteger(current, maxDecimal - r2);
+            // 相加后还原小数位
+            return (adjusted1 + adjusted2) / m;
+        });
+    }
+    /**
+     * 精确减法运算
+     * @param arg1 被减数
+     * @param arg2 减数
+     * @returns 两数之差
+     * @example
+     * cmx.sub(0.3, 0.1) // 返回 0.2
+     */
+    sub(arg1, arg2) {
+        const r1 = CMX.getDecimalLength(arg1);
+        const r2 = CMX.getDecimalLength(arg2);
+        const maxDecimal = Math.max(r1, r2);
+        const m = Math.pow(10, maxDecimal);
+        // 先转换为整数运算，再还原小数位
+        return Number(((arg1 * m - arg2 * m) / m).toFixed(maxDecimal));
+    }
+    /**
+     * 精确乘法运算（支持多个参数）
+     * @param args 要相乘的数字序列
+     * @returns 所有数字的乘积
+     * @example
+     * cmx.mul(0.1, 0.2) // 返回 0.02
+     * cmx.mul(2, 3, 4) // 返回 24
+     */
+    mul(...args) {
+        if (args.length < 2)
+            return args[0] || 0;
+        return args.reduce((acc, current) => {
+            // 计算总小数位数
+            const decimalPlaces = CMX.getDecimalLength(acc) + CMX.getDecimalLength(current);
+            // 移除小数点转换为整数
+            const adjusted1 = Number(acc.toString().replace('.', ''));
+            const adjusted2 = Number(current.toString().replace('.', ''));
+            // 相乘后还原总小数位
+            return (adjusted1 * adjusted2) / Math.pow(10, decimalPlaces);
+        });
+    }
+    /**
+     * 精确除法运算
+     * @param arg1 被除数
+     * @param arg2 除数
+     * @returns 两数之商
+     * @throws {Error} 除数为零时抛出错误
+     * @example
+     * cmx.div(0.3, 0.1) // 返回 3
+     */
+    div(arg1, arg2) {
+        if (arg2 === 0)
+            throw new Error('除数不能为零');
+        // 添加误差补偿
+        const compensation = 1 + Number.EPSILON;
+        const t1 = CMX.getDecimalLength(arg1);
+        const t2 = CMX.getDecimalLength(arg2);
+        const r1 = Number(arg1.toString().replace('.', '')) * compensation;
+        const r2 = Number(arg2.toString().replace('.', '')) * compensation;
+        return (r1 / r2) * Math.pow(10, t2 - t1);
+    }
+    /**
+     * 精确四舍五入
+     * @param num 要舍入的数字
+     * @param decimalPlaces 保留的小数位数（默认为0）
+     * @returns 舍入后的数字
+     * @example
+     * cmx.round(1.2345, 2) // 返回 1.23
+     */
+    round(num, decimalPlaces = 0) {
+        const m = Math.pow(10, decimalPlaces);
+        return Math.round(num * m) / m;
+    }
+    /**
+     * 计算百分比值
+     * @param value 基础值
+     * @param percent 百分比
+     * @returns 计算后的百分比值
+     * @example
+     * cmx.percent(200, 15) // 返回 30（200的15%）
+     */
+    percent(value, percent) {
+        return this.div(this.mul(value, percent), 100);
+    }
+    /**
+     * 计算平均数
+     * @param args 要计算平均数的数字序列
+     * @returns 平均数
+     * @example
+     * cmx.average(1, 2, 3) // 返回 2
+     */
+    average(...args) {
+        if (args.length === 0)
+            return 0;
+        return this.div(args.reduce((a, b) => this.add(a, b)), args.length);
+    }
+    /**
+     * 判断两个数是否近似相等（解决浮点数精度问题）
+     * @param a 第一个数
+     * @param b 第二个数
+     * @param tolerance 允许的误差范围（默认为1e-10）
+     * @returns 如果差值小于误差范围则返回true
+     * @example
+     * cmx.approxEqual(0.1 + 0.2, 0.3) // 返回 true
+     */
+    approxEqual(a, b, tolerance = 1e-10) {
+        return Math.abs(this.sub(a, b)) < tolerance;
+    }
+    /**
+     * 计算自然对数（ln(x)）
+     * @param num 要计算对数的数字
+     * @param decimalPlaces 结果保留的小数位数（默认保留10位）
+     * @returns 自然对数值
+     * @throws {Error} 当输入小于等于0时抛出错误
+     * @example
+     * cmx.ln(1)      // 返回 0
+     * cmx.ln(Math.E) // 返回 1
+     */
+    ln(num, decimalPlaces = 10) {
+        if (num <= 0)
+            throw new Error('对数函数的输入必须为正数');
+        if (num === 1)
+            return 0;
+        // 使用泰勒级数展开计算自然对数
+        let result = 0;
+        const tolerance = Math.pow(10, -decimalPlaces - 1);
+        let term = this.div(this.sub(num, 1), this.add(num, 1));
+        const termSquared = this.mul(term, term);
+        let currentTerm = term;
+        let n = 1;
+        do {
+            result = this.add(result, this.div(currentTerm, n));
+            currentTerm = this.mul(currentTerm, termSquared);
+            n += 2;
+        } while (Math.abs(currentTerm) > tolerance);
+        return this.round(this.mul(2, result), decimalPlaces);
+    }
+    /**
+     * 高精度指数函数（解决Math.exp的精度问题）
+     * @param x 指数
+     * @param decimalPlaces 精度位数（默认10位）
+     * @returns e^x 的精确值
+     * @example
+     * cmx.exp(1)  // 2.7182818285（比Math.exp(1)更可控精度）
+     * cmx.exp(-3.5)  // 0.0301973834
+     */
+    exp(x, decimalPlaces = 10) {
+        // 添加提前终止条件
+        if (x === 0)
+            return 1;
+        if (x === 1)
+            return Math.E;
+        let result = 1;
+        let term = 1;
+        const tolerance = Math.pow(10, -decimalPlaces - 1);
+        let n = 1;
+        let prevResult = 0;
+        do {
+            prevResult = result;
+            term = this.div(this.mul(term, x), n);
+            result = this.add(result, term);
+            n++;
+        } while (Math.abs(term) > tolerance &&
+            !this.approxEqual(result, prevResult, tolerance) // 新增终止条件
+        );
+        return this.round(result, decimalPlaces);
+    }
+    /**
+     * 精确计算平方根（解决Math.sqrt的精度问题）
+     * @param num 输入数字（必须 ≥0）
+     * @param decimalPlaces 结果精度（默认10位）
+     * @returns 精确的平方根值
+     * @throws {Error} 输入负数时抛出
+     * @example
+     * cmx.sqrt(2) // 1.4142135624 (Math.sqrt(2)可能产生微小误差)
+     */
+    sqrt(num, decimalPlaces = 10) {
+        if (num < 0)
+            throw new Error('负数平方根需使用复数计算');
+        if (num === 0)
+            return 0;
+        // 牛顿迭代法+自定义精度控制
+        let guess = num / 2;
+        const tolerance = Math.pow(10, -decimalPlaces - 1);
+        do {
+            guess = this.div(this.add(guess, this.div(num, guess)), 2);
+        } while (Math.abs(this.sub(this.mul(guess, guess), num)) > tolerance);
+        return this.round(guess, decimalPlaces);
+    }
+    /**
+     * 安全对数计算（解决Math.log的边界问题）
+     * @param num 输入数字（支持 ≤0 的特殊处理）
+     * @param options 配置项：
+     *   - safe: 是否返回安全值（默认true）
+     *   - replaceNeg: 负数替换值（默认NaN）
+     *   - replaceZero: 零替换值（默认-Infinity）
+     * @returns 处理后的结果
+     * @example
+     * cmx.safeLog(-1) // NaN（Math.log直接报错）
+     * cmx.safeLog(0)  // -Infinity（可配置替换值）
+     */
+    safeLog(num, options = {}) {
+        const { safe = true, replaceNeg = NaN, replaceZero = -Infinity } = options;
+        if (num > 0)
+            return Math.log(num);
+        if (!safe)
+            throw new Error('Invalid input');
+        return num === 0 ? replaceZero : replaceNeg;
+    }
+    /**
+     * 精确阶乘（解决Math无阶乘方法的问题）
+     * @param n 输入整数（0≤n≤170）
+     * @returns 精确结果（超过170返回Infinity）
+     * @example
+     * cmx.factorial(20) // 2432902008176640000（JS整数精确范围）
+     */
+    factorial(n) {
+        if (!Number.isInteger(n) || n < 0)
+            return NaN;
+        if (n < 0)
+            return NaN;
+        if (n > Number.MAX_SAFE_INTEGER) {
+            // 使用BigInt计算后转换为科学计数法
+            let result = BigInt(1);
+            for (let i = 2; i <= n; i++) {
+                result *= BigInt(i);
             }
+            return Number(result.toString());
         }
-        else {
-            arg1 = Number(arg1?.toString().replace('.', ''));
-            arg2 = Number(arg2?.toString().replace('.', ''));
-        }
-        return (arg1 + arg2) / m;
-    };
-    /**
-     ** 减
-     **/
-    sub = function (arg1, arg2) {
-        let r1, r2, m, n;
-        try {
-            r1 = arg1.toString().split('.')[1].length;
-        }
-        catch (e) {
-            r1 = 0;
-        }
-        try {
-            r2 = arg2.toString().split('.')[1].length;
-        }
-        catch (e) {
-            r2 = 0;
+        if (n > 170)
+            return Infinity;
+        if (CMX.factorialCache.has(n))
+            return CMX.factorialCache.get(n);
+        let result = 1;
+        for (let i = 2; i <= n; i++) {
+            if (CMX.factorialCache.has(i)) {
+                result = CMX.factorialCache.get(i);
+                continue;
+            }
+            result = this.mul(result, i);
+            CMX.factorialCache.set(i, result); // 缓存中间结果
         }
-        m = Math.pow(10, Math.max(r1, r2)); //last modify by deeka //动态控制精度长度
-        n = r1 >= r2 ? r1 : r2;
-        return Number(((arg1 * m - arg2 * m) / m).toFixed(n));
-    };
-    /**
-     ** 乘
-     **/
-    mul = function (arg1, arg2) {
-        let m = 0, s1 = arg1.toString(), s2 = arg2.toString();
-        try {
-            m += s1.split('.')[1].length;
+        return result;
+    }
+    /**
+     * 双曲函数精确计算（解决大数精度问题）
+     * @param x 输入值
+     * @param type 函数类型：'sinh' | 'cosh' | 'tanh'
+     * @param decimalPlaces 精度（默认10位）
+     * @returns 计算结果
+     * @example
+     * cmx.hypFunc(1, 'tanh') // 0.761594156（比Math.tanh更精确）
+     */
+    hypFunc(x, type, decimalPlaces = 10) {
+        // 使用泰勒展开式避免大数计算误差
+        const expX = this.exp(x, decimalPlaces + 2);
+        const expNegX = this.exp(-x, decimalPlaces + 2);
+        switch (type) {
+            case 'sinh':
+                return this.round(this.div(this.sub(expX, expNegX), 2), decimalPlaces);
+            case 'cosh':
+                return this.round(this.div(this.add(expX, expNegX), 2), decimalPlaces);
+            case 'tanh':
+                return this.round(this.div(this.sub(expX, expNegX), this.add(expX, expNegX)), decimalPlaces);
+            default:
+                throw new Error('不支持的函数类型');
         }
-        catch (e) { }
-        try {
-            m += s2.split('.')[1].length;
+    }
+    /**
+     * 精确排列组合（解决大数计算问题）
+     * @param n 总数
+     * @param k 选取数
+     * @param type 计算类型：'permutation' | 'combination'
+     * @returns 精确结果
+     * @example
+     * cmx.permComb(100, 5, 'combination') // 75287520
+     */
+    permComb(n, k, type) {
+        if (!Number.isInteger(n) || !Number.isInteger(k) || k > n || k < 0) {
+            return NaN;
         }
-        catch (e) { }
-        return ((Number(s1.replace('.', '')) * Number(s2.replace('.', ''))) / Math.pow(10, m));
-    };
-    /**
-     ** 除
-     **/
-    div = function (arg1, arg2) {
-        let t1 = 0, t2 = 0, r1, r2;
-        try {
-            t1 = arg1.toString().split('.')[1].length;
+        let result = 1;
+        for (let i = 0; i < k; i++) {
+            result = this.mul(result, n - i);
+            if (type === 'combination') {
+                result = this.div(result, i + 1);
+            }
         }
-        catch (e) { }
-        try {
-            t2 = arg2.toString().split('.')[1].length;
+        return result;
+    }
+    /**
+     * 计算最大公约数（GCD）
+     * @param a 第一个数字
+     * @param b 第二个数字
+     * @returns 最大公约数
+     * @example
+     * cmx.gcd(48, 18) // 返回 6
+     */
+    gcd(a, b) {
+        a = Math.abs(a);
+        b = Math.abs(b);
+        while (b !== 0) {
+            const temp = b;
+            b = a % b;
+            a = temp;
         }
-        catch (e) { }
-        r1 = Number(arg1.toString().replace('.', ''));
-        r2 = Number(arg2.toString().replace('.', ''));
-        return (r1 / r2) * Math.pow(10, t2 - t1);
-    };
+        return a;
+    }
+    /**
+     * 计算最小公倍数（LCM）
+     * @param a 第一个数字
+     * @param b 第二个数字
+     * @returns 最小公倍数
+     * @example
+     * cmx.lcm(12, 15) // 返回 60
+     */
+    lcm(a, b) {
+        return this.div(this.mul(a, b), this.gcd(a, b));
+    }
 }
 export const cmx = new CMX();

package/dist/utils/index.d.ts

@@ -1,4 +1,5 @@
 export * from './calc';
 export * from './nextTick';
+export * from './openModal';
 export * from './util';
 export * from './version';

package/dist/utils/index.js

@@ -1,5 +1,5 @@
 export * from './calc';
 export * from './nextTick';
-// export * from './openModal';
+export * from './openModal';
 export * from './util';
 export * from './version';

package/dist/utils/openModal.d.ts

@@ -0,0 +1,15 @@
+import type { ModalProps } from 'antd';
+import { type ComponentType } from 'react';
+interface IModalBaseClosedParams {
+    cancel?: boolean;
+    ok?: boolean;
+}
+export interface IModalBaseProps extends ModalProps {
+    onClosed?: (params?: IModalBaseClosedParams) => void;
+}
+export interface IModalControls<T = any> {
+    destroy: (params?: IModalBaseClosedParams) => void;
+    update: (configUpdate: Partial<T> | ((prevConfig: T) => T)) => void;
+}
+declare function openModal<ITModalProps extends IModalBaseProps = IModalBaseProps>(DialogComponent: ComponentType<ITModalProps>, initialConfig: ITModalProps): IModalControls<ITModalProps>;
+export { openModal };

package/dist/utils/openModal.js

@@ -0,0 +1,98 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as ReactDOMClient from 'react-dom/client';
+const { createRoot } = ReactDOMClient;
+const destroyFns = [];
+let modalContainer = null;
+let root = null;
+function getOrCreateContainer() {
+    if (!modalContainer) {
+        modalContainer = document.createElement('div');
+        document.body.appendChild(modalContainer);
+    }
+    return modalContainer;
+}
+function openModal(DialogComponent, initialConfig) {
+    const container = getOrCreateContainer();
+    let currentConfig = {
+        open: true,
+        ...initialConfig,
+        // 默认自动关闭
+        onClosed: initialConfig.onClosed ||
+            ((params) => {
+                unifiedDestroy(params);
+            }),
+    };
+    if (!root) {
+        try {
+            root = createRoot(container);
+        }
+        catch (error) {
+            console.error('Failed to create root:', error);
+            return {
+                destroy: () => { },
+                update: () => { },
+            };
+        }
+    }
+    const cleanup = () => {
+        if (root) {
+            root.unmount();
+            root = null;
+        }
+        if (modalContainer && modalContainer.parentNode) {
+            modalContainer.parentNode.removeChild(modalContainer);
+            modalContainer = null;
+        }
+    };
+    const destroy = (params) => {
+        if (typeof currentConfig.onClosed === 'function') {
+            currentConfig.onClosed(params);
+        }
+        // 从 destroyFns 中移除
+        const index = destroyFns.indexOf(destroy);
+        if (index !== -1) {
+            destroyFns.splice(index, 1);
+        }
+        // 销毁 modal
+        cleanup();
+    };
+    const render = (props) => {
+        if (root) {
+            root.render(_jsx(DialogComponent, { ...props }));
+        }
+    };
+    const update = (configUpdate) => {
+        currentConfig =
+            typeof configUpdate === 'function'
+                ? configUpdate(currentConfig)
+                : { ...currentConfig, ...configUpdate };
+        render(currentConfig);
+    };
+    // 统一的销毁函数
+    const unifiedDestroy = (params) => {
+        // 如果当前配置是打开的，关闭
+        if (currentConfig.open) {
+            currentConfig = {
+                ...currentConfig,
+                open: false,
+                onClosed: (closedParams) => {
+                    if (initialConfig.onClosed) {
+                        initialConfig.onClosed(closedParams || params);
+                    }
+                    destroy(closedParams || params);
+                },
+            };
+            render(currentConfig);
+        }
+        else {
+            console.warn('Modal is already closed.');
+        }
+    };
+    render(currentConfig);
+    destroyFns.push(unifiedDestroy);
+    return {
+        destroy: unifiedDestroy,
+        update,
+    };
+}
+export { openModal };

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@mi-avalon/libs",
 	"private": false,
-	"version": "0.0.24",
+	"version": "0.0.26",
 	"type": "module",
 	"main": "./dist/index.umd.js",
 	"module": "./dist/index.es.js",