@yh-ui/request 0.1.21

package/dist/interceptors/security.cjs

@@ -0,0 +1,154 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCSRFInterceptor = createCSRFInterceptor;
+exports.createSecurityInterceptor = createSecurityInterceptor;
+exports.createTokenRefreshInterceptor = createTokenRefreshInterceptor;
+function createCSRFInterceptor(config = {}) {
+  const {
+    cookieName = "XSRF-TOKEN",
+    headerName = "X-XSRF-TOKEN",
+    getToken
+  } = config;
+  const getCSRFToken = () => {
+    if (getToken) {
+      return getToken();
+    }
+    if (typeof document === "undefined") return void 0;
+    const cookies = document.cookie.split(";");
+    for (const cookie of cookies) {
+      const [name, value] = cookie.trim().split("=");
+      if (name === cookieName) {
+        return decodeURIComponent(value);
+      }
+    }
+    return void 0;
+  };
+  return {
+    /**
+     * 请求拦截 - 添加 CSRF Token
+     */
+    onRequest: config2 => {
+      const safeMethods = ["GET", "HEAD", "OPTIONS"];
+      if (!safeMethods.includes(config2.method || "GET")) {
+        const token = getCSRFToken();
+        if (token) {
+          return {
+            ...config2,
+            headers: {
+              ...config2.headers,
+              [headerName]: token
+            }
+          };
+        }
+      }
+      return config2;
+    },
+    /**
+     * 获取 CSRF Token
+     */
+    getCSRFToken
+  };
+}
+function createTokenRefreshInterceptor(config = {}) {
+  const {
+    statusCode = 401,
+    refreshToken,
+    isRefreshing = () => false,
+    pendingRequests = [],
+    updateHeaders,
+    retryTimes = 3
+  } = config;
+  const originalConfigs = /* @__PURE__ */new Map();
+  let currentRetryTimes = retryTimes;
+  return {
+    /**
+     * 请求拦截
+     */
+    onRequest: config2 => {
+      originalConfigs.set(config2.requestId, config2);
+      return config2;
+    },
+    /**
+     * 响应拦截 - 处理 401
+     */
+    onResponseError: async (error, _request) => {
+      const {
+        response,
+        config: errorConfig
+      } = error;
+      if (response?.status !== statusCode) {
+        throw error;
+      }
+      if (currentRetryTimes <= 0) {
+        currentRetryTimes = retryTimes;
+        throw error;
+      }
+      const config2 = errorConfig;
+      if (!config2) {
+        throw error;
+      }
+      if (isRefreshing()) {
+        return new Promise((resolve, reject) => {
+          pendingRequests.push(() => {
+            _request(config2).then(resolve).catch(reject);
+          });
+        });
+      }
+      if (refreshToken) {
+        const refreshed = await refreshToken();
+        if (refreshed) {
+          if (updateHeaders && config2.headers) {
+            const newHeaders = {
+              ...config2.headers
+            };
+            updateHeaders(newHeaders);
+            config2.headers = newHeaders;
+          }
+          currentRetryTimes--;
+          return _request(config2);
+        }
+      }
+      throw error;
+    },
+    /**
+     * 重置重试次数
+     */
+    resetRetryTimes: () => {
+      currentRetryTimes = retryTimes;
+    }
+  };
+}
+function createSecurityInterceptor(options = {}) {
+  const {
+    csrf = {},
+    tokenRefresh = {}
+  } = options;
+  const csrfInterceptor = csrf === false ? null : createCSRFInterceptor(csrf);
+  const tokenRefreshInterceptor = tokenRefresh === false ? null : createTokenRefreshInterceptor(tokenRefresh);
+  return {
+    /**
+     * 请求拦截
+     */
+    onRequest: config => {
+      let result = config;
+      if (csrfInterceptor) {
+        result = csrfInterceptor.onRequest(result);
+      }
+      if (tokenRefreshInterceptor) {
+        result = tokenRefreshInterceptor.onRequest(result);
+      }
+      return result;
+    },
+    /**
+     * 获取 CSRF Token
+     */
+    getCSRFToken: csrfInterceptor?.getCSRFToken,
+    /**
+     * 重置 Token 刷新状态
+     */
+    resetTokenRefresh: tokenRefreshInterceptor?.resetRetryTimes
+  };
+}

package/dist/interceptors/security.d.ts

@@ -0,0 +1,83 @@
+/**
+ * 安全拦截器
+ * 包含 CSRF 防护和 Token 刷新功能
+ */
+import type { InternalRequestOptions, RequestResponse, RequestError } from '../types';
+/** CSRF 配置 */
+export interface CSRFConfig {
+    /** CSRF Token Cookie 名称 */
+    cookieName?: string;
+    /** CSRF Token Header 名称 */
+    headerName?: string;
+    /** 获取 Token 的函数 */
+    getToken?: () => string | undefined;
+}
+/** Token 刷新配置 */
+export interface TokenRefreshConfig {
+    /** 401 状态码是否触发刷新 */
+    statusCode?: number;
+    /** 刷新 Token 的函数 */
+    refreshToken?: () => Promise<boolean>;
+    /** 是否正在刷新中 */
+    isRefreshing?: () => boolean;
+    /** 等待刷新的请求队列 */
+    pendingRequests?: Array<() => void>;
+    /** 刷新后的 Header 更新 */
+    updateHeaders?: (headers: Record<string, string>) => void;
+    /** 重试次数 */
+    retryTimes?: number;
+}
+/** 安全拦截器选项 */
+export interface SecurityInterceptorOptions {
+    /** CSRF 配置 */
+    csrf?: CSRFConfig | false;
+    /** Token 刷新配置 */
+    tokenRefresh?: TokenRefreshConfig | false;
+}
+/**
+ * 创建 CSRF 拦截器
+ */
+export declare function createCSRFInterceptor(config?: CSRFConfig): {
+    /**
+     * 请求拦截 - 添加 CSRF Token
+     */
+    onRequest: (config: InternalRequestOptions) => InternalRequestOptions;
+    /**
+     * 获取 CSRF Token
+     */
+    getCSRFToken: () => string | undefined;
+};
+/**
+ * 创建 Token 刷新拦截器
+ */
+export declare function createTokenRefreshInterceptor(config?: TokenRefreshConfig): {
+    /**
+     * 请求拦截
+     */
+    onRequest: (config: InternalRequestOptions) => InternalRequestOptions;
+    /**
+     * 响应拦截 - 处理 401
+     */
+    onResponseError: (error: RequestError, _request: (config: InternalRequestOptions) => Promise<RequestResponse>) => Promise<RequestResponse>;
+    /**
+     * 重置重试次数
+     */
+    resetRetryTimes: () => void;
+};
+/**
+ * 创建安全拦截器
+ */
+export declare function createSecurityInterceptor(options?: SecurityInterceptorOptions): {
+    /**
+     * 请求拦截
+     */
+    onRequest: (config: InternalRequestOptions) => InternalRequestOptions;
+    /**
+     * 获取 CSRF Token
+     */
+    getCSRFToken: (() => string | undefined) | undefined;
+    /**
+     * 重置 Token 刷新状态
+     */
+    resetTokenRefresh: (() => void) | undefined;
+};

package/dist/interceptors/security.mjs

@@ -0,0 +1,134 @@
+export function createCSRFInterceptor(config = {}) {
+  const { cookieName = "XSRF-TOKEN", headerName = "X-XSRF-TOKEN", getToken } = config;
+  const getCSRFToken = () => {
+    if (getToken) {
+      return getToken();
+    }
+    if (typeof document === "undefined") return void 0;
+    const cookies = document.cookie.split(";");
+    for (const cookie of cookies) {
+      const [name, value] = cookie.trim().split("=");
+      if (name === cookieName) {
+        return decodeURIComponent(value);
+      }
+    }
+    return void 0;
+  };
+  return {
+    /**
+     * 请求拦截 - 添加 CSRF Token
+     */
+    onRequest: (config2) => {
+      const safeMethods = ["GET", "HEAD", "OPTIONS"];
+      if (!safeMethods.includes(config2.method || "GET")) {
+        const token = getCSRFToken();
+        if (token) {
+          return {
+            ...config2,
+            headers: {
+              ...config2.headers,
+              [headerName]: token
+            }
+          };
+        }
+      }
+      return config2;
+    },
+    /**
+     * 获取 CSRF Token
+     */
+    getCSRFToken
+  };
+}
+export function createTokenRefreshInterceptor(config = {}) {
+  const {
+    statusCode = 401,
+    refreshToken,
+    isRefreshing = () => false,
+    pendingRequests = [],
+    updateHeaders,
+    retryTimes = 3
+  } = config;
+  const originalConfigs = /* @__PURE__ */ new Map();
+  let currentRetryTimes = retryTimes;
+  return {
+    /**
+     * 请求拦截
+     */
+    onRequest: (config2) => {
+      originalConfigs.set(config2.requestId, config2);
+      return config2;
+    },
+    /**
+     * 响应拦截 - 处理 401
+     */
+    onResponseError: async (error, _request) => {
+      const { response, config: errorConfig } = error;
+      if (response?.status !== statusCode) {
+        throw error;
+      }
+      if (currentRetryTimes <= 0) {
+        currentRetryTimes = retryTimes;
+        throw error;
+      }
+      const config2 = errorConfig;
+      if (!config2) {
+        throw error;
+      }
+      if (isRefreshing()) {
+        return new Promise((resolve, reject) => {
+          pendingRequests.push(() => {
+            _request(config2).then(resolve).catch(reject);
+          });
+        });
+      }
+      if (refreshToken) {
+        const refreshed = await refreshToken();
+        if (refreshed) {
+          if (updateHeaders && config2.headers) {
+            const newHeaders = { ...config2.headers };
+            updateHeaders(newHeaders);
+            config2.headers = newHeaders;
+          }
+          currentRetryTimes--;
+          return _request(config2);
+        }
+      }
+      throw error;
+    },
+    /**
+     * 重置重试次数
+     */
+    resetRetryTimes: () => {
+      currentRetryTimes = retryTimes;
+    }
+  };
+}
+export function createSecurityInterceptor(options = {}) {
+  const { csrf = {}, tokenRefresh = {} } = options;
+  const csrfInterceptor = csrf === false ? null : createCSRFInterceptor(csrf);
+  const tokenRefreshInterceptor = tokenRefresh === false ? null : createTokenRefreshInterceptor(tokenRefresh);
+  return {
+    /**
+     * 请求拦截
+     */
+    onRequest: (config) => {
+      let result = config;
+      if (csrfInterceptor) {
+        result = csrfInterceptor.onRequest(result);
+      }
+      if (tokenRefreshInterceptor) {
+        result = tokenRefreshInterceptor.onRequest(result);
+      }
+      return result;
+    },
+    /**
+     * 获取 CSRF Token
+     */
+    getCSRFToken: csrfInterceptor?.getCSRFToken,
+    /**
+     * 重置 Token 刷新状态
+     */
+    resetTokenRefresh: tokenRefreshInterceptor?.resetRetryTimes
+  };
+}

package/dist/plugin.cjs

@@ -0,0 +1,166 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.retryPlugin = exports.loggingPlugin = exports.errorHandlerPlugin = exports.cachePlugin = exports.builtInPlugins = exports.PluginManager = void 0;
+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
+    };
+  }
+}
+exports.PluginManager = PluginManager;
+const loggingPlugin = exports.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;
+    });
+  }
+};
+const cachePlugin = exports.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;
+    });
+  }
+};
+const errorHandlerPlugin = exports.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);
+    });
+  }
+};
+const retryPlugin = exports.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);
+    });
+  }
+};
+const builtInPlugins = exports.builtInPlugins = {
+  logging: loggingPlugin,
+  cache: cachePlugin,
+  errorHandler: errorHandlerPlugin,
+  retry: retryPlugin
+};

package/dist/plugin.d.ts

@@ -0,0 +1,106 @@
+/**
+ * 插件系统
+ * 支持按需加载和树摇
+ */
+import { Request } from './request';
+import type { InternalRequestOptions, RequestResponse } from './types';
+/** 插件接口 */
+export interface RequestPlugin {
+    /** 插件名称 */
+    name: string;
+    /** 插件版本 */
+    version?: string;
+    /** 安装插件 */
+    install: (request: Request, options?: Record<string, unknown>) => void;
+    /** 卸载插件 */
+    uninstall?: (request: Request) => void;
+}
+/** 插件实例 */
+export interface PluginInstance {
+    /** 插件 */
+    plugin: RequestPlugin;
+    /** 选项 */
+    options?: Record<string, unknown>;
+    /** 安装时间 */
+    installedAt: number;
+}
+/** 请求生命周期钩子 */
+export interface RequestLifecycleHooks {
+    /** 请求发送前 */
+    onRequest?: (config: InternalRequestOptions) => InternalRequestOptions | Promise<InternalRequestOptions>;
+    /** 请求发送后（成功） */
+    onResponse?: <T>(response: RequestResponse<T>) => RequestResponse<T> | Promise<RequestResponse<T>>;
+    /** 请求发送后（错误） */
+    onError?: (error: Error) => Error | Promise<Error>;
+    /** 请求完成（无论成功或失败） */
+    onFinally?: () => void;
+}
+/**
+ * 插件管理器
+ */
+export declare class PluginManager {
+    private plugins;
+    private request;
+    private lifecycleHooks;
+    /**
+     * 初始化插件管理器
+     */
+    init(request: Request): void;
+    /**
+     * 注册插件
+     */
+    use(plugin: RequestPlugin, options?: Record<string, unknown>): this;
+    /**
+     * 卸载插件
+     */
+    uninstall(name: string): boolean;
+    /**
+     * 获取插件
+     */
+    get(name: string): PluginInstance | undefined;
+    /**
+     * 获取所有插件
+     */
+    getAll(): PluginInstance[];
+    /**
+     * 检查插件是否已安装
+     */
+    has(name: string): boolean;
+    /**
+     * 清除所有插件
+     */
+    clear(): void;
+    /**
+     * 注册生命周期钩子
+     */
+    registerHooks(hooks: RequestLifecycleHooks): void;
+    /**
+     * 获取生命周期钩子
+     */
+    getHooks(): RequestLifecycleHooks;
+}
+/**
+ * 日志插件
+ */
+export declare const loggingPlugin: RequestPlugin;
+/**
+ * 缓存插件
+ */
+export declare const cachePlugin: RequestPlugin;
+/**
+ * 错误处理插件
+ */
+export declare const errorHandlerPlugin: RequestPlugin;
+/**
+ * 重试插件
+ */
+export declare const retryPlugin: RequestPlugin;
+/**
+ * 预定义插件集合
+ */
+export declare const builtInPlugins: {
+    logging: RequestPlugin;
+    cache: RequestPlugin;
+    errorHandler: RequestPlugin;
+    retry: RequestPlugin;
+};