fast-vue-multi-pages 1.0.5 → 1.0.7

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

@@ -14,6 +14,7 @@ const FastVueMultiFunction_1 = require("./other/FastVueMultiFunction");
 const FastVueMultiElement_1 = require("./other/FastVueMultiElement");
 const FastVueMultiWindow_1 = require("./other/FastVueMultiWindow");
 const FastVueMultiFile_1 = require("./other/FastVueMultiFile");
+const FastVueMultiBase64_1 = require("./other/FastVueMultiBase64");
 /**
  * FastBaseApp 手机APP功能工具类
  */
@@ -70,5 +71,9 @@ class FastVueMultiTool {
      * 文件选择器
      */
     static File = FastVueMultiFile_1.FastVueMultiFile;
+    /**
+     * base64相关操作
+     */
+    static Base64 = FastVueMultiBase64_1.FastVueMultiBase64;
 }
 exports.FastVueMultiTool = FastVueMultiTool;

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/FastVueMultiBase64.d.ts

@@ -0,0 +1,12 @@
+export declare class FastVueMultiBase64 {
+    /**
+     * 转码base64
+     * @param content
+     */
+    static encode(content: any): string;
+    /**
+     * 解码base64
+     * @param content
+     */
+    static decode(content: string): string;
+}

package/dist/cjs/other/FastVueMultiBase64.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FastVueMultiBase64 = void 0;
+class FastVueMultiBase64 {
+    /**
+     * 转码base64
+     * @param content
+     */
+    static encode(content) {
+        const Base64 = require("js-base64");
+        return Base64.encode(content);
+    }
+    /**
+     * 解码base64
+     * @param content
+     */
+    static decode(content) {
+        const Base64 = require("js-base64");
+        return Base64.decode(content);
+    }
+}
+exports.FastVueMultiBase64 = FastVueMultiBase64;

package/dist/cjs/other/FastVueMultiFile.d.ts

@@ -4,4 +4,15 @@ export declare class FastVueMultiFile {
      * @param multi
      */
     static showUploadImage(multi: boolean): Promise<any>;
+    /**
+     * 将base64转为file对象
+     * @param content base64内容
+     * @param fileName 文件名
+     */
+    static base64ToFile(content: string, fileName: string): File;
+    /**
+     * 将file对象转为base64
+     * @param file
+     */
+    static fileToBase64(file: File): Promise<unknown>;
 }