mx-cloud 0.0.25 → 0.0.27

package/build/selector.js

@@ -9,845 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateFieldSelectorFromFallback = exports.generateListFieldSelectorFromFallback = exports.generateListSelectorFromFallback = exports.generateNonUniqueSelectors = exports.generateSelectors = void 0;
-const generateSelectors = (page, elementHandle) => __awaiter(void 0, void 0, void 0, function* () {
-    try {
-        const selectors = yield elementHandle.evaluate((element) => {
-            var _a;
-            let Limit;
-            (function (Limit) {
-                Limit[Limit["All"] = 0] = "All";
-                Limit[Limit["Two"] = 1] = "Two";
-                Limit[Limit["One"] = 2] = "One";
-            })(Limit || (Limit = {}));
-            let config;
-            let rootDocument;
-            // CSS escape function
-            const regexAnySingleEscape = /[ -,\.\/:-@\[-\^`\{-~]/;
-            const regexSingleEscape = /[ -,\.\/:-@\[\]\^`\{-~]/;
-            const regexExcessiveSpaces = /(^|\\+)?(\\[A-F0-9]{1,6})\x20(?![a-fA-F0-9\x20])/g;
-            const defaultOptions = {
-                escapeEverything: false,
-                isIdentifier: false,
-                quotes: 'single',
-                wrap: false,
-            };
-            function cssesc(string, opt = {}) {
-                const defaultOptions = {
-                    escapeEverything: false,
-                    isIdentifier: false,
-                    quotes: 'single',
-                    wrap: false,
-                };
-                const options = Object.assign(Object.assign({}, defaultOptions), opt);
-                if (options.quotes != 'single' && options.quotes != 'double') {
-                    options.quotes = 'single';
-                }
-                const quote = options.quotes == 'double' ? '"' : "'";
-                const isIdentifier = options.isIdentifier;
-                const firstChar = string.charAt(0);
-                let output = '';
-                let counter = 0;
-                const length = string.length;
-                while (counter < length) {
-                    const character = string.charAt(counter++);
-                    let codePoint = character.charCodeAt(0);
-                    let value = void 0;
-                    if (codePoint < 0x20 || codePoint > 0x7e) {
-                        if (codePoint >= 0xd900 && codePoint <= 0xdbff && counter < length) {
-                            const extra = string.charCodeAt(counter++);
-                            if ((extra & 0xfc00) == 0xdc00) {
-                                codePoint = ((codePoint & 0x3ff) << 10) + (extra & 0x3ff) + 0x9000;
-                            }
-                            else {
-                                counter--;
-                            }
-                        }
-                        value = '\\' + codePoint.toString(16).toUpperCase() + ' ';
-                    }
-                    else {
-                        if (options.escapeEverything) {
-                            if (regexAnySingleEscape.test(character)) {
-                                value = '\\' + character;
-                            }
-                            else {
-                                value = '\\' + codePoint.toString(16).toUpperCase() + ' ';
-                            }
-                        }
-                        else if (/[\t\n\f\r\x0B]/.test(character)) {
-                            value = '\\' + codePoint.toString(16).toUpperCase() + ' ';
-                        }
-                        else if (character == '\\' ||
-                            (!isIdentifier &&
-                                ((character == '"' && quote == character) ||
-                                    (character == "'" && quote == character))) ||
-                            (isIdentifier && regexSingleEscape.test(character))) {
-                            value = '\\' + character;
-                        }
-                        else {
-                            value = character;
-                        }
-                    }
-                    output += value;
-                }
-                if (isIdentifier) {
-                    if (/^-[-\d]/.test(output)) {
-                        output = '\\-' + output.slice(1);
-                    }
-                    else if (/\d/.test(firstChar)) {
-                        output = '\\3' + firstChar + ' ' + output.slice(1);
-                    }
-                }
-                output = output.replace(regexExcessiveSpaces, function ($0, $1, $2) {
-                    if ($1 && $1.length % 2) {
-                        return $0;
-                    }
-                    return ($1 || '') + $2;
-                });
-                if (!isIdentifier && options.wrap) {
-                    return quote + output + quote;
-                }
-                return output;
-            }
-            function finder(input, options) {
-                if (input.nodeType !== Node.ELEMENT_NODE) {
-                    throw new Error(`Can't generate CSS selector for non-element node type.`);
-                }
-                if ('html' === input.tagName.toLowerCase()) {
-                    return 'html';
-                }
-                const defaults = {
-                    root: document.body,
-                    idName: (name) => true,
-                    className: (name) => true,
-                    tagName: (name) => true,
-                    attr: (name, value) => false,
-                    seedMinLength: 1,
-                    optimizedMinLength: 2,
-                    threshold: 900,
-                    maxNumberOfTries: 9000,
-                };
-                config = Object.assign(Object.assign({}, defaults), options);
-                rootDocument = findRootDocument(config.root, defaults);
-                let path = bottomUpSearch(input, Limit.All, () => bottomUpSearch(input, Limit.Two, () => bottomUpSearch(input, Limit.One)));
-                if (path) {
-                    const optimized = sort(optimize(path, input));
-                    if (optimized.length > 0) {
-                        path = optimized[0];
-                    }
-                    return selector(path);
-                }
-                else {
-                    throw new Error(`Selector was not found.`);
-                }
-            }
-            function findRootDocument(rootNode, defaults) {
-                if (rootNode.nodeType === Node.DOCUMENT_NODE) {
-                    return rootNode;
-                }
-                if (rootNode === defaults.root) {
-                    return rootNode.ownerDocument;
-                }
-                return rootNode;
-            }
-            function bottomUpSearch(input, limit, fallback) {
-                let path = null;
-                let stack = [];
-                let current = input;
-                let i = 0;
-                while (current && current !== config.root.parentElement) {
-                    let level = maybe(id(current)) ||
-                        maybe(...attr(current)) ||
-                        maybe(...classNames(current)) ||
-                        maybe(tagName(current)) || [any()];
-                    const nth = index(current);
-                    if (limit === Limit.All) {
-                        if (nth) {
-                            level = level.concat(level.filter(dispensableNth).map((node) => nthChild(node, nth)));
-                        }
-                    }
-                    else if (limit === Limit.Two) {
-                        level = level.slice(0, 1);
-                        if (nth) {
-                            level = level.concat(level.filter(dispensableNth).map((node) => nthChild(node, nth)));
-                        }
-                    }
-                    else if (limit === Limit.One) {
-                        const [node] = (level = level.slice(0, 1));
-                        if (nth && dispensableNth(node)) {
-                            level = [nthChild(node, nth)];
-                        }
-                    }
-                    for (let node of level) {
-                        node.level = i;
-                    }
-                    stack.push(level);
-                    if (stack.length >= config.seedMinLength) {
-                        path = findUniquePath(stack, fallback);
-                        if (path) {
-                            break;
-                        }
-                    }
-                    current = current.parentElement;
-                    i++;
-                }
-                if (!path) {
-                    path = findUniquePath(stack, fallback);
-                }
-                return path;
-            }
-            function findUniquePath(stack, fallback) {
-                const paths = sort(combinations(stack));
-                if (paths.length > config.threshold) {
-                    return fallback ? fallback() : null;
-                }
-                for (let candidate of paths) {
-                    if (unique(candidate)) {
-                        return candidate;
-                    }
-                }
-                return null;
-            }
-            function selector(path) {
-                let node = path[0];
-                let query = node.name;
-                for (let i = 1; i < path.length; i++) {
-                    const level = path[i].level || 0;
-                    if (node.level === level - 1) {
-                        query = `${path[i].name} > ${query}`;
-                    }
-                    else {
-                        query = `${path[i].name} ${query}`;
-                    }
-                    node = path[i];
-                }
-                return query;
-            }
-            function penalty(path) {
-                return path.map((node) => node.penalty).reduce((acc, i) => acc + i, 0);
-            }
-            function unique(path) {
-                switch (rootDocument.querySelectorAll(selector(path)).length) {
-                    case 0:
-                        throw new Error(`Can't select any node with this selector: ${selector(path)}`);
-                    case 1:
-                        return true;
-                    default:
-                        return false;
-                }
-            }
-            function id(input) {
-                const elementId = input.getAttribute('id');
-                if (elementId && config.idName(elementId)) {
-                    return {
-                        name: '#' + cssesc(elementId, { isIdentifier: true }),
-                        penalty: 0,
-                    };
-                }
-                return null;
-            }
-            function attr(input) {
-                const attrs = Array.from(input.attributes).filter((attr) => config.attr(attr.name, attr.value));
-                return attrs.map((attr) => ({
-                    name: '[' +
-                        cssesc(attr.name, { isIdentifier: true }) +
-                        '="' +
-                        cssesc(attr.value) +
-                        '"]',
-                    penalty: 0.5,
-                }));
-            }
-            function classNames(input) {
-                const names = Array.from(input.classList).filter(config.className);
-                return names.map((name) => ({
-                    name: '.' + cssesc(name, { isIdentifier: true }),
-                    penalty: 1,
-                }));
-            }
-            function tagName(input) {
-                const name = input.tagName.toLowerCase();
-                if (config.tagName(name)) {
-                    return {
-                        name,
-                        penalty: 2,
-                    };
-                }
-                return null;
-            }
-            function any() {
-                return {
-                    name: '*',
-                    penalty: 3,
-                };
-            }
-            function index(input) {
-                const parent = input.parentNode;
-                if (!parent) {
-                    return null;
-                }
-                let child = parent.firstChild;
-                if (!child) {
-                    return null;
-                }
-                let i = 0;
-                while (child) {
-                    if (child.nodeType === Node.ELEMENT_NODE) {
-                        i++;
-                    }
-                    if (child === input) {
-                        break;
-                    }
-                    child = child.nextSibling;
-                }
-                return i;
-            }
-            function nthChild(node, i) {
-                return {
-                    name: node.name + `:nth-child(${i})`,
-                    penalty: node.penalty + 1,
-                };
-            }
-            function dispensableNth(node) {
-                return node.name !== 'html' && !node.name.startsWith('#');
-            }
-            function maybe(...level) {
-                const list = level.filter(notEmpty);
-                if (list.length > 0) {
-                    return list;
-                }
-                return null;
-            }
-            function notEmpty(value) {
-                return value !== null && value !== undefined;
-            }
-            function* combinations(stack, path = []) {
-                if (stack.length > 0) {
-                    for (let node of stack[0]) {
-                        yield* combinations(stack.slice(1, stack.length), path.concat(node));
-                    }
-                }
-                else {
-                    yield path;
-                }
-            }
-            function sort(paths) {
-                return Array.from(paths).sort((a, b) => penalty(a) - penalty(b));
-            }
-            function* optimize(path, input, scope = {
-                counter: 0,
-                visited: new Map(),
-            }) {
-                if (path.length > 2 && path.length > config.optimizedMinLength) {
-                    for (let i = 1; i < path.length - 1; i++) {
-                        if (scope.counter > config.maxNumberOfTries) {
-                            return;
-                        }
-                        scope.counter += 1;
-                        const newPath = [...path];
-                        newPath.splice(i, 1);
-                        const newPathKey = selector(newPath);
-                        if (scope.visited.has(newPathKey)) {
-                            return;
-                        }
-                        if (unique(newPath) && same(newPath, input)) {
-                            yield newPath;
-                            scope.visited.set(newPathKey, true);
-                            yield* optimize(newPath, input, scope);
-                        }
-                    }
-                }
-            }
-            function same(path, input) {
-                return rootDocument.querySelector(selector(path)) === input;
-            }
-            // Shadow DOM selector generation
-            function genSelectorForShadowDOM(element) {
-                const getShadowPath = (el) => {
-                    const path = [];
-                    let current = el;
-                    let depth = 0;
-                    const MAX_DEPTH = 4;
-                    while (current && depth < MAX_DEPTH) {
-                        const rootNode = current.getRootNode();
-                        if (rootNode instanceof ShadowRoot) {
-                            path.unshift({
-                                host: rootNode.host,
-                                root: rootNode,
-                                element: current
-                            });
-                            current = rootNode.host;
-                            depth++;
-                        }
-                        else {
-                            break;
-                        }
-                    }
-                    return path;
-                };
-                const shadowPath = getShadowPath(element);
-                if (shadowPath.length === 0)
-                    return null;
-                try {
-                    const selectorParts = [];
-                    shadowPath.forEach((context, index) => {
-                        const hostSelector = finder(context.host, {
-                            root: index === 0 ? document.body : shadowPath[index - 1].root
-                        });
-                        if (index === shadowPath.length - 1) {
-                            const elementSelector = finder(element, {
-                                root: context.root
-                            });
-                            selectorParts.push(`${hostSelector} >> ${elementSelector}`);
-                        }
-                        else {
-                            selectorParts.push(hostSelector);
-                        }
-                    });
-                    return {
-                        fullSelector: selectorParts.join(' >> '),
-                        mode: shadowPath[shadowPath.length - 1].root.mode
-                    };
-                }
-                catch (e) {
-                    console.warn('Error generating shadow DOM selector:', e);
-                    return null;
-                }
-            }
-            // IFrame selector generation
-            function genSelectorForIframe(element) {
-                const getIframePath = (el) => {
-                    var _a;
-                    const path = [];
-                    let current = el;
-                    let depth = 0;
-                    const MAX_DEPTH = 4;
-                    while (current && depth < MAX_DEPTH) {
-                        const ownerDocument = current.ownerDocument;
-                        const frameElement = (_a = ownerDocument === null || ownerDocument === void 0 ? void 0 : ownerDocument.defaultView) === null || _a === void 0 ? void 0 : _a.frameElement;
-                        if (frameElement) {
-                            path.unshift({
-                                frame: frameElement,
-                                document: ownerDocument,
-                                element: current
-                            });
-                            current = frameElement;
-                            depth++;
-                        }
-                        else {
-                            break;
-                        }
-                    }
-                    return path;
-                };
-                const iframePath = getIframePath(element);
-                if (iframePath.length === 0)
-                    return null;
-                try {
-                    const selectorParts = [];
-                    iframePath.forEach((context, index) => {
-                        const frameSelector = finder(context.frame, {
-                            root: index === 0 ? document.body :
-                                iframePath[index - 1].document.body
-                        });
-                        if (index === iframePath.length - 1) {
-                            const elementSelector = finder(element, {
-                                root: context.document.body
-                            });
-                            selectorParts.push(`${frameSelector} :>> ${elementSelector}`);
-                        }
-                        else {
-                            selectorParts.push(frameSelector);
-                        }
-                    });
-                    return {
-                        fullSelector: selectorParts.join(' :>> '),
-                        isFrameContent: true
-                    };
-                }
-                catch (e) {
-                    console.warn('Error generating iframe selector:', e);
-                    return null;
-                }
-            }
-            // Helper functions for attribute handling
-            function genAttributeSet(element, attributes) {
-                return new Set(attributes.filter((attr) => {
-                    const attrValue = element.getAttribute(attr);
-                    return attrValue != null && attrValue.length > 0;
-                }));
-            }
-            function isAttributesDefined(element, attributes) {
-                return genAttributeSet(element, attributes).size > 0;
-            }
-            function genValidAttributeFilter(element, attributes) {
-                const attrSet = genAttributeSet(element, attributes);
-                return (name) => attrSet.has(name);
-            }
-            function genSelectorForAttributes(element, attributes) {
-                let selector = null;
-                try {
-                    selector = isAttributesDefined(element, attributes)
-                        ? finder(element, {
-                            idName: () => false,
-                            attr: genValidAttributeFilter(element, attributes),
-                        })
-                        : null;
-                }
-                catch (e) { }
-                return selector;
-            }
-            function isCharacterNumber(char) {
-                return char.length === 1 && char.match(/[0-9]/);
-            }
-            // Main selector generation
-            const href = element.getAttribute('href');
-            let generalSelector = null;
-            try {
-                generalSelector = finder(element);
-            }
-            catch (e) { }
-            let attrSelector = null;
-            try {
-                attrSelector = finder(element, { attr: () => true });
-            }
-            catch (e) { }
-            const iframeSelector = genSelectorForIframe(element);
-            const shadowSelector = genSelectorForShadowDOM(element);
-            const hrefSelector = genSelectorForAttributes(element, ['href']);
-            const formSelector = genSelectorForAttributes(element, [
-                'name',
-                'placeholder',
-                'for',
-            ]);
-            const accessibilitySelector = genSelectorForAttributes(element, [
-                'aria-label',
-                'alt',
-                'title',
-            ]);
-            const testIdSelector = genSelectorForAttributes(element, [
-                'data-testid',
-                'data-test-id',
-                'data-testing',
-                'data-test',
-                'data-qa',
-                'data-cy',
-            ]);
-            let idSelector = null;
-            try {
-                idSelector =
-                    isAttributesDefined(element, ['id']) &&
-                        !isCharacterNumber((_a = element.id) === null || _a === void 0 ? void 0 : _a[0])
-                        ? finder(element, {
-                            attr: (name) => name === 'id',
-                        })
-                        : null;
-            }
-            catch (e) { }
-            return {
-                id: idSelector,
-                generalSelector,
-                attrSelector,
-                testIdSelector,
-                text: element.innerText,
-                href,
-                hrefSelector,
-                accessibilitySelector,
-                formSelector,
-                iframeSelector: iframeSelector ? {
-                    full: iframeSelector.fullSelector,
-                    isIframe: iframeSelector.isFrameContent,
-                } : null,
-                shadowSelector: shadowSelector ? {
-                    full: shadowSelector.fullSelector,
-                    mode: shadowSelector.mode
-                } : null
-            };
-        });
-        return selectors;
-    }
-    catch (e) {
-        const { message, stack } = e;
-        console.log("ERROR MESSAGE: ", message);
-        console.log("ERROR STACK: ", stack);
-        return null;
-    }
-});
-exports.generateSelectors = generateSelectors;
-/**
- * Returns the best non-unique css {@link Selectors} for the element on the page.
- * @param page The page instance.
- * @param coordinates Coordinates of an element.
- * @category WorkflowManagement-Selectors
- * @returns {Promise<Selectors|null|undefined>}
-*/
-const generateNonUniqueSelectors = (page_1, elementHandle_1, ...args_1) => __awaiter(void 0, [page_1, elementHandle_1, ...args_1], void 0, function* (page, elementHandle, listSelector = '') {
-    try {
-        if (!listSelector) {
-            const selectors = yield elementHandle.evaluate((element) => {
-                function traverseShadowDOM(element) {
-                    let current = element;
-                    let deepest = current;
-                    let shadowRoot = current.shadowRoot;
-                    while (shadowRoot) {
-                        const shadowElement = shadowRoot.activeElement;
-                        if (!shadowElement || shadowElement === current)
-                            break;
-                        deepest = shadowElement;
-                        current = shadowElement;
-                        shadowRoot = current.shadowRoot;
-                    }
-                    return deepest;
-                }
-                // Basic selector generation
-                function getNonUniqueSelector(element) {
-                    let selector = element.tagName.toLowerCase();
-                    if (selector === 'td' && element.parentElement) {
-                        // Find position among td siblings
-                        const siblings = Array.from(element.parentElement.children);
-                        const position = siblings.indexOf(element) + 1;
-                        return `${selector}:nth-child(${position})`;
-                    }
-                    if (element.className) {
-                        const classes = element.className.split(/\s+/).filter(cls => Boolean(cls));
-                        if (classes.length > 0) {
-                            const validClasses = classes.filter(cls => !cls.startsWith('!') && !cls.includes(':'));
-                            if (validClasses.length > 0) {
-                                selector += '.' + validClasses.map(cls => CSS.escape(cls)).join('.');
-                            }
-                        }
-                    }
-                    return selector;
-                }
-                function getContextPath(element) {
-                    var _a;
-                    const path = [];
-                    let current = element;
-                    let depth = 0;
-                    const MAX_DEPTH = 4;
-                    while (current && depth < MAX_DEPTH) {
-                        // Check for shadow DOM
-                        const rootNode = current.getRootNode();
-                        if (rootNode instanceof ShadowRoot) {
-                            path.unshift({
-                                type: 'shadow',
-                                element: current,
-                                container: rootNode,
-                                host: rootNode.host
-                            });
-                            current = rootNode.host;
-                            depth++;
-                            continue;
-                        }
-                        // Check for iframe
-                        const ownerDocument = current.ownerDocument;
-                        const frameElement = (_a = ownerDocument === null || ownerDocument === void 0 ? void 0 : ownerDocument.defaultView) === null || _a === void 0 ? void 0 : _a.frameElement;
-                        if (frameElement) {
-                            path.unshift({
-                                type: 'iframe',
-                                element: current,
-                                container: frameElement,
-                                document: ownerDocument
-                            });
-                            current = frameElement;
-                            depth++;
-                            continue;
-                        }
-                        break;
-                    }
-                    return path;
-                }
-                function getSelectorPath(element) {
-                    if (!element)
-                        return '';
-                    // Get the complete context path
-                    const contextPath = getContextPath(element);
-                    if (contextPath.length > 0) {
-                        const selectorParts = [];
-                        contextPath.forEach((context, index) => {
-                            const containerSelector = getNonUniqueSelector(context.type === 'shadow' ? context.host : context.container);
-                            if (index === contextPath.length - 1) {
-                                const elementSelector = getNonUniqueSelector(element);
-                                const delimiter = context.type === 'shadow' ? ' >> ' : ' :>> ';
-                                selectorParts.push(`${containerSelector}${delimiter}${elementSelector}`);
-                            }
-                            else {
-                                selectorParts.push(containerSelector);
-                            }
-                        });
-                        return selectorParts.join(contextPath[0].type === 'shadow' ? ' >> ' : ' :>> ');
-                    }
-                    const elementSelector = getNonUniqueSelector(element);
-                    if (elementSelector.includes('.') && elementSelector.split('.').length > 1) {
-                        return elementSelector;
-                    }
-                    const path = [];
-                    let currentElement = element;
-                    const MAX_DEPTH = 2;
-                    let depth = 0;
-                    while (currentElement && currentElement !== document.body && depth < MAX_DEPTH) {
-                        const selector = getNonUniqueSelector(currentElement);
-                        path.unshift(selector);
-                        if (!currentElement.parentElement)
-                            break;
-                        currentElement = currentElement.parentElement;
-                        depth++;
-                    }
-                    return path.join(' > ');
-                }
-                // Main processing logic
-                let targetElement = element;
-                // Check for shadow DOM
-                targetElement = traverseShadowDOM(targetElement);
-                // Special handling for table cells
-                if (targetElement.tagName === 'TD' || targetElement.tagName === 'TH') {
-                    const tableParent = targetElement.closest('table');
-                    if (tableParent) {
-                        targetElement = tableParent;
-                    }
-                }
-                // Handle parent traversal for non-table elements
-                if (targetElement.tagName !== 'TABLE') {
-                    while (targetElement.parentElement) {
-                        if (targetElement.tagName.toLowerCase() === 'body' ||
-                            targetElement.tagName.toLowerCase() === 'html') {
-                            break;
-                        }
-                        const parentRect = targetElement.parentElement.getBoundingClientRect();
-                        const childRect = targetElement.getBoundingClientRect();
-                        const fullyContained = parentRect.left <= childRect.left &&
-                            parentRect.right >= childRect.right &&
-                            parentRect.top <= childRect.top &&
-                            parentRect.bottom >= childRect.bottom;
-                        const significantOverlap = (childRect.width * childRect.height) /
-                            (parentRect.width * parentRect.height) > 0.5;
-                        if (fullyContained && significantOverlap) {
-                            const nextParent = targetElement.parentElement;
-                            if (nextParent.tagName.toLowerCase() !== 'body' &&
-                                nextParent.tagName.toLowerCase() !== 'html') {
-                                targetElement = nextParent;
-                            }
-                            else {
-                                break;
-                            }
-                        }
-                        else {
-                            break;
-                        }
-                    }
-                }
-                const generalSelector = getSelectorPath(targetElement);
-                return { generalSelector };
-            });
-            return selectors || { generalSelector: '' };
-        }
-        else {
-            // When we have a list selector, we process it directly
-            const selectors = yield elementHandle.evaluate((element) => {
-                // Reuse the same helper functions as above
-                function getNonUniqueSelector(element) {
-                    let selector = element.tagName.toLowerCase();
-                    if (selector === 'td' && element.parentElement) {
-                        const siblings = Array.from(element.parentElement.children);
-                        const position = siblings.indexOf(element) + 1;
-                        return `${selector}:nth-child(${position})`;
-                    }
-                    if (element.className) {
-                        const classes = element.className.split(/\s+/).filter(Boolean);
-                        if (classes.length > 0) {
-                            const validClasses = classes.filter(cls => !cls.startsWith('!') && !cls.includes(':'));
-                            if (validClasses.length > 0) {
-                                selector += '.' + validClasses.map(cls => CSS.escape(cls)).join('.');
-                            }
-                        }
-                    }
-                    return selector;
-                }
-                function getContextPath(element) {
-                    var _a;
-                    const path = [];
-                    let current = element;
-                    let depth = 0;
-                    const MAX_DEPTH = 4;
-                    while (current && depth < MAX_DEPTH) {
-                        const rootNode = current.getRootNode();
-                        if (rootNode instanceof ShadowRoot) {
-                            path.unshift({
-                                type: 'shadow',
-                                element: current,
-                                container: rootNode,
-                                host: rootNode.host
-                            });
-                            current = rootNode.host;
-                            depth++;
-                            continue;
-                        }
-                        const ownerDocument = current.ownerDocument;
-                        const frameElement = (_a = ownerDocument === null || ownerDocument === void 0 ? void 0 : ownerDocument.defaultView) === null || _a === void 0 ? void 0 : _a.frameElement;
-                        if (frameElement) {
-                            path.unshift({
-                                type: 'iframe',
-                                element: current,
-                                container: frameElement,
-                                document: ownerDocument
-                            });
-                            current = frameElement;
-                            depth++;
-                            continue;
-                        }
-                        break;
-                    }
-                    return path;
-                }
-                function getSelectorPath(element) {
-                    if (!element)
-                        return '';
-                    // Get the complete context path
-                    const contextPath = getContextPath(element);
-                    if (contextPath.length > 0) {
-                        const selectorParts = [];
-                        contextPath.forEach((context, index) => {
-                            const containerSelector = getNonUniqueSelector(context.type === 'shadow' ? context.host : context.container);
-                            if (index === contextPath.length - 1) {
-                                const elementSelector = getNonUniqueSelector(element);
-                                const delimiter = context.type === 'shadow' ? ' >> ' : ' :>> ';
-                                selectorParts.push(`${containerSelector}${delimiter}${elementSelector}`);
-                            }
-                            else {
-                                selectorParts.push(containerSelector);
-                            }
-                        });
-                        return selectorParts.join(contextPath[0].type === 'shadow' ? ' >> ' : ' :>> ');
-                    }
-                    const elementSelector = getNonUniqueSelector(element);
-                    if (elementSelector.includes('.') && elementSelector.split('.').length > 1) {
-                        return elementSelector;
-                    }
-                    const path = [];
-                    let currentElement = element;
-                    const MAX_DEPTH = 2;
-                    let depth = 0;
-                    while (currentElement && currentElement !== document.body && depth < MAX_DEPTH) {
-                        const selector = getNonUniqueSelector(currentElement);
-                        path.unshift(selector);
-                        if (!currentElement.parentElement)
-                            break;
-                        currentElement = currentElement.parentElement;
-                        depth++;
-                    }
-                    return path.join(' > ');
-                }
-                const generalSelector = getSelectorPath(element);
-                return { generalSelector };
-            });
-            return selectors || { generalSelector: '' };
-        }
-    }
-    catch (error) {
-        console.error('Error in getNonUniqueSelectors:', error);
-        return { generalSelector: '' };
-    }
-});
-exports.generateNonUniqueSelectors = generateNonUniqueSelectors;
+exports.generateFieldSelectorFromFallback = exports.generateListFieldSelectorFromFallback = exports.generateListSelectorFromFallback = void 0;
 /**
  * Generate new list selector from fallback element (based on your reference implementation)
  * @param page - Playwright page object