@xiuchang-midscene/shared 2.0.2 → 2.0.3

package/dist/es/extractor/util.mjs.bak

@@ -1,245 +0,0 @@
-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;
-    const hasGetBoundingClientRect = el instanceof Element;
-    if (hasGetBoundingClientRect) {
-        originalRect = el.getBoundingClientRect();
-        if (el instanceof currentWindow.HTMLElement && !('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 (el?.contains(topElement)) return false;
-    if (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 = 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('.')}`
-        ];
-        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);
-}
-const NODE_CACHE_MAX_SIZE = 2000;
-function setNodeHashCacheListOnWindow() {
-    if ('undefined' != typeof window) window.midsceneNodeHashCache = new Map();
-}
-function getNodeCacheMap() {
-    if ('undefined' == typeof window) return;
-    return window.midsceneNodeHashCache;
-}
-function setNodeToCacheList(node, id) {
-    const cache = getNodeCacheMap();
-    if (!cache) return;
-    if (cache.has(id)) return;
-    if (cache.size >= NODE_CACHE_MAX_SIZE) {
-        const firstKey = cache.keys().next().value;
-        if (void 0 !== firstKey) cache.delete(firstKey);
-    }
-    cache.set(id, node);
-}
-function getNodeFromCacheList(id) {
-    return getNodeCacheMap()?.get(id);
-}
-function midsceneGenerateHash(node, content, rect) {
-    const slicedHash = generateHashId(rect, content);
-    if (node) {
-        if ('undefined' != typeof window && !getNodeCacheMap()) setNodeHashCacheListOnWindow();
-        setNodeToCacheList(node, slicedHash);
-    }
-    return slicedHash;
-}
-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.bak

@@ -1,303 +0,0 @@
-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) tagName = node.tagName?.toLowerCase();
-    else {
-        const parentElement = node.parentElement;
-        if (parentElement && parentElement instanceof HTMLElement) tagName = 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 = 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)) {
-        const attributes = getNodeAttributes(node, currentWindow);
-        const nodeHashId = midsceneGenerateHash(node, '', rect);
-        const elementInfo = {
-            id: nodeHashId,
-            indexId: indexId++,
-            nodeHashId,
-            attributes: {
-                ...attributes,
-                ...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)) {
-        const text = 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 (elementInfo?.nodeType === NodeType.BUTTON || elementInfo?.nodeType === NodeType.IMG || elementInfo?.nodeType === NodeType.TEXT || elementInfo?.nodeType === NodeType.FORM_ITEM || 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 };