@fairys/taro-tools-react 0.0.3 → 0.0.5

package/README.md

@@ -1 +1,10 @@
 # 框架 ui 组件库
+
+- [X] 全局弹框
+- [X] 页面布局
+- [X] 请求封装
+- [X] 路由封装
+- [X] 权限管理
+- [X] 用户信息
+
+文档地址：[fairys-taro-react](https://autumn-fairy-tales.github.io/fairys-taro-react/)

package/esm/context/auth.data.instance.d.ts

@@ -6,6 +6,8 @@ export interface AuthDataInstanceState<T = any> {
     token?: string;
     /**权限列表*/
     permissions?: string[];
+    /**菜单权限列表*/
+    menusPermissions?: string[];
     /**数据默认值不使用*/
     __defaultValue?: string;
 }
@@ -41,6 +43,22 @@ export declare class AuthDataInstance<T = any> {
      * @returns 权限列表
      */
     get permissions(): string[];
+    /**
+     * 设置菜单权限列表
+     * @param menusPermissions 菜单权限列表
+     */
+    set menusPermissions(menusPermissions: string[]);
+    /**
+     * 获取菜单权限列表
+     * @returns 菜单权限列表
+     */
+    get menusPermissions(): string[];
+    /**
+     * 判断是否有指定菜单权限
+     * @param menuPermission 菜单权限
+     * @returns 是否有指定菜单权限
+     */
+    hasMenuPermission(menuPermission: string): boolean;
     /**
      * 判断是否有指定权限
      * @param permission 权限

package/esm/context/auth.data.instance.js

@@ -5,7 +5,8 @@ class AuthDataInstance {
     store = proxy({
         userInfo: void 0,
         token: void 0,
-        permissions: void 0
+        permissions: void 0,
+        menusPermissions: void 0
     });
     set userInfo(userInfo) {
         this.store.userInfo = userInfo;
@@ -51,7 +52,28 @@ class AuthDataInstance {
         }
         return this.store.permissions || [];
     }
+    set menusPermissions(menusPermissions) {
+        this.store.menusPermissions = menusPermissions;
+        if (menusPermissions) taro.setStorageSync('menusPermissions', JSON.stringify(menusPermissions));
+        else taro.removeStorageSync('menusPermissions');
+    }
+    get menusPermissions() {
+        if (!this.store.menusPermissions) {
+            const menusPermissions = taro.getStorageSync('menusPermissions');
+            if (menusPermissions) try {
+                this.store.menusPermissions = JSON.parse(menusPermissions);
+            } catch (error) {
+                console.error("\u89E3\u6790\u83DC\u5355\u6743\u9650\u5217\u8868\u5931\u8D25", error);
+            }
+        }
+        return this.store.menusPermissions || [];
+    }
+    hasMenuPermission(menuPermission) {
+        if (!globalSettingDataInstance.store.isEnableAuth) return true;
+        return this.menusPermissions.includes(menuPermission);
+    }
     hasPermission(permission) {
+        if (!globalSettingDataInstance.store.isEnableAuth) return true;
         return this.permissions.includes(permission);
     }
 }

package/esm/context/global.setting.data.instance.d.ts

@@ -25,15 +25,26 @@ export interface GlobalSettingDataInstanceState {
      * @default pages/login/index
      */
     loginPageRoute?: string;
+    /**跳转忽略权限校验的路由*/
+    ignoreAuthRoutes?: string[];
+    /**路由跳转默认使用authDataInstance中的hasMenuPermission 判断是否有菜单权限*/
+    useAuthHasMenuPermission?: boolean;
+    /**是否开启权限校验*/
+    isEnableAuth?: boolean;
     /**数据默认值不使用*/
     __defaultValue?: string;
 }
 export declare class GlobalSettingDataInstance extends ProxyInstanceObjectBase<GlobalSettingDataInstanceState> {
+    defaultStore: GlobalSettingDataInstanceState;
     store: GlobalSettingDataInstanceState;
     /**
      * 扩展全局设置数据状态
      */
     extendStore: (state: Partial<GlobalSettingDataInstanceState>) => void;
+    /**
+     * 判断是否跳转忽略权限校验的路由
+     */
+    isIgnoreAuthRoutes: (route: string) => boolean;
 }
 /**
  * 全局设置数据实例

package/esm/context/global.setting.data.instance.js

@@ -1,15 +1,30 @@
 import { proxy, useSnapshot } from "valtio";
 import { ProxyInstanceObjectBase } from "../utils/valtio/instance.js";
 class GlobalSettingDataInstance extends ProxyInstanceObjectBase {
-    store = proxy({
+    defaultStore = {
         requestSuccessCode: 200,
         tokenFieldName: 'token',
         headerTokenName: 'token',
         tokenExpiredCode: 401,
-        loginPageRoute: 'pages/login/index'
+        loginPageRoute: 'pages/login/index',
+        ignoreAuthRoutes: [],
+        useAuthHasMenuPermission: true,
+        isEnableAuth: true
+    };
+    store = proxy({
+        ...this.defaultStore
     });
     extendStore = (state)=>{
-        this._setValues(state);
+        this._setValues({
+            ...this.defaultStore,
+            ...state
+        });
+    };
+    isIgnoreAuthRoutes = (route)=>{
+        const _route = route.replace(/^\//, '');
+        const _loginPageRoute = this.store.loginPageRoute.replace(/^\//, '');
+        if (_route === _loginPageRoute) return true;
+        return (this.store.ignoreAuthRoutes || []).includes(_route) || (this.store.ignoreAuthRoutes || []).includes(route);
     };
 }
 const globalSettingDataInstance = new GlobalSettingDataInstance();

package/esm/utils/navigate.d.ts

@@ -1,6 +1,6 @@
 import Taro from '@tarojs/taro';
 declare class NavigateInstance {
-    /**判断是否已登录(方法需要在项目入口文件中进行挂载)*/
+    /**判断是否已登录(方法需要在项目入口文件中进行挂载,如果不挂载,默认使用 authDataInstance.hasMenuPermission 判断是否有菜单权限)*/
     isAuth: (url: string) => Promise<boolean> | boolean;
     private _isAuth;
     /**

package/esm/utils/navigate.js

@@ -1,12 +1,19 @@
 import taro from "@tarojs/taro";
+import { globalSettingDataInstance } from "../context/global.setting.data.instance.js";
+import { authDataInstance } from "../context/auth.data.instance.js";
 class NavigateInstance {
     isAuth;
     _isAuth = async (url)=>{
         let isAuthTo = true;
-        if (url && 'function' == typeof this.isAuth) isAuthTo = await this.isAuth(url);
+        const isIgnoreAuthRoutes = globalSettingDataInstance.isIgnoreAuthRoutes(url);
+        const useAuthHasMenuPermission = globalSettingDataInstance.store.useAuthHasMenuPermission;
+        const isEnableAuth = globalSettingDataInstance.store.isEnableAuth;
+        let isAuthFunction = this.isAuth;
+        if (useAuthHasMenuPermission && 'function' != typeof isAuthFunction && isEnableAuth) isAuthFunction = authDataInstance.hasMenuPermission;
+        if (url && 'function' == typeof isAuthFunction && !isIgnoreAuthRoutes && isEnableAuth) isAuthTo = await isAuthFunction(url);
         if (false === isAuthTo) {
             taro.showToast({
-                title: "\u65E0\u6743\u8BBF\u95EE",
+                title: `${url} \u{65E0}\u{6743}\u{8BBF}\u{95EE}`,
                 icon: 'none'
             });
             return false;

package/esm/utils/request.d.ts

@@ -1,5 +1,5 @@
 import Taro from '@tarojs/taro';
-export interface RequestInstanceOptions extends Taro.request.Option<any, any> {
+export interface TaroRequestOption {
     /**模块名称*/
     module?: string;
     /**是否忽略token*/
@@ -7,6 +7,16 @@ export interface RequestInstanceOptions extends Taro.request.Option<any, any> {
     /**是否提示错误信息*/
     isShowErrorMessage?: boolean;
 }
+export interface RequestInstanceOptions extends Taro.request.Option<any, any>, TaroRequestOption {
+}
+export interface DownloadFileOptions extends Taro.downloadFile.Option, TaroRequestOption {
+    /**下载进度回调*/
+    onProgress?: Taro.DownloadTask.OnProgressUpdateCallback;
+}
+export interface UploadFileOptions extends Taro.uploadFile.Option, TaroRequestOption {
+    /**上传进度回调*/
+    onProgress?: Taro.UploadTask.OnProgressUpdateCallback;
+}
 export interface RequestInstanceCreateOptions {
     /**
      * 公共请求配置
@@ -58,6 +68,71 @@ export declare class RequestInstance {
     };
     /**格式化地址*/
     formatUrl: (url: string, module?: string) => string;
+    formatRequestOptions: (options: RequestInstanceOptions | DownloadFileOptions | UploadFileOptions) => {
+        url: string;
+        data?: any;
+        timeout?: number;
+        method?: keyof Taro.request.Method;
+        dataType?: keyof Taro.request.DataType | string;
+        responseType?: keyof Taro.request.ResponseType;
+        enableHttp2?: boolean;
+        enableQuic?: boolean;
+        enableCache?: boolean;
+        enableHttpDNS?: boolean;
+        httpDNSServiceId?: string;
+        enableChunked?: boolean;
+        forceCellularNetwork?: boolean;
+        enableCookie?: boolean;
+        referrerStrategy?: keyof Taro.request.ReferrerStrategy;
+        success?: (result: Taro.request.SuccessCallbackResult<any>) => void;
+        fail?: (res: TaroGeneral.CallbackResult) => void;
+        complete?: (res: Partial<Taro.request.SuccessCallbackResult> & TaroGeneral.CallbackResult) => void;
+        jsonp?: boolean | string;
+        jsonpCache?: RequestCache;
+        mode?: keyof Taro.request.CorsMode;
+        credentials?: keyof Taro.request.Credentials;
+        cache?: keyof Taro.request.Cache;
+        retryTimes?: number;
+        backup?: string | string[];
+        signal?: AbortSignal;
+        dataCheck?(): boolean;
+        useStore?: boolean;
+        storeCheckKey?: string;
+        storeSign?: string;
+        storeCheck?(): boolean;
+        header: {
+            [x: string]: any;
+        };
+    } | {
+        url: string;
+        /**下载进度回调*/
+        onProgress?: Taro.DownloadTask.OnProgressUpdateCallback;
+        filePath?: string;
+        timeout?: number;
+        withCredentials?: boolean;
+        complete?: (res: TaroGeneral.CallbackResult) => void;
+        fail?: (res: TaroGeneral.CallbackResult) => void;
+        success?: (result: Taro.downloadFile.FileSuccessCallbackResult) => void;
+        header: {
+            [x: string]: any;
+        };
+    } | {
+        url: string;
+        /**上传进度回调*/
+        onProgress?: Taro.UploadTask.OnProgressUpdateCallback;
+        filePath: string;
+        name: string;
+        formData?: TaroGeneral.IAnyObject;
+        timeout?: number;
+        fileName?: string;
+        withCredentials?: boolean;
+        complete?: (res: TaroGeneral.CallbackResult) => void;
+        fail?: (res: TaroGeneral.CallbackResult) => void;
+        success?: (result: Taro.uploadFile.SuccessCallbackResult) => void;
+        header: {
+            [x: string]: any;
+        };
+    };
     /**发送请求，返回 Taro.RequestTask */
     requestBase: (options: RequestInstanceOptions) => Taro.RequestTask<any>;
     /**发送请求,返回 Promise */
@@ -90,6 +165,14 @@ export declare class RequestInstance {
         data?: any;
         message?: string;
     }>;
+    /**下载文件(返回 Taro.DownloadTask.DownloadTaskPromise ，可显示下载进度)*/
+    downloadFileTask: (options: DownloadFileOptions) => Taro.DownloadTask.DownloadTaskPromise | undefined;
+    /**下载文件*/
+    downloadFile: (options: DownloadFileOptions) => Promise<Taro.downloadFile.FileSuccessCallbackResult>;
+    /**上传文件(返回 Taro.UploadTask.UploadTaskPromise ，可显示上传进度)*/
+    uploadFileTask: (options: UploadFileOptions) => Taro.UploadTask.UploadTaskPromise;
+    /**上传文件*/
+    uploadFile: (options: UploadFileOptions) => Promise<Taro.uploadFile.SuccessCallbackResult>;
 }
 /** 请求*/
 export declare const request: RequestInstance;

package/esm/utils/request.js

@@ -19,15 +19,13 @@ const requestResponseHandle = (result, options)=>{
     try {
         const statusCode = result.statusCode;
         const code = result?.data?.code;
-        if (result?.data) {
-            if (401 === statusCode || 401 === code || code === globalSettingDataInstance.store.tokenExpiredCode) {
-                msg = "\u8BF7\u91CD\u65B0\u767B\u5F55";
-                globalDataInstance.toLoginPage();
-            } else if (![
-                globalSettingDataInstance.store.requestSuccessCode,
-                200
-            ].includes(code)) msg = result?.data?.message || "\u63A5\u53E3\u5F02\u5E38";
-        } else msg = codeMessage[result?.statusCode];
+        if (401 === statusCode || 401 === code || code === globalSettingDataInstance.store.tokenExpiredCode) {
+            msg = "\u8BF7\u91CD\u65B0\u767B\u5F55";
+            globalDataInstance.toLoginPage();
+        } else msg = [
+            globalSettingDataInstance.store.requestSuccessCode,
+            200
+        ].includes(code) ? codeMessage[result?.statusCode] : result?.data?.message || codeMessage[code || result?.statusCode] || "\u63A5\u53E3\u5F02\u5E38";
     } catch (error) {
         msg = codeMessage[result?.statusCode];
         console.log(error);
@@ -103,8 +101,8 @@ class RequestInstance {
         }
         return `${host}/${newUrl}`;
     };
-    requestBase = (options)=>{
-        const { data, header = {}, module, isIgnoreToken, isShowErrorMessage, ...restOptions } = options;
+    formatRequestOptions = (options)=>{
+        const { header = {}, module, isIgnoreToken, isShowErrorMessage, ...restOptions } = options;
         const token = taro.getStorageSync(globalSettingDataInstance.store.tokenFieldName || 'token');
         const newHeader = {
             ...header
@@ -121,6 +119,17 @@ class RequestInstance {
             globalDataInstance.toLoginPage();
             return;
         }
+        return {
+            header: newHeader,
+            ...restOptions,
+            url: this.formatUrl(options.url, module)
+        };
+    };
+    requestBase = (options)=>{
+        const { isShowErrorMessage } = options;
+        const formattedOptions = this.formatRequestOptions(options);
+        if (!formattedOptions) return;
+        const { header: newHeader, ...restOptions } = formattedOptions;
         return taro.request({
             ...this.commonOptions,
             ...restOptions,
@@ -128,7 +137,6 @@ class RequestInstance {
                 ...newHeader,
                 ...options?.header || {}
             },
-            url: this.formatUrl(options.url, module),
             success: (result)=>{
                 requestResponseHandle(result, options);
                 options?.success?.(result);
@@ -203,6 +211,95 @@ class RequestInstance {
             throw error;
         }
     };
+    downloadFileTask = (options)=>{
+        const { isShowErrorMessage } = options;
+        const formattedOptions = this.formatRequestOptions(options);
+        if (!formattedOptions) return;
+        const { header: newHeader, onProgress, ...restOptions } = formattedOptions;
+        const downloadTask = taro.downloadFile({
+            ...this.commonOptions,
+            ...restOptions,
+            header: {
+                ...newHeader,
+                ...options?.header || {}
+            },
+            success: (result)=>{
+                if (200 === result.statusCode) options?.success?.(result);
+                else {
+                    requestResponseHandle(result, options);
+                    options?.fail?.(result);
+                }
+            },
+            fail: (result)=>{
+                if (false !== isShowErrorMessage) globalDataInstance.showMessage({
+                    content: result.errMsg || "\u8BF7\u6C42\u53D1\u751F\u9519\u8BEF",
+                    type: 'error'
+                });
+                options?.fail?.(result);
+            }
+        });
+        if ('function' == typeof onProgress && downloadTask) downloadTask.onProgressUpdate(onProgress);
+        return downloadTask;
+    };
+    downloadFile = (options)=>{
+        try {
+            return new Promise((resolve, reject)=>{
+                this.downloadFileTask({
+                    ...options,
+                    success: (result)=>{
+                        options?.success?.(result);
+                        resolve(result);
+                    },
+                    fail: (result)=>{
+                        options?.fail?.(result);
+                        reject(result);
+                    }
+                });
+            });
+        } catch (error) {
+            throw error;
+        }
+    };
+    uploadFileTask = (options)=>{
+        const { isShowErrorMessage } = options;
+        const formattedOptions = this.formatRequestOptions(options);
+        if (!formattedOptions) return;
+        const { header: newHeader, onProgress, ...restOptions } = formattedOptions;
+        const uploadTask = taro.uploadFile({
+            ...this.commonOptions,
+            ...restOptions,
+            header: {
+                ...newHeader,
+                ...options?.header || {}
+            },
+            success: (result)=>{
+                requestResponseHandle(result, options);
+                options?.success?.(result);
+            },
+            fail: (result)=>{
+                if (false !== isShowErrorMessage) globalDataInstance.showMessage({
+                    content: result.errMsg || "\u8BF7\u6C42\u53D1\u751F\u9519\u8BEF",
+                    type: 'error'
+                });
+                options?.fail?.(result);
+            }
+        });
+        if ('function' == typeof onProgress && uploadTask) uploadTask.onProgressUpdate(onProgress);
+        return uploadTask;
+    };
+    uploadFile = (options)=>new Promise((resolve, reject)=>{
+            this.uploadFileTask({
+                ...options,
+                success: (result)=>{
+                    options?.success?.(result);
+                    resolve(result);
+                },
+                fail: (result)=>{
+                    options?.fail?.(result);
+                    reject(result);
+                }
+            });
+        });
 }
 const request_request = new RequestInstance();
 const utils_request = request_request;

package/package.json

@@ -3,7 +3,7 @@
   "author": "SunLxy <1011771396@qq.com>",
   "description": "框架组件库",
   "homepage": "https://github.com/autumn-fairy-tales/fairys-taro-react",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "main": "lib/index.js",
   "types": "esm/index.d.ts",
   "module": "esm/index.js",

package/src/context/auth.data.instance.ts

@@ -10,6 +10,8 @@ export interface AuthDataInstanceState<T = any> {
   token?: string;
   /**权限列表*/
   permissions?: string[];
+  /**菜单权限列表*/
+  menusPermissions?: string[];
   /**数据默认值不使用*/
   __defaultValue?: string;
 }
@@ -19,6 +21,7 @@ export class AuthDataInstance<T = any> {
     userInfo: undefined,
     token: undefined,
     permissions: undefined,
+    menusPermissions: undefined,
   });
 
   /**
@@ -107,6 +110,46 @@ export class AuthDataInstance<T = any> {
     }
     return this.store.permissions || [];
   }
+  /**
+   * 设置菜单权限列表
+   * @param menusPermissions 菜单权限列表
+   */
+  set menusPermissions(menusPermissions: string[]) {
+    this.store.menusPermissions = menusPermissions;
+    if (menusPermissions) {
+      Taro.setStorageSync('menusPermissions', JSON.stringify(menusPermissions));
+    } else {
+      Taro.removeStorageSync('menusPermissions');
+    }
+  }
+  /**
+   * 获取菜单权限列表
+   * @returns 菜单权限列表
+   */
+  get menusPermissions(): string[] {
+    if (!this.store.menusPermissions) {
+      const menusPermissions = Taro.getStorageSync('menusPermissions');
+      if (menusPermissions) {
+        try {
+          this.store.menusPermissions = JSON.parse(menusPermissions);
+        } catch (error) {
+          console.error('解析菜单权限列表失败', error);
+        }
+      }
+    }
+    return this.store.menusPermissions || [];
+  }
+  /**
+   * 判断是否有指定菜单权限
+   * @param menuPermission 菜单权限
+   * @returns 是否有指定菜单权限
+   */
+  hasMenuPermission(menuPermission: string): boolean {
+    if (!globalSettingDataInstance.store.isEnableAuth) {
+      return true;
+    }
+    return this.menusPermissions.includes(menuPermission);
+  }
 
   /**
    * 判断是否有指定权限
@@ -114,6 +157,9 @@ export class AuthDataInstance<T = any> {
    * @returns 是否有指定权限
    */
   hasPermission(permission: string): boolean {
+    if (!globalSettingDataInstance.store.isEnableAuth) {
+      return true;
+    }
     return this.permissions.includes(permission);
   }
 }

package/src/context/global.setting.data.instance.ts

@@ -27,23 +27,49 @@ export interface GlobalSettingDataInstanceState {
    * @default pages/login/index
    */
   loginPageRoute?: string;
+  /**跳转忽略权限校验的路由*/
+  ignoreAuthRoutes?: string[];
+  /**路由跳转默认使用authDataInstance中的hasMenuPermission 判断是否有菜单权限*/
+  useAuthHasMenuPermission?: boolean;
+  /**是否开启权限校验*/
+  isEnableAuth?: boolean;
   /**数据默认值不使用*/
   __defaultValue?: string;
 }
 
 export class GlobalSettingDataInstance extends ProxyInstanceObjectBase<GlobalSettingDataInstanceState> {
-  store = proxy<GlobalSettingDataInstanceState>({
+  defaultStore: GlobalSettingDataInstanceState = {
     requestSuccessCode: 200,
     tokenFieldName: 'token',
     headerTokenName: 'token',
     tokenExpiredCode: 401,
     loginPageRoute: 'pages/login/index',
-  });
+    ignoreAuthRoutes: [],
+    useAuthHasMenuPermission: true,
+    isEnableAuth: true,
+  };
+  store = proxy<GlobalSettingDataInstanceState>({ ...this.defaultStore });
   /**
    * 扩展全局设置数据状态
    */
   extendStore = (state: Partial<GlobalSettingDataInstanceState>) => {
-    this._setValues(state);
+    this._setValues({
+      ...this.defaultStore,
+      ...state,
+    });
+  };
+  /**
+   * 判断是否跳转忽略权限校验的路由
+   */
+  isIgnoreAuthRoutes = (route: string): boolean => {
+    /**处理路由前缀*/
+    const _route = route.replace(/^\//, '');
+    /**处理登录页面路由前缀*/
+    const _loginPageRoute = this.store.loginPageRoute.replace(/^\//, '');
+    if (_route === _loginPageRoute) {
+      return true;
+    }
+    return (this.store.ignoreAuthRoutes || []).includes(_route) || (this.store.ignoreAuthRoutes || []).includes(route);
   };
 }
 /**

package/src/utils/navigate.ts

@@ -1,17 +1,28 @@
 import Taro from '@tarojs/taro';
+import { globalSettingDataInstance } from 'context/global.setting.data.instance';
+import { authDataInstance } from 'context/auth.data.instance';
 
 class NavigateInstance {
-  /**判断是否已登录(方法需要在项目入口文件中进行挂载)*/
+  /**判断是否已登录(方法需要在项目入口文件中进行挂载,如果不挂载,默认使用 authDataInstance.hasMenuPermission 判断是否有菜单权限)*/
   public isAuth: (url: string) => Promise<boolean> | boolean;
-
   private _isAuth = async (url?: string) => {
     let isAuthTo = true;
-    if (url && typeof this.isAuth === 'function') {
-      isAuthTo = await this.isAuth(url);
+    // 判断是否跳转忽略权限校验的路由
+    const isIgnoreAuthRoutes = globalSettingDataInstance.isIgnoreAuthRoutes(url);
+    // 判断是否使用 authDataInstance中的hasMenuPermission 判断是否有菜单权限
+    const useAuthHasMenuPermission = globalSettingDataInstance.store.useAuthHasMenuPermission;
+    // 判断是否开启权限校验
+    const isEnableAuth = globalSettingDataInstance.store.isEnableAuth;
+    let isAuthFunction = this.isAuth;
+    if (useAuthHasMenuPermission && typeof isAuthFunction !== 'function' && isEnableAuth) {
+      isAuthFunction = authDataInstance.hasMenuPermission;
+    }
+    if (url && typeof isAuthFunction === 'function' && !isIgnoreAuthRoutes && isEnableAuth) {
+      isAuthTo = await isAuthFunction(url);
     }
     if (isAuthTo === false) {
       // 无权访问页面
-      Taro.showToast({ title: '无权访问', icon: 'none' });
+      Taro.showToast({ title: `${url} 无权访问`, icon: 'none' });
       return false;
     }
     return true;

package/src/utils/request.ts

@@ -16,7 +16,7 @@ const codeMessage = {
   504: 'nginx超时',
 } as const;
 
-export interface RequestInstanceOptions extends Taro.request.Option<any, any> {
+export interface TaroRequestOption {
   /**模块名称*/
   module?: string;
   /**是否忽略token*/
@@ -25,22 +25,37 @@ export interface RequestInstanceOptions extends Taro.request.Option<any, any> {
   isShowErrorMessage?: boolean;
 }
 
+export interface RequestInstanceOptions extends Taro.request.Option<any, any>, TaroRequestOption {}
+export interface DownloadFileOptions extends Taro.downloadFile.Option, TaroRequestOption {
+  /**下载进度回调*/
+  onProgress?: Taro.DownloadTask.OnProgressUpdateCallback;
+}
+export interface UploadFileOptions extends Taro.uploadFile.Option, TaroRequestOption {
+  /**上传进度回调*/
+  onProgress?: Taro.UploadTask.OnProgressUpdateCallback;
+}
 /**处理提示信息*/
-const requestResponseHandle = (result: Taro.request.SuccessCallbackResult<any>, options?: RequestInstanceOptions) => {
+const requestResponseHandle = (
+  result:
+    | Taro.request.SuccessCallbackResult<any>
+    | Taro.downloadFile.FileSuccessCallbackResult
+    | Taro.uploadFile.SuccessCallbackResult,
+  options?: RequestInstanceOptions,
+) => {
   let msg = '';
   try {
     const statusCode = result.statusCode;
+    // @ts-ignore
     const code = result?.data?.code;
-    if (result?.data) {
-      if (statusCode === 401 || code === 401 || code === globalSettingDataInstance.store.tokenExpiredCode) {
-        // 权限问题 ，重新登录
-        msg = '请重新登录';
-        /**重新跳转登录页面*/
-        globalDataInstance.toLoginPage();
-      } else if (![globalSettingDataInstance.store.requestSuccessCode, 200].includes(code)) {
-        // 提示内容
-        msg = result?.data?.message || '接口异常';
-      }
+    if (statusCode === 401 || code === 401 || code === globalSettingDataInstance.store.tokenExpiredCode) {
+      // 权限问题 ，重新登录
+      msg = '请重新登录';
+      /**重新跳转登录页面*/
+      globalDataInstance.toLoginPage();
+    } else if (![globalSettingDataInstance.store.requestSuccessCode, 200].includes(code)) {
+      // 提示内容
+      // @ts-ignore
+      msg = result?.data?.message || codeMessage[code || result?.statusCode] || '接口异常';
     } else {
       msg = codeMessage[result?.statusCode];
     }
@@ -62,7 +77,6 @@ export interface RequestInstanceCreateOptions {
    * @default {}
    */
   commonOptions?: Omit<Taro.request.Option<any, any>, 'url'>;
-
   /**
    * 请求IP地址
    * @default ''
@@ -153,11 +167,9 @@ export class RequestInstance {
     if (!host) {
       host = this.proxy?.default?.[process.env.NODE_ENV === 'production' ? 'pro' : 'dev'] || '';
     }
-
     if (!host) {
       host = this.getHttpPath(url, module);
     }
-
     return {
       host,
       url: _url,
@@ -178,9 +190,8 @@ export class RequestInstance {
     return `${host}/${newUrl}`;
   };
 
-  /**发送请求，返回 Taro.RequestTask */
-  requestBase = (options: RequestInstanceOptions) => {
-    const { data, header = {}, module, isIgnoreToken, isShowErrorMessage, ...restOptions } = options;
+  formatRequestOptions = (options: RequestInstanceOptions | DownloadFileOptions | UploadFileOptions) => {
+    const { header = {}, module, isIgnoreToken, isShowErrorMessage, ...restOptions } = options;
     const token = Taro.getStorageSync(globalSettingDataInstance.store.tokenFieldName || 'token');
     const newHeader = { ...header };
     if (token) {
@@ -199,6 +210,22 @@ export class RequestInstance {
         return undefined;
       }
     }
+
+    return {
+      header: newHeader,
+      ...restOptions,
+      url: this.formatUrl(options.url, module),
+    };
+  };
+
+  /**发送请求，返回 Taro.RequestTask */
+  requestBase = (options: RequestInstanceOptions) => {
+    const { isShowErrorMessage } = options;
+    const formattedOptions = this.formatRequestOptions(options);
+    if (!formattedOptions) {
+      return undefined;
+    }
+    const { header: newHeader, ...restOptions } = formattedOptions;
     return Taro.request({
       ...this.commonOptions,
       ...restOptions,
@@ -206,7 +233,6 @@ export class RequestInstance {
         ...newHeader,
         ...(options?.header || {}),
       },
-      url: this.formatUrl(options.url, module),
       success: (result) => {
         /**处理提示
          * 使用 global 状态管理
@@ -298,6 +324,119 @@ export class RequestInstance {
       throw error;
     }
   };
+
+  /**下载文件(返回 Taro.DownloadTask.DownloadTaskPromise ，可显示下载进度)*/
+  downloadFileTask = (options: DownloadFileOptions): Taro.DownloadTask.DownloadTaskPromise | undefined => {
+    const { isShowErrorMessage } = options;
+    const formattedOptions = this.formatRequestOptions(options);
+    if (!formattedOptions) {
+      return undefined;
+    }
+    const { header: newHeader, onProgress, ...restOptions } = formattedOptions as DownloadFileOptions;
+    const downloadTask = Taro.downloadFile({
+      ...this.commonOptions,
+      ...restOptions,
+      header: {
+        ...newHeader,
+        ...(options?.header || {}),
+      },
+      success: (result) => {
+        if (result.statusCode === 200) {
+          options?.success?.(result);
+        } else {
+          requestResponseHandle(result, options as any);
+          options?.fail?.(result);
+        }
+      },
+      fail: (result) => {
+        if (isShowErrorMessage !== false) {
+          globalDataInstance.showMessage({
+            content: result.errMsg || '请求发生错误',
+            type: 'error',
+          });
+        }
+        options?.fail?.(result);
+      },
+    });
+    /**监听下载进度*/
+    if (typeof onProgress === 'function' && downloadTask) {
+      downloadTask.onProgressUpdate(onProgress);
+    }
+    return downloadTask;
+  };
+
+  /**下载文件*/
+  downloadFile = (options: DownloadFileOptions): Promise<Taro.downloadFile.FileSuccessCallbackResult> => {
+    try {
+      return new Promise((resolve, reject) => {
+        this.downloadFileTask({
+          ...options,
+          success: (result) => {
+            options?.success?.(result);
+            resolve(result);
+          },
+          fail: (result) => {
+            options?.fail?.(result);
+            reject(result);
+          },
+        });
+      });
+    } catch (error) {
+      throw error;
+    }
+  };
+
+  /**上传文件(返回 Taro.UploadTask.UploadTaskPromise ，可显示上传进度)*/
+  uploadFileTask = (options: UploadFileOptions) => {
+    const { isShowErrorMessage } = options;
+    const formattedOptions = this.formatRequestOptions(options);
+    if (!formattedOptions) {
+      return undefined;
+    }
+    const { header: newHeader, onProgress, ...restOptions } = formattedOptions as UploadFileOptions;
+    const uploadTask = Taro.uploadFile({
+      ...this.commonOptions,
+      ...restOptions,
+      header: {
+        ...newHeader,
+        ...(options?.header || {}),
+      },
+      success: (result) => {
+        requestResponseHandle(result, options);
+        options?.success?.(result);
+      },
+      fail: (result) => {
+        if (isShowErrorMessage !== false) {
+          globalDataInstance.showMessage({
+            content: result.errMsg || '请求发生错误',
+            type: 'error',
+          });
+        }
+        options?.fail?.(result);
+      },
+    });
+    /**监听上传进度*/
+    if (typeof onProgress === 'function' && uploadTask) {
+      uploadTask.onProgressUpdate(onProgress);
+    }
+    return uploadTask;
+  };
+  /**上传文件*/
+  uploadFile = (options: UploadFileOptions): Promise<Taro.uploadFile.SuccessCallbackResult> => {
+    return new Promise((resolve, reject) => {
+      this.uploadFileTask({
+        ...options,
+        success: (result) => {
+          options?.success?.(result);
+          resolve(result);
+        },
+        fail: (result) => {
+          options?.fail?.(result);
+          reject(result);
+        },
+      });
+    });
+  };
 }
 
 /** 请求*/