@yh-ui/request 0.1.21

package/dist/cache/indexedDB.mjs

@@ -0,0 +1,176 @@
+export class IndexedDBCache {
+  dbName;
+  storeName;
+  dbVersion;
+  db = null;
+  constructor(options = {}) {
+    this.dbName = options.dbName || "yh_request_cache";
+    this.storeName = options.storeName || "cache";
+    this.dbVersion = options.dbVersion || 1;
+  }
+  /**
+   * 打开数据库
+   */
+  async openDB() {
+    if (this.db) return this.db;
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(this.dbName, this.dbVersion);
+      request.onerror = () => {
+        reject(request.error);
+      };
+      request.onsuccess = () => {
+        this.db = request.result;
+        resolve(this.db);
+      };
+      request.onupgradeneeded = (event) => {
+        const db = event.target.result;
+        if (!db.objectStoreNames.contains(this.storeName)) {
+          db.createObjectStore(this.storeName, { keyPath: "key" });
+        }
+      };
+    });
+  }
+  /**
+   * 获取缓存
+   */
+  async get(key, _staleTime) {
+    try {
+      const db = await this.openDB();
+      const transaction = db.transaction(this.storeName, "readonly");
+      const store = transaction.objectStore(this.storeName);
+      const request = store.get(key);
+      return new Promise((resolve, reject) => {
+        request.onsuccess = () => {
+          if (!request.result) {
+            resolve(void 0);
+            return;
+          }
+          const item = request.result;
+          if (item.expireTime && Date.now() > item.expireTime) {
+            this.delete(key);
+            resolve(void 0);
+            return;
+          }
+          resolve(item.data);
+        };
+        request.onerror = () => {
+          reject(request.error);
+        };
+      });
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * 设置缓存
+   */
+  async set(key, data, options = {}) {
+    try {
+      const { staleTime = 5 * 60 * 1e3 } = options;
+      const now = Date.now();
+      const item = {
+        data,
+        expireTime: now + staleTime,
+        createTime: now
+      };
+      const db = await this.openDB();
+      const transaction = db.transaction(this.storeName, "readwrite");
+      const store = transaction.objectStore(this.storeName);
+      store.put({ key, ...item });
+      await new Promise((resolve, reject) => {
+        transaction.oncomplete = () => resolve();
+        transaction.onerror = () => reject(transaction.error);
+      });
+    } catch (error) {
+      console.warn("IndexedDB cache set failed:", error);
+    }
+  }
+  /**
+   * 删除缓存
+   */
+  async delete(key) {
+    try {
+      const db = await this.openDB();
+      const transaction = db.transaction(this.storeName, "readwrite");
+      const store = transaction.objectStore(this.storeName);
+      store.delete(key);
+      await new Promise((resolve, reject) => {
+        transaction.oncomplete = () => resolve();
+        transaction.onerror = () => reject(transaction.error);
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * 清空缓存
+   */
+  async clear() {
+    try {
+      const db = await this.openDB();
+      const transaction = db.transaction(this.storeName, "readwrite");
+      const store = transaction.objectStore(this.storeName);
+      store.clear();
+      await new Promise((resolve, reject) => {
+        transaction.oncomplete = () => resolve();
+        transaction.onerror = () => reject(transaction.error);
+      });
+    } catch {
+    }
+  }
+  /**
+   * 检查缓存是否存在
+   */
+  async has(key) {
+    const data = await this.get(key);
+    return data !== void 0;
+  }
+  /**
+   * 获取所有缓存 keys
+   */
+  async keys() {
+    try {
+      const db = await this.openDB();
+      const transaction = db.transaction(this.storeName, "readonly");
+      const store = transaction.objectStore(this.storeName);
+      const request = store.getAllKeys();
+      return new Promise((resolve, reject) => {
+        request.onsuccess = () => {
+          resolve(request.result);
+        };
+        request.onerror = () => {
+          reject(request.error);
+        };
+      });
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * 清理过期缓存
+   */
+  async cleanup() {
+    try {
+      const db = await this.openDB();
+      const transaction = db.transaction(this.storeName, "readwrite");
+      const store = transaction.objectStore(this.storeName);
+      const request = store.getAll();
+      await new Promise((resolve, reject) => {
+        request.onsuccess = async () => {
+          const now = Date.now();
+          const items = request.result;
+          for (const item of items) {
+            if (item.expireTime && now > item.expireTime) {
+              store.delete(item.key);
+            }
+          }
+          resolve();
+        };
+        request.onerror = () => reject(request.error);
+      });
+    } catch {
+    }
+  }
+}
+export const indexedDBCache = new IndexedDBCache();

package/dist/cache/localStorage.cjs

@@ -0,0 +1,158 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.localStorageCache = exports.LocalStorageCache = void 0;
+class LocalStorageCache {
+  prefix;
+  maxSize;
+  constructor(options = {}) {
+    this.prefix = options.prefix || "yh_request_cache_";
+    this.maxSize = options.maxSize || 5 * 1024 * 1024;
+  }
+  /**
+   * 生成存储 key
+   */
+  getStorageKey(key) {
+    return `${this.prefix}${key}`;
+  }
+  /**
+   * 获取缓存
+   */
+  get(key, _staleTime) {
+    try {
+      const storageKey = this.getStorageKey(key);
+      const itemStr = localStorage.getItem(storageKey);
+      if (!itemStr) return void 0;
+      const item = JSON.parse(itemStr);
+      if (item.expireTime && Date.now() > item.expireTime) {
+        this.delete(key);
+        return void 0;
+      }
+      return item.data;
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * 设置缓存
+   */
+  set(key, data, options = {}) {
+    try {
+      const {
+        staleTime = 5 * 60 * 1e3
+      } = options;
+      const now = Date.now();
+      const item = {
+        data,
+        expireTime: now + staleTime,
+        createTime: now
+      };
+      const storageKey = this.getStorageKey(key);
+      const itemStr = JSON.stringify(item);
+      if (this.calculateSize() + itemStr.length > this.maxSize) {
+        this.cleanup();
+      }
+      localStorage.setItem(storageKey, itemStr);
+    } catch (error) {
+      console.warn("LocalStorage cache set failed:", error);
+    }
+  }
+  /**
+   * 删除缓存
+   */
+  delete(key) {
+    try {
+      const storageKey = this.getStorageKey(key);
+      localStorage.removeItem(storageKey);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * 清空缓存
+   */
+  clear() {
+    try {
+      const keys = this.keys();
+      keys.forEach(key => {
+        localStorage.removeItem(this.getStorageKey(key));
+      });
+    } catch {}
+  }
+  /**
+   * 检查缓存是否存在
+   */
+  has(key) {
+    return this.get(key) !== void 0;
+  }
+  /**
+   * 获取所有缓存 keys
+   */
+  keys() {
+    const result = [];
+    try {
+      for (let i = 0; i < localStorage.length; i++) {
+        const key = localStorage.key(i);
+        if (key && key.startsWith(this.prefix)) {
+          result.push(key.slice(this.prefix.length));
+        }
+      }
+    } catch {}
+    return result;
+  }
+  /**
+   * 计算当前存储使用量
+   */
+  calculateSize() {
+    let size = 0;
+    try {
+      for (let i = 0; i < localStorage.length; i++) {
+        const key = localStorage.key(i);
+        if (key && key.startsWith(this.prefix)) {
+          const value = localStorage.getItem(key);
+          if (value) {
+            size += key.length + value.length;
+          }
+        }
+      }
+    } catch {}
+    return size;
+  }
+  /**
+   * 清理过期缓存
+   */
+  cleanup() {
+    const keys = this.keys();
+    const now = Date.now();
+    for (const key of keys) {
+      try {
+        const storageKey = this.getStorageKey(key);
+        const itemStr = localStorage.getItem(storageKey);
+        if (itemStr) {
+          const item = JSON.parse(itemStr);
+          if (item.expireTime && now > item.expireTime) {
+            localStorage.removeItem(storageKey);
+          }
+        }
+      } catch {}
+    }
+    if (this.calculateSize() > this.maxSize) {
+      const sortedKeys = keys.sort((a, b) => {
+        const itemA = this.get(a);
+        const itemB = this.get(b);
+        const timeA = itemA ? itemA.createTime || 0 : 0;
+        const timeB = itemB ? itemB.createTime || 0 : 0;
+        return timeA - timeB;
+      });
+      const removeCount = Math.ceil(keys.length * 0.2);
+      for (let i = 0; i < removeCount; i++) {
+        this.delete(sortedKeys[i]);
+      }
+    }
+  }
+}
+exports.LocalStorageCache = LocalStorageCache;
+const localStorageCache = exports.localStorageCache = new LocalStorageCache();

package/dist/cache/localStorage.d.ts

@@ -0,0 +1,58 @@
+/**
+ * LocalStorage 缓存实现
+ * 适用于小量数据的持久化缓存
+ */
+export interface LocalStorageCacheOptions {
+    /** 缓存前缀 */
+    prefix?: string;
+    /** 存储上限 (bytes) */
+    maxSize?: number;
+}
+/**
+ * LocalStorage 缓存类
+ */
+export declare class LocalStorageCache {
+    private prefix;
+    private maxSize;
+    constructor(options?: LocalStorageCacheOptions);
+    /**
+     * 生成存储 key
+     */
+    private getStorageKey;
+    /**
+     * 获取缓存
+     */
+    get<T>(key: string, _staleTime?: number): T | undefined;
+    /**
+     * 设置缓存
+     */
+    set<T>(key: string, data: T, options?: {
+        staleTime?: number;
+        cacheTime?: number;
+    }): void;
+    /**
+     * 删除缓存
+     */
+    delete(key: string): boolean;
+    /**
+     * 清空缓存
+     */
+    clear(): void;
+    /**
+     * 检查缓存是否存在
+     */
+    has(key: string): boolean;
+    /**
+     * 获取所有缓存 keys
+     */
+    keys(): string[];
+    /**
+     * 计算当前存储使用量
+     */
+    private calculateSize;
+    /**
+     * 清理过期缓存
+     */
+    private cleanup;
+}
+export declare const localStorageCache: LocalStorageCache;

package/dist/cache/localStorage.mjs

@@ -0,0 +1,153 @@
+export class LocalStorageCache {
+  prefix;
+  maxSize;
+  constructor(options = {}) {
+    this.prefix = options.prefix || "yh_request_cache_";
+    this.maxSize = options.maxSize || 5 * 1024 * 1024;
+  }
+  /**
+   * 生成存储 key
+   */
+  getStorageKey(key) {
+    return `${this.prefix}${key}`;
+  }
+  /**
+   * 获取缓存
+   */
+  get(key, _staleTime) {
+    try {
+      const storageKey = this.getStorageKey(key);
+      const itemStr = localStorage.getItem(storageKey);
+      if (!itemStr) return void 0;
+      const item = JSON.parse(itemStr);
+      if (item.expireTime && Date.now() > item.expireTime) {
+        this.delete(key);
+        return void 0;
+      }
+      return item.data;
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * 设置缓存
+   */
+  set(key, data, options = {}) {
+    try {
+      const { staleTime = 5 * 60 * 1e3 } = options;
+      const now = Date.now();
+      const item = {
+        data,
+        expireTime: now + staleTime,
+        createTime: now
+      };
+      const storageKey = this.getStorageKey(key);
+      const itemStr = JSON.stringify(item);
+      if (this.calculateSize() + itemStr.length > this.maxSize) {
+        this.cleanup();
+      }
+      localStorage.setItem(storageKey, itemStr);
+    } catch (error) {
+      console.warn("LocalStorage cache set failed:", error);
+    }
+  }
+  /**
+   * 删除缓存
+   */
+  delete(key) {
+    try {
+      const storageKey = this.getStorageKey(key);
+      localStorage.removeItem(storageKey);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * 清空缓存
+   */
+  clear() {
+    try {
+      const keys = this.keys();
+      keys.forEach((key) => {
+        localStorage.removeItem(this.getStorageKey(key));
+      });
+    } catch {
+    }
+  }
+  /**
+   * 检查缓存是否存在
+   */
+  has(key) {
+    return this.get(key) !== void 0;
+  }
+  /**
+   * 获取所有缓存 keys
+   */
+  keys() {
+    const result = [];
+    try {
+      for (let i = 0; i < localStorage.length; i++) {
+        const key = localStorage.key(i);
+        if (key && key.startsWith(this.prefix)) {
+          result.push(key.slice(this.prefix.length));
+        }
+      }
+    } catch {
+    }
+    return result;
+  }
+  /**
+   * 计算当前存储使用量
+   */
+  calculateSize() {
+    let size = 0;
+    try {
+      for (let i = 0; i < localStorage.length; i++) {
+        const key = localStorage.key(i);
+        if (key && key.startsWith(this.prefix)) {
+          const value = localStorage.getItem(key);
+          if (value) {
+            size += key.length + value.length;
+          }
+        }
+      }
+    } catch {
+    }
+    return size;
+  }
+  /**
+   * 清理过期缓存
+   */
+  cleanup() {
+    const keys = this.keys();
+    const now = Date.now();
+    for (const key of keys) {
+      try {
+        const storageKey = this.getStorageKey(key);
+        const itemStr = localStorage.getItem(storageKey);
+        if (itemStr) {
+          const item = JSON.parse(itemStr);
+          if (item.expireTime && now > item.expireTime) {
+            localStorage.removeItem(storageKey);
+          }
+        }
+      } catch {
+      }
+    }
+    if (this.calculateSize() > this.maxSize) {
+      const sortedKeys = keys.sort((a, b) => {
+        const itemA = this.get(a);
+        const itemB = this.get(b);
+        const timeA = itemA ? itemA.createTime || 0 : 0;
+        const timeB = itemB ? itemB.createTime || 0 : 0;
+        return timeA - timeB;
+      });
+      const removeCount = Math.ceil(keys.length * 0.2);
+      for (let i = 0; i < removeCount; i++) {
+        this.delete(sortedKeys[i]);
+      }
+    }
+  }
+}
+export const localStorageCache = new LocalStorageCache();

package/dist/cache/memory.cjs

@@ -0,0 +1,112 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.memoryCache = exports.MemoryCache = void 0;
+class MemoryCache {
+  cache = /* @__PURE__ */new Map();
+  cleanupTimer = null;
+  /**
+   * 获取缓存
+   */
+  get(key, _staleTime) {
+    const item = this.cache.get(key);
+    if (!item) return void 0;
+    const now = Date.now();
+    if (item.expireTime && now > item.expireTime) {
+      this.cache.delete(key);
+      return void 0;
+    }
+    return item.data;
+  }
+  /**
+   * 设置缓存
+   */
+  set(key, data, options = {}) {
+    const {
+      staleTime = 5 * 60 * 1e3,
+      cacheTime = 10 * 60 * 1e3
+    } = options;
+    const now = Date.now();
+    this.cache.set(key, {
+      data,
+      expireTime: now + staleTime,
+      createTime: now
+    });
+    setTimeout(() => {
+      const item = this.cache.get(key);
+      if (item && item.expireTime <= Date.now()) {
+        this.cache.delete(key);
+      }
+    }, cacheTime);
+  }
+  /**
+   * 删除缓存
+   */
+  delete(key) {
+    return this.cache.delete(key);
+  }
+  /**
+   * 清空缓存
+   */
+  clear() {
+    this.cache.clear();
+  }
+  /**
+   * 检查缓存是否存在
+   */
+  has(key) {
+    const item = this.cache.get(key);
+    if (!item) return false;
+    if (item.expireTime && Date.now() > item.expireTime) {
+      this.cache.delete(key);
+      return false;
+    }
+    return true;
+  }
+  /**
+   * 通过标签清除缓存
+   */
+  deleteByTags(_tags) {}
+  /**
+   * 获取缓存大小
+   */
+  size() {
+    return this.cache.size;
+  }
+  /**
+   * 批量获取缓存 keys
+   */
+  keys() {
+    return Array.from(this.cache.keys());
+  }
+  /**
+   * 启动定时清理
+   */
+  startCleanup(interval = 60 * 1e3) {
+    if (this.cleanupTimer) return;
+    this.cleanupTimer = setInterval(() => {
+      const now = Date.now();
+      for (const [key, item] of this.cache.entries()) {
+        if (item.expireTime && now > item.expireTime) {
+          this.cache.delete(key);
+        }
+      }
+    }, interval);
+  }
+  /**
+   * 停止定时清理
+   */
+  stopCleanup() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+  }
+}
+exports.MemoryCache = MemoryCache;
+const memoryCache = exports.memoryCache = new MemoryCache();
+if (typeof window !== "undefined") {
+  memoryCache.startCleanup();
+}