@whitesev/utils 2.11.7 → 2.11.9

package/dist/index.amd.js

@@ -239,7 +239,7 @@ define((function () { 'use strict';
     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==
@@ -6129,31 +6129,35 @@ define((function () { 'use strict';
              * 元素是否可见
              * @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) {
@@ -6161,9 +6165,9 @@ define((function () { 'use strict';
                     }
                 }
                 /** 元素的样式 */
-                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) {
@@ -6179,7 +6183,7 @@ define((function () { 'use strict';
                         });
                     }
                 }
-            }
+            };
             target.querySelectorAll("*").forEach(($elItem) => {
                 queryMaxZIndex($elItem);
             });
@@ -6204,33 +6208,31 @@ define((function () { 'use strict';
             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)) {
@@ -6242,61 +6244,79 @@ define((function () { 'use strict';
             }
             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);
@@ -8321,6 +8341,20 @@ define((function () { 'use strict';
          * 深度获取对象的某个属性
          * @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) {
@@ -8336,10 +8370,23 @@ define((function () { 'use strict';
          * 异步-深度获取对象属性
          * @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);
@@ -8351,7 +8398,8 @@ define((function () { 'use strict';
         /**
          * 创建一个新的Utils实例
          * @param option
-         * @returns
+         * @example
+         * Utils.createUtils();
          */
         createUtils(option) {
             return new Utils(option);
@@ -8419,7 +8467,9 @@ define((function () { 'use strict';
         /**
          * 覆盖对象中的函数this指向
          * @param target 需要覆盖的对象
-         * @param [objectThis] 覆盖的this指向，如果为传入，则默认为对象本身
+         * @param objectThis 覆盖的this指向，如果为传入，则默认为对象本身
+         * @example
+         * Utils.coverObjectFunctionThis({})
          */
         coverObjectFunctionThis = commonUtil.coverObjectFunctionThis.bind(commonUtil);
         /**
@@ -8470,7 +8520,7 @@ define((function () { 'use strict';
         /**
          * 自动使用 Worker 执行 setTimeout
          * @param callback 回调函数
-         * @param [timeout=0] 延迟时间，默认为0
+         * @param timeout 延迟时间，默认为0
          */
         workerSetTimeout(callback, timeout = 0) {
             try {
@@ -8541,6 +8591,10 @@ define((function () { 'use strict';
         /**
          * 判断页面中是否存在`worker-src`的CSP规则
          * @param timeout 超时时间，默认为`1500ms`
+         * @example
+         * Utils.hasWorkerCSP().then((hasCSP) => {
+         *   console.log(hasCSP);
+         * })
          */
         hasWorkerCSP(timeout = 1500) {
             return new Promise((resolve) => {