@whitesev/utils 1.2.2 → 1.3.1

package/dist/index.system.js

@@ -3174,7 +3174,7 @@ System.register('Utils', [], (function (exports) {
             /// <reference path="./ajaxHooker/index.d.ts" />
             class Utils {
                 /** 版本号 */
-                version = "2024.5.28";
+                version = "2024.5.30";
                 addStyle(cssText) {
                     if (typeof cssText !== "string") {
                         throw new Error("Utils.addStyle 参数cssText 必须为String类型");
@@ -5601,251 +5601,318 @@ System.register('Utils', [], (function (exports) {
                         await UtilsContext.tryCatch(index, item).run(handleFunc);
                     }));
                 }
-                async waitNode(...nodeSelectors) {
-                    /* 检查每个参数是否为字符串类型 */
-                    for (let nodeSelector of nodeSelectors) {
-                        if (typeof nodeSelector !== "string") {
-                            throw new Error("Utils.waitNode 参数必须都是 string 类型");
+                waitNode(...args) {
+                    // 过滤掉undefined
+                    args = args.filter((arg) => arg !== void 0);
+                    let that = this;
+                    // 选择器
+                    let selector = args[0];
+                    // 父元素（监听的元素）
+                    let parent = UtilsCore.document;
+                    // 超时时间
+                    let timeout = 0;
+                    if (typeof args[0] !== "string" && !Array.isArray(args[0])) {
+                        throw new TypeError("Utils.waitNode 第一个参数必须是string|string[]");
+                    }
+                    if (args.length === 1) ;
+                    else if (args.length === 2) {
+                        let secondParam = args[1];
+                        if (typeof secondParam === "number") {
+                            // "div",10000
+                            timeout = secondParam;
+                        }
+                        else if (typeof secondParam === "object" &&
+                            secondParam instanceof Node) {
+                            // "div",document
+                            parent = secondParam;
+                        }
+                        else {
+                            throw new TypeError("Utils.waitNode 第二个参数必须是number|Node");
+                        }
+                    }
+                    else if (args.length === 3) {
+                        // "div",document,10000
+                        // 第二个参数，parent
+                        let secondParam = args[1];
+                        // 第三个参数，timeout
+                        let thirdParam = args[2];
+                        if (typeof secondParam === "object" && secondParam instanceof Node) {
+                            parent = secondParam;
+                            if (typeof thirdParam === "number") {
+                                timeout = thirdParam;
+                            }
+                            else {
+                                throw new TypeError("Utils.waitNode 第三个参数必须是number");
+                            }
+                        }
+                        else {
+                            throw new TypeError("Utils.waitNode 第二个参数必须是Node");
                         }
                     }
-                    let UtilsContext = this;
+                    else {
+                        throw new TypeError("Utils.waitNode 参数个数错误");
+                    }
                     return new Promise((resolve) => {
-                        /* 防止触发第二次回调 */
-                        let isReturn = false;
-                        /**
-                         * 检查所有选择器是否匹配到节点
-                         * @param observer
-                         */
-                        let checkNodes = (observer) => {
-                            let isFind = true;
-                            let selectNodeArray = [];
-                            for (let selector of nodeSelectors) {
-                                let element = document.querySelector(selector);
-                                if (!element) {
-                                    /* 没找到，直接退出循环 */
-                                    isFind = false;
-                                    break;
+                        function getNode() {
+                            if (Array.isArray(selector)) {
+                                let result = [];
+                                for (let index = 0; index < selector.length; index++) {
+                                    let node = parent.querySelector(selector[index]);
+                                    if (node) {
+                                        result.push(node);
+                                    }
                                 }
-                                selectNodeArray.push(element);
-                            }
-                            if (isFind) {
-                                isReturn = true;
-                                observer?.disconnect();
-                                /* 如果只有一个选择器，那么返回数组中存储的第一个 */
-                                if (selectNodeArray.length === 1) {
-                                    resolve(selectNodeArray[0]);
-                                }
-                                else {
-                                    resolve(selectNodeArray);
+                                if (result.length === selector.length) {
+                                    return result;
                                 }
                             }
-                        };
-                        /* 在函数开始时检查节点是否已经存在 */
-                        checkNodes();
-                        /* 监听 DOM 的变化，直到至少有一个节点被匹配到 */
-                        UtilsContext.mutationObserver(document.documentElement, {
-                            config: { subtree: true, childList: true, attributes: true },
-                            callback: (mutations, observer) => {
-                                if (isReturn) {
+                            else {
+                                return parent.querySelector(selector);
+                            }
+                        }
+                        let node = getNode();
+                        if (node) {
+                            resolve(node);
+                            return;
+                        }
+                        let observer = that.mutationObserver(parent, {
+                            config: {
+                                subtree: true,
+                                childList: true,
+                                attributes: true,
+                            },
+                            callback() {
+                                let node = getNode();
+                                if (node) {
+                                    // 取消观察器
+                                    observer.disconnect();
+                                    resolve(node);
                                     return;
                                 }
-                                checkNodes(observer);
                             },
                         });
+                        if (timeout > 0) {
+                            setTimeout(() => {
+                                // 取消观察器
+                                observer.disconnect();
+                                resolve(null);
+                            }, timeout);
+                        }
                     });
                 }
-                waitNodeWithInterval(nodeSelectorsList = [], maxTime = 0) {
-                    let UtilsContext = this;
-                    let nodeSelectors = [];
-                    /* 检查每个参数是否为字符串类型 */
-                    if (Array.isArray(nodeSelectorsList)) {
-                        for (let nodeSelector of nodeSelectorsList) {
-                            if (typeof nodeSelector !== "string") {
-                                throw new Error("Utils.waitNodeWithInterval 参数nodeSelectorsList必须为 string[] 类型");
+                waitAnyNode(...args) {
+                    // 过滤掉undefined
+                    args = args.filter((arg) => arg !== void 0);
+                    let that = this;
+                    // 选择器
+                    let selectorList = args[0];
+                    // 父元素（监听的元素）
+                    let parent = UtilsCore.document;
+                    // 超时时间
+                    let timeout = 0;
+                    if (typeof args[0] !== "object" && !Array.isArray(args[0])) {
+                        throw new TypeError("Utils.waitAnyNode 第一个参数必须是string[]");
+                    }
+                    if (args.length === 1) ;
+                    else if (args.length === 2) {
+                        let secondParam = args[1];
+                        if (typeof secondParam === "number") {
+                            // "div",10000
+                            timeout = secondParam;
+                        }
+                        else if (typeof secondParam === "object" &&
+                            secondParam instanceof Node) {
+                            // "div",document
+                            parent = secondParam;
+                        }
+                        else {
+                            throw new TypeError("Utils.waitAnyNode 第二个参数必须是number|Node");
+                        }
+                    }
+                    else if (args.length === 3) {
+                        // "div",document,10000
+                        // 第二个参数，parent
+                        let secondParam = args[1];
+                        // 第三个参数，timeout
+                        let thirdParam = args[2];
+                        if (typeof secondParam === "object" && secondParam instanceof Node) {
+                            parent = secondParam;
+                            if (typeof thirdParam === "number") {
+                                timeout = thirdParam;
+                            }
+                            else {
+                                throw new TypeError("Utils.waitAnyNode 第三个参数必须是number");
                             }
                         }
-                        nodeSelectors = nodeSelectorsList;
+                        else {
+                            throw new TypeError("Utils.waitAnyNode 第二个参数必须是Node");
+                        }
                     }
                     else {
-                        nodeSelectors.push(nodeSelectorsList);
+                        throw new TypeError("Utils.waitAnyNode 参数个数错误");
                     }
-                    return new Promise((resolve, reject) => {
-                        /* 防止触发第二次回调 */
-                        let isReturn = false;
-                        /* 检查所有选择器是否匹配到节点 */
-                        let checkNodes = (observer) => {
-                            let isFind = true;
-                            let selectNodeArray = [];
-                            for (let selector of nodeSelectors) {
-                                let element = document.querySelector(selector);
-                                if (!element) {
-                                    /* 没找到，直接退出循环 */
-                                    isFind = false;
-                                    break;
-                                }
-                                selectNodeArray.push(element);
-                            }
-                            if (isFind) {
-                                isReturn = true;
-                                observer?.disconnect();
-                                /* 如果只有一个选择器，那么返回数组中存储的第一个 */
-                                if (selectNodeArray.length === 1) {
-                                    resolve(selectNodeArray[0]);
-                                }
-                                else {
-                                    resolve(selectNodeArray);
-                                }
-                            }
-                        };
-                        /* 在函数开始时检查节点是否已经存在 */
-                        checkNodes();
-                        /* 监听 DOM 的变化，直到至少有一个节点被匹配到 */
-                        let mutationObserver = UtilsContext.mutationObserver(document.documentElement, {
-                            config: { subtree: true, childList: true, attributes: true },
-                            callback: (mutations, observer) => {
-                                if (isReturn) {
-                                    return;
-                                }
-                                checkNodes(observer);
-                            },
-                        });
-                        setTimeout(() => {
-                            mutationObserver.disconnect();
-                            reject();
-                        }, maxTime);
+                    let promiseList = selectorList.map((selector) => {
+                        return that.waitNode(selector, parent, timeout);
                     });
+                    return Promise.any(promiseList);
                 }
-                waitAnyNode(...nodeSelectors) {
-                    let UtilsContext = this;
-                    /* 检查每个参数是否为字符串类型 */
-                    for (let nodeSelector of nodeSelectors) {
-                        if (typeof nodeSelector !== "string") {
-                            throw new Error("Utils.waitNode 参数必须为 ...string 类型");
+                waitNodeList(...args) {
+                    // 过滤掉undefined
+                    args = args.filter((arg) => arg !== void 0);
+                    let that = this;
+                    // 选择器数组
+                    let selector = args[0];
+                    // 父元素（监听的元素）
+                    let parent = UtilsCore.document;
+                    // 超时时间
+                    let timeout = 0;
+                    if (typeof args[0] !== "string" && !Array.isArray(args[0])) {
+                        throw new TypeError("Utils.waitNodeList 第一个参数必须是string|string[]");
+                    }
+                    if (args.length === 1) ;
+                    else if (args.length === 2) {
+                        let secondParam = args[1];
+                        if (typeof secondParam === "number") {
+                            // "div",10000
+                            timeout = secondParam;
+                        }
+                        else if (typeof secondParam === "object" &&
+                            secondParam instanceof Node) {
+                            // "div",document
+                            parent = secondParam;
                         }
-                    }
-                    return new Promise((resolve) => {
-                        /* 防止触发第二次回调 */
-                        let isReturn = false;
-                        /* 检查所有选择器是否存在任意匹配到元素 */
-                        let checkNodes = (observer) => {
-                            let selectNode = null;
-                            for (let selector of nodeSelectors) {
-                                selectNode = document.querySelector(selector);
-                                if (selectNode) {
-                                    /* 找到，退出循环 */
-                                    break;
-                                }
+                        else {
+                            throw new TypeError("Utils.waitNodeList 第二个参数必须是number|Node");
+                        }
+                    }
+                    else if (args.length === 3) {
+                        // "div",document,10000
+                        // 第二个参数，parent
+                        let secondParam = args[1];
+                        // 第三个参数，timeout
+                        let thirdParam = args[2];
+                        if (typeof secondParam === "object" && secondParam instanceof Node) {
+                            parent = secondParam;
+                            if (typeof thirdParam === "number") {
+                                timeout = thirdParam;
                             }
-                            if (selectNode) {
-                                isReturn = true;
-                                observer?.disconnect();
-                                resolve(selectNode);
+                            else {
+                                throw new TypeError("Utils.waitNodeList 第三个参数必须是number");
                             }
-                        };
-                        /* 在函数开始时检查节点是否已经存在 */
-                        checkNodes();
-                        /* 监听 DOM 的变化，直到至少有一个节点被匹配到 */
-                        UtilsContext.mutationObserver(document.documentElement, {
-                            config: { subtree: true, childList: true, attributes: true },
-                            callback: (mutations, observer) => {
-                                if (isReturn) {
-                                    return;
-                                }
-                                checkNodes(observer);
-                            },
-                        });
-                    });
-                }
-                waitNodeList(...nodeSelectors) {
-                    let UtilsContext = this;
-                    /* 检查每个参数是否为字符串类型 */
-                    for (let nodeSelector of nodeSelectors) {
-                        if (typeof nodeSelector !== "string") {
-                            throw new Error("Utils.waitNode 参数必须为 ...string 类型");
+                        }
+                        else {
+                            throw new TypeError("Utils.waitNodeList 第二个参数必须是Node");
                         }
                     }
+                    else {
+                        throw new TypeError("Utils.waitNodeList 参数个数错误");
+                    }
                     return new Promise((resolve) => {
-                        /* 防止触发第二次回调 */
-                        let isReturn = false;
-                        /* 检查所有选择器是否匹配到节点 */
-                        let checkNodes = (observer) => {
-                            let isFind = true;
-                            let selectNodes = [];
-                            for (let selector of nodeSelectors) {
-                                let nodeList = document.querySelectorAll(selector);
-                                if (nodeList.length === 0) {
-                                    /* 没找到，直接退出循环 */
-                                    isFind = false;
-                                    break;
+                        function getNodeList() {
+                            if (Array.isArray(selector)) {
+                                let result = [];
+                                for (let index = 0; index < selector.length; index++) {
+                                    let nodeList = parent.querySelectorAll(selector[index]);
+                                    if (nodeList.length) {
+                                        result.push(nodeList);
+                                    }
                                 }
-                                selectNodes.push(nodeList);
-                            }
-                            if (isFind) {
-                                isReturn = true;
-                                observer?.disconnect();
-                                /* 如果只有一个选择器，那么返回第一个 */
-                                if (selectNodes.length === 1) {
-                                    resolve(selectNodes[0]);
+                                if (result.length === selector.length) {
+                                    return result;
                                 }
-                                else {
-                                    resolve(selectNodes);
+                            }
+                            else {
+                                let nodeList = parent.querySelectorAll(selector);
+                                if (nodeList.length) {
+                                    return nodeList;
                                 }
                             }
-                        };
-                        /* 在函数开始时检查节点是否已经存在 */
-                        checkNodes();
-                        /* 监听 DOM 的变化，直到至少有一个节点被匹配到 */
-                        UtilsContext.mutationObserver(document.documentElement, {
-                            config: { subtree: true, childList: true, attributes: true },
-                            callback: (mutations, observer) => {
-                                if (isReturn) {
+                        }
+                        let nodeList = getNodeList();
+                        if (nodeList) {
+                            resolve(nodeList);
+                            return;
+                        }
+                        let observer = that.mutationObserver(parent, {
+                            config: {
+                                subtree: true,
+                                childList: true,
+                                attributes: true,
+                            },
+                            callback() {
+                                let node = getNodeList();
+                                if (node) {
+                                    // 取消观察器
+                                    observer.disconnect();
+                                    resolve(node);
                                     return;
                                 }
-                                checkNodes(observer);
                             },
                         });
+                        if (timeout > 0) {
+                            setTimeout(() => {
+                                // 取消观察器
+                                observer.disconnect();
+                                resolve(null);
+                            }, timeout);
+                        }
                     });
                 }
-                waitAnyNodeList(...nodeSelectors) {
-                    let UtilsContext = this;
-                    /* 检查每个参数是否为字符串类型 */
-                    for (let nodeSelector of nodeSelectors) {
-                        if (typeof nodeSelector !== "string") {
-                            throw new Error("Utils.waitNode 参数必须为 ...string 类型");
+                waitAnyNodeList(...args) {
+                    // 过滤掉undefined
+                    args = args.filter((arg) => arg !== void 0);
+                    let that = this;
+                    // 选择器数组
+                    let selectorList = args[0];
+                    // 父元素（监听的元素）
+                    let parent = UtilsCore.document;
+                    // 超时时间
+                    let timeout = 0;
+                    if (!Array.isArray(args[0])) {
+                        throw new TypeError("Utils.waitAnyNodeList 第一个参数必须是string[]");
+                    }
+                    if (args.length === 1) ;
+                    else if (args.length === 2) {
+                        let secondParam = args[1];
+                        if (typeof secondParam === "number") {
+                            // "div",10000
+                            timeout = secondParam;
+                        }
+                        else if (typeof secondParam === "object" &&
+                            secondParam instanceof Node) {
+                            // "div",document
+                            parent = secondParam;
                         }
-                    }
-                    return new Promise((resolve) => {
-                        /* 防止触发第二次回调 */
-                        let isReturn = false;
-                        /* 检查所有选择器是否匹配到节点 */
-                        let checkNodes = (observer) => {
-                            let selectNodes = [];
-                            for (let selector of nodeSelectors) {
-                                selectNodes = document.querySelectorAll(selector);
-                                if (selectNodes.length) {
-                                    /* 找到，退出循环 */
-                                    break;
-                                }
+                        else {
+                            throw new TypeError("Utils.waitAnyNodeList 第二个参数必须是number|Node");
+                        }
+                    }
+                    else if (args.length === 3) {
+                        // "div",document,10000
+                        // 第二个参数，parent
+                        let secondParam = args[1];
+                        // 第三个参数，timeout
+                        let thirdParam = args[2];
+                        if (typeof secondParam === "object" && secondParam instanceof Node) {
+                            parent = secondParam;
+                            if (typeof thirdParam === "number") {
+                                timeout = thirdParam;
                             }
-                            if (selectNodes.length) {
-                                isReturn = true;
-                                observer?.disconnect();
-                                resolve(selectNodes);
+                            else {
+                                throw new TypeError("Utils.waitAnyNodeList 第三个参数必须是number");
                             }
-                        };
-                        /* 在函数开始时检查节点是否已经存在 */
-                        checkNodes();
-                        /* 监听 DOM 的变化，直到至少有一个节点被匹配到 */
-                        UtilsContext.mutationObserver(document.documentElement, {
-                            config: { subtree: true, childList: true, attributes: true },
-                            callback: (mutations, observer) => {
-                                if (isReturn) {
-                                    return;
-                                }
-                                checkNodes(observer);
-                            },
-                        });
+                        }
+                        else {
+                            throw new TypeError("Utils.waitAnyNodeList 第二个参数必须是Node");
+                        }
+                    }
+                    else {
+                        throw new TypeError("Utils.waitAnyNodeList 参数个数错误");
+                    }
+                    let promiseList = selectorList.map((selector) => {
+                        return that.waitNodeList(selector, parent, timeout);
                     });
+                    return Promise.any(promiseList);
                 }
                 waitProperty(checkObj, checkPropertyName) {
                     return new Promise((resolve) => {