fast-vue-multi-pages 1.0.5 → 1.0.7

package/dist/cjs/other/FastVueMultiFile.js

@@ -6,7 +6,7 @@ class FastVueMultiFile {
      * 弹出上传文件的选择框
      * @param multi
      */
-    static showUploadImage(multi) {
+    static async showUploadImage(multi) {
         return new Promise((resolve, reject) => {
             let inputElement = document.createElement('input');
             let event = new MouseEvent('click');
@@ -24,7 +24,10 @@ class FastVueMultiFile {
                         const fileReader = new FileReader();
                         fileReader.onload = (readEvent) => {
                             let base64 = readEvent.target.result;
-                            base64Array.push(base64);
+                            base64Array.push({
+                                file: file,
+                                url: base64
+                            });
                             if (base64Array.length === target.files.length) {
                                 resolve(base64Array);
                             }
@@ -33,8 +36,39 @@ class FastVueMultiFile {
                     }
                 }
             };
+            inputElement.onerror = reject;
+            inputElement.onabort = reject;
             inputElement.dispatchEvent(event);
         });
     }
+    /**
+     * 将base64转为file对象
+     * @param content base64内容
+     * @param fileName 文件名
+     */
+    static base64ToFile(content, fileName) {
+        let arr = content.split(','), mime = arr[0].match(/:(.*?);/)[1], bstr = atob(arr[1]), n = bstr.length, u8arr = new Uint8Array(n);
+        while (n--) {
+            u8arr[n] = bstr.charCodeAt(n);
+        }
+        const blob = new Blob([u8arr], { type: mime });
+        blob.lastModifiedDate = new Date();
+        blob.name = fileName;
+        return blob;
+    }
+    /**
+     * 将file对象转为base64
+     * @param file
+     */
+    static async fileToBase64(file) {
+        return new Promise(function (resolved, rejected) {
+            const fileReader = new FileReader();
+            fileReader.onload = function (readEvent) {
+                let base64 = readEvent.target.result;
+                resolved(base64);
+            };
+            fileReader.readAsDataURL(file);
+        });
+    }
 }
 exports.FastVueMultiFile = FastVueMultiFile;

package/dist/esm/FastVueMultiTool.d.ts

@@ -10,6 +10,7 @@ import { FastVueMultiFunction } from "./other/FastVueMultiFunction";
 import { FastVueMultiElement } from "./other/FastVueMultiElement";
 import { FastVueMultiWindow } from "./other/FastVueMultiWindow";
 import { FastVueMultiFile } from "./other/FastVueMultiFile";
+import { FastVueMultiBase64 } from "./other/FastVueMultiBase64";
 /**
  * FastBaseApp 手机APP功能工具类
  */
@@ -66,4 +67,8 @@ export declare class FastVueMultiTool {
      * 文件选择器
      */
     static File: typeof FastVueMultiFile;
+    /**
+     * base64相关操作
+     */
+    static Base64: typeof FastVueMultiBase64;
 }

package/dist/esm/FastVueMultiTool.js

@@ -1,4 +1,4 @@
-define(["require", "exports", "tslib", "lodash", "./http/FastVueMultiHttp", "./other/FastVueMultiStore", "./vue/FastVueMultiConfig", "./http/FastVueMultiCookie", "./other/FastVueMultiClipboard", "./other/FastVueMultiDate", "./other/FastVueMultiBoolean", "./other/FastVueMultiFunction", "./other/FastVueMultiElement", "./other/FastVueMultiWindow", "./other/FastVueMultiFile"], function (require, exports, tslib_1, lodash_1, FastVueMultiHttp_1, FastVueMultiStore_1, FastVueMultiConfig_1, FastVueMultiCookie_1, FastVueMultiClipboard_1, FastVueMultiDate_1, FastVueMultiBoolean_1, FastVueMultiFunction_1, FastVueMultiElement_1, FastVueMultiWindow_1, FastVueMultiFile_1) {
+define(["require", "exports", "tslib", "lodash", "./http/FastVueMultiHttp", "./other/FastVueMultiStore", "./vue/FastVueMultiConfig", "./http/FastVueMultiCookie", "./other/FastVueMultiClipboard", "./other/FastVueMultiDate", "./other/FastVueMultiBoolean", "./other/FastVueMultiFunction", "./other/FastVueMultiElement", "./other/FastVueMultiWindow", "./other/FastVueMultiFile", "./other/FastVueMultiBase64"], function (require, exports, tslib_1, lodash_1, FastVueMultiHttp_1, FastVueMultiStore_1, FastVueMultiConfig_1, FastVueMultiCookie_1, FastVueMultiClipboard_1, FastVueMultiDate_1, FastVueMultiBoolean_1, FastVueMultiFunction_1, FastVueMultiElement_1, FastVueMultiWindow_1, FastVueMultiFile_1, FastVueMultiBase64_1) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.FastVueMultiTool = void 0;
@@ -61,6 +61,10 @@ define(["require", "exports", "tslib", "lodash", "./http/FastVueMultiHttp", "./o
          * 文件选择器
          */
         FastVueMultiTool.File = FastVueMultiFile_1.FastVueMultiFile;
+        /**
+         * base64相关操作
+         */
+        FastVueMultiTool.Base64 = FastVueMultiBase64_1.FastVueMultiBase64;
         return FastVueMultiTool;
     }());
     exports.FastVueMultiTool = FastVueMultiTool;

package/dist/esm/http/FastVueMultiHttp.d.ts

@@ -1,4 +1,6 @@
 import { AxiosPromise } from "axios";
+import { FastVueMultiSimpleJsonResponse } from "./FastVueMultiSimpleJsonResponse";
+import { FastVueMultiSimpleRequestConfig } from "./FastVueMultiSimpleRequestConfig";
 /**
  * FastVueMultiHttp 网咯请求接口工具类
  * @author Janesen
@@ -117,7 +119,7 @@ export declare namespace FastVueMultiHttp {
          * @param config 请求配置
          * @param callBack 请求接口回调函数，在使用alwaysCache和alwaysBackRequest参数为true时，必须使用回调函数接收
          */
-        static request(method: string, url: string, params: any, config?: SimpleRequestConfig, callBack?: (result: SimpleJsonResponse) => void): Promise<SimpleJsonResponse>;
+        static request(method: string, url: string, params: any, config?: FastVueMultiSimpleRequestConfig, callBack?: (result: FastVueMultiSimpleJsonResponse) => void): Promise<FastVueMultiSimpleJsonResponse>;
         /**
          * post请求接口
          * @param url 接口地址 完整的地址，例如：http://loalhost:8080/user/login
@@ -125,7 +127,7 @@ export declare namespace FastVueMultiHttp {
          * @param config 请求配置
          * @param callBack 请求接口回调函数，在使用alwaysCache和alwaysBackRequest参数为true时，必须使用回调函数接收
          */
-        static post(url: string, params: any, config?: SimpleRequestConfig, callBack?: (result: SimpleJsonResponse) => void): Promise<SimpleJsonResponse>;
+        static post(url: string, params: any, config?: FastVueMultiSimpleRequestConfig, callBack?: (result: FastVueMultiSimpleJsonResponse) => void): Promise<FastVueMultiSimpleJsonResponse>;
         /**
          * get请求接口
          * @param url 接口地址 完整的地址，例如：http://loalhost:8080/user/login
@@ -133,93 +135,6 @@ export declare namespace FastVueMultiHttp {
          * @param config 请求配置
          * @param callBack 请求接口回调函数，在使用alwaysCache和alwaysBackRequest参数为true时，必须使用回调函数接收
          */
-        static get(url: string, params: any, config?: SimpleRequestConfig, callBack?: (result: SimpleJsonResponse) => void): Promise<SimpleJsonResponse>;
-    }
-    /**
-     * 常规返回数据的格式解析类 JSON：{success:true,message:"消息",data:{}}
-     */
-    class SimpleJsonResponse {
-        responseData: any;
-        cacheData: boolean;
-        requestConfig: SimpleRequestConfig;
-        constructor(responseData: any, cacheData?: boolean);
-        /**
-         * 获取接口返回的原始数据
-         */
-        getResponseData(): any;
-        /**
-         * 判断当前回调的数据是否是缓存的数据
-         */
-        isCacheData(): boolean;
-        /**
-         * 判断接口是否请求成功-success
-         */
-        isSuccess(): boolean;
-        /**
-         * 获取接口请求返回的状态值-code
-         */
-        getCode(): number;
-        /**
-         * 获取接口请求返回的消息提示-message
-         */
-        getMessage(): string;
-        /**
-         * 获取接口请求返回的数据-data
-         */
-        getData(): any;
-        /**
-         * 获取接口请求返回的其他数据，例如：data_1、data_2
-         * @param suffixIndex 数据后缀，例如:data_1 后缀传 1
-         */
-        getOtherData(suffixIndex: number): any;
-        /**
-         * 判断接口返回的数据data是否是分页的数据
-         */
-        isPageData(): boolean;
-        /**
-         * 获取接口返回的数据列表，如果data是分页数据则返回分页的列表，否则返回data
-         */
-        getList(): any[];
-        /**
-         * 获取接口列表分页数据的页数
-         */
-        getPage(): number;
-        /**
-         * 获取接口列表分页数据的总页数
-         */
-        getTotalPage(): number;
-        /**
-         * 获取接口列表分页数据的总行数
-         */
-        getTotalRow(): number;
-        /**
-         * 获取接口列表分页数据的每页大小
-         */
-        getPageSize(): number;
-        /**
-         * 是否已加载结束，当page>=totalPage 或 list 为空时，认为加载已结束
-         */
-        isFinished(): boolean;
-    }
-    /**
-     * 接口请求配置类
-     */
-    class SimpleRequestConfig {
-        /**
-         * 是否追加全局参数，默认true
-         */
-        finalParams: boolean;
-        /**
-         * 是否缓存数据，true：检测到有当前接口的缓存数据时，将回调缓存的数据
-         */
-        cache: boolean;
-        /**
-         * 是否总是缓存数据，true：无论是否已有缓存数据，都将请求接口并刷新当前缓存的数据，不支持then方法接收
-         */
-        alwaysCache: boolean;
-        /**
-         * 是否总是回调接口请求返回的数据，true：如果有缓存第一次回调缓存数据，第二次回调接口返回的数据，否则值回调一次接口返回的数据，不支持then方法接收
-         */
-        alwaysBackRequest: boolean;
+        static get(url: string, params: any, config?: FastVueMultiSimpleRequestConfig, callBack?: (result: FastVueMultiSimpleJsonResponse) => void): Promise<FastVueMultiSimpleJsonResponse>;
     }
 }

package/dist/esm/http/FastVueMultiHttp.js

@@ -1,4 +1,4 @@
-define(["require", "exports", "tslib", "axios", "lodash", "../vue/FastVueMultiConfig", "../other/FastVueMultiStore"], function (require, exports, tslib_1, axios_1, lodash_1, FastVueMultiConfig_1, FastVueMultiStore_1) {
+define(["require", "exports", "tslib", "axios", "lodash", "../vue/FastVueMultiConfig", "../other/FastVueMultiStore", "./FastVueMultiSimpleJsonResponse", "./FastVueMultiSimpleRequestConfig"], function (require, exports, tslib_1, axios_1, lodash_1, FastVueMultiConfig_1, FastVueMultiStore_1, FastVueMultiSimpleJsonResponse_1, FastVueMultiSimpleRequestConfig_1) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.FastVueMultiHttp = void 0;
@@ -372,7 +372,7 @@ define(["require", "exports", "tslib", "axios", "lodash", "../vue/FastVueMultiCo
                                             result = FastVueMultiStore_1.FastVueMultiStore.getValue(cacheKey);
                                             if (result.success) {
                                                 cachedData = true;
-                                                fastResponseData = new SimpleJsonResponse(JSON.parse(result.data), true);
+                                                fastResponseData = new FastVueMultiSimpleJsonResponse_1.FastVueMultiSimpleJsonResponse(JSON.parse(result.data), true);
                                                 fastResponseData.requestConfig = config;
                                                 resolved(fastResponseData);
                                                 if (callBack) {
@@ -384,7 +384,7 @@ define(["require", "exports", "tslib", "axios", "lodash", "../vue/FastVueMultiCo
                                             }
                                         }
                                         if (!url) {
-                                            fastResponseData = new SimpleJsonResponse({
+                                            fastResponseData = new FastVueMultiSimpleJsonResponse_1.FastVueMultiSimpleJsonResponse({
                                                 success: false,
                                                 message: "JS错误：请求地址不可为空！"
                                             });
@@ -396,9 +396,9 @@ define(["require", "exports", "tslib", "axios", "lodash", "../vue/FastVueMultiCo
                                         }
                                         FastVueMultiHttp.Base.doRequest(method, url, params).then(function (response) {
                                             if (!config) {
-                                                config = new FastVueMultiHttp.SimpleRequestConfig();
+                                                config = new FastVueMultiSimpleRequestConfig_1.FastVueMultiSimpleRequestConfig();
                                             }
-                                            var fastResponseData = new SimpleJsonResponse(response.data);
+                                            var fastResponseData = new FastVueMultiSimpleJsonResponse_1.FastVueMultiSimpleJsonResponse(response.data);
                                             fastResponseData.requestConfig = config;
                                             if (config.cache) {
                                                 if (config.alwaysBackRequest || !cachedData) {
@@ -457,152 +457,5 @@ define(["require", "exports", "tslib", "axios", "lodash", "../vue/FastVueMultiCo
             return Simple;
         }(Base));
         FastVueMultiHttp.Simple = Simple;
-        /**
-         * 常规返回数据的格式解析类 JSON：{success:true,message:"消息",data:{}}
-         */
-        var SimpleJsonResponse = /** @class */ (function () {
-            function SimpleJsonResponse(responseData, cacheData) {
-                this.cacheData = false;
-                this.requestConfig = new FastVueMultiHttp.SimpleRequestConfig();
-                this.responseData = responseData;
-                if (cacheData == undefined) {
-                    cacheData = false;
-                }
-                this.cacheData = cacheData;
-            }
-            /**
-             * 获取接口返回的原始数据
-             */
-            SimpleJsonResponse.prototype.getResponseData = function () {
-                return this.responseData;
-            };
-            /**
-             * 判断当前回调的数据是否是缓存的数据
-             */
-            SimpleJsonResponse.prototype.isCacheData = function () {
-                return this.cacheData;
-            };
-            /**
-             * 判断接口是否请求成功-success
-             */
-            SimpleJsonResponse.prototype.isSuccess = function () {
-                return this.responseData.success;
-            };
-            /**
-             * 获取接口请求返回的状态值-code
-             */
-            SimpleJsonResponse.prototype.getCode = function () {
-                return this.responseData.code;
-            };
-            /**
-             * 获取接口请求返回的消息提示-message
-             */
-            SimpleJsonResponse.prototype.getMessage = function () {
-                return this.responseData.message;
-            };
-            /**
-             * 获取接口请求返回的数据-data
-             */
-            SimpleJsonResponse.prototype.getData = function () {
-                return this.responseData.data;
-            };
-            /**
-             * 获取接口请求返回的其他数据，例如：data_1、data_2
-             * @param suffixIndex 数据后缀，例如:data_1 后缀传 1
-             */
-            SimpleJsonResponse.prototype.getOtherData = function (suffixIndex) {
-                return this.responseData["data_" + suffixIndex];
-            };
-            /**
-             * 判断接口返回的数据data是否是分页的数据
-             */
-            SimpleJsonResponse.prototype.isPageData = function () {
-                if (!this.responseData.data) {
-                    return false;
-                }
-                return this.responseData.data.hasOwnProperty("page");
-            };
-            /**
-             * 获取接口返回的数据列表，如果data是分页数据则返回分页的列表，否则返回data
-             */
-            SimpleJsonResponse.prototype.getList = function () {
-                if (this.isPageData()) {
-                    return this.responseData.data.list;
-                }
-                if (this.responseData.data) {
-                    return this.responseData.data;
-                }
-                return [];
-            };
-            /**
-             * 获取接口列表分页数据的页数
-             */
-            SimpleJsonResponse.prototype.getPage = function () {
-                if (this.isPageData()) {
-                    return this.responseData.data.page;
-                }
-                return -1;
-            };
-            /**
-             * 获取接口列表分页数据的总页数
-             */
-            SimpleJsonResponse.prototype.getTotalPage = function () {
-                if (this.isPageData()) {
-                    return this.responseData.data.totalPage;
-                }
-                return -1;
-            };
-            /**
-             * 获取接口列表分页数据的总行数
-             */
-            SimpleJsonResponse.prototype.getTotalRow = function () {
-                if (this.isPageData()) {
-                    return this.responseData.data.totalRow;
-                }
-                return -1;
-            };
-            /**
-             * 获取接口列表分页数据的每页大小
-             */
-            SimpleJsonResponse.prototype.getPageSize = function () {
-                if (this.isPageData()) {
-                    return this.responseData.data.pageSize;
-                }
-                return -1;
-            };
-            /**
-             * 是否已加载结束，当page>=totalPage 或 list 为空时，认为加载已结束
-             */
-            SimpleJsonResponse.prototype.isFinished = function () {
-                return this.getPage() >= this.getTotalPage() || this.getList().length === 0;
-            };
-            return SimpleJsonResponse;
-        }());
-        FastVueMultiHttp.SimpleJsonResponse = SimpleJsonResponse;
-        /**
-         * 接口请求配置类
-         */
-        var SimpleRequestConfig = /** @class */ (function () {
-            function SimpleRequestConfig() {
-                /**
-                 * 是否追加全局参数，默认true
-                 */
-                this.finalParams = true;
-                /**
-                 * 是否缓存数据，true：检测到有当前接口的缓存数据时，将回调缓存的数据
-                 */
-                this.cache = false;
-                /**
-                 * 是否总是缓存数据，true：无论是否已有缓存数据，都将请求接口并刷新当前缓存的数据，不支持then方法接收
-                 */
-                this.alwaysCache = false;
-                /**
-                 * 是否总是回调接口请求返回的数据，true：如果有缓存第一次回调缓存数据，第二次回调接口返回的数据，否则值回调一次接口返回的数据，不支持then方法接收
-                 */
-                this.alwaysBackRequest = false;
-            }
-            return SimpleRequestConfig;
-        }());
-        FastVueMultiHttp.SimpleRequestConfig = SimpleRequestConfig;
     })(FastVueMultiHttp || (exports.FastVueMultiHttp = FastVueMultiHttp = {}));
 });

package/dist/esm/http/FastVueMultiSimpleJsonResponse.d.ts

@@ -0,0 +1,67 @@
+import { FastVueMultiSimpleRequestConfig } from "./FastVueMultiSimpleRequestConfig";
+/**
+ * 常规返回数据的格式解析类 JSON：{success:true,message:"消息",data:{}}
+ */
+export declare class FastVueMultiSimpleJsonResponse {
+    responseData: any;
+    cacheData: boolean;
+    requestConfig: FastVueMultiSimpleRequestConfig;
+    constructor(responseData: any, cacheData?: boolean);
+    /**
+     * 获取接口返回的原始数据
+     */
+    getResponseData(): any;
+    /**
+     * 判断当前回调的数据是否是缓存的数据
+     */
+    isCacheData(): boolean;
+    /**
+     * 判断接口是否请求成功-success
+     */
+    isSuccess(): boolean;
+    /**
+     * 获取接口请求返回的状态值-code
+     */
+    getCode(): number;
+    /**
+     * 获取接口请求返回的消息提示-message
+     */
+    getMessage(): string;
+    /**
+     * 获取接口请求返回的数据-data
+     */
+    getData(): any;
+    /**
+     * 获取接口请求返回的其他数据，例如：data_1、data_2
+     * @param suffixIndex 数据后缀，例如:data_1 后缀传 1
+     */
+    getOtherData(suffixIndex: number): any;
+    /**
+     * 判断接口返回的数据data是否是分页的数据
+     */
+    isPageData(): boolean;
+    /**
+     * 获取接口返回的数据列表，如果data是分页数据则返回分页的列表，否则返回data
+     */
+    getList(): any[];
+    /**
+     * 获取接口列表分页数据的页数
+     */
+    getPage(): number;
+    /**
+     * 获取接口列表分页数据的总页数
+     */
+    getTotalPage(): number;
+    /**
+     * 获取接口列表分页数据的总行数
+     */
+    getTotalRow(): number;
+    /**
+     * 获取接口列表分页数据的每页大小
+     */
+    getPageSize(): number;
+    /**
+     * 是否已加载结束，当page>=totalPage 或 list 为空时，认为加载已结束
+     */
+    isFinished(): boolean;
+}

package/dist/esm/http/FastVueMultiSimpleJsonResponse.js

@@ -0,0 +1,127 @@
+define(["require", "exports", "./FastVueMultiSimpleRequestConfig"], function (require, exports, FastVueMultiSimpleRequestConfig_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.FastVueMultiSimpleJsonResponse = void 0;
+    /**
+     * 常规返回数据的格式解析类 JSON：{success:true,message:"消息",data:{}}
+     */
+    var FastVueMultiSimpleJsonResponse = /** @class */ (function () {
+        function FastVueMultiSimpleJsonResponse(responseData, cacheData) {
+            this.cacheData = false;
+            this.requestConfig = new FastVueMultiSimpleRequestConfig_1.FastVueMultiSimpleRequestConfig();
+            this.responseData = responseData;
+            if (cacheData == undefined) {
+                cacheData = false;
+            }
+            this.cacheData = cacheData;
+        }
+        /**
+         * 获取接口返回的原始数据
+         */
+        FastVueMultiSimpleJsonResponse.prototype.getResponseData = function () {
+            return this.responseData;
+        };
+        /**
+         * 判断当前回调的数据是否是缓存的数据
+         */
+        FastVueMultiSimpleJsonResponse.prototype.isCacheData = function () {
+            return this.cacheData;
+        };
+        /**
+         * 判断接口是否请求成功-success
+         */
+        FastVueMultiSimpleJsonResponse.prototype.isSuccess = function () {
+            return this.responseData.success;
+        };
+        /**
+         * 获取接口请求返回的状态值-code
+         */
+        FastVueMultiSimpleJsonResponse.prototype.getCode = function () {
+            return this.responseData.code;
+        };
+        /**
+         * 获取接口请求返回的消息提示-message
+         */
+        FastVueMultiSimpleJsonResponse.prototype.getMessage = function () {
+            return this.responseData.message;
+        };
+        /**
+         * 获取接口请求返回的数据-data
+         */
+        FastVueMultiSimpleJsonResponse.prototype.getData = function () {
+            return this.responseData.data;
+        };
+        /**
+         * 获取接口请求返回的其他数据，例如：data_1、data_2
+         * @param suffixIndex 数据后缀，例如:data_1 后缀传 1
+         */
+        FastVueMultiSimpleJsonResponse.prototype.getOtherData = function (suffixIndex) {
+            return this.responseData["data_" + suffixIndex];
+        };
+        /**
+         * 判断接口返回的数据data是否是分页的数据
+         */
+        FastVueMultiSimpleJsonResponse.prototype.isPageData = function () {
+            if (!this.responseData.data) {
+                return false;
+            }
+            return this.responseData.data.hasOwnProperty("page");
+        };
+        /**
+         * 获取接口返回的数据列表，如果data是分页数据则返回分页的列表，否则返回data
+         */
+        FastVueMultiSimpleJsonResponse.prototype.getList = function () {
+            if (this.isPageData()) {
+                return this.responseData.data.list;
+            }
+            if (this.responseData.data) {
+                return this.responseData.data;
+            }
+            return [];
+        };
+        /**
+         * 获取接口列表分页数据的页数
+         */
+        FastVueMultiSimpleJsonResponse.prototype.getPage = function () {
+            if (this.isPageData()) {
+                return this.responseData.data.page;
+            }
+            return -1;
+        };
+        /**
+         * 获取接口列表分页数据的总页数
+         */
+        FastVueMultiSimpleJsonResponse.prototype.getTotalPage = function () {
+            if (this.isPageData()) {
+                return this.responseData.data.totalPage;
+            }
+            return -1;
+        };
+        /**
+         * 获取接口列表分页数据的总行数
+         */
+        FastVueMultiSimpleJsonResponse.prototype.getTotalRow = function () {
+            if (this.isPageData()) {
+                return this.responseData.data.totalRow;
+            }
+            return -1;
+        };
+        /**
+         * 获取接口列表分页数据的每页大小
+         */
+        FastVueMultiSimpleJsonResponse.prototype.getPageSize = function () {
+            if (this.isPageData()) {
+                return this.responseData.data.pageSize;
+            }
+            return -1;
+        };
+        /**
+         * 是否已加载结束，当page>=totalPage 或 list 为空时，认为加载已结束
+         */
+        FastVueMultiSimpleJsonResponse.prototype.isFinished = function () {
+            return this.getPage() >= this.getTotalPage() || this.getList().length === 0;
+        };
+        return FastVueMultiSimpleJsonResponse;
+    }());
+    exports.FastVueMultiSimpleJsonResponse = FastVueMultiSimpleJsonResponse;
+});

package/dist/esm/http/FastVueMultiSimpleRequestConfig.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 接口请求配置类
+ */
+export declare class FastVueMultiSimpleRequestConfig {
+    /**
+     * 是否追加全局参数，默认true
+     */
+    finalParams: boolean;
+    /**
+     * 是否缓存数据，true：检测到有当前接口的缓存数据时，将回调缓存的数据
+     */
+    cache: boolean;
+    /**
+     * 是否总是缓存数据，true：无论是否已有缓存数据，都将请求接口并刷新当前缓存的数据，不支持then方法接收
+     */
+    alwaysCache: boolean;
+    /**
+     * 是否总是回调接口请求返回的数据，true：如果有缓存第一次回调缓存数据，第二次回调接口返回的数据，否则值回调一次接口返回的数据，不支持then方法接收
+     */
+    alwaysBackRequest: boolean;
+}

package/dist/esm/http/FastVueMultiSimpleRequestConfig.js

@@ -0,0 +1,30 @@
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.FastVueMultiSimpleRequestConfig = void 0;
+    /**
+     * 接口请求配置类
+     */
+    var FastVueMultiSimpleRequestConfig = /** @class */ (function () {
+        function FastVueMultiSimpleRequestConfig() {
+            /**
+             * 是否追加全局参数，默认true
+             */
+            this.finalParams = true;
+            /**
+             * 是否缓存数据，true：检测到有当前接口的缓存数据时，将回调缓存的数据
+             */
+            this.cache = false;
+            /**
+             * 是否总是缓存数据，true：无论是否已有缓存数据，都将请求接口并刷新当前缓存的数据，不支持then方法接收
+             */
+            this.alwaysCache = false;
+            /**
+             * 是否总是回调接口请求返回的数据，true：如果有缓存第一次回调缓存数据，第二次回调接口返回的数据，否则值回调一次接口返回的数据，不支持then方法接收
+             */
+            this.alwaysBackRequest = false;
+        }
+        return FastVueMultiSimpleRequestConfig;
+    }());
+    exports.FastVueMultiSimpleRequestConfig = FastVueMultiSimpleRequestConfig;
+});

package/dist/esm/index.d.ts

@@ -1,2 +1,4 @@
 import { FastVueMultiTool } from "./FastVueMultiTool";
-export { FastVueMultiTool };
+import { FastVueMultiSimpleJsonResponse } from "./http/FastVueMultiSimpleJsonResponse";
+import { FastVueMultiSimpleRequestConfig } from "./http/FastVueMultiSimpleRequestConfig";
+export { FastVueMultiTool, FastVueMultiSimpleJsonResponse, FastVueMultiSimpleRequestConfig };

package/dist/esm/index.js

@@ -1,6 +1,8 @@
-define(["require", "exports", "./FastVueMultiTool"], function (require, exports, FastVueMultiTool_1) {
+define(["require", "exports", "./FastVueMultiTool", "./http/FastVueMultiSimpleJsonResponse", "./http/FastVueMultiSimpleRequestConfig"], function (require, exports, FastVueMultiTool_1, FastVueMultiSimpleJsonResponse_1, FastVueMultiSimpleRequestConfig_1) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.FastVueMultiTool = void 0;
+    exports.FastVueMultiSimpleRequestConfig = exports.FastVueMultiSimpleJsonResponse = exports.FastVueMultiTool = void 0;
     Object.defineProperty(exports, "FastVueMultiTool", { enumerable: true, get: function () { return FastVueMultiTool_1.FastVueMultiTool; } });
+    Object.defineProperty(exports, "FastVueMultiSimpleJsonResponse", { enumerable: true, get: function () { return FastVueMultiSimpleJsonResponse_1.FastVueMultiSimpleJsonResponse; } });
+    Object.defineProperty(exports, "FastVueMultiSimpleRequestConfig", { enumerable: true, get: function () { return FastVueMultiSimpleRequestConfig_1.FastVueMultiSimpleRequestConfig; } });
 });