lyb-js 1.0.7 → 1.0.8

package/dist/Formatter/LibJsNumComma/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @description 数字每三位添加逗号
+ * @param num 需要格式化的数字
+ * @param reserve 保留小数位数
+ * @example
+ * const formatted = libJsNumComma(1234567.89);
+ * console.log(formatted); //1,234,567.89
+ */
+export declare const libJsNumComma: (num: number, reserve?: number) => string;

package/dist/Formatter/LibJsNumComma/index.js

@@ -0,0 +1,13 @@
+/**
+ * @description 数字每三位添加逗号
+ * @param num 需要格式化的数字
+ * @param reserve 保留小数位数
+ * @example
+ * const formatted = libJsNumComma(1234567.89);
+ * console.log(formatted); //1,234,567.89
+ */
+export const libJsNumComma = (num, reserve = 2) => {
+    const str = num.toFixed(reserve).toString();
+    const reg = str.indexOf(".") > -1 ? /(\d)(?=(\d{3})+\.)/g : /(\d)(?=(?:\d{3})+$)/g;
+    return str.replace(reg, "$1,");
+};

package/dist/Formatter/LibJsNumberUnit/index.d.ts

@@ -0,0 +1,12 @@
+export interface LibJsNumberUnitParams {
+    [unit: string]: number;
+}
+/** @description 将大于1000的数字使用k为单位
+ * @param num 数字
+ * @param units 单位组，key为单位，value为格式化阈值
+ * @returns [数字, 单位]
+ * @example
+ * const [value, unit] = libJsNumberUnit(1500, { K: 1000, M: 1000000 });
+ * console.log(value, unit); //1.50 K
+ */
+export declare const libJsNumberUnit: (num: number, units: LibJsNumberUnitParams) => string[];

package/dist/Formatter/LibJsNumberUnit/index.js

@@ -0,0 +1,23 @@
+import Decimal from "decimal.js";
+/** @description 将大于1000的数字使用k为单位
+ * @param num 数字
+ * @param units 单位组，key为单位，value为格式化阈值
+ * @returns [数字, 单位]
+ * @example
+ * const [value, unit] = libJsNumberUnit(1500, { K: 1000, M: 1000000 });
+ * console.log(value, unit); //1.50 K
+ */
+export const libJsNumberUnit = (num, units) => {
+    const decimalValue = new Decimal(num);
+    const sortedUnits = Object.entries(units).sort(([, a], [, b]) => b - a);
+    for (const [unit, threshold] of sortedUnits) {
+        const decimalThreshold = new Decimal(threshold);
+        if (decimalValue.greaterThanOrEqualTo(decimalThreshold)) {
+            const formattedValue = decimalValue
+                .dividedBy(decimalThreshold)
+                .toFixed(2);
+            return [formattedValue, unit];
+        }
+    }
+    return [decimalValue.toFixed(2), ""];
+};

package/dist/Formatter/LibJsSecondsFormatterChinese/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @description 将秒数格式化为中文时间描述，支持扩展到年
+ * @param seconds 秒数
+ * @returns 格式化后的中文时间
+ * @example
+ * libJsSecondsFormatterChinese(100000); //"1天3小时46分40秒"
+ * libJsSecondsFormatterChinese(31536000); //"1年"
+ * libJsSecondsFormatterChinese(3600); //"1小时"
+ * libJsSecondsFormatterChinese(90); //"1分30秒"
+ */
+export declare const libJsSecondsFormatterChinese: (seconds: number) => string;

package/dist/Formatter/LibJsSecondsFormatterChinese/index.js

@@ -0,0 +1,42 @@
+import dayjs from "dayjs";
+import duration from "dayjs/plugin/duration";
+dayjs.extend(duration);
+/**
+ * @description 将秒数格式化为中文时间描述，支持扩展到年
+ * @param seconds 秒数
+ * @returns 格式化后的中文时间
+ * @example
+ * libJsSecondsFormatterChinese(100000); //"1天3小时46分40秒"
+ * libJsSecondsFormatterChinese(31536000); //"1年"
+ * libJsSecondsFormatterChinese(3600); //"1小时"
+ * libJsSecondsFormatterChinese(90); //"1分30秒"
+ */
+export const libJsSecondsFormatterChinese = (seconds) => {
+    const duration = dayjs.duration(seconds, "seconds");
+    const years = Math.floor(duration.asYears());
+    const months = Math.floor(duration.asMonths() % 12);
+    const days = Math.floor(duration.asDays() % 30);
+    const hours = duration.hours();
+    const minutes = duration.minutes();
+    const remainingSeconds = duration.seconds();
+    const timeParts = [];
+    if (years > 0) {
+        timeParts.push(`${years}年`);
+    }
+    if (months > 0) {
+        timeParts.push(`${months}月`);
+    }
+    if (days > 0) {
+        timeParts.push(`${days}天`);
+    }
+    if (hours > 0) {
+        timeParts.push(`${hours}小时`);
+    }
+    if (minutes > 0) {
+        timeParts.push(`${minutes}分`);
+    }
+    if (timeParts.length === 0 || remainingSeconds > 0) {
+        timeParts.push(`${remainingSeconds}秒`);
+    }
+    return timeParts.join("");
+};

package/dist/Math/LibJsCalculateExpression/index.d.ts

@@ -0,0 +1,9 @@
+/** @description 计算表达式字符串
+ * @param expression 表达式字符串
+ * @param point 小数点精度
+ * @returns 计算结果
+ * @example
+ * const result = libJsCalculateExpression("(1+2)-(3*4)/5");
+ * console.log(result); //0.6
+ */
+export declare const libJsCalculateExpression: (expression: string, point?: number) => number;

package/dist/Math/LibJsCalculateExpression/index.js

@@ -0,0 +1,107 @@
+import Decimal from 'decimal.js';
+/** @description 计算表达式字符串
+ * @param expression 表达式字符串
+ * @param point 小数点精度
+ * @returns 计算结果
+ * @example
+ * const result = libJsCalculateExpression("(1+2)-(3*4)/5");
+ * console.log(result); //0.6
+ */
+export const libJsCalculateExpression = (expression, point = 2) => {
+    //清除所有空格
+    expression = expression.replace(/\s+/g, '');
+    //支持的运算符和优先级
+    const operators = {
+        "+": 1,
+        "-": 1,
+        "*": 2,
+        "/": 2,
+    };
+    //支持的小数点精度
+    const toDecimal = (value) => new Decimal(value);
+    //判断字符是否是运算符
+    const isOperator = (char) => ['+', '-', '*', '/'].includes(char);
+    //判断字符是否是数字（包括小数点）
+    const isNumber = (char) => /[0-9.]/.test(char);
+    //解析表达式并计算
+    const evaluate = (expression) => {
+        const outputQueue = []; //输出队列
+        const operatorStack = []; //操作符栈
+        let i = 0;
+        while (i < expression.length) {
+            const char = expression[i];
+            if (isNumber(char)) {
+                let numStr = '';
+                //处理多位数字（支持小数）
+                while (i < expression.length && isNumber(expression[i])) {
+                    numStr += expression[i];
+                    i++;
+                }
+                outputQueue.push(toDecimal(numStr));
+            }
+            else if (char === '(') {
+                operatorStack.push(char);
+                i++;
+            }
+            else if (char === ')') {
+                //处理右括号，直到遇到左括号
+                while (operatorStack.length > 0 && operatorStack[operatorStack.length - 1] !== '(') {
+                    outputQueue.push(operatorStack.pop());
+                }
+                operatorStack.pop(); //弹出左括号
+                i++;
+            }
+            else if (isOperator(char)) {
+                //运算符
+                while (operatorStack.length > 0 && operators[operatorStack[operatorStack.length - 1]] >= operators[char]) {
+                    outputQueue.push(operatorStack.pop());
+                }
+                operatorStack.push(char);
+                i++;
+            }
+            else {
+                throw new Error(`无效字符: ${char}`);
+            }
+        }
+        //把所有剩余的操作符添加到输出队列
+        while (operatorStack.length > 0) {
+            outputQueue.push(operatorStack.pop());
+        }
+        //执行运算
+        const calcStack = [];
+        for (let token of outputQueue) {
+            if (typeof token === 'string') {
+                const b = calcStack.pop();
+                const a = calcStack.pop();
+                switch (token) {
+                    case '+':
+                        calcStack.push(a.add(b));
+                        break;
+                    case '-':
+                        calcStack.push(a.sub(b));
+                        break;
+                    case '*':
+                        calcStack.push(a.mul(b));
+                        break;
+                    case '/':
+                        if (b.eq(0))
+                            throw new Error("除数不能为零");
+                        calcStack.push(a.div(b));
+                        break;
+                }
+            }
+            else {
+                calcStack.push(token);
+            }
+        }
+        return calcStack.pop();
+    };
+    try {
+        //调用计算器并返回结果
+        const result = evaluate(expression);
+        return Number(result.toFixed(point)); //保留指定的小数位数
+    }
+    catch (error) {
+        throw new Error("表达式计算失败：" + error.message);
+    }
+};

package/dist/Math/LibJsConvertAngle/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @description 角度和弧度互相转换
+ * @param value 角度值或弧度值
+ * @param type 角度类型或弧度类型
+ * @example
+ * //角度转弧度
+ * libJsConvertAngle(90, "rad"); //返回 1.5708... (π/2)
+ *
+ * //弧度转角度
+ * libJsConvertAngle(Math.PI, "deg"); //返回 180
+ */
+export declare const libJsConvertAngle: (value: number, type: "rad" | "deg") => number;

package/dist/Math/LibJsConvertAngle/index.js

@@ -0,0 +1,22 @@
+/**
+ * @description 角度和弧度互相转换
+ * @param value 角度值或弧度值
+ * @param type 角度类型或弧度类型
+ * @example
+ * //角度转弧度
+ * libJsConvertAngle(90, "rad"); //返回 1.5708... (π/2)
+ *
+ * //弧度转角度
+ * libJsConvertAngle(Math.PI, "deg"); //返回 180
+ */
+export const libJsConvertAngle = (value, type) => {
+    if (type === "rad") {
+        return value * (Math.PI / 180);
+    }
+    else if (type === "deg") {
+        return value * (180 / Math.PI);
+    }
+    else {
+        throw new Error("请使用正确类型");
+    }
+};

package/dist/Math/LibJsCoordsAngle/index.d.ts

@@ -0,0 +1,15 @@
+/** @description 计算两点角度
+ * @param coord1 起点坐标
+ * @param coord2 终点坐标
+ * @example
+ * libJsCoordsAngle({ x: 0, y: 0 }, { x: 1, y: 0 }); //0
+ * libJsCoordsAngle({ x: 0, y: 0 }, { x: 1, y: 1 }); //45
+ * libJsCoordsAngle({ x: 0, y: 0 }, { x: 0, y: 1 }); //90
+ */
+export declare const libJsCoordsAngle: (coord1: {
+    x: number;
+    y: number;
+}, coord2: {
+    x: number;
+    y: number;
+}) => number;

package/dist/Math/LibJsCoordsAngle/index.js

@@ -0,0 +1,24 @@
+/** @description 计算两点角度
+ * @param coord1 起点坐标
+ * @param coord2 终点坐标
+ * @example
+ * libJsCoordsAngle({ x: 0, y: 0 }, { x: 1, y: 0 }); //0
+ * libJsCoordsAngle({ x: 0, y: 0 }, { x: 1, y: 1 }); //45
+ * libJsCoordsAngle({ x: 0, y: 0 }, { x: 0, y: 1 }); //90
+ */
+export const libJsCoordsAngle = (coord1, coord2) => {
+    //计算相对于第一个坐标的水平和垂直距离
+    const deltaX = coord2.x - coord1.x;
+    const deltaY = coord2.y - coord1.y;
+    //使用反三角函数计算角度（以弧度为单位）
+    const angleRad = Math.atan2(deltaY, deltaX);
+    //将弧度转换为角度
+    let angleDeg = angleRad * (180 / Math.PI);
+    //将角度转换为顺时针方向为正方向的角度
+    angleDeg = -angleDeg + 90;
+    //调整角度使得右边成为 360 度的位置变为 0 度
+    if (angleDeg < 0) {
+        angleDeg += 360;
+    }
+    return angleDeg;
+};

package/dist/Math/LibJsCoordsDistance/index.d.ts

@@ -0,0 +1,15 @@
+/** @description 计算两点距离
+ * @param coord1 起点坐标
+ * @param coord2 终点坐标
+ * @example
+ * libJsCoordsDistance({ x: 0, y: 0 }, { x: 3, y: 4 }); //5
+ * libJsCoordsDistance({ x: 1, y: 1 }, { x: 4, y: 5 }); //5
+ * libJsCoordsDistance({ x: 0, y: 0 }, { x: 0, y: 0 }); //0
+ */
+export declare const libJsCoordsDistance: (coord1: {
+    x: number;
+    y: number;
+}, coord2: {
+    x: number;
+    y: number;
+}) => number;

package/dist/Math/LibJsCoordsDistance/index.js

@@ -0,0 +1,16 @@
+/** @description 计算两点距离
+ * @param coord1 起点坐标
+ * @param coord2 终点坐标
+ * @example
+ * libJsCoordsDistance({ x: 0, y: 0 }, { x: 3, y: 4 }); //5
+ * libJsCoordsDistance({ x: 1, y: 1 }, { x: 4, y: 5 }); //5
+ * libJsCoordsDistance({ x: 0, y: 0 }, { x: 0, y: 0 }); //0
+ */
+export const libJsCoordsDistance = (coord1, coord2) => {
+    //计算两个坐标之间的水平和垂直距离
+    const deltaX = coord2.x - coord1.x;
+    const deltaY = coord2.y - coord1.y;
+    //使用勾股定理计算两点之间的距离
+    const distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
+    return distance;
+};

package/dist/Math/LibJsDecimal/index.d.ts

@@ -0,0 +1,10 @@
+/** @description 计算两个数的运算结果，并保留指定位数的小数
+ * @param num1 第一个数
+ * @param num2 第二个数
+ * @param operator 运算符，支持加减乘除
+ * @example
+ * libJsDecimal(10, 3, "+"); //13
+ * libJsDecimal(10, 3, "-"); //7
+ * libJsDecimal(10, 3, "/", 2); //3.33
+ */
+export declare const libJsDecimal: (num1: number, num2: number, operator: "+" | "-" | "*" | "/", point?: number) => number;

package/dist/Math/LibJsDecimal/index.js

@@ -0,0 +1,25 @@
+import { Decimal } from "decimal.js";
+/** @description 计算两个数的运算结果，并保留指定位数的小数
+ * @param num1 第一个数
+ * @param num2 第二个数
+ * @param operator 运算符，支持加减乘除
+ * @example
+ * libJsDecimal(10, 3, "+"); //13
+ * libJsDecimal(10, 3, "-"); //7
+ * libJsDecimal(10, 3, "/", 2); //3.33
+ */
+export const libJsDecimal = (num1, num2, operator, point = 2) => {
+    const calc = {
+        "+": (a, b) => a.add(b),
+        "-": (a, b) => a.sub(b),
+        "*": (a, b) => a.mul(b),
+        "/": (a, b) => {
+            if (b.eq(0)) {
+                throw new Error("除数不能为0");
+            }
+            return a.div(b);
+        },
+    };
+    const result = calc[operator](new Decimal(num1), new Decimal(num2));
+    return Number(result.toFixed(point));
+};

package/dist/Misc/LibJsRegFormValidate/index.d.ts

@@ -0,0 +1,32 @@
+export type ValidationResult = {
+    key: string;
+    msg: string;
+    name: string;
+};
+/**
+ * @description 通过传递对象数字的方式进行正则或自定义函数进行验证
+ * @param form 表单数据对象
+ * @param rules 验证规则数组
+ * @returns 验证结果数组，包含未通过验证的项
+ * @example
+ * const form = { username: "john", email: "john@example.com" };
+ * const rules = [
+ *   { key: "username", verify: /^[a-zA-Z0-9]{3,}$/, msg: "用户名不合法", name: "用户名" },
+ *   { key: "email", verify: /^\S+@\S+\.\S+$/, msg: "邮箱格式不正确", name: "邮箱" },
+ * ];
+ * libJsRegFormValidate(form, rules);
+ * //返回结果: []
+ *
+ * const invalidForm = { username: "jo", email: "invalid-email" };
+ * libJsRegFormValidate(invalidForm, rules);
+ * //返回结果: [
+ * //  { key: "username", msg: "用户名不合法", name: "用户名" },
+ * //  { key: "email", msg: "邮箱格式不正确", name: "邮箱" }
+ * //]
+ */
+export declare const libJsRegFormValidate: (form: Record<string, any>, rules: Array<{
+    key: string;
+    verify: RegExp | ((value: any) => boolean);
+    msg: string;
+    name: string;
+}>) => ValidationResult[];

package/dist/Misc/LibJsRegFormValidate/index.js

@@ -0,0 +1,34 @@
+/**
+ * @description 通过传递对象数字的方式进行正则或自定义函数进行验证
+ * @param form 表单数据对象
+ * @param rules 验证规则数组
+ * @returns 验证结果数组，包含未通过验证的项
+ * @example
+ * const form = { username: "john", email: "john@example.com" };
+ * const rules = [
+ *   { key: "username", verify: /^[a-zA-Z0-9]{3,}$/, msg: "用户名不合法", name: "用户名" },
+ *   { key: "email", verify: /^\S+@\S+\.\S+$/, msg: "邮箱格式不正确", name: "邮箱" },
+ * ];
+ * libJsRegFormValidate(form, rules);
+ * //返回结果: []
+ *
+ * const invalidForm = { username: "jo", email: "invalid-email" };
+ * libJsRegFormValidate(invalidForm, rules);
+ * //返回结果: [
+ * //  { key: "username", msg: "用户名不合法", name: "用户名" },
+ * //  { key: "email", msg: "邮箱格式不正确", name: "邮箱" }
+ * //]
+ */
+export const libJsRegFormValidate = (form, rules) => {
+    return rules.reduce((result, rule) => {
+        const { key, verify, msg, name } = rule;
+        const value = form[key];
+        if (value === "" || value === undefined || value === null) {
+            result.push({ key, msg: "必填项", name });
+        }
+        else if (typeof verify === "function" ? !verify(value) : !verify.test(value)) {
+            result.push({ key, msg, name });
+        }
+        return result;
+    }, []);
+};

package/dist/Misc/LibJsRetryRequest/index.d.ts

@@ -0,0 +1,24 @@
+/** @description 请求失败重连
+ * @param promiseFn 请求函数
+ * @param maxRetries 最大重试次数
+ * @param retryDelay 重试间隔时间
+ * @param params 请求参数
+ * @example
+ * const requestFn = (params: { url: string }) => fetch(params.url).then(res => res.json());
+ * const params = { url: "https://api.example.com/data" };
+ * libJsRetryRequest({
+ *   promiseFn: requestFn,
+ *   params,
+ *   maxRetries: 5,
+ *   retryDelay: 1000
+ * })
+ * .then(data => console.log(data))
+ * .catch(err => console.error(err));
+ */
+export declare const libJsRetryRequest: <T>({ promiseFn, maxRetries, retryDelay, params, }: {
+    promiseFn: (params?: any) => Promise<T>;
+    params?: any;
+    maxRetries?: number;
+    retryDelay?: number;
+    onRetry?: () => void;
+}) => Promise<T>;

package/dist/Misc/LibJsRetryRequest/index.js

@@ -0,0 +1,37 @@
+/** @description 请求失败重连
+ * @param promiseFn 请求函数
+ * @param maxRetries 最大重试次数
+ * @param retryDelay 重试间隔时间
+ * @param params 请求参数
+ * @example
+ * const requestFn = (params: { url: string }) => fetch(params.url).then(res => res.json());
+ * const params = { url: "https://api.example.com/data" };
+ * libJsRetryRequest({
+ *   promiseFn: requestFn,
+ *   params,
+ *   maxRetries: 5,
+ *   retryDelay: 1000
+ * })
+ * .then(data => console.log(data))
+ * .catch(err => console.error(err));
+ */
+export const libJsRetryRequest = ({ promiseFn, maxRetries = 3, retryDelay = 2000, params = undefined, }) => {
+    return new Promise((resolve, reject) => {
+        let count = 0;
+        const makeRequest = () => {
+            promiseFn(params)
+                .then((res) => {
+                resolve(res);
+            })
+                .catch((err) => {
+                count++;
+                if (count >= maxRetries) {
+                    reject(err);
+                    return;
+                }
+                setTimeout(makeRequest, retryDelay);
+            });
+        };
+        makeRequest();
+    });
+};

package/dist/Random/LibJsProbabilityResult/index.d.ts

@@ -0,0 +1,8 @@
+/** @description 百分比概率结果
+ * @param probability 触发概率，百分比，0-100
+ * @example
+ * libJsProbabilityResult(50); //50% 概率为 true
+ * libJsProbabilityResult(80); //80% 概率为 true
+ * libJsProbabilityResult(100); //100% 概率为 true
+ */
+export declare const libJsProbabilityResult: (probability: number) => boolean;

package/dist/Random/LibJsProbabilityResult/index.js

@@ -0,0 +1,8 @@
+/** @description 百分比概率结果
+ * @param probability 触发概率，百分比，0-100
+ * @example
+ * libJsProbabilityResult(50); //50% 概率为 true
+ * libJsProbabilityResult(80); //80% 概率为 true
+ * libJsProbabilityResult(100); //100% 概率为 true
+ */
+export const libJsProbabilityResult = (probability) => Math.random() * 100 < probability;

package/dist/Random/LibJsRandom/index.d.ts

@@ -0,0 +1,9 @@
+/** @description 随机获取两个数之间的值，包含两数自身
+ * @param min 最小值
+ * @param max 最大值
+ * @param num 保留小数位数
+  * @example
+ * libJsRandom(1, 10); //1 到 10 之间的随机整数
+ * libJsRandom(1, 10, 2); //1 到 10 之间保留两位小数的随机数
+ */
+export declare const libJsRandom: (min: number, max: number, num?: number) => number;

package/dist/Random/LibJsRandom/index.js

@@ -0,0 +1,11 @@
+/** @description 随机获取两个数之间的值，包含两数自身
+ * @param min 最小值
+ * @param max 最大值
+ * @param num 保留小数位数
+  * @example
+ * libJsRandom(1, 10); //1 到 10 之间的随机整数
+ * libJsRandom(1, 10, 2); //1 到 10 之间保留两位小数的随机数
+ */
+export const libJsRandom = (min, max, num = 0) => {
+    return parseFloat((Math.random() * (max - min) + min).toFixed(num));
+};

package/dist/Random/LibJsRandomColor/index.d.ts

@@ -0,0 +1,7 @@
+/** @description 随机 RGBA 颜色
+ * @param alpha 透明度
+ * @example
+ * libJsRandomColor(); //生成随机的 RGBA 颜色，默认透明度 1
+ * libJsRandomColor(0.5); //生成随机的 RGBA 颜色，透明度为 0.5
+ */
+export declare const libJsRandomColor: (alpha?: number) => string;

package/dist/Random/LibJsRandomColor/index.js

@@ -0,0 +1,12 @@
+/** @description 随机 RGBA 颜色
+ * @param alpha 透明度
+ * @example
+ * libJsRandomColor(); //生成随机的 RGBA 颜色，默认透明度 1
+ * libJsRandomColor(0.5); //生成随机的 RGBA 颜色，透明度为 0.5
+ */
+export const libJsRandomColor = (alpha = 1) => {
+    const r = Math.floor(Math.random() * 256);
+    const g = Math.floor(Math.random() * 256);
+    const b = Math.floor(Math.random() * 256);
+    return `rgba(${r}, ${g}, ${b}, ${alpha})`;
+};

package/dist/Random/LibJsUniqueRandomNumbers/index.d.ts

@@ -0,0 +1,9 @@
+/** @description 随机生成指定个数、指定范围不重复的随机数数组
+ * @param min 最小值
+ * @param max 最大值
+ * @param count 数组长度
+ * @example
+ * libJsUniqueRandomNumbers(1, 10, 5); //从 1 到 10 中随机生成 5 个唯一数字
+ * libJsUniqueRandomNumbers(1, 100, 10); //从 1 到 100 中随机生成 10 个唯一数字
+ */
+export declare const libJsUniqueRandomNumbers: (min: number, max: number, count: number) => number[];

package/dist/Random/LibJsUniqueRandomNumbers/index.js

@@ -0,0 +1,16 @@
+/** @description 随机生成指定个数、指定范围不重复的随机数数组
+ * @param min 最小值
+ * @param max 最大值
+ * @param count 数组长度
+ * @example
+ * libJsUniqueRandomNumbers(1, 10, 5); //从 1 到 10 中随机生成 5 个唯一数字
+ * libJsUniqueRandomNumbers(1, 100, 10); //从 1 到 100 中随机生成 10 个唯一数字
+ */
+export const libJsUniqueRandomNumbers = (min, max, count) => {
+    const numbers = Array.from({ length: max - min + 1 }, (_, i) => i + min);
+    for (let i = numbers.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [numbers[i], numbers[j]] = [numbers[j], numbers[i]];
+    }
+    return numbers.slice(0, count);
+};

package/dist/Time/LibJsSameTimeCheck/index.d.ts

@@ -0,0 +1,12 @@
+import dayjs from "dayjs";
+/**
+ * @description 传入时间戳与当前时间判断是否为同一分、同一时、同一天、同一周、同一月、同一年
+ * @param timestamp 毫秒时间戳
+ * @param unit 判断单位
+ * @returns 0-同一单位时间 1-新单位时间 -1时间戳大于当前时间
+ * @example
+ * const timestamp = 1679872800000; //时间戳
+ * const result = libSameTimeCheck(timestamp, 'day'); //判断是否为同一天
+ * console.log(result); //0: 同一天, 1: 新的一天, -1: 时间戳大于当前时间
+ */
+export declare const libJsSameTimeCheck: (timestamp: number, unit: dayjs.OpUnitType) => 0 | 1 | -1;

package/dist/Time/LibJsSameTimeCheck/index.js

@@ -0,0 +1,24 @@
+import dayjs from "dayjs";
+/**
+ * @description 传入时间戳与当前时间判断是否为同一分、同一时、同一天、同一周、同一月、同一年
+ * @param timestamp 毫秒时间戳
+ * @param unit 判断单位
+ * @returns 0-同一单位时间 1-新单位时间 -1时间戳大于当前时间
+ * @example
+ * const timestamp = 1679872800000; //时间戳
+ * const result = libSameTimeCheck(timestamp, 'day'); //判断是否为同一天
+ * console.log(result); //0: 同一天, 1: 新的一天, -1: 时间戳大于当前时间
+ */
+export const libJsSameTimeCheck = (timestamp, unit) => {
+    const inputTime = dayjs(timestamp).startOf(unit);
+    const currentTime = dayjs().startOf(unit);
+    if (inputTime.isSame(currentTime)) {
+        return 0;
+    }
+    else if (inputTime.isBefore(currentTime)) {
+        return 1;
+    }
+    else {
+        return -1;
+    }
+};