fast-vue-multi-pages 1.0.0

package/dist/esm/loader/FastTagBuilderLoader.js

@@ -0,0 +1,89 @@
+"use strict";
+var htmlparser2 = require("htmlparser2");
+var singleTag = ["br", "hr", "img", "input", "param", "meta", "link", "slot"];
+/**
+ * 标签builder插件，用来处理是否排除标签内的代码
+ * @author Janesen
+ * @param source
+ */
+module.exports = function (source) {
+    //对应配置的options
+    // @ts-ignore
+    var legacyLoaderConfig = this.query;
+    var parseNewHtml = "";
+    var isBreak = false, hasResolve = false;
+    var tagName = legacyLoaderConfig.buildLevelTagName;
+    var parser = new htmlparser2.Parser({
+        onopentag: function (name, attributes) {
+            if (isBreak) {
+                return;
+            }
+            var attr = "";
+            var buildConfig = {
+                level: 1,
+            };
+            for (var attributesKey in attributes) {
+                var 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: function (text) {
+            if (isBreak) {
+                return;
+            }
+            parseNewHtml += text;
+        },
+        onclosetag: function (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/esm/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;
+}

package/dist/esm/other/FastVueMultiBoolean.js

@@ -0,0 +1,60 @@
+define(["require", "exports", "tslib", "lodash"], function (require, exports, tslib_1, lodash_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.FastVueMultiBoolean = void 0;
+    lodash_1 = tslib_1.__importDefault(lodash_1);
+    var FastVueMultiBoolean = /** @class */ (function () {
+        function FastVueMultiBoolean() {
+        }
+        /**
+         * 判断目标值是否为布尔值
+         * @param source
+         */
+        FastVueMultiBoolean.isBoolean = function (source) {
+            if (source == null) {
+                return false;
+            }
+            if (source instanceof Boolean) {
+                return true;
+            }
+            return typeof source === 'boolean';
+        };
+        /**
+         * 转为布尔值
+         * @param source 目标值
+         * @param defaultValue 默认值，当为空或无效的布尔值时 返回
+         */
+        FastVueMultiBoolean.parse = function (source, defaultValue) {
+            if (lodash_1.default.isEmpty(defaultValue)) {
+                defaultValue = false;
+            }
+            if (lodash_1.default.isEmpty(source)) {
+                return defaultValue;
+            }
+            if (lodash_1.default.isString(source)) {
+                if (source === "0" || source.toLowerCase() === "false") {
+                    return false;
+                }
+                if (source === "1" || source.toLowerCase() === "true") {
+                    return true;
+                }
+                return defaultValue;
+            }
+            if (lodash_1.default.isNumber(source)) {
+                if (source === 0) {
+                    return false;
+                }
+                if (source === 1) {
+                    return true;
+                }
+                return defaultValue;
+            }
+            if (this.isBoolean(source)) {
+                return source;
+            }
+            return defaultValue;
+        };
+        return FastVueMultiBoolean;
+    }());
+    exports.FastVueMultiBoolean = FastVueMultiBoolean;
+});

package/dist/esm/other/FastVueMultiClipboard.d.ts

@@ -0,0 +1,21 @@
+import * as clipboard from "clipboard-polyfill";
+export declare class FastVueMultiClipboard {
+    /**
+     * 将内容复制到剪贴板中
+     * @param content
+     */
+    static copy(content: string): Promise<void>;
+    /**
+     * 将blob复制到剪贴板中
+     * @param blob
+     */
+    static copyBlob(blob: Blob): Promise<void>;
+    /**
+     * 获取剪贴板的文本内容
+     */
+    static getText(): Promise<string | undefined>;
+    /**
+     * 获取剪贴板的ClipboardItem内容
+     */
+    static getItems(): Promise<clipboard.ClipboardItems | undefined>;
+}

package/dist/esm/other/FastVueMultiClipboard.js

@@ -0,0 +1,56 @@
+define(["require", "exports", "tslib", "clipboard-polyfill"], function (require, exports, tslib_1, clipboard) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.FastVueMultiClipboard = void 0;
+    clipboard = tslib_1.__importStar(clipboard);
+    var FastVueMultiClipboard = /** @class */ (function () {
+        function FastVueMultiClipboard() {
+        }
+        /**
+         * 将内容复制到剪贴板中
+         * @param content
+         */
+        FastVueMultiClipboard.copy = function (content) {
+            return clipboard.writeText(content);
+        };
+        /**
+         * 将blob复制到剪贴板中
+         * @param blob
+         */
+        FastVueMultiClipboard.copyBlob = function (blob) {
+            var contentType = blob.type;
+            var items = {};
+            items[contentType] = blob;
+            var item = new clipboard.ClipboardItem(items);
+            return clipboard.write([item]);
+        };
+        /**
+         * 获取剪贴板的文本内容
+         */
+        FastVueMultiClipboard.getText = function () {
+            return tslib_1.__awaiter(this, void 0, void 0, function () {
+                return tslib_1.__generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, clipboard.readText()];
+                        case 1: return [2 /*return*/, _a.sent()];
+                    }
+                });
+            });
+        };
+        /**
+         * 获取剪贴板的ClipboardItem内容
+         */
+        FastVueMultiClipboard.getItems = function () {
+            return tslib_1.__awaiter(this, void 0, void 0, function () {
+                return tslib_1.__generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, clipboard.read()];
+                        case 1: return [2 /*return*/, _a.sent()];
+                    }
+                });
+            });
+        };
+        return FastVueMultiClipboard;
+    }());
+    exports.FastVueMultiClipboard = FastVueMultiClipboard;
+});

package/dist/esm/other/FastVueMultiDate.d.ts

@@ -0,0 +1,30 @@
+export declare class FastVueMultiDate {
+    /**
+     * 判断目标值是否是日期类型
+     * @param source
+     */
+    static isDate(source: any): boolean;
+    /**
+     * 格式化日期
+     * @param source 日期
+     * @param pattern 格式类型，例如：yyyy-MM-DD HH:mm:ss，更多查看：https://momentjs.com/docs/#/displaying/
+     */
+    static format(source: Date, pattern: string): string | null;
+    /**
+     * 将字符串日期转换为Date对象
+     * @param source 日期值
+     */
+    static parse(source: string): Date | null;
+    /**
+     * 格式化日期的友好展示，例如：1分钟前，3分钟前
+     * @param source
+     * @param level 精确级别 1 分钟 2 小时 3 天  4 周 5 月
+     */
+    static formatNice(source: string, level?: number): string | null;
+    /**
+     * 将总时间转换为中文描述，最高描述到：天，例如：2天03时45分09秒
+     * @param timestamp 时间戳 单位：毫秒
+     * @param chinese 是否用中文表达，默认：true
+     */
+    static toDescription(timestamp: number, chinese: boolean): string;
+}

package/dist/esm/other/FastVueMultiDate.js

@@ -0,0 +1,170 @@
+define(["require", "exports", "tslib", "moment", "lodash"], function (require, exports, tslib_1, moment_1, lodash_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.FastVueMultiDate = void 0;
+    moment_1 = tslib_1.__importDefault(moment_1);
+    lodash_1 = tslib_1.__importDefault(lodash_1);
+    var FastVueMultiDate = /** @class */ (function () {
+        function FastVueMultiDate() {
+        }
+        /**
+         * 判断目标值是否是日期类型
+         * @param source
+         */
+        FastVueMultiDate.isDate = function (source) {
+            if (source == null) {
+                return false;
+            }
+            if (source instanceof Date) {
+                return true;
+            }
+            return toString.call(source) === '[object Date]';
+        };
+        /**
+         * 格式化日期
+         * @param source 日期
+         * @param pattern 格式类型，例如：yyyy-MM-DD HH:mm:ss，更多查看：https://momentjs.com/docs/#/displaying/
+         */
+        FastVueMultiDate.format = function (source, pattern) {
+            if (lodash_1.default.isEmpty(pattern)) {
+                return null;
+            }
+            if (lodash_1.default.isEmpty(source)) {
+                return null;
+            }
+            return (0, moment_1.default)(source).format(pattern);
+        };
+        /**
+         * 将字符串日期转换为Date对象
+         * @param source 日期值
+         */
+        FastVueMultiDate.parse = function (source) {
+            if (lodash_1.default.isEmpty(source)) {
+                return null;
+            }
+            return (0, moment_1.default)(source).toDate();
+        };
+        /**
+         * 格式化日期的友好展示，例如：1分钟前，3分钟前
+         * @param source
+         * @param level 精确级别 1 分钟 2 小时 3 天  4 周 5 月
+         */
+        FastVueMultiDate.formatNice = function (source, level) {
+            if (lodash_1.default.isEmpty(source)) {
+                return null;
+            }
+            if (level === undefined) {
+                level = 2;
+            }
+            var seconds = 1000;
+            var minute = seconds * 60;
+            var hour = minute * 60;
+            var day = hour * 24;
+            var week = day * 7;
+            var month = day * 30;
+            var time1 = new Date().getTime(); //当前的时间戳
+            var sourceDate = this.parse(source);
+            if (!sourceDate) {
+                return null;
+            }
+            var time2 = sourceDate.getTime();
+            var time = time1 - time2;
+            if (time <= minute) {
+                return "刚刚";
+            }
+            if (time / month >= 3) {
+                return this.format(sourceDate, "yyyy-MM-DD HH:mm");
+            }
+            var nice = true;
+            if (time / month >= 1) {
+                if (level >= 5) {
+                    return parseInt(String(time / month)) + "个月前";
+                }
+                nice = false;
+            }
+            if (nice && time / week >= 1) {
+                if (level >= 4) {
+                    return parseInt(String(time / week)) + "周前";
+                }
+                nice = false;
+            }
+            if (nice && time / day >= 1) {
+                if (level >= 3) {
+                    return parseInt(String(time / day)) + "天前";
+                }
+                nice = false;
+            }
+            if (nice && time / hour >= 1) {
+                if (level >= 2) {
+                    return parseInt(String(time / hour)) + "小时前";
+                }
+                nice = false;
+            }
+            if (nice && time / minute >= 1) {
+                if (level >= 1) {
+                    return parseInt(String(time / minute)) + "分钟前";
+                }
+            }
+            return this.format(sourceDate, "yyyy-MM-DD HH:mm");
+        };
+        /**
+         * 将总时间转换为中文描述，最高描述到：天，例如：2天03时45分09秒
+         * @param timestamp 时间戳 单位：毫秒
+         * @param chinese 是否用中文表达，默认：true
+         */
+        FastVueMultiDate.toDescription = function (timestamp, chinese) {
+            if (chinese === undefined) {
+                chinese = true;
+            }
+            var seconds = 1000, minuteUnit = 1000 * 60, hourUnit = 1000 * 60 * 60, dayUnit = 1000 * 60 * 60 * 24;
+            var descriptions = [];
+            if (timestamp < seconds) {
+                descriptions.push("00" + (chinese ? '秒' : ''));
+                return descriptions.join("");
+            }
+            else if (timestamp < minuteUnit) {
+                descriptions.push(lodash_1.default.padStart(String(timestamp / seconds), 2, "0") + (chinese ? '秒' : ''));
+                return descriptions.join("");
+            }
+            if (timestamp < hourUnit) {
+                var minute = parseInt(String(timestamp / minuteUnit));
+                descriptions.push(lodash_1.default.padStart(String(minute), 2, "0") + (chinese ? '分' : ':'));
+                var nextTimestamp_1 = timestamp - parseInt(String(minute * minuteUnit));
+                if (nextTimestamp_1 === 0) {
+                    descriptions.push("00" + (chinese ? '秒' : ''));
+                }
+                else {
+                    descriptions.push(this.toDescription(nextTimestamp_1, chinese));
+                }
+                return descriptions.join("");
+            }
+            if (timestamp < dayUnit) {
+                var hour = parseInt(String(timestamp / hourUnit));
+                descriptions.push(lodash_1.default.padStart(String(hour), 2, "0") + (chinese ? '时' : ':'));
+                var nextTimestamp_2 = timestamp - parseInt(String(hour * hourUnit));
+                if (nextTimestamp_2 === 0) {
+                    descriptions.push("00" + (chinese ? '分' : ':'));
+                    descriptions.push("00" + (chinese ? '秒' : ''));
+                }
+                else {
+                    descriptions.push(this.toDescription(nextTimestamp_2, chinese));
+                }
+                return descriptions.join("");
+            }
+            var day = parseInt(String(timestamp / dayUnit));
+            descriptions.push(day + (chinese ? '天' : 'day '));
+            var nextTimestamp = timestamp - parseInt(String(day * dayUnit));
+            if (nextTimestamp === 0) {
+                descriptions.push("00" + (chinese ? '时' : ':'));
+                descriptions.push("00" + (chinese ? '分' : ':'));
+                descriptions.push("00" + (chinese ? '秒' : ''));
+            }
+            else {
+                descriptions.push(this.toDescription(nextTimestamp, chinese));
+            }
+            return descriptions.join("");
+        };
+        return FastVueMultiDate;
+    }());
+    exports.FastVueMultiDate = FastVueMultiDate;
+});

package/dist/esm/other/FastVueMultiElement.d.ts

@@ -0,0 +1,46 @@
+export declare class FastVueMultiElement {
+    /**
+     * 绑定节点属性变动的监听
+     * @param source 节点对象
+     * @param attrs 需要监听的属性集合
+     * @param callBack 回调
+     */
+    static onAttributesChange(source: Element, attrs: any[], callBack?: (event: MutationRecord) => void): MutationObserver | null;
+    /**
+     * 绑定当前节点子节点的变动的监听
+     * @param source 节点对象
+     * @param callBack 回调
+     */
+    static onChildrenChange(source: Element, callBack?: (event: MutationRecord) => void): MutationObserver | null;
+    /**
+     * 在目标节点后追加新的节点
+     * @param targetEl 目标节点
+     * @param newEl 新的节点
+     */
+    static insertAfter(targetEl: Element, newEl: Element): void;
+    /**
+     * 在目标节点前追加新的节点
+     * @param targetEl 目标节点
+     * @param newEl 新的节点
+     */
+    static insertBefore(targetEl: Element, newEl: Element): void;
+    /**
+     * 获取目标节点的实际占位空间，包含的内外边距
+     * @param targetEl
+     */
+    static getRealSize(targetEl: Element): {
+        width: number;
+        height: number;
+    };
+    /**
+     * 获取目标节点的selector
+     * @param targetEl
+     */
+    static getPath(targetEl: Element): string;
+    /**
+     * 判断目标元素的滚动条 是否已滚动到底部
+     * @param targetEl
+     * @param scrollNimble 检测的灵敏度，越大越灵敏
+     */
+    static isScrollBottom(targetEl: Element, scrollNimble: number): boolean;
+}

package/dist/esm/other/FastVueMultiElement.js

@@ -0,0 +1,158 @@
+define(["require", "exports", "tslib", "lodash"], function (require, exports, tslib_1, lodash_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.FastVueMultiElement = void 0;
+    lodash_1 = tslib_1.__importDefault(lodash_1);
+    var FastVueMultiElement = /** @class */ (function () {
+        function FastVueMultiElement() {
+        }
+        /**
+         * 绑定节点属性变动的监听
+         * @param source 节点对象
+         * @param attrs 需要监听的属性集合
+         * @param callBack 回调
+         */
+        FastVueMultiElement.onAttributesChange = function (source, attrs, callBack) {
+            if (source) {
+                var observe = new MutationObserver(function (mutationsList) {
+                    mutationsList.forEach(function (item, index) {
+                        if (callBack) {
+                            callBack(item);
+                        }
+                    });
+                });
+                observe.observe(source, {
+                    attributes: true,
+                    attributeFilter: attrs
+                });
+                return observe;
+            }
+            return null;
+        };
+        /**
+         * 绑定当前节点子节点的变动的监听
+         * @param source 节点对象
+         * @param callBack 回调
+         */
+        FastVueMultiElement.onChildrenChange = function (source, callBack) {
+            if (source) {
+                var observe = new MutationObserver(function (mutationsList) {
+                    mutationsList.forEach(function (item, index) {
+                        if (callBack) {
+                            callBack(item);
+                        }
+                    });
+                });
+                observe.observe(source, {
+                    childList: true,
+                    subtree: true
+                });
+                return observe;
+            }
+            return null;
+        };
+        /**
+         * 在目标节点后追加新的节点
+         * @param targetEl 目标节点
+         * @param newEl 新的节点
+         */
+        FastVueMultiElement.insertAfter = function (targetEl, newEl) {
+            var parent = targetEl.parentNode;
+            if (parent.lastChild === targetEl) {
+                parent.appendChild(newEl);
+            }
+            else {
+                parent.insertBefore(newEl, targetEl.nextSibling);
+            }
+        };
+        /**
+         * 在目标节点前追加新的节点
+         * @param targetEl 目标节点
+         * @param newEl 新的节点
+         */
+        FastVueMultiElement.insertBefore = function (targetEl, newEl) {
+            var parent = targetEl.parentNode;
+            if (parent.lastChild === targetEl) {
+                parent.appendChild(newEl);
+            }
+            else {
+                parent.insertBefore(newEl, targetEl);
+            }
+        };
+        /**
+         * 获取目标节点的实际占位空间，包含的内外边距
+         * @param targetEl
+         */
+        FastVueMultiElement.getRealSize = function (targetEl) {
+            var childStyle = window.getComputedStyle(targetEl);
+            var height = lodash_1.default.parseInt(childStyle.height);
+            var width = lodash_1.default.parseInt(childStyle.width);
+            var vSpace = lodash_1.default.parseInt(childStyle.marginTop)
+                + lodash_1.default.parseInt(childStyle.marginBottom)
+                + lodash_1.default.parseInt(childStyle.paddingTop)
+                + lodash_1.default.parseInt(childStyle.paddingBottom);
+            var hSpace = lodash_1.default.parseInt(childStyle.marginLeft)
+                + lodash_1.default.parseInt(childStyle.marginRight)
+                + lodash_1.default.parseInt(childStyle.paddingLeft)
+                + lodash_1.default.parseInt(childStyle.paddingRight);
+            return { width: width + hSpace, height: height + vSpace };
+        };
+        /**
+         * 获取目标节点的selector
+         * @param targetEl
+         */
+        FastVueMultiElement.getPath = function (targetEl) {
+            var currEl = targetEl;
+            var domPath = [];
+            if (currEl.id) {
+                domPath.unshift('#' + currEl.id);
+            }
+            else {
+                while (currEl.nodeName.toLowerCase() !== "html") {
+                    if (currEl.id) {
+                        domPath.unshift('#' + currEl.id);
+                        break;
+                    }
+                    else if (currEl.tagName.toLocaleLowerCase() === "body") {
+                        domPath.unshift(currEl.tagName.toLowerCase());
+                    }
+                    else {
+                        for (var i = 0; i < currEl.parentNode.childElementCount; i++) {
+                            if (currEl.parentNode.children[i] === currEl) {
+                                var className = currEl.getAttribute('class');
+                                if (className) {
+                                    var selectors = currEl.className.split(/\s/g), array = [];
+                                    for (var j = 0; j < selectors.length; ++j) {
+                                        if (selectors[j].length > 0) {
+                                            array.push('.' + selectors[j]);
+                                        }
+                                    }
+                                    className = array.join("");
+                                }
+                                else {
+                                    className = "";
+                                }
+                                domPath.unshift(currEl.tagName.toLowerCase() + className + ':nth-child(' + (i + 1) + ')');
+                            }
+                        }
+                    }
+                    currEl = currEl.parentNode;
+                }
+            }
+            return domPath.join(' > ');
+        };
+        /**
+         * 判断目标元素的滚动条 是否已滚动到底部
+         * @param targetEl
+         * @param scrollNimble 检测的灵敏度，越大越灵敏
+         */
+        FastVueMultiElement.isScrollBottom = function (targetEl, scrollNimble) {
+            var scrollTop = targetEl.scrollTop;
+            var elHeight = targetEl.getBoundingClientRect().height;
+            var scrollHeight = targetEl.scrollHeight;
+            return scrollTop + elHeight >= (scrollHeight - scrollNimble);
+        };
+        return FastVueMultiElement;
+    }());
+    exports.FastVueMultiElement = FastVueMultiElement;
+});

package/dist/esm/other/FastVueMultiFunction.d.ts

@@ -0,0 +1,19 @@
+export declare class FastVueMultiFunction {
+    /**
+     * 判断目标类型是否为函数
+     * @param source
+     */
+    static isFunction(source: any): boolean;
+    /**
+     * 批量执行函数并获取返回值
+     * @param source 单个函数或函数数组
+     * @param params 执行函数携带的参数
+     */
+    static run(source: any, ...params: any[]): any | null;
+    /**
+     * 按顺序同步执行函数，当其中一个函数返回false时，则终止后续执行
+     * @param source 单个函数或函数数组
+     * @param params 执行函数携带的参数
+     */
+    static syncRun(source: any, ...params: any[]): Promise<void>;
+}