@qy_better_lib/core 0.1.2 → 0.1.4

package/lib/utils/object.js

@@ -1,73 +1,247 @@
-import { isObject as c } from "./is.js";
-function f(e) {
-  const t = Object.prototype.toString;
-  if (!e || typeof e != "object")
-    return e;
-  if (e.nodeType && "cloneNode" in e)
-    return e.cloneNode(!0);
-  if (t.call(e) === "[object Date]")
-    return new Date(e.getTime());
-  if (t.call(e) === "[object RegExp]") {
-    const r = [];
-    return e.global && r.push("g"), e.multiline && r.push("m"), e.ignoreCase && r.push("i"), new RegExp(e.source, r.join(""));
+import { is_object } from "./is.js";
+function deep_clone(obj) {
+  const _toString = Object.prototype.toString;
+  if (!obj || typeof obj !== "object") {
+    return obj;
   }
-  if (t.call(e) === "[object FormData]") {
-    const r = new FormData();
-    for (const [l, o] of e.entries())
-      r.append(l, o);
-    return r;
+  if (obj.nodeType && "cloneNode" in obj) {
+    return obj.cloneNode(true);
   }
-  const n = Array.isArray(e) ? [] : e.constructor ? new e.constructor() : {};
-  for (const r in e)
-    n[r] = f(e[r]);
-  return n;
+  if (_toString.call(obj) === "[object Date]") {
+    return new Date(obj.getTime());
+  }
+  if (_toString.call(obj) === "[object RegExp]") {
+    const flags = [];
+    if (obj.global) {
+      flags.push("g");
+    }
+    if (obj.multiline) {
+      flags.push("m");
+    }
+    if (obj.ignoreCase) {
+      flags.push("i");
+    }
+    return new RegExp(obj.source, flags.join(""));
+  }
+  if (_toString.call(obj) === "[object FormData]") {
+    const form_data = new FormData();
+    for (const [key, value] of obj.entries()) {
+      form_data.append(key, value);
+    }
+    return form_data;
+  }
+  if (_toString.call(obj) === "[object Map]") {
+    const map = /* @__PURE__ */ new Map();
+    for (const [key, value] of obj.entries()) {
+      map.set(key, deep_clone(value));
+    }
+    return map;
+  }
+  if (_toString.call(obj) === "[object Set]") {
+    const set = /* @__PURE__ */ new Set();
+    for (const value of obj.values()) {
+      set.add(deep_clone(value));
+    }
+    return set;
+  }
+  const result = Array.isArray(obj) ? [] : obj.constructor ? new obj.constructor() : {};
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      result[key] = deep_clone(obj[key]);
+    }
+  }
+  return result;
 }
-function s(...e) {
-  let t = e.length, n = e[0];
-  c(n) || (n = {});
-  for (let r = 1; r < t; r++) {
-    let l = e[r];
-    if (c(l))
-      for (let o in l)
-        o === "__proto__" || n === l[o] || (c(l[o]) ? n[o] = s(n[o], l[o]) : n[o] = l[o]);
+function deep_assign(...args) {
+  let len = args.length, target = args[0];
+  if (!is_object(target)) {
+    target = {};
   }
-  return n;
+  for (let i = 1; i < len; i++) {
+    let source = args[i];
+    if (is_object(source)) {
+      for (let s in source) {
+        if (s === "__proto__" || target === source[s]) {
+          continue;
+        }
+        if (is_object(source[s])) {
+          if (!is_object(target[s])) {
+            target[s] = Array.isArray(source[s]) ? [] : {};
+          }
+          target[s] = deep_assign(target[s], source[s]);
+        } else {
+          target[s] = source[s];
+        }
+      }
+    }
+  }
+  return target;
 }
-function i(e, t) {
-  if (e === t) return !0;
-  if (e && t && typeof e == "object" && typeof t == "object") {
-    if (e.constructor !== t.constructor)
-      return console.log("对象比较-a.constructor", e.constructor, "对象比较-b.constructor", t.constructor), !1;
-    let n, r, l;
-    if (Array.isArray(e)) {
-      if (n = e.length, n != t.length)
-        return console.log("对象比较-a.length", e.length, "对象比较-b.length", t.length), !1;
-      for (r = n; r-- !== 0; )
-        if (!i(e[r], t[r]))
-          return console.log("对象比较-a[i]", e[r], "对象比较-b[i]", t[r]), !1;
-      return !0;
-    }
-    if (e.constructor === RegExp) return e.source === t.source && e.flags === t.flags;
-    if (e.valueOf !== Object.prototype.valueOf)
-      return e.valueOf() !== t.valueOf() && console.log("对象比较-a.valueOf()", e.valueOf(), "对象比较-b.valueOf()", e.valueOf()), e.valueOf() === t.valueOf();
-    if (e.toString !== Object.prototype.toString)
-      return e.toString() === t.toString() && console.log("对象比较-a.toString()", e.toString(), "对象比较-b.toString()", t.toString()), e.toString() === t.toString();
-    if (l = Object.keys(e), n = l.length, n !== Object.keys(t).length)
-      return console.log("对象比较-Object.keys(a).length", Object.keys(e).length, "对象比较-Object.keys(b).length", Object.keys(t).length), !1;
-    for (r = n; r-- !== 0; )
-      if (!Object.prototype.hasOwnProperty.call(t, l[r]))
-        return console.log("对象比较-keys[i]", l[r], "对象比较-b", t), !1;
-    for (r = n; r-- !== 0; ) {
-      const o = l[r];
-      if (!i(e[o], t[o]))
-        return console.log("对象比较-a[key]", e[o], "对象比较-b[key]", t[o]), !1;
-    }
-    return !0;
+function deep_equal(a, b) {
+  if (a === b) return true;
+  if (a && b && typeof a == "object" && typeof b == "object") {
+    if (a.constructor !== b.constructor) {
+      return false;
+    }
+    let length, i, keys;
+    if (Array.isArray(a)) {
+      length = a.length;
+      if (length != b.length) {
+        return false;
+      }
+      for (i = length; i-- !== 0; ) {
+        if (!deep_equal(a[i], b[i])) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
+    if (a.valueOf !== Object.prototype.valueOf) {
+      return a.valueOf() === b.valueOf();
+    }
+    if (a.toString !== Object.prototype.toString) {
+      return a.toString() === b.toString();
+    }
+    keys = Object.keys(a);
+    length = keys.length;
+    if (length !== Object.keys(b).length) {
+      return false;
+    }
+    for (i = length; i-- !== 0; ) {
+      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) {
+        return false;
+      }
+    }
+    for (i = length; i-- !== 0; ) {
+      const key = keys[i];
+      if (!deep_equal(a[key], b[key])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return a !== a && b !== b;
+}
+function is_empty_object(obj) {
+  return is_object(obj) && Object.keys(obj).length === 0;
+}
+function pick(obj, keys) {
+  if (!is_object(obj)) return {};
+  const result = {};
+  keys.forEach((key) => {
+    if (key in obj) {
+      result[key] = obj[key];
+    }
+  });
+  return result;
+}
+function omit(obj, keys) {
+  if (!is_object(obj)) return {};
+  const result = {};
+  Object.keys(obj).forEach((key) => {
+    if (!keys.includes(key)) {
+      result[key] = obj[key];
+    }
+  });
+  return result;
+}
+function flatten_object(obj, prefix = "") {
+  if (!is_object(obj)) return {};
+  const result = {};
+  Object.keys(obj).forEach((key) => {
+    const newKey = prefix ? `${prefix}.${key}` : key;
+    if (is_object(obj[key]) && !Array.isArray(obj[key])) {
+      Object.assign(result, flatten_object(obj[key], newKey));
+    } else {
+      result[newKey] = obj[key];
+    }
+  });
+  return result;
+}
+function unflatten_object(obj) {
+  if (!is_object(obj)) return {};
+  const result = {};
+  Object.keys(obj).forEach((key) => {
+    const parts = key.split(".");
+    let current = result;
+    parts.forEach((part, index) => {
+      if (index === parts.length - 1) {
+        current[part] = obj[key];
+      } else {
+        if (!current[part]) {
+          current[part] = {};
+        }
+        current = current[part];
+      }
+    });
+  });
+  return result;
+}
+function get_object_value(obj, path, defaultValue = void 0) {
+  if (!is_object(obj)) return defaultValue;
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === void 0 || current === null) {
+      return defaultValue;
+    }
+    current = current[part];
+  }
+  return current !== void 0 ? current : defaultValue;
+}
+function set_object_value(obj, path, value) {
+  if (!is_object(obj)) obj = {};
+  const parts = path.split(".");
+  let current = obj;
+  parts.forEach((part, index) => {
+    if (index === parts.length - 1) {
+      current[part] = value;
+    } else {
+      if (!is_object(current[part])) {
+        current[part] = {};
+      }
+      current = current[part];
+    }
+  });
+  return obj;
+}
+function merge_objects(...args) {
+  return Object.assign({}, ...args);
+}
+function diff_objects(obj1, obj2) {
+  const result = {};
+  if (!is_object(obj1) && !is_object(obj2)) {
+    return result;
+  }
+  if (!is_object(obj1)) {
+    return obj2;
   }
-  return e !== e && t !== t || console.log("对象比较-a", e, "对象比较-b", t), e !== e && t !== t;
+  if (!is_object(obj2)) {
+    return obj1;
+  }
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(obj1), ...Object.keys(obj2)]);
+  allKeys.forEach((key) => {
+    if (!deep_equal(obj1[key], obj2[key])) {
+      result[key] = {
+        oldValue: obj1[key],
+        newValue: obj2[key]
+      };
+    }
+  });
+  return result;
 }
 export {
-  s as deepAssign,
-  f as deepClone,
-  i as deepEqual
+  deep_assign,
+  deep_clone,
+  deep_equal,
+  diff_objects,
+  flatten_object,
+  get_object_value,
+  is_empty_object,
+  merge_objects,
+  omit,
+  pick,
+  set_object_value,
+  unflatten_object
 };

package/lib/utils/random.d.ts

@@ -7,19 +7,98 @@
  * 生成[0-10000]的随机数,针对数据小量使用
  * @returns 随机数
  */
-export declare function generateId(): number;
+export declare function generate_id(): number;
 /**
  * 生成[0-max]的随机数
+ * @param max 最大值
  * @returns 随机数
  */
-export declare function getRandomInt(max: number): number;
+export declare function get_random_int(max: number): number;
 /**
- * 生成GUID
- * @returns
+ * 生成指定范围的随机整数
+ * @param min 最小值
+ * @param max 最大值
+ * @returns 随机整数
  */
-export declare function guiID(): string;
+export declare function get_random_int_range(min: number, max: number): number;
 /**
- * 随机字符串
- * @returns
+ * 生成随机浮点数
+ * @param min 最小值
+ * @param max 最大值
+ * @param decimalPlaces 小数位数
+ * @returns 随机浮点数
  */
-export declare function generateString(): string;
+export declare function get_random_float(min: number, max: number, decimalPlaces?: number): number;
+/**
+ * 生成GUID/UUID
+ * @returns GUID/UUID字符串
+ */
+export declare function generate_guid(): string;
+/**
+ * 生成随机字符串
+ * @returns 随机字符串
+ */
+export declare function generate_string(): string;
+/**
+ * 生成指定长度的随机字符串
+ * @param length 字符串长度
+ * @param chars 可选字符集
+ * @returns 随机字符串
+ */
+export declare function generate_random_string(length: number, chars?: string): string;
+/**
+ * 生成随机布尔值
+ * @returns 随机布尔值
+ */
+export declare function get_random_boolean(): boolean;
+/**
+ * 从数组中随机选择一个元素
+ * @param array 源数组
+ * @returns 随机选中的元素
+ */
+export declare function get_random_element<T>(array: T[]): T | undefined;
+/**
+ * 从数组中随机选择多个元素
+ * @param array 源数组
+ * @param count 选择数量
+ * @returns 随机选中的元素数组
+ */
+export declare function get_random_elements<T>(array: T[], count: number): T[];
+/**
+ * 生成随机颜色
+ * @returns 随机颜色的十六进制值
+ */
+export declare function generate_random_color(): string;
+/**
+ * 生成指定长度的随机数字字符串
+ * @param length 字符串长度
+ * @returns 随机数字字符串
+ */
+export declare function generate_random_number_string(length: number): string;
+/**
+ * 生成随机密码
+ * @param length 密码长度，默认8
+ * @returns 随机密码
+ */
+export declare function generate_random_password(length?: number): string;
+/**
+ * 生成随机手机号
+ * @returns 随机手机号
+ */
+export declare function generate_random_phone(): string;
+/**
+ * 生成随机邮箱
+ * @returns 随机邮箱
+ */
+export declare function generate_random_email(): string;
+/**
+ * 生成随机URL
+ * @returns 随机URL
+ */
+export declare function generate_random_url(): string;
+/**
+ * 打乱数组顺序
+ * @param array 源数组
+ * @returns 打乱后的新数组
+ */
+export declare function shuffle_array<T>(array: T[]): T[];

package/lib/utils/random.js

@@ -1,19 +1,109 @@
-function r() {
+function generate_id() {
   return Math.floor(Math.random() * 1e4);
 }
-function o(t) {
-  return Math.floor(Math.random() * Math.floor(t));
+function get_random_int(max) {
+  if (max < 0) return 0;
+  return Math.floor(Math.random() * Math.floor(max));
 }
-function a() {
-  const t = n;
-  return `${t()}${t()}-${t()}-${t()}-${t()}-${t()}${t()}${t()}`;
+function get_random_int_range(min, max) {
+  if (min > max) [min, max] = [max, min];
+  return Math.floor(Math.random() * (max - min + 1)) + min;
 }
-function n() {
+function get_random_float(min, max, decimalPlaces = 2) {
+  if (min > max) [min, max] = [max, min];
+  const random = Math.random() * (max - min) + min;
+  return parseFloat(random.toFixed(decimalPlaces));
+}
+function generate_guid() {
+  const gs = generate_string;
+  return `${gs()}${gs()}-${gs()}-${gs()}-${gs()}-${gs()}${gs()}${gs()}`;
+}
+function generate_string() {
   return Math.floor((1 + Math.random()) * 65536).toString(16).substring(1);
 }
+function generate_random_string(length, chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") {
+  let result = "";
+  const charsLength = chars.length;
+  for (let i = 0; i < length; i++) {
+    result += chars.charAt(Math.floor(Math.random() * charsLength));
+  }
+  return result;
+}
+function get_random_boolean() {
+  return Math.random() > 0.5;
+}
+function get_random_element(array) {
+  if (!array || array.length === 0) return void 0;
+  return array[Math.floor(Math.random() * array.length)];
+}
+function get_random_elements(array, count) {
+  if (!array || array.length === 0 || count <= 0) return [];
+  if (count >= array.length) return [...array];
+  const shuffled = [...array].sort(() => 0.5 - Math.random());
+  return shuffled.slice(0, count);
+}
+function generate_random_color() {
+  const letters = "0123456789ABCDEF";
+  let color = "#";
+  for (let i = 0; i < 6; i++) {
+    color += letters[Math.floor(Math.random() * 16)];
+  }
+  return color;
+}
+function generate_random_number_string(length) {
+  return generate_random_string(length, "0123456789");
+}
+function generate_random_password(length = 8) {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()_+~`|}{[]:;?><,./-=";
+  return generate_random_string(length, chars);
+}
+function generate_random_phone() {
+  const prefixes = ["130", "131", "132", "133", "134", "135", "136", "137", "138", "139", "150", "151", "152", "153", "155", "156", "157", "158", "159", "170", "171", "172", "173", "175", "176", "177", "178", "180", "181", "182", "183", "184", "185", "186", "187", "188", "189"];
+  const prefix = get_random_element(prefixes);
+  const suffix = generate_random_number_string(8);
+  return `${prefix}${suffix}`;
+}
+function generate_random_email() {
+  const domains = ["gmail.com", "yahoo.com", "hotmail.com", "outlook.com", "163.com", "126.com", "qq.com", "sina.com"];
+  const username = generate_random_string(8);
+  const domain = get_random_element(domains);
+  return `${username}@${domain}`;
+}
+function generate_random_url() {
+  const protocols = ["http", "https"];
+  const domains = ["example.com", "test.com", "demo.com", "sample.com"];
+  const paths = ["api", "docs", "about", "contact", "products"];
+  const protocol = get_random_element(protocols);
+  const domain = get_random_element(domains);
+  const path = get_random_element(paths);
+  const query = generate_random_string(4);
+  return `${protocol}://www.${domain}/${path}?id=${query}`;
+}
+function shuffle_array(array) {
+  if (!array) return [];
+  const shuffled = [...array];
+  for (let i = shuffled.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+  }
+  return shuffled;
+}
 export {
-  r as generateId,
-  n as generateString,
-  o as getRandomInt,
-  a as guiID
+  generate_guid,
+  generate_id,
+  generate_random_color,
+  generate_random_email,
+  generate_random_number_string,
+  generate_random_password,
+  generate_random_phone,
+  generate_random_string,
+  generate_random_url,
+  generate_string,
+  get_random_boolean,
+  get_random_element,
+  get_random_elements,
+  get_random_float,
+  get_random_int,
+  get_random_int_range,
+  shuffle_array
 };

package/lib/utils/share.d.ts

@@ -1,16 +1,81 @@
 type Fn = (...args: any[]) => any;
 /**
- * 防抖
- * @param fn
- * @param delay
- * @returns
+ * 防抖函数
+ * @param fn 要执行的函数
+ * @param delay 延迟时间，默认200ms
+ * @param immediate 是否立即执行，默认false
+ * @returns 防抖处理后的函数
  */
-export declare function debounce(fn: Fn, delay?: number): (this: any, ...args: any[]) => void;
+export declare function debounce<T extends (...args: any[]) => any>(fn: T, delay?: number, immediate?: boolean): (this: any, ...args: Parameters<T>) => ReturnType<T>;
 /**
- * 节流
- * @param fn
- * @param interval
- * @returns
+ * 节流函数
+ * @param fn 要执行的函数
+ * @param interval 时间间隔，默认200ms
+ * @param options 配置选项
+ * @returns 节流处理后的函数
  */
-export declare function throttle(fn: Fn, interval?: number): (this: any, ...args: any[]) => void;
+export declare function throttle<T extends (...args: any[]) => any>(fn: T, interval?: number, options?: {
+    leading?: boolean;
+    trailing?: boolean;
+}): (this: any, ...args: Parameters<T>) => ReturnType<T>;
+/**
+ * 柯里化函数
+ * @param fn 要柯里化的函数
+ * @returns 柯里化后的函数
+ */
+export declare function curry<T extends (...args: any[]) => any>(fn: T): (...args: any[]) => any;
+/**
+ * 函数组合
+ * @param fns 要组合的函数列表
+ * @returns 组合后的函数
+ */
+export declare function compose(...fns: Fn[]): (initialValue: any) => any;
+/**
+ * 管道函数
+ * @param fns 要管道的函数列表
+ * @returns 管道后的函数
+ */
+export declare function pipe(...fns: Fn[]): (initialValue: any) => any;
+/**
+ * 延迟执行函数
+ * @param fn 要延迟执行的函数
+ * @param delay 延迟时间，默认1000ms
+ * @returns Promise
+ */
+export declare function delay_execution(fn: Fn, delay?: number): Promise<any>;
+/**
+ * 重试函数
+ * @param fn 要执行的函数
+ * @param maxRetries 最大重试次数，默认3
+ * @param delay 重试间隔，默认1000ms
+ * @returns Promise
+ */
+export declare function retry(fn: Fn, maxRetries?: number, delay?: number): Promise<any>;
+/**
+ * 一次性函数
+ * @param fn 要执行的函数
+ * @returns 只能执行一次的函数
+ */
+export declare function once<T extends (...args: any[]) => any>(fn: T): (...args: Parameters<T>) => ReturnType<T>;
+/**
+ * 记忆化函数
+ * @param fn 要记忆化的函数
+ * @returns 记忆化后的函数
+ */
+export declare function memoize<T extends (...args: any[]) => any>(fn: T): (...args: Parameters<T>) => ReturnType<T>;
+/**
+ * 批量执行函数
+ * @param fns 要执行的函数列表
+ * @param parallel 是否并行执行，默认true
+ * @returns Promise数组
+ */
+export declare function batch_execution(fns: Array<() => Promise<any>>, parallel?: boolean): Promise<any[]>;
+/**
+ * 超时控制函数
+ * @param fn 要执行的函数
+ * @param timeout 超时时间，默认5000ms
+ * @param timeoutMessage 超时消息
+ * @returns Promise
+ */
+export declare function timeout(fn: Fn, timeout?: number, timeoutMessage?: string): Promise<any>;
 export {};