@be-link/http 1.0.1-beta.0

package/dist/index.cjs.js

@@ -0,0 +1,845 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var axios = require('axios');
+var CryptoJS = require('crypto-js');
+
+/**
+ * 时间同步服务
+ *
+ * 用于同步客户端和服务器时间，解决客户端时间不准确的问题
+ * 主要用于 Token 加密时使用服务器时间，防止重放攻击
+ *
+ * 使用 performance.now() 计算时间流逝，防止用户修改系统时间导致的问题
+ *
+ * @module TimeSyncService
+ */
+/**
+ * localStorage 存储键名常量
+ */
+const STORAGE_KEYS = {
+    /** 服务器时间存储键 */
+    SERVER_TIME: 'belink_server_time',
+    /** 客户端时间存储键（同步时的客户端时间，用于判断是否需要重新同步） */
+    CLIENT_TIME: 'belink_client_time',
+};
+/**
+ * 检测是否为浏览器环境
+ */
+function isBrowser() {
+    return typeof window !== 'undefined' && typeof localStorage !== 'undefined';
+}
+/**
+ * 获取带前缀的存储 key
+ */
+function getStorageKey(prefix, key) {
+    return prefix ? `${prefix}_${key}` : key;
+}
+/**
+ * 获取 performance.now()，兼容非浏览器环境
+ */
+function getPerformanceNow() {
+    if (typeof performance !== 'undefined' && performance.now) {
+        return performance.now();
+    }
+    return Date.now();
+}
+/**
+ * 时间同步服务
+ *
+ * 负责同步客户端和服务器时间，提供以下功能：
+ * - 自动检测是否需要同步
+ * - 获取服务器时间
+ * - 使用 performance.now() 计算时间流逝，防止用户修改系统时间
+ * - 获取调整后的当前时间
+ *
+ * @example
+ * ```ts
+ * const timeSync = new TimeSyncService({
+ *   syncUrl: 'https://api.example.com/api/time',
+ *   syncGapTime: 50000,
+ * });
+ *
+ * // 确保时间同步
+ * await timeSync.ensureSync();
+ *
+ * // 获取调整后的时间
+ * const adjustedTime = timeSync.getAdjustedTime();
+ * ```
+ */
+class TimeSyncService {
+    /**
+     * 创建时间同步服务实例
+     */
+    constructor(config) {
+        /**
+         * 同步时的服务器时间（内存存储）
+         * 用于计算调整后的时间
+         */
+        this.syncServerTime = null;
+        /**
+         * 同步时的 performance.now() 值（内存存储）
+         * 使用 performance.now() 而不是 Date.now()，防止用户修改系统时间
+         */
+        this.syncPerformanceTime = null;
+        /**
+         * 正在进行的同步 Promise（用于防止并发请求时重复同步）
+         * 当有同步请求正在进行时，其他请求会等待这个 Promise 完成
+         */
+        this.syncPromise = null;
+        this.config = {
+            enabled: true,
+            syncGapTime: 50 * 1000, // 默认 50 秒
+            ...config,
+        };
+    }
+    /**
+     * 确保时间已同步
+     *
+     * 检查是否需要同步：
+     * 1. 内存中没有同步数据（页面刷新后）
+     * 2. 距离上次同步的时间超过了 syncGapTime 阈值
+     *
+     * 并发控制：
+     * - 如果已有同步请求正在进行，直接等待该请求完成
+     * - 避免多个并发请求同时触发多次时间同步
+     */
+    async ensureSync() {
+        if (!this.config.enabled || !isBrowser()) {
+            return;
+        }
+        // 如果已有同步请求正在进行，等待它完成
+        if (this.syncPromise) {
+            await this.syncPromise;
+            return;
+        }
+        // 如果内存中没有同步数据，需要同步
+        if (this.syncServerTime === null || this.syncPerformanceTime === null) {
+            await this.sync();
+            return;
+        }
+        // 使用 performance.now() 计算时间流逝，检查是否需要重新同步
+        const elapsed = getPerformanceNow() - this.syncPerformanceTime;
+        if (elapsed > (this.config.syncGapTime || 50 * 1000)) {
+            await this.sync();
+        }
+    }
+    /**
+     * 执行时间同步
+     *
+     * 向服务器发送请求获取服务器时间
+     * 同时记录 performance.now() 用于后续计算时间流逝
+     *
+     * 并发控制：
+     * - 使用 syncPromise 作为锁，确保同一时间只有一个同步请求
+     * - 同步完成后清除锁，允许后续同步请求
+     */
+    async sync() {
+        if (!isBrowser() || !this.config.syncUrl) {
+            return;
+        }
+        // 如果已有同步请求正在进行，等待它完成
+        if (this.syncPromise) {
+            await this.syncPromise;
+            return;
+        }
+        // 创建同步 Promise 并保存引用（作为锁）
+        this.syncPromise = this.doSync();
+        try {
+            await this.syncPromise;
+        }
+        finally {
+            // 同步完成后清除锁
+            this.syncPromise = null;
+        }
+    }
+    /**
+     * 实际执行时间同步的内部方法
+     */
+    async doSync() {
+        try {
+            // 记录请求发起时的 performance.now()
+            const requestStartTime = getPerformanceNow();
+            const response = await fetch(this.config.syncUrl, { method: 'POST' });
+            if (!response.ok) {
+                console.error('[TimeSyncService] Sync failed with status:', response.status);
+                this.clear();
+                return;
+            }
+            const res = await response.json();
+            const serverTime = res.data.timestamp;
+            if (!serverTime) {
+                this.clear();
+                return;
+            }
+            // 计算网络延迟的一半，补偿到服务器时间
+            const requestEndTime = getPerformanceNow();
+            const networkDelay = (requestEndTime - requestStartTime) / 2;
+            // 存储到内存（使用 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()));
+        }
+        catch (error) {
+            console.error('[TimeSyncService] Failed to sync time:', error);
+            this.clear();
+        }
+    }
+    /**
+     * 获取服务器时间
+     *
+     * 返回同步时获取的服务器时间戳
+     */
+    getServerTime() {
+        return this.syncServerTime;
+    }
+    /**
+     * 获取时间差
+     *
+     * 返回服务器时间与客户端时间的差值
+     * 注意：此方法仅用于向后兼容，实际计算使用 getAdjustedTime()
+     */
+    getTimeDiff() {
+        if (this.syncServerTime === null) {
+            return null;
+        }
+        return this.syncServerTime - Date.now();
+    }
+    /**
+     * 获取调整后的当前时间
+     *
+     * 使用 performance.now() 计算时间流逝，得到准确的服务器时间
+     * 计算公式：同步时的服务器时间 + (当前 performance.now() - 同步时的 performance.now())
+     *
+     * 优势：即使用户修改系统时间，performance.now() 的流逝是正确的
+     *
+     * @returns 调整后的时间戳（毫秒），未同步时返回当前客户端时间
+     */
+    getAdjustedTime() {
+        if (this.syncServerTime === null || this.syncPerformanceTime === null) {
+            return Date.now();
+        }
+        // 使用 performance.now() 计算时间流逝
+        const elapsed = getPerformanceNow() - this.syncPerformanceTime;
+        return Math.round(this.syncServerTime + elapsed);
+    }
+    /**
+     * 清除同步数据
+     */
+    clear() {
+        this.syncServerTime = null;
+        this.syncPerformanceTime = null;
+        if (isBrowser()) {
+            const serverTimeKey = getStorageKey(this.config.storagePrefix, STORAGE_KEYS.SERVER_TIME);
+            const clientTimeKey = getStorageKey(this.config.storagePrefix, STORAGE_KEYS.CLIENT_TIME);
+            localStorage.removeItem(serverTimeKey);
+            localStorage.removeItem(clientTimeKey);
+        }
+    }
+    /**
+     * 更新配置
+     */
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
+}
+
+/**
+ * 加密服务
+ *
+ * 提供 Token 加密/解密功能，使用 AES-CBC 模式
+ * 加密后的 Token 包含时间戳，用于防止重放攻击
+ *
+ * @module EncryptionService
+ */
+/**
+ * 加密服务
+ *
+ * 负责 Token 的 AES 加密和解密，提供以下功能：
+ * - Token 加密（带时间戳）
+ * - Token 解密
+ * - 与时间同步服务集成
+ *
+ * 加密格式说明：
+ * - 原始数据格式: `${token}|+|${timestamp}`
+ * - 加密算法: AES-128-CBC
+ * - 输出格式: Base64 编码
+ *
+ * @example
+ * ```ts
+ * const encryption = new EncryptionService({
+ *   key: '1234567890123456', // 16 位
+ *   iv: '1234567890123456',  // 16 位
+ * });
+ *
+ * // 加密 Token
+ * const encryptedToken = encryption.encryptToken('my-token');
+ *
+ * // 解密 Token
+ * const { token, timestamp } = encryption.decryptToken(encryptedToken);
+ * ```
+ */
+class EncryptionService {
+    /**
+     * 创建加密服务实例
+     *
+     * @param config - 加密配置
+     * @param timeSyncService - 时间同步服务实例（可选），用于获取服务器校正后的时间
+     */
+    constructor(config, timeSyncService) {
+        this.config = {
+            enabled: true,
+            ...config,
+        };
+        this.timeSyncService = timeSyncService;
+    }
+    /**
+     * 加密 Token
+     *
+     * 将 Token 与时间戳组合后进行 AES 加密
+     * 加密后的数据用于请求头的 Authorization 字段
+     *
+     * 加密流程：
+     * 1. 组合原始数据: `${token}|+|${timestamp}`
+     * 2. 使用 AES-128-CBC 加密
+     * 3. 输出 Base64 编码的密文
+     *
+     * @param token - 原始 Token 字符串
+     * @param timestamp - 可选的时间戳（毫秒），默认使用调整后的当前时间
+     * @returns 加密后的 Token 字符串（Base64 编码）
+     *
+     * @example
+     * ```ts
+     * // 使用默认时间戳
+     * const encrypted = encryption.encryptToken('my-token');
+     *
+     * // 使用指定时间戳
+     * const encrypted = encryption.encryptToken('my-token', Date.now());
+     * ```
+     */
+    encryptToken(token, timestamp) {
+        // 如果 Token 为空或加密功能禁用，直接返回原始 Token
+        if (!token || !this.config.enabled) {
+            return token || '';
+        }
+        // 获取时间戳（优先使用传入的时间戳，否则使用调整后的时间）
+        const time = timestamp ?? this.getAdjustedTime();
+        // 组合原始数据：Token + 分隔符 + 时间戳
+        const data = `${token}|+|${time}`;
+        // 使用 AES-CBC 模式加密
+        return CryptoJS.AES.encrypt(data, CryptoJS.enc.Utf8.parse(this.config.key), {
+            iv: CryptoJS.enc.Utf8.parse(this.config.iv),
+            mode: CryptoJS.mode.CBC,
+        }).toString();
+    }
+    /**
+     * 解密 Token
+     *
+     * 将加密后的 Token 解密，提取原始 Token 和时间戳
+     *
+     * @param encryptedToken - 加密后的 Token 字符串
+     * @returns 包含原始 Token 和时间戳的对象
+     *
+     * @example
+     * ```ts
+     * const { token, timestamp } = encryption.decryptToken(encryptedToken);
+     * console.log(token);     // 'my-token'
+     * console.log(timestamp); // 1703577600000
+     * ```
+     */
+    decryptToken(encryptedToken) {
+        // 使用 AES-CBC 模式解密
+        const decrypted = CryptoJS.AES.decrypt(encryptedToken, CryptoJS.enc.Utf8.parse(this.config.key), {
+            iv: CryptoJS.enc.Utf8.parse(this.config.iv),
+            mode: CryptoJS.mode.CBC,
+        }).toString(CryptoJS.enc.Utf8);
+        // 分割原始数据，提取 Token 和时间戳
+        const parts = decrypted.split('|+|');
+        return {
+            token: parts[0],
+            timestamp: parseInt(parts[1], 10),
+        };
+    }
+    /**
+     * 获取调整后的时间戳
+     *
+     * 优先使用时间同步服务获取校正后的时间
+     * 如果没有时间同步服务，则使用当前客户端时间
+     *
+     * @returns 时间戳（毫秒）
+     */
+    getAdjustedTime() {
+        if (this.timeSyncService) {
+            return this.timeSyncService.getAdjustedTime();
+        }
+        return Date.now();
+    }
+    /**
+     * 更新配置
+     *
+     * 动态更新加密服务的配置
+     *
+     * @param config - 要更新的配置项
+     */
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
+    /**
+     * 设置时间同步服务
+     *
+     * 用于后期绑定时间同步服务实例
+     *
+     * @param timeSyncService - 时间同步服务实例
+     */
+    setTimeSyncService(timeSyncService) {
+        this.timeSyncService = timeSyncService;
+    }
+}
+
+/**
+ * 请求拦截器
+ *
+ * 在请求发出前对请求进行处理，包括：
+ * - 时间同步
+ * - 设置默认请求头
+ * - 添加用户 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 && encryptionService) {
+            // 有加密服务：获取 Token 并加密后添加到请求头
+            const token = options.getToken();
+            if (token) {
+                config.headers[tokenHeaderName] = encryptionService.encryptToken(token);
+            }
+        }
+        else if (options.getToken) {
+            // 无加密服务：直接使用原始 Token
+            const token = options.getToken();
+            if (token) {
+                config.headers[tokenHeaderName] = 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 加密
+ *
+ * @module BeLinkHttp
+ *
+ * @example
+ * ```ts
+ * import { beLinkHttp } from '@be-link/http';
+ *
+ * // 初始化
+ * beLinkHttp.init({
+ *   baseURL: 'https://api.example.com',
+ *   timeSync: { syncUrl: 'https://api.example.com/api/time' },
+ *   encryption: { key: '...', iv: '...' },
+ *   getToken: () => localStorage.getItem('token'),
+ * });
+ *
+ * // 发起请求
+ * const data = await beLinkHttp.get('/api/users');
+ * ```
+ */
+/**
+ * BeLinkHttp 单例类
+ *
+ * 提供统一的 HTTP 请求接口，支持：
+ * - 时间同步
+ * - Token 加密
+ * - 请求/响应拦截
+ */
+class BeLinkHttp {
+    constructor() {
+        /** Axios 实例 */
+        this.instance = null;
+        /** 时间同步服务 */
+        this.timeSyncService = null;
+        /** 加密服务 */
+        this.encryptionService = null;
+        /** 是否已初始化 */
+        this.initialized = false;
+    }
+    /**
+     * 初始化请求客户端
+     *
+     * 必须在使用其他方法之前调用此方法进行初始化
+     *
+     * @param options - 请求配置选项
+     *
+     * @example
+     * ```ts
+     * beLinkHttp.init({
+     *   baseURL: 'https://api.example.com',
+     *   timeout: 30000,
+     *   timeSync: {
+     *     syncUrl: 'https://api.example.com/api/time',
+     *   },
+     *   encryption: {
+     *     key: 'your-aes-key-16ch',
+     *     iv: 'your-aes-iv-16ch',
+     *   },
+     *   getToken: () => localStorage.getItem('token'),
+     *   getUserId: () => localStorage.getItem('userId'),
+     * });
+     * ```
+     */
+    init(options) {
+        const { baseURL, timeout = 30000, headers = {}, timeSync, encryption } = options;
+        // 创建 Axios 实例
+        this.instance = axios.create({
+            baseURL,
+            timeout,
+            headers: {
+                'Content-Type': 'application/json',
+                ...headers,
+            },
+        });
+        // 创建时间同步服务
+        if (timeSync?.syncUrl) {
+            this.timeSyncService = new TimeSyncService(timeSync);
+        }
+        // 创建加密服务
+        if (encryption?.key && encryption?.iv) {
+            this.encryptionService = new EncryptionService(encryption, this.timeSyncService || undefined);
+        }
+        // 设置拦截器
+        setRequestInterceptor(this.instance, options, this.timeSyncService || undefined, this.encryptionService || undefined);
+        setResponseInterceptor(this.instance, options);
+        this.initialized = true;
+    }
+    /**
+     * 检查是否已初始化
+     */
+    checkInitialized() {
+        if (!this.initialized || !this.instance) {
+            throw new Error('[BeLinkHttp] 请先调用 init() 方法进行初始化');
+        }
+    }
+    /**
+     * GET 请求
+     *
+     * @param url - 请求 URL
+     * @param config - 可选的 Axios 请求配置
+     * @returns Promise 响应数据
+     *
+     * @example
+     * ```ts
+     * const users = await beLinkHttp.get('/api/users');
+     * const user = await beLinkHttp.get('/api/users/1', { params: { include: 'profile' } });
+     * ```
+     */
+    async get(url, config) {
+        this.checkInitialized();
+        return this.instance.get(url, config);
+    }
+    /**
+     * POST 请求
+     *
+     * @param url - 请求 URL
+     * @param data - 请求体数据
+     * @param config - 可选的 Axios 请求配置
+     * @returns Promise 响应数据
+     *
+     * @example
+     * ```ts
+     * const result = await beLinkHttp.post('/api/users', { name: '张三', age: 25 });
+     * ```
+     */
+    async post(url, data, config) {
+        this.checkInitialized();
+        return this.instance.post(url, data, config);
+    }
+    /**
+     * PUT 请求
+     *
+     * @param url - 请求 URL
+     * @param data - 请求体数据
+     * @param config - 可选的 Axios 请求配置
+     * @returns Promise 响应数据
+     *
+     * @example
+     * ```ts
+     * const result = await beLinkHttp.put('/api/users/1', { name: '李四' });
+     * ```
+     */
+    async put(url, data, config) {
+        this.checkInitialized();
+        return this.instance.put(url, data, config);
+    }
+    /**
+     * PATCH 请求
+     *
+     * @param url - 请求 URL
+     * @param data - 请求体数据
+     * @param config - 可选的 Axios 请求配置
+     * @returns Promise 响应数据
+     *
+     * @example
+     * ```ts
+     * const result = await beLinkHttp.patch('/api/users/1', { age: 26 });
+     * ```
+     */
+    async patch(url, data, config) {
+        this.checkInitialized();
+        return this.instance.patch(url, data, config);
+    }
+    /**
+     * DELETE 请求
+     *
+     * @param url - 请求 URL
+     * @param config - 可选的 Axios 请求配置
+     * @returns Promise 响应数据
+     *
+     * @example
+     * ```ts
+     * await beLinkHttp.delete('/api/users/1');
+     * ```
+     */
+    async delete(url, config) {
+        this.checkInitialized();
+        return this.instance.delete(url, config);
+    }
+    /**
+     * 通用请求方法
+     *
+     * @param config - Axios 请求配置
+     * @returns Promise 响应数据
+     *
+     * @example
+     * ```ts
+     * const result = await beLinkHttp.request({
+     *   method: 'post',
+     *   url: '/api/users',
+     *   data: { name: '张三' },
+     *   headers: { 'X-Custom': 'value' },
+     * });
+     * ```
+     */
+    async request(config) {
+        this.checkInitialized();
+        return this.instance.request(config);
+    }
+    /**
+     * 获取时间同步服务实例
+     *
+     * @returns 时间同步服务实例，未初始化时返回 null
+     */
+    getTimeSyncService() {
+        return this.timeSyncService;
+    }
+    /**
+     * 获取加密服务实例
+     *
+     * @returns 加密服务实例，未初始化时返回 null
+     */
+    getEncryptionService() {
+        return this.encryptionService;
+    }
+    /**
+     * 获取 Axios 实例
+     *
+     * @returns Axios 实例，未初始化时返回 null
+     */
+    getAxiosInstance() {
+        return this.instance;
+    }
+    /**
+     * 重置客户端
+     *
+     * 清除所有配置和实例，需要重新调用 init() 初始化
+     */
+    reset() {
+        this.instance = null;
+        this.timeSyncService = null;
+        this.encryptionService = null;
+        this.initialized = false;
+    }
+}
+/**
+ * BeLinkHttp 单例实例
+ *
+ * @example
+ * ```ts
+ * import { beLinkHttp } from '@be-link/http';
+ *
+ * // 初始化
+ * beLinkHttp.init({
+ *   baseURL: 'https://api.example.com',
+ * });
+ *
+ * // 使用
+ * const data = await beLinkHttp.get('/api/users');
+ * ```
+ */
+const beLinkHttp = new BeLinkHttp();
+
+exports.BeLinkHttp = BeLinkHttp;
+exports.EncryptionService = EncryptionService;
+exports.TimeSyncService = TimeSyncService;
+exports.beLinkHttp = beLinkHttp;
+exports.default = beLinkHttp;
+exports.setRequestInterceptor = setRequestInterceptor;
+exports.setResponseInterceptor = setResponseInterceptor;