@yh-ui/request 0.1.21

package/dist/adapters/platform.mjs

@@ -0,0 +1,369 @@
+export function detectPlatform() {
+  const globalObj = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : {};
+  if (typeof Deno !== "undefined") {
+    return {
+      environment: "deno",
+      supportsFetch: true,
+      supportsFormData: true,
+      supportsAbortController: true
+    };
+  }
+  if (typeof Bun !== "undefined") {
+    return {
+      environment: "bun",
+      supportsFetch: true,
+      supportsFormData: true,
+      supportsAbortController: true
+    };
+  }
+  if (globalObj.edgeRuntime !== void 0 || typeof navigator !== "undefined" && navigator.userAgent.includes("Cloudflare") || globalObj.caches !== void 0) {
+    return {
+      environment: "edge",
+      supportsFetch: true,
+      supportsFormData: true,
+      supportsAbortController: true
+    };
+  }
+  if (typeof process !== "undefined" && process.versions?.node) {
+    return {
+      environment: "node",
+      supportsFetch: typeof fetch !== "undefined",
+      supportsFormData: typeof FormData !== "undefined",
+      supportsAbortController: typeof AbortController !== "undefined"
+    };
+  }
+  return {
+    environment: "browser",
+    supportsFetch: typeof fetch !== "undefined",
+    supportsFormData: typeof FormData !== "undefined",
+    supportsAbortController: typeof AbortController !== "undefined"
+  };
+}
+export const platform = detectPlatform();
+export class NodeHttpAdapter {
+  name = "node-http";
+  http = NodeHttpAdapter.getHttpModule();
+  static getHttpModule() {
+    try {
+      return require("http");
+    } catch {
+      throw new Error("Node.js http module is not available");
+    }
+  }
+  isSupported() {
+    return typeof process !== "undefined" && !!process.versions?.node;
+  }
+  async request(config) {
+    const { fullPath, method = "GET", headers = {}, data, signal, credentials } = config;
+    return new Promise((resolve, reject) => {
+      const urlObj = new URL(fullPath);
+      const isHttps = urlObj.protocol === "https:";
+      const httpModule = isHttps ? require("https") : this.http;
+      const options = {
+        hostname: urlObj.hostname,
+        port: urlObj.port || (isHttps ? 443 : 80),
+        path: urlObj.pathname + urlObj.search,
+        method,
+        headers: {
+          ...headers,
+          // 处理凭证
+          ...credentials === "include" ? { Cookie: "" } : {}
+        },
+        timeout: config.timeout || 3e4
+      };
+      if (isHttps) {
+        Object.assign(options, {
+          rejectUnauthorized: false
+          // 允许自签名证书（可选配置）
+        });
+      }
+      const req = httpModule.request(options, (res) => {
+        const chunks = [];
+        res.on("data", (chunk) => {
+          chunks.push(chunk);
+        });
+        res.on("end", () => {
+          const body = Buffer.concat(chunks).toString("utf-8");
+          let responseData;
+          if (config.responseType === "text") {
+            responseData = body;
+          } else if (config.responseType === "arraybuffer") {
+            responseData = Buffer.from(body).buffer;
+          } else if (config.responseType === "blob") {
+            responseData = Buffer.from(body);
+          } else {
+            try {
+              responseData = body ? JSON.parse(body) : null;
+            } catch {
+              responseData = body;
+            }
+          }
+          const mockResponse = {
+            ok: (res.statusCode || 200) >= 200 && (res.statusCode || 200) < 300,
+            status: res.statusCode || 200,
+            statusText: res.statusMessage || "",
+            headers: res.headers,
+            text: () => Promise.resolve(body),
+            json: () => Promise.resolve(responseData),
+            blob: () => Promise.resolve(Buffer.from(body)),
+            arrayBuffer: () => Promise.resolve(Buffer.from(body).buffer),
+            formData: () => Promise.resolve(new URLSearchParams(body))
+          };
+          resolve({
+            data: responseData,
+            response: mockResponse,
+            config,
+            requestId: config.requestId
+          });
+        });
+      });
+      req.on("timeout", () => {
+        req.destroy();
+        reject(new Error("Request timeout"));
+      });
+      req.on("error", (error) => {
+        reject(error);
+      });
+      if (signal) {
+        signal.addEventListener("abort", () => {
+          req.destroy();
+          reject(new DOMException("Aborted", "AbortError"));
+        });
+      }
+      if (data && method !== "GET") {
+        const body = typeof data === "string" ? data : JSON.stringify(data);
+        req.write(body);
+      }
+      req.end();
+    });
+  }
+}
+export class DenoAdapter {
+  name = "deno";
+  isSupported() {
+    return typeof globalThis.Deno !== "undefined";
+  }
+  async request(config) {
+    const {
+      fullPath,
+      method = "GET",
+      headers = {},
+      data,
+      signal,
+      credentials,
+      responseType,
+      timeout
+    } = config;
+    const fetchOptions = {
+      method,
+      headers,
+      credentials
+    };
+    if (data && method !== "GET") {
+      if (data instanceof FormData) {
+        fetchOptions.body = data;
+      } else {
+        fetchOptions.body = JSON.stringify(data);
+        if (!headers["Content-Type"]) {
+          ;
+          fetchOptions.headers["Content-Type"] = "application/json";
+        }
+      }
+    }
+    const controller = new AbortController();
+    fetchOptions.signal = controller.signal;
+    if (timeout) {
+      setTimeout(() => controller.abort(), timeout).unref?.();
+    }
+    if (signal) {
+      signal.addEventListener("abort", () => controller.abort());
+    }
+    const response = await fetch(fullPath, fetchOptions);
+    let responseData;
+    switch (responseType) {
+      case "text":
+        responseData = await response.text();
+        break;
+      case "blob":
+        responseData = await response.blob();
+        break;
+      case "arraybuffer":
+        responseData = await response.arrayBuffer();
+        break;
+      case "formdata":
+        responseData = await response.formData();
+        break;
+      default:
+        const text = await response.text();
+        responseData = text ? JSON.parse(text) : null;
+    }
+    return {
+      data: responseData,
+      response,
+      config,
+      requestId: config.requestId
+    };
+  }
+}
+export class BunAdapter {
+  name = "bun";
+  isSupported() {
+    return typeof globalThis.Bun !== "undefined";
+  }
+  // Bun 直接使用 fetch，与 FetchAdapter 相同
+  // 但保留此类以便未来可能的 Bun 特定优化
+  async request(config) {
+    const {
+      fullPath,
+      method = "GET",
+      headers = {},
+      data,
+      signal,
+      credentials,
+      responseType,
+      timeout
+    } = config;
+    const fetchOptions = {
+      method,
+      headers,
+      credentials
+    };
+    if (data && method !== "GET") {
+      if (data instanceof FormData) {
+        fetchOptions.body = data;
+      } else {
+        fetchOptions.body = JSON.stringify(data);
+        if (!headers["Content-Type"]) {
+          ;
+          fetchOptions.headers["Content-Type"] = "application/json";
+        }
+      }
+    }
+    if (timeout) {
+      const controller = new AbortController();
+      fetchOptions.signal = controller.signal;
+      setTimeout(() => controller.abort(), timeout);
+    } else if (signal) {
+      fetchOptions.signal = signal;
+    }
+    const response = await fetch(fullPath, fetchOptions);
+    let responseData;
+    switch (responseType) {
+      case "text":
+        responseData = await response.text();
+        break;
+      case "blob":
+        responseData = await response.blob();
+        break;
+      case "arraybuffer":
+        responseData = await response.arrayBuffer();
+        break;
+      case "formdata":
+        responseData = await response.formData();
+        break;
+      default:
+        const text = await response.text();
+        responseData = text ? JSON.parse(text) : null;
+    }
+    return {
+      data: responseData,
+      response,
+      config,
+      requestId: config.requestId
+    };
+  }
+}
+export class EdgeAdapter {
+  name = "edge";
+  isSupported() {
+    return platform.environment === "edge";
+  }
+  async request(config) {
+    const {
+      fullPath,
+      method = "GET",
+      headers = {},
+      data,
+      signal,
+      credentials,
+      responseType,
+      timeout
+    } = config;
+    const fetchOptions = {
+      method,
+      headers,
+      credentials
+    };
+    if (data && method !== "GET") {
+      if (data instanceof URLSearchParams) {
+        fetchOptions.body = data;
+      } else {
+        fetchOptions.body = JSON.stringify(data);
+        if (!headers["Content-Type"]) {
+          ;
+          fetchOptions.headers["Content-Type"] = "application/json";
+        }
+      }
+    }
+    if (timeout) {
+      const controller = new AbortController();
+      fetchOptions.signal = controller.signal;
+      setTimeout(() => controller.abort(), timeout);
+    } else if (signal) {
+      fetchOptions.signal = signal;
+    }
+    const response = await fetch(fullPath, fetchOptions);
+    let responseData;
+    switch (responseType) {
+      case "text":
+        responseData = await response.text();
+        break;
+      case "blob":
+        responseData = await response.blob();
+        break;
+      case "arraybuffer":
+        responseData = await response.arrayBuffer();
+        break;
+      default:
+        const text = await response.text();
+        responseData = text ? JSON.parse(text) : null;
+    }
+    return {
+      data: responseData,
+      response,
+      config,
+      requestId: config.requestId
+    };
+  }
+}
+export function getBestAdapter() {
+  const { environment } = platform;
+  switch (environment) {
+    case "deno":
+      return new DenoAdapter();
+    case "bun":
+      return new BunAdapter();
+    case "edge":
+      return new EdgeAdapter();
+    case "node":
+      return new NodeHttpAdapter();
+    case "browser":
+    default:
+      return new (require("./fetch")).FetchAdapter();
+  }
+}
+export function getAdapter(environment) {
+  switch (environment) {
+    case "deno":
+      return new DenoAdapter();
+    case "bun":
+      return new BunAdapter();
+    case "edge":
+      return new EdgeAdapter();
+    case "node":
+      return new NodeHttpAdapter();
+    case "browser":
+    default:
+      return new (require("./fetch")).FetchAdapter();
+  }
+}

package/dist/cache/index.cjs

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  createCache: true
+};
+exports.createCache = createCache;
+var _memory = require("./memory.cjs");
+Object.keys(_memory).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _memory[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _memory[key];
+    }
+  });
+});
+var _localStorage = require("./localStorage.cjs");
+Object.keys(_localStorage).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _localStorage[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _localStorage[key];
+    }
+  });
+});
+var _indexedDB = require("./indexedDB.cjs");
+Object.keys(_indexedDB).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _indexedDB[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _indexedDB[key];
+    }
+  });
+});
+function createCache(type = "memory", options) {
+  switch (type) {
+    case "localStorage":
+      return new (require("./localStorage.cjs").LocalStorageCache)(options);
+    case "indexedDB":
+      return new (require("./indexedDB.cjs").IndexedDBCache)(options);
+    case "memory":
+    default:
+      return new (require("./memory.cjs").MemoryCache)();
+  }
+}

package/dist/cache/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 缓存系统导出
+ */
+export * from './memory';
+export * from './localStorage';
+export * from './indexedDB';
+import { type CacheOptions } from './memory';
+/**
+ * 创建缓存实例的工厂函数
+ */
+export type CacheType = 'memory' | 'localStorage' | 'indexedDB';
+export interface CacheFactoryOptions {
+    /** 缓存类型 */
+    type?: CacheType;
+    /** 缓存选项 */
+    options?: CacheOptions;
+}
+/**
+ * 根据类型创建缓存实例
+ */
+export declare function createCache(type?: CacheType, options?: CacheOptions): any;

package/dist/cache/index.mjs

@@ -0,0 +1,14 @@
+export * from "./memory.mjs";
+export * from "./localStorage.mjs";
+export * from "./indexedDB.mjs";
+export function createCache(type = "memory", options) {
+  switch (type) {
+    case "localStorage":
+      return new (require("./localStorage")).LocalStorageCache(options);
+    case "indexedDB":
+      return new (require("./indexedDB")).IndexedDBCache(options);
+    case "memory":
+    default:
+      return new (require("./memory")).MemoryCache();
+  }
+}

package/dist/cache/indexedDB.cjs

@@ -0,0 +1,188 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.indexedDBCache = exports.IndexedDBCache = void 0;
+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 {}
+  }
+}
+exports.IndexedDBCache = IndexedDBCache;
+const indexedDBCache = exports.indexedDBCache = new IndexedDBCache();

package/dist/cache/indexedDB.d.ts

@@ -0,0 +1,58 @@
+/**
+ * IndexedDB 缓存实现
+ * 适用于大量数据的持久化缓存
+ */
+export interface IndexedDBCacheOptions {
+    /** 数据库名称 */
+    dbName?: string;
+    /** 存储名称 */
+    storeName?: string;
+    /** 数据库版本 */
+    dbVersion?: number;
+}
+/**
+ * IndexedDB 缓存类
+ */
+export declare class IndexedDBCache {
+    private dbName;
+    private storeName;
+    private dbVersion;
+    private db;
+    constructor(options?: IndexedDBCacheOptions);
+    /**
+     * 打开数据库
+     */
+    private openDB;
+    /**
+     * 获取缓存
+     */
+    get<T>(key: string, _staleTime?: number): Promise<T | undefined>;
+    /**
+     * 设置缓存
+     */
+    set<T>(key: string, data: T, options?: {
+        staleTime?: number;
+        cacheTime?: number;
+    }): Promise<void>;
+    /**
+     * 删除缓存
+     */
+    delete(key: string): Promise<boolean>;
+    /**
+     * 清空缓存
+     */
+    clear(): Promise<void>;
+    /**
+     * 检查缓存是否存在
+     */
+    has(key: string): Promise<boolean>;
+    /**
+     * 获取所有缓存 keys
+     */
+    keys(): Promise<string[]>;
+    /**
+     * 清理过期缓存
+     */
+    cleanup(): Promise<void>;
+}
+export declare const indexedDBCache: IndexedDBCache;