ff-automationv2 2.2.36-beta.0 → 2.2.36-beta.2

package/dist/domAnalysis/searchBest.js

@@ -0,0 +1,315 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DomSearcher = void 0;
+const fastest_levenshtein_1 = require("fastest-levenshtein");
+const fast_fuzzy_1 = require("fast-fuzzy");
+class DomSearcher {
+    search(nodes, keywords, topN = 20, threshold = 40) {
+        if (typeof keywords === "string") {
+            keywords = keywords.replace(/[\[\]]/g, "");
+            keywords = keywords.split(",").map(k => k.trim());
+        }
+        keywords = keywords.map(k => (typeof k === "string" ? k : String(k))
+            .replace(/[^a-zA-Z0-9\s]/g, " ")
+            .trim()
+            .toLowerCase()
+            .replace(/\s+/g, ""));
+        const ffNumber = (val) => {
+            if (!val)
+                return 0;
+            const m = val.match(/(\d+)$/);
+            return m ? parseInt(m[1]) : 0;
+        };
+        const isChild = (p, c) => c.startsWith(p + "/");
+        const isSibling = (x1, x2) => x1.substring(0, x1.lastIndexOf("/")) ===
+            x2.substring(0, x2.lastIndexOf("/"));
+        const addWithContext = (idx, collected) => {
+            const total = nodes.length;
+            for (const i of [idx - 1, idx, idx + 1]) {
+                if (i >= 0 && i < total) {
+                    if (nodes[i].node["FF-inspecter"]) {
+                        collected.add(i);
+                    }
+                }
+            }
+            const current = nodes[idx].node;
+            const cx = current["ff-xpath"];
+            if (!cx)
+                return;
+            for (let j = 0; j < total; j++) {
+                const nx = nodes[j].node["ff-xpath"];
+                if (nx && isChild(cx, nx)) {
+                    if (nodes[j].node["FF-inspecter"]) {
+                        collected.add(j);
+                    }
+                    break;
+                }
+            }
+            for (let j = 0; j < total; j++) {
+                const nx = nodes[j].node["ff-xpath"];
+                if (nx && isSibling(cx, nx) && j !== idx) {
+                    if (nodes[j].node["FF-inspecter"]) {
+                        collected.add(j);
+                    }
+                    break;
+                }
+            }
+        };
+        const results = {};
+        const tempResults = {};
+        let hasAnyMatch = false;
+        for (const kw of keywords) {
+            const exact = [];
+            const strong = [];
+            const tagMatches = [];
+            for (let i = 0; i < nodes.length; i++) {
+                const node = nodes[i].node;
+                const searchText = (node.search || "").toLowerCase();
+                const tagName = (node.tag || "").toLowerCase();
+                if (searchText === kw) {
+                    exact.push(i);
+                }
+                else if (searchText.includes(kw)) {
+                    strong.push(i);
+                }
+                else if (kw === tagName || tagName.includes(kw)) {
+                    tagMatches.push(i);
+                }
+            }
+            const collected = new Set();
+            for (const idx of exact) {
+                addWithContext(idx, collected);
+                if (collected.size >= topN * 4)
+                    break;
+            }
+            for (const idx of strong) {
+                addWithContext(idx, collected);
+                if (collected.size >= topN * 4)
+                    break;
+            }
+            for (const idx of tagMatches) {
+                addWithContext(idx, collected);
+                if (collected.size >= topN * 4)
+                    break;
+            }
+            if (collected.size > 0) {
+                hasAnyMatch = true;
+            }
+            tempResults[kw] = Array.from(collected);
+        }
+        if (!hasAnyMatch) {
+            for (const kw of keywords) {
+                const fuzzyList = [];
+                const tokens1 = Array.from(new Set(kw.toLowerCase().split(/\s+/)));
+                for (let i = 0; i < nodes.length; i++) {
+                    const node = nodes[i].node;
+                    const searchText = (node.search || "").toLowerCase();
+                    const tokens2 = searchText.split(/\s+/);
+                    // For each kw token, find best matching token in searchText
+                    const tokenScores = tokens1.map(t1 => {
+                        let best = 0;
+                        for (const t2 of tokens2) {
+                            if (t1 === t2) {
+                                best = 100;
+                                break;
+                            }
+                            const sim = (1 - (0, fastest_levenshtein_1.distance)(t1, t2) / Math.max(t1.length, t2.length))
+                                * 100;
+                            if (sim > best)
+                                best = sim;
+                        }
+                        return best;
+                    });
+                    const allMatched = tokenScores.every(s => s >= 50);
+                    if (!allMatched)
+                        continue;
+                    const score = tokenScores.reduce((a, b) => a + b, 0) / tokenScores.length;
+                    if (score >= threshold) {
+                        fuzzyList.push([score, i]);
+                    }
+                }
+                const collected = new Set();
+                fuzzyList
+                    .sort((a, b) => b[0] - a[0])
+                    .forEach(([_, idx]) => {
+                    if (collected.size < topN * 4) {
+                        addWithContext(idx, collected);
+                    }
+                });
+                results[kw] = Array.from(collected).map(i => nodes[i].node);
+            }
+        }
+        else {
+            for (const kw of keywords) {
+                results[kw] = tempResults[kw].map(i => nodes[i].node);
+            }
+        }
+        const seen = new Set();
+        const unique = Object.values(results)
+            .flat()
+            .filter(node => {
+            const ff = node["FF-inspecter"];
+            if (!ff || seen.has(ff))
+                return false;
+            seen.add(ff);
+            return true;
+        });
+        unique.sort((a, b) => ffNumber(a["FF-inspecter"]) - ffNumber(b["FF-inspecter"]));
+        return unique;
+    }
+    searchBestAndroid(nodes, keywords, topN = 5, threshold = 40) {
+        if (typeof keywords === "string") {
+            keywords = keywords.replace(/[\[\]]/g, "")
+                .split(",")
+                .map(k => k.trim());
+        }
+        keywords = keywords.map(k => String(k).toLowerCase().replace(/\s+/g, ""));
+        const slim = (n) => {
+            const allowed = [
+                "tag",
+                "FF-inspecter",
+                "text",
+                "content-desc",
+                "resource-id",
+                "class",
+                "pane-title",
+                "hint",
+                "clickable",
+                "editable",
+                "enabled"
+            ];
+            const result = {};
+            for (const key of allowed) {
+                if (key in n)
+                    result[key] = n[key];
+            }
+            return result;
+        };
+        const indexMap = {};
+        nodes.forEach((item, i) => {
+            const ff = item.node["FF-inspecter"];
+            if (ff)
+                indexMap[ff] = i;
+        });
+        const results = {};
+        const tempResults = {};
+        let hasAnyMatch = false;
+        for (const kw of keywords) {
+            const exact = [];
+            const strong = [];
+            for (const item of nodes) {
+                const node = item.node;
+                const text = (item.search || "").toLowerCase();
+                const hint = (node["hint"] || "").toLowerCase();
+                // EXACT MATCH
+                if (text === kw || hint === kw) {
+                    exact.push(node);
+                }
+                // STRONG MATCH
+                else if (text.includes(kw) || hint.includes(kw)) {
+                    strong.push(node);
+                }
+            }
+            let selected = [];
+            if (exact.length) {
+                selected = exact.slice(0, topN);
+            }
+            else if (strong.length) {
+                selected = strong.slice(0, topN);
+            }
+            if (selected.length > 0) {
+                hasAnyMatch = true;
+            }
+            tempResults[kw] = selected;
+        }
+        if (!hasAnyMatch) {
+            for (const kw of keywords) {
+                const fuzzyMatches = [];
+                for (const item of nodes) {
+                    const node = item.node;
+                    const text = (item.search || "").toLowerCase();
+                    const score = (0, fast_fuzzy_1.fuzzy)(kw, text) * 100;
+                    if (score >= threshold) {
+                        fuzzyMatches.push([score, node]);
+                    }
+                }
+                fuzzyMatches.sort((a, b) => b[0] - a[0]);
+                const selected = fuzzyMatches
+                    .slice(0, topN)
+                    .map(f => f[1]);
+                results[kw] = selected.map(slim);
+            }
+        }
+        else {
+            for (const kw of keywords) {
+                results[kw] = tempResults[kw].map(slim);
+            }
+        }
+        return {
+            results,
+            indexMap
+        };
+    }
+    searchBestIos(nodes, keywords, topN = 5, threshold = 40) {
+        if (typeof keywords === "string") {
+            keywords = keywords.replace(/[\[\]]/g, "")
+                .split(",")
+                .map(k => k.trim());
+        }
+        keywords = keywords.map(k => k.toLowerCase().replace(/\s+/g, ""));
+        const slim = (n) => {
+            const allowed = [
+                "tag", "FF-inspecter", "value", "name",
+                "label", "class", "pane-title",
+                "accessible", "editable", "enabled", "traits"
+            ];
+            const res = {};
+            for (const k of allowed)
+                if (k in n)
+                    res[k] = n[k];
+            return res;
+        };
+        const indexMap = {};
+        nodes.forEach((item, i) => {
+            const ff = item.node?.["FF-inspecter"];
+            if (ff)
+                indexMap[ff] = i;
+        });
+        const results = {};
+        for (const kw of keywords) {
+            const exact = [];
+            const strong = [];
+            const fuzzyMatches = [];
+            for (const item of nodes) {
+                const node = item.node || {};
+                const text = (item.search || "").toLowerCase();
+                const value = (node["value"] || "").toLowerCase();
+                const name = (node["name"] || "").toLowerCase();
+                const label = (node["label"] || "").toLowerCase();
+                if (text === kw || value === kw || name === kw || label === kw) {
+                    exact.push(node);
+                    continue;
+                }
+                if (text.includes(kw) || value.includes(kw) || name.includes(kw) || label.includes(kw)) {
+                    strong.push(node);
+                    continue;
+                }
+                const score = (0, fast_fuzzy_1.fuzzy)(kw, text) * 100;
+                if (score >= threshold)
+                    fuzzyMatches.push([score, node]);
+            }
+            let selected;
+            if (exact.length)
+                selected = exact.slice(0, topN);
+            else if (strong.length)
+                selected = strong.slice(0, topN);
+            else {
+                fuzzyMatches.sort((a, b) => b[0] - a[0]);
+                selected = fuzzyMatches.slice(0, topN).map(f => f[1]);
+            }
+            results[kw] = selected.map(slim);
+        }
+        return { results, indexMap };
+    }
+}
+exports.DomSearcher = DomSearcher;

package/dist/domAnalysis/simplifyAndFlatten.d.ts

@@ -0,0 +1,6 @@
+import { FlatNode, SimplifiedDomResult, SimplifiedDomResultIos } from "../core/interfaces/simplifyAndFlattenInterface.js";
+export declare class DomSimplifier {
+    simplify(rawDom: string): FlatNode[];
+    simplifyAndroidDom(rawDom: string, stepAction: string, step: string): SimplifiedDomResult;
+    simplifyIosDom(rawDom: string, driver: WebdriverIO.Browser): Promise<SimplifiedDomResultIos>;
+}

package/dist/domAnalysis/simplifyAndFlatten.js

@@ -0,0 +1,318 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DomSimplifier = void 0;
+const cheerio = __importStar(require("cheerio"));
+const xmldom_1 = require("@xmldom/xmldom");
+class DomSimplifier {
+    simplify(rawDom) {
+        const $ = cheerio.load(rawDom, { xml: true });
+        const flatNodes = [];
+        $("*").each((_, node) => {
+            if (node.type !== "tag")
+                return;
+            const el = node;
+            const tag = el.tagName.toLowerCase();
+            if (!tag || tag === "meta")
+                return;
+            const attribs = el.attribs ?? {};
+            if (tag !== "select" && tag !== "option" && tag !== "mat-select" && tag !== "mat-option") {
+                if ((attribs["element-visibility"] === "hidden" ||
+                    attribs["element-covered"] === "true")) {
+                    return;
+                }
+            }
+            const simplified = { tag };
+            if (attribs["ff-inspect"])
+                simplified["FF-inspecter"] = attribs["ff-inspect"];
+            if (attribs["ff-xpath"])
+                simplified["ff-xpath"] = attribs["ff-xpath"];
+            // -----------------
+            // Direct text only
+            // -----------------
+            let directText = "";
+            $(el).contents().each((_, child) => {
+                if (child.type === "text") {
+                    const txt = child.data?.trim();
+                    if (txt)
+                        directText += txt;
+                }
+            });
+            const cleanText = directText.trim();
+            if (cleanText)
+                simplified["text"] = cleanText.slice(0, 200);
+            // -----------------
+            // Copy attributes
+            // -----------------
+            const EXCLUDED_ATTRS = new Set([
+                "style", "onclick", "onchange", "href",
+                "oninput", "onmouseover", "onfocus",
+                "ff-inspect", "element-visibility",
+                "element-pointer-events", "element-zindex", "element-covered", "width", "height"
+            ]);
+            Object.entries(attribs).forEach(([key, val]) => {
+                if (!EXCLUDED_ATTRS.has(key.toLowerCase())) {
+                    simplified[key] = val;
+                }
+            });
+            // -----------------
+            // Build search
+            // -----------------
+            const parts = new Set();
+            if (cleanText && cleanText.length <= 70) {
+                // parts.add(cleanText.toLowerCase().replace(/\s+/g, ""));
+                parts.add(cleanText
+                    .toLowerCase()
+                    .replace(/[^a-zA-Z0-9\s]/g, " ")
+                    .replace(/\s+/g, " "));
+            }
+            const SEARCH_EXCLUDED = new Set([
+                "class", "style", "onclick", "onchange",
+                "oninput", "onmouseover", "onfocus",
+                "tabindex", "role", "href"
+            ]);
+            Object.entries(simplified).forEach(([key, value]) => {
+                if (!value)
+                    return;
+                if (SEARCH_EXCLUDED.has(key.toLowerCase()))
+                    return;
+                if (["tag", "FF-inspecter", "search", "ff-xpath"].includes(key))
+                    return;
+                const v = String(value)
+                    .replace(/[^a-zA-Z0-9\s]/g, " ")
+                    .trim()
+                    .toLowerCase();
+                if (v)
+                    parts.add(v.replace(/\s+/g, ""));
+            });
+            simplified["search"] = Array.from(parts).join(" ").trim();
+            flatNodes.push({
+                node: simplified,
+                search: simplified["search"]
+            });
+        });
+        return flatNodes;
+    }
+    simplifyAndroidDom(rawDom, stepAction, step) {
+        const parser = new xmldom_1.DOMParser();
+        const xmlDoc = parser.parseFromString(rawDom, "text/xml");
+        const root = xmlDoc.documentElement;
+        const flatNodes = [];
+        // parentMap: child → parent
+        const parentMap = new Map();
+        function xmlToTree(elem) {
+            const children = [];
+            for (let i = 0; i < elem.childNodes.length; i++) {
+                const child = elem.childNodes[i];
+                if (child.nodeType === 1) {
+                    const childElement = child;
+                    // store parent relationship
+                    parentMap.set(childElement, elem);
+                    children.push(xmlToTree(childElement));
+                }
+            }
+            const attributes = {};
+            for (let i = 0; i < elem.attributes.length; i++) {
+                const attr = elem.attributes[i];
+                attributes[attr.name] = attr.value;
+            }
+            return {
+                tag: elem.tagName,
+                attributes,
+                text: (elem.textContent || "").trim(),
+                _element: elem,
+                children
+            };
+        }
+        const xmlTree = xmlToTree(root);
+        function simplifyAndFlatten(node) {
+            const simplified = {};
+            const attrs = node.attributes || {};
+            simplified["tag"] = node.tag;
+            const skipNode = attrs["enabled"] === "false";
+            if (attrs["FF-inspecter"]) {
+                simplified["FF-inspecter"] = attrs["FF-inspecter"];
+            }
+            simplified["text"] = node.text || attrs["text"] || "";
+            const importantAttrs = [
+                "resource-id",
+                "content-desc",
+                "pane-title",
+                "clickable",
+                "editable",
+                "enabled",
+                "class",
+                "hint"
+            ];
+            for (const attr of importantAttrs) {
+                if (attrs[attr]) {
+                    simplified[attr] = attrs[attr];
+                }
+            }
+            const searchParts = [];
+            if (simplified.text && simplified.text.trim()) {
+                searchParts.push(simplified.text.replace(/\s+/g, ""));
+            }
+            for (const key of [
+                "content-desc",
+                "pane-title",
+                "resource-id",
+                "hint"
+            ]) {
+                const val = simplified[key];
+                if (val && typeof val === "string" && val.trim()) {
+                    searchParts.push(val.replace(/\s+/g, ""));
+                }
+            }
+            simplified["search"] = searchParts.join(" ").trim().toLowerCase();
+            if (stepAction === "verify" && (step.toLowerCase().includes("disable") || step.toLowerCase().includes("disabled"))) {
+                flatNodes.push({
+                    node: simplified,
+                    search: simplified["search"],
+                    element: node._element
+                });
+            }
+            else {
+                if (!skipNode) {
+                    flatNodes.push({
+                        node: simplified,
+                        search: simplified["search"],
+                        element: node._element
+                    });
+                }
+            }
+            for (const child of node.children || []) {
+                simplifyAndFlatten(child);
+            }
+        }
+        simplifyAndFlatten(xmlTree);
+        return {
+            flatNodes, parentMap
+        };
+    }
+    async simplifyIosDom(rawDom, driver) {
+        const { width: screenWidth, height: screenHeight } = await driver.getWindowSize();
+        const parser = new xmldom_1.DOMParser();
+        const xmlDoc = parser.parseFromString(rawDom, "text/xml");
+        const root = xmlDoc.documentElement;
+        const flatNodes = [];
+        const runtimeElements = {};
+        const parentMap = new Map();
+        function xmlToTree(elem) {
+            const children = [];
+            for (let i = 0; i < elem.childNodes.length; i++) {
+                const child = elem.childNodes[i];
+                if (child.nodeType === 1) {
+                    const childElement = child;
+                    // store parent relationship
+                    parentMap.set(childElement, elem);
+                    children.push(xmlToTree(childElement));
+                }
+            }
+            const attributes = {};
+            for (let i = 0; i < elem.attributes.length; i++) {
+                const attr = elem.attributes[i];
+                attributes[attr.name] = attr.value;
+            }
+            return {
+                tag: elem.tagName,
+                attributes,
+                text: (elem.textContent || "").trim(),
+                _element: elem,
+                children
+            };
+        }
+        const xmlTree = xmlToTree(root);
+        function isOnScreen(x, y, w, h) {
+            return ((x + w) > 0 && x < screenWidth &&
+                (y + h) > 0 && y < screenHeight);
+        }
+        function simplifyAndFlatten(node) {
+            const attrs = node.attributes || {};
+            const x = parseInt(attrs["x"] || "0");
+            const y = parseInt(attrs["y"] || "0");
+            const w = parseInt(attrs["width"] || "0");
+            const h = parseInt(attrs["height"] || "0");
+            const skipNode = attrs["enabled"] === "false" ||
+                attrs["traits"] === "PlaysSound, KeyboardKey" ||
+                !isOnScreen(x, y, w, h);
+            const simplified = {};
+            simplified["tag"] = node.tag;
+            simplified["class"] = node.tag;
+            if (attrs["FF-inspecter"]) {
+                simplified["FF-inspecter"] = attrs["FF-inspecter"];
+            }
+            simplified["value"] = attrs["value"] || "";
+            const importantAttrs = [
+                "label", "name", "class", "accessible", "enabled", "traits"
+            ];
+            for (const attr of importantAttrs) {
+                if (attrs[attr]) {
+                    simplified[attr] = attrs[attr];
+                }
+            }
+            const searchParts = [];
+            if (simplified["value"]?.trim()) {
+                searchParts.push(simplified["value"].replace(/\s+/g, ""));
+            }
+            for (const key of ["name", "label"]) {
+                const val = simplified[key];
+                if (val?.trim()) {
+                    searchParts.push(val.replace(/\s+/g, ""));
+                }
+            }
+            simplified["search"] = searchParts.join(" ").toLowerCase();
+            if (!skipNode) {
+                const id = flatNodes.length;
+                flatNodes.push({
+                    node: simplified,
+                    search: simplified["search"],
+                    element: node._element
+                });
+                runtimeElements[id] = node._element;
+            }
+            for (const child of node.children || []) {
+                simplifyAndFlatten(child);
+            }
+        }
+        simplifyAndFlatten(xmlTree);
+        return {
+            flatNodes,
+            parentMap,
+            runtimeElements
+        };
+    }
+}
+exports.DomSimplifier = DomSimplifier;

package/dist/fireflinkData/fireflinkLocators/getListOfLocators.d.ts

@@ -0,0 +1,7 @@
+import { platform } from "../../core/types/scriptTypesType.js";
+import { LocatorWorkerPool } from "../../utils/workers/LocatorWorkerPool.js";
+export declare class ElementGetter {
+    private readonly workerPool;
+    constructor(workerPool: LocatorWorkerPool);
+    getFireFlinkElement(html: string, attribute: string, targetPlatform?: platform): Promise<any>;
+}

package/dist/fireflinkData/fireflinkLocators/getListOfLocators.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElementGetter = void 0;
+const logData_js_1 = require("../../utils/logger/logData.js");
+// import { getAiElementsFromHTML } from "./parser/getElementsFromHTML.js";
+const platformContext_js_1 = require("../../utils/helpers/platformContext.js");
+class ElementGetter {
+    constructor(workerPool) {
+        this.workerPool = workerPool;
+    }
+    async getFireFlinkElement(html, attribute, targetPlatform) {
+        const platform = targetPlatform || (html?.includes("ff-inspect") ? "web" : (0, platformContext_js_1.getPlatform)());
+        // const formattedAttribute = attribute.replace('[', '//*[@');
+        try {
+            const result = await this.workerPool.getFireFlinkElement(html, attribute, platform);
+            // logger.info("formattedAttribute", formattedAttribute);
+            // const result = await getFireFlinkElement(
+            //     {
+            //         locators: [
+            //             {
+            //                 name: "xpath",
+            //                 type: "Static",
+            //                 value: formattedAttribute,
+            //                 reference: "local",
+            //                 status: "NOT_USED",
+            //                 isRecorded: "N",
+            //             }
+            //         ]
+            //     },
+            //     html,
+            //     platform
+            // );
+            return Array.isArray(result) && result.length > 0 ? JSON.parse(JSON.stringify(result[0], null, 4)) : null;
+        }
+        catch (error) {
+            logData_js_1.logger.info("attribute");
+            logData_js_1.logger.error(`[${Object.getPrototypeOf(this).constructor.name}] : `, "Unable to find the element", error);
+            return "";
+        }
+    }
+}
+exports.ElementGetter = ElementGetter;