@whitesev/utils 2.11.7 → 2.11.9

package/dist/index.esm.js

@@ -237,7 +237,7 @@ const clearTimeout$1 = (timerId) => loadOrReturnBroker().clearTimeout(timerId);
 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==
@@ -6127,31 +6127,35 @@ class Utils {
          * 元素是否可见
          * @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) {
@@ -6159,9 +6163,9 @@ class Utils {
                 }
             }
             /** 元素的样式 */
-            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) {
@@ -6177,7 +6181,7 @@ class Utils {
                     });
                 }
             }
-        }
+        };
         target.querySelectorAll("*").forEach(($elItem) => {
             queryMaxZIndex($elItem);
         });
@@ -6202,33 +6206,31 @@ class Utils {
         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)) {
@@ -6240,61 +6242,79 @@ class Utils {
         }
         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);
@@ -8319,6 +8339,20 @@ class Utils {
      * 深度获取对象的某个属性
      * @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) {
@@ -8334,10 +8368,23 @@ class Utils {
      * 异步-深度获取对象属性
      * @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);
@@ -8349,7 +8396,8 @@ class Utils {
     /**
      * 创建一个新的Utils实例
      * @param option
-     * @returns
+     * @example
+     * Utils.createUtils();
      */
     createUtils(option) {
         return new Utils(option);
@@ -8417,7 +8465,9 @@ class Utils {
     /**
      * 覆盖对象中的函数this指向
      * @param target 需要覆盖的对象
-     * @param [objectThis] 覆盖的this指向，如果为传入，则默认为对象本身
+     * @param objectThis 覆盖的this指向，如果为传入，则默认为对象本身
+     * @example
+     * Utils.coverObjectFunctionThis({})
      */
     coverObjectFunctionThis = commonUtil.coverObjectFunctionThis.bind(commonUtil);
     /**
@@ -8468,7 +8518,7 @@ class Utils {
     /**
      * 自动使用 Worker 执行 setTimeout
      * @param callback 回调函数
-     * @param [timeout=0] 延迟时间，默认为0
+     * @param timeout 延迟时间，默认为0
      */
     workerSetTimeout(callback, timeout = 0) {
         try {
@@ -8539,6 +8589,10 @@ class Utils {
     /**
      * 判断页面中是否存在`worker-src`的CSP规则
      * @param timeout 超时时间，默认为`1500ms`
+     * @example
+     * Utils.hasWorkerCSP().then((hasCSP) => {
+     *   console.log(hasCSP);
+     * })
      */
     hasWorkerCSP(timeout = 1500) {
         return new Promise((resolve) => {