@polyv/request-core 2.0.0

package/README.md

@@ -0,0 +1,171 @@
+# 保利威业务请求库
+
+保利威前端项目请求库，用于前端项目的请求封装。
+
+## 安装
+
+```
+npm install @polyv/request-core --save
+```
+
+## 使用
+
+```js
+import { PolyvRequest } from '@polyv/request-core';
+
+// 实例化请求器
+const requester = new PolyvRequest({
+  baseUrl: '//api.polyv.net',
+});
+
+(async () => {
+  // 执行请求
+  const data = await requester.get('/getDetail', {
+    channelId: 'xxxx'
+  });
+
+  console.log(data);
+})();
+```
+
+使用 Typescript：
+
+```ts
+// 自定义请求选项
+interface CustomRequestOptions {
+  test?: boolean;
+}
+
+// 实例化请求器
+const requester = new PolyvRequest<CustomRequestOptions>({
+  baseUrl: '//api.polyv.net',
+});
+
+interface ChannelDetail {
+  channelName: string;
+}
+
+(async () => {
+  // 执行请求
+  const data = await requester.get<ChannelDetail>('/getDetail', {
+    channelId: 'xxxx'
+  }, {
+    test: true
+  });
+
+  console.log(data.channelName);
+})();
+```
+
+## 实例化参数
+
+| 参数名 | 用途 | 类型 | 默认值 |
+| - | - | - | - |
+| baseUrl | 接口请求地址前缀 | `string \| function` | `''` |
+| requestPlugins | 请求插件 | `RequestPlugin[]` | `[]` |
+| timeout | 超时时间，毫秒 | `number` | `10000` |
+| requestType | 请求方式 | `RequestType` | `'form'` |
+| responseType | 响应格式 | `ResponseType` | `'json'` |
+| withCredentials | 跨域请求时是否提供凭据 | `boolean` | `false` |
+
+## 发送请求
+
+### 发送 GET 请求
+
+```ts
+// 后端接口返回的 Response
+interface ChannelDetailResponse {
+  code: number;
+  data: {
+    /** 频道名称 */
+    channelName: string;
+  }
+}
+
+// 接口入参参数
+interface ChannelDetailRequestParams {
+  /** 频道号 */
+  channelId: string;
+}
+
+const res = await requester.get<ChannelDetailResponse, ChannelDetailRequestParams>(
+  '/getDetail',
+  {
+    channelId: 'xxxx'
+  }
+);
+
+console.log('code', res.code);
+console.log('channelName', res.data.channelName);
+```
+
+### 发送 POST 请求
+
+```ts
+interface Response {
+  code: number;
+  message: string;
+}
+
+interface RequestData {
+  userId: number;
+  name: string;
+}
+
+const res = await requester.post<Response, RequestData>(
+  '/save-name',
+  {
+    userId: 123,
+    name: '小明'
+  },
+  {
+    // 如果需要额外入参地址参数
+    params: {
+      channelId: 'xxx'
+    }
+  }
+);
+
+if (res.code === 200) {
+  console.log('提交成功');
+}
+```
+
+## 请求选项
+
+请求器实例的 `get`、`post` 方法的第三个入参为请求选项，详细类型查看 `RequestOptions` 类型。
+
+## 请求插件
+
+`@polyv/request-plugin-xxx` 为请求库的插件，使用方式如下：
+
+```ts
+import { PolyvRequest } from '@polyv/request-core';
+import { GlobalParamsRequestPlugin } from '@polyv/request-plugin-global-params';
+import { StatusCodeRequestPlugin } from '@polyv/request-plugin-status-code';
+
+const requester = new PolyvRequest({
+  requestPlugins: [
+    // 创建插件并传入 requestPlugins
+    new GlobalParamsRequestPlugin({
+      globalParams: {
+        viewerId: 'xxx',
+        channelId: 'xxx',
+      },
+    }),
+    new StatusCodeRequestPlugin(),
+  ]
+});
+```
+
+### 插件概览
+
+| 插件名 | 用途 |
+| - | - |
+| [@polyv/request-plugin-global-params](https://npm-registry.polyv.net/-/web/detail/@polyv/request-plugin-global-params) | 全局 params 入参插件 |
+| [@polyv/request-plugin-authorize-token](https://npm-registry.polyv.net/-/web/detail/@polyv/request-plugin-authorize-token) | 请求令牌插件 |
+| [@polyv/request-plugin-authorize-app-sign](https://npm-registry.polyv.net/-/web/detail/@polyv/request-plugin-authorize-app-sign) | 请求签名插件 |
+| [@polyv/request-plugin-status-code](https://npm-registry.polyv.net/-/web/detail/@polyv/request-plugin-status-code) | 状态码处理插件 |
+| [@polyv/request-plugin-aes-decrypt](https://npm-registry.polyv.net/-/web/detail/@polyv/request-plugin-aes-decrypt) | AES 解密响应内容 |
+| [@polyv/request-plugin-aes](https://npm-registry.polyv.net/-/web/detail/@polyv/request-plugin-aes) | AES 业务请求加密和解密 |
+| [@polyv/request-plugin-sm2](https://npm-registry.polyv.net/-/web/detail/@polyv/request-plugin-sm2) | SM2 业务请求加密和解密 |

package/ajax.d.ts

@@ -0,0 +1,60 @@
+import { PolyvRequestConfig, RequestOptions } from './interface';
+/**
+ * API 请求封装
+ */
+export declare class PolyvRequest<Options extends RequestOptions = RequestOptions> {
+    /** 是否已被销毁（不再允许执行 ajax 调用） */
+    private __isDestroyed;
+    /** 请求域名前缀 */
+    private __baseUrl;
+    private __timeout;
+    private __requestType;
+    private __responseType;
+    private __withCredentials;
+    /** 请求器 */
+    private __xhrRequest;
+    private __pluginCtrl;
+    constructor(options?: PolyvRequestConfig<Options>);
+    /**
+     * 修改请求前缀
+     * @param baseUrl 新的请求前缀
+     * @returns this
+     */
+    setBaseUrl(baseUrl: string): void;
+    /**
+     * 生成请求地址，插入 baseUrl
+     */
+    generateUrl(options: Options): string;
+    /** 发起请求 */
+    protected _request<R = unknown>(options: Options): Promise<R>;
+    private __beforeSend;
+    /**
+     * 请求拦截
+     */
+    private __interceptRequest;
+    /**
+     * 响应拦截
+     */
+    private __interceptResponse;
+    /**
+     * 过滤请求中的 params 和 data，将 undefined 的字段移除
+     * @param target 目标对象
+     */
+    private __filterParamsData;
+    /** 发起 get 请求 */
+    get<R = unknown, P = object>(url: string, params: P, options?: Options): Promise<R>;
+    /** 发起 post 请求 */
+    post<R = unknown, D = object>(url: string, data: D, options?: Options): Promise<R>;
+    /** 发起 delete 请求 */
+    delete<R = unknown, D = object>(url: string, data: D, options?: Options): Promise<R>;
+    /** 发起 put 请求 */
+    put<R = unknown, D = object>(url: string, data: D, options?: Options): Promise<R>;
+    /**
+     * 解析响应头
+     * @param headerStr 响应头字符串
+     * @returns 响应头对象
+     */
+    private __parseResponseHeaders;
+    destroy(): void;
+}
+export default PolyvRequest;

package/ajax.js

@@ -0,0 +1,222 @@
+/* eslint-disable @typescript-eslint/ban-types */
+import { Request } from '@just4/request';
+import { xhrAdapter } from '@just4/request/adapter/xhr';
+import { startsWithProtocol } from '@polyv/utils/es/net';
+import { PluginController } from './plugins/plugin-controller';
+import { buildFormData, hasFileValue } from './utils';
+import { DEFAULT_REQUEST_TYPE, DEFAULT_RESPONSE_TYPE } from './config';
+let xhrRequest;
+/**
+ * API 请求封装
+ */
+export class PolyvRequest {
+    /** 是否已被销毁（不再允许执行 ajax 调用） */
+    __isDestroyed = false;
+    /** 请求域名前缀 */
+    __baseUrl = '';
+    __timeout;
+    __requestType;
+    __responseType;
+    __withCredentials;
+    /** 请求器 */
+    __xhrRequest;
+    __pluginCtrl;
+    constructor(options = {}) {
+        const { baseUrl } = options;
+        if (baseUrl) {
+            this.setBaseUrl(baseUrl);
+        }
+        this.__timeout = options.timeout || 10000;
+        this.__requestType = options.requestType || DEFAULT_REQUEST_TYPE;
+        this.__responseType = options.responseType || DEFAULT_RESPONSE_TYPE;
+        this.__withCredentials = options.withCredentials ?? false;
+        if (!xhrRequest) {
+            xhrRequest = new Request(xhrAdapter);
+        }
+        this.__xhrRequest = xhrRequest;
+        const requestPlugins = (options.requestPlugins || []);
+        this.__pluginCtrl = new PluginController(requestPlugins);
+    }
+    /**
+     * 修改请求前缀
+     * @param baseUrl 新的请求前缀
+     * @returns this
+     */
+    setBaseUrl(baseUrl) {
+        this.__baseUrl = baseUrl;
+    }
+    /**
+     * 生成请求地址，插入 baseUrl
+     */
+    generateUrl(options) {
+        if (options.requestUrl) {
+            return options.requestUrl;
+        }
+        const url = options.url || '';
+        let baseUrl = '';
+        if (typeof this.__baseUrl === 'string') {
+            baseUrl = this.__baseUrl;
+        }
+        // if (typeof this.__baseUrl === 'function') {
+        //   baseUrl = this.__baseUrl();
+        // }
+        if (!baseUrl || startsWithProtocol(url)) {
+            return url;
+        }
+        return baseUrl + url;
+    }
+    /** 发起请求 */
+    async _request(options) {
+        if (this.__isDestroyed) {
+            return Promise.reject(new Error('Ajax has been destroyed.'));
+        }
+        let _options = { ...options };
+        // 处理请求地址
+        const orignRequestUrl = this.generateUrl(_options);
+        _options.requestUrl = orignRequestUrl;
+        // 超时时间
+        _options.timeout = _options.timeout || this.__timeout;
+        // 请求方式
+        _options.requestType = _options.requestType || this.__requestType;
+        _options.responseType = _options.responseType || this.__responseType;
+        _options.withCredentials = _options.withCredentials || this.__withCredentials;
+        // 处理插件中的请求拦截
+        _options = await this.__interceptRequest(_options);
+        // 处理后的请求地址
+        const requestUrl = _options.requestUrl || orignRequestUrl;
+        // 做最后一步处理
+        _options = this.__beforeSend(_options);
+        let result;
+        try {
+            // 调用请求库
+            const justRes = await this.__xhrRequest.send(requestUrl, {
+                ..._options,
+            });
+            const headers = this.__parseResponseHeaders(justRes.xhr.getAllResponseHeaders());
+            // 请求结果
+            result = {
+                data: justRes.data,
+                headers,
+            };
+        }
+        catch (e) {
+            const error = e;
+            const justRes = error.result;
+            result = {
+                data: justRes.data,
+            };
+        }
+        if (!result) {
+            throw Error('result is undefined');
+        }
+        // 处理插件中的响应拦截
+        result = await this.__interceptResponse(result, _options);
+        return result.data;
+    }
+    __beforeSend(options) {
+        const data = options.data || {};
+        // 处理 formData 提交
+        if (options.method === 'POST' && options.requestType === 'form' && typeof data === 'object') {
+            const useFormData = options.useFormData ?? hasFileValue(data);
+            if (useFormData) {
+                options.data = buildFormData(data);
+            }
+        }
+        return options;
+    }
+    /**
+     * 请求拦截
+     */
+    async __interceptRequest(options) {
+        let newOptions = options;
+        // 处理插件中的请求拦截
+        newOptions = await this.__pluginCtrl.interceptPluginRequest(newOptions);
+        return newOptions;
+    }
+    /**
+     * 响应拦截
+     */
+    async __interceptResponse(result, options) {
+        let newResult = result;
+        // 处理插件中的响应拦截
+        newResult = await this.__pluginCtrl.interceptPluginResponse(newResult, options);
+        return newResult;
+    }
+    /**
+     * 过滤请求中的 params 和 data，将 undefined 的字段移除
+     * @param target 目标对象
+     */
+    __filterParamsData(target) {
+        const obj = {};
+        for (const key in target) {
+            const val = target[key];
+            if (typeof val !== 'undefined') {
+                obj[key] = val;
+            }
+        }
+        return obj;
+    }
+    /** 发起 get 请求 */
+    get(url, params, options) {
+        return this._request(Object.assign({
+            url,
+            method: 'GET',
+            params: this.__filterParamsData(params),
+        }, options));
+    }
+    /** 发起 post 请求 */
+    post(url, data, options) {
+        return this._request(Object.assign({
+            url,
+            method: 'POST',
+            data: this.__filterParamsData(data),
+        }, options));
+    }
+    /** 发起 delete 请求 */
+    delete(url, data, options) {
+        return this._request(Object.assign({
+            url,
+            method: 'DELETE',
+            data: this.__filterParamsData(data),
+        }, options));
+    }
+    /** 发起 put 请求 */
+    put(url, data, options) {
+        return this._request(Object.assign({
+            url,
+            method: 'PUT',
+            data: this.__filterParamsData(data),
+        }, options));
+    }
+    /**
+     * 解析响应头
+     * @param headerStr 响应头字符串
+     * @returns 响应头对象
+     */
+    __parseResponseHeaders(headerStr) {
+        const headers = {};
+        // 如果字符串为空，则返回空对象
+        if (!headerStr) {
+            return headers;
+        }
+        // 按行分割头信息
+        const headerPairs = headerStr.trim().split('\r\n');
+        headerPairs.forEach(headerPair => {
+            // 查找第一个冒号的位置
+            const index = headerPair.indexOf(':');
+            // 如果找不到冒号，则跳过此行
+            if (index > 0) {
+                // 提取键（转为小写）和值（去除前后空格）
+                const key = headerPair.substring(0, index).trim().toLowerCase();
+                const value = headerPair.substring(index + 1).trim();
+                // 保存到结果对象
+                headers[key] = value;
+            }
+        });
+        return headers;
+    }
+    destroy() {
+        this.__isDestroyed = true;
+    }
+}
+export default PolyvRequest;

package/axios-interceptor.d.ts

@@ -0,0 +1,10 @@
+import { AxiosInstance } from 'axios';
+import { PolyvRequestConfig, RequestType } from './interface';
+export type SetupAxiosInterceptorConfig = Pick<PolyvRequestConfig, 'baseUrl' | 'timeout' | 'requestPlugins'>;
+declare module 'axios' {
+    interface AxiosRequestConfig {
+        /** 请求类型 */
+        requestType?: RequestType;
+    }
+}
+export declare function setupAxiosInterceptor(axios: AxiosInstance, config?: PolyvRequestConfig): void;

package/axios-interceptor.js

@@ -0,0 +1,62 @@
+import { PluginController } from './plugins/plugin-controller';
+import { DEFAULT_REQUEST_TYPE } from './config';
+export function setupAxiosInterceptor(axios, config = {}) {
+    const pluginController = new PluginController(config.requestPlugins || []);
+    // 处理默认配置
+    if (config.baseUrl) {
+        axios.defaults.baseURL = config.baseUrl;
+    }
+    if (config.timeout) {
+        axios.defaults.timeout = config.timeout;
+    }
+    if (config.responseType) {
+        axios.defaults.responseType = config.responseType;
+    }
+    // 注入请求拦截器
+    axios.interceptors.request.use(async (options) => {
+        const axiosHeaders = options.headers;
+        const headers = axiosHeaders.toJSON();
+        const requestOptions = {
+            ...options,
+            params: options.params,
+            data: options.data,
+            headers,
+            requestType: options.requestType || config.requestType || DEFAULT_REQUEST_TYPE,
+        };
+        const newOptions = await pluginController.interceptPluginRequest(requestOptions);
+        options.params = newOptions.params;
+        options.data = newOptions.data;
+        // 将新的请求头重新设置会 axios 中
+        const newHeaders = newOptions.headers;
+        if (newHeaders) {
+            for (const key in newHeaders) {
+                options.headers.set(key, newHeaders[key]);
+            }
+        }
+        // 处理请求选项
+        if (newOptions.requestType && options.method?.toLocaleUpperCase() === 'POST') {
+            const reqTypes = {
+                json: 'application/json;charset=UTF-8',
+                form: 'application/x-www-form-urlencoded'
+            };
+            options.headers.setAccept('*/*');
+            options.headers.setContentType(reqTypes[newOptions.requestType]);
+        }
+        return options;
+    });
+    // 注入响应拦截器
+    axios.interceptors.response.use(async (response) => {
+        let headers = response.headers;
+        if (response.headers && typeof response.headers.toJSON === 'function') {
+            headers = response.headers.toJSON();
+        }
+        const result = {
+            data: response.data,
+            headers,
+        };
+        const requestResult = response.config;
+        const newResult = await pluginController.interceptPluginResponse(result, requestResult);
+        response.data = newResult.data;
+        return response;
+    });
+}

package/config.d.ts

@@ -0,0 +1,3 @@
+import { RequestType, ResponseType } from "./interface";
+export declare const DEFAULT_REQUEST_TYPE: RequestType;
+export declare const DEFAULT_RESPONSE_TYPE: ResponseType;

package/config.js

@@ -0,0 +1,2 @@
+export const DEFAULT_REQUEST_TYPE = 'json';
+export const DEFAULT_RESPONSE_TYPE = 'json';

package/index.d.ts

@@ -0,0 +1,7 @@
+export * from './ajax';
+export * from './request-error';
+export * from './interface';
+export * from './utils';
+export * from './plugins';
+export * from './plugins/plugin-controller';
+export * from './axios-interceptor';

package/index.js

@@ -0,0 +1,7 @@
+export * from './ajax';
+export * from './request-error';
+export * from './interface';
+export * from './utils';
+export * from './plugins';
+export * from './plugins/plugin-controller';
+export * from './axios-interceptor';

package/interface/index.d.ts

@@ -0,0 +1,118 @@
+import { RequestPlugin } from '../plugins';
+export type BaseUrlFn = () => string;
+export interface PolyvRequestConfig<Options extends RequestOptions = RequestOptions> {
+    /**
+     * 接口请求地址前缀
+     * @default ''
+     */
+    baseUrl?: string;
+    /**
+     * 超时时间，单位：毫秒
+     * @default 10000
+     */
+    timeout?: number;
+    /**
+     * 请求方式，form 或 json。POST 或 PUT 时有效，默认为 form
+     */
+    requestType?: RequestType;
+    /**
+     * 响应格式，默认为 json
+     */
+    responseType?: ResponseType;
+    /**
+     * 请求插件
+     */
+    requestPlugins?: RequestPlugin<Options>[];
+    /**
+     * 跨域请求时是否提供凭据，默认：false
+     */
+    withCredentials?: boolean;
+}
+/**
+ * 请求方法。
+ */
+export type RequestMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+/**
+ * 请求格式。
+ */
+export type RequestType = 'form' | 'json';
+/**
+ * 响应格式。
+ */
+export type ResponseType = 'json' | 'text' | 'blob' | 'arraybuffer';
+/**
+ * 请求公用选项
+ */
+export interface RequestBasicOptions {
+    /**
+     * 请求地址
+     */
+    url?: string;
+    /**
+     * 完整的请求地址
+     */
+    requestUrl?: string;
+    /**
+     * 请求方式
+     */
+    method?: RequestMethod;
+    /**
+     * URL 参数。
+     */
+    params?: object;
+    /**
+     * 请求体数据。
+     */
+    data?: object | string;
+    /**
+     * 自定义请求头。
+     */
+    headers?: object;
+    /**
+     * 超时时间，单位：毫秒
+     * @default 10000
+     */
+    timeout?: number;
+    /**
+     * 请求方式，form 或 json。POST 或 PUT 时有效，默认为 json
+     */
+    requestType?: RequestType;
+    /**
+     * 响应格式，默认为 json
+     */
+    responseType?: ResponseType;
+    /**
+     * 跨域请求时是否提供凭据
+     */
+    withCredentials?: boolean;
+}
+export interface RequestCustomOptions {
+}
+/**
+ * 请求选项
+ */
+export interface RequestOptions extends RequestBasicOptions, RequestCustomOptions {
+    /**
+     * 使用 formData 提交
+     */
+    useFormData?: boolean;
+}
+/**
+ * 请求结果
+ */
+export interface RequestResult {
+    /**
+     * 接口响应数据
+     */
+    data?: unknown;
+    /**
+     * 响应头对象
+     */
+    headers?: Record<string, string>;
+}
+export type UniversalParams = {
+    [key: string]: unknown;
+};
+export type RequiredField<T, K extends keyof T> = T & {
+    [P in K]-?: NonNullable<T[P]>;
+};

package/interface/index.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@polyv/request-core",
+  "version": "2.0.0",
+  "main": "./index.js",
+  "peerDependencies": {
+    "axios": ">=1.0.0"
+  },
+  "peerDependenciesMeta": {
+    "axios": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@just4/request": "^0.6.0",
+    "@polyv/utils": "^2.6.0",
+    "md5": "2.3.0",
+    "sha256": "0.2.0"
+  },
+  "types": "./index.d.ts"
+}

package/plugins/index.d.ts

@@ -0,0 +1,56 @@
+import { RequestOptions, RequestResult } from '../interface';
+import { PluginController } from './plugin-controller';
+/**
+ * 请求插件
+ */
+export interface RequestPlugin<Options extends RequestOptions = RequestOptions> {
+    /**
+     * 安装插件钩子
+     * @param pluginController 插件控制器
+     */
+    installPlugin?: (pluginController: PluginController) => void;
+    /**
+     * 是否使用当前插件，不传默认为 true
+     * @param options 请求选项
+     * @returns 是否使用
+     */
+    usePlugin?: (options: Options) => Promise<boolean> | boolean;
+    /**
+     * 插入 params 参数，仅插入参数
+     * @param options 请求选项
+     * @returns 请求选项
+     */
+    interceptIncludeParams?: (options: Options) => Promise<object | void> | object | void;
+    /**
+     * 请求授权
+     * @param options 请求选项
+     * @returns 请求选项
+     */
+    interceptAuthorizeRequest?: (options: Options) => Promise<Options | void> | Options | void;
+    /**
+     * 请求加密
+     * @param options 请求选项
+     * @returns 请求选项
+     */
+    interceptEncryptRequest?: (options: Options) => Promise<Options | void> | Options | void;
+    /**
+     * 请求拦截器
+     * @param options 请求选项
+     * @returns 请求选项
+     */
+    interceptRequest?: (options: Options) => Promise<Options | void> | Options | void;
+    /**
+     * 响应解密
+     * @param result 请求结果
+     * @param options 请求选项
+     * @returns 请求结果
+     */
+    interceptDecryptResponse?: (result: RequestResult, options: Options) => Promise<RequestResult | void> | RequestResult | void;
+    /**
+     * 响应拦截器
+     * @param result 请求结果
+     * @param options 请求选项
+     * @returns 请求结果
+     */
+    interceptResponse?: (result: RequestResult, options: Options) => Promise<RequestResult | void> | RequestResult | void;
+}

package/plugins/index.js

@@ -0,0 +1 @@
+export {};

package/plugins/plugin-controller.d.ts

@@ -0,0 +1,24 @@
+import { RequestOptions, RequestResult } from "../interface";
+import { RequestPlugin } from "./index";
+export declare class PluginController {
+    /** 请求插件 */
+    private __requestPlugins;
+    constructor(plugins: RequestPlugin[]);
+    installPlugin(plugin: RequestPlugin): void;
+    private __getUsePlugin;
+    /**
+     * 遍历请求插件中的某个方法
+     * @param options 请求选项
+     * @param fnName 插件方法名
+     * @param callback 处理回调
+     */
+    private __forEachRequestPlugin;
+    /**
+     * 请求拦截
+     */
+    interceptPluginRequest(options: RequestOptions): Promise<RequestOptions>;
+    /**
+     * 响应拦截
+     */
+    interceptPluginResponse(result: RequestResult, options: RequestOptions): Promise<RequestResult>;
+}

package/plugins/plugin-controller.js

@@ -0,0 +1,86 @@
+export class PluginController {
+    /** 请求插件 */
+    __requestPlugins = [];
+    constructor(plugins) {
+        plugins.forEach(plugin => {
+            this.installPlugin(plugin);
+        });
+    }
+    installPlugin(plugin) {
+        this.__requestPlugins.push(plugin);
+        if (plugin.installPlugin) {
+            plugin.installPlugin(this);
+        }
+    }
+    async __getUsePlugin(options, requestPlugin) {
+        if (!requestPlugin.usePlugin) {
+            return true;
+        }
+        const use = await requestPlugin.usePlugin(options);
+        return !!use;
+    }
+    /**
+     * 遍历请求插件中的某个方法
+     * @param options 请求选项
+     * @param fnName 插件方法名
+     * @param callback 处理回调
+     */
+    async __forEachRequestPlugin(options, fnName, callback) {
+        for (let i = 0; i < this.__requestPlugins.length; i++) {
+            const requestPlugin = this.__requestPlugins[i];
+            const usePlugin = await this.__getUsePlugin(options, requestPlugin);
+            if (usePlugin && requestPlugin[fnName]) {
+                await callback(requestPlugin);
+            }
+        }
+    }
+    /**
+     * 请求拦截
+     */
+    async interceptPluginRequest(options) {
+        let newOptions = options;
+        // 处理插件中的 includeParams
+        await this.__forEachRequestPlugin(options, 'interceptIncludeParams', async (requestPlugin) => {
+            const includeParams = await requestPlugin.interceptIncludeParams(newOptions);
+            if (includeParams) {
+                newOptions.params = {
+                    ...(newOptions.params || {}),
+                    ...includeParams,
+                };
+            }
+        });
+        // 处理插件中的请求授权
+        await this.__forEachRequestPlugin(options, 'interceptAuthorizeRequest', async (requestPlugin) => {
+            const r = await requestPlugin.interceptAuthorizeRequest(newOptions);
+            newOptions = r || newOptions;
+        });
+        // 处理插件中的请求加密
+        await this.__forEachRequestPlugin(options, 'interceptEncryptRequest', async (requestPlugin) => {
+            const r = await requestPlugin.interceptEncryptRequest(newOptions);
+            newOptions = r || newOptions;
+        });
+        // 处理插件中的请求
+        await this.__forEachRequestPlugin(options, 'interceptRequest', async (requestPlugin) => {
+            const r = await requestPlugin.interceptRequest(newOptions);
+            newOptions = r || newOptions;
+        });
+        return newOptions;
+    }
+    /**
+     * 响应拦截
+     */
+    async interceptPluginResponse(result, options) {
+        let newResult = result;
+        // 处理插件中的解密
+        await this.__forEachRequestPlugin(options, 'interceptDecryptResponse', async (requestPlugin) => {
+            const r = await requestPlugin.interceptDecryptResponse(newResult, options);
+            newResult = r || newResult;
+        });
+        // 处理插件中的响应
+        await this.__forEachRequestPlugin(options, 'interceptResponse', async (requestPlugin) => {
+            const r = await requestPlugin.interceptResponse(newResult, options);
+            newResult = r || newResult;
+        });
+        return newResult;
+    }
+}

package/request-error.d.ts

@@ -0,0 +1,12 @@
+export interface RequestErrorOptions {
+    code: number;
+    message: string;
+}
+export default class RequestError extends Error {
+    /**
+     * 错误码
+     */
+    code: number;
+    constructor(options: RequestErrorOptions);
+}
+export declare function createRequestError(options: RequestErrorOptions): RequestError;

package/request-error.js

@@ -0,0 +1,14 @@
+export default class RequestError extends Error {
+    /**
+     * 错误码
+     */
+    code;
+    constructor(options) {
+        const { code, message } = options;
+        super(message);
+        this.code = code;
+    }
+}
+export function createRequestError(options) {
+    return new RequestError(options);
+}

package/utils.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 是否存在 File 值
+ * @param data
+ */
+export declare function hasFileValue(data: object): boolean;
+/**
+ * 构建formData对象
+ * @param data 数据
+ */
+export declare function buildFormData(data: object): FormData;

package/utils.js

@@ -0,0 +1,27 @@
+/**
+ * 是否存在 File 值
+ * @param data
+ */
+export function hasFileValue(data) {
+    for (const key in data) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const val = data[key];
+        if (val instanceof File) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * 构建formData对象
+ * @param data 数据
+ */
+export function buildFormData(data) {
+    const form = new FormData();
+    for (const key in data) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const val = data[key];
+        form.append(key, val);
+    }
+    return form;
+}