ff-automationv2 2.2.35 → 2.2.36-beta.0

package/dist/utils/DomExtraction/jsForAttributeInjection.js

@@ -1,566 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.INJECT_AND_SERIALIZE_DOM_JS = exports.processCrossOriginIframes = exports.combineDom = exports.markCrossOriginElements = void 0;
-exports.getAnnotatedDOM = getAnnotatedDOM;
-exports.injectReact = injectReact;
-exports.getReactAnnotatedDOM = getReactAnnotatedDOM;
-exports.injectAngular = injectAngular;
-exports.getAngularAnnotatedDOM = getAngularAnnotatedDOM;
-exports.getAnnotatedDOMForMobile = getAnnotatedDOMForMobile;
-const xmldom_1 = require("@xmldom/xmldom");
-const frameWorkDetector_js_1 = require("../frameWorkDetector/frameWorkDetector.js");
-const crossOriginHelper_js_1 = require("../crossOrigin/crossOriginHelper.js");
-Object.defineProperty(exports, "markCrossOriginElements", { enumerable: true, get: function () { return crossOriginHelper_js_1.markCrossOriginElements; } });
-Object.defineProperty(exports, "combineDom", { enumerable: true, get: function () { return crossOriginHelper_js_1.combineDom; } });
-Object.defineProperty(exports, "processCrossOriginIframes", { enumerable: true, get: function () { return crossOriginHelper_js_1.processCrossOriginIframes; } });
-async function getAnnotatedDOM(browser) {
-    const isAngular = await frameWorkDetector_js_1.frameWorkDetector.isAngular(browser);
-    if (isAngular) {
-        return getAngularAnnotatedDOM(browser);
-    }
-    return getReactAnnotatedDOM(browser);
-}
-// ==========================================================
-// REACT INJECTION
-// ==========================================================
-async function injectReact(browser, startIndex = 0) {
-    return await browser.execute((startIndexArg) => {
-        let nodeIndex = typeof startIndexArg === "number" ? startIndexArg : 0;
-        // ==========================================================
-        // COVERAGE CHECK
-        // ==========================================================
-        function getCoverageStatus(el) {
-            if (!el || !el.getBoundingClientRect)
-                return "unknown";
-            const rect = el.getBoundingClientRect();
-            if (rect.width === 0 || rect.height === 0)
-                return "false";
-            const testPoints = [
-                [rect.left + 5, rect.top + 5],
-                [rect.right - 5, rect.top + 5],
-                [rect.left + 5, rect.bottom - 5],
-                [rect.right - 5, rect.bottom - 5],
-                [rect.left + rect.width / 2, rect.top + rect.height / 2]
-            ];
-            for (const [x, y] of testPoints) {
-                const topEl = document.elementFromPoint(x, y);
-                if (!topEl)
-                    continue;
-                if (topEl === el || el.contains(topEl))
-                    continue;
-                const style = getComputedStyle(topEl);
-                if (style.pointerEvents === "none" ||
-                    style.opacity === "0" ||
-                    style.visibility === "hidden")
-                    continue;
-                if (el.closest("label")?.contains(topEl))
-                    continue;
-                if (topEl.closest("label")?.contains(el))
-                    continue;
-                if (el.parentElement?.contains(topEl))
-                    continue;
-                const isBlocking = ["BUTTON", "A"].includes(topEl.tagName) ||
-                    topEl.onclick ||
-                    topEl.getAttribute("role") === "button";
-                if (isBlocking)
-                    return "true";
-            }
-            return "false";
-        }
-        // ==========================================================
-        // VISIBILITY CHECK
-        // ==========================================================
-        function isUsable(node) {
-            const s = getComputedStyle(node);
-            if (s.display === "none" ||
-                s.visibility === "hidden" ||
-                s.opacity === "0" ||
-                s.pointerEvents === "none")
-                return false;
-            const rect = node.getBoundingClientRect();
-            if (rect.width === 0 || rect.height === 0)
-                return false;
-            return true;
-        }
-        // ==========================================================
-        // ANNOTATION
-        // ==========================================================
-        function annotate(node) {
-            const s = getComputedStyle(node);
-            node.setAttribute("element-visibility", s.visibility || "");
-            node.setAttribute("element-pointer-events", s.pointerEvents || "");
-            node.setAttribute("element-zindex", s.zIndex || "");
-            if (!isUsable(node)) {
-                node.setAttribute("element-covered", "true");
-                return;
-            }
-            try {
-                node.setAttribute("element-covered", getCoverageStatus(node));
-            }
-            catch {
-                node.setAttribute("element-covered", "unknown");
-            }
-        }
-        // ==========================================================
-        // XPATH (Shadow + iframe safe)
-        // ==========================================================
-        function getXPath(node) {
-            if (!node || node.nodeType !== 1)
-                return "";
-            const segments = [];
-            let current = node;
-            while (current && current.nodeType === 1) {
-                const parent = current.parentNode;
-                if (parent instanceof ShadowRoot) {
-                    const host = parent.host;
-                    const siblings = Array.from(parent.children)
-                        .filter(n => n.tagName === current.tagName);
-                    const index = siblings.indexOf(current) + 1;
-                    segments.unshift("shadow/" +
-                        current.tagName.toLowerCase() +
-                        "[" + index + "]");
-                    current = host;
-                    continue;
-                }
-                let index = 1;
-                if (parent && parent.children) {
-                    const siblings = Array.from(parent.children).filter(n => n.tagName === current.tagName);
-                    index = siblings.indexOf(current) + 1;
-                }
-                segments.unshift(current.tagName.toLowerCase() +
-                    "[" + index + "]");
-                if (!parent || parent.nodeType !== 1)
-                    break;
-                current = parent;
-            }
-            let path = "/" + segments.join("/");
-            if (node.ownerDocument !== document) {
-                const frameEl = node.ownerDocument.defaultView?.frameElement;
-                if (frameEl) {
-                    let framePath = frameEl.getAttribute("ff-xpath");
-                    if (!framePath) {
-                        framePath = getXPath(frameEl);
-                    }
-                    path = framePath + path;
-                }
-            }
-            path = path.replace(/\/div\[0\]\/div\[0\]/g, "/div[1]").replace(/\/div\[0\]/g, "/div[1]");
-            return path;
-        }
-        // ==========================================================
-        // TRUE NODE WALK (TreeWalker)
-        // ==========================================================
-        function walk(root) {
-            const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, null);
-            let node = walker.currentNode;
-            while (node) {
-                if (node.nodeType === 1 &&
-                    !["META", "STYLE", "SCRIPT"]
-                        .includes(node.tagName)) {
-                    const fireId = "Fire-Flink-" + nodeIndex++;
-                    const xpath = getXPath(node);
-                    node.setAttribute("ff-inspect", fireId);
-                    node.setAttribute("ff-xpath", xpath);
-                    annotate(node);
-                }
-                if (node.shadowRoot) {
-                    walk(node.shadowRoot);
-                }
-                if (node.tagName === "IFRAME") {
-                    try {
-                        const doc = node
-                            .contentDocument;
-                        if (doc && doc.documentElement) {
-                            walk(doc.documentElement);
-                        }
-                        else {
-                            node.setAttribute("ff-cross-origin", "true");
-                        }
-                    }
-                    catch {
-                        node.setAttribute("ff-cross-origin", "true");
-                    }
-                }
-                node = walker.nextNode();
-            }
-        }
-        // Start traversal
-        walk(document.documentElement);
-        // ==========================================================
-        // SERIALIZER
-        // ==========================================================
-        function serializeNode(node) {
-            if (node.nodeType === Node.TEXT_NODE)
-                return node.textContent || "";
-            if (node.nodeType !== Node.ELEMENT_NODE)
-                return "";
-            const el = node;
-            const tag = el.tagName.toLowerCase();
-            let html = "<" + tag;
-            for (const attr of Array.from(el.attributes)) {
-                if (attr.name === "srcdoc")
-                    continue;
-                html +=
-                    " " + attr.name +
-                        "=\"" +
-                        attr.value.replace(/"/g, "&quot;") +
-                        "\"";
-            }
-            html += ">";
-            if (el.shadowRoot) {
-                html += "<!--#shadow-root-->";
-                el
-                    .shadowRoot
-                    .childNodes
-                    .forEach(child => {
-                    html += serializeNode(child);
-                });
-                html += "<!--#/shadow-root-->";
-            }
-            if (tag === "iframe" &&
-                el.getAttribute("ff-cross-origin") !== "true") {
-                try {
-                    const doc = el
-                        .contentDocument;
-                    if (doc) {
-                        html += serializeNode(doc.documentElement);
-                    }
-                }
-                catch {
-                    // inaccessible iframe
-                }
-            }
-            const voidElements = new Set([
-                "area",
-                "base",
-                "br",
-                "col",
-                "embed",
-                "hr",
-                "img",
-                "input",
-                "link",
-                "meta",
-                "param",
-                "source",
-                "track",
-                "wbr"
-            ]);
-            // Void elements cannot have children or closing tags
-            if (voidElements.has(tag)) {
-                return html;
-            }
-            // Normal children
-            el.childNodes.forEach(child => {
-                html += serializeNode(child);
-            });
-            html += "</" + tag + ">";
-            return html;
-        }
-        const crossOriginIframes = Array.from(document.querySelectorAll("iframe"))
-            .filter(iframe => iframe.getAttribute("ff-cross-origin") === "true")
-            .map(iframe => ({
-            xpath: iframe.getAttribute("ff-xpath"),
-            src: iframe.getAttribute("src"),
-            title: iframe.getAttribute("title"),
-            name: iframe.getAttribute("name")
-        }));
-        return {
-            dom: "<!DOCTYPE html>\n" +
-                serializeNode(document.documentElement),
-            crossOriginIframes: crossOriginIframes,
-            nextNodeIndex: nodeIndex
-        };
-    }, startIndex);
-}
-async function getReactAnnotatedDOM(browser, startIndex = 0) {
-    const parentResult = await injectReact(browser, startIndex);
-    const dom = await (0, crossOriginHelper_js_1.processCrossOriginIframes)(browser, parentResult, injectReact);
-    return { dom };
-}
-// ==========================================================
-// ANGULAR INJECTION
-// ==========================================================
-exports.INJECT_AND_SERIALIZE_DOM_JS = `
-return (function (startIndex) {
-  let nodeIndex = typeof startIndex === "number" ? startIndex : 0;
-function getCoverageStatus(el) {
-    if (!el || !el.getBoundingClientRect) return "unknown";
-    const s = getComputedStyle(el);
-    if (s.pointerEvents === "none") return "false";
-    const rect = el.getBoundingClientRect();
-    if (rect.width === 0 || rect.height === 0) return "false";
-    // Off-screen element — check if something is blocking the viewport
-    const isOffScreen =
-        rect.bottom < 0 ||
-        rect.right < 0 ||
-        rect.top > window.innerHeight ||
-        rect.left > window.innerWidth;
-    if (isOffScreen) {
-        const centerEl = document.elementFromPoint(
-            window.innerWidth / 2,
-            window.innerHeight / 2
-        );
-        if (centerEl && centerEl !== document.body && centerEl !== document.documentElement) {
-            // Something is at center of viewport — check if el and centerEl
-            // share the same scrollable container
-            const elScrollParent = getScrollParent(el);
-            const centerScrollParent = getScrollParent(centerEl);
-            if (elScrollParent !== centerScrollParent) return "true";
-        }
-        return "false";
-    }
-    // On-screen element — use elementFromPoint
-    const testPoints = [
-        [rect.left + 5, rect.top + 5],
-        [rect.right - 5, rect.top + 5],
-        [rect.left + 5, rect.bottom - 5],
-        [rect.right - 5, rect.bottom - 5],
-        [rect.left + rect.width / 2, rect.top + rect.height / 2]
-    ];
-    for (const [x, y] of testPoints) {
-        if (x < 0 || y < 0 || x > window.innerWidth || y > window.innerHeight) continue;
-        const topEl = document.elementFromPoint(x, y);
-        if (!topEl) continue;
-        if (topEl === el || el.contains(topEl)) continue;
-        if (topEl.contains(el)) continue; // topEl is ancestor, not a cover
-        return "true";
-    }
-    return "false";
-}
-function getScrollParent(node) {
-    if (!node || node === document.body) return document.body;
-    const s = getComputedStyle(node);
-    if (
-        s.overflow === "auto" || s.overflow === "scroll" ||
-        s.overflowY === "auto" || s.overflowY === "scroll"
-    ) return node;
-    return getScrollParent(node.parentElement);
-}
-function isUsable(node) {
-    const s = getComputedStyle(node);
-    if (s.display === "none" || s.visibility === "hidden" || s.opacity === "0") return false;
-    const rect = node.getBoundingClientRect();
-    if (rect.width === 0 || rect.height === 0) return false;
-    return true;
-}
-
-function isSelectRelated(node) {
-    return (
-        node.matches?.("select, option") ||
-        node.closest?.("select, [role='listbox'], [role='combobox']")
-    );
-}
-  function annotate(node) {
-    const s = getComputedStyle(node);
-    node.setAttribute("element-visibility", s.visibility || "");
-    node.setAttribute("element-pointer-events", s.pointerEvents || "");
-    node.setAttribute("element-zindex", s.zIndex || "");
-     if (isSelectRelated(node)) {
-        node.setAttribute("element-covered", "false");
-        return;
-    }
-
-    if (!isUsable(node)) {
-        node.setAttribute("element-covered", "true");
-        return;
-    }
-     try {
-        node.setAttribute("element-covered", getCoverageStatus(node));
-        
-    } catch {
-        node.setAttribute("element-covered", "unknown");
-    }
-  }
-  function getXPath(node) {
-    if (!node || node.nodeType !== 1) return "";
-    let segments = [];
-    let current = node;
-    while (current && current.nodeType === 1) {
-        const parent = current.parentNode;
-        if (parent instanceof ShadowRoot) {
-            const host = parent.host;
-            const siblings = Array.from(parent.children).filter(n => n.tagName === current.tagName);
-            const index = siblings.indexOf(current) + 1;
-            segments.unshift("shadow/" + current.tagName.toLowerCase() + "[" + index + "]");
-            current = host;
-            continue;
-        }
-        let index = 1;
-        if (parent && parent.children) {
-            const siblings = Array.from(parent.children).filter(n => n.tagName === current.tagName);
-            index = siblings.indexOf(current) + 1;
-        }
-        segments.unshift(current.tagName.toLowerCase() + "[" + index + "]");
-        if (!parent || parent.nodeType !== 1) break;
-        current = parent;
-    }
-    let path = "/" + segments.join("/");
-    if (node.ownerDocument !== document) {
-        const frameEl = node.ownerDocument.defaultView && node.ownerDocument.defaultView.frameElement;
-        if (frameEl) {
-            let framePath = frameEl.getAttribute("ff-xpath");
-            if (!framePath) framePath = getXPath(frameEl);
-            path = framePath + path;
-        }
-    }
-    path = path.replace(/\/div\[0\]\/div\[0\]/g, "/div[1]").replace(/\/div\[0\]/g, "/div[1]");
-    return path;
-  }
-  function walk(root) {
-     const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, null, false);
-    let node = walker.currentNode;
-    while (node) {
-        if (node.nodeType === 1 
-            && typeof node.setAttribute === 'function'
-            && !["META", "STYLE", "SCRIPT"].includes(node.tagName)) {
-            node.setAttribute("ff-inspect", "Fire-Flink-" + nodeIndex++);
-            node.setAttribute("ff-xpath", getXPath(node));
-            annotate(node);
-        }
-        if (node.shadowRoot) walk(node.shadowRoot);
-        if (node.tagName === "IFRAME") {
-            try {
-                const doc = node.contentDocument;
-                if (doc && doc.documentElement) {
-                    walk(doc.documentElement);
-                } else {
-                    node.setAttribute("ff-cross-origin", "true");
-                }
-            } catch {
-                node.setAttribute("ff-cross-origin", "true");
-            }
-        }
-        node = walker.nextNode();
-    }
-  }
-function cleanup(root) {
-    const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, null, false);
-    let node = walker.currentNode;
-    while (node) {
-     if (node.nodeType === 1 && typeof node.removeAttribute === 'function') {
-        node.removeAttribute("ff-inspect");
-        node.removeAttribute("ff-xpath");
-        node.removeAttribute("element-visibility");
-        node.removeAttribute("element-pointer-events");
-        node.removeAttribute("element-zindex");
-        node.removeAttribute("element-covered");
-        node.removeAttribute("ff-cross-origin");
-}
-        if (node.shadowRoot) cleanup(node.shadowRoot);
-        node = walker.nextNode();
-    }
-}
-cleanup(document.documentElement);
-// Force browser to settle DOM after cleanup
-void document.documentElement.offsetHeight;
-walk(document.documentElement);
-  function serializeNode(node) {
-    if (node.nodeType === Node.TEXT_NODE) return node.textContent;
-    if (node.nodeType !== Node.ELEMENT_NODE) return "";
-    const tag = node.tagName.toLowerCase();
-    let html = "<" + tag;
-    for (const attr of node.attributes) {
-        if (attr.name === "srcdoc") continue;
-        html += " " + attr.name + "=\"" + attr.value.replace(/"/g, "&quot;") + "\"";
-    }
-    html += ">";
-    if (node.shadowRoot) {
-        html += "<!--#shadow-root-->";
-        node.shadowRoot.childNodes.forEach(child => { html += serializeNode(child); });
-        html += "<!--#/shadow-root-->";
-    }
-    if (tag === "iframe" && node.getAttribute("ff-cross-origin") !== "true") {
-        try {
-            const doc = node.contentDocument;
-            if (doc) html += serializeNode(doc.documentElement);
-        } catch {}
-    }
-    node.childNodes.forEach(child => { html += serializeNode(child); });
-    html += "</" + tag + ">";
-    return html;
-  }
-
-  const crossOriginIframes =
-      Array.from(
-          document.querySelectorAll("iframe")
-      )
-      .filter(
-          iframe =>
-              iframe.getAttribute(
-                  "ff-cross-origin"
-              ) === "true"
-      )
-      .map(iframe => ({
-          xpath:
-              iframe.getAttribute(
-                  "ff-xpath"
-              ),
-
-          src:
-              iframe.getAttribute("src"),
-
-          title:
-              iframe.getAttribute("title"),
-
-          name:
-              iframe.getAttribute("name")
-      }));
-
-  return {
-      dom: "<!DOCTYPE html>\n" + serializeNode(document.documentElement),
-      crossOriginIframes: crossOriginIframes,
-      nextNodeIndex: nodeIndex
-  };
-})(arguments[0]);
-`;
-async function injectAngular(browser, startIndex = 0) {
-    const fn = new Function("startIndex", exports.INJECT_AND_SERIALIZE_DOM_JS);
-    return await browser.execute(fn, startIndex);
-}
-async function getAngularAnnotatedDOM(browser, startIndex = 0) {
-    const parentResult = await injectAngular(browser, startIndex);
-    const dom = await (0, crossOriginHelper_js_1.processCrossOriginIframes)(browser, parentResult, injectAngular);
-    return {
-        dom
-    };
-}
-async function getAnnotatedDOMForMobile(driver, existingDom) {
-    try {
-        let pageSource = "";
-        if (existingDom) {
-            pageSource = existingDom;
-        }
-        else {
-            await driver.pause(1000);
-            pageSource = await driver.getPageSource();
-        }
-        if (!pageSource) {
-            throw new Error("Unable to capture DOM");
-        }
-        const parser = new xmldom_1.DOMParser();
-        const xmlDoc = parser.parseFromString(pageSource, "text/xml");
-        const allElements = xmlDoc.getElementsByTagName("*");
-        let index = 1;
-        for (const element of Array.from(allElements)) {
-            element.setAttribute("FF-inspecter", `Fire-Flink-${index}`);
-            index++;
-        }
-        // Convert DOM back to string
-        const serializer = new xmldom_1.XMLSerializer();
-        let annotatedXML = serializer.serializeToString(xmlDoc);
-        // Preserve XML declaration if present
-        if (pageSource.trim().startsWith("<?xml") &&
-            !annotatedXML.trim().startsWith("<?xml")) {
-            const declarationEnd = pageSource.indexOf("?>");
-            const declaration = pageSource.substring(0, declarationEnd + 2).trim();
-            annotatedXML = `${declaration}\n${annotatedXML}`;
-        }
-        return {
-            dom: annotatedXML
-        };
-    }
-    catch (error) {
-        throw new Error(`Unable to annotate DOM: ${error.message}`, { cause: error });
-    }
-}

package/dist/utils/InstancesDetails/getInstancesInfo.d.ts

@@ -1,26 +0,0 @@
-export interface GoogleServiceAccount {
-    type: string;
-    project_id: string;
-    private_key_id: string;
-    private_key: string;
-    client_email: string;
-    client_id: string;
-    auth_uri: string;
-    token_uri: string;
-    auth_provider_x509_cert_url: string;
-    client_x509_cert_url: string;
-    universe_domain: string;
-}
-export interface AIInstanceInfo {
-    serviceProvider: string;
-    apiKey: string;
-    apiUrl: string;
-    visionApiKey: string;
-    model: string;
-    resource: string;
-    accountType: string;
-    enterpriseConfigFile: GoogleServiceAccount;
-    projectId: string;
-    region: string;
-}
-export declare function getAiInstanceInfo(responseObject: any): AIInstanceInfo;

package/dist/utils/InstancesDetails/getInstancesInfo.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAiInstanceInfo = getAiInstanceInfo;
-function getAiInstanceInfo(responseObject) {
-    return {
-        serviceProvider: responseObject.serviceProvider,
-        apiKey: responseObject.instanceDetails?.apiKey,
-        apiUrl: responseObject.instanceDetails?.apiUrl,
-        visionApiKey: responseObject.serviceProvider === "DefaultFireFlink" ? responseObject.visionKey : "",
-        model: responseObject.serviceProvider === "DefaultFireFlink"
-            ? "openai/gpt-oss-20b"
-            : responseObject.model,
-        resource: responseObject.resourceName ?? null,
-        accountType: responseObject.accountType ?? null,
-        enterpriseConfigFile: responseObject.enterpriseConfigFile ?? null,
-        projectId: responseObject.enterpriseConfigFile?.project_id ?? null,
-        region: responseObject.region ?? null,
-    };
-}

package/dist/utils/JsPathGenerator/generateJsPath.d.ts

@@ -1,2 +0,0 @@
-export declare function convertToCssSelector(pathFragment: string): string;
-export declare function generateJsPath(selector: string, finalSelectorOverride?: string): string;