@alibarbar/common 1.0.8 → 1.0.10

package/dist/storage.js

@@ -1,34 +1,553 @@
-'use strict';
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
-var chunkWZDOPUJW_js = require('./chunk-WZDOPUJW.js');
-require('./chunk-DYBSRI7V.js');
-require('./chunk-PR4QN5HX.js');
-
-
-
-Object.defineProperty(exports, "cookie", {
-  enumerable: true,
-  get: function () { return chunkWZDOPUJW_js.cookie; }
-});
-Object.defineProperty(exports, "getStorageKeyPair", {
-  enumerable: true,
-  get: function () { return chunkWZDOPUJW_js.getStorageKeyPair; }
-});
-Object.defineProperty(exports, "localStorage", {
-  enumerable: true,
-  get: function () { return chunkWZDOPUJW_js.localStorage; }
+// src/helper/crypto.ts
+var crypto_exports = {};
+__export(crypto_exports, {
+  base64Decode: () => base64Decode,
+  base64Encode: () => base64Encode,
+  exportPrivateKey: () => exportPrivateKey,
+  exportPublicKey: () => exportPublicKey,
+  generateRSAKeyPair: () => generateRSAKeyPair,
+  generateRandomString: () => generateRandomString,
+  generateUUID: () => generateUUID,
+  hash: () => hash,
+  importPrivateKey: () => importPrivateKey,
+  importPublicKey: () => importPublicKey,
+  rsaDecrypt: () => rsaDecrypt,
+  rsaEncrypt: () => rsaEncrypt,
+  sha256: () => sha256
 });
-Object.defineProperty(exports, "sessionStorage", {
-  enumerable: true,
-  get: function () { return chunkWZDOPUJW_js.sessionStorage; }
+async function sha256(data) {
+  const buffer = typeof data === "string" ? new TextEncoder().encode(data) : data;
+  const hashBuffer = await crypto.subtle.digest("SHA-256", buffer);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function base64Encode(data) {
+  if (typeof data === "string") {
+    return btoa(unescape(encodeURIComponent(data)));
+  }
+  const bytes = new Uint8Array(data);
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+function base64Decode(data) {
+  try {
+    return decodeURIComponent(escape(atob(data)));
+  } catch {
+    throw new Error("Invalid Base64 string");
+  }
+}
+function generateUUID() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+function generateRandomString(length, charset = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") {
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += charset.charAt(Math.floor(Math.random() * charset.length));
+  }
+  return result;
+}
+function hash(data) {
+  let hashValue = 0;
+  for (let i = 0; i < data.length; i++) {
+    const char = data.charCodeAt(i);
+    hashValue = (hashValue << 5) - hashValue + char;
+    hashValue = hashValue & hashValue;
+  }
+  return Math.abs(hashValue);
+}
+async function generateRSAKeyPair(modulusLength = 2048) {
+  if (typeof crypto === "undefined" || !crypto.subtle) {
+    throw new Error("Web Crypto API is not available");
+  }
+  const keyPair = await crypto.subtle.generateKey(
+    {
+      name: "RSA-OAEP",
+      modulusLength,
+      publicExponent: new Uint8Array([1, 0, 1]),
+      hash: "SHA-256"
+    },
+    true,
+    ["encrypt", "decrypt"]
+  );
+  return {
+    publicKey: keyPair.publicKey,
+    privateKey: keyPair.privateKey
+  };
+}
+async function rsaEncrypt(data, publicKey) {
+  if (typeof crypto === "undefined" || !crypto.subtle) {
+    throw new Error("Web Crypto API is not available");
+  }
+  const encoder = new TextEncoder();
+  const dataBuffer = encoder.encode(data);
+  const maxChunkSize = 245;
+  const chunks = [];
+  for (let i = 0; i < dataBuffer.length; i += maxChunkSize) {
+    const chunk = dataBuffer.slice(i, i + maxChunkSize);
+    const encrypted = await crypto.subtle.encrypt(
+      {
+        name: "RSA-OAEP"
+      },
+      publicKey,
+      chunk
+    );
+    chunks.push(encrypted);
+  }
+  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
+  const merged = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    merged.set(new Uint8Array(chunk), offset);
+    offset += chunk.byteLength;
+  }
+  return base64Encode(merged.buffer);
+}
+async function rsaDecrypt(encryptedData, privateKey) {
+  if (typeof crypto === "undefined" || !crypto.subtle) {
+    throw new Error("Web Crypto API is not available");
+  }
+  const binaryString = atob(encryptedData);
+  const encryptedArray = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    encryptedArray[i] = binaryString.charCodeAt(i);
+  }
+  const chunkSize = 256;
+  const chunks = [];
+  for (let i = 0; i < encryptedArray.length; i += chunkSize) {
+    const chunk = encryptedArray.slice(i, i + chunkSize);
+    const decrypted = await crypto.subtle.decrypt(
+      {
+        name: "RSA-OAEP"
+      },
+      privateKey,
+      chunk
+    );
+    const decoder = new TextDecoder();
+    chunks.push(decoder.decode(decrypted));
+  }
+  return chunks.join("");
+}
+async function exportPublicKey(publicKey) {
+  if (typeof crypto === "undefined" || !crypto.subtle) {
+    throw new Error("Web Crypto API is not available");
+  }
+  const exported = await crypto.subtle.exportKey("spki", publicKey);
+  return base64Encode(exported);
+}
+async function exportPrivateKey(privateKey) {
+  if (typeof crypto === "undefined" || !crypto.subtle) {
+    throw new Error("Web Crypto API is not available");
+  }
+  const exported = await crypto.subtle.exportKey("pkcs8", privateKey);
+  return base64Encode(exported);
+}
+async function importPublicKey(keyData) {
+  if (typeof crypto === "undefined" || !crypto.subtle) {
+    throw new Error("Web Crypto API is not available");
+  }
+  const keyBuffer = base64Decode(keyData);
+  const keyArray = new Uint8Array(keyBuffer.split("").map((char) => char.charCodeAt(0)));
+  return crypto.subtle.importKey(
+    "spki",
+    keyArray.buffer,
+    {
+      name: "RSA-OAEP",
+      hash: "SHA-256"
+    },
+    true,
+    ["encrypt"]
+  );
+}
+async function importPrivateKey(keyData) {
+  if (typeof crypto === "undefined" || !crypto.subtle) {
+    throw new Error("Web Crypto API is not available");
+  }
+  const keyBuffer = base64Decode(keyData);
+  const keyArray = new Uint8Array(keyBuffer.split("").map((char) => char.charCodeAt(0)));
+  return crypto.subtle.importKey(
+    "pkcs8",
+    keyArray.buffer,
+    {
+      name: "RSA-OAEP",
+      hash: "SHA-256"
+    },
+    true,
+    ["decrypt"]
+  );
+}
+var init_crypto = __esm({
+  "src/helper/crypto.ts"() {
+  }
 });
-Object.defineProperty(exports, "setStorageKeyPair", {
-  enumerable: true,
-  get: function () { return chunkWZDOPUJW_js.setStorageKeyPair; }
-});
-Object.defineProperty(exports, "storage", {
-  enumerable: true,
-  get: function () { return chunkWZDOPUJW_js.storage; }
-});
-//# sourceMappingURL=storage.js.map
-//# sourceMappingURL=storage.js.map
+
+// src/browser/storage.ts
+init_crypto();
+var globalKeyPair = null;
+function setStorageKeyPair(keyPair) {
+  globalKeyPair = keyPair;
+}
+function getStorageKeyPair() {
+  return globalKeyPair;
+}
+async function encryptValue(value, publicKey) {
+  return rsaEncrypt(value, publicKey);
+}
+async function decryptValue(encryptedValue, privateKey) {
+  try {
+    return await rsaDecrypt(encryptedValue, privateKey);
+  } catch {
+    try {
+      JSON.parse(encryptedValue);
+      return encryptedValue;
+    } catch {
+      throw new Error("Failed to decrypt storage value");
+    }
+  }
+}
+var localStorage = {
+  /**
+   * 设置值
+   * @param key - 键
+   * @param value - 值
+   * @param options - 选项（过期时间、密钥等）
+   * @returns Promise<void>
+   */
+  async set(key, value, options = {}) {
+    if (typeof window === "undefined" || !window.localStorage) {
+      throw new Error("localStorage is not available");
+    }
+    const { expiry, publicKey } = options;
+    const item = {
+      value,
+      expiry: expiry ? Date.now() + expiry : void 0
+    };
+    try {
+      const jsonStr = JSON.stringify(item);
+      const keyToUse = publicKey || globalKeyPair?.publicKey;
+      if (keyToUse) {
+        const encrypted = await encryptValue(jsonStr, keyToUse);
+        window.localStorage.setItem(key, encrypted);
+      } else {
+        const { base64Encode: base64Encode2 } = await Promise.resolve().then(() => (init_crypto(), crypto_exports));
+        const encoded = base64Encode2(jsonStr);
+        window.localStorage.setItem(key, encoded);
+      }
+    } catch (error) {
+      console.error("localStorage.set error:", error);
+      throw error;
+    }
+  },
+  /**
+   * 获取值
+   * @param key - 键
+   * @param options - 选项（默认值、私钥等）
+   * @returns Promise<T | undefined> 值或默认值
+   */
+  async get(key, options = {}) {
+    if (typeof window === "undefined" || !window.localStorage) {
+      return options.defaultValue;
+    }
+    const { defaultValue, privateKey } = options;
+    try {
+      const encryptedStr = window.localStorage.getItem(key);
+      if (!encryptedStr) return defaultValue;
+      let decryptedStr;
+      const keyToUse = privateKey || globalKeyPair?.privateKey;
+      if (keyToUse) {
+        try {
+          decryptedStr = await decryptValue(encryptedStr, keyToUse);
+        } catch {
+          const { base64Decode: base64Decode2 } = await Promise.resolve().then(() => (init_crypto(), crypto_exports));
+          try {
+            decryptedStr = base64Decode2(encryptedStr);
+          } catch {
+            return defaultValue;
+          }
+        }
+      } else {
+        const { base64Decode: base64Decode2 } = await Promise.resolve().then(() => (init_crypto(), crypto_exports));
+        try {
+          decryptedStr = base64Decode2(encryptedStr);
+        } catch {
+          return defaultValue;
+        }
+      }
+      const item = JSON.parse(decryptedStr);
+      if (item.expiry && Date.now() > item.expiry) {
+        window.localStorage.removeItem(key);
+        return defaultValue;
+      }
+      return item.value;
+    } catch {
+      return defaultValue;
+    }
+  },
+  /**
+   * 移除值
+   * @param key - 键
+   */
+  remove(key) {
+    if (typeof window === "undefined" || !window.localStorage) return;
+    try {
+      window.localStorage.removeItem(key);
+    } catch (error) {
+      console.error("localStorage.remove error:", error);
+    }
+  },
+  /**
+   * 清空所有值
+   */
+  clear() {
+    if (typeof window === "undefined" || !window.localStorage) return;
+    try {
+      window.localStorage.clear();
+    } catch (error) {
+      console.error("localStorage.clear error:", error);
+    }
+  },
+  /**
+   * 获取所有键
+   * @returns 键数组
+   */
+  keys() {
+    if (typeof window === "undefined" || !window.localStorage) return [];
+    const keys = [];
+    try {
+      for (let i = 0; i < window.localStorage.length; i++) {
+        const key = window.localStorage.key(i);
+        if (key) keys.push(key);
+      }
+    } catch (error) {
+      console.error("localStorage.keys error:", error);
+    }
+    return keys;
+  }
+};
+var sessionStorage = {
+  /**
+   * 设置值
+   * @param key - 键
+   * @param value - 值
+   * @param options - 选项（公钥等）
+   * @returns Promise<void>
+   */
+  async set(key, value, options = {}) {
+    if (typeof window === "undefined" || !window.sessionStorage) {
+      throw new Error("sessionStorage is not available");
+    }
+    const { publicKey } = options;
+    try {
+      const jsonStr = JSON.stringify(value);
+      const keyToUse = publicKey || globalKeyPair?.publicKey;
+      if (keyToUse) {
+        const encrypted = await encryptValue(jsonStr, keyToUse);
+        window.sessionStorage.setItem(key, encrypted);
+      } else {
+        const { base64Encode: base64Encode2 } = await Promise.resolve().then(() => (init_crypto(), crypto_exports));
+        const encoded = base64Encode2(jsonStr);
+        window.sessionStorage.setItem(key, encoded);
+      }
+    } catch (error) {
+      console.error("sessionStorage.set error:", error);
+      throw error;
+    }
+  },
+  /**
+   * 获取值
+   * @param key - 键
+   * @param options - 选项（默认值、私钥等）
+   * @returns Promise<T | undefined> 值或默认值
+   */
+  async get(key, options = {}) {
+    if (typeof window === "undefined" || !window.sessionStorage) {
+      return options.defaultValue;
+    }
+    const { defaultValue, privateKey } = options;
+    try {
+      const encryptedStr = window.sessionStorage.getItem(key);
+      if (!encryptedStr) return defaultValue;
+      let decryptedStr;
+      const keyToUse = privateKey || globalKeyPair?.privateKey;
+      if (keyToUse) {
+        try {
+          decryptedStr = await decryptValue(encryptedStr, keyToUse);
+        } catch {
+          const { base64Decode: base64Decode2 } = await Promise.resolve().then(() => (init_crypto(), crypto_exports));
+          try {
+            decryptedStr = base64Decode2(encryptedStr);
+          } catch {
+            return defaultValue;
+          }
+        }
+      } else {
+        const { base64Decode: base64Decode2 } = await Promise.resolve().then(() => (init_crypto(), crypto_exports));
+        try {
+          decryptedStr = base64Decode2(encryptedStr);
+        } catch {
+          return defaultValue;
+        }
+      }
+      return JSON.parse(decryptedStr);
+    } catch {
+      return defaultValue;
+    }
+  },
+  /**
+   * 移除值
+   * @param key - 键
+   */
+  remove(key) {
+    if (typeof window === "undefined" || !window.sessionStorage) return;
+    try {
+      window.sessionStorage.removeItem(key);
+    } catch (error) {
+      console.error("sessionStorage.remove error:", error);
+    }
+  },
+  /**
+   * 清空所有值
+   */
+  clear() {
+    if (typeof window === "undefined" || !window.sessionStorage) return;
+    try {
+      window.sessionStorage.clear();
+    } catch (error) {
+      console.error("sessionStorage.clear error:", error);
+    }
+  }
+};
+var cookie = {
+  /**
+   * 设置Cookie
+   * @param key - 键
+   * @param value - 值
+   * @param options - Cookie选项
+   */
+  set(key, value, options = {}) {
+    if (typeof document === "undefined") {
+      throw new Error("document is not available");
+    }
+    let cookieStr = `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+    if (options.expires) {
+      const expiresDate = options.expires instanceof Date ? options.expires : new Date(Date.now() + options.expires * 24 * 60 * 60 * 1e3);
+      cookieStr += `; expires=${expiresDate.toUTCString()}`;
+    }
+    if (options.path) cookieStr += `; path=${options.path}`;
+    if (options.domain) cookieStr += `; domain=${options.domain}`;
+    if (options.secure) cookieStr += "; secure";
+    if (options.sameSite) cookieStr += `; sameSite=${options.sameSite}`;
+    document.cookie = cookieStr;
+  },
+  /**
+   * 获取Cookie
+   * @param key - 键
+   * @returns Cookie值
+   */
+  get(key) {
+    if (typeof document === "undefined") return void 0;
+    const name = encodeURIComponent(key);
+    const cookies = document.cookie.split(";");
+    for (const cookie2 of cookies) {
+      const [cookieKey, cookieValue] = cookie2.trim().split("=");
+      if (cookieKey === name) {
+        return decodeURIComponent(cookieValue);
+      }
+    }
+    return void 0;
+  },
+  /**
+   * 移除Cookie
+   * @param key - 键
+   * @param options - Cookie选项
+   */
+  remove(key, options = {}) {
+    cookie.set(key, "", {
+      ...options,
+      expires: /* @__PURE__ */ new Date(0)
+    });
+  },
+  /**
+   * 获取所有Cookie
+   * @returns Cookie对象
+   */
+  getAll() {
+    if (typeof document === "undefined") return {};
+    const cookies = {};
+    document.cookie.split(";").forEach((cookieStr) => {
+      const [key, value] = cookieStr.trim().split("=");
+      if (key && value) {
+        cookies[decodeURIComponent(key)] = decodeURIComponent(value);
+      }
+    });
+    return cookies;
+  }
+};
+var storage = {
+  /**
+   * 设置值（优先使用localStorage，失败则使用sessionStorage）
+   * @param key - 键
+   * @param value - 值
+   * @param options - 选项（过期时间、公钥等）
+   * @returns Promise<void>
+   */
+  async set(key, value, options = {}) {
+    try {
+      await localStorage.set(key, value, options);
+    } catch {
+      try {
+        await sessionStorage.set(key, value, { publicKey: options.publicKey });
+      } catch {
+        console.warn("Both localStorage and sessionStorage are not available");
+      }
+    }
+  },
+  /**
+   * 获取值
+   * @param key - 键
+   * @param options - 选项（默认值、私钥等）
+   * @returns Promise<T | undefined> 值或默认值
+   */
+  async get(key, options = {}) {
+    const localValue = await localStorage.get(key, options);
+    if (localValue !== void 0) return localValue;
+    const sessionValue = await sessionStorage.get(key, options);
+    return sessionValue !== void 0 ? sessionValue : options.defaultValue;
+  },
+  /**
+   * 移除值
+   * @param key - 键
+   */
+  remove(key) {
+    localStorage.remove(key);
+    sessionStorage.remove(key);
+  },
+  /**
+   * 清空所有值
+   */
+  clear() {
+    localStorage.clear();
+    sessionStorage.clear();
+  }
+};
+
+export { cookie, getStorageKeyPair, localStorage, sessionStorage, setStorageKeyPair, storage };

package/dist/{chunk-D7CS5EKF.js → string.cjs}

@@ -106,5 +106,3 @@ exports.snakeCase = snakeCase;
 exports.template = template;
 exports.truncate = truncate;
 exports.unescapeHtml = unescapeHtml;
-//# sourceMappingURL=chunk-D7CS5EKF.js.map
-//# sourceMappingURL=chunk-D7CS5EKF.js.map