js_ryl_v3 1.0.0

package/src/cookie/index.ts

@@ -0,0 +1,47 @@
+interface CookieOptions {
+  path?: string;
+  domain?: string;
+  expires?: number | Date;
+}
+
+interface CookieSetOptions extends CookieOptions {
+  domain?: 'domain' | string;
+}
+
+const cookie = {
+  set: (key: string, val: string, ops?: CookieSetOptions): void => {
+    ops = ops || {};
+    let path = ops.path ? ";Path=" + ops.path : "";
+    let domain = '';
+    if (ops.domain && ops.domain === 'domain') {
+      const hostname = window.location.hostname;
+      const parts = hostname.split('.');
+      const set_domain = parts.slice(-2).join('.');
+      domain = ";domain=" + set_domain;
+    }
+    let expires = "";
+    if (ops.expires) {
+      const exp = String(ops.expires).length === 10 
+        ? new Date(Number(ops.expires) * 1000) 
+        : new Date(ops.expires);
+      expires = ";expires=" + exp.toUTCString();
+    }
+    document.cookie = `${key}=${encodeURIComponent(val)}${domain}${path}${expires}`;
+  },
+  get: (name: string): string | null => {
+    const value = `; ${document.cookie}`;
+    const parts = value.split(`; ${name}=`);
+    if (parts.length === 2) {
+      return decodeURIComponent(parts.pop()!.split(';').shift()!);
+    } else {
+      return null;
+    }
+  },
+  remove: (key: string, ops?: CookieOptions): void => {
+    ops = ops || {};
+    ops.expires = -1;
+    cookie.set(key, '', ops as CookieSetOptions);
+  }
+};
+
+export default cookie;

package/src/copy/index.ts

@@ -0,0 +1,23 @@
+interface CopyResult {
+  code: number;
+  msg: string;
+}
+
+interface CopyCallback {
+  (result: CopyResult): void;
+}
+
+export default function copy(content: string, callback: CopyCallback): void {
+  const newInput = document.createElement("input");
+  newInput.setAttribute("readonly", "readonly");
+  newInput.setAttribute("value", content);
+  document.body.appendChild(newInput);
+  if (document.execCommand("copy")) {
+    newInput.select();
+    document.execCommand("copy");
+    callback({ code: 200, msg: "复制成功" });
+  } else {
+    callback({ code: 100, msg: "当前浏览器不支持，请更换浏览器后重试" });
+  }
+  document.body.removeChild(newInput);
+}

package/src/deepCopy/index.ts

@@ -0,0 +1,26 @@
+export default function deepCopy<T extends Record<string, any>>(
+  obj: T = {} as T,
+  tar?: Record<string, any>
+): T {
+  const dest: Record<string, any> = obj || {};
+  if (!tar) return dest as T;
+
+  for (const key in tar) {
+    if (!tar.hasOwnProperty(key)) continue;
+
+    const val = tar[key];
+
+    if (val === null || val === undefined) {
+      dest[key] = val;
+    } else if (Array.isArray(val)) {
+      dest[key] = [];
+      deepCopy(dest[key], val);
+    } else if (typeof val === 'object') {
+      dest[key] = {};
+      deepCopy(dest[key], val);
+    } else {
+      dest[key] = val;
+    }
+  }
+  return dest as T;
+}

package/src/downExcel/index.ts

@@ -0,0 +1,16 @@
+import * as XLSX from 'xlsx';
+
+interface ExcelData {
+  [key: string]: any;
+}
+
+export default function downExcel(
+  data: ExcelData[],
+  fileName: string = '列表',
+  sheetName: string = 'Sheet1'
+): void {
+  const worksheet = XLSX.utils.json_to_sheet(data);
+  const workbook = XLSX.utils.book_new();
+  XLSX.utils.book_append_sheet(workbook, worksheet, sheetName);
+  XLSX.writeFile(workbook, fileName + '.xlsx');
+}

package/src/emoji/index.ts

@@ -0,0 +1,63 @@
+const emojiRanges: [number, number][] = [
+  [0x231A, 0x231B], [0x23E9, 0x23EC], [0x23F0, 0x23F0], [0x23F3, 0x23F3],
+  [0x25AA, 0x25AB], [0x25B6, 0x25B6], [0x25C0, 0x25C0], [0x25FB, 0x25FE],
+  [0x2600, 0x2604], [0x260E, 0x260E], [0x2611, 0x2611], [0x2614, 0x2615],
+  [0x2618, 0x2618], [0x261D, 0x261D], [0x2620, 0x2620], [0x2622, 0x2623],
+  [0x2626, 0x2626], [0x262A, 0x262A], [0x262E, 0x262F], [0x2638, 0x263A],
+  [0x2640, 0x2640], [0x2642, 0x2642], [0x2648, 0x2653], [0x265F, 0x2660],
+  [0x2663, 0x2663], [0x2665, 0x2666], [0x2668, 0x2668], [0x267B, 0x267B],
+  [0x267F, 0x267F], [0x2692, 0x2697], [0x2699, 0x2699], [0x269B, 0x269C],
+  [0x26A0, 0x26A1], [0x26AA, 0x26AB], [0x26B0, 0x26B1], [0x26BD, 0x26BE],
+  [0x26C4, 0x26C5], [0x26C8, 0x26C8], [0x26CE, 0x26CF], [0x26D1, 0x26D1],
+  [0x26D3, 0x26D4], [0x26E9, 0x26EA], [0x26F0, 0x26F5], [0x26F7, 0x26FA],
+  [0x26FD, 0x26FD], [0x2702, 0x2702], [0x2705, 0x2705], [0x2708, 0x270D],
+  [0x270F, 0x270F], [0x2712, 0x2712], [0x2714, 0x2714], [0x2716, 0x2716],
+  [0x271D, 0x271D], [0x2721, 0x2721], [0x2728, 0x2728], [0x2733, 0x2734],
+  [0x2744, 0x2744], [0x2747, 0x2747], [0x274C, 0x274C], [0x274E, 0x274E],
+  [0x2753, 0x2755], [0x2757, 0x2757], [0x2763, 0x2764], [0x2795, 0x2797],
+  [0x27A1, 0x27A1], [0x27B0, 0x27B0], [0x27BF, 0x27BF], [0x2934, 0x2935],
+  [0x2B05, 0x2B07], [0x2B1B, 0x2B1C], [0x2B50, 0x2B50], [0x2B55, 0x2B55],
+  [0x1F004, 0x1F004], [0x1F0CF, 0x1F0CF], [0x1F170, 0x1F171], [0x1F17E, 0x1F17F],
+  [0x1F18E, 0x1F18E], [0x1F191, 0x1F19A], [0x1F1E6, 0x1F1FF], [0x1F201, 0x1F202],
+  [0x1F21A, 0x1F21A], [0x1F22F, 0x1F22F], [0x1F232, 0x1F23A], [0x1F250, 0x1F251],
+  [0x1F300, 0x1F5FF], [0x1F600, 0x1F64F], [0x1F680, 0x1F6FF], [0x1F700, 0x1F77F],
+  [0x1F780, 0x1F7FF], [0x1F800, 0x1F8FF], [0x1F900, 0x1F9FF], [0x1FA00, 0x1FA6F],
+  [0x1FA70, 0x1FAFF], [0x1FB00, 0x1FBFF],
+];
+
+function isEmoji(codePoint: number): boolean {
+  return emojiRanges.some(([start, end]) => codePoint >= start && codePoint <= end);
+}
+
+function canDisplayChar(char: string): boolean {
+  return char !== '\uFFFD';
+}
+
+export default function emoji(str: string): string {
+  if (!str) return str;
+  const regex = /U\+([0-9A-Fa-f]{4,6})|\[u\+([0-9A-Fa-f]{4,6})\]|\\u\{([0-9A-Fa-f]{4,6})\}/g;
+  return str.replace(regex, (match, p1, p2, p3) => {
+    const hexStr = p1 || p2 || p3;
+    const codePoint = parseInt(hexStr, 16);
+
+    if (isNaN(codePoint) || codePoint < 0 || codePoint > 0x10FFFF) {
+      return match;
+    }
+
+    try {
+      const char = String.fromCodePoint(codePoint);
+
+      if (isEmoji(codePoint)) {
+        return char;
+      } else {
+        if (canDisplayChar(char)) {
+          return char;
+        } else {
+          return match;
+        }
+      }
+    } catch (e) {
+      return match;
+    }
+  });
+}

package/src/emojiToUnicode/index.ts

@@ -0,0 +1,9 @@
+export default function emojiToUnicode(msg: string): string {
+  const rex =
+    /[\u{1f300}-\u{1f5ff}\u{1f900}-\u{1f9ff}\u{1f600}-\u{1f64f}\u{1f680}-\u{1f6ff}\u{2600}-\u{26ff}\u{2700}-\u{27bf}\u{1f1e6}-\u{1f1ff}\u{1f191}-\u{1f251}\u{1f004}\u{1f0cf}\u{1f170}-\u{1f171}\u{1f17e}-\u{1f17f}\u{1f18e}\u{3030}\u{2b50}\u{2b55}\u{2934}-\u{2935}\u{2b05}-\u{2b07}\u{2b1b}-\u{2b1c}\u{3297}\u{3299}\u{303d}\u{00a9}\u{00ae}\u{2122}\u{23f3}\u{24c2}\u{23e9}-\u{23ef}\u{25b6}\u{23f8}-\u{23fa}]/gu;
+  const updated = msg.replace(
+    rex,
+    (match) => `[u+${match.codePointAt(0)!.toString(16)}]`
+  );
+  return updated;
+}

package/src/filterTable/index.ts

@@ -0,0 +1,33 @@
+interface TableData {
+  [key: string]: any;
+}
+
+const defaultTypes: (string | undefined | null)[] = ['', undefined, null];
+
+function filterType(val: any, types: (string | undefined | null)[]): boolean {
+  return types.some(v => v === val);
+}
+
+export default function filterTable(
+  data: TableData[],
+  params: string = '--',
+  more?: (string | undefined | null)[]
+): TableData[] {
+  const types = more && more.length ? [...defaultTypes, ...more] : defaultTypes;
+  const newArr: TableData[] = [];
+
+  for (const key in data) {
+    const obj: TableData = {};
+    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/src/flyToCart/index.ts

@@ -0,0 +1,67 @@
+interface FlyToCartCallback {
+  (): void;
+}
+
+export default function flyToCart(
+  event: MouseEvent,
+  image: string,
+  targets: HTMLElement,
+  callback: FlyToCartCallback = () => {}
+): void {
+  const button = event.target as HTMLElement;
+  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: number) => {
+    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/src/function/index.ts

@@ -0,0 +1,37 @@
+interface ThrottleFunction<T extends (...args: any[]) => any> {
+  (...args: Parameters<T>): void;
+}
+
+interface DebounceFunction<T extends (...args: any[]) => any> {
+  (...args: Parameters<T>): void;
+}
+
+const fun = {
+  throole<T extends (...args: any[]) => any>(
+    fn: T,
+    delay: number = 500
+  ): ThrottleFunction<T> {
+    let lastTime = 0;
+    return function (this: any, ...args: Parameters<T>) {
+      const nowTime = Date.now();
+      if (nowTime - lastTime > delay) {
+        fn.apply(this, args);
+        lastTime = nowTime;
+      }
+    };
+  },
+  debounce<T extends (...args: any[]) => any>(
+    fn: T,
+    delay: number = 500
+  ): DebounceFunction<T> {
+    let timer: ReturnType<typeof setTimeout> | null = null;
+    return function (this: any, ...args: Parameters<T>) {
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(() => {
+        fn.apply(this, args);
+      }, delay);
+    };
+  }
+};
+
+export default fun;

package/src/getMonthDays/index.ts

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

package/src/getParamsUtil/index.ts

@@ -0,0 +1,107 @@
+type ParamType = 'string' | 'number' | 'boolean' | 'object';
+
+interface ParamsObject {
+  [key: string]: string | string[];
+}
+
+const getParamsUtil = {
+  getParam<T = any>(
+    name: string,
+    url?: string,
+    defaultValue?: T,
+    type?: ParamType
+  ): T {
+    const params = this.getParams(url);
+    let value = params[name];
+
+    if (value === undefined) {
+      return defaultValue as T;
+    }
+
+    if (type === 'number') {
+      return Number(value) as T;
+    } else if (type === 'boolean') {
+      return ((value === 'true' || value === '1') as unknown) as T;
+    } else if (type === 'object') {
+      try {
+        return JSON.parse(String(value)) as T;
+      } catch (e) {
+        return defaultValue as T;
+      }
+    }
+
+    return value as unknown as T;
+  },
+
+  getParams(url: string = window.location.href): ParamsObject {
+    const params: ParamsObject = {};
+    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] as string, decodedValue];
+          }
+        } else {
+          params[decodedKey] = decodedValue;
+        }
+      }
+    });
+
+    return params;
+  },
+
+  buildQueryString(params: Record<string, any>): string {
+    const query: string[] = [];
+
+    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: string, params: Record<string, any>): string {
+    const [baseUrl] = url.split('?');
+    const existingParams = this.getParams(url);
+    const mergedParams = { ...existingParams, ...params };
+    const queryString = this.buildQueryString(mergedParams);
+
+    return queryString ? `${baseUrl}?${queryString}` : baseUrl;
+  },
+
+  removeParams(url: string, keys: string | string[]): string {
+    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/src/highLight/index.ts

@@ -0,0 +1,10 @@
+export default function highlight(
+  searchName: string,
+  backText: string,
+  className: string
+): string {
+  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/src/index.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/src/number/index.ts

@@ -0,0 +1,133 @@
+function countDecimals(num: number): number {
+  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: number): number {
+  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: 'add' | 'sub' | 'div' | 'mul', num1: number, num2: number, result: number): number {
+  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: number): boolean {
+  return Math.floor(num * 100) === num * 100;
+}
+
+const num = {
+  NumFilter(v: number): number {
+    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: number | string, num2: number | string): number {
+    const n1 = this.NumFilter(Number(num1));
+    const n2 = this.NumFilter(Number(num2));
+    let dec1 = 0, dec2 = 0, times: number;
+    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: number | string, num2: number | string): number {
+    const n1 = this.NumFilter(Number(num1));
+    const n2 = this.NumFilter(Number(num2));
+    let dec1 = 0, dec2 = 0, times: number;
+    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: number | string, num2: number | string): number {
+    const n1 = Number(num1);
+    const n2 = Number(num2);
+    let t1 = 0, t2 = 0, dec1: number, dec2: number;
+    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: number | string, num2: number | string): number {
+    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/src/reg/index.ts

@@ -0,0 +1,36 @@
+const reg = {
+  Phone(value: string): boolean {
+    const regex = /^[1][3,4,5,6,7,8,9][0-9]{9}$/;
+    return regex.test(value);
+  },
+  Email(value: string): boolean {
+    const regex = /^([0-9A-Za-z\-_\.]+)@([0-9a-z]+\.[a-z]{2,3}(\.[a-z]{2})?)$/g;
+    return regex.test(value);
+  },
+  IdCard(value: string): boolean {
+    const regex = /(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/;
+    return regex.test(value);
+  },
+  Common(value: string): boolean {
+    const regex = /^[a-zA-Z0-9_]+$/;
+    return regex.test(value);
+  },
+  QQ(value: string): boolean {
+    const regex = /^[1-9][0-9]{4,10}$/gim;
+    return regex.test(value);
+  },
+  Money(value: string): boolean {
+    const regex = /(^[1-9]([0-9]+)?(\.[0-9]{1,2})?$)|(^(0){1}$)|(^[0-9]\.[0-9]([0-9])?$)/;
+    return regex.test(value);
+  },
+  imgUrl(value: string): boolean {
+    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: string): boolean {
+    const regex = /[\u4e00-\u9fa5]/;
+    return regex.test(value);
+  }
+};
+
+export default reg;