@be-link/request 1.45.1-beta.8 → 1.45.1-beta.9

package/README.md

@@ -1,499 +1,422 @@
 # @be-link/request
 
-共比邻 HTTP 请求库，提供企业级的 HTTP 请求封装和云函数调用功能。
+共比邻 HTTP 请求库，提供简洁的 HTTP 请求封装，支持时间同步和 Token 加密。
 
 ## 特性
 
-- 企业级 HTTP 请求客户端（认证、加密、时间同步）
-- 云函数调用封装（腾讯云 CloudBase）
-- 拦截器机制（请求/响应拦截）
+- 单例模式，全局统一配置
+- 服务器时间同步（解决客户端时间不准问题）
+- Token AES 加密（防重放攻击）
+- 请求/响应拦截器
 - TypeScript 类型支持
-- 多环境适配（Browser/Node.js）
-- 支持多服务实例配置
+- 所有参数由应用方传递，灵活配置
+- 自定义 Header 名称（Token、UserId）
+- 并发请求时自动合并时间同步（防止重复请求）
+- 使用 `performance.now()` 防止客户端系统时间篡改
 
 ## 安装
 
 ```bash
-# 基础安装（包含所有依赖）
 pnpm add @be-link/request axios crypto-js
-
-# 如果需要使用云函数调用 (callFunction)
-pnpm add @be-link/request axios crypto-js @cloudbase/js-sdk
 ```
 
 ### 依赖说明
 
-| 依赖                | 是否必须 | 说明                   |
-| ------------------- | -------- | ---------------------- |
-| `axios`             | ✅ 必须  | HTTP 客户端            |
-| `crypto-js`         | ✅ 必须  | Token 加密（AES）      |
-| `@cloudbase/js-sdk` | ⚠️ 可选  | 仅 `callFunction` 需要 |
+| 依赖        | 是否必须 | 说明              |
+| ----------- | -------- | ----------------- |
+| `axios`     | ✅ 必须  | HTTP 客户端       |
+| `crypto-js` | ✅ 必须  | Token 加密（AES） |
 
-> **注意**：所有依赖作为 external 不打包进产物，需要用户安装。
+## 快速开始
 
-## 架构设计
+### 基本用法
 
-```
-┌─────────────────────────────────────────────────────────────────────┐
-│                          应用层 (Application)                        │
-│  ┌──────────────────┐  ┌──────────────────┐  ┌──────────────────┐  │
-│  │   beLinkRequest  │  │ beLinkLiveRequest│  │     request      │  │
-│  │   (企业级客户端)  │  │   (直播客户端)    │  │   (基础请求)     │  │
-│  └────────┬─────────┘  └────────┬─────────┘  └────────┬─────────┘  │
-└───────────│─────────────────────│─────────────────────│─────────────┘
-            │                     │                     │
-            ▼                     ▼                     │
-┌─────────────────────────────────────────────────────────────────────┐
-│                          客户端层 (Clients)                          │
-│  ┌──────────────────┐  ┌──────────────────┐                        │
-│  │   BeLinkClient   │  │    LiveClient    │                        │
-│  │  - Token 加密    │  │  - 简化版        │                        │
-│  │  - 时间同步      │  │  - 无认证逻辑    │                        │
-│  │  - 401 处理      │  │                  │                        │
-│  └────────┬─────────┘  └────────┬─────────┘                        │
-└───────────│─────────────────────│───────────────────────────────────┘
-            │                     │
-            ▼                     ▼
-┌─────────────────────────────────────────────────────────────────────┐
-│                          基类层 (HttpClient)                         │
-│  ┌─────────────────────────────────────────────────────────────┐   │
-│  │  - get/post/put/delete 方法                                  │   │
-│  │  - 拦截器管理 (addRequestInterceptor/addResponseInterceptor) │   │
-│  │  - 请求上下文管理                                            │   │
-│  └──────────────────────────────┬──────────────────────────────┘   │
-└─────────────────────────────────│───────────────────────────────────┘
-                                  │
-                                  ▼
-┌─────────────────────────────────────────────────────────────────────┐
-│                          适配器层 (AxiosAdapter)                     │
-│  ┌─────────────────────────────────────────────────────────────┐   │
-│  │  - 封装 Axios 实例                                           │   │
-│  │  - 统一错误处理 (HttpError/NetworkError/TimeoutError)        │   │
-│  │  - 请求/响应转换                                             │   │
-│  └─────────────────────────────────────────────────────────────┘   │
-└─────────────────────────────────────────────────────────────────────┘
-```
+```typescript
+import { beLinkRequest } from '@be-link/request';
 
-### Token 加密流程
+// 1. 初始化（应用启动时调用一次）
+beLinkRequest.init({
+  baseURL: 'https://api.example.com',
+  timeout: 30000,
+});
 
+// 2. 发起请求
+const users = await beLinkRequest.get('/api/users');
+const result = await beLinkRequest.post('/api/users', { name: '张三' });
 ```
-每次请求时:
-┌─────────────┐     ┌──────────────────┐     ┌─────────────────┐
-│ TokenProvider│────>│ EncryptionService│────>│   请求头        │
-│ () => token  │     │ AES(token|+|time)│     │ x-belink-auth.. │
-└─────────────┘     └──────────────────┘     └─────────────────┘
-                            │
-                            ▼
-                    TimeSyncService
-                    (服务器时间校正)
-```
-
-## 客户端选择指南
-
-| 客户端              | 使用场景             | Token 加密 | 时间同步 | 401 处理 |
-| ------------------- | -------------------- | :--------: | :------: | :------: |
-| `beLinkRequest`     | 需要认证的业务 API   |     ✅     |    ✅    |    ✅    |
-| `beLinkLiveRequest` | 直播、无需认证的场景 |     ❌     |    ❌    |    ❌    |
-| `request`           | 第三方 API、简单请求 |     ❌     |    ❌    |    ❌    |
-
-## 快速开始
 
-### 1. 初始化配置
+### 完整配置
 
 ```typescript
 import { beLinkRequest } from '@be-link/request';
 
-// 初始化客户端
 beLinkRequest.init({
-  mode: 'production', // 'development' | 'testing' | 'production'
-  baseUrl: 'https://api.example.com', // API 基础地址
-  loginPath: '/login', // 401 时跳转的登录页路径
-  tokenHeaderName: 'x-belink-authorization', // Token 请求头名称（可选）
-  tokenStorageKey: 'belink_token', // localStorage 存储键名（可选）
-});
+  // 基础配置
+  baseURL: 'https://api.example.com',
+  timeout: 30000,
+  headers: {
+    'X-Custom-Header': 'value',
+  },
 
-// 设置 Token（通常在登录后调用）
-beLinkRequest.setToken('your-auth-token');
+  // 时间同步配置
+  timeSync: {
+    enabled: true,
+    syncUrl: 'https://api.example.com/api/time',
+    syncGapTime: 50000, // 同步间隔阈值（毫秒）
+    storagePrefix: 'myapp', // 存储 key 前缀
+  },
 
-// 或监听 localStorage 中的 Token 变化
-beLinkRequest.setupTokenListener('belink_token');
-```
+  // 加密配置
+  encryption: {
+    enabled: true,
+    key: 'your-aes-key-16ch', // 16 位 AES 密钥
+    iv: 'your-aes-iv-16ch', // 16 位 AES IV
+  },
 
-### 2. 发起请求
+  // Token 获取函数
+  getToken: () => localStorage.getItem('token'),
 
-```typescript
-import { beLinkRequest } from '@be-link/request';
+  // 用户 ID 获取函数
+  getUserId: () => localStorage.getItem('userId'),
 
-// GET 请求
-const users = await beLinkRequest.get('/api/users');
+  // 自定义 Header 名称（可选）
+  tokenHeaderName: 'X-BeLink-Token', // 默认值
+  userIdHeaderName: 'X-BeLink-UserId', // 默认值
 
-// POST 请求
-const result = await beLinkRequest.post('/api/users', {
-  name: '张三',
-  age: 25,
-});
+  // 自定义请求拦截器
+  onRequest: (config) => {
+    console.log('请求发出:', config.url);
+    return config;
+  },
 
-// 带配置的请求
-const data = await beLinkRequest.request({
-  url: '/api/data',
-  method: 'post',
-  data: { key: 'value' },
-  headers: { 'X-Custom-Header': 'custom-value' },
-  timeout: 10000,
+  // 自定义响应拦截器
+  onResponse: (response) => {
+    console.log('响应收到:', response);
+    return response;
+  },
+
+  // 自定义错误处理
+  onError: (error) => {
+    if (error.response?.status === 401) {
+      window.location.href = '/login';
+    }
+    throw error;
+  },
 });
 ```
 
 ## API 文档
 
-### beLinkRequest - 企业级请求客户端
+### beLinkRequest
 
-**使用场景**: 需要用户认证的业务 API，如用户信息、订单、支付等。
+单例请求客户端，提供以下方法：
 
-**特性**:
+#### init(options)
 
-- Token 自动加密（AES + 时间戳，防重放攻击）
-- 服务器时间同步（解决客户端时间不准问题）
-- 401 自动处理（跳转登录页或执行回调）
+初始化请求客户端，必须在使用其他方法之前调用。
 
 ```typescript
-import { beLinkRequest } from '@be-link/request';
-
-// 初始化（必须在使用前调用）
 beLinkRequest.init({
-  mode: 'production',
-  baseUrl: 'https://api.example.com',
-  loginPath: '/login',
-  tokenHeaderName: 'x-belink-authorization',  // 请求头名称
-  tokenStorageKey: 'belink_token',            // localStorage 键名
+  baseURL: 'https://api.example.com',
+  // ... 其他配置
 });
+```
 
-// Token 管理
-beLinkRequest.setToken(token: string): void           // 设置 Token
-beLinkRequest.getToken(): string | null               // 获取 Token
-beLinkRequest.setupTokenListener(tokenKey): () => void // 监听 Token 变化
+#### HTTP 方法
 
-// HTTP 方法
-beLinkRequest.get<T>(url: string, config?): Promise<ApiResponse<T>>
-beLinkRequest.post<T>(url: string, data?, config?): Promise<ApiResponse<T>>
-beLinkRequest.put<T>(url: string, data?, config?): Promise<ApiResponse<T>>
-beLinkRequest.delete<T>(url: string, config?): Promise<ApiResponse<T>>
+```typescript
+// GET 请求
+beLinkRequest.get<T>(url: string, config?: AxiosRequestConfig): Promise<T>
 
-// 通用请求
-beLinkRequest.request<T>(config: RequestConfig): Promise<ApiResponse<T>>
+// POST 请求
+beLinkRequest.post<T>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T>
 
-// 时间同步（向后兼容）
-beLinkRequest.setupRequestTime(config): Promise<void>  // 设置请求时间
-beLinkRequest.removeRequestTime(): Promise<void>       // 清除请求时间
-```
+// PUT 请求
+beLinkRequest.put<T>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T>
 
-### beLinkLiveRequest - 直播请求客户端
+// PATCH 请求
+beLinkRequest.patch<T>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T>
 
-**使用场景**: 直播、公开 API、不需要用户认证的场景。
+// DELETE 请求
+beLinkRequest.delete<T>(url: string, config?: AxiosRequestConfig): Promise<T>
 
-**特性**:
+// 通用请求
+beLinkRequest.request<T>(config: AxiosRequestConfig): Promise<T>
+```
 
-- 简化版客户端，无 Token 加密
-- 无时间同步
-- 无 401 处理
-- 支持配置 baseUrl 和 tokenHeaderName
+#### 其他方法
 
 ```typescript
-import { beLinkLiveRequest } from '@be-link/request';
+// 获取时间同步服务实例
+beLinkRequest.getTimeSyncService(): TimeSyncService | null
 
-// 初始化
-beLinkLiveRequest.init({
-  baseUrl: 'https://live-api.example.com',
-  tokenHeaderName: 'x-live-authorization', // 可选
-});
+// 获取加密服务实例
+beLinkRequest.getEncryptionService(): EncryptionService | null
 
-// 发起请求
-const data = await beLinkLiveRequest.post('/api/live/room', { roomId: '123' });
-const info = await beLinkLiveRequest.get('/api/live/info');
+// 获取 Axios 实例
+beLinkRequest.getAxiosInstance(): AxiosInstance | null
+
+// 重置客户端（清除配置，需重新 init）
+beLinkRequest.reset(): void
 ```
 
-### request - 基础请求
+### 配置选项 RequestOptions
 
-**使用场景**: 调用第三方 API、简单的 HTTP 请求、不需要任何认证处理的场景。
+| 参数             | 类型                                | 必填 | 默认值          | 说明               |
+| ---------------- | ----------------------------------- | :--: | --------------- | ------------------ |
+| baseURL          | `string`                            |  ✅  | -               | API 基础地址       |
+| timeout          | `number`                            |  ❌  | 30000           | 请求超时时间（ms） |
+| headers          | `Record<string, string>`            |  ❌  | {}              | 默认请求头         |
+| timeSync         | `TimeSyncConfig`                    |  ❌  | -               | 时间同步配置       |
+| encryption       | `EncryptionConfig`                  |  ❌  | -               | 加密配置           |
+| getToken         | `() => string \| null \| undefined` |  ❌  | -               | Token 获取函数     |
+| getUserId        | `() => string \| null \| undefined` |  ❌  | -               | 用户 ID 获取函数   |
+| tokenHeaderName  | `string`                            |  ❌  | X-BeLink-Token  | Token Header 名称  |
+| userIdHeaderName | `string`                            |  ❌  | X-BeLink-UserId | UserId Header 名称 |
+| onRequest        | `(config) => config`                |  ❌  | -               | 自定义请求拦截器   |
+| onResponse       | `(response) => response`            |  ❌  | -               | 自定义响应拦截器   |
+| onError          | `(error) => any`                    |  ❌  | -               | 自定义错误处理     |
 
-```typescript
-import { request } from '@be-link/request';
+### TimeSyncConfig
 
-const result = await request({
-  url: 'https://api.example.com/data',
-  method: 'post',
-  data: { key: 'value' },
-});
-```
+| 参数          | 类型      | 必填 | 默认值 | 说明                  |
+| ------------- | --------- | :--: | ------ | --------------------- |
+| enabled       | `boolean` |  ❌  | true   | 是否启用时间同步      |
+| syncUrl       | `string`  |  ✅  | -      | 时间同步接口 URL      |
+| syncGapTime   | `number`  |  ❌  | 50000  | 同步间隔阈值（毫秒）  |
+| storagePrefix | `string`  |  ❌  | -      | localStorage key 前缀 |
+
+### EncryptionConfig
+
+| 参数    | 类型      | 必填 | 默认值 | 说明           |
+| ------- | --------- | :--: | ------ | -------------- |
+| enabled | `boolean` |  ❌  | true   | 是否启用加密   |
+| key     | `string`  |  ✅  | -      | 16 位 AES 密钥 |
+| iv      | `string`  |  ✅  | -      | 16 位 AES IV   |
 
-### callFunction - 云函数调用
+## 使用示例
 
-**使用场景**: 调用腾讯云 CloudBase 云函数。
+### 基础请求
 
 ```typescript
-import { callFunction } from '@be-link/request';
-
-// 调用云函数
-const result = await callFunction({
-  name: 'cloud-function-name',
-  data: {
-    moduleName: 'biz',
-    serviceName: 'main',
-    funcName: 'getUserInfo',
-    param: { userId: '123' },
-  },
-});
+import { beLinkRequest } from '@be-link/request';
 
-// 带操作用户信息（会自动注入）
-const result = await callFunction({
-  name: 'cloud-function-name',
-  data: {
-    moduleName: 'biz',
-    serviceName: 'main',
-    funcName: 'createOrder',
-    param: { productId: '456' },
-    operateUser: { name: 'staffName' }, // 可选，会自动注入
-  },
+// 初始化
+beLinkRequest.init({
+  baseURL: 'https://api.example.com',
 });
-```
-
-## 多服务配置
 
-当页面需要调用多个不同域名的服务时，可以配置不同的 `tokenStorageKey` 避免冲突：
+// GET 请求
+const users = await beLinkRequest.get('/api/users');
 
-```typescript
-import { BeLinkClient } from '@be-link/request';
+// 带参数的 GET 请求
+const user = await beLinkRequest.get('/api/users/1', {
+  params: { include: 'profile' },
+});
 
-// 服务 A
-const serviceA = new BeLinkClient();
-serviceA.init({
-  mode: 'production',
-  baseUrl: 'https://api-a.example.com',
-  tokenHeaderName: 'x-service-a-auth',
-  tokenStorageKey: 'service_a_token',
+// POST 请求
+const newUser = await beLinkRequest.post('/api/users', {
+  name: '张三',
+  age: 25,
 });
 
-// 服务 B
-const serviceB = new BeLinkClient();
-serviceB.init({
-  mode: 'production',
-  baseUrl: 'https://api-b.example.com',
-  tokenHeaderName: 'x-service-b-auth',
-  tokenStorageKey: 'service_b_token',
+// PUT 请求
+const updated = await beLinkRequest.put('/api/users/1', {
+  name: '李四',
 });
 
-// localStorage 结构：
-// {
-//   "service_a_token": "token_for_service_a",
-//   "service_b_token": "token_for_service_b"
-// }
+// DELETE 请求
+await beLinkRequest.delete('/api/users/1');
 ```
 
-## 初始化配置
+### 带类型的请求
 
-### init 配置项
+```typescript
+interface User {
+  id: number;
+  name: string;
+  age: number;
+}
 
-| 参数            | 类型                                         | 必填 | 默认值                     | 说明                  |
-| --------------- | -------------------------------------------- | :--: | -------------------------- | --------------------- |
-| mode            | `'development' \| 'testing' \| 'production'` |  ✅  | -                          | 运行模式              |
-| baseUrl         | `string`                                     |  ❌  | -                          | API 基础地址          |
-| loginPath       | `string \| (() => void)`                     |  ❌  | -                          | 401 时跳转路径或回调  |
-| tokenHeaderName | `string`                                     |  ❌  | `'x-belink-authorization'` | Token 请求头名称      |
-| tokenStorageKey | `string`                                     |  ❌  | `'token'`                  | localStorage 存储键名 |
+interface ApiResult<T> {
+  success: boolean;
+  data: T;
+  message?: string;
+}
 
-### RequestConfig
+// 指定响应类型
+const result = await beLinkRequest.get<ApiResult<User[]>>('/api/users');
+console.log(result.data); // User[]
 
-```typescript
-interface RequestConfig<D = any> {
-  url: string; // 请求 URL
-  method?: 'get' | 'post' | 'put' | 'delete' | 'patch'; // HTTP 方法
-  headers?: Record<string, string>; // 请求头
-  params?: Record<string, any>; // URL 参数
-  data?: D; // 请求体
-  timeout?: number; // 超时时间（毫秒）
-  withCredentials?: boolean; // 是否携带凭证
-  customToken?: string; // 自定义 Token
-}
+const user = await beLinkRequest.post<ApiResult<User>>('/api/users', {
+  name: '张三',
+  age: 25,
+});
+console.log(user.data); // User
 ```
 
-### 响应格式
+### 错误处理
 
 ```typescript
-interface ApiResponse<T = any> {
-  data: T; // 响应数据
-  code: number; // 状态码
-  msg: string; // 消息
-  success: boolean; // 是否成功
-}
+beLinkRequest.init({
+  baseURL: 'https://api.example.com',
+  onError: (error) => {
+    // 处理 401 未授权
+    if (error.response?.status === 401) {
+      localStorage.removeItem('token');
+      window.location.href = '/login';
+      return;
+    }
+
+    // 处理业务错误
+    if (error.data?.message) {
+      alert(error.data.message);
+    }
+
+    throw error;
+  },
+});
 ```
 
-## 拦截器
+### 多实例场景
 
-### 添加自定义拦截器
+如果需要创建多个独立的请求实例，可以使用 `BeLinkRequest` 类：
 
 ```typescript
-import { beLinkRequest } from '@be-link/request';
+import { BeLinkRequest } from '@be-link/request';
 
-// 添加请求拦截器
-const removeInterceptor = beLinkRequest.addRequestInterceptor({
-  name: 'CustomInterceptor',
-  priority: 10, // 数字越小优先级越高
-  onRequest: async (context) => {
-    // 修改请求配置
-    context.config.headers['X-Custom'] = 'value';
-    return context;
-  },
+// 创建实例 A
+const serviceA = new BeLinkRequest();
+serviceA.init({
+  baseURL: 'https://api-a.example.com',
 });
 
-// 添加响应拦截器
-beLinkRequest.addResponseInterceptor({
-  name: 'LogInterceptor',
-  priority: 10,
-  onResponse: async (context) => {
-    console.log('Response:', context.response);
-    return context;
-  },
-  onResponseError: async (error) => {
-    console.error('Error:', error);
-    throw error;
-  },
+// 创建实例 B
+const serviceB = new BeLinkRequest();
+serviceB.init({
+  baseURL: 'https://api-b.example.com',
 });
 
-// 移除拦截器
-removeInterceptor();
+// 分别使用
+const dataA = await serviceA.get('/api/data');
+const dataB = await serviceB.get('/api/data');
 ```
 
-### 内置拦截器（BeLinkClient）
-
-| 拦截器           | 优先级 | 功能                       |
-| ---------------- | :----: | -------------------------- |
-| TimeInterceptor  |   1    | 时间同步，添加服务器时间头 |
-| TokenInterceptor |   2    | Token 加密，添加认证头     |
-| AuthInterceptor  |   1    | 401 响应处理，跳转登录     |
+## 工作流程
 
-## 错误处理
+### Token 加密流程
 
-```typescript
-import { beLinkRequest, HttpError, AuthError, TimeoutError, NetworkError } from '@be-link/request';
-
-try {
-  const data = await beLinkRequest.get('/api/data');
-} catch (error) {
-  if (error instanceof AuthError) {
-    // 401 认证错误，会自动跳转登录页
-    console.log('认证失败');
-  } else if (error instanceof TimeoutError) {
-    console.log('请求超时');
-  } else if (error instanceof NetworkError) {
-    console.log('网络错误');
-  } else if (error instanceof HttpError) {
-    console.log('HTTP 错误:', error.status);
-  }
-}
+```
+请求发起时:
+┌─────────────┐     ┌──────────────────┐     ┌─────────────────┐
+│  getToken() │────>│ EncryptionService│────>│   请求头        │
+│  获取 Token │     │ AES(token|+|time)│     │ Authorization   │
+└─────────────┘     └──────────────────┘     └─────────────────┘
+                            │
+                            ▼
+                    TimeSyncService
+                    (服务器时间校正)
 ```
 
-## 环境变量
+### 时间同步流程
 
-支持通过环境变量配置加密密钥：
+```
+1. 请求发起前检查本地时间是否需要同步
+2. 如果超过同步间隔阈值（默认 50 秒），发起同步请求
+3. 将服务器时间和客户端时间存储到 localStorage
+4. 后续加密时使用校正后的时间戳
+```
 
-```bash
-# Vite
-VITE_BELINK_ENCRYPTION_KEY=your-key
-VITE_BELINK_ENCRYPTION_IV=your-iv
+#### 并发控制
 
-# Webpack/Node
-BELINK_ENCRYPTION_KEY=your-key
-BELINK_ENCRYPTION_IV=your-iv
-```
+当多个请求同时发起时，时间同步使用 Promise 锁机制，确保只发起一次同步请求：
 
-## 类型导出
+```
+请求1 ──┬── ensureSync() ──> 发起同步 ──> 等待完成 ──> 继续请求
+请求2 ──┤                        ↓
+请求3 ──┼── ensureSync() ──> 检测到锁 ──> 等待同一个 Promise ──> 继续请求
+请求4 ──┤
+请求5 ──┘
+```
 
-```typescript
-// 请求相关
-export type { RequestConfig, RequestContext, IConfig, HttpMethod } from '@be-link/request';
+#### 防止系统时间篡改
 
-// 响应相关
-export type { ApiResponse, ResponseContext, IApiResponse } from '@be-link/request';
+使用 `performance.now()` 替代 `Date.now()` 计算时间流逝：
 
-// 拦截器
-export type { RequestInterceptor, ResponseInterceptor } from '@be-link/request';
+- `performance.now()` 返回页面加载后的高精度时间，不受系统时间修改影响
+- 即使用户修改系统时间，Token 加密的时间戳仍然准确
 
-// 配置
-export type { AppConfig, EncryptionConfig, TimeSyncConfig, CloudbaseConfig } from '@be-link/request';
+## 类型导出
 
-// 云函数
-export type { CloudFunctionOptions, CloudFunctionResponse, CloudFunctionData } from '@be-link/request';
+```typescript
+// 单例实例
+import { beLinkRequest } from '@be-link/request';
 
-// 错误类
-export { BaseError, HttpError, AuthError, TimeoutError, ConfigError, NetworkError } from '@be-link/request';
+// 类（用于多实例）
+import { BeLinkRequest } from '@be-link/request';
 
-// 客户端类
-export { HttpClient, BeLinkClient, LiveClient } from '@be-link/request';
+// 服务类
+import { TimeSyncService, EncryptionService } from '@be-link/request';
 
-// 工具函数
-export { isBrowser, isNode, detectEnvironment } from '@be-link/request';
+// 配置类型
+import type { RequestOptions, TimeSyncConfig, EncryptionConfig, ApiResponse } from '@be-link/request';
 ```
 
 ## 完整示例
 
 ```typescript
-import { beLinkRequest, beLinkLiveRequest, callFunction, HttpError, AuthError } from '@be-link/request';
+import { beLinkRequest } from '@be-link/request';
 
-// 1. 初始化企业级客户端
+// 应用入口初始化
 beLinkRequest.init({
-  mode: process.env.NODE_ENV === 'production' ? 'production' : 'development',
-  baseUrl: 'https://api.example.com',
-  loginPath: () => {
-    window.location.href = '/login';
+  baseURL: import.meta.env.VITE_API_URL,
+  timeout: 30000,
+
+  // 时间同步
+  timeSync: {
+    syncUrl: `${import.meta.env.VITE_API_URL}/api/time`,
   },
-  tokenStorageKey: 'app_token',
-});
 
-// 2. 初始化直播客户端
-beLinkLiveRequest.init({
-  baseUrl: 'https://live-api.example.com',
-});
+  // Token 加密
+  encryption: {
+    key: import.meta.env.VITE_ENCRYPTION_KEY,
+    iv: import.meta.env.VITE_ENCRYPTION_IV,
+  },
 
-// 3. 设置 Token（登录后）
-const token = localStorage.getItem('app_token');
-if (token) {
-  beLinkRequest.setToken(token);
-}
+  // Token 获取
+  getToken: () => localStorage.getItem('token'),
+
+  // 用户 ID
+  getUserId: () => {
+    const user = JSON.parse(localStorage.getItem('user') || '{}');
+    return user.id;
+  },
 
-// 4. 监听 Token 变化
-beLinkRequest.setupTokenListener('app_token');
-
-// 5. 发起业务请求
-async function fetchUserInfo(userId: string) {
-  try {
-    const response = await beLinkRequest.get<{ name: string; age: number }>(`/api/users/${userId}`);
-    return response.data;
-  } catch (error) {
-    if (error instanceof AuthError) {
-      // 自动跳转登录页
-      return null;
+  // 错误处理
+  onError: (error) => {
+    if (error.response?.status === 401) {
+      localStorage.removeItem('token');
+      window.location.href = '/login';
     }
     throw error;
-  }
+  },
+});
+
+// API 调用
+async function getUserInfo(userId: string) {
+  return beLinkRequest.get(`/api/users/${userId}`);
+}
+
+async function createUser(data: { name: string; age: number }) {
+  return beLinkRequest.post('/api/users', data);
 }
 
-// 6. 发起直播请求
-async function getLiveRoomInfo(roomId: string) {
-  const response = await beLinkLiveRequest.get(`/api/room/${roomId}`);
-  return response.data;
+async function updateUser(userId: string, data: { name?: string; age?: number }) {
+  return beLinkRequest.put(`/api/users/${userId}`, data);
 }
 
-// 7. 调用云函数
-async function createOrder(productId: string) {
-  const result = await callFunction({
-    name: 'order-service',
-    data: {
-      moduleName: 'order',
-      serviceName: 'main',
-      funcName: 'create',
-      param: { productId },
-    },
-  });
-  return result;
+async function deleteUser(userId: string) {
+  return beLinkRequest.delete(`/api/users/${userId}`);
 }
 ```