fast-vue-multi-pages 1.0.0

package/dist/cjs/http/FastVueMultiHttp.js

@@ -0,0 +1,572 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FastVueMultiHttp = void 0;
+const tslib_1 = require("tslib");
+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");
+/**
+ * FastVueMultiHttp 网咯请求接口工具类
+ * @author Janesen
+ */
+var FastVueMultiHttp;
+(function (FastVueMultiHttp) {
+    /**
+     * 基本的网络请求接口
+     */
+    class Base {
+        /**
+         * 获取地址栏携带的参数
+         * @param paramName 参数名
+         */
+        static getWindowUrlParam(paramName) {
+            return this.getUrlParam(window.location.href, paramName);
+        }
+        /**
+         * 获取地址栏携带的参数对象信息
+         */
+        static getWindowUrlInfo() {
+            return this.getUrlParamInfo(window.location.href);
+        }
+        /**
+         * 获取url的参数
+         * @param url 地址
+         * @param paramName 参数名
+         */
+        static getUrlParam(url, paramName) {
+            let windowUrlInfo = FastVueMultiHttp.Base.getUrlParamInfo(url);
+            for (let windowUrlInfoKey in windowUrlInfo) {
+                if (windowUrlInfoKey == paramName) {
+                    return windowUrlInfo[windowUrlInfoKey];
+                }
+            }
+            return null;
+        }
+        /**
+         * 获取url的参数实体对象
+         * @param url 地址
+         */
+        static getUrlParamInfo(url) {
+            let urlInfo = {};
+            let splitArray = url.split("#")[0].split("?");
+            let search = splitArray[splitArray.length - 1];
+            let vars = search.split("&");
+            for (let i = 0; i < vars.length; i++) {
+                let pair = vars[i].split("=");
+                urlInfo[pair[0]] = pair[1];
+            }
+            return urlInfo;
+        }
+        /**
+         * 追加url参数
+         * @param url
+         * @param params
+         */
+        static appendUrlParams(url, params) {
+            let newUrl = url;
+            if (url.indexOf("?") > 0) {
+                newUrl = url + "&1=1";
+            }
+            else {
+                newUrl = url + "?1=1";
+            }
+            if (params) {
+                this.convertToFormData(params).forEach(function (value, key, parent) {
+                    if (value instanceof File) {
+                        return;
+                    }
+                    newUrl = newUrl + "&" + key + "=" + value;
+                });
+            }
+            return newUrl;
+        }
+        /**
+         * 合并多个FormData参数
+         * @param formData
+         */
+        static mergeFormData(...formData) {
+            const newParams = new FormData();
+            formData.forEach(function (item) {
+                if (lodash_1.default.isNull(item)) {
+                    return true;
+                }
+                item.forEach(function (value, key, parent) {
+                    newParams.append(key, value);
+                });
+            });
+            return newParams;
+        }
+        /**
+         * 如果是formData对象则转转换参数为object对象
+         * @param param
+         */
+        static convertToObject(param) {
+            if (param instanceof FormData) {
+                let newParams = {};
+                param.forEach(function (value, key, parent) {
+                    newParams[key] = value;
+                });
+                return newParams;
+            }
+            return param;
+        }
+        /**
+         * 转换参数为FormData格式
+         * @param param 任意格式的参数，FormData、Object、Function
+         */
+        static convertToFormData(param) {
+            const newParams = new FormData();
+            if (param instanceof FormData) {
+                return param;
+            }
+            else if (lodash_1.default.isFunction(param)) {
+                return this.convertToFormData(param());
+            }
+            else {
+                for (let paramKey in param) {
+                    if (param.hasOwnProperty(paramKey)) {
+                        newParams.append(paramKey, param[paramKey]);
+                    }
+                }
+            }
+            return newParams;
+        }
+        /**
+         * 合并参数并转换为FormData格式
+         * @param params 任意多个参数，FormData、Object、Function
+         */
+        static mergeParams(...params) {
+            let newParams = new FormData();
+            params.forEach(function (param) {
+                if (lodash_1.default.isNull(param)) {
+                    return true;
+                }
+                if (lodash_1.default.isArray(param)) {
+                    newParams = FastVueMultiHttp.Base.mergeFormData(newParams, FastVueMultiHttp.Base.mergeParamsByArray(param));
+                }
+                else {
+                    newParams = FastVueMultiHttp.Base.mergeFormData(newParams, FastVueMultiHttp.Base.convertToFormData(param));
+                }
+            });
+            return newParams;
+        }
+        /**
+         * 将数组格式的参数合并
+         * @param params 数组
+         */
+        static mergeParamsByArray(params) {
+            let newParams = new FormData();
+            for (let i = 0; i < params.length; i++) {
+                let item = params[i];
+                if (lodash_1.default.isNull(item)) {
+                    continue;
+                }
+                if (lodash_1.default.isArray(item)) {
+                    newParams = this.mergeFormData(newParams, this.mergeParamsByArray(item));
+                }
+                else {
+                    newParams = this.mergeFormData(newParams, this.convertToFormData(item));
+                }
+            }
+            return newParams;
+        }
+        /**
+         * 发起接口请求
+         * @param method 请求方法，例如，post、get
+         * @param url 请求地址
+         * @param params 请求参数
+         */
+        static doRequest(method, url, params) {
+            let axiosConfig = {
+                headers: this.getFinalHeaders(),
+                method: method,
+                url: url,
+                timeout: 3 * 60 * 1000
+            };
+            if (method === "post") {
+                if (lodash_1.default.isString(params)) {
+                    axiosConfig.paramsSerializer = params;
+                }
+                else {
+                    axiosConfig.data = this.convertToFormData(params);
+                }
+            }
+            else {
+                if (lodash_1.default.isString(params)) {
+                    axiosConfig.paramsSerializer = params;
+                }
+                else {
+                    axiosConfig.params = this.convertToObject(params);
+                }
+            }
+            let _request = axios_1.default.create();
+            _request.interceptors.request.use(function (config) {
+                let httpBeforeRequest = FastVueMultiConfig_1.FastVueMultiConfig.getGlobalConfig("httpBeforeRequest");
+                if (httpBeforeRequest) {
+                    httpBeforeRequest(config);
+                }
+                return config;
+            }, function (error) {
+                return Promise.reject(error);
+            });
+            _request.interceptors.response.use(function (response) {
+                let httpAfterRequest = FastVueMultiConfig_1.FastVueMultiConfig.getGlobalConfig("httpAfterRequest");
+                if (httpAfterRequest) {
+                    httpAfterRequest(response);
+                }
+                return response;
+            }, function (error) {
+                return Promise.reject(error);
+            });
+            return _request(axiosConfig);
+        }
+        /**
+         * 执行post请求
+         * @param url 请求地址
+         * @param params 请求参数，可为object或form data
+         */
+        static doPost(url, params) {
+            return this.doRequest("post", url, params);
+        }
+        /**
+         * 执行get请求
+         * @param url 请求接口地址
+         * @param params 请求接口参数
+         */
+        static doGet(url, params) {
+            return this.doRequest("get", url, params);
+        }
+        /**
+         * 获取请求接口的默认头信息配置
+         */
+        static getFinalHeaders() {
+            let justFinalHeaders = {};
+            if (window["FastSecurity"]) {
+                // @ts-ignore
+                justFinalHeaders["token"] = window["FastSecurity"].token();
+            }
+            let httpFinalHeaders = FastVueMultiConfig_1.FastVueMultiConfig.getGlobalConfig("httpFinalHeaders");
+            if (httpFinalHeaders) {
+                for (let dataKey in httpFinalHeaders) {
+                    if (httpFinalHeaders[dataKey] === undefined) {
+                        continue;
+                    }
+                    justFinalHeaders[dataKey] = httpFinalHeaders[dataKey];
+                }
+            }
+            return justFinalHeaders;
+        }
+        /**
+         * 设置请求头
+         * @param key
+         * @param value
+         */
+        static setFinalHeader(key, value) {
+            let httpFinalHeaders = FastVueMultiConfig_1.FastVueMultiConfig.getGlobalConfig("httpFinalHeaders");
+            if (httpFinalHeaders) {
+                httpFinalHeaders[key] = value;
+            }
+        }
+        /**
+         * 获取接口的全局参数，同步获取了原生APP的全局参数
+         */
+        static getFinalParams() {
+            let justFinalParams = {};
+            let finalParams = FastVueMultiConfig_1.FastVueMultiConfig.getGlobalConfig("httpFinalParams");
+            if (finalParams) {
+                for (let dataKey in finalParams) {
+                    if (finalParams[dataKey] === undefined) {
+                        continue;
+                    }
+                    justFinalParams[dataKey] = finalParams[dataKey];
+                }
+            }
+            return justFinalParams;
+        }
+        /**
+         * 设置全局请求参数
+         * @param key
+         * @param value
+         */
+        static setFinalParam(key, value) {
+            let finalParams = FastVueMultiConfig_1.FastVueMultiConfig.getGlobalConfig("httpFinalParams");
+            if (finalParams) {
+                finalParams[key] = value;
+            }
+        }
+        /**
+         * 构建接口请求的缓存key
+         * @param url 请求地址
+         * @param params 请求参数
+         */
+        static buildCacheKey(url, params) {
+            const md5 = require('md5');
+            if (params instanceof FormData) {
+                let paramObj = {};
+                params.forEach(function (value, key, parent) {
+                    if (value instanceof File) {
+                        paramObj[key] = value.name + "//" + value.size + "//" + value.type;
+                    }
+                    else {
+                        paramObj[key] = value;
+                    }
+                });
+                return md5(url + JSON.stringify(paramObj));
+            }
+            return md5(url + JSON.stringify(params));
+        }
+    }
+    FastVueMultiHttp.Base = Base;
+    // noinspection DuplicatedCode
+    /**
+     * 常规的接口请求类，返回格式要求为JSON：{success:true,message:"消息",data:{}}
+     */
+    class Simple extends Base {
+        /**
+         * 发起请求接口
+         * @param method 请求方法，例如：post、get
+         * @param url 接口地址 完整的地址，例如：http://loalhost:8080/user/login
+         * @param params 参数
+         * @param config 请求配置
+         * @param callBack 请求接口回调函数，在使用alwaysCache和alwaysBackRequest参数为true时，必须使用回调函数接收
+         */
+        static async request(method, url, params, config, callBack) {
+            return new Promise(async function (resolved, rejected) {
+                if (!config) {
+                    config = {
+                        finalParams: true
+                    };
+                }
+                params = FastVueMultiHttp.Base.convertToFormData(params);
+                if (config.finalParams) {
+                    let justFinalParams = FastVueMultiHttp.Base.getFinalParams();
+                    for (let dataKey in justFinalParams) {
+                        if (params.has(dataKey)) {
+                            delete justFinalParams[dataKey];
+                        }
+                    }
+                    params = FastVueMultiHttp.Base.mergeParams(justFinalParams, params);
+                }
+                let cacheKey = FastVueMultiHttp.Base.buildCacheKey(url, params);
+                let cachedData = false;
+                if (config.cache) {
+                    let result = FastVueMultiStore_1.FastVueMultiStore.getValue(cacheKey);
+                    if (result.success) {
+                        cachedData = true;
+                        let fastResponseData = new SimpleJsonResponse(JSON.parse(result.data), true);
+                        fastResponseData.requestConfig = config;
+                        resolved(fastResponseData);
+                        if (callBack) {
+                            callBack(fastResponseData);
+                        }
+                        if (!config.alwaysCache) {
+                            return;
+                        }
+                    }
+                }
+                if (!url) {
+                    let fastResponseData = new SimpleJsonResponse({
+                        success: false,
+                        message: "JS错误：请求地址不可为空！"
+                    });
+                    resolved(fastResponseData);
+                    if (callBack) {
+                        callBack(fastResponseData);
+                    }
+                    return;
+                }
+                FastVueMultiHttp.Base.doRequest(method, url, params).then(function (response) {
+                    if (!config) {
+                        config = new FastVueMultiHttp.SimpleRequestConfig();
+                    }
+                    let fastResponseData = new SimpleJsonResponse(response.data);
+                    fastResponseData.requestConfig = config;
+                    if (config.cache) {
+                        if (config.alwaysBackRequest || !cachedData) {
+                            resolved(fastResponseData);
+                            if (callBack) {
+                                callBack(fastResponseData);
+                            }
+                        }
+                        FastVueMultiStore_1.FastVueMultiStore.setValue(cacheKey, JSON.stringify(response.data));
+                    }
+                    else {
+                        resolved(fastResponseData);
+                        if (callBack) {
+                            callBack(fastResponseData);
+                        }
+                    }
+                }).catch(function (error) {
+                    console.error(error);
+                    rejected(error);
+                });
+            });
+        }
+        /**
+         * post请求接口
+         * @param url 接口地址 完整的地址，例如：http://loalhost:8080/user/login
+         * @param params 参数
+         * @param config 请求配置
+         * @param callBack 请求接口回调函数，在使用alwaysCache和alwaysBackRequest参数为true时，必须使用回调函数接收
+         */
+        static async post(url, params, config, callBack) {
+            return this.request("post", url, params, config, callBack);
+        }
+        /**
+         * get请求接口
+         * @param url 接口地址 完整的地址，例如：http://loalhost:8080/user/login
+         * @param params 参数
+         * @param config 请求配置
+         * @param callBack 请求接口回调函数，在使用alwaysCache和alwaysBackRequest参数为true时，必须使用回调函数接收
+         */
+        static async get(url, params, config, callBack) {
+            return this.request("get", url, params, config, callBack);
+        }
+    }
+    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/index.d.ts

@@ -0,0 +1,2 @@
+import { FastVueMultiTool } from "./FastVueMultiTool";
+export { FastVueMultiTool };

package/dist/cjs/index.js

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

package/dist/cjs/loader/FastTagBuilderLoader.d.ts

@@ -0,0 +1,2 @@
+declare const htmlparser2: any;
+declare const singleTag: string[];

package/dist/cjs/loader/FastTagBuilderLoader.js

@@ -0,0 +1,89 @@
+"use strict";
+const htmlparser2 = require("htmlparser2");
+const singleTag = ["br", "hr", "img", "input", "param", "meta", "link", "slot"];
+/**
+ * 标签builder插件，用来处理是否排除标签内的代码
+ * @author Janesen
+ * @param source
+ */
+module.exports = function (source) {
+    //对应配置的options
+    // @ts-ignore
+    let legacyLoaderConfig = this.query;
+    let parseNewHtml = "";
+    let isBreak = false, hasResolve = false;
+    const tagName = legacyLoaderConfig.buildLevelTagName;
+    const parser = new htmlparser2.Parser({
+        onopentag(name, attributes) {
+            if (isBreak) {
+                return;
+            }
+            let attr = "";
+            let buildConfig = {
+                level: 1,
+            };
+            for (let attributesKey in attributes) {
+                let attributesValue = attributes[attributesKey];
+                if (attributesValue.length === 0) {
+                    attr += " " + attributesKey;
+                    continue;
+                }
+                if (attributesKey === "level") {
+                    buildConfig.level = parseInt(attributesValue);
+                }
+                attr += " " + attributesKey + "=\"" + attributesValue + "\"";
+            }
+            if (name === tagName) {
+                hasResolve = true;
+                if (legacyLoaderConfig.buildLevel < buildConfig.level) {
+                    isBreak = true;
+                }
+            }
+            else {
+                if (attr.length > 0) {
+                    parseNewHtml += "<" + name + " " + attr + " ";
+                }
+                else {
+                    parseNewHtml += "<" + name;
+                }
+                if (singleTag.indexOf(name) >= 0) {
+                    parseNewHtml += "/>";
+                }
+                else {
+                    parseNewHtml += ">";
+                }
+            }
+        },
+        ontext(text) {
+            if (isBreak) {
+                return;
+            }
+            parseNewHtml += text;
+        },
+        onclosetag(name) {
+            if (name === tagName) {
+                isBreak = false;
+            }
+            if (isBreak) {
+                return;
+            }
+            if (singleTag.indexOf(name) >= 0) {
+                return;
+            }
+            if (name === tagName) {
+                return;
+            }
+            parseNewHtml += "</" + name + ">";
+        },
+    }, {
+        recognizeSelfClosing: true,
+        lowerCaseTags: false,
+        lowerCaseAttributeNames: false
+    });
+    parser.write(source);
+    parser.end();
+    if (hasResolve) {
+        return parseNewHtml;
+    }
+    return source;
+};

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

@@ -0,0 +1,13 @@
+export declare class FastVueMultiBoolean {
+    /**
+     * 判断目标值是否为布尔值
+     * @param source
+     */
+    static isBoolean(source: any): boolean;
+    /**
+     * 转为布尔值
+     * @param source 目标值
+     * @param defaultValue 默认值，当为空或无效的布尔值时 返回
+     */
+    static parse(source: any, defaultValue?: boolean): boolean;
+}