super-toolkit 1.0.2 → 1.0.5

package/src/file.ts

@@ -1,108 +1,200 @@
 
-/* file转base64 */
-export function fileToBase64(file: File | Blob): Promise<string> {
-  return new Promise<string>((resolve, reject) => {
-    const reader = new FileReader();
-    reader.readAsDataURL(file); //发起异步请求
-    reader.onload = function (readRes) {
-      resolve(readRes.target?.result as string)
-    };
-  })
+/** 
+ * 文件转 Base64
+ * @param file 文件或 Blob 对象
+ * @param callback 回调函数
+ */
+export function fileToBase64(file: File | Blob, callback: (error: Error | null, result: string | null) => void): void {
+  if (!file) {
+    callback(new Error('File is required'), null);
+    return;
+  }
+  
+  var reader = new FileReader();
+  reader.readAsDataURL(file);
+  
+  reader.onload = function (readRes: any) {
+    if (readRes.target && readRes.target.result) {
+      callback(null, readRes.target.result);
+    } else {
+      callback(new Error('Failed to convert file to base64'), null);
+    }
+  };
+  
+  reader.onerror = function () {
+    callback(new Error('Error reading file'), null);
+  };
+}
+
+/** 
+ * Base64 转 Blob
+ * @param dataURL Base64 字符串
+ * @param mimeType MIME 类型
+ * @returns Blob 对象
+ */
+export function base64ToBlob(dataURL: string, mimeType: string = ""): Blob {
+  if (!dataURL || typeof dataURL !== 'string') {
+    throw new Error('Invalid dataURL');
+  }
+  
+  var arr = dataURL.split(',');
+  if (arr.length < 2) {
+    throw new Error('Invalid dataURL format');
+  }
+  
+  var match = arr[0].match(/:(.*?);/);
+  if (!match) {
+    throw new Error('Invalid dataURL format');
+  }
+  
+  var defaultMimeType = match[1];
+  var bStr = atob(arr[1]);
+  var n = bStr.length;
+  var u8arr = new Uint8Array(n);
+  
+  for (var i = 0; i < n; i++) {
+    u8arr[i] = bStr.charCodeAt(i);
+  }
+  
+  return new Blob([u8arr], { type: mimeType || defaultMimeType });
 }
 
-/* base64转blob */
-export function base64ToBlob(dataURL: string, mimeType = "") {
-  let arr: any = dataURL.split(','),
-    defaultMimeType = arr[0].match(/:(.*?);/)[1],
-    bStr = atob(arr[1]),
-    n = bStr.length,
-    u8arr = new Uint8Array(n)
-  while (n--) {
-    u8arr[n] = bStr.charCodeAt(n)
+/** 
+ * Blob 转 File
+ * @param blob Blob 对象
+ * @param fileName 文件名
+ * @param mimeType MIME 类型
+ * @returns File 对象
+ */
+export function blobToFile(blob: Blob, fileName: string, mimeType: string = blob.type): File {
+  if (!blob || !fileName) {
+    throw new Error('Blob and fileName are required');
   }
-  return new Blob([u8arr], { type: mimeType || defaultMimeType })
+  
+  return new File([blob], fileName, { type: mimeType });
 }
 
-/* blob转file */
-export function blobToFile(blob: Blob, fileName: string, mimeType: string) {
-  return new File([blob], fileName, { type: mimeType })
+/** 
+ * Base64 转 File
+ * @param dataURL Base64 字符串
+ * @param fileName 文件名
+ * @param mimeType MIME 类型
+ * @returns File 对象
+ */
+export function base64ToFile(dataURL: string, fileName: string, mimeType: string = ""): File {
+  if (!dataURL || !fileName) {
+    throw new Error('dataURL and fileName are required');
+  }
+  
+  var blob = base64ToBlob(dataURL, mimeType);
+  return blobToFile(blob, fileName, mimeType || blob.type);
+}
+
+// 缓存文件类型映射
+var MIME_TYPE_MAP: Record<string, string> = {
+  'doc': 'application/msword',
+  'docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  'dot': 'application/msword',
+  'dotx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.template',
+  'xls': 'application/vnd.ms-excel',
+  'xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+  'ppt': 'application/vnd.ms-powerpoint',
+  'pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+  'pdf': 'application/pdf',
+  'txt': 'text/plain',
+  'gif': 'image/gif',
+  'jpeg': 'image/jpeg',
+  'jpg': 'image/jpeg',
+  'png': 'image/png',
+  'css': 'text/css',
+  'html': 'text/html',
+  'htm': 'text/html',
+  'xsl': 'text/xml',
+  'xml': 'text/xml',
+  'mpeg': 'video/mpeg',
+  'mpg': 'video/mpeg',
+  'avi': 'video/x-msvideo',
+  'movie': 'video/x-sgi-movie',
+  'bin': 'application/octet-stream',
+  'exe': 'application/octet-stream',
+  'so': 'application/octet-stream',
+  'dll': 'application/octet-stream',
+  'ai': 'application/postscript',
+  'dir': 'application/x-director',
+  'js': 'application/x-javascript',
+  'swf': 'application/x-shockwave-flash',
+  'xhtml': 'application/xhtml+xml',
+  'xht': 'application/xhtml+xml',
+  'zip': 'application/zip',
+  'mid': 'audio/midi',
+  'midi': 'audio/midi',
+  'mp3': 'audio/mpeg',
+  'rm': 'audio/x-pn-realaudio',
+  'rpm': 'audio/x-pn-realaudio-plugin',
+  'wav': 'audio/x-wav',
+  'bmp': 'image/bmp'
+};
+
+/** 
+ * 获取指定 URL 文件的 MIME 类型
+ * @param url 文件 URL
+ * @returns MIME 类型字符串或 null
+ */
+export function getApplication(url: string): string | null {
+  if (!url || typeof url !== 'string') {
+    return null;
+  }
+  
+  var parts = url.split('.');
+  var type = parts.length > 0 ? parts[parts.length - 1].toLowerCase() : null;
+  if (!type) {
+    return null;
+  }
+  
+  return MIME_TYPE_MAP[type] || null;
 }
 
-/* base64转file */
-export function base64ToFile(dataURL: string, fileName: string, mimeType = "") {
-  let arr: any = dataURL.split(','),
-    defaultMimeType = arr[0].match(/:(.*?);/)[1],
-    bStr = atob(arr[1]),
-    n = bStr.length,
-    u8arr = new Uint8Array(n)
-  while (n--) {
-    u8arr[n] = bStr.charCodeAt(n)
+/** 
+ * 下载文件
+ * @param data 文件数据（Blob 或 File）
+ * @param fileName 文件名
+ */
+export function downloadFile(data: Blob | File, fileName: string): void {
+  if (!data || !fileName) {
+    throw new Error('Data and fileName are required');
   }
-  return new File([u8arr], fileName, { type: mimeType || defaultMimeType })
+  
+  var url = URL.createObjectURL(data);
+  var link = document.createElement('a');
+  link.href = url;
+  link.download = fileName;
+  document.body.appendChild(link);
+  link.click();
+  document.body.removeChild(link);
+  URL.revokeObjectURL(url);
 }
 
-/** 获取指定url文件的application  */
-export function getApplication(url: string) {
-  let applications = [
-    { type: "doc", application: "application/msword" },
-    {
-      type: "docx",
-      application:
-        "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
-    },
-    { type: "dot", application: "application/msword" },
-    {
-      type: "dotx",
-      application:
-        "application/vnd.openxmlformats-officedocument.wordprocessingml.template"
-    },
-    { type: "xls", application: "application/vnd.ms-excel" },
-    {
-      type: "xlsx",
-      application:
-        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
-    },
-    { type: "ppt", application: "application/vnd.ms-powerpoint" },
-    {
-      type: "pptx",
-      application:
-        "application/vnd.openxmlformats-officedocument.presentationml.presentation"
-    },
-    { type: "pdf", application: "application/pdf" },
-    { type: "txt", application: "text/plain" },
-    { type: "gif", application: "image/gif" },
-    { type: "jpeg", application: "image/jpeg" },
-    { type: "jpg", application: "image/jpeg" },
-    { type: "png", application: "image/png" },
-    { type: "css", application: "text/css" },
-    { type: "html", application: "text/html" },
-    { type: "htm", application: "text/html" },
-    { type: "xsl", application: "text/xml" },
-    { type: "xml", application: "text/xml" },
-    { type: "mpeg", application: "video/mpeg" },
-    { type: "mpg", application: "video/mpeg" },
-    { type: "avi", application: "video/x-msvideo" },
-    { type: "movie", application: "video/x-sgi-movie" },
-    { type: "bin", application: "application/octet-stream" },
-    { type: "exe", application: "application/octet-stream" },
-    { type: "so", application: "application/octet-stream" },
-    { type: "dll", application: "application/octet-stream" },
-    { type: "ai", application: "application/postscript" },
-    { type: "dir", application: "application/x-director" },
-    { type: "js", application: "application/x-javascript" },
-    { type: "swf", application: "application/x-shockwave-flash" },
-    { type: "xhtml", application: "application/xhtml+xml" },
-    { type: "xht", application: "application/xhtml+xml" },
-    { type: "zip", application: "application/zip" },
-    { type: "mid", application: "audio/midi" },
-    { type: "midi", application: "audio/midi" },
-    { type: "mp3", application: "audio/mpeg" },
-    { type: "rm", application: "audio/x-pn-realaudio" },
-    { type: "rpm", application: "audio/x-pn-realaudio-plugin" },
-    { type: "wav", application: "audio/x-wav" },
-    { type: "bmp", application: "image/bmp" }
-  ];
-  let type = url.split('.').pop();
-  const row = applications.find(t => t.type == type)
-  return row?.type || null
+/** 
+ * 从 URL 获取文件
+ * @param url 文件 URL
+ * @param callback 回调函数
+ */
+export function getFileFromUrl(url: string, callback: (error: Error | null, result: Blob | null) => void): void {
+  var xhr = new XMLHttpRequest();
+  xhr.open('GET', url, true);
+  xhr.responseType = 'blob';
+  
+  xhr.onload = function() {
+    if (xhr.status === 200) {
+      callback(null, xhr.response);
+    } else {
+      callback(new Error('HTTP error! status: ' + xhr.status), null);
+    }
+  };
+  
+  xhr.onerror = function() {
+    callback(new Error('Network error'), null);
+  };
+  
+  xhr.send();
 }

package/src/localStorage.ts

@@ -1,24 +1,182 @@
-const getLocalStorage = <T>(key: string): T | null => {
-  if (!window) {
-    throw new Error('非web环境禁止使用localStorage')
+/** 
+ * 检查是否支持 localStorage
+ * @returns 是否支持 localStorage
+ */
+const isLocalStorageSupported = (): boolean => {
+  if (typeof window === 'undefined') {
+    return false;
   }
+  
+  try {
+    const testKey = '__localStorage_test__';
+    localStorage.setItem(testKey, testKey);
+    localStorage.removeItem(testKey);
+    return true;
+  } catch (error) {
+    return false;
+  }
+};
+
+/** 
+ * 获取 localStorage 数据
+ * @param key 存储键名
+ * @param defaultValue 默认值
+ * @returns 存储的数据或默认值
+ */
+export function getLocalStorage<T>(key: string, defaultValue?: T): T | null {
+  if (!isLocalStorageSupported()) {
+    console.warn('localStorage is not supported in this environment');
+    return defaultValue || null;
+  }
+  
   if (!key) {
-    throw new Error('key的值不能为空')
+    throw new Error('key cannot be empty');
+  }
+  
+  try {
+    const data = localStorage.getItem(key);
+    return data ? JSON.parse(data) : (defaultValue || null);
+  } catch (error) {
+    console.error('Error getting data from localStorage:', error);
+    return defaultValue || null;
   }
-  const data = localStorage.getItem(key)
-  return data ? JSON.parse(data) : null
 }
-const setLocalStorage = <T = any>(key: string, value: T): void => {
-  if (!window) {
-    throw new Error('非web环境禁止使用localStorage')
+
+/** 
+ * 设置 localStorage 数据
+ * @param key 存储键名
+ * @param value 存储数据
+ * @param expire 过期时间（毫秒）
+ */
+export function setLocalStorage<T = any>(key: string, value: T, expire?: number): void {
+  if (!isLocalStorageSupported()) {
+    console.warn('localStorage is not supported in this environment');
+    return;
+  }
+  
+  if (!key) {
+    throw new Error('key cannot be empty');
   }
-  if (!(key && value)) {
-    throw new Error('key or value的值不能为空')
+  
+  try {
+    const data = {
+      value,
+      expire: expire ? Date.now() + expire : null
+    };
+    localStorage.setItem(key, JSON.stringify(data));
+  } catch (error) {
+    console.error('Error setting data to localStorage:', error);
+    // 处理存储容量不足的情况
+    if ((error as Error).name === 'QuotaExceededError') {
+      console.warn('localStorage quota exceeded, trying to clear old data');
+      // 这里可以添加清理策略
+    }
+  }
+}
+
+/** 
+ * 移除 localStorage 数据
+ * @param key 存储键名
+ */
+export function removeLocalStorage(key: string): void {
+  if (!isLocalStorageSupported()) {
+    console.warn('localStorage is not supported in this environment');
+    return;
+  }
+  
+  if (!key) {
+    throw new Error('key cannot be empty');
   }
-  const data = JSON.stringify(value)
-  localStorage.setItem(key, data)
+  
+  try {
+    localStorage.removeItem(key);
+  } catch (error) {
+    console.error('Error removing data from localStorage:', error);
+  }
+}
+
+/** 
+ * 清空所有 localStorage 数据
+ */
+export function clearLocalStorage(): void {
+  if (!isLocalStorageSupported()) {
+    console.warn('localStorage is not supported in this environment');
+    return;
+  }
+  
+  try {
+    localStorage.clear();
+  } catch (error) {
+    console.error('Error clearing localStorage:', error);
+  }
+}
+
+/** 
+ * 获取所有 localStorage 键名
+ * @returns 键名数组
+ */
+export function getLocalStorageKeys(): string[] {
+  if (!isLocalStorageSupported()) {
+    console.warn('localStorage is not supported in this environment');
+    return [];
+  }
+  
+  try {
+    const keys: string[] = [];
+    for (let i = 0; i < localStorage.length; i++) {
+      const key = localStorage.key(i);
+      if (key) {
+        keys.push(key);
+      }
+    }
+    return keys;
+  } catch (error) {
+    console.error('Error getting localStorage keys:', error);
+    return [];
+  }
+}
+
+/** 
+ * 创建带命名空间的 localStorage 操作
+ * @param namespace 命名空间
+ * @returns 命名空间化的 localStorage 操作方法
+ */
+export function createNamespacedStorage(namespace: string) {
+  const prefix = `${namespace}:`;
+  
+  return {
+    get: <T>(key: string, defaultValue?: T): T | null => {
+      return getLocalStorage(`${prefix}${key}`, defaultValue);
+    },
+    set: <T = any>(key: string, value: T, expire?: number): void => {
+      setLocalStorage(`${prefix}${key}`, value, expire);
+    },
+    remove: (key: string): void => {
+      removeLocalStorage(`${prefix}${key}`);
+    },
+    clear: (): void => {
+      const keys = getLocalStorageKeys();
+      keys.forEach(key => {
+        if (key.startsWith(prefix)) {
+          removeLocalStorage(key);
+        }
+      });
+    },
+    keys: (): string[] => {
+      const keys = getLocalStorageKeys();
+      return keys
+        .filter(key => key.startsWith(prefix))
+        .map(key => key.replace(prefix, ''));
+    }
+  };
 }
-export {
-  getLocalStorage,
-  setLocalStorage
-}
+
+// 导出默认方法
+export default {
+  get: getLocalStorage,
+  set: setLocalStorage,
+  remove: removeLocalStorage,
+  clear: clearLocalStorage,
+  keys: getLocalStorageKeys,
+  createNamespaced: createNamespacedStorage
+};

package/src/random.ts

@@ -0,0 +1,161 @@
+/** 
+ * 随机生成16进制颜色
+ * @returns 16进制颜色字符串
+ */
+export function getRandomColor(): string {
+  // 使用更兼容的实现方式
+  const color = Math.floor(Math.random() * 0xFFFFFF).toString(16);
+  // 手动补零，确保长度为6
+  const paddedColor = '000000'.substring(0, 6 - color.length) + color;
+  return '#' + paddedColor;
+}
+
+/** 
+ * 随机生成指定长度的字符串
+ * @param length 字符串长度
+ * @param options 配置选项
+ * @returns 随机字符串
+ */
+export function getRandomString(
+  length: number,
+  options: {
+    includeLetters?: boolean;
+    includeNumbers?: boolean;
+    includeSymbols?: boolean;
+    caseSensitive?: boolean;
+  } = {}
+): string {
+  // 参数验证
+  if (typeof length !== 'number' || length < 1) {
+    throw new Error('Length must be a positive number');
+  }
+  
+  const { 
+    includeLetters = true, 
+    includeNumbers = true, 
+    includeSymbols = false, 
+    caseSensitive = true 
+  } = options;
+  
+  // 定义字符集
+  let charset = '';
+  
+  if (includeLetters) {
+    charset += caseSensitive ? 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' : 'abcdefghijklmnopqrstuvwxyz';
+  }
+  
+  if (includeNumbers) {
+    charset += '0123456789';
+  }
+  
+  if (includeSymbols) {
+    charset += '!@#$%^&*()_+-=[]{}|;:,.<>?';
+  }
+  
+  if (charset.length === 0) {
+    throw new Error('At least one character set must be included');
+  }
+  
+  // 生成随机字符串
+  let result = '';
+  for (let i = 0; i < length; i++) {
+    const randomIndex = Math.floor(Math.random() * charset.length);
+    result += charset[randomIndex];
+  }
+  
+  return result;
+}
+
+/** 
+ * 生成指定范围内的随机整数
+ * @param min 最小值（包含）
+ * @param max 最大值（包含）
+ * @returns 随机整数
+ */
+export function getRandomInt(min: number, max: number): number {
+  // 参数验证
+  if (typeof min !== 'number' || typeof max !== 'number') {
+    throw new Error('Min and max must be numbers');
+  }
+  
+  if (min > max) {
+    [min, max] = [max, min];
+  }
+  
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+/** 
+ * 生成指定范围内的随机浮点数
+ * @param min 最小值
+ * @param max 最大值
+ * @param decimals 小数位数
+ * @returns 随机浮点数
+ */
+export function getRandomFloat(min: number, max: number, decimals: number = 2): number {
+  // 参数验证
+  if (typeof min !== 'number' || typeof max !== 'number') {
+    throw new Error('Min and max must be numbers');
+  }
+  
+  if (min > max) {
+    [min, max] = [max, min];
+  }
+  
+  const random = Math.random() * (max - min) + min;
+  return parseFloat(random.toFixed(decimals));
+}
+
+/** 
+ * 从数组中随机选择一个元素
+ * @param array 源数组
+ * @returns 随机选中的元素
+ */
+export function getRandomElement<T>(array: T[]): T | undefined {
+  // 参数验证
+  if (!Array.isArray(array) || array.length === 0) {
+    return undefined;
+  }
+  
+  const randomIndex = Math.floor(Math.random() * array.length);
+  return array[randomIndex];
+}
+
+/** 
+ * 随机打乱数组
+ * @param array 源数组
+ * @returns 打乱后的新数组
+ */
+export function shuffleArray<T>(array: T[]): T[] {
+  // 参数验证
+  if (!Array.isArray(array)) {
+    throw new Error('Input must be an array');
+  }
+  
+  // 创建数组副本
+  const result = [...array];
+  
+  // Fisher-Yates 洗牌算法
+  for (let i = result.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [result[i], result[j]] = [result[j], result[i]];
+  }
+  
+  return result;
+}
+
+/** 
+ * 生成指定长度的随机ID
+ * @param prefix ID前缀
+ * @param length 随机部分长度
+ * @returns 随机ID
+ */
+export function generateRandomId(prefix: string = '', length: number = 8): string {
+  const randomPart = getRandomString(length, {
+    includeLetters: true,
+    includeNumbers: true,
+    caseSensitive: true
+  });
+  
+  return prefix ? `${prefix}_${randomPart}` : randomPart;
+}