js_ryl_v3 1.0.0

package/dist/getParamsUtil/index.d.ts

@@ -0,0 +1,12 @@
+type ParamType = 'string' | 'number' | 'boolean' | 'object';
+interface ParamsObject {
+    [key: string]: string | string[];
+}
+declare const getParamsUtil: {
+    getParam<T = any>(name: string, url?: string, defaultValue?: T, type?: ParamType): T;
+    getParams(url?: string): ParamsObject;
+    buildQueryString(params: Record<string, any>): string;
+    joinParams(url: string, params: Record<string, any>): string;
+    removeParams(url: string, keys: string | string[]): string;
+};
+export default getParamsUtil;

package/dist/getParamsUtil/index.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const getParamsUtil = {
+    getParam(name, url, defaultValue, type) {
+        const params = this.getParams(url);
+        let value = params[name];
+        if (value === undefined) {
+            return defaultValue;
+        }
+        if (type === 'number') {
+            return Number(value);
+        }
+        else if (type === 'boolean') {
+            return (value === 'true' || value === '1');
+        }
+        else if (type === 'object') {
+            try {
+                return JSON.parse(String(value));
+            }
+            catch (e) {
+                return defaultValue;
+            }
+        }
+        return value;
+    },
+    getParams(url = window.location.href) {
+        const params = {};
+        const search = url.split('?')[1];
+        if (!search) {
+            return params;
+        }
+        const pairs = search.split('&');
+        pairs.forEach(pair => {
+            const [key, value] = pair.split('=');
+            if (key) {
+                const decodedKey = decodeURIComponent(key);
+                const decodedValue = value ? decodeURIComponent(value) : '';
+                if (params[decodedKey]) {
+                    if (Array.isArray(params[decodedKey])) {
+                        params[decodedKey].push(decodedValue);
+                    }
+                    else {
+                        params[decodedKey] = [params[decodedKey], decodedValue];
+                    }
+                }
+                else {
+                    params[decodedKey] = decodedValue;
+                }
+            }
+        });
+        return params;
+    },
+    buildQueryString(params) {
+        const query = [];
+        Object.entries(params).forEach(([key, value]) => {
+            if (value !== undefined && value !== null) {
+                if (Array.isArray(value)) {
+                    value.forEach(item => {
+                        query.push(`${encodeURIComponent(key)}=${encodeURIComponent(item)}`);
+                    });
+                }
+                else {
+                    query.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
+                }
+            }
+        });
+        return query.join('&');
+    },
+    joinParams(url, params) {
+        const [baseUrl] = url.split('?');
+        const existingParams = this.getParams(url);
+        const mergedParams = Object.assign(Object.assign({}, existingParams), params);
+        const queryString = this.buildQueryString(mergedParams);
+        return queryString ? `${baseUrl}?${queryString}` : baseUrl;
+    },
+    removeParams(url, keys) {
+        const [baseUrl] = url.split('?');
+        const params = this.getParams(url);
+        const keysArray = Array.isArray(keys) ? keys : [keys];
+        keysArray.forEach(key => {
+            delete params[key];
+        });
+        const queryString = this.buildQueryString(params);
+        return queryString ? `${baseUrl}?${queryString}` : baseUrl;
+    }
+};
+exports.default = getParamsUtil;

package/dist/highLight/index.d.ts

@@ -0,0 +1 @@
+export default function highlight(searchName: string, backText: string, className: string): string;

package/dist/highLight/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = highlight;
+function highlight(searchName, backText, className) {
+    if (!searchName)
+        return backText;
+    const escapedKeyword = searchName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const regex = new RegExp(`(${escapedKeyword})`, 'gi');
+    return backText.replace(regex, `<span class="${className}">$1</span>`);
+}

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+export { default as base64Img } from './base64Img';
+export { default as cookie } from './cookie';
+export { default as copy } from './copy';
+export { default as deepCopy } from './deepCopy';
+export { default as downExcel } from './downExcel';
+export { default as emoji } from './emoji';
+export { default as emojiToUnicode } from './emojiToUnicode';
+export { default as filterTable } from './filterTable';
+export { default as flyToCart } from './flyToCart';
+export { default as fun } from './function';
+export { default as getMonthDays } from './getMonthDays';
+export { default as getParamsUtil } from './getParamsUtil';
+export { default as highlight } from './highLight';
+export { default as num } from './number';
+export { default as reg } from './reg';
+export { default as time } from './time';
+export { default as verCode } from './verCode';

package/dist/index.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verCode = exports.time = exports.reg = exports.num = exports.highlight = exports.getParamsUtil = exports.getMonthDays = exports.fun = exports.flyToCart = exports.filterTable = exports.emojiToUnicode = exports.emoji = exports.downExcel = exports.deepCopy = exports.copy = exports.cookie = exports.base64Img = void 0;
+var base64Img_1 = require("./base64Img");
+Object.defineProperty(exports, "base64Img", { enumerable: true, get: function () { return __importDefault(base64Img_1).default; } });
+var cookie_1 = require("./cookie");
+Object.defineProperty(exports, "cookie", { enumerable: true, get: function () { return __importDefault(cookie_1).default; } });
+var copy_1 = require("./copy");
+Object.defineProperty(exports, "copy", { enumerable: true, get: function () { return __importDefault(copy_1).default; } });
+var deepCopy_1 = require("./deepCopy");
+Object.defineProperty(exports, "deepCopy", { enumerable: true, get: function () { return __importDefault(deepCopy_1).default; } });
+var downExcel_1 = require("./downExcel");
+Object.defineProperty(exports, "downExcel", { enumerable: true, get: function () { return __importDefault(downExcel_1).default; } });
+var emoji_1 = require("./emoji");
+Object.defineProperty(exports, "emoji", { enumerable: true, get: function () { return __importDefault(emoji_1).default; } });
+var emojiToUnicode_1 = require("./emojiToUnicode");
+Object.defineProperty(exports, "emojiToUnicode", { enumerable: true, get: function () { return __importDefault(emojiToUnicode_1).default; } });
+var filterTable_1 = require("./filterTable");
+Object.defineProperty(exports, "filterTable", { enumerable: true, get: function () { return __importDefault(filterTable_1).default; } });
+var flyToCart_1 = require("./flyToCart");
+Object.defineProperty(exports, "flyToCart", { enumerable: true, get: function () { return __importDefault(flyToCart_1).default; } });
+var function_1 = require("./function");
+Object.defineProperty(exports, "fun", { enumerable: true, get: function () { return __importDefault(function_1).default; } });
+var getMonthDays_1 = require("./getMonthDays");
+Object.defineProperty(exports, "getMonthDays", { enumerable: true, get: function () { return __importDefault(getMonthDays_1).default; } });
+var getParamsUtil_1 = require("./getParamsUtil");
+Object.defineProperty(exports, "getParamsUtil", { enumerable: true, get: function () { return __importDefault(getParamsUtil_1).default; } });
+var highLight_1 = require("./highLight");
+Object.defineProperty(exports, "highlight", { enumerable: true, get: function () { return __importDefault(highLight_1).default; } });
+var number_1 = require("./number");
+Object.defineProperty(exports, "num", { enumerable: true, get: function () { return __importDefault(number_1).default; } });
+var reg_1 = require("./reg");
+Object.defineProperty(exports, "reg", { enumerable: true, get: function () { return __importDefault(reg_1).default; } });
+var time_1 = require("./time");
+Object.defineProperty(exports, "time", { enumerable: true, get: function () { return __importDefault(time_1).default; } });
+var verCode_1 = require("./verCode");
+Object.defineProperty(exports, "verCode", { enumerable: true, get: function () { return __importDefault(verCode_1).default; } });

package/dist/number/index.d.ts

@@ -0,0 +1,8 @@
+declare const num: {
+    NumFilter(v: number): number;
+    add(num1: number | string, num2: number | string): number;
+    sub(num1: number | string, num2: number | string): number;
+    div(num1: number | string, num2: number | string): number;
+    mul(num1: number | string, num2: number | string): number;
+};
+export default num;

package/dist/number/index.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function countDecimals(num) {
+    let len = 0;
+    try {
+        num = Number(num);
+        const str = num.toString().toUpperCase();
+        if (str.split('E').length === 2) {
+            let isDecimal = false;
+            if (str.split('.').length === 2) {
+                str.split('.')[1];
+                if (parseInt(str.split('E')[0]) !== 0) {
+                    isDecimal = true;
+                }
+            }
+            const x = str.split('E');
+            if (isDecimal) {
+                len = x[0].length;
+            }
+            len -= parseInt(x[1]);
+        }
+        else if (str.split('.').length === 2) {
+            if (parseInt(str.split('.')[1]) !== 0) {
+                len = str.split('.')[1].length;
+            }
+        }
+    }
+    catch (e) {
+        throw e;
+    }
+    finally {
+        if (isNaN(len) || len < 0) {
+            len = 0;
+        }
+        return len;
+    }
+}
+function convertToInt(num) {
+    num = Number(num);
+    let newNum = num;
+    const times = countDecimals(num);
+    const temp_num = num.toString().toUpperCase();
+    if (temp_num.split('E').length === 2) {
+        newNum = Math.round(num * Math.pow(10, times));
+    }
+    else {
+        newNum = Number(temp_num.replace(".", ""));
+    }
+    return newNum;
+}
+function getCorrectResult(type, num1, num2, result) {
+    let temp_result = 0;
+    switch (type) {
+        case "add":
+            temp_result = num1 + num2;
+            break;
+        case "sub":
+            temp_result = num1 - num2;
+            break;
+        case "div":
+            temp_result = num1 / num2;
+            break;
+        case "mul":
+            temp_result = num1 * num2;
+            break;
+    }
+    if (Math.abs(result - temp_result) > 1) {
+        return temp_result;
+    }
+    if (!isLessThanTwoDecimalPlaces(result)) {
+        result = Number(result.toFixed(2));
+    }
+    return result;
+}
+function isLessThanTwoDecimalPlaces(num) {
+    return Math.floor(num * 100) === num * 100;
+}
+const num = {
+    NumFilter(v) {
+        const x = String(v).indexOf(".") + 1;
+        const y = String(v).length - x;
+        if (y > 0 && y >= 3) {
+            v = Math.floor(v * 100) / 100;
+        }
+        return v;
+    },
+    add(num1, num2) {
+        const n1 = this.NumFilter(Number(num1));
+        const n2 = this.NumFilter(Number(num2));
+        let dec1 = 0, dec2 = 0, times;
+        try {
+            dec1 = countDecimals(n1) + 1;
+        }
+        catch (e) {
+            dec1 = 0;
+        }
+        try {
+            dec2 = countDecimals(n2) + 1;
+        }
+        catch (e) {
+            dec2 = 0;
+        }
+        times = Math.pow(10, Math.max(dec1, dec2));
+        const result = (this.mul(n1, times) + this.mul(n2, times)) / times;
+        return getCorrectResult("add", n1, n2, result);
+    },
+    sub(num1, num2) {
+        const n1 = this.NumFilter(Number(num1));
+        const n2 = this.NumFilter(Number(num2));
+        let dec1 = 0, dec2 = 0, times;
+        try {
+            dec1 = countDecimals(n1) + 1;
+        }
+        catch (e) {
+            dec1 = 0;
+        }
+        try {
+            dec2 = countDecimals(n2) + 1;
+        }
+        catch (e) {
+            dec2 = 0;
+        }
+        times = Math.pow(10, Math.max(dec1, dec2));
+        const result = Number((this.mul(n1, times) - this.mul(n2, times)) / times);
+        return getCorrectResult("sub", n1, n2, result);
+    },
+    div(num1, num2) {
+        const n1 = Number(num1);
+        const n2 = Number(num2);
+        let t1 = 0, t2 = 0, dec1, dec2;
+        try {
+            t1 = countDecimals(n1);
+        }
+        catch (e) { }
+        try {
+            t2 = countDecimals(n2);
+        }
+        catch (e) { }
+        dec1 = convertToInt(n1);
+        dec2 = convertToInt(n2);
+        const result = this.mul((dec1 / dec2), Math.pow(10, t2 - t1));
+        return getCorrectResult("div", n1, n2, result);
+    },
+    mul(num1, num2) {
+        const n1 = Number(num1);
+        const n2 = Number(num2);
+        let times = 0;
+        const s1 = n1.toString();
+        const s2 = n2.toString();
+        try {
+            times += countDecimals(n1);
+        }
+        catch (e) { }
+        try {
+            times += countDecimals(n2);
+        }
+        catch (e) { }
+        const result = convertToInt(n1) * convertToInt(n2) / Math.pow(10, times);
+        return getCorrectResult("mul", n1, n2, result);
+    }
+};
+exports.default = num;

package/dist/reg/index.d.ts

@@ -0,0 +1,11 @@
+declare const reg: {
+    Phone(value: string): boolean;
+    Email(value: string): boolean;
+    IdCard(value: string): boolean;
+    Common(value: string): boolean;
+    QQ(value: string): boolean;
+    Money(value: string): boolean;
+    imgUrl(value: string): boolean;
+    verChinese(value: string): boolean;
+};
+export default reg;

package/dist/reg/index.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const reg = {
+    Phone(value) {
+        const regex = /^[1][3,4,5,6,7,8,9][0-9]{9}$/;
+        return regex.test(value);
+    },
+    Email(value) {
+        const regex = /^([0-9A-Za-z\-_\.]+)@([0-9a-z]+\.[a-z]{2,3}(\.[a-z]{2})?)$/g;
+        return regex.test(value);
+    },
+    IdCard(value) {
+        const regex = /(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/;
+        return regex.test(value);
+    },
+    Common(value) {
+        const regex = /^[a-zA-Z0-9_]+$/;
+        return regex.test(value);
+    },
+    QQ(value) {
+        const regex = /^[1-9][0-9]{4,10}$/gim;
+        return regex.test(value);
+    },
+    Money(value) {
+        const regex = /(^[1-9]([0-9]+)?(\.[0-9]{1,2})?$)|(^(0){1}$)|(^[0-9]\.[0-9]([0-9])?$)/;
+        return regex.test(value);
+    },
+    imgUrl(value) {
+        const regex = /^\s*data:([a-z]+\/[a-z0-9-+.]+(;[a-z-]+=[a-z0-9-]+)?)?(;base64)?,([a-z0-9!$&',()*+;=\-._~:@\/?%\s]*?)\s*$/i;
+        return regex.test(value);
+    },
+    verChinese(value) {
+        const regex = /[\u4e00-\u9fa5]/;
+        return regex.test(value);
+    }
+};
+exports.default = reg;

package/dist/time/index.d.ts

@@ -0,0 +1,8 @@
+type DateFormatType = 'yyyy-MM-dd' | 'yyyy-MM-dd HH:mm' | 'yyyy-MM-dd HH:mm:ss';
+declare const time: {
+    toDate(v: number | string, type?: DateFormatType): string;
+    toStamp(v?: Date | string, len?: number): number;
+    getNow(): string;
+    timestampFormat(timestamp: number | string): string;
+};
+export default time;

package/dist/time/index.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function add0(m) {
+    return m < 10 ? '0' + m : String(m);
+}
+const time = {
+    toDate(v, type) {
+        let date;
+        if (String(v).length === 10) {
+            date = new Date(Number(v) * 1000);
+        }
+        else {
+            date = new Date(v);
+        }
+        const Y = date.getFullYear();
+        const M = date.getMonth() + 1;
+        const D = date.getDate();
+        const h = date.getHours();
+        const m = date.getMinutes();
+        const s = date.getSeconds();
+        let tim = '';
+        if (type === 'yyyy-MM-dd') {
+            tim = `${Y}-${add0(M)}-${add0(D)}`;
+        }
+        else if (type === 'yyyy-MM-dd HH:mm') {
+            tim = `${Y}-${add0(M)}-${add0(D)} ${add0(h)}:${add0(m)}`;
+        }
+        else {
+            tim = `${Y}-${add0(M)}-${add0(D)} ${add0(h)}:${add0(m)}:${add0(s)}`;
+        }
+        return tim;
+    },
+    toStamp(v = new Date(), len = 10) {
+        const tmp = new Date(String(v).replace(/-/g, '/')).getTime().toString();
+        if (len === 10) {
+            return parseInt(tmp.substr(0, 10));
+        }
+        return parseInt(tmp);
+    },
+    getNow() {
+        const ts = new Date().getTime();
+        return this.toDate(ts);
+    },
+    timestampFormat(timestamp) {
+        if (String(timestamp).length === 10) {
+            timestamp = Number(timestamp) * 1000;
+        }
+        function zeroize(num) {
+            return (String(num).length === 1 ? "0" : "") + num;
+        }
+        const curTimestamp = parseInt(String(new Date().getTime() / 1000));
+        const curDate = new Date(curTimestamp * 1000);
+        const tmDate = new Date(Number(timestamp));
+        const Y = tmDate.getFullYear();
+        const m = tmDate.getMonth() + 1;
+        const d = tmDate.getDate();
+        const H = tmDate.getHours();
+        const i = tmDate.getMinutes();
+        if (curDate.getFullYear() === Y &&
+            curDate.getMonth() + 1 === m &&
+            curDate.getDate() === d) {
+            return zeroize(H) + ":" + zeroize(i);
+        }
+        else {
+            const newDate = new Date((curTimestamp - 86400) * 1000);
+            if (newDate.getFullYear() === Y &&
+                newDate.getMonth() + 1 === m &&
+                newDate.getDate() === d) {
+                return "昨天 " + zeroize(H) + ":" + zeroize(i);
+            }
+            else if (curDate.getFullYear() === Y) {
+                return zeroize(m) + "/" + zeroize(d) + " " + zeroize(H) + ":" + zeroize(i);
+            }
+            else {
+                return Y + "/" + zeroize(m) + "/" + zeroize(d) + " " + zeroize(H) + ":" + zeroize(i);
+            }
+        }
+    }
+};
+exports.default = time;

package/dist/verCode/index.d.ts

@@ -0,0 +1,6 @@
+declare const verCode: {
+    PhoneCode(e: MouseEvent, ss?: number, cc?: string): void;
+    PhoneCodeClear(): void;
+    phoneCodeStatus: () => boolean;
+};
+export default verCode;

package/dist/verCode/index.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+let phoneCodeStatus = false;
+let phoneCodeTimer = null;
+let phoneCodeName = '';
+let phoneCodeSelf = null;
+const verCode = {
+    PhoneCode(e, ss = 60, cc = '后重新获取') {
+        phoneCodeName = e.target.innerText;
+        phoneCodeSelf = e;
+        if (!phoneCodeStatus) {
+            phoneCodeStatus = true;
+            e.target.innerText = `${ss - 1}s${cc}`;
+            let timer = ss - 1;
+            phoneCodeTimer = setInterval(() => {
+                timer--;
+                if (timer <= 0) {
+                    e.target.innerText = phoneCodeName;
+                    this.PhoneCodeClear();
+                }
+                else {
+                    e.target.innerText = `${timer}s${cc}`;
+                }
+            }, 1000);
+        }
+    },
+    PhoneCodeClear() {
+        phoneCodeStatus = false;
+        if (phoneCodeSelf) {
+            phoneCodeSelf.target.innerText = phoneCodeName;
+        }
+        if (phoneCodeTimer) {
+            clearInterval(phoneCodeTimer);
+            phoneCodeTimer = null;
+        }
+    },
+    phoneCodeStatus: () => phoneCodeStatus
+};
+exports.default = verCode;

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "js_ryl_v3",
+  "version": "1.0.0",
+  "description": "常用JavaScript工具函数集合，包含日期处理、数字运算、正则验证、Cookie操作等",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "module": "dist/esm/index.js",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc && npm run build:esm",
+    "build:esm": "tsc --module ES6 --outDir dist/esm",
+    "clean": "rd /s /q dist 2>nul || rm -rf dist",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "utils",
+    "javascript",
+    "typescript",
+    "tools",
+    "common"
+  ],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0",
+    "vite": "^8.1.0"
+  },
+  "dependencies": {
+    "xlsx": "^0.18.5"
+  }
+}

package/src/base64Img/index.ts

@@ -0,0 +1,66 @@
+interface Base64Replacement {
+  original: string;
+  base64: string;
+  url?: string;
+}
+
+interface Base64ImgCallback {
+  (original: string, error: string | Error): void;
+}
+
+export default function base64Img(
+  content: string,
+  apiUrl: string,
+  token: string,
+  data?: Record<string, any>,
+  callback: Base64ImgCallback = () => {}
+): Promise<string> {
+  const base64Regex = /<img [^>]*src=['"](data:image[^'"]+base64,[^'"]+)['"][^>]*>/gi;
+  let match: RegExpExecArray | null;
+  const replacements: Base64ImgCallback[] = [];
+
+  while ((match = base64Regex.exec(content)) !== null) {
+    replacements.push({
+      original: match[1],
+      base64: match[1]
+    } as any);
+  }
+
+  if (replacements.length > 0) {
+    const uploadPromises = replacements.map((replacement: any) => {
+      return fetch(apiUrl, {
+        method: "POST",
+        headers: {
+          "Authorization": "Bearer " + token,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ image: replacement.base64, ...data })
+      })
+        .then(res => res.json())
+        .then(result => {
+          if (result.code === 200) {
+            replacement.url = result.data.url;
+          } else {
+            callback(replacement.original, result.msg);
+          }
+          return replacement;
+        })
+        .catch(error => {
+          callback(replacement.original, error);
+          return replacement;
+        });
+    });
+
+    return Promise.all(uploadPromises)
+      .then(results => {
+        results.forEach((result: any) => {
+          if (result.url) {
+            content = content.replace(result.original, result.url);
+          }
+        });
+        return content;
+      });
+  }
+
+  return Promise.resolve(content);
+}