@yh-ui/request 0.1.21

package/dist/plugin.mjs

@@ -0,0 +1,163 @@
+export class PluginManager {
+  plugins = /* @__PURE__ */ new Map();
+  request = null;
+  lifecycleHooks = {};
+  /**
+   * 初始化插件管理器
+   */
+  init(request) {
+    this.request = request;
+  }
+  /**
+   * 注册插件
+   */
+  use(plugin, options) {
+    if (this.plugins.has(plugin.name)) {
+      console.warn(`Plugin ${plugin.name} is already installed`);
+      return this;
+    }
+    if (!this.request) {
+      throw new Error("PluginManager must be initialized with a Request instance");
+    }
+    plugin.install(this.request, options);
+    this.plugins.set(plugin.name, {
+      plugin,
+      options,
+      installedAt: Date.now()
+    });
+    return this;
+  }
+  /**
+   * 卸载插件
+   */
+  uninstall(name) {
+    const instance = this.plugins.get(name);
+    if (!instance) return false;
+    if (instance.plugin.uninstall && this.request) {
+      instance.plugin.uninstall(this.request);
+    }
+    this.plugins.delete(name);
+    return true;
+  }
+  /**
+   * 获取插件
+   */
+  get(name) {
+    return this.plugins.get(name);
+  }
+  /**
+   * 获取所有插件
+   */
+  getAll() {
+    return Array.from(this.plugins.values());
+  }
+  /**
+   * 检查插件是否已安装
+   */
+  has(name) {
+    return this.plugins.has(name);
+  }
+  /**
+   * 清除所有插件
+   */
+  clear() {
+    this.plugins.forEach((instance, name) => {
+      this.uninstall(name);
+    });
+  }
+  /**
+   * 注册生命周期钩子
+   */
+  registerHooks(hooks) {
+    this.lifecycleHooks = {
+      ...this.lifecycleHooks,
+      ...hooks
+    };
+  }
+  /**
+   * 获取生命周期钩子
+   */
+  getHooks() {
+    return { ...this.lifecycleHooks };
+  }
+}
+export const loggingPlugin = {
+  name: "logging",
+  version: "1.0.0",
+  install(request) {
+    request.interceptors.request.use((config) => {
+      console.log(`[YH-Request] \u2192 ${config.method} ${config.url}`);
+      return config;
+    });
+    request.interceptors.response.use((response) => {
+      console.log(`[YH-Request] \u2190 ${response.response.status} ${response.config.url}`);
+      return response;
+    });
+  }
+};
+export const cachePlugin = {
+  name: "cache",
+  version: "1.0.0",
+  install(request, options) {
+    request.interceptors.request.use((config) => {
+      if (config.method === "GET" && options?.getCache) {
+        const key = config.url || "";
+        const cached = options.getCache(key);
+        if (cached) {
+          console.log("[YH-Request Cache] Cache hit:", key);
+        }
+      }
+      return config;
+    });
+    request.interceptors.response.use((response) => {
+      if (response.config.method === "GET" && options?.setCache) {
+        const key = response.config.url || "";
+        options.setCache(key, response.data);
+      }
+      return response;
+    });
+  }
+};
+export const errorHandlerPlugin = {
+  name: "errorHandler",
+  version: "1.0.0",
+  install(request, options) {
+    request.interceptors.response.use(
+      (response) => response,
+      (error) => {
+        if (options?.onError) {
+          options.onError(error);
+        }
+        return Promise.reject(error);
+      }
+    );
+  }
+};
+export const retryPlugin = {
+  name: "retry",
+  version: "1.0.0",
+  install(request, options) {
+    const retries = options?.retries || 3;
+    const retryDelay = options?.retryDelay || 1e3;
+    request.interceptors.response.use(
+      (response) => response,
+      async (error) => {
+        const config = error.config;
+        if (!config) return Promise.reject(error);
+        const currentRetries = config._retryCount || 0;
+        if (currentRetries < retries) {
+          config._retryCount = currentRetries + 1;
+          await new Promise((resolve) => setTimeout(resolve, retryDelay));
+          return request.request(config);
+        }
+        return Promise.reject(error);
+      }
+    );
+  }
+};
+export const builtInPlugins = {
+  logging: loggingPlugin,
+  cache: cachePlugin,
+  errorHandler: errorHandlerPlugin,
+  retry: retryPlugin
+};

package/dist/request.cjs

@@ -0,0 +1,396 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Request = exports.InterceptorManagerImpl = void 0;
+exports.buildURL = buildURL;
+exports.createRequest = void 0;
+exports.createRequestError = createRequestError;
+
+exports.defaultExponentialBackoff = defaultExponentialBackoff;
+exports.exponentialBackoffWithMaxRetries = exponentialBackoffWithMaxRetries;
+exports.fixedBackoff = fixedBackoff;
+exports.generateRequestId = generateRequestId;
+exports.linearBackoff = linearBackoff;
+exports.request = void 0;
+exports.serializeParams = serializeParams;
+let requestIdCounter = 0;
+function generateRequestId() {
+  return `req_${Date.now()}_${++requestIdCounter}`;
+}
+function serializeParams(params) {
+  const searchParams = new URLSearchParams();
+  const encode = value => {
+    if (value === null || value === void 0) return "";
+    if (typeof value === "object") return JSON.stringify(value);
+    return String(value);
+  };
+  const addParam = (key, value) => {
+    if (value !== null && value !== void 0) {
+      searchParams.append(key, encode(value));
+    }
+  };
+  for (const [key, value] of Object.entries(params)) {
+    if (Array.isArray(value)) {
+      value.forEach(v => addParam(key, v));
+    } else {
+      addParam(key, value);
+    }
+  }
+  return searchParams.toString();
+}
+function buildURL(options) {
+  const {
+    baseURL = "",
+    url = "",
+    params,
+    serializeParams: sp = true
+  } = options;
+  let fullPath = url;
+  if (baseURL) {
+    fullPath = url.startsWith("http") ? url : baseURL + url;
+  }
+  if (params && Object.keys(params).length > 0 && sp) {
+    const queryString = serializeParams(params);
+    const separator = fullPath.includes("?") ? "&" : "?";
+    fullPath += separator + queryString;
+  }
+  return fullPath;
+}
+function createRequestError(error, config, response) {
+  const err = typeof error === "string" ? new Error(error) : error;
+  const requestError = {
+    name: err.name,
+    message: err.message,
+    config,
+    response,
+    requestId: config?.requestId
+  };
+  if (error instanceof TypeError && error.message.includes("fetch")) {
+    requestError.isNetworkError = true;
+    requestError.code = "NETWORK_ERROR";
+  } else if (config?.signal?.aborted) {
+    requestError.isCanceled = true;
+    requestError.code = "CANCELED";
+  } else if (response) {
+    requestError.code = `HTTP_${response.status}`;
+  }
+  return requestError;
+}
+class InterceptorManagerImpl {
+  handlers = [];
+  use(onFulfilled, onRejected) {
+    this.handlers.push({
+      fulfilled: onFulfilled,
+      rejected: onRejected
+    });
+    return this.handlers.length - 1;
+  }
+  eject(id) {
+    if (this.handlers[id]) {
+      this.handlers[id] = null;
+    }
+  }
+  clear() {
+    this.handlers = [];
+  }
+  async execute(value) {
+    let result = value;
+    for (const handler of this.handlers) {
+      if (handler) {
+        try {
+          result = await handler.fulfilled(result);
+        } catch (error) {
+          if (handler.rejected) {
+            result = await handler.rejected(error);
+          } else {
+            throw error;
+          }
+        }
+      }
+    }
+    return result;
+  }
+}
+exports.InterceptorManagerImpl = InterceptorManagerImpl;
+class Request {
+  defaults;
+  interceptors;
+  abortControllers = /* @__PURE__ */new Map();
+  constructor(options = {}) {
+    this.defaults = {
+      timeout: 3e4,
+      credentials: "same-origin",
+      responseType: "json",
+      serializeParams: true,
+      retry: false,
+      retryTimes: 3,
+      retryDelay: 1e3,
+      retryCondition: error => {
+        return error.isNetworkError || (error.response?.status ?? 0) >= 500;
+      },
+      ...options.defaultOptions
+    };
+    this.interceptors = {
+      request: new InterceptorManagerImpl(),
+      response: new InterceptorManagerImpl()
+    };
+  }
+  /**
+   * 创建请求实例的静态方法
+   */
+  static create(options) {
+    return new Request(options);
+  }
+  /**
+   * 生成 AbortSignal
+   */
+  createAbortSignal(options) {
+    const controller = new AbortController();
+    if (options.requestKey) {
+      const prevController = this.abortControllers.get(options.requestKey);
+      if (prevController) {
+        prevController.abort();
+      }
+      this.abortControllers.set(options.requestKey, controller);
+    }
+    if (options.timeout) {
+      const timeoutId = setTimeout(() => {
+        controller.abort(new Error("Request timeout"));
+      }, options.timeout);
+      controller.signal.addEventListener("abort", () => {
+        clearTimeout(timeoutId);
+      });
+    }
+    return controller.signal;
+  }
+  /**
+   * 执行请求
+   */
+  async request(options) {
+    const requestId = generateRequestId();
+    const mergedOptions = {
+      ...this.defaults,
+      ...options,
+      requestId
+    };
+    mergedOptions.fullPath = buildURL(mergedOptions);
+    mergedOptions.signal = this.createAbortSignal(mergedOptions);
+    let config = await this.interceptors.request.execute(mergedOptions);
+    if (config.requestInterceptor) {
+      config = await config.requestInterceptor(config);
+    }
+    const executeRequest = async () => {
+      try {
+        const fetchOptions = {
+          method: config.method || "GET",
+          headers: config.headers,
+          credentials: config.credentials,
+          signal: config.signal
+        };
+        if (config.data !== void 0 && config.method !== "GET") {
+          if (config.responseType === "formdata" || config.data instanceof FormData) {
+            fetchOptions.body = config.data;
+          } else {
+            fetchOptions.body = JSON.stringify(config.data);
+            if (!fetchOptions.headers) {
+              fetchOptions.headers = {};
+            }
+            const headers = fetchOptions.headers;
+            if (!headers["Content-Type"]) {
+              headers["Content-Type"] = "application/json";
+            }
+          }
+        }
+        let response;
+        try {
+          response = await fetch(config.fullPath, fetchOptions);
+        } catch (error) {
+          throw createRequestError(error, config);
+        }
+        if (!response.ok) {
+          const error = createRequestError(`Request failed with status ${response.status}`, config, response);
+          try {
+            await this.interceptors.response.execute({
+              data: void 0,
+              response,
+              config,
+              requestId
+            });
+          } catch {}
+          throw error;
+        }
+        let data;
+        if (config.rawResponse) {
+          data = response;
+        } else {
+          switch (config.responseType) {
+            case "text":
+              data = await response.text();
+              break;
+            case "blob":
+              data = await response.blob();
+              break;
+            case "arraybuffer":
+              data = await response.arrayBuffer();
+              break;
+            case "formdata":
+              data = await response.formData();
+              break;
+            case "json":
+            default:
+              const text = await response.text();
+              data = text ? JSON.parse(text) : null;
+              break;
+          }
+        }
+        const requestResponse = {
+          data,
+          response,
+          config,
+          requestId
+        };
+        const finalResponse = await this.interceptors.response.execute(requestResponse);
+        return finalResponse;
+      } catch (error) {
+        const requestError = error;
+        const currentRetryCount = config._retryCount ?? 0;
+        const maxRetries = config.retryTimes ?? 3;
+        const shouldRetry = config.retry && currentRetryCount < maxRetries && (!config.retryCondition || config.retryCondition(requestError));
+        if (shouldRetry) {
+          const baseDelay = config.retryDelay || 1e3;
+          const delayCalculator = config.retryDelayCalculator || defaultExponentialBackoff;
+          const delay = delayCalculator(currentRetryCount, baseDelay);
+          if (delay < 0) {
+            if (config.errorHandler) {
+              config.errorHandler(requestError);
+            }
+            throw requestError;
+          }
+          await new Promise(resolve => setTimeout(resolve, delay));
+          config._retryCount = currentRetryCount + 1;
+          return executeRequest();
+        }
+        if (config.errorHandler) {
+          config.errorHandler(requestError);
+        }
+        throw requestError;
+      }
+    };
+    return executeRequest();
+  }
+  /**
+   * 便捷方法
+   */
+  get(url, options) {
+    return this.request({
+      ...options,
+      url,
+      method: "GET"
+    });
+  }
+  post(url, data, options) {
+    return this.request({
+      ...options,
+      url,
+      method: "POST",
+      data
+    });
+  }
+  put(url, data, options) {
+    return this.request({
+      ...options,
+      url,
+      method: "PUT",
+      data
+    });
+  }
+  delete(url, options) {
+    return this.request({
+      ...options,
+      url,
+      method: "DELETE"
+    });
+  }
+  patch(url, data, options) {
+    return this.request({
+      ...options,
+      url,
+      method: "PATCH",
+      data
+    });
+  }
+  head(url, options) {
+    return this.request({
+      ...options,
+      url,
+      method: "HEAD"
+    });
+  }
+  options(url, options) {
+    return this.request({
+      ...options,
+      url,
+      method: "OPTIONS"
+    });
+  }
+  /**
+   * 设置默认配置
+   */
+  setConfig(config) {
+    this.defaults = {
+      ...this.defaults,
+      ...config
+    };
+  }
+  /**
+   * 获取默认配置
+   */
+  getConfig() {
+    return {
+      ...this.defaults
+    };
+  }
+  /**
+   * 取消所有请求
+   */
+  cancelAll() {
+    this.abortControllers.forEach(controller => {
+      controller.abort();
+    });
+    this.abortControllers.clear();
+  }
+  /**
+   * 取消指定 key 的请求
+   */
+  cancel(key) {
+    const controller = this.abortControllers.get(key);
+    if (controller) {
+      controller.abort();
+      this.abortControllers.delete(key);
+    }
+  }
+}
+exports.Request = Request;
+function defaultExponentialBackoff(retryCount, defaultDelay = 1e3) {
+  const baseDelay = defaultDelay * Math.pow(2, retryCount);
+  const jitter = Math.random() * 1e3;
+  return Math.min(baseDelay + jitter, 3e4);
+}
+function linearBackoff(retryCount, defaultDelay) {
+  return defaultDelay * (retryCount + 1);
+}
+function fixedBackoff(_retryCount, defaultDelay) {
+  return defaultDelay;
+}
+function exponentialBackoffWithMaxRetries(retryCount, defaultDelay, maxRetries = 10) {
+  if (retryCount >= maxRetries) {
+    return -1;
+  }
+  return defaultExponentialBackoff(retryCount, defaultDelay);
+}
+const request = exports.request = new Request();
+const createRequest = options => new Request(options);
+exports.createRequest = createRequest;
+module.exports = request;

package/dist/request.d.ts

@@ -0,0 +1,111 @@
+import { type RequestOptions, type InternalRequestOptions, type RequestResponse, type RequestError, type RequestInstance, type InterceptorManager, type CreateRequestOptions, type ParamsRecord } from './types';
+export declare function generateRequestId(): string;
+/**
+ * 序列化 URL 参数
+ */
+export declare function serializeParams(params: ParamsRecord): string;
+/**
+ * 构建完整 URL
+ */
+export declare function buildURL(options: InternalRequestOptions): string;
+/**
+ * 创建请求错误
+ */
+export declare function createRequestError(error: Error | string, config?: InternalRequestOptions, response?: Response): RequestError;
+/**
+ * 拦截器管理器
+ */
+export declare class InterceptorManagerImpl<T> implements InterceptorManager<T> {
+    private handlers;
+    use(onFulfilled: (value: T) => T | Promise<T>, onRejected?: (error: RequestError) => T | Promise<T>): number;
+    eject(id: number): void;
+    clear(): void;
+    execute(value: T): Promise<T>;
+}
+/**
+ * 请求客户端类
+ */
+export declare class Request implements RequestInstance {
+    defaults: RequestOptions;
+    interceptors: {
+        request: InterceptorManager<InternalRequestOptions>;
+        response: InterceptorManager<RequestResponse<unknown>>;
+    };
+    private abortControllers;
+    constructor(options?: CreateRequestOptions);
+    /**
+     * 创建请求实例的静态方法
+     */
+    static create(options?: CreateRequestOptions): Request;
+    /**
+     * 生成 AbortSignal
+     */
+    private createAbortSignal;
+    /**
+     * 执行请求
+     */
+    request<T = unknown>(options: RequestOptions & {
+        url: string;
+    }): Promise<RequestResponse<T>>;
+    /**
+     * 便捷方法
+     */
+    get<T = unknown>(url: string, options?: RequestOptions): Promise<RequestResponse<T>>;
+    post<T = unknown>(url: string, data?: unknown, options?: RequestOptions): Promise<RequestResponse<T>>;
+    put<T = unknown>(url: string, data?: unknown, options?: RequestOptions): Promise<RequestResponse<T>>;
+    delete<T = unknown>(url: string, options?: RequestOptions): Promise<RequestResponse<T>>;
+    patch<T = unknown>(url: string, data?: unknown, options?: RequestOptions): Promise<RequestResponse<T>>;
+    head<T = unknown>(url: string, options?: RequestOptions): Promise<RequestResponse<T>>;
+    options<T = unknown>(url: string, options?: RequestOptions): Promise<RequestResponse<T>>;
+    /**
+     * 设置默认配置
+     */
+    setConfig(config: Partial<RequestOptions>): void;
+    /**
+     * 获取默认配置
+     */
+    getConfig(): RequestOptions;
+    /**
+     * 取消所有请求
+     */
+    cancelAll(): void;
+    /**
+     * 取消指定 key 的请求
+     */
+    cancel(key: string): void;
+}
+/**
+ * 默认指数退避延迟计算器 (带随机抖动)
+ * @param retryCount 当前重试次数 (从 0 开始)
+ * @param defaultDelay 基础延迟时间 (ms)
+ * @returns 实际延迟时间 (ms)
+ *
+ * @example
+ * // 第 1 次重试: 1000ms * 2^0 + 随机(0-1000ms) = 1000-2000ms
+ * // 第 2 次重试: 1000ms * 2^1 + 随机(0-1000ms) = 2000-3000ms
+ * // 第 3 次重试: 1000ms * 2^2 + 随机(0-1000ms) = 4000-5000ms
+ */
+export declare function defaultExponentialBackoff(retryCount: number, defaultDelay?: number): number;
+/**
+ * 线性退避延迟计算器
+ * 每次重试延迟线性增长
+ *
+ * @example
+ * // defaultDelay = 1000
+ * // 第 1 次重试: 1000ms
+ * // 第 2 次重试: 2000ms
+ * // 第 3 次重试: 3000ms
+ */
+export declare function linearBackoff(retryCount: number, defaultDelay: number): number;
+/**
+ * 固定延迟计算器
+ * 每次重试使用相同的延迟
+ */
+export declare function fixedBackoff(_retryCount: number, defaultDelay: number): number;
+/**
+ * 指数退避带最大重试次数限制
+ */
+export declare function exponentialBackoffWithMaxRetries(retryCount: number, defaultDelay: number, maxRetries?: number): number;
+export declare const request: Request;
+export declare const createRequest: (options?: CreateRequestOptions) => Request;
+export default request;