fast-vue-multi-pages 1.0.6 → 1.0.7

package/dist/cjs/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/cjs/http/FastVueMultiHttp.js

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

package/dist/cjs/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/cjs/http/FastVueMultiSimpleJsonResponse.js

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

package/dist/cjs/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/cjs/http/FastVueMultiSimpleRequestConfig.js

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

package/dist/cjs/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/cjs/index.js

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

package/dist/cjs/other/FastVueMultiFile.js

@@ -36,6 +36,8 @@ class FastVueMultiFile {
                     }
                 }
             };
+            inputElement.onerror = reject;
+            inputElement.onabort = reject;
             inputElement.dispatchEvent(event);
         });
     }

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; } });
 });

package/dist/esm/other/FastVueMultiFile.js

@@ -44,6 +44,8 @@ define(["require", "exports", "tslib"], function (require, exports, tslib_1) {
                                     }
                                 }
                             };
+                            inputElement.onerror = reject;
+                            inputElement.onabort = reject;
                             inputElement.dispatchEvent(event);
                         })];
                 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fast-vue-multi-pages",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "author": "janesen",
   "description": "快速搭建VUE项目工具类的基本库，主要用于每个功能页面独立生成html",
   "main": "./dist/cjs/index.js",