@whitesev/utils 2.11.7 → 2.11.9

package/dist/index.system.js

@@ -242,7 +242,7 @@ System.register('Utils', [], (function (exports) {
             const setInterval$1 = (...args) => loadOrReturnBroker().setInterval(...args);
             const setTimeout$1 = (...args) => loadOrReturnBroker().setTimeout(...args);
 
-            const version = "2.11.7";
+            const version = "2.11.9";
 
             /* eslint-disable */
             // ==UserScript==
@@ -6132,31 +6132,35 @@ System.register('Utils', [], (function (exports) {
                      * 元素是否可见
                      * @param $el
                      * @param $css
+                     * @returns
+                     * + true 可见
+                     * + false 不可见
                      */
-                    function isVisibleNode($el, $css) {
+                    const isVisibleNode = function ($css, $el) {
                         let flag = true;
-                        if (typeof $el.checkVisibility === "function") {
-                            flag = $el.checkVisibility();
+                        if (!($el instanceof HTMLElement)) {
+                            flag = false;
                         }
                         else {
-                            flag =
-                                $css.position !== "static" && $css.display !== "none" && $css.visibility !== "hidden" && $css.opacity !== "0";
-                        }
-                        if (flag) {
-                            // css样式上可见
-                            // 再判断宽高
-                            const rect = $el.getBoundingClientRect();
-                            // 确保该元素的中心点在屏幕内
-                            flag = rect.width > 0 && rect.height > 0 && rect.x > 0 && rect.y > 0;
+                            if (typeof $el.checkVisibility === "function") {
+                                flag = $el.checkVisibility();
+                            }
+                            else {
+                                flag =
+                                    $css.position !== "static" &&
+                                        $css.display !== "none" &&
+                                        $css.visibility !== "hidden" &&
+                                        $css.opacity !== "0";
+                            }
                         }
                         return flag;
-                    }
+                    };
                     /**
                      * 查询元素的z-index
                      * 并比较值是否是已获取的最大值
                      * @param $el
                      */
-                    function queryMaxZIndex($el) {
+                    const queryMaxZIndex = function ($el) {
                         if (typeof ignoreCallBack === "function") {
                             const ignoreResult = ignoreCallBack($el);
                             if (typeof ignoreResult === "boolean" && !ignoreResult) {
@@ -6164,9 +6168,9 @@ System.register('Utils', [], (function (exports) {
                             }
                         }
                         /** 元素的样式 */
-                        const nodeStyle = that.windowApi.window.getComputedStyle($el);
+                        const nodeStyle = that.windowApi.globalThis.getComputedStyle($el);
                         /* 不对position为static和display为none的元素进行获取它们的z-index */
-                        if (isVisibleNode($el, nodeStyle)) {
+                        if (isVisibleNode(nodeStyle, $el)) {
                             const nodeZIndex = parseInt(nodeStyle.zIndex);
                             if (!isNaN(nodeZIndex)) {
                                 if (nodeZIndex > zIndex) {
@@ -6182,7 +6186,7 @@ System.register('Utils', [], (function (exports) {
                                 });
                             }
                         }
-                    }
+                    };
                     target.querySelectorAll("*").forEach(($elItem) => {
                         queryMaxZIndex($elItem);
                     });
@@ -6207,33 +6211,31 @@ System.register('Utils', [], (function (exports) {
                     if (typeof deviation !== "number" || Number.isNaN(deviation)) {
                         deviation = 10;
                     }
-                    const leftTop = {
-                        x: globalThis.innerWidth * (1 / 8),
-                        y: globalThis.innerHeight * (1 / 8),
-                    };
-                    const leftBottom = {
-                        x: globalThis.innerWidth * (1 / 8),
-                        y: globalThis.innerHeight * (7 / 8),
-                    };
-                    const rightTop = {
-                        x: globalThis.innerWidth * (7 / 8),
-                        y: globalThis.innerHeight * (1 / 8),
-                    };
-                    const rightBottom = {
-                        x: globalThis.innerWidth * (7 / 8),
-                        y: globalThis.innerHeight * (7 / 8),
-                    };
-                    const center = {
-                        x: globalThis.innerWidth / 2,
-                        y: globalThis.innerHeight / 2,
-                    };
-                    const delayHandlerElementPostionList = [
-                        leftTop,
-                        leftBottom,
-                        rightTop,
-                        rightBottom,
-                        center,
-                    ];
+                    /** 坐标偏移 */
+                    const positionDistance = 10;
+                    const defaultCalcPostion = [];
+                    const maxPostionX = globalThis.innerWidth;
+                    const maxPostionY = globalThis.innerHeight;
+                    const gridXCount = 8;
+                    const gridYCount = 8;
+                    for (let i = 0; i < gridXCount; i++) {
+                        for (let j = 0; j < gridYCount; j++) {
+                            const positionX = globalThis.innerWidth * (i / gridXCount) + positionDistance;
+                            const positionY = globalThis.innerHeight * (j / gridYCount) + positionDistance;
+                            const position = {
+                                x: positionX,
+                                y: positionY,
+                            };
+                            if (position.x > maxPostionX) {
+                                position.x = maxPostionX;
+                            }
+                            if (position.y > maxPostionY) {
+                                position.y = maxPostionY;
+                            }
+                            defaultCalcPostion.push(position);
+                        }
+                    }
+                    const delayHandlerElementPostionList = defaultCalcPostion;
                     if ($el) {
                         delayHandlerElementPostionList.length = 0;
                         if (Array.isArray($el)) {
@@ -6245,61 +6247,79 @@ System.register('Utils', [], (function (exports) {
                     }
                     const positionInfoList = delayHandlerElementPostionList
                         .map((position) => {
-                        let positionNode;
+                        let $position;
                         let positionX;
                         let positionY;
                         if (position instanceof HTMLElement) {
-                            positionNode = position;
+                            $position = position;
                             const nodeRect = position.getBoundingClientRect();
                             positionX = nodeRect.x + nodeRect.width / 2;
                             positionY = nodeRect.y + nodeRect.height / 2;
                         }
                         else {
-                            positionNode = document.elementFromPoint(position.x, position.y);
+                            $position = document.elementFromPoint(position.x, position.y);
                             positionX = position.x;
                             positionY = position.y;
                         }
-                        const shadowRoot = positionNode?.shadowRoot;
+                        const shadowRoot = $position?.shadowRoot;
                         if (shadowRoot) {
-                            positionNode = shadowRoot.elementFromPoint(positionX, positionY);
+                            // 处理ShadowRoot
+                            $position = shadowRoot.elementFromPoint(positionX, positionY);
                         }
-                        if (positionNode instanceof HTMLStyleElement)
-                            return;
-                        if (positionNode instanceof HTMLScriptElement)
-                            return;
-                        if (positionNode instanceof HTMLMetaElement)
-                            return;
-                        if (positionNode instanceof HTMLHeadElement)
+                        if (!($position instanceof HTMLElement))
                             return;
-                        if (!(positionNode instanceof HTMLElement))
-                            return;
-                        let parent = positionNode;
+                        let $parent = $position;
                         let zIndex = 0;
-                        let maxZIndexNode = null;
-                        while (parent) {
-                            const nodeStyle = globalThis.getComputedStyle(parent);
+                        let $maxZIndexNode = null;
+                        let rect = {
+                            x: 0,
+                            y: 0,
+                            width: 0,
+                            height: 0,
+                            top: 0,
+                            right: 0,
+                            bottom: 0,
+                            left: 0,
+                        };
+                        while ($parent) {
+                            const nodeStyle = globalThis.getComputedStyle($parent);
                             const nodeZIndex = parseInt(nodeStyle.zIndex);
                             if (nodeStyle.position !== "static" && !isNaN(nodeZIndex)) {
                                 if (nodeZIndex > zIndex) {
                                     zIndex = nodeZIndex;
-                                    maxZIndexNode = parent;
+                                    $maxZIndexNode = $parent;
                                 }
                             }
-                            parent = parent.parentElement;
+                            $parent = $parent.parentElement;
+                        }
+                        if ($maxZIndexNode) {
+                            const maxRect = $maxZIndexNode.getBoundingClientRect();
+                            rect = {
+                                x: maxRect.x,
+                                y: maxRect.y,
+                                width: maxRect.width,
+                                height: maxRect.height,
+                                top: maxRect.top,
+                                right: maxRect.right,
+                                bottom: maxRect.bottom,
+                                left: maxRect.left,
+                            };
                         }
                         return {
-                            /** 处理了偏移量后的z-index值 */
+                            /** 计算偏移量后的z-index值 */
                             zIndex: zIndex + deviation,
-                            /** 原始z-index值 */
+                            /** 获取到的最大的z-index值 */
                             originZIndex: zIndex,
                             /** 拥有最大z-index的元素 */
-                            node: maxZIndexNode,
+                            node: $maxZIndexNode,
                             /** 目标坐标元素 */
-                            positionNode: positionNode,
-                            /** x坐标 */
+                            positionNode: $position,
+                            /** 目标x坐标 */
                             positionX: positionX,
-                            /** y坐标 */
+                            /** 目标y坐标 */
                             positionY: positionY,
+                            /** node位置信息 */
+                            rect,
                         };
                     })
                         .filter((it) => it != null);
@@ -8324,6 +8344,20 @@ System.register('Utils', [], (function (exports) {
                  * 深度获取对象的某个属性
                  * @param target 待获取的对象
                  * @param handler 获取属性的回调
+                 * @example
+                 * Utils.queryProperty(window,(target)=>{
+                 *   if(target.xxx){
+                 *     return {
+                 *       isFind: true,
+                 *       data: target.xxx,
+                 *     }
+                 *   }else{
+                 *     return {
+                 *       isFind: false,
+                 *       data: target.aabbcc,
+                 *     }
+                 *   }
+                 * })
                  */
                 queryProperty(target, handler) {
                     if (target == null) {
@@ -8339,10 +8373,23 @@ System.register('Utils', [], (function (exports) {
                  * 异步-深度获取对象属性
                  * @param target 待获取的对象
                  * @param handler 获取属性的回调
+                 * @example
+                 * Utils.asyncQueryProperty(window, async (target)=>{
+                 *   if(target.xxx){
+                 *     return {
+                 *       isFind: true,
+                 *       data: target.xxx,
+                 *     }
+                 *   }else{
+                 *     return {
+                 *       isFind: false,
+                 *       data: target.aabbcc,
+                 *     }
+                 *   }
+                 * })
                  */
                 async asyncQueryProperty(target, handler) {
                     if (target == null) {
-                        // @ts-expect-error 空返回
                         return;
                     }
                     const handleResult = await handler(target);
@@ -8354,7 +8401,8 @@ System.register('Utils', [], (function (exports) {
                 /**
                  * 创建一个新的Utils实例
                  * @param option
-                 * @returns
+                 * @example
+                 * Utils.createUtils();
                  */
                 createUtils(option) {
                     return new Utils(option);
@@ -8422,7 +8470,9 @@ System.register('Utils', [], (function (exports) {
                 /**
                  * 覆盖对象中的函数this指向
                  * @param target 需要覆盖的对象
-                 * @param [objectThis] 覆盖的this指向，如果为传入，则默认为对象本身
+                 * @param objectThis 覆盖的this指向，如果为传入，则默认为对象本身
+                 * @example
+                 * Utils.coverObjectFunctionThis({})
                  */
                 coverObjectFunctionThis = commonUtil.coverObjectFunctionThis.bind(commonUtil);
                 /**
@@ -8473,7 +8523,7 @@ System.register('Utils', [], (function (exports) {
                 /**
                  * 自动使用 Worker 执行 setTimeout
                  * @param callback 回调函数
-                 * @param [timeout=0] 延迟时间，默认为0
+                 * @param timeout 延迟时间，默认为0
                  */
                 workerSetTimeout(callback, timeout = 0) {
                     try {
@@ -8544,6 +8594,10 @@ System.register('Utils', [], (function (exports) {
                 /**
                  * 判断页面中是否存在`worker-src`的CSP规则
                  * @param timeout 超时时间，默认为`1500ms`
+                 * @example
+                 * Utils.hasWorkerCSP().then((hasCSP) => {
+                 *   console.log(hasCSP);
+                 * })
                  */
                 hasWorkerCSP(timeout = 1500) {
                     return new Promise((resolve) => {