@rpascene/shared 0.30.8

package/dist/es/extractor/dom-util.mjs

@@ -0,0 +1,92 @@
+import { NodeType } from "../constants/index.mjs";
+import { generateHashId } from "../utils.mjs";
+function isFormElement(node, currentWindow = globalThis) {
+    return node instanceof currentWindow.HTMLElement && ('input' === node.tagName.toLowerCase() || 'textarea' === node.tagName.toLowerCase() || 'select' === node.tagName.toLowerCase() || 'option' === node.tagName.toLowerCase());
+}
+function isButtonElement(node, currentWindow = globalThis) {
+    return node instanceof currentWindow.HTMLElement && 'button' === node.tagName.toLowerCase();
+}
+function isAElement(node, currentWindow = globalThis) {
+    return node instanceof currentWindow.HTMLElement && 'a' === node.tagName.toLowerCase();
+}
+function isSvgElement(node, currentWindow = globalThis) {
+    return node instanceof currentWindow.SVGElement;
+}
+function isImgElement(node, currentWindow = globalThis) {
+    if (!includeBaseElement(node) && node instanceof currentWindow.Element) {
+        const computedStyle = window.getComputedStyle(node);
+        const backgroundImage = computedStyle.getPropertyValue('background-image');
+        if ('none' !== backgroundImage) return true;
+    }
+    if (isIconfont(node)) return true;
+    return node instanceof currentWindow.HTMLElement && 'img' === node.tagName.toLowerCase() || node instanceof currentWindow.SVGElement && 'svg' === node.tagName.toLowerCase();
+}
+function isIconfont(node, currentWindow = globalThis) {
+    if (node instanceof currentWindow.Element) {
+        const computedStyle = window.getComputedStyle(node);
+        const fontFamilyValue = computedStyle.fontFamily || '';
+        return fontFamilyValue.toLowerCase().indexOf('iconfont') >= 0;
+    }
+    return false;
+}
+function isNotContainerElement(node, currentWindow = globalThis) {
+    return isTextElement(node, currentWindow) || isIconfont(node, currentWindow) || isImgElement(node, currentWindow) || isButtonElement(node, currentWindow) || isAElement(node, currentWindow) || isFormElement(node, currentWindow);
+}
+function isTextElement(node, currentWindow = globalThis) {
+    var _node_nodeName_toLowerCase, _node_nodeName;
+    if (node instanceof currentWindow.Element) {
+        var _node_childNodes;
+        if ((null == node ? void 0 : null == (_node_childNodes = node.childNodes) ? void 0 : _node_childNodes.length) === 1 && (null == node ? void 0 : node.childNodes[0]) instanceof currentWindow.Text) return true;
+    }
+    return (null == (_node_nodeName = node.nodeName) ? void 0 : null == (_node_nodeName_toLowerCase = _node_nodeName.toLowerCase) ? void 0 : _node_nodeName_toLowerCase.call(_node_nodeName)) === '#text' && !isIconfont(node);
+}
+function isContainerElement(node, currentWindow = globalThis) {
+    if (!(node instanceof currentWindow.HTMLElement)) return false;
+    if (includeBaseElement(node, currentWindow)) return false;
+    const computedStyle = window.getComputedStyle(node);
+    const backgroundColor = computedStyle.getPropertyValue('background-color');
+    if (backgroundColor) return true;
+    return false;
+}
+function includeBaseElement(node, currentWindow = globalThis) {
+    if (!(node instanceof currentWindow.HTMLElement)) return false;
+    if (node.innerText) return true;
+    const includeList = [
+        'svg',
+        'button',
+        'input',
+        'textarea',
+        'select',
+        'option',
+        'img',
+        'a'
+    ];
+    for (const tagName of includeList){
+        const element = node.querySelectorAll(tagName);
+        if (element.length > 0) return true;
+    }
+    return false;
+}
+function generateElementByPosition(position) {
+    const rect = {
+        left: Math.max(position.x - 4, 0),
+        top: Math.max(position.y - 4, 0),
+        width: 8,
+        height: 8
+    };
+    const id = generateHashId(rect);
+    const element = {
+        id,
+        attributes: {
+            nodeType: NodeType.POSITION
+        },
+        rect,
+        content: '',
+        center: [
+            position.x,
+            position.y
+        ]
+    };
+    return element;
+}
+export { generateElementByPosition, isAElement, isButtonElement, isContainerElement, isFormElement, isImgElement, isNotContainerElement, isSvgElement, isTextElement };

package/dist/es/extractor/index.mjs

@@ -0,0 +1,7 @@
+import { descriptionOfTree, traverseTree, treeToList, trimAttributes, truncateText } from "./tree.mjs";
+import { extractTextWithPosition, extractTreeNode, extractTreeNodeAsString } from "./web-extractor.mjs";
+import { getNodeFromCacheList, setNodeHashCacheListOnWindow } from "./util.mjs";
+import { getElementInfoByXpath, getElementXpath, getNodeInfoByXpath, getXpathsById, getXpathsByPoint } from "./locator.mjs";
+import { generateElementByPosition, isNotContainerElement } from "./dom-util.mjs";
+export * from "./customLocator.mjs";
+export { descriptionOfTree, generateElementByPosition, getElementInfoByXpath, getElementXpath, getNodeFromCacheList, getNodeInfoByXpath, getXpathsById, getXpathsByPoint, isNotContainerElement, setNodeHashCacheListOnWindow, traverseTree, treeToList, trimAttributes, truncateText, extractTreeNode as webExtractNodeTree, extractTreeNodeAsString as webExtractNodeTreeAsString, extractTextWithPosition as webExtractTextWithPosition };

package/dist/es/extractor/locator.mjs

@@ -0,0 +1,95 @@
+import { isSvgElement } from "./dom-util.mjs";
+import { getNodeFromCacheList, getRect, isElementPartiallyInViewport } from "./util.mjs";
+import { collectElementInfo } from "./web-extractor.mjs";
+const getElementXpathIndex = (element)=>{
+    let index = 1;
+    let prev = element.previousElementSibling;
+    while(prev){
+        if (prev.nodeName.toLowerCase() === element.nodeName.toLowerCase()) index++;
+        prev = prev.previousElementSibling;
+    }
+    return index;
+};
+const normalizeXpathText = (text)=>{
+    if ('string' != typeof text) return '';
+    return text.replace(/\s+/g, ' ').trim();
+};
+const buildCurrentElementXpath = (element, isOrderSensitive, isLeafElement)=>{
+    var _element_textContent;
+    const parentPath = element.parentNode ? getElementXpath(element.parentNode, isOrderSensitive) : '';
+    const prefix = parentPath ? `${parentPath}/` : '/';
+    const tagName = element.nodeName.toLowerCase();
+    const textContent = null == (_element_textContent = element.textContent) ? void 0 : _element_textContent.trim();
+    if (isOrderSensitive) {
+        const index = getElementXpathIndex(element);
+        return `${prefix}${tagName}[${index}]`;
+    }
+    if (isLeafElement && textContent) return `${prefix}${tagName}[normalize-space()="${normalizeXpathText(textContent)}"]`;
+    const index = getElementXpathIndex(element);
+    return `${prefix}${tagName}[${index}]`;
+};
+const getElementXpath = (element, isOrderSensitive = false, isLeafElement = false)=>{
+    if (element.nodeType === Node.TEXT_NODE) {
+        const parentNode = element.parentNode;
+        if (parentNode && parentNode.nodeType === Node.ELEMENT_NODE) {
+            var _element_textContent;
+            const parentXPath = getElementXpath(parentNode, isOrderSensitive, true);
+            const textContent = null == (_element_textContent = element.textContent) ? void 0 : _element_textContent.trim();
+            if (textContent) return `${parentXPath}/text()[normalize-space()="${normalizeXpathText(textContent)}"]`;
+            return `${parentXPath}/text()`;
+        }
+        return '';
+    }
+    if (element.nodeType !== Node.ELEMENT_NODE) return '';
+    const el = element;
+    if (el === document.documentElement) return '/html';
+    if (el === document.body) return '/html/body';
+    if (isSvgElement(el)) {
+        let parent = el.parentNode;
+        while(parent && parent.nodeType === Node.ELEMENT_NODE){
+            if (!isSvgElement(parent)) return getElementXpath(parent, isOrderSensitive, isLeafElement);
+            parent = parent.parentNode;
+        }
+        return getElementXpath(el.parentNode, isOrderSensitive, isLeafElement);
+    }
+    return buildCurrentElementXpath(el, isOrderSensitive, isLeafElement);
+};
+function getXpathsById(id) {
+    const node = getNodeFromCacheList(id);
+    if (!node) return null;
+    const fullXPath = getElementXpath(node, false, true);
+    return [
+        fullXPath
+    ];
+}
+function getXpathsByPoint(point, isOrderSensitive) {
+    const element = document.elementFromPoint(point.left, point.top);
+    if (!element) return null;
+    const fullXPath = getElementXpath(element, isOrderSensitive, true);
+    return [
+        fullXPath
+    ];
+}
+function getNodeInfoByXpath(xpath) {
+    const xpathResult = document.evaluate(xpath, document, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
+    if (1 !== xpathResult.snapshotLength) return null;
+    const node = xpathResult.snapshotItem(0);
+    return node;
+}
+function getElementInfoByXpath(xpath) {
+    const node = getNodeInfoByXpath(xpath);
+    if (!node) return null;
+    if (node instanceof HTMLElement) {
+        const rect = getRect(node, 1, window);
+        const isVisible = isElementPartiallyInViewport(rect, window, document, 1);
+        if (!isVisible) node.scrollIntoView({
+            behavior: 'instant',
+            block: 'center'
+        });
+    }
+    return collectElementInfo(node, window, document, 1, {
+        left: 0,
+        top: 0
+    }, true);
+}
+export { getElementInfoByXpath, getElementXpath, getNodeInfoByXpath, getXpathsById, getXpathsByPoint };

package/dist/es/extractor/tree.mjs

@@ -0,0 +1,81 @@
+function truncateText(text, maxLength = 150) {
+    if (void 0 === text) return '';
+    if ('object' == typeof text) text = JSON.stringify(text);
+    if ('number' == typeof text) return text.toString();
+    if ('string' == typeof text && text.length > maxLength) return `${text.slice(0, maxLength)}...`;
+    if ('string' == typeof text) return text.trim();
+    return '';
+}
+function trimAttributes(attributes, truncateTextLength) {
+    const tailorAttributes = Object.keys(attributes).reduce((res, currentKey)=>{
+        const attributeVal = attributes[currentKey];
+        if ('style' === currentKey || 'htmlTagName' === currentKey || 'nodeType' === currentKey) return res;
+        res[currentKey] = truncateText(attributeVal, truncateTextLength);
+        return res;
+    }, {});
+    return tailorAttributes;
+}
+const nodeSizeThreshold = 4;
+function descriptionOfTree(tree, truncateTextLength, filterNonTextContent = false, visibleOnly = true) {
+    const attributesString = (kv)=>Object.entries(kv).map(([key, value])=>`${key}="${truncateText(value, truncateTextLength)}"`).join(' ');
+    function buildContentTree(node, indent = 0, visibleOnly = true) {
+        let before = '';
+        let contentWithIndent = '';
+        let after = '';
+        let emptyNode = true;
+        const indentStr = '  '.repeat(indent);
+        let children = '';
+        for(let i = 0; i < (node.children || []).length; i++){
+            const childContent = buildContentTree(node.children[i], indent + 1, visibleOnly);
+            if (childContent) children += `\n${childContent}`;
+        }
+        if (node.node && node.node.rect.width > nodeSizeThreshold && node.node.rect.height > nodeSizeThreshold && (!filterNonTextContent || filterNonTextContent && node.node.content) && (!visibleOnly || visibleOnly && node.node.isVisible)) {
+            var _node_node_attributes;
+            emptyNode = false;
+            let nodeTypeString;
+            nodeTypeString = (null == (_node_node_attributes = node.node.attributes) ? void 0 : _node_node_attributes.htmlTagName) ? node.node.attributes.htmlTagName.replace(/[<>]/g, '') : node.node.attributes.nodeType.replace(/\sNode$/, '').toLowerCase();
+            const markerId = node.node.indexId;
+            const markerIdString = markerId ? `markerId="${markerId}"` : '';
+            const rectAttribute = node.node.rect ? {
+                left: node.node.rect.left,
+                top: node.node.rect.top,
+                width: node.node.rect.width,
+                height: node.node.rect.height
+            } : {};
+            before = `<${nodeTypeString} id="${node.node.id}" ${markerIdString} ${attributesString(trimAttributes(node.node.attributes || {}, truncateTextLength))} ${attributesString(rectAttribute)}>`;
+            const content = truncateText(node.node.content, truncateTextLength);
+            contentWithIndent = content ? `\n${indentStr}  ${content}` : '';
+            after = `</${nodeTypeString}>`;
+        } else if (!filterNonTextContent) {
+            if (!children.trim().startsWith('<>')) {
+                before = '<>';
+                contentWithIndent = '';
+                after = '</>';
+            }
+        }
+        if (emptyNode && !children.trim()) return '';
+        const result = `${indentStr}${before}${contentWithIndent}${children}\n${indentStr}${after}`;
+        if (result.trim()) return result;
+        return '';
+    }
+    const result = buildContentTree(tree, 0, visibleOnly);
+    return result.replace(/^\s*\n/gm, '');
+}
+function treeToList(tree) {
+    const result = [];
+    function dfs(node) {
+        if (node.node) result.push(node.node);
+        for (const child of node.children)dfs(child);
+    }
+    dfs(tree);
+    return result;
+}
+function traverseTree(tree, onNode) {
+    function dfs(node) {
+        if (node.node) node.node = onNode(node.node);
+        for (const child of node.children)dfs(child);
+    }
+    dfs(tree);
+    return tree;
+}
+export { descriptionOfTree, traverseTree, treeToList, trimAttributes, truncateText };

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 rpasceneGenerateHash(node, content, rect) {
+    const slicedHash = generateHashId(rect, content);
+    if (node) {
+        if (!window.rpasceneNodeHashCacheList) setNodeHashCacheListOnWindow();
+        setNodeToCacheList(node, slicedHash);
+    }
+    return slicedHash;
+}
+function setNodeHashCacheListOnWindow() {
+    if ('undefined' != typeof window) window.rpasceneNodeHashCacheList = [];
+}
+function setNodeToCacheList(node, id) {
+    if ('undefined' != typeof window) {
+        var _window_rpasceneNodeHashCacheList;
+        if (getNodeFromCacheList(id)) return;
+        null == (_window_rpasceneNodeHashCacheList = window.rpasceneNodeHashCacheList) || _window_rpasceneNodeHashCacheList.push({
+            node,
+            id
+        });
+    }
+}
+function getNodeFromCacheList(id) {
+    if ('undefined' != typeof window) {
+        var _window_rpasceneNodeHashCacheList_find, _window_rpasceneNodeHashCacheList;
+        return null == (_window_rpasceneNodeHashCacheList = window.rpasceneNodeHashCacheList) ? void 0 : null == (_window_rpasceneNodeHashCacheList_find = _window_rpasceneNodeHashCacheList.find((item)=>item.id === id)) ? void 0 : _window_rpasceneNodeHashCacheList_find.node;
+    }
+    return null;
+}
+function generateId(numberId) {
+    return `${numberId}`;
+}
+function setGenerateHashOnWindow() {
+    if ('undefined' != typeof window) window.rpasceneGenerateHash = rpasceneGenerateHash;
+}
+function setRpasceneVisibleRectOnWindow() {
+    if ('undefined' != typeof window) window.rpasceneVisibleRect = 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, overlappedRect, rpasceneGenerateHash, setDebugMode, setExtractTextWithPositionOnWindow, setGenerateHashOnWindow, setNodeHashCacheListOnWindow, setNodeToCacheList, setRpasceneVisibleRectOnWindow, validTextNodeContent };