@whitesev/utils 2.11.5 → 2.11.7

package/dist/index.iife.js

@@ -240,7 +240,7 @@ var Utils = (function () {
     const setInterval$1 = (...args) => loadOrReturnBroker().setInterval(...args);
     const setTimeout$1 = (...args) => loadOrReturnBroker().setTimeout(...args);
 
-    const version = "2.11.5";
+    const version = "2.11.7";
 
     /* eslint-disable */
     // ==UserScript==
@@ -6076,15 +6076,9 @@ var Utils = (function () {
             }
             return diffValue;
         }
-        /**
-         * 获取最大值
-         * @example
-         * Utils.getMaxValue([{1:123},{2:345},{3:456}],(index,value)=>{return parseInt(index)})
-         * > 2
-         */
         getMaxValue(...args) {
             const result = [...args];
-            let newResult = [];
+            const newResult = [];
             if (result.length === 0) {
                 return void 0;
             }
@@ -6093,13 +6087,20 @@ var Utils = (function () {
                     const data = result[0];
                     const handleDataFunc = result[1];
                     Object.keys(data).forEach((keyName) => {
-                        newResult = [...newResult, handleDataFunc(keyName, data[keyName])];
+                        newResult.push(handleDataFunc(keyName, data[keyName]));
+                    });
+                }
+                else if (result.length === 2 && Array.isArray(result[0]) && typeof result[1] === "function") {
+                    const data = result[0];
+                    const handleDataFunc = result[1];
+                    data.forEach((value, index, __data__) => {
+                        newResult.push(handleDataFunc(value, index, __data__));
                     });
                 }
                 else {
                     result.forEach((item) => {
                         if (!isNaN(parseFloat(item))) {
-                            newResult = [...newResult, parseFloat(item)];
+                            newResult.push(parseFloat(item));
                         }
                     });
                 }
@@ -6108,7 +6109,7 @@ var Utils = (function () {
             else {
                 result[0].forEach((item) => {
                     if (!isNaN(parseFloat(item))) {
-                        newResult = [...newResult, parseFloat(item)];
+                        newResult.push(parseFloat(item));
                     }
                 });
                 return Math.max(...newResult);
@@ -6127,45 +6128,61 @@ var Utils = (function () {
             let maxZIndexNode = null;
             /**
              * 元素是否可见
+             * @param $el
              * @param $css
              */
-            function isVisibleNode($css) {
-                return $css.position !== "static" && $css.display !== "none";
+            function isVisibleNode($el, $css) {
+                let flag = true;
+                if (typeof $el.checkVisibility === "function") {
+                    flag = $el.checkVisibility();
+                }
+                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;
+                }
+                return flag;
             }
             /**
              * 查询元素的z-index
              * 并比较值是否是已获取的最大值
-             * @param $ele
+             * @param $el
              */
-            function queryMaxZIndex($ele) {
+            function queryMaxZIndex($el) {
                 if (typeof ignoreCallBack === "function") {
-                    const ignoreResult = ignoreCallBack($ele);
+                    const ignoreResult = ignoreCallBack($el);
                     if (typeof ignoreResult === "boolean" && !ignoreResult) {
                         return;
                     }
                 }
                 /** 元素的样式 */
-                const nodeStyle = that.windowApi.window.getComputedStyle($ele);
+                const nodeStyle = that.windowApi.window.getComputedStyle($el);
                 /* 不对position为static和display为none的元素进行获取它们的z-index */
-                if (isVisibleNode(nodeStyle)) {
+                if (isVisibleNode($el, nodeStyle)) {
                     const nodeZIndex = parseInt(nodeStyle.zIndex);
                     if (!isNaN(nodeZIndex)) {
                         if (nodeZIndex > zIndex) {
                             // 赋值到全局
                             zIndex = nodeZIndex;
-                            maxZIndexNode = $ele;
+                            maxZIndexNode = $el;
                         }
                     }
                     // 判断shadowRoot
-                    if ($ele.shadowRoot != null && $ele instanceof ShadowRoot) {
-                        $ele.shadowRoot.querySelectorAll("*").forEach(($shadowEle) => {
+                    if ($el.shadowRoot != null && $el instanceof ShadowRoot) {
+                        $el.shadowRoot.querySelectorAll("*").forEach(($shadowEle) => {
                             queryMaxZIndex($shadowEle);
                         });
                     }
                 }
             }
-            target.querySelectorAll("*").forEach(($ele) => {
-                queryMaxZIndex($ele);
+            target.querySelectorAll("*").forEach(($elItem) => {
+                queryMaxZIndex($elItem);
             });
             zIndex += deviation;
             if (zIndex >= maxZIndexCompare) {
@@ -6177,6 +6194,127 @@ var Utils = (function () {
                 zIndex: zIndex,
             };
         }
+        getMaxZIndexNodeInfoFromPoint($el, deviation) {
+            if (typeof $el === "function") {
+                $el = $el();
+            }
+            if (typeof $el === "number") {
+                deviation = $el;
+                $el = void 0;
+            }
+            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,
+            ];
+            if ($el) {
+                delayHandlerElementPostionList.length = 0;
+                if (Array.isArray($el)) {
+                    delayHandlerElementPostionList.push(...$el);
+                }
+                else {
+                    delayHandlerElementPostionList.push($el);
+                }
+            }
+            const positionInfoList = delayHandlerElementPostionList
+                .map((position) => {
+                let positionNode;
+                let positionX;
+                let positionY;
+                if (position instanceof HTMLElement) {
+                    positionNode = 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);
+                    positionX = position.x;
+                    positionY = position.y;
+                }
+                const shadowRoot = positionNode?.shadowRoot;
+                if (shadowRoot) {
+                    positionNode = shadowRoot.elementFromPoint(positionX, positionY);
+                }
+                if (positionNode instanceof HTMLStyleElement)
+                    return;
+                if (positionNode instanceof HTMLScriptElement)
+                    return;
+                if (positionNode instanceof HTMLMetaElement)
+                    return;
+                if (positionNode instanceof HTMLHeadElement)
+                    return;
+                if (!(positionNode instanceof HTMLElement))
+                    return;
+                let parent = positionNode;
+                let zIndex = 0;
+                let maxZIndexNode = null;
+                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;
+                        }
+                    }
+                    parent = parent.parentElement;
+                }
+                return {
+                    /** 处理了偏移量后的z-index值 */
+                    zIndex: zIndex + deviation,
+                    /** 原始z-index值 */
+                    originZIndex: zIndex,
+                    /** 拥有最大z-index的元素 */
+                    node: maxZIndexNode,
+                    /** 目标坐标元素 */
+                    positionNode: positionNode,
+                    /** x坐标 */
+                    positionX: positionX,
+                    /** y坐标 */
+                    positionY: positionY,
+                };
+            })
+                .filter((it) => it != null);
+            // 降序排序
+            positionInfoList.sort((a, b) => {
+                if (a.zIndex < b.zIndex) {
+                    return 1;
+                }
+                else if (a.zIndex > b.zIndex) {
+                    return -1;
+                }
+                else {
+                    return 0;
+                }
+            });
+            return positionInfoList;
+        }
         getMaxZIndex(deviation = 1, target = this.windowApi.document, ignoreCallBack) {
             return this.getMaxZIndexNodeInfo(deviation, target, ignoreCallBack).zIndex;
         }
@@ -6730,7 +6868,6 @@ var Utils = (function () {
                     "is",
                     "jquery",
                     "keydown",
-                    "keypress",
                     "keyup",
                     "last",
                     "load",