@whitesev/utils 2.11.4 → 2.11.6

package/dist/index.cjs.js

@@ -239,7 +239,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.4";
+const version = "2.11.6";
 
 /* eslint-disable */
 // ==UserScript==
@@ -6075,15 +6075,9 @@ class Utils {
         }
         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;
         }
@@ -6092,13 +6086,20 @@ class Utils {
                 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));
                     }
                 });
             }
@@ -6107,7 +6108,7 @@ class Utils {
         else {
             result[0].forEach((item) => {
                 if (!isNaN(parseFloat(item))) {
-                    newResult = [...newResult, parseFloat(item)];
+                    newResult.push(parseFloat(item));
                 }
             });
             return Math.max(...newResult);
@@ -6126,45 +6127,61 @@ class Utils {
         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) {
@@ -6176,6 +6193,124 @@ class Utils {
             zIndex: zIndex,
         };
     }
+    getMaxZIndexNodeInfoFromPoint($el, deviation) {
+        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;
     }
@@ -6729,7 +6864,6 @@ class Utils {
                 "is",
                 "jquery",
                 "keydown",
-                "keypress",
                 "keyup",
                 "last",
                 "load",
@@ -7513,8 +7647,7 @@ class Utils {
             }
             async init() {
                 let copyStatus = false;
-                const requestPermissionStatus = await this.requestClipboardPermission();
-                console.log(requestPermissionStatus);
+                await this.requestClipboardPermission();
                 if (this.hasClipboard() && (this.hasClipboardWrite() || this.hasClipboardWriteText())) {
                     try {
                         copyStatus = await this.copyDataByClipboard();