@qy_better_lib/core 0.1.2 → 0.1.4

package/lib/utils/share.js

@@ -1,19 +1,164 @@
-function u(e, n = 200) {
-  let t;
-  return function(...o) {
-    clearTimeout(t), t = setTimeout(() => {
-      e.apply(this, o);
-    }, n);
+function debounce(fn, delay = 200, immediate = false) {
+  let timer;
+  return function(...args) {
+    const context = this;
+    if (timer) clearTimeout(timer);
+    if (immediate) {
+      const callNow = !timer;
+      timer = setTimeout(() => {
+        timer = void 0;
+      }, delay);
+      if (callNow) {
+        return fn.apply(context, args);
+      }
+    } else {
+      timer = setTimeout(() => {
+        fn.apply(context, args);
+      }, delay);
+    }
+    return void 0;
   };
 }
-function r(e, n = 200) {
-  let t = 0;
-  return function(...o) {
-    const i = Date.now();
-    i - t >= n && (e.apply(this, o), t = i);
+function throttle(fn, interval = 200, options = {}) {
+  const { leading = true, trailing = true } = options;
+  let lastCallTime = 0;
+  let timer;
+  let lastArgs;
+  let lastContext;
+  return function(...args) {
+    const context = this;
+    const now = Date.now();
+    if (lastCallTime === 0) {
+      if (leading) {
+        fn.apply(context, args);
+      }
+      lastCallTime = now;
+      return void 0;
+    }
+    lastArgs = args;
+    lastContext = context;
+    const elapsed = now - lastCallTime;
+    if (elapsed >= interval) {
+      if (timer) {
+        clearTimeout(timer);
+        timer = void 0;
+      }
+      fn.apply(context, args);
+      lastCallTime = now;
+      return void 0;
+    }
+    if (!timer && trailing) {
+      timer = setTimeout(() => {
+        if (lastArgs) {
+          fn.apply(lastContext, lastArgs);
+          lastCallTime = Date.now();
+        }
+        timer = void 0;
+        lastArgs = void 0;
+        lastContext = void 0;
+      }, interval - elapsed);
+    }
+    return void 0;
   };
 }
+function curry(fn) {
+  const arity = fn.length;
+  function curried(...args) {
+    if (args.length >= arity) {
+      return fn.apply(this, args);
+    }
+    return function(...moreArgs) {
+      return curried.apply(this, [...args, ...moreArgs]);
+    };
+  }
+  return curried;
+}
+function compose(...fns) {
+  return function(initialValue) {
+    return fns.reduceRight((accumulator, fn) => {
+      return fn(accumulator);
+    }, initialValue);
+  };
+}
+function pipe(...fns) {
+  return function(initialValue) {
+    return fns.reduce((accumulator, fn) => {
+      return fn(accumulator);
+    }, initialValue);
+  };
+}
+function delay_execution(fn, delay = 1e3) {
+  return new Promise((resolve) => {
+    setTimeout(() => {
+      resolve(fn());
+    }, delay);
+  });
+}
+async function retry(fn, maxRetries = 3, delay = 1e3) {
+  try {
+    return await fn();
+  } catch (error) {
+    if (maxRetries <= 0) {
+      throw error;
+    }
+    await new Promise((resolve) => setTimeout(resolve, delay));
+    return retry(fn, maxRetries - 1, delay);
+  }
+}
+function once(fn) {
+  let called = false;
+  let result;
+  return function(...args) {
+    if (!called) {
+      called = true;
+      result = fn.apply(this, args);
+    }
+    return result;
+  };
+}
+function memoize(fn) {
+  const cache = /* @__PURE__ */ new Map();
+  return function(...args) {
+    const key = JSON.stringify(args);
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    const result = fn.apply(this, args);
+    cache.set(key, result);
+    return result;
+  };
+}
+async function batch_execution(fns, parallel = true) {
+  if (parallel) {
+    return Promise.all(fns.map((fn) => fn()));
+  } else {
+    const results = [];
+    for (const fn of fns) {
+      results.push(await fn());
+    }
+    return results;
+  }
+}
+function timeout(fn, timeout2 = 5e3, timeoutMessage = "Operation timed out") {
+  return Promise.race([
+    Promise.resolve(fn()),
+    new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(timeoutMessage));
+      }, timeout2);
+    })
+  ]);
+}
 export {
-  u as debounce,
-  r as throttle
+  batch_execution,
+  compose,
+  curry,
+  debounce,
+  delay_execution,
+  memoize,
+  once,
+  pipe,
+  retry,
+  throttle,
+  timeout
 };

package/lib/utils/storage.d.ts

@@ -1,35 +1,124 @@
+/**
+ * 存储工具函数
+ */
+/**
+ * 存储类型
+ */
+export type StorageType = 'local' | 'session';
+/**
+ * 带过期时间的存储数据结构
+ */
+export interface StorageWithExpiry {
+    value: any;
+    expiry: number;
+}
 /**
  * 获取用户token,包含过期时间判断
+ * @returns token值或null
  */
-export declare function getToken(): any | null;
+export declare function get_token(): any | null;
 /**
  * 设置用户token,有效期默认七天
- * @param {*} value
+ * @param value token值
+ * @param expires 过期时间（秒），默认7天
  */
-export declare function setToken(value: any, expires?: number): void;
+export declare function set_token(value: any, expires?: number): void;
 /**
  * 移除token
  */
-export declare function removeToken(): void;
+export declare function remove_token(): void;
 /**
  * 设置缓存
- * @param key key
- * @param value 值
+ * @param key 缓存键
+ * @param value 缓存值
+ * @param type 存储类型，默认local
  */
-export declare function setStorage(key: string, value: any, tpye?: "local" | "session"): void;
+export declare function set_storage(key: string, value: any, type?: StorageType): void;
 /**
  * 获取缓存
- * @param key
- * @returns
+ * @param key 缓存键
+ * @param type 存储类型，默认local
+ * @returns 缓存值或null
  */
-export declare function getStorage(key: string, tpye?: "local" | "session"): any;
+export declare function get_storage(key: string, type?: StorageType): any;
 /**
  * 删除指定key的缓存
- * @param key
+ * @param key 缓存键
+ * @param type 存储类型，默认local
  */
-export declare function removeStorage(key: string, tpye?: "local" | "session"): void;
+export declare function remove_storage(key: string, type?: StorageType): void;
 /**
  * 清除所有缓存
- * @param tpye
+ * @param type 存储类型，默认local
+ */
+export declare function clear_storage(type?: StorageType): void;
+/**
+ * 设置带过期时间的缓存
+ * @param key 缓存键
+ * @param value 缓存值
+ * @param expiry 过期时间（秒）
+ * @param type 存储类型，默认local
+ */
+export declare function set_storage_with_expiry(key: string, value: any, expiry: number, type?: StorageType): void;
+/**
+ * 获取带过期时间的缓存
+ * @param key 缓存键
+ * @param type 存储类型，默认local
+ * @returns 缓存值或null
+ */
+export declare function get_storage_with_expiry(key: string, type?: StorageType): any;
+/**
+ * 检查缓存是否存在
+ * @param key 缓存键
+ * @param type 存储类型，默认local
+ * @returns 是否存在
+ */
+export declare function has_storage(key: string, type?: StorageType): boolean;
+/**
+ * 获取所有缓存键
+ * @param type 存储类型，默认local
+ * @returns 缓存键数组
+ */
+export declare function get_all_storage_keys(type?: StorageType): string[];
+/**
+ * 清除过期的缓存
+ * @param type 存储类型，默认local
+ * @returns 清除的缓存数量
+ */
+export declare function clear_expired_storage(type?: StorageType): number;
+/**
+ * 加密存储敏感数据
+ * @param key 缓存键
+ * @param value 缓存值
+ * @param type 存储类型，默认local
+ */
+export declare function encrypt_storage(key: string, value: any, type?: StorageType): void;
+/**
+ * 解密获取敏感数据
+ * @param key 缓存键
+ * @param type 存储类型，默认local
+ * @returns 解密后的数据或null
+ */
+export declare function decrypt_storage(key: string, type?: StorageType): any;
+/**
+ * 批量设置缓存
+ * @param items 缓存项数组
+ * @param type 存储类型，默认local
+ */
+export declare function set_batch_storage(items: Array<{
+    key: string;
+    value: any;
+}>, type?: StorageType): void;
+/**
+ * 批量获取缓存
+ * @param keys 缓存键数组
+ * @param type 存储类型，默认local
+ * @returns 缓存值对象
+ */
+export declare function get_batch_storage(keys: string[], type?: StorageType): Record<string, any>;
+/**
+ * 批量删除缓存
+ * @param keys 缓存键数组
+ * @param type 存储类型，默认local
  */
-export declare function clearStorage(tpye?: "local" | "session"): void;
+export declare function remove_batch_storage(keys: string[], type?: StorageType): void;

package/lib/utils/storage.js

@@ -1,43 +1,181 @@
-function n() {
-  const o = localStorage.getItem("token");
-  if (!o)
-    return;
-  const e = JSON.parse(o);
-  if (e !== null)
-    if (e.expirse != null && e.expirse < (/* @__PURE__ */ new Date()).getTime())
+function get_storage_instance(type = "local") {
+  return type === "local" ? localStorage : sessionStorage;
+}
+function json_parse(data, defaultValue = null) {
+  try {
+    return JSON.parse(data);
+  } catch (error) {
+    console.error("JSON解析错误:", error);
+    return defaultValue;
+  }
+}
+function get_token() {
+  const session = localStorage.getItem("token");
+  if (!session) {
+    return null;
+  }
+  const data = json_parse(session);
+  if (data !== null) {
+    if (data.expiry != null && data.expiry < Date.now()) {
       localStorage.removeItem("token");
-    else
-      return e.value;
+      return null;
+    } else {
+      return data.value;
+    }
+  }
   return null;
 }
-function r(o, e) {
-  !e && (e = 10080 * 60 * 1e3) || (e = e * 1e3);
-  const t = { value: o, expirse: (/* @__PURE__ */ new Date()).getTime() + e };
-  localStorage.setItem("token", JSON.stringify(t));
+function set_token(value, expires = 7 * 24 * 60 * 60) {
+  const expiry = Date.now() + expires * 1e3;
+  const data = { value, expiry };
+  localStorage.setItem("token", JSON.stringify(data));
 }
-function l() {
+function remove_token() {
   localStorage.removeItem("token");
 }
-function s(o, e, t = "local") {
-  const a = t == "local" ? localStorage : sessionStorage;
-  e != null && a.setItem(o, JSON.stringify(e));
+function set_storage(key, value, type = "local") {
+  const storage = get_storage_instance(type);
+  if (value !== void 0) {
+    storage.setItem(key, JSON.stringify(value));
+  }
+}
+function get_storage(key, type = "local") {
+  const storage = get_storage_instance(type);
+  const item = storage.getItem(key);
+  if (item) {
+    return json_parse(item);
+  }
+  return null;
+}
+function remove_storage(key, type = "local") {
+  const storage = get_storage_instance(type);
+  storage.removeItem(key);
+}
+function clear_storage(type = "local") {
+  const storage = get_storage_instance(type);
+  storage.clear();
+}
+function set_storage_with_expiry(key, value, expiry, type = "local") {
+  const storage = get_storage_instance(type);
+  const item = {
+    value,
+    expiry: Date.now() + expiry * 1e3
+  };
+  storage.setItem(key, JSON.stringify(item));
+}
+function get_storage_with_expiry(key, type = "local") {
+  const storage = get_storage_instance(type);
+  const itemStr = storage.getItem(key);
+  if (!itemStr) {
+    return null;
+  }
+  const item = json_parse(itemStr);
+  if (item.expiry && item.expiry < Date.now()) {
+    storage.removeItem(key);
+    return null;
+  }
+  return item.value;
+}
+function has_storage(key, type = "local") {
+  const storage = get_storage_instance(type);
+  return storage.getItem(key) !== null;
+}
+function get_all_storage_keys(type = "local") {
+  const storage = get_storage_instance(type);
+  const keys = [];
+  for (let i = 0; i < storage.length; i++) {
+    const key = storage.key(i);
+    if (key) {
+      keys.push(key);
+    }
+  }
+  return keys;
+}
+function clear_expired_storage(type = "local") {
+  const storage = get_storage_instance(type);
+  const keys = get_all_storage_keys(type);
+  let cleared = 0;
+  keys.forEach((key) => {
+    const itemStr = storage.getItem(key);
+    if (itemStr) {
+      const item = json_parse(itemStr);
+      if (item.expiry && item.expiry < Date.now()) {
+        storage.removeItem(key);
+        cleared++;
+      }
+    }
+  });
+  return cleared;
+}
+function simple_encrypt(text) {
+  try {
+    return btoa(unescape(encodeURIComponent(text)));
+  } catch (error) {
+    console.error("加密错误:", error);
+    return text;
+  }
+}
+function simple_decrypt(encryptedText) {
+  try {
+    return decodeURIComponent(escape(atob(encryptedText)));
+  } catch (error) {
+    console.error("解密错误:", error);
+    return encryptedText;
+  }
+}
+function encrypt_storage(key, value, type = "local") {
+  const storage = get_storage_instance(type);
+  const jsonValue = JSON.stringify(value);
+  const encryptedValue = simple_encrypt(jsonValue);
+  storage.setItem(key, encryptedValue);
+}
+function decrypt_storage(key, type = "local") {
+  const storage = get_storage_instance(type);
+  const encryptedValue = storage.getItem(key);
+  if (!encryptedValue) {
+    return null;
+  }
+  try {
+    const decryptedValue = simple_decrypt(encryptedValue);
+    return JSON.parse(decryptedValue);
+  } catch (error) {
+    console.error("解密解析错误:", error);
+    return null;
+  }
 }
-function c(o, e = "local") {
-  let a = (e == "local" ? localStorage : sessionStorage).getItem(o);
-  return a && JSON.parse(a || "");
+function set_batch_storage(items, type = "local") {
+  items.forEach((item) => {
+    set_storage(item.key, item.value, type);
+  });
 }
-function g(o, e = "local") {
-  (e == "local" ? localStorage : sessionStorage).removeItem(o);
+function get_batch_storage(keys, type = "local") {
+  const result = {};
+  keys.forEach((key) => {
+    result[key] = get_storage(key, type);
+  });
+  return result;
 }
-function i(o = "local") {
-  (o == "local" ? localStorage : sessionStorage).clear();
+function remove_batch_storage(keys, type = "local") {
+  keys.forEach((key) => {
+    remove_storage(key, type);
+  });
 }
 export {
-  i as clearStorage,
-  c as getStorage,
-  n as getToken,
-  g as removeStorage,
-  l as removeToken,
-  s as setStorage,
-  r as setToken
+  clear_expired_storage,
+  clear_storage,
+  decrypt_storage,
+  encrypt_storage,
+  get_all_storage_keys,
+  get_batch_storage,
+  get_storage,
+  get_storage_with_expiry,
+  get_token,
+  has_storage,
+  remove_batch_storage,
+  remove_storage,
+  remove_token,
+  set_batch_storage,
+  set_storage,
+  set_storage_with_expiry,
+  set_token
 };