@sqaitech/shared 0.30.10

package/dist/es/extractor/util.mjs

@@ -0,0 +1,244 @@
+import { generateHashId } from "../utils.mjs";
+import { extractTextWithPosition } from "./web-extractor.mjs";
+const MAX_VALUE_LENGTH = 300;
+let debugMode = false;
+function setDebugMode(mode) {
+    debugMode = mode;
+}
+function getDebugMode() {
+    return debugMode;
+}
+function logger(..._msg) {
+    if (!debugMode) return;
+    console.log(..._msg);
+}
+function isElementPartiallyInViewport(rect, currentWindow, currentDocument, visibleAreaRatio = 2 / 3) {
+    const elementHeight = rect.height;
+    const elementWidth = rect.width;
+    const viewportRect = {
+        left: 0,
+        top: 0,
+        width: currentWindow.innerWidth || currentDocument.documentElement.clientWidth,
+        height: currentWindow.innerHeight || currentDocument.documentElement.clientHeight,
+        right: currentWindow.innerWidth || currentDocument.documentElement.clientWidth,
+        bottom: currentWindow.innerHeight || currentDocument.documentElement.clientHeight,
+        x: 0,
+        y: 0,
+        zoom: 1
+    };
+    const overlapRect = overlappedRect(rect, viewportRect);
+    if (!overlapRect) return false;
+    const visibleArea = overlapRect.width * overlapRect.height;
+    const totalArea = elementHeight * elementWidth;
+    return visibleArea / totalArea >= visibleAreaRatio;
+}
+function getPseudoElementContent(element, currentWindow) {
+    if (!(element instanceof currentWindow.HTMLElement)) return {
+        before: '',
+        after: ''
+    };
+    const beforeContent = currentWindow.getComputedStyle(element, '::before').getPropertyValue('content');
+    const afterContent = currentWindow.getComputedStyle(element, '::after').getPropertyValue('content');
+    return {
+        before: 'none' === beforeContent ? '' : beforeContent.replace(/"/g, ''),
+        after: 'none' === afterContent ? '' : afterContent.replace(/"/g, '')
+    };
+}
+function hasOverflowY(element, currentWindow) {
+    const style = currentWindow.getComputedStyle(element);
+    return 'scroll' === style.overflowY || 'auto' === style.overflowY || 'hidden' === style.overflowY;
+}
+function overlappedRect(rect1, rect2) {
+    const left = Math.max(rect1.left, rect2.left);
+    const top = Math.max(rect1.top, rect2.top);
+    const right = Math.min(rect1.right, rect2.right);
+    const bottom = Math.min(rect1.bottom, rect2.bottom);
+    if (left < right && top < bottom) return {
+        left,
+        top,
+        right,
+        bottom,
+        width: right - left,
+        height: bottom - top,
+        x: left,
+        y: top,
+        zoom: 1
+    };
+    return null;
+}
+function getRect(el, baseZoom, currentWindow) {
+    let originalRect;
+    let newZoom = 1;
+    if (el instanceof currentWindow.HTMLElement) {
+        originalRect = el.getBoundingClientRect();
+        if (!('currentCSSZoom' in el)) newZoom = Number.parseFloat(currentWindow.getComputedStyle(el).zoom) || 1;
+    } else {
+        const range = currentWindow.document.createRange();
+        range.selectNodeContents(el);
+        originalRect = range.getBoundingClientRect();
+    }
+    const zoom = newZoom * baseZoom;
+    return {
+        width: originalRect.width * zoom,
+        height: originalRect.height * zoom,
+        left: originalRect.left * zoom,
+        top: originalRect.top * zoom,
+        right: originalRect.right * zoom,
+        bottom: originalRect.bottom * zoom,
+        x: originalRect.x * zoom,
+        y: originalRect.y * zoom,
+        zoom
+    };
+}
+const isElementCovered = (el, rect, currentWindow)=>{
+    const x = rect.left + rect.width / 2;
+    const y = rect.top + rect.height / 2;
+    const topElement = currentWindow.document.elementFromPoint(x, y);
+    if (!topElement) return false;
+    if (topElement === el) return false;
+    if (null == el ? void 0 : el.contains(topElement)) return false;
+    if (null == topElement ? void 0 : topElement.contains(el)) return false;
+    const rectOfTopElement = getRect(topElement, 1, currentWindow);
+    const overlapRect = overlappedRect(rect, rectOfTopElement);
+    if (!overlapRect) return false;
+    logger(el, 'Element is covered by another element', {
+        topElement,
+        el,
+        rect,
+        x,
+        y
+    });
+    return true;
+};
+function elementRect(el, currentWindow, currentDocument, baseZoom = 1) {
+    if (!el) {
+        logger(el, 'Element is not in the DOM hierarchy');
+        return false;
+    }
+    if (!(el instanceof currentWindow.HTMLElement) && el.nodeType !== Node.TEXT_NODE && 'svg' !== el.nodeName.toLowerCase()) {
+        logger(el, 'Element is not in the DOM hierarchy');
+        return false;
+    }
+    if (el instanceof currentWindow.HTMLElement) {
+        const style = currentWindow.getComputedStyle(el);
+        if ('none' === style.display || 'hidden' === style.visibility || '0' === style.opacity && 'INPUT' !== el.tagName) {
+            logger(el, 'Element is hidden');
+            return false;
+        }
+    }
+    const rect = getRect(el, baseZoom, currentWindow);
+    if (0 === rect.width && 0 === rect.height) {
+        logger(el, 'Element has no size');
+        return false;
+    }
+    if (1 === baseZoom && isElementCovered(el, rect, currentWindow)) return false;
+    const isVisible = isElementPartiallyInViewport(rect, currentWindow, currentDocument);
+    let parent = el;
+    const parentUntilNonStatic = (currentNode)=>{
+        let parent = null == currentNode ? void 0 : currentNode.parentElement;
+        while(parent){
+            const style = currentWindow.getComputedStyle(parent);
+            if ('static' !== style.position) return parent;
+            parent = parent.parentElement;
+        }
+        return null;
+    };
+    while(parent && parent !== currentDocument.body){
+        if (!(parent instanceof currentWindow.HTMLElement)) {
+            parent = parent.parentElement;
+            continue;
+        }
+        const parentStyle = currentWindow.getComputedStyle(parent);
+        if ('hidden' === parentStyle.overflow) {
+            const parentRect = getRect(parent, 1, currentWindow);
+            const tolerance = 10;
+            if (rect.right < parentRect.left - tolerance || rect.left > parentRect.right + tolerance || rect.bottom < parentRect.top - tolerance || rect.top > parentRect.bottom + tolerance) {
+                logger(el, 'element is partially or totally hidden by an ancestor', {
+                    rect,
+                    parentRect
+                });
+                return false;
+            }
+        }
+        if ('fixed' === parentStyle.position || 'sticky' === parentStyle.position) break;
+        parent = 'absolute' === parentStyle.position ? parentUntilNonStatic(parent) : parent.parentElement;
+    }
+    return {
+        left: Math.round(rect.left),
+        top: Math.round(rect.top),
+        width: Math.round(rect.width),
+        height: Math.round(rect.height),
+        zoom: rect.zoom,
+        isVisible
+    };
+}
+function validTextNodeContent(node) {
+    if (!node) return false;
+    if (node.nodeType !== Node.ELEMENT_NODE && node.nodeType !== Node.TEXT_NODE && '#text' !== node.nodeName) return false;
+    const content = node.textContent || node.innerText;
+    if (content && !/^\s*$/.test(content)) return content.trim();
+    return false;
+}
+function getNodeAttributes(node, currentWindow) {
+    if (!node || !(node instanceof currentWindow.HTMLElement) || !node.attributes) return {};
+    const attributesList = Array.from(node.attributes).map((attr)=>{
+        if ('class' === attr.name) return [
+            attr.name,
+            `.${attr.value.split(' ').join('.')}`
+        ];
+        if (!attr.value) return [];
+        let value = attr.value;
+        if (value.startsWith('data:image')) value = 'image';
+        if (value.length > MAX_VALUE_LENGTH) value = `${value.slice(0, MAX_VALUE_LENGTH)}...`;
+        return [
+            attr.name,
+            value
+        ];
+    });
+    return Object.fromEntries(attributesList);
+}
+function midsceneGenerateHash(node, content, rect) {
+    const slicedHash = generateHashId(rect, content);
+    if (node) {
+        if (!window.midsceneNodeHashCacheList) setNodeHashCacheListOnWindow();
+        setNodeToCacheList(node, slicedHash);
+    }
+    return slicedHash;
+}
+function setNodeHashCacheListOnWindow() {
+    if ('undefined' != typeof window) window.midsceneNodeHashCacheList = [];
+}
+function setNodeToCacheList(node, id) {
+    if ('undefined' != typeof window) {
+        var _window_midsceneNodeHashCacheList;
+        if (getNodeFromCacheList(id)) return;
+        null == (_window_midsceneNodeHashCacheList = window.midsceneNodeHashCacheList) || _window_midsceneNodeHashCacheList.push({
+            node,
+            id
+        });
+    }
+}
+function getNodeFromCacheList(id) {
+    if ('undefined' != typeof window) {
+        var _window_midsceneNodeHashCacheList_find, _window_midsceneNodeHashCacheList;
+        return null == (_window_midsceneNodeHashCacheList = window.midsceneNodeHashCacheList) ? void 0 : null == (_window_midsceneNodeHashCacheList_find = _window_midsceneNodeHashCacheList.find((item)=>item.id === id)) ? void 0 : _window_midsceneNodeHashCacheList_find.node;
+    }
+    return null;
+}
+function generateId(numberId) {
+    return `${numberId}`;
+}
+function setGenerateHashOnWindow() {
+    if ('undefined' != typeof window) window.midsceneGenerateHash = midsceneGenerateHash;
+}
+function setMidsceneVisibleRectOnWindow() {
+    if ('undefined' != typeof window) window.midsceneVisibleRect = elementRect;
+}
+function setExtractTextWithPositionOnWindow() {
+    if ('undefined' != typeof window) window.extractTextWithPosition = extractTextWithPosition;
+}
+function getTopDocument() {
+    const container = document.body || document;
+    return container;
+}
+export { elementRect, generateId, getDebugMode, getNodeAttributes, getNodeFromCacheList, getPseudoElementContent, getRect, getTopDocument, hasOverflowY, isElementPartiallyInViewport, logger, midsceneGenerateHash, overlappedRect, setDebugMode, setExtractTextWithPositionOnWindow, setGenerateHashOnWindow, setMidsceneVisibleRectOnWindow, setNodeHashCacheListOnWindow, setNodeToCacheList, validTextNodeContent };

package/dist/es/extractor/web-extractor.mjs

@@ -0,0 +1,310 @@
+import { CONTAINER_MINI_HEIGHT, CONTAINER_MINI_WIDTH, NodeType } from "../constants/index.mjs";
+import { isAElement, isButtonElement, isContainerElement, isFormElement, isImgElement, isTextElement } from "./dom-util.mjs";
+import { descriptionOfTree } from "./tree.mjs";
+import { elementRect, getNodeAttributes, getPseudoElementContent, getRect, getTopDocument, logger, midsceneGenerateHash, setDebugMode } from "./util.mjs";
+let indexId = 0;
+function tagNameOfNode(node) {
+    let tagName = '';
+    if (node instanceof HTMLElement) {
+        var _node_tagName;
+        tagName = null == (_node_tagName = node.tagName) ? void 0 : _node_tagName.toLowerCase();
+    } else {
+        const parentElement = node.parentElement;
+        if (parentElement && parentElement instanceof HTMLElement) {
+            var _parentElement_tagName;
+            tagName = null == (_parentElement_tagName = parentElement.tagName) ? void 0 : _parentElement_tagName.toLowerCase();
+        }
+    }
+    return tagName ? `<${tagName}>` : '';
+}
+function collectElementInfo(node, currentWindow, currentDocument, baseZoom = 1, basePoint = {
+    left: 0,
+    top: 0
+}, isContainer = false) {
+    const rect = elementRect(node, currentWindow, currentDocument, baseZoom);
+    if (!rect) return null;
+    if (rect.width < CONTAINER_MINI_WIDTH || rect.height < CONTAINER_MINI_HEIGHT) return null;
+    if (0 !== basePoint.left || 0 !== basePoint.top) {
+        rect.left += basePoint.left;
+        rect.top += basePoint.top;
+    }
+    if (rect.height >= window.innerHeight && rect.width >= window.innerWidth) return null;
+    if (isFormElement(node)) {
+        const attributes = getNodeAttributes(node, currentWindow);
+        let valueContent = attributes.value || attributes.placeholder || node.textContent || '';
+        const nodeHashId = midsceneGenerateHash(node, valueContent, rect);
+        const tagName = node.tagName.toLowerCase();
+        if ('select' === node.tagName.toLowerCase()) {
+            const selectedOption = node.options[node.selectedIndex];
+            valueContent = (null == selectedOption ? void 0 : selectedOption.textContent) || '';
+        }
+        if (('input' === node.tagName.toLowerCase() || 'textarea' === node.tagName.toLowerCase()) && node.value) valueContent = node.value;
+        const elementInfo = {
+            id: nodeHashId,
+            nodeHashId,
+            nodeType: NodeType.FORM_ITEM,
+            indexId: indexId++,
+            attributes: {
+                ...attributes,
+                htmlTagName: `<${tagName}>`,
+                nodeType: NodeType.FORM_ITEM
+            },
+            content: valueContent.trim(),
+            rect,
+            center: [
+                Math.round(rect.left + rect.width / 2),
+                Math.round(rect.top + rect.height / 2)
+            ],
+            zoom: rect.zoom,
+            isVisible: rect.isVisible
+        };
+        return elementInfo;
+    }
+    if (isButtonElement(node)) {
+        const rect = mergeElementAndChildrenRects(node, currentWindow, currentDocument, baseZoom);
+        if (!rect) return null;
+        const attributes = getNodeAttributes(node, currentWindow);
+        const pseudo = getPseudoElementContent(node, currentWindow);
+        const content = node.innerText || pseudo.before || pseudo.after || '';
+        const nodeHashId = midsceneGenerateHash(node, content, rect);
+        const elementInfo = {
+            id: nodeHashId,
+            indexId: indexId++,
+            nodeHashId,
+            nodeType: NodeType.BUTTON,
+            attributes: {
+                ...attributes,
+                htmlTagName: tagNameOfNode(node),
+                nodeType: NodeType.BUTTON
+            },
+            content,
+            rect,
+            center: [
+                Math.round(rect.left + rect.width / 2),
+                Math.round(rect.top + rect.height / 2)
+            ],
+            zoom: rect.zoom,
+            isVisible: rect.isVisible
+        };
+        return elementInfo;
+    }
+    if (isImgElement(node)) {
+        var _node_nodeName;
+        const attributes = getNodeAttributes(node, currentWindow);
+        const nodeHashId = midsceneGenerateHash(node, '', rect);
+        const elementInfo = {
+            id: nodeHashId,
+            indexId: indexId++,
+            nodeHashId,
+            attributes: {
+                ...attributes,
+                ...(null == (_node_nodeName = node.nodeName) ? void 0 : _node_nodeName.toLowerCase()) === 'svg' ? {
+                    svgContent: 'true'
+                } : {},
+                nodeType: NodeType.IMG,
+                htmlTagName: tagNameOfNode(node)
+            },
+            nodeType: NodeType.IMG,
+            content: '',
+            rect,
+            center: [
+                Math.round(rect.left + rect.width / 2),
+                Math.round(rect.top + rect.height / 2)
+            ],
+            zoom: rect.zoom,
+            isVisible: rect.isVisible
+        };
+        return elementInfo;
+    }
+    if (isTextElement(node)) {
+        var _node_textContent;
+        const text = null == (_node_textContent = node.textContent) ? void 0 : _node_textContent.trim().replace(/\n+/g, ' ');
+        if (!text) return null;
+        const attributes = getNodeAttributes(node, currentWindow);
+        const attributeKeys = Object.keys(attributes);
+        if (!text.trim() && 0 === attributeKeys.length) return null;
+        const nodeHashId = midsceneGenerateHash(node, text, rect);
+        const elementInfo = {
+            id: nodeHashId,
+            indexId: indexId++,
+            nodeHashId,
+            nodeType: NodeType.TEXT,
+            attributes: {
+                ...attributes,
+                nodeType: NodeType.TEXT,
+                htmlTagName: tagNameOfNode(node)
+            },
+            center: [
+                Math.round(rect.left + rect.width / 2),
+                Math.round(rect.top + rect.height / 2)
+            ],
+            content: text,
+            rect,
+            zoom: rect.zoom,
+            isVisible: rect.isVisible
+        };
+        return elementInfo;
+    }
+    if (isAElement(node)) {
+        const attributes = getNodeAttributes(node, currentWindow);
+        const pseudo = getPseudoElementContent(node, currentWindow);
+        const content = node.innerText || pseudo.before || pseudo.after || '';
+        const nodeHashId = midsceneGenerateHash(node, content, rect);
+        const elementInfo = {
+            id: nodeHashId,
+            indexId: indexId++,
+            nodeHashId,
+            nodeType: NodeType.A,
+            attributes: {
+                ...attributes,
+                htmlTagName: tagNameOfNode(node),
+                nodeType: NodeType.A
+            },
+            content,
+            rect,
+            center: [
+                Math.round(rect.left + rect.width / 2),
+                Math.round(rect.top + rect.height / 2)
+            ],
+            zoom: rect.zoom,
+            isVisible: rect.isVisible
+        };
+        return elementInfo;
+    }
+    if (isContainerElement(node) || isContainer) {
+        const attributes = getNodeAttributes(node, currentWindow);
+        const nodeHashId = midsceneGenerateHash(node, '', rect);
+        const elementInfo = {
+            id: nodeHashId,
+            nodeHashId,
+            indexId: indexId++,
+            nodeType: NodeType.CONTAINER,
+            attributes: {
+                ...attributes,
+                nodeType: NodeType.CONTAINER,
+                htmlTagName: tagNameOfNode(node)
+            },
+            content: '',
+            rect,
+            center: [
+                Math.round(rect.left + rect.width / 2),
+                Math.round(rect.top + rect.height / 2)
+            ],
+            zoom: rect.zoom,
+            isVisible: rect.isVisible
+        };
+        return elementInfo;
+    }
+    return null;
+}
+function extractTextWithPosition(initNode, debugMode = false) {
+    const elementNode = extractTreeNode(initNode, debugMode);
+    const elementInfoArray = [];
+    function dfsTopChildren(node) {
+        if (node.node) elementInfoArray.push(node.node);
+        for(let i = 0; i < node.children.length; i++)dfsTopChildren(node.children[i]);
+    }
+    dfsTopChildren({
+        children: elementNode.children,
+        node: elementNode.node
+    });
+    return elementInfoArray;
+}
+function extractTreeNodeAsString(initNode, visibleOnly = false, debugMode = false) {
+    const elementNode = extractTreeNode(initNode, debugMode);
+    return descriptionOfTree(elementNode, void 0, false, visibleOnly);
+}
+function extractTreeNode(initNode, debugMode = false) {
+    setDebugMode(debugMode);
+    indexId = 0;
+    const topDocument = getTopDocument();
+    const startNode = initNode || topDocument;
+    const topChildren = [];
+    function dfs(node, currentWindow, currentDocument, baseZoom = 1, basePoint = {
+        left: 0,
+        top: 0
+    }) {
+        if (!node) return null;
+        if (node.nodeType && 10 === node.nodeType) return null;
+        const elementInfo = collectElementInfo(node, currentWindow, currentDocument, baseZoom, basePoint);
+        if (node instanceof currentWindow.HTMLIFrameElement) {
+            if (node.contentWindow && node.contentWindow) return null;
+        }
+        const nodeInfo = {
+            node: elementInfo,
+            children: []
+        };
+        if ((null == elementInfo ? void 0 : elementInfo.nodeType) === NodeType.BUTTON || (null == elementInfo ? void 0 : elementInfo.nodeType) === NodeType.IMG || (null == elementInfo ? void 0 : elementInfo.nodeType) === NodeType.TEXT || (null == elementInfo ? void 0 : elementInfo.nodeType) === NodeType.FORM_ITEM || (null == elementInfo ? void 0 : elementInfo.nodeType) === NodeType.CONTAINER) return nodeInfo;
+        const rect = getRect(node, baseZoom, currentWindow);
+        for(let i = 0; i < node.childNodes.length; i++){
+            logger('will dfs', node.childNodes[i]);
+            const childNodeInfo = dfs(node.childNodes[i], currentWindow, currentDocument, rect.zoom, basePoint);
+            if (Array.isArray(childNodeInfo)) nodeInfo.children.push(...childNodeInfo);
+            else if (childNodeInfo) nodeInfo.children.push(childNodeInfo);
+        }
+        if (null === nodeInfo.node) {
+            if (0 === nodeInfo.children.length) return null;
+            return nodeInfo.children;
+        }
+        return nodeInfo;
+    }
+    const rootNodeInfo = dfs(startNode, window, document, 1, {
+        left: 0,
+        top: 0
+    });
+    if (Array.isArray(rootNodeInfo)) topChildren.push(...rootNodeInfo);
+    else if (rootNodeInfo) topChildren.push(rootNodeInfo);
+    if (startNode === topDocument) {
+        const iframes = document.querySelectorAll('iframe');
+        for(let i = 0; i < iframes.length; i++){
+            const iframe = iframes[i];
+            if (iframe.contentDocument && iframe.contentWindow) {
+                const iframeInfo = collectElementInfo(iframe, window, document, 1);
+                if (iframeInfo) {
+                    const iframeChildren = dfs(iframe.contentDocument.body, iframe.contentWindow, iframe.contentDocument, 1, {
+                        left: iframeInfo.rect.left,
+                        top: iframeInfo.rect.top
+                    });
+                    if (Array.isArray(iframeChildren)) topChildren.push(...iframeChildren);
+                    else if (iframeChildren) topChildren.push(iframeChildren);
+                }
+            }
+        }
+    }
+    return {
+        node: null,
+        children: topChildren
+    };
+}
+function mergeElementAndChildrenRects(node, currentWindow, currentDocument, baseZoom = 1) {
+    const selfRect = elementRect(node, currentWindow, currentDocument, baseZoom);
+    if (!selfRect) return null;
+    let minLeft = selfRect.left;
+    let minTop = selfRect.top;
+    let maxRight = selfRect.left + selfRect.width;
+    let maxBottom = selfRect.top + selfRect.height;
+    function traverse(child) {
+        for(let i = 0; i < child.childNodes.length; i++){
+            const sub = child.childNodes[i];
+            if (1 === sub.nodeType) {
+                const rect = elementRect(sub, currentWindow, currentDocument, baseZoom);
+                if (rect) {
+                    minLeft = Math.min(minLeft, rect.left);
+                    minTop = Math.min(minTop, rect.top);
+                    maxRight = Math.max(maxRight, rect.left + rect.width);
+                    maxBottom = Math.max(maxBottom, rect.top + rect.height);
+                }
+                traverse(sub);
+            }
+        }
+    }
+    traverse(node);
+    return {
+        ...selfRect,
+        left: minLeft,
+        top: minTop,
+        width: maxRight - minLeft,
+        height: maxBottom - minTop
+    };
+}
+export { collectElementInfo, extractTextWithPosition, extractTreeNode, extractTreeNodeAsString, mergeElementAndChildrenRects };