js_ryl_v3 1.0.0

package/dist/esm/function/index.js

@@ -0,0 +1,23 @@
+const fun = {
+    throole(fn, delay = 500) {
+        let lastTime = 0;
+        return function (...args) {
+            const nowTime = Date.now();
+            if (nowTime - lastTime > delay) {
+                fn.apply(this, args);
+                lastTime = nowTime;
+            }
+        };
+    },
+    debounce(fn, delay = 500) {
+        let timer = null;
+        return function (...args) {
+            if (timer)
+                clearTimeout(timer);
+            timer = setTimeout(() => {
+                fn.apply(this, args);
+            }, delay);
+        };
+    }
+};
+export default fun;

package/dist/esm/getMonthDays/index.d.ts

@@ -0,0 +1 @@
+export default function getMonthDays(year: number, month: number): number;

package/dist/esm/getMonthDays/index.js

@@ -0,0 +1,4 @@
+export default function getMonthDays(year, month) {
+    const thisDate = new Date(year, month, 0);
+    return thisDate.getDate();
+}

package/dist/esm/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/esm/getParamsUtil/index.js

@@ -0,0 +1,85 @@
+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;
+    }
+};
+export default getParamsUtil;

package/dist/esm/highLight/index.d.ts

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

package/dist/esm/highLight/index.js

@@ -0,0 +1,7 @@
+export default 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/esm/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/esm/index.js

@@ -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/esm/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/esm/number/index.js

@@ -0,0 +1,160 @@
+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);
+    }
+};
+export default num;

package/dist/esm/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/esm/reg/index.js

@@ -0,0 +1,35 @@
+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);
+    }
+};
+export default reg;

package/dist/esm/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/esm/time/index.js

@@ -0,0 +1,78 @@
+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);
+            }
+        }
+    }
+};
+export default time;

package/dist/esm/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/esm/verCode/index.js

@@ -0,0 +1,37 @@
+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
+};
+export default verCode;

package/dist/filterTable/index.d.ts

@@ -0,0 +1,5 @@
+interface TableData {
+    [key: string]: any;
+}
+export default function filterTable(data: TableData[], params?: string, more?: (string | undefined | null)[]): TableData[];
+export {};

package/dist/filterTable/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = filterTable;
+const defaultTypes = ['', undefined, null];
+function filterType(val, types) {
+    return types.some(v => v === val);
+}
+function filterTable(data, params = '--', more) {
+    const types = more && more.length ? [...defaultTypes, ...more] : defaultTypes;
+    const newArr = [];
+    for (const key in data) {
+        const obj = {};
+        const re = Object.entries(data[key]);
+        for (let i = 0; i < re.length; i++) {
+            const d = re[i];
+            if (filterType(d[1], types)) {
+                d[1] = params;
+            }
+            obj[d[0]] = d[1];
+        }
+        newArr.push(obj);
+    }
+    return newArr;
+}

package/dist/flyToCart/index.d.ts

@@ -0,0 +1,5 @@
+interface FlyToCartCallback {
+    (): void;
+}
+export default function flyToCart(event: MouseEvent, image: string, targets: HTMLElement, callback?: FlyToCartCallback): void;
+export {};

package/dist/flyToCart/index.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = flyToCart;
+function flyToCart(event, image, targets, callback = () => { }) {
+    const button = event.target;
+    const flyEl = document.createElement('img');
+    flyEl.style.cssText = `position: fixed;
+    width: 20px;
+    height: 20px;
+    border-radius: 50%;
+    pointer-events: none;
+    transition: transform 0.8s cubic-bezier(0.4, 0, 0.2, 1), opacity 0.8s;
+    z-index: 10000;
+    opacity: 1;
+    transform-origin: center center;`;
+    flyEl.setAttribute('src', image);
+    document.body.appendChild(flyEl);
+    const startRect = button.getBoundingClientRect();
+    const startX = startRect.left + startRect.width / 2;
+    const startY = startRect.top + startRect.height / 2;
+    const cartRect = targets.getBoundingClientRect();
+    const endX = cartRect.left + cartRect.width / 2;
+    const endY = cartRect.top + cartRect.height / 2;
+    const controlX = (startX + endX) / 2;
+    const controlY = Math.min(startY, endY) - 150;
+    flyEl.style.left = startX + 'px';
+    flyEl.style.top = startY + 'px';
+    let t = 0;
+    const duration = 800;
+    const startTime = performance.now();
+    const animate = (time) => {
+        t = (time - startTime) / duration;
+        if (t > 1)
+            t = 1;
+        const x = (1 - t) * (1 - t) * startX + 2 * (1 - t) * t * controlX + t * t * endX;
+        const y = (1 - t) * (1 - t) * startY + 2 * (1 - t) * t * controlY + t * t * endY;
+        flyEl.style.left = x + 'px';
+        flyEl.style.top = y + 'px';
+        flyEl.style.transform = `scale(${1 - t * 0.7})`;
+        flyEl.style.opacity = `${1 - t}`;
+        if (t < 1) {
+            requestAnimationFrame(animate);
+        }
+        else {
+            flyEl.remove();
+            callback();
+        }
+    };
+    requestAnimationFrame(animate);
+}

package/dist/function/index.d.ts

@@ -0,0 +1,11 @@
+interface ThrottleFunction<T extends (...args: any[]) => any> {
+    (...args: Parameters<T>): void;
+}
+interface DebounceFunction<T extends (...args: any[]) => any> {
+    (...args: Parameters<T>): void;
+}
+declare const fun: {
+    throole<T extends (...args: any[]) => any>(fn: T, delay?: number): ThrottleFunction<T>;
+    debounce<T extends (...args: any[]) => any>(fn: T, delay?: number): DebounceFunction<T>;
+};
+export default fun;

package/dist/function/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fun = {
+    throole(fn, delay = 500) {
+        let lastTime = 0;
+        return function (...args) {
+            const nowTime = Date.now();
+            if (nowTime - lastTime > delay) {
+                fn.apply(this, args);
+                lastTime = nowTime;
+            }
+        };
+    },
+    debounce(fn, delay = 500) {
+        let timer = null;
+        return function (...args) {
+            if (timer)
+                clearTimeout(timer);
+            timer = setTimeout(() => {
+                fn.apply(this, args);
+            }, delay);
+        };
+    }
+};
+exports.default = fun;

package/dist/getMonthDays/index.d.ts

@@ -0,0 +1 @@
+export default function getMonthDays(year: number, month: number): number;

package/dist/getMonthDays/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getMonthDays;
+function getMonthDays(year, month) {
+    const thisDate = new Date(year, month, 0);
+    return thisDate.getDate();
+}