ff-dom 1.0.17 → 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,469 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getElementsFromHTML = void 0;
-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) => {
-    // Replace text() comparisons like text() = 'something' with normalize-space(.) = 'something'
-    // to avoid issues with whitespace differences
-    xpath = xpath.replace(/text\(\)\s*=\s*['"](.+?)['"]/g, "normalize-space(.)='$1'");
-    // Replace direct . = 'something' comparisons with normalize-space(.) = 'something' for consistent text matching
-    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;
-    const finalLocatorsSet = new Set();
-    let finalLocators = [];
-    function createLocator(base, overrides = {}) {
-        var _a, _b, _c, _d, _e, _f;
-        const newLocator = {
-            name: (_a = overrides.name) !== null && _a !== void 0 ? _a : base === null || base === void 0 ? void 0 : base.name,
-            type: (_b = overrides.type) !== null && _b !== void 0 ? _b : base === null || base === void 0 ? void 0 : base.type,
-            value: (_c = overrides.value) !== null && _c !== void 0 ? _c : base === null || base === void 0 ? void 0 : base.value,
-            reference: (_d = overrides.reference) !== null && _d !== void 0 ? _d : base === null || base === void 0 ? void 0 : base.reference,
-            status: (_e = overrides.status) !== null && _e !== void 0 ? _e : base === null || base === void 0 ? void 0 : base.status,
-            isRecorded: (_f = overrides.isRecorded) !== null && _f !== void 0 ? _f : base === null || base === void 0 ? void 0 : base.isRecorded,
-        };
-        if (overrides.hasOwnProperty('isSelfHealed')) {
-            newLocator.isSelfHealed = overrides.isSelfHealed;
-        }
-        else if (base === null || base === void 0 ? void 0 : base.hasOwnProperty('isSelfHealed')) {
-            newLocator.isSelfHealed = base.isSelfHealed;
-        }
-        pushUniqueLocator(newLocator);
-    }
-    function pushUniqueLocator(obj) {
-        const key = `${obj.name}:${obj.value}`;
-        if (!finalLocatorsSet.has(key)) {
-            finalLocatorsSet.add(key);
-            finalLocators.push(obj);
-        }
-    }
-    /** Locator Value Cleaner (Handles Special Scenarios) **/
-    const cleanLocatorValue = (val, type, isRecorded) => {
-        if (!val)
-            return null;
-        let cleaned = val.trim();
-        // Return null for empty or literal "null"
-        if (!cleaned || cleaned.toLowerCase() === 'null')
-            return null;
-        // Unescape any escaped quotes
-        cleaned = cleaned.replace(/\\"/g, '"').replace(/\\'/g, "'");
-        // Remove surrounding single or double quotes
-        cleaned = cleaned.replace(/^['"](.+?)['"]$/, '$1');
-        // Replace double single quotes with a single quote inside XPath
-        cleaned = cleaned.replace(/''/g, "'");
-        // Normalize double quotes in XPath attribute selectors [@id="" -> [@id='']
-        cleaned = cleaned.replace(/\[@(id|name)=['"]{2}(.+?)['"]{2}\]/g, "[@$1='$2']");
-        // For DOM selectors (id or name), remove ALL quotes
-        if (type === 'id' || type === 'name') {
-            cleaned = cleaned.replace(/['"]/g, '').trim();
-        }
-        if (type === 'xpath' && isRecorded === 'Y' && !val.startsWith('//'))
-            return null;
-        // Final check for empty strings
-        if (!cleaned || /^['"]{2}$/.test(cleaned))
-            return null;
-        return cleaned;
-    };
-    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) {
-                    createLocator(locator);
-                }
-            }
-            const isDynamic = String(locator.value || locator.type || '');
-            if (isDynamic.includes('dynamic') || isDynamic.match('dynamic') ||
-                isDynamic.includes('{') || isDynamic.includes('}')) {
-                createLocator(locator);
-                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) {
-                                            createLocator(locator, {
-                                                value: trimmedSelector,
-                                                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) => {
-                        const key = `${name}:${value}`;
-                        return finalLocatorsSet.has(key);
-                    };
-                    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) => {
-                                createLocator(loc, {
-                                    name: 'id',
-                                    value: idValue,
-                                    isRecorded: loc.value === idValue && loc.name === 'id' ? loc.isRecorded : 'Y',
-                                    isSelfHealed: loc.value === idValue && loc.name === 'id' ? loc.isSelfHealed : 'Y'
-                                });
-                            });
-                        }
-                        const textValue = getVisibleText(targetElement);
-                        if (textValue) {
-                            locators.forEach((loc) => {
-                                createLocator(loc, {
-                                    name: 'linkText',
-                                    type: 'static',
-                                    value: textValue,
-                                    isRecorded: loc.value === textValue ? loc.isRecorded : 'Y',
-                                    isSelfHealed: loc.value === textValue ? loc.isSelfHealed : 'Y',
-                                });
-                            });
-                        }
-                        const nameLocator = getName(targetElement);
-                        if (nameLocator && !locatorExists('name', nameLocator)) {
-                            locators.forEach((loc) => {
-                                createLocator(loc, {
-                                    name: 'name',
-                                    type: 'static',
-                                    value: nameLocator,
-                                    isRecorded: loc.value === nameLocator && loc.name === 'name' ? loc.isRecorded : 'Y',
-                                    isSelfHealed: loc.value === nameLocator && loc.name === 'name' ? loc.isSelfHealed : 'Y',
-                                });
-                            });
-                        }
-                        const classValue = getClassName(targetElement);
-                        if (classValue && classValue.trim() !== '' && !locatorExists('className', classValue)) {
-                            locators.forEach((loc) => {
-                                createLocator(loc, {
-                                    name: 'className',
-                                    value: classValue,
-                                    isRecorded: loc.value === classValue && loc.name === 'className' ? loc.isRecorded : 'Y',
-                                    isSelfHealed: loc.value === classValue && loc.name === 'className' ? loc.isSelfHealed : 'Y',
-                                });
-                            });
-                        }
-                        xpathFunctions.forEach((fn) => {
-                            const fnValue = fn.value(targetElement);
-                            locators.forEach((loc) => {
-                                createLocator(loc, {
-                                    name: fn.name,
-                                    value: fnValue,
-                                    isRecorded: loc.value === fnValue ? loc.isRecorded : 'Y',
-                                    isSelfHealed: loc.value === fnValue ? loc.isSelfHealed : 'Y',
-                                });
-                            });
-                        });
-                        for (const locator of locators) {
-                            try {
-                                for (const loc of locators) {
-                                    if (!loc.value)
-                                        continue;
-                                    for (const relation of relations) {
-                                        if (loc.value.includes(relation)) {
-                                            const relativeXpath = checkReferenceElementIsValid(loc.value, relation, tempDiv);
-                                            if (relativeXpath) {
-                                                createLocator(loc, {
-                                                    name: 'xpath',
-                                                    value: relativeXpath,
-                                                    isRecorded: locator.isRecorded !== '' && locator.isRecorded !== null ? locator.isRecorded : 'Y',
-                                                });
-                                                break;
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                            catch (error) {
-                                console.error('Error processing locator:', locator, error);
-                            }
-                        }
-                        const finalAutoHealedLocators = finalLocators.map((obj) => ({
-                            ...obj,
-                            value: cleanLocatorValue(obj.value, obj.name, obj.isRecorded),
-                        }));
-                        const finalUniqueAutoHealedLocators = finalAutoHealedLocators.reduce((unique, locator) => {
-                            if (locator.value && !unique.some((l) => l.value === locator.value)) {
-                                unique.push(locator);
-                            }
-                            return unique;
-                        }, []);
-                        const jsonResult = [
-                            {
-                                name: `${name}`,
-                                desc: `${desc}`,
-                                type: `${type}`,
-                                locators: finalUniqueAutoHealedLocators.filter((locator) => (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 };