ff-dom 1.0.16 → 1.0.18-beta.1

package/tsconfig.browser.json

@@ -0,0 +1,11 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "emitDeclarationOnly": true,
+    "declaration": true,
+    "declarationDir": "dist/types/browser",
+    "outDir": "dist/browser",
+  },
+  "exclude": ["src/node"],
+  "include": ["src/browser"]
+}

package/tsconfig.json

@@ -1,14 +1,18 @@
-{
-    "compilerOptions": {
-      "target": "es2019", // or "es2020", "es2021", etc.
-      "lib": ["dom", "es2019"], 
-      "module": "commonjs",
-      "strict": true,
-      "esModuleInterop": true,
-      "skipLibCheck": true,
-      "forceConsistentCasingInFileNames": true,
-      "outDir": "./dist"
-    },
-    "include": ["**/*.ts"],
-    "exclude": ["node_modules"]
+{
+    "compilerOptions": {
+      "target": "esnext",
+      "lib": ["dom", "ESNext"],
+      "moduleResolution": "bundler",
+      "module": "esnext",
+      "allowImportingTsExtensions": true,
+      "noEmit": false,
+
+      "strict": true,
+      "esModuleInterop": true,
+      "skipLibCheck": true,
+      "forceConsistentCasingInFileNames": true,
+      "allowSyntheticDefaultImports": true,
+    },
+    "include": ["**/*.ts", "test/node.spec.js"],
+    "exclude": ["node_modules", "rollup.config.js"]
   }

package/tsconfig.node.json

@@ -0,0 +1,11 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "emitDeclarationOnly": true,
+    "declaration": true,
+    "outDir": "dist/node",
+    "declarationDir": "dist/types/node"
+  },
+  "exclude": ["src/browser"],
+  "include": ["src/node", "src/node/xpath.d.ts"]
+}

package/dist/index.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getElementsFromHTML = void 0;
-const getElementsFromHTML_1 = require("./utils/getElementsFromHTML");
-Object.defineProperty(exports, "getElementsFromHTML", { enumerable: true, get: function () { return getElementsFromHTML_1.getElementsFromHTML; } });

package/dist/utils/getElementsFromHTML.js

@@ -1,532 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getElementsFromHTML = void 0;
-//@ts-nocheck
-const jsdom_1 = require("jsdom");
-const isUnique = (xpathResult) => {
-    return xpathResult && xpathResult.snapshotLength === 1;
-};
-const getElementFromShadowRoot = (element, selector) => {
-    const shadowRoot = element.shadowRoot;
-    if (shadowRoot && !selector.includes("dynamic")) {
-        return shadowRoot.querySelector(selector);
-    }
-    return null;
-};
-const isSVGElement = (element) => {
-    return (typeof window !== "undefined" &&
-        typeof SVGElement !== "undefined" &&
-        element instanceof SVGElement);
-};
-const getXPath = (element, xpath) => {
-    const window = element.ownerDocument.defaultView;
-    if (!window)
-        return null;
-    const xpathEvaluator = new window.XPathEvaluator();
-    const xpathResult = xpathEvaluator.evaluate(xpath, element.ownerDocument, null, window.XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
-    return isUnique(xpathResult) ? xpath : null;
-};
-const getId = (element) => {
-    return (element === null || element === void 0 ? void 0 : element.id) || null;
-};
-const getClassName = (element) => {
-    return element.className || null;
-};
-const getVisibleText = (element) => {
-    var _a;
-    return ((_a = element.textContent) === null || _a === void 0 ? void 0 : _a.trim()) || null;
-};
-const getXPathByText = (element) => {
-    const text = getVisibleText(element);
-    if (text) {
-        const xpath = `//${element.nodeName.toLowerCase()}[text()='${text}']`;
-        return getXPath(element, xpath);
-    }
-    return null;
-};
-const getXPathById = (element) => {
-    if (element.id) {
-        const xpath = `//${element.nodeName.toLowerCase()}[@id='${element.id}']`;
-        return getXPath(element, xpath);
-    }
-    return null;
-};
-const getXPathByClass = (element) => {
-    const classNames = element.classList;
-    if (classNames.length > 0) {
-        const xpath = `//${element.nodeName.toLowerCase()}[@class='${classNames[0]}']`;
-        return getXPath(element, xpath);
-    }
-    return null;
-};
-const getXpathByName = (element) => {
-    const selector = element.nodeName.toLowerCase();
-    const elementEl = element;
-    if (elementEl.hasAttribute("name")) {
-        const attrValue = elementEl.getAttribute("name");
-        const xpath = `//${selector}[@name='${attrValue}']`;
-        return getXPath(element, xpath) || null;
-    }
-    return null;
-};
-const getName = (element) => {
-    const elementEl = element;
-    if (elementEl.hasAttribute("name")) {
-        const attrValue = elementEl.getAttribute("name");
-        const name = `${attrValue}`;
-        return name || null;
-    }
-    return null;
-};
-const getXpathByPlaceholder = (element) => {
-    const selector = element.nodeName.toLowerCase();
-    const elementEl = element;
-    if (elementEl.hasAttribute("placeholder")) {
-        const attrValue = elementEl.getAttribute("placeholder");
-        const xpath = `//${selector}[@placeholder='${attrValue}']`;
-        return getXPath(element, xpath) || null;
-    }
-    return null;
-};
-const getXpathByType = (element) => {
-    const selector = element.nodeName.toLowerCase();
-    const elementEl = element;
-    if (elementEl.hasAttribute("type")) {
-        const attrValue = elementEl.getAttribute("type");
-        const xpath = `//${selector}[@type='${attrValue}']`;
-        return getXPath(element, xpath) || null;
-    }
-    return null;
-};
-const getXPathAbsolute = (element) => {
-    const path = [];
-    while (element && element.nodeType === 1) {
-        // ELEMENT_NODE
-        let selector = element.nodeName.toLowerCase();
-        let sibling = element;
-        let siblingCount = 1;
-        while ((sibling = sibling.previousElementSibling)) {
-            if (sibling.nodeName.toLowerCase() === element.nodeName.toLowerCase()) {
-                siblingCount++;
-            }
-        }
-        if (siblingCount > 1) {
-            selector += `[${siblingCount}]`;
-        }
-        path.unshift(selector);
-        element = element.parentNode;
-    }
-    return "//" + path.join("/");
-};
-const relations = [
-    "/preceding-sibling",
-    "/following-sibling",
-    "/parent",
-    "/descendant",
-    "/ancestor",
-    "/self",
-    "/ancestor-or-self",
-    "/child",
-    "/preceding",
-    "/following",
-];
-const normalizeXPath = (xpath) => {
-    xpath = xpath.replace(/text\(\)\s*=\s*['"](.+?)['"]/g, "normalize-space(.)='$1'");
-    xpath = xpath.replace(/\.\s*=\s*['"](.+?)['"]/g, "normalize-space(.)='$1'");
-    return xpath;
-};
-function getElementFromXPath(tempDiv, xpath) {
-    let currentElement = tempDiv;
-    const window = currentElement.ownerDocument.defaultView;
-    if (!window)
-        return null;
-    const xpathEvaluator = new window.XPathEvaluator();
-    const xpathResult = xpathEvaluator.evaluate(xpath, currentElement.ownerDocument, //here even tempDiv can be passed
-    null, window.XPathResult.FIRST_ORDERED_NODE_TYPE, null);
-    return xpathResult.singleNodeValue;
-}
-function checkReferenceElementIsValid(locator, relation, tempDiv) {
-    if (locator.includes(relation)) {
-        const locatotSplitArray = locator.split(relation);
-        const sourceLoc = locatotSplitArray[0].trim();
-        let currentElement = tempDiv;
-        const window = currentElement.ownerDocument.defaultView;
-        if (!window)
-            return null;
-        if (!locator.includes("dynamic")) {
-            const xpathEvaluator = new window.XPathEvaluator();
-            const xpathResult = xpathEvaluator.evaluate(sourceLoc, currentElement.ownerDocument, null, window.XPathResult.FIRST_ORDERED_NODE_TYPE, null);
-            const sourceElement = xpathResult.singleNodeValue;
-            if (sourceElement) {
-                const xpathResultComplete = xpathEvaluator.evaluate(locator, currentElement.ownerDocument, null, window.XPathResult.FIRST_ORDERED_NODE_TYPE, null);
-                const completeElement = xpathResultComplete.singleNodeValue;
-                let relativeXpath;
-                if (completeElement) {
-                    relativeXpath = locator;
-                    return relativeXpath;
-                }
-                else {
-                    console.error("Complete Locator is Invalid:", locator);
-                    relativeXpath = locator;
-                    return relativeXpath;
-                }
-            }
-            else {
-                console.error("Source Locator Not Found:", sourceLoc);
-            }
-        }
-    }
-    return null;
-}
-const getElementsFromHTML = (name, desc, type, locators, isShared, projectId, projectType, isRecorded, folder, parentId, parentName, platform, licenseId, licenseType, userId, htmlString) => {
-    var _a;
-    const virtualConsole = new jsdom_1.VirtualConsole();
-    const dom = new jsdom_1.JSDOM(htmlString, {
-        resources: "usable",
-        runScripts: "outside-only", // Prevents inline script execution in JSDOM
-        pretendToBeVisual: true,
-        virtualConsole,
-        includeNodeLocations: true,
-    });
-    const document = dom.window.document;
-    global.SVGElement = dom.window.SVGElement;
-    const tempDiv = document.createElement("div");
-    const elementsToRemove = document.querySelectorAll("script, style, link[rel='stylesheet'], meta, noscript, embed, object, param, source, svg");
-    if (elementsToRemove) {
-        elementsToRemove.forEach((tag) => {
-            tag.remove();
-        });
-    }
-    tempDiv.innerHTML = document.body.innerHTML;
-    let finalLocators = [];
-    locators: for (const locator of locators) {
-        try {
-            const isRecorded = String(locator.isRecorded || "");
-            const recordedNLocators = locators.filter((l) => l.isRecorded === "N");
-            if (recordedNLocators.length > 0) {
-                for (const locator of recordedNLocators) {
-                    finalLocators.push({
-                        name: locator.name,
-                        type: locator.type,
-                        value: locator.value,
-                        reference: locator.reference,
-                        status: locator.status,
-                        isRecorded: locator.isRecorded,
-                    });
-                }
-            }
-            let relativeXpath = null;
-            const isDynamic = String(locator.value || locator.type || "");
-            if (isDynamic.includes("dynamic") ||
-                isDynamic.match("dynamic") ||
-                isDynamic.includes("{") ||
-                isDynamic.includes("}")) {
-                finalLocators.push({
-                    name: locator.name,
-                    type: locator.type,
-                    value: locator.value,
-                    reference: locator.reference,
-                    status: locator.status,
-                    isRecorded: locator.isRecorded,
-                });
-                continue;
-            }
-            if (isShared.includes("Y")) {
-                break locators;
-            }
-            for (const relation of relations) {
-                try {
-                    let targetElement = null;
-                    if (locator.value.startsWith("iframe")) {
-                        const iframe = tempDiv.querySelector(locator.value);
-                        if (iframe) {
-                            const iframeDocument = iframe.contentDocument || ((_a = iframe.contentWindow) === null || _a === void 0 ? void 0 : _a.document);
-                            if (iframeDocument) {
-                                targetElement = iframeDocument.querySelector(locator.value.slice(6));
-                            }
-                        }
-                    }
-                    else {
-                        const selectors = locator.value.split(">>>"); // Custom delimiter for shadow DOM
-                        let currentElement = tempDiv;
-                        for (const selector of selectors) {
-                            if (currentElement) {
-                                const trimmedSelector = selector.trim();
-                                if (locator.name.includes("id") ||
-                                    trimmedSelector.startsWith("#")) {
-                                    targetElement = currentElement.querySelector("#" + trimmedSelector);
-                                }
-                                else if (locator.name.includes("className") ||
-                                    trimmedSelector.startsWith(".")) {
-                                    targetElement = currentElement.querySelector("." + trimmedSelector);
-                                }
-                                else if ((locator.name.includes("xpath") ||
-                                    trimmedSelector.startsWith("//")) &&
-                                    !locator.type.match("dynamic")) {
-                                    if (tempDiv.innerHTML) {
-                                        const normalizedXPath = normalizeXPath(trimmedSelector);
-                                        targetElement = getElementFromXPath(tempDiv, normalizedXPath);
-                                        if (targetElement) {
-                                            finalLocators.push({
-                                                name: locator.name,
-                                                type: locator.type,
-                                                value: trimmedSelector,
-                                                reference: locator.reference,
-                                                status: locator.status,
-                                                isRecorded: String(locator.isRecorded).includes("N")
-                                                    ? "N"
-                                                    : "Y",
-                                            });
-                                        }
-                                    }
-                                }
-                                else {
-                                    targetElement = currentElement.querySelector(trimmedSelector);
-                                    if (!targetElement) {
-                                        targetElement = getElementFromShadowRoot(currentElement, trimmedSelector);
-                                    }
-                                }
-                                if (!targetElement &&
-                                    isSVGElement(currentElement) &&
-                                    !locator.type.match("dynamic")) {
-                                    targetElement = currentElement.querySelector(trimmedSelector);
-                                }
-                                currentElement = targetElement;
-                            }
-                            else {
-                                console.error("Element not found at:", selector);
-                                break;
-                            }
-                        }
-                    }
-                    const locatorExists = (name, value) => {
-                        return finalLocators.some((loc) => loc.name === name &&
-                            loc.value === value &&
-                            (!loc.value.includes("dynamic") ||
-                                !locator.type.match("dynamic")));
-                    };
-                    const xpathFunctions = [
-                        { name: "xpath", value: getXPathByText },
-                        { name: "xpath", value: getXPathById },
-                        { name: "xpath", value: getXPathByClass },
-                        { name: "xpath", value: getXPathAbsolute },
-                        { name: "xpath", value: getXpathByName },
-                        { name: "xpath", value: getXpathByPlaceholder },
-                        { name: "xpath", value: getXpathByType },
-                    ];
-                    if (targetElement) {
-                        const idValue = getId(targetElement);
-                        if (idValue && !locatorExists("id", idValue)) {
-                            locators.forEach((loc) => {
-                                if (locator.value === idValue && locator.name === "id") {
-                                    finalLocators.push({
-                                        name: "id",
-                                        type: locator.type,
-                                        value: idValue,
-                                        reference: locator.reference,
-                                        status: locator.status,
-                                        isRecorded: locator.isRecorded,
-                                    });
-                                }
-                                else {
-                                    finalLocators.push({
-                                        name: "id",
-                                        type: locator.type,
-                                        value: idValue,
-                                        reference: locator.reference,
-                                        status: locator.status,
-                                        isRecorded: "Y",
-                                        isSelfHealed: "Y",
-                                    });
-                                }
-                            });
-                        }
-                        if (getVisibleText(targetElement)) {
-                            const textValue = getVisibleText(targetElement);
-                            locators.forEach((loc) => {
-                                if (loc.value === textValue) {
-                                    finalLocators.push({
-                                        name: "linkText",
-                                        type: "static",
-                                        value: textValue,
-                                        reference: locator.reference,
-                                        status: locator.status,
-                                        isRecorded: locator.isRecorded,
-                                    });
-                                }
-                                else {
-                                    finalLocators.push({
-                                        name: "linkText",
-                                        type: "static",
-                                        value: textValue,
-                                        reference: locator.reference,
-                                        status: locator.status,
-                                        isRecorded: "Y",
-                                        isSelfHealed: "Y",
-                                    });
-                                }
-                            });
-                        }
-                        if (getName(targetElement)) {
-                            const nameLocator = getName(targetElement);
-                            if (nameLocator && !locatorExists("name", nameLocator)) {
-                                locators.forEach((loc) => {
-                                    if (loc.value === nameLocator && locator.name === "name") {
-                                        finalLocators.push({
-                                            name: "name",
-                                            type: "static",
-                                            value: nameLocator,
-                                            reference: locator.reference,
-                                            status: locator.status,
-                                            isRecorded: locator.isRecorded,
-                                        });
-                                    }
-                                    else {
-                                        finalLocators.push({
-                                            name: "name",
-                                            type: "static",
-                                            value: nameLocator,
-                                            reference: locator.reference,
-                                            status: locator.status,
-                                            isRecorded: "Y",
-                                            isSelfHealed: "Y",
-                                        });
-                                    }
-                                });
-                            }
-                        }
-                        const classValue = getClassName(targetElement);
-                        if (classValue &&
-                            classValue.trim() !== "" &&
-                            !locatorExists("className", classValue)) {
-                            locators.forEach((loc) => {
-                                if (loc.value === classValue && locator.name === "className") {
-                                    finalLocators.push({
-                                        name: "className",
-                                        type: locator.type,
-                                        value: classValue,
-                                        reference: locator.reference,
-                                        status: locator.status,
-                                        isRecorded: locator.isRecorded,
-                                    });
-                                }
-                                else {
-                                    finalLocators.push({
-                                        name: "className",
-                                        type: locator.type,
-                                        value: classValue,
-                                        reference: locator.reference,
-                                        status: locator.status,
-                                        isRecorded: "Y",
-                                        isSelfHealed: "Y",
-                                    });
-                                }
-                            });
-                        }
-                        xpathFunctions.forEach((fn) => {
-                            locators.forEach((loc) => {
-                                if (loc.value === fn.value(targetElement)) {
-                                    finalLocators.push({
-                                        name: fn.name,
-                                        type: locator.type,
-                                        value: fn.value(targetElement),
-                                        reference: locator.reference,
-                                        status: locator.status,
-                                        isRecorded: locator.isRecorded,
-                                    });
-                                }
-                                else {
-                                    finalLocators.push({
-                                        name: fn.name,
-                                        type: locator.type,
-                                        value: fn.value(targetElement),
-                                        reference: locator.reference,
-                                        status: locator.status,
-                                        isRecorded: "Y",
-                                        isSelfHealed: "Y",
-                                    });
-                                }
-                            });
-                        });
-                        for (const locator of locators) {
-                            try {
-                                let relativeXpath = null;
-                                if (locator.value) {
-                                    for (const relation of relations) {
-                                        if (locator.value.includes(relation)) {
-                                            relativeXpath = checkReferenceElementIsValid(locator.value, relation, tempDiv);
-                                            if (relativeXpath) {
-                                                finalLocators.push({
-                                                    name: "xpath",
-                                                    type: locator.type,
-                                                    value: relativeXpath,
-                                                    reference: locator.reference,
-                                                    status: locator.status,
-                                                    isRecorded: locator.isRecorded !== "" ||
-                                                        locator.isRecorded !== null
-                                                        ? locator.isRecorded
-                                                        : "Y",
-                                                });
-                                                break;
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                            catch (error) {
-                                console.error("Error processing locator:", locator, error);
-                            }
-                        }
-                        let uniqueLocators = new Map();
-                        finalLocators.forEach((obj) => {
-                            let val = obj.value;
-                            if (obj.isRecorded === 'Y' && val) {
-                                val = String(val).replace(/"/g, "'").replace(/\\'/g, "'");
-                            }
-                            // filter out redundant/invalid values
-                            if (!val || val === 'null' || val === "''")
-                                return;
-                            // ensure unique entries
-                            if (!uniqueLocators.has(val)) {
-                                uniqueLocators.set(val, { ...obj, value: val });
-                            }
-                        });
-                        let ffLoc = Array.from(uniqueLocators.values());
-                        const jsonResult = [
-                            {
-                                name: `${name}`,
-                                desc: `${desc}`,
-                                type: `${type}`,
-                                locators: ffLoc.filter((locator) => locator.hasOwnProperty("value") &&
-                                    (locator === null || locator === void 0 ? void 0 : locator.value) !== null &&
-                                    locator.value !== ""),
-                                isShared: `${isShared}`,
-                                projectId: `${projectId}`,
-                                projectType: `${projectType}`,
-                                isRecorded: `${isRecorded}`,
-                                folder: `${folder}`,
-                                parentId: `${parentId}`,
-                                parentName: `${parentName}`,
-                                platform: `${platform}`,
-                                licenseId: `${licenseId}`,
-                                licenseType: `${licenseType}`,
-                                userId: `${userId}`,
-                            },
-                        ];
-                        return jsonResult;
-                    }
-                }
-                catch (error) {
-                    console.error("Error processing locator:", locator, error);
-                    continue;
-                }
-            }
-        }
-        catch (error) {
-            console.error("Error processing locator:", locator, error);
-            continue;
-        }
-    }
-    return null;
-};
-exports.getElementsFromHTML = getElementsFromHTML;

package/src/index.ts

@@ -1,3 +0,0 @@
-import { getElementsFromHTML } from "./utils/getElementsFromHTML";
-
-export { getElementsFromHTML };