fast-vue-multi-pages 1.0.0

package/dist/esm/http/FastVueMultiHttp.js

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

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

package/dist/esm/index.js

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

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

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