runline 0.23.0 → 0.24.0

package/dist/plugins/steel/src/page/vendor/aria-snapshot/domUtils.js

@@ -0,0 +1,157 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+let globalOptions = {};
+export function setGlobalOptions(options) {
+    globalOptions = options;
+}
+export function getGlobalOptions() {
+    return globalOptions;
+}
+export function isInsideScope(scope, element) {
+    while (element) {
+        if (scope.contains(element))
+            return true;
+        element = enclosingShadowHost(element);
+    }
+    return false;
+}
+export function enclosingElement(node) {
+    if (node.nodeType === 1 /* Node.ELEMENT_NODE */)
+        return node;
+    return node.parentElement ?? undefined;
+}
+export function parentElementOrShadowHost(element) {
+    if (element.parentElement)
+        return element.parentElement;
+    if (!element.parentNode)
+        return;
+    if (element.parentNode.nodeType === 11 /* Node.DOCUMENT_FRAGMENT_NODE */ && element.parentNode.host)
+        return element.parentNode.host;
+}
+export function enclosingShadowRootOrDocument(element) {
+    let node = element;
+    while (node.parentNode)
+        node = node.parentNode;
+    if (node.nodeType === 11 /* Node.DOCUMENT_FRAGMENT_NODE */ || node.nodeType === 9 /* Node.DOCUMENT_NODE */)
+        return node;
+}
+function enclosingShadowHost(element) {
+    while (element.parentElement)
+        element = element.parentElement;
+    return parentElementOrShadowHost(element);
+}
+// Assumption: if scope is provided, element must be inside scope's subtree.
+export function closestCrossShadow(element, css, scope) {
+    while (element) {
+        const closest = element.closest(css);
+        if (scope && closest !== scope && closest?.contains(scope))
+            return;
+        if (closest)
+            return closest;
+        element = enclosingShadowHost(element);
+    }
+}
+export function getElementComputedStyle(element, pseudo) {
+    const cache = pseudo === '::before' ? cacheStyleBefore : pseudo === '::after' ? cacheStyleAfter : cacheStyle;
+    if (cache && cache.has(element))
+        return cache.get(element);
+    const style = element.ownerDocument && element.ownerDocument.defaultView ? element.ownerDocument.defaultView.getComputedStyle(element, pseudo) : undefined;
+    cache?.set(element, style);
+    return style;
+}
+export function isElementStyleVisibilityVisible(element, style) {
+    style = style ?? getElementComputedStyle(element);
+    if (!style)
+        return true;
+    // Element.checkVisibility checks for content-visibility and also looks at
+    // styles up the flat tree including user-agent ShadowRoots, such as the
+    // details element for example.
+    // All the browser implement it, but WebKit has a bug which prevents us from using it:
+    // https://bugs.webkit.org/show_bug.cgi?id=264733
+    // @ts-ignore
+    if (Element.prototype.checkVisibility && globalOptions.browserNameForWorkarounds !== 'webkit') {
+        if (!element.checkVisibility())
+            return false;
+    }
+    else {
+        // Manual workaround for WebKit that does not have checkVisibility.
+        const detailsOrSummary = element.closest('details,summary');
+        if (detailsOrSummary !== element && detailsOrSummary?.nodeName === 'DETAILS' && !detailsOrSummary.open)
+            return false;
+    }
+    if (style.visibility !== 'visible')
+        return false;
+    return true;
+}
+export function computeBox(element) {
+    // Note: this logic should be similar to waitForDisplayedAtStablePosition() to avoid surprises.
+    const style = getElementComputedStyle(element);
+    if (!style)
+        return { visible: true, inline: false };
+    const cursor = style.cursor;
+    if (style.display === 'contents') {
+        // display:contents is not rendered itself, but its child nodes are.
+        for (let child = element.firstChild; child; child = child.nextSibling) {
+            if (child.nodeType === 1 /* Node.ELEMENT_NODE */ && isElementVisible(child))
+                return { visible: true, inline: false, cursor };
+            if (child.nodeType === 3 /* Node.TEXT_NODE */ && isVisibleTextNode(child))
+                return { visible: true, inline: true, cursor };
+        }
+        return { visible: false, inline: false, cursor };
+    }
+    if (!isElementStyleVisibilityVisible(element, style))
+        return { cursor, visible: false, inline: false };
+    const rect = element.getBoundingClientRect();
+    return { cursor, visible: rect.width > 0 && rect.height > 0, inline: style.display === 'inline' };
+}
+export function isElementVisible(element) {
+    return computeBox(element).visible;
+}
+export function isVisibleTextNode(node) {
+    // https://stackoverflow.com/questions/1461059/is-there-an-equivalent-to-getboundingclientrect-for-text-nodes
+    const range = node.ownerDocument.createRange();
+    range.selectNode(node);
+    const rect = range.getBoundingClientRect();
+    return rect.width > 0 && rect.height > 0;
+}
+export function elementSafeTagName(element) {
+    const tagName = element.tagName;
+    if (typeof tagName === 'string') // Fast path.
+        return tagName.toUpperCase();
+    // Named inputs, e.g. <input name=tagName>, will be exposed as fields on the parent <form>
+    // and override its properties.
+    if (element instanceof HTMLFormElement)
+        return 'FORM';
+    // Elements from the svg namespace do not have uppercase tagName right away.
+    return element.tagName.toUpperCase();
+}
+let cacheStyle;
+let cacheStyleBefore;
+let cacheStyleAfter;
+let cachesCounter = 0;
+export function beginDOMCaches() {
+    ++cachesCounter;
+    cacheStyle ??= new Map();
+    cacheStyleBefore ??= new Map();
+    cacheStyleAfter ??= new Map();
+}
+export function endDOMCaches() {
+    if (!--cachesCounter) {
+        cacheStyle = undefined;
+        cacheStyleBefore = undefined;
+        cacheStyleAfter = undefined;
+    }
+}