@be-link/http 1.1.0 → 1.2.1

package/dist/index.cjs.js

@@ -5,6 +5,319 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var axios = require('axios');
 var CryptoJS = require('crypto-js');
 
+/**
+ * Axios 适配器
+ *
+ * 使用 Axios 实现 HttpAdapter 接口
+ *
+ * @module adapters/AxiosAdapter
+ */
+/**
+ * Axios 适配器
+ *
+ * 将 Axios 封装为统一的 HttpAdapter 接口
+ */
+class AxiosAdapter {
+    /**
+     * 创建 Axios 适配器实例
+     *
+     * @param config - 适配器配置
+     */
+    constructor(config) {
+        this.instance = axios.create({
+            baseURL: config.baseURL,
+            timeout: config.timeout || 30000,
+            headers: {
+                'Content-Type': 'application/json',
+                ...(config.headers || {}),
+            },
+        });
+    }
+    /**
+     * 发起 HTTP 请求
+     *
+     * @param config - 请求配置
+     * @returns Promise 响应数据
+     */
+    async request(config) {
+        const axiosConfig = {
+            url: config.url,
+            method: config.method || 'GET',
+            data: config.data,
+            headers: config.headers,
+            timeout: config.timeout,
+            params: config.params,
+        };
+        const response = await this.instance.request(axiosConfig);
+        return {
+            data: response.data,
+            status: response.status,
+            headers: response.headers,
+        };
+    }
+    /**
+     * 获取 Axios 实例
+     *
+     * 用于直接访问 Axios 实例进行高级操作
+     *
+     * @returns Axios 实例
+     */
+    getAxiosInstance() {
+        return this.instance;
+    }
+}
+
+/**
+ * Taro 适配器
+ *
+ * 使用 Taro.request 实现 HttpAdapter 接口
+ * 适用于 Taro 小程序项目
+ *
+ * @module adapters/TaroAdapter
+ */
+/**
+ * Taro 适配器
+ *
+ * 将 Taro.request 封装为统一的 HttpAdapter 接口
+ */
+class TaroAdapter {
+    /**
+     * 创建 Taro 适配器实例
+     *
+     * @param config - 适配器配置
+     */
+    constructor(config) {
+        this.baseURL = config.baseURL;
+        this.timeout = config.timeout || 30000;
+        this.defaultHeaders = {
+            'Content-Type': 'application/json',
+            ...(config.headers || {}),
+        };
+        this.taroRequest = config.taroRequest;
+    }
+    /**
+     * 发起 HTTP 请求
+     *
+     * @param config - 请求配置
+     * @returns Promise 响应数据
+     */
+    async request(config) {
+        const fullUrl = this.resolveUrl(config.url, config.params);
+        const res = await this.taroRequest({
+            url: fullUrl,
+            method: (config.method || 'GET'),
+            data: config.data,
+            header: {
+                ...this.defaultHeaders,
+                ...(config.headers || {}),
+            },
+            timeout: config.timeout || this.timeout,
+        });
+        return {
+            data: res.data,
+            status: res.statusCode,
+            headers: res.header,
+        };
+    }
+    /**
+     * 解析完整 URL
+     *
+     * 处理相对路径和查询参数
+     *
+     * @param url - 请求 URL
+     * @param params - 查询参数
+     * @returns 完整 URL
+     */
+    resolveUrl(url, params) {
+        // 如果是绝对路径，直接使用；否则拼接 baseURL
+        const fullUrl = url.startsWith('http') ? url : `${this.baseURL}${url}`;
+        // 如果没有查询参数，直接返回
+        if (!params || Object.keys(params).length === 0) {
+            return fullUrl;
+        }
+        // 序列化查询参数
+        const queryParts = [];
+        for (const key of Object.keys(params)) {
+            const value = params[key];
+            if (value !== undefined && value !== null) {
+                queryParts.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+            }
+        }
+        if (queryParts.length === 0) {
+            return fullUrl;
+        }
+        const queryString = queryParts.join('&');
+        return `${fullUrl}${fullUrl.includes('?') ? '&' : '?'}${queryString}`;
+    }
+}
+/**
+ * 创建 Taro Fetch 包装器
+ *
+ * 将 Taro.request 包装为类似 fetch 的函数
+ * 用于 TimeSyncService 进行时间同步
+ *
+ * @param taroRequest - Taro.request 函数引用
+ * @returns FetchFunction 类型的函数
+ *
+ * @example
+ * ```ts
+ * import Taro from '@tarojs/taro';
+ * import { createTaroFetch } from '@be-link/http';
+ *
+ * const fetchFn = createTaroFetch(Taro.request);
+ * const timeSyncService = new TimeSyncService(config, fetchFn);
+ * ```
+ */
+function createTaroFetch(taroRequest) {
+    return async (url, options) => {
+        const method = (options?.method?.toUpperCase() || 'GET');
+        const res = await taroRequest({
+            url,
+            method,
+            // POST 请求需要传递 data，避免 "Body cannot be empty" 错误
+            data: method === 'POST' ? {} : undefined,
+        });
+        return {
+            ok: res.statusCode >= 200 && res.statusCode < 300,
+            status: res.statusCode,
+            json: async () => res.data,
+        };
+    };
+}
+
+/**
+ * 通用拦截器核心逻辑
+ *
+ * 提供与具体 HTTP 库无关的请求/响应处理函数
+ * 支持 Axios 和 Taro.request 适配器复用
+ *
+ * @module interceptors/core
+ */
+/**
+ * 处理请求配置
+ *
+ * 在请求发出前对配置进行处理，包括：
+ * 1. 确保时间同步
+ * 2. 设置默认 Content-Type
+ * 3. 添加用户 ID 到请求头
+ * 4. 加密并添加 Token 到请求头
+ * 5. 调用自定义请求拦截器
+ *
+ * @param config - 请求配置
+ * @param options - 全局请求选项
+ * @param timeSyncService - 时间同步服务（可选）
+ * @param encryptionService - 加密服务（可选）
+ * @returns 处理后的请求配置
+ */
+async function processRequest(config, options, timeSyncService, encryptionService) {
+    // 获取 header 名称，使用默认值
+    const tokenHeaderName = options.tokenHeaderName || 'X-BeLink-Token';
+    const userIdHeaderName = options.userIdHeaderName || 'X-BeLink-UserId';
+    // 确保 headers 对象存在
+    config.headers = config.headers || {};
+    // 步骤 1: 确保时间同步
+    // 在请求发出前检查并同步服务器时间，确保后续 Token 加密使用正确的时间戳
+    if (timeSyncService) {
+        await timeSyncService.ensureSync();
+    }
+    // 步骤 2: 设置默认 Content-Type
+    // 如果请求未指定 Content-Type，默认使用 JSON 格式
+    if (!config.headers['Content-Type']) {
+        config.headers['Content-Type'] = 'application/json';
+    }
+    // 步骤 3: 添加用户 ID
+    // 调用用户配置的 getUserId 函数获取用户 ID，添加到请求头
+    if (options.getUserId) {
+        const userId = options.getUserId();
+        if (userId) {
+            config.headers[userIdHeaderName] = userId;
+        }
+    }
+    // 步骤 4: 添加 Token
+    // 根据是否配置了加密服务，决定是否对 Token 进行加密
+    if (options.getToken) {
+        const token = options.getToken();
+        if (token) {
+            config.headers[tokenHeaderName] = encryptionService ? encryptionService.encryptToken(token) : token;
+        }
+    }
+    return config;
+}
+/**
+ * 处理响应数据
+ *
+ * 在收到响应后对数据进行处理，调用自定义响应拦截器
+ *
+ * @param data - 响应数据
+ * @param options - 全局请求选项
+ * @returns 处理后的响应数据
+ */
+function processResponse(data, options) {
+    // 调用自定义响应拦截器
+    // 允许用户对响应数据进行进一步处理
+    if (options.onResponse) {
+        return options.onResponse(data);
+    }
+    return data;
+}
+/**
+ * 处理错误
+ *
+ * 在请求出错时进行处理，支持自定义错误处理和业务错误检查
+ *
+ * @param error - 错误对象
+ * @param options - 全局请求选项
+ * @throws 处理后的错误
+ */
+function processError(error, options) {
+    // 优先调用自定义错误处理
+    // 如果用户配置了 onError，由用户自行处理错误
+    if (options.onError) {
+        const result = options.onError(error);
+        // 如果 onError 返回了值而不是抛出错误，我们继续抛出
+        throw result ?? error;
+    }
+    // 获取响应数据（如果有）
+    const responseData = error?.response?.data;
+    // 检查业务错误
+    // 业务错误：HTTP 状态码可能是 200，但响应体中 success === false
+    if (responseData && typeof responseData === 'object' && !responseData.success) {
+        // 创建业务错误对象
+        const bizError = new Error(responseData.message || '接口请求失败');
+        // 附加原始响应信息，方便调试
+        bizError.response = error.response;
+        bizError.data = responseData;
+        throw bizError;
+    }
+    // 其他错误（网络错误、超时等）直接抛出
+    throw error;
+}
+/**
+ * 检查响应状态并处理业务错误
+ *
+ * @param data - 响应数据
+ * @param status - HTTP 状态码
+ * @returns 处理后的响应数据
+ */
+function checkResponseStatus(data, status) {
+    // 检查 HTTP 状态码
+    if (status < 200 || status >= 300) {
+        const error = new Error(`HTTP Error: ${status}`);
+        error.status = status;
+        error.data = data;
+        throw error;
+    }
+    // 检查业务错误（如果响应是标准格式）
+    const responseData = data;
+    if (responseData && typeof responseData === 'object' && 'success' in responseData && !responseData.success) {
+        const bizError = new Error(responseData.message || '接口请求失败');
+        bizError.data = responseData;
+        bizError.errorType = responseData.errorType;
+        throw bizError;
+    }
+    return data;
+}
+
 /**
  * 时间同步服务
  *
@@ -25,7 +338,7 @@ const STORAGE_KEYS = {
     CLIENT_TIME: 'belink_client_time',
 };
 /**
- * 检测是否为浏览器环境
+ * 检测是否为浏览器环境（支持 localStorage）
  */
 function isBrowser() {
     return typeof window !== 'undefined' && typeof localStorage !== 'undefined';
@@ -71,8 +384,21 @@ function getPerformanceNow() {
 class TimeSyncService {
     /**
      * 创建时间同步服务实例
+     *
+     * @param config - 时间同步配置
+     * @param fetchFn - 自定义 fetch 函数（可选），用于支持 Taro 等非浏览器环境
+     *
+     * @example
+     * ```ts
+     * // 使用默认 fetch
+     * const timeSync = new TimeSyncService({ syncUrl: 'https://api.example.com/time' });
+     *
+     * // 使用 Taro.request
+     * import { createTaroFetch } from '@be-link/http';
+     * const timeSync = new TimeSyncService(config, createTaroFetch(Taro.request));
+     * ```
      */
-    constructor(config) {
+    constructor(config, fetchFn) {
         /**
          * 同步时的服务器时间（内存存储）
          * 用于计算调整后的时间
@@ -93,6 +419,22 @@ class TimeSyncService {
             syncGapTime: 50 * 1000, // 默认 50 秒
             ...config,
         };
+        // 记录是否使用了自定义 fetchFn
+        this.hasCustomFetch = !!fetchFn;
+        // 使用传入的 fetchFn 或默认的 fetch
+        this.fetchFn = fetchFn || this.defaultFetch.bind(this);
+    }
+    /**
+     * 默认的 fetch 实现
+     * 使用浏览器原生 fetch API
+     */
+    async defaultFetch(url, options) {
+        const response = await fetch(url, options);
+        return {
+            ok: response.ok,
+            status: response.status,
+            json: () => response.json(),
+        };
     }
     /**
      * 确保时间已同步
@@ -106,7 +448,13 @@ class TimeSyncService {
      * - 避免多个并发请求同时触发多次时间同步
      */
     async ensureSync() {
-        if (!this.config.enabled || !isBrowser()) {
+        // 检查是否启用
+        if (!this.config.enabled) {
+            return;
+        }
+        // 环境检测：如果没有自定义 fetchFn 且不是浏览器环境，跳过同步
+        // 如果有自定义 fetchFn（如 Taro.request），则允许在任何环境执行
+        if (!this.hasCustomFetch && !isBrowser()) {
             return;
         }
         // 如果已有同步请求正在进行，等待它完成
@@ -136,7 +484,12 @@ class TimeSyncService {
      * - 同步完成后清除锁，允许后续同步请求
      */
     async sync() {
-        if (!isBrowser() || !this.config.syncUrl) {
+        // 检查 syncUrl 是否配置
+        if (!this.config.syncUrl) {
+            return;
+        }
+        // 环境检测：如果没有自定义 fetchFn 且不是浏览器环境，跳过同步
+        if (!this.hasCustomFetch && !isBrowser()) {
             return;
         }
         // 如果已有同步请求正在进行，等待它完成
@@ -161,7 +514,8 @@ class TimeSyncService {
         try {
             // 记录请求发起时的 performance.now()
             const requestStartTime = getPerformanceNow();
-            const response = await fetch(this.config.syncUrl, { method: 'POST' });
+            // 使用注入的 fetch 函数
+            const response = await this.fetchFn(this.config.syncUrl, { method: 'POST' });
             if (!response.ok) {
                 console.error('[TimeSyncService] Sync failed with status:', response.status);
                 this.clear();
@@ -179,11 +533,13 @@ class TimeSyncService {
             // 存储到内存（使用 performance.now()）
             this.syncServerTime = serverTime + networkDelay;
             this.syncPerformanceTime = requestEndTime;
-            // 同时存储到 localStorage（用于调试和日志）
-            const serverTimeKey = getStorageKey(this.config.storagePrefix, STORAGE_KEYS.SERVER_TIME);
-            const clientTimeKey = getStorageKey(this.config.storagePrefix, STORAGE_KEYS.CLIENT_TIME);
-            localStorage.setItem(serverTimeKey, String(this.syncServerTime));
-            localStorage.setItem(clientTimeKey, String(Date.now()));
+            // 同时存储到 localStorage（用于调试和日志），仅在浏览器环境下
+            if (isBrowser()) {
+                const serverTimeKey = getStorageKey(this.config.storagePrefix, STORAGE_KEYS.SERVER_TIME);
+                const clientTimeKey = getStorageKey(this.config.storagePrefix, STORAGE_KEYS.CLIENT_TIME);
+                localStorage.setItem(serverTimeKey, String(this.syncServerTime));
+                localStorage.setItem(clientTimeKey, String(Date.now()));
+            }
         }
         catch (error) {
             console.error('[TimeSyncService] Failed to sync time:', error);
@@ -388,185 +744,16 @@ class EncryptionService {
     }
 }
 
-/**
- * 请求拦截器
- *
- * 在请求发出前对请求进行处理，包括：
- * - 时间同步
- * - 设置默认请求头
- * - 添加用户 ID
- * - Token 加密和添加
- * - 调用自定义拦截器
- *
- * @module interceptors/request
- */
-/**
- * 设置请求拦截器
- *
- * 为 Axios 实例添加请求拦截器，处理请求前的通用逻辑
- *
- * 拦截器执行顺序：
- * 1. 确保时间同步（如果配置了 TimeSyncService）
- * 2. 设置默认 Content-Type
- * 3. 添加用户 ID 到请求头
- * 4. 加密并添加 Token 到请求头
- * 5. 调用自定义请求拦截器
- *
- * @param instance - Axios 实例
- * @param options - 请求配置选项
- * @param timeSyncService - 时间同步服务实例（可选）
- * @param encryptionService - 加密服务实例（可选）
- *
- * @example
- * ```ts
- * const instance = axios.create({ baseURL: 'https://api.example.com' });
- *
- * setRequestInterceptor(
- *   instance,
- *   {
- *     baseURL: 'https://api.example.com',
- *     getToken: () => localStorage.getItem('token'),
- *     getUserId: () => localStorage.getItem('userId'),
- *   },
- *   timeSyncService,
- *   encryptionService,
- * );
- * ```
- */
-function setRequestInterceptor(instance, options, timeSyncService, encryptionService) {
-    // 获取 header 名称，使用默认值
-    const tokenHeaderName = options.tokenHeaderName || 'X-BeLink-Token';
-    const userIdHeaderName = options.userIdHeaderName || 'X-BeLink-UserId';
-    instance.interceptors.request.use(async (config) => {
-        // 步骤 1: 确保时间同步
-        // 在请求发出前检查并同步服务器时间，确保后续 Token 加密使用正确的时间戳
-        if (timeSyncService) {
-            await timeSyncService.ensureSync();
-        }
-        // 步骤 2: 设置默认 Content-Type
-        // 如果请求未指定 Content-Type，默认使用 JSON 格式
-        if (!config.headers['Content-Type']) {
-            config.headers['Content-Type'] = 'application/json';
-        }
-        // 步骤 3: 添加用户 ID
-        // 调用用户配置的 getUserId 函数获取用户 ID，添加到请求头
-        if (options.getUserId) {
-            const userId = options.getUserId();
-            if (userId) {
-                config.headers[userIdHeaderName] = userId;
-            }
-        }
-        // 步骤 4: 添加 Token
-        // 根据是否配置了加密服务，决定是否对 Token 进行加密
-        if (options.getToken) {
-            const token = options.getToken();
-            if (token) {
-                config.headers[tokenHeaderName] = encryptionService ? encryptionService.encryptToken(token) : token;
-            }
-        }
-        // 步骤 5: 调用自定义请求拦截器
-        // 允许用户进一步自定义请求配置
-        if (options.onRequest) {
-            return options.onRequest(config);
-        }
-        return config;
-    });
-}
-
-/**
- * 响应拦截器
- *
- * 在收到响应后对响应进行处理，包括：
- * - 提取响应数据
- * - 调用自定义响应拦截器
- * - 统一错误处理
- *
- * @module interceptors/response
- */
-/**
- * 设置响应拦截器
- *
- * 为 Axios 实例添加响应拦截器，处理响应后的通用逻辑
- *
- * 成功响应处理：
- * 1. 提取响应数据（response.data）
- * 2. 调用自定义响应拦截器（如果配置）
- * 3. 返回处理后的数据
- *
- * 错误响应处理：
- * 1. 调用自定义错误处理（如果配置）
- * 2. 检查业务错误（success === false）
- * 3. 抛出错误
- *
- * @param instance - Axios 实例
- * @param options - 请求配置选项
- *
- * @example
- * ```ts
- * const instance = axios.create({ baseURL: 'https://api.example.com' });
- *
- * setResponseInterceptor(instance, {
- *   baseURL: 'https://api.example.com',
- *   onResponse: (data) => {
- *     console.log('响应数据:', data);
- *     return data;
- *   },
- *   onError: (error) => {
- *     if (error.response?.status === 401) {
- *       // 处理未授权错误
- *       window.location.href = '/login';
- *     }
- *     throw error;
- *   },
- * });
- * ```
- */
-function setResponseInterceptor(instance, options) {
-    instance.interceptors.response.use(
-    // 成功响应处理
-    (response) => {
-        // 提取响应数据（Axios 的响应数据在 response.data 中）
-        const data = response.data;
-        // 调用自定义响应拦截器
-        // 允许用户对响应数据进行进一步处理
-        if (options.onResponse) {
-            return options.onResponse(data);
-        }
-        return data;
-    }, 
-    // 错误响应处理
-    (error) => {
-        // 优先调用自定义错误处理
-        // 如果用户配置了 onError，由用户自行处理错误
-        if (options.onError) {
-            return options.onError(error);
-        }
-        // 获取响应数据（如果有）
-        const responseData = error?.response?.data;
-        // 检查业务错误
-        // 业务错误：HTTP 状态码可能是 200，但响应体中 success === false
-        if (responseData && typeof responseData === 'object' && !responseData.success) {
-            // 创建业务错误对象
-            const bizError = new Error(responseData.message || '接口请求失败');
-            // 附加原始响应信息，方便调试
-            bizError.response = error.response;
-            bizError.data = responseData;
-            throw bizError;
-        }
-        // 其他错误（网络错误、超时等）直接抛出
-        throw error;
-    });
-}
-
 /**
  * BeLinkHttp 请求客户端
  *
  * 单例模式的 HTTP 请求客户端
  * 支持时间同步和 Token 加密
+ * 支持 Axios 和 Taro.request 两种请求引擎
  *
  * @module BeLinkHttp
  *
- * @example
+ * @example Axios 模式（默认）
  * ```ts
  * import { beLinkHttp } from '@be-link/http';
  *
@@ -581,25 +768,49 @@ function setResponseInterceptor(instance, options) {
  * // 发起请求
  * const data = await beLinkHttp.get('/api/users');
  * ```
+ *
+ * @example Taro 模式
+ * ```ts
+ * import { beLinkHttp } from '@be-link/http';
+ * import Taro from '@tarojs/taro';
+ *
+ * // 初始化
+ * beLinkHttp.init({
+ *   adapter: 'taro',
+ *   taroRequest: Taro.request,
+ *   baseURL: 'https://api.example.com',
+ *   getToken: () => Taro.getStorageSync('token'),
+ * });
+ *
+ * // 发起请求（使用方式完全一致）
+ * const data = await beLinkHttp.get('/api/users');
+ * ```
  */
 /**
  * BeLinkHttp 单例类
  *
  * 提供统一的 HTTP 请求接口，支持：
+ * - 多适配器（Axios / Taro）
  * - 时间同步
  * - Token 加密
  * - 请求/响应拦截
  */
 class BeLinkHttp {
     constructor() {
-        /** Axios 实例 */
-        this.instance = null;
+        /** HTTP 适配器实例 */
+        this.adapter = null;
         /** 时间同步服务 */
         this.timeSyncService = null;
         /** 加密服务 */
         this.encryptionService = null;
+        /** 请求配置选项 */
+        this.options = null;
         /** 是否已初始化 */
         this.initialized = false;
+        /** 动态设置的 Token */
+        this._token = null;
+        /** 动态设置的 UserId */
+        this._userId = null;
     }
     /**
      * 初始化请求客户端
@@ -608,7 +819,7 @@ class BeLinkHttp {
      *
      * @param options - 请求配置选项
      *
-     * @example
+     * @example Axios 模式
      * ```ts
      * beLinkHttp.init({
      *   baseURL: 'https://api.example.com',
@@ -624,36 +835,61 @@ class BeLinkHttp {
      *   getUserId: () => localStorage.getItem('userId'),
      * });
      * ```
+     *
+     * @example Taro 模式
+     * ```ts
+     * import Taro from '@tarojs/taro';
+     *
+     * beLinkHttp.init({
+     *   adapter: 'taro',
+     *   taroRequest: Taro.request,
+     *   baseURL: 'https://api.example.com',
+     *   getToken: () => Taro.getStorageSync('token'),
+     * });
+     * ```
      */
     init(options) {
-        const { baseURL, timeout = 30000, headers = {}, timeSync, encryption } = options;
-        // 创建 Axios 实例
-        this.instance = axios.create({
-            baseURL,
-            timeout,
-            headers: {
-                'Content-Type': 'application/json',
-                ...headers,
-            },
-        });
+        this.options = options;
+        const { baseURL, timeout = 30000, headers = {}, timeSync, encryption, adapter = 'axios' } = options;
+        // 创建适配器
+        if (adapter === 'taro') {
+            if (!options.taroRequest) {
+                throw new Error('[BeLinkHttp] 使用 taro 适配器时必须传入 taroRequest');
+            }
+            this.adapter = new TaroAdapter({
+                baseURL,
+                timeout,
+                headers,
+                taroRequest: options.taroRequest,
+            });
+        }
+        else {
+            this.adapter = new AxiosAdapter({
+                baseURL,
+                timeout,
+                headers,
+            });
+        }
         // 创建时间同步服务
         if (timeSync?.syncUrl) {
-            this.timeSyncService = new TimeSyncService(timeSync);
+            let fetchFn;
+            // 如果使用 Taro 适配器，创建 Taro Fetch 包装器
+            if (adapter === 'taro' && options.taroRequest) {
+                fetchFn = createTaroFetch(options.taroRequest);
+            }
+            this.timeSyncService = new TimeSyncService(timeSync, fetchFn);
         }
         // 创建加密服务
         if (encryption?.key && encryption?.iv) {
             this.encryptionService = new EncryptionService(encryption, this.timeSyncService);
         }
-        // 设置拦截器
-        setRequestInterceptor(this.instance, options, this.timeSyncService, this.encryptionService);
-        setResponseInterceptor(this.instance, options);
         this.initialized = true;
     }
     /**
      * 检查是否已初始化
      */
     checkInitialized() {
-        if (!this.initialized || !this.instance) {
+        if (!this.initialized || !this.adapter) {
             throw new Error('[BeLinkHttp] 请先调用 init() 方法进行初始化');
         }
     }
@@ -661,7 +897,7 @@ class BeLinkHttp {
      * GET 请求
      *
      * @param url - 请求 URL
-     * @param config - 可选的 Axios 请求配置
+     * @param config - 可选的请求配置
      * @returns Promise 响应数据
      *
      * @example
@@ -671,15 +907,14 @@ class BeLinkHttp {
      * ```
      */
     async get(url, config) {
-        this.checkInitialized();
-        return this.instance.get(url, config);
+        return this.request({ ...config, url, method: 'GET' });
     }
     /**
      * POST 请求
      *
      * @param url - 请求 URL
      * @param data - 请求体数据
-     * @param config - 可选的 Axios 请求配置
+     * @param config - 可选的请求配置
      * @returns Promise 响应数据
      *
      * @example
@@ -688,15 +923,14 @@ class BeLinkHttp {
      * ```
      */
     async post(url, data, config) {
-        this.checkInitialized();
-        return this.instance.post(url, data, config);
+        return this.request({ ...config, url, method: 'POST', data });
     }
     /**
      * PUT 请求
      *
      * @param url - 请求 URL
      * @param data - 请求体数据
-     * @param config - 可选的 Axios 请求配置
+     * @param config - 可选的请求配置
      * @returns Promise 响应数据
      *
      * @example
@@ -705,15 +939,14 @@ class BeLinkHttp {
      * ```
      */
     async put(url, data, config) {
-        this.checkInitialized();
-        return this.instance.put(url, data, config);
+        return this.request({ ...config, url, method: 'PUT', data });
     }
     /**
      * PATCH 请求
      *
      * @param url - 请求 URL
      * @param data - 请求体数据
-     * @param config - 可选的 Axios 请求配置
+     * @param config - 可选的请求配置
      * @returns Promise 响应数据
      *
      * @example
@@ -722,14 +955,13 @@ class BeLinkHttp {
      * ```
      */
     async patch(url, data, config) {
-        this.checkInitialized();
-        return this.instance.patch(url, data, config);
+        return this.request({ ...config, url, method: 'PATCH', data });
     }
     /**
      * DELETE 请求
      *
      * @param url - 请求 URL
-     * @param config - 可选的 Axios 请求配置
+     * @param config - 可选的请求配置
      * @returns Promise 响应数据
      *
      * @example
@@ -738,19 +970,18 @@ class BeLinkHttp {
      * ```
      */
     async delete(url, config) {
-        this.checkInitialized();
-        return this.instance.delete(url, config);
+        return this.request({ ...config, url, method: 'DELETE' });
     }
     /**
      * 通用请求方法
      *
-     * @param config - Axios 请求配置
+     * @param config - 请求配置
      * @returns Promise 响应数据
      *
      * @example
      * ```ts
      * const result = await beLinkHttp.request({
-     *   method: 'post',
+     *   method: 'POST',
      *   url: '/api/users',
      *   data: { name: '张三' },
      *   headers: { 'X-Custom': 'value' },
@@ -759,7 +990,25 @@ class BeLinkHttp {
      */
     async request(config) {
         this.checkInitialized();
-        return this.instance.request(config);
+        try {
+            // 创建带有动态 token/userId 获取函数的 options
+            const optionsWithDynamicAuth = {
+                ...this.options,
+                getToken: () => this.getToken(),
+                getUserId: () => this.getUserId(),
+            };
+            // 处理请求（应用拦截器逻辑）
+            const processedConfig = await processRequest({ ...config }, optionsWithDynamicAuth, this.timeSyncService, this.encryptionService);
+            // 发起请求
+            const response = await this.adapter.request(processedConfig);
+            // 检查响应状态
+            const checkedData = checkResponseStatus(response.data, response.status);
+            // 处理响应
+            return processResponse(checkedData, this.options);
+        }
+        catch (error) {
+            return processError(error, this.options);
+        }
     }
     /**
      * 获取时间同步服务实例
@@ -780,10 +1029,90 @@ class BeLinkHttp {
     /**
      * 获取 Axios 实例
      *
-     * @returns Axios 实例，未初始化时返回 null
+     * 仅在使用 axios 适配器时有效
+     *
+     * @returns Axios 实例，非 axios 适配器或未初始化时返回 null
      */
     getAxiosInstance() {
-        return this.instance;
+        if (this.adapter instanceof AxiosAdapter) {
+            return this.adapter.getAxiosInstance();
+        }
+        return null;
+    }
+    /**
+     * 获取当前适配器类型
+     *
+     * @returns 适配器类型，未初始化时返回 null
+     */
+    getAdapterType() {
+        if (!this.initialized || !this.options) {
+            return null;
+        }
+        return this.options.adapter || 'axios';
+    }
+    /**
+     * 设置 Token
+     *
+     * 动态更新请求时使用的 Token，会覆盖 init 时传入的 getToken 返回值
+     *
+     * @param token - 新的 Token 值，传入 null 则清除
+     *
+     * @example
+     * ```ts
+     * // 登录后设置 Token
+     * beLinkHttp.setToken('new-token-value');
+     *
+     * // 登出时清除 Token
+     * beLinkHttp.setToken(null);
+     * ```
+     */
+    setToken(token) {
+        this._token = token;
+    }
+    /**
+     * 设置 UserId
+     *
+     * 动态更新请求时使用的 UserId，会覆盖 init 时传入的 getUserId 返回值
+     *
+     * @param userId - 新的 UserId 值，传入 null 则清除
+     *
+     * @example
+     * ```ts
+     * // 登录后设置 UserId
+     * beLinkHttp.setUserId('user-123');
+     *
+     * // 登出时清除 UserId
+     * beLinkHttp.setUserId(null);
+     * ```
+     */
+    setUserId(userId) {
+        this._userId = userId;
+    }
+    /**
+     * 获取当前 Token
+     *
+     * 优先返回通过 setToken 设置的值，否则调用 init 时传入的 getToken 函数
+     *
+     * @returns 当前 Token 值
+     */
+    getToken() {
+        if (this._token !== null) {
+            return this._token;
+        }
+        return this.options?.getToken?.() ?? null;
+    }
+    /**
+     * 获取当前 UserId
+     *
+     * 优先返回通过 setUserId 设置的值，否则调用 init 时传入的 getUserId 函数
+     *
+     * @returns 当前 UserId 值
+     */
+    getUserId() {
+        if (this._userId !== null) {
+            return this._userId;
+        }
+        return this.options?.getUserId?.() ?? null;
     }
     /**
      * 重置客户端
@@ -791,10 +1120,13 @@ class BeLinkHttp {
      * 清除所有配置和实例，需要重新调用 init() 初始化
      */
     reset() {
-        this.instance = null;
+        this.adapter = null;
         this.timeSyncService = null;
         this.encryptionService = null;
+        this.options = null;
         this.initialized = false;
+        this._token = null;
+        this._userId = null;
     }
 }
 /**
@@ -815,6 +1147,9 @@ class BeLinkHttp {
  */
 const beLinkHttp = new BeLinkHttp();
 
+exports.AxiosAdapter = AxiosAdapter;
 exports.BeLinkHttp = BeLinkHttp;
+exports.TaroAdapter = TaroAdapter;
 exports.beLinkHttp = beLinkHttp;
+exports.createTaroFetch = createTaroFetch;
 exports.default = beLinkHttp;