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

package/dist/utils/JsPathGenerator/generateJsPath.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToCssSelector = convertToCssSelector;
+exports.generateJsPath = generateJsPath;
+//Converts XPath or FireFlink selector fragment to a clean CSS selector.
+function convertToCssSelector(pathFragment) {
+    let s = pathFragment.trim().replace(/^\/+/, "");
+    // Remove redundant html/body prefix for top-level selectors
+    s = s.replace(/^html(\[\d+\])?\/body(\[\d+\])?\//i, "");
+    // Convert tag[n] -> tag or tag:nth-of-type(n)
+    s = s.replace(/([a-zA-Z0-9_-]+)\[(\d+)\]/g, (_, tag, index) => {
+        return index === "1" ? tag : `${tag}:nth-of-type(${index})`;
+    });
+    s = s.replace(/\//g, " > ");
+    return s;
+}
+//jspath generation
+function generateJsPath(selector, finalSelectorOverride) {
+    if (typeof selector !== 'string' || selector.trim().length === 0) {
+        throw new TypeError('generateJsPath: "selector" must be a non-empty string.');
+    }
+    const SHADOW_TOKEN = '/shadow/';
+    const trimmedSelector = selector.trim();
+    if (trimmedSelector.startsWith(SHADOW_TOKEN)) {
+        throw new Error('generateJsPath: selector cannot start with "/shadow/" — a host element path is required before it.');
+    }
+    if (trimmedSelector.endsWith(SHADOW_TOKEN)) {
+        throw new Error('generateJsPath: selector cannot end with "/shadow/" — a path is required after it.');
+    }
+    const rawChunks = trimmedSelector
+        .split(SHADOW_TOKEN)
+        .map((c) => c.trim())
+        .filter((c) => c.length > 0);
+    if (rawChunks.length === 0) {
+        throw new Error('generateJsPath: no valid path segments found in selector.');
+    }
+    const cssChunks = rawChunks.map((chunk) => xpathChunkToCss(chunk));
+    if (typeof finalSelectorOverride === 'string' && finalSelectorOverride.trim().length > 0) {
+        cssChunks[cssChunks.length - 1] = finalSelectorOverride.trim();
+    }
+    let jsPath = `document.querySelector(${toQuotedSelector(cssChunks[0])})`;
+    for (let i = 1; i < cssChunks.length; i++) {
+        jsPath += `.shadowRoot.querySelector(${toQuotedSelector(cssChunks[i])})`;
+    }
+    return jsPath;
+}
+//Helpers
+function toQuotedSelector(cssSelector) {
+    const cleanSelector = cssSelector.replace(/\[([\w\-:]+)\s*=\s*['"]([^'"]+)['"]\]/g, '[$1=$2]');
+    return `'${cleanSelector}'`;
+}
+//Nodes
+function xpathChunkToCss(chunk) {
+    const { nodes, combinators } = tokenizeXPath(chunk);
+    if (nodes.length === 0) {
+        throw new Error(`generateJsPath: unable to parse path segment "${chunk}".`);
+    }
+    let css = xpathNodeToCss(nodes[0]);
+    for (let i = 1; i < nodes.length; i++) {
+        const combinator = combinators[i] === 'descendant' ? ' ' : ' > ';
+        css += combinator + xpathNodeToCss(nodes[i]);
+    }
+    return css;
+}
+/**
+ * Splits an XPath chunk into node segments plus the axis combinator
+ * ('child' | 'descendant') that precedes each node. Bracket contents are
+ * treated as opaque so a `/` inside a predicate does not cause an
+ */
+function tokenizeXPath(path) {
+    const nodes = [];
+    const combinators = [];
+    let depth = 0;
+    let current = '';
+    let pendingCombinator;
+    let i = 0;
+    const pushCurrent = () => {
+        const trimmed = current.trim();
+        if (trimmed.length > 0 && trimmed !== '.') {
+            nodes.push(trimmed);
+            combinators.push(pendingCombinator);
+        }
+        current = '';
+    };
+    while (i < path.length) {
+        const ch = path[i];
+        if (ch === '[')
+            depth++;
+        if (ch === ']')
+            depth--;
+        if (ch === '/' && depth === 0) {
+            pushCurrent();
+            if (path[i + 1] === '/') {
+                pendingCombinator = 'descendant';
+                i += 2;
+                continue;
+            }
+            else {
+                pendingCombinator = 'child';
+                i += 1;
+                continue;
+            }
+        }
+        current += ch;
+        i += 1;
+    }
+    pushCurrent();
+    return { nodes, combinators };
+}
+/**
+ * Converts a single XPath node (e.g. `div[1]`, `input[@id='x']`,
+ * `span[contains(@class,'icon')]`) into an equivalent CSS selector
+ * fragment, always preserving positional predicates as `:nth-of-type()`.
+ */
+function xpathNodeToCss(node) {
+    const match = node.match(/^(\*|[A-Za-z_][\w\-.:]*)((?:\[[^\]]*\])*)$/);
+    // Fallback: if the node doesn't match the expected shape, pass it
+    // through as-is rather than silently dropping information.
+    if (!match) {
+        return node;
+    }
+    const tag = match[1];
+    const predicatesStr = match[2] || '';
+    const predicates = predicatesStr.match(/\[[^\]]*\]/g) || [];
+    const attrSelectors = [];
+    let nthIndex = null;
+    for (const pred of predicates) {
+        const inner = pred.slice(1, -1).trim();
+        // [@attr='value'] or [@attr="value"]
+        const attrEqMatch = inner.match(/^@([\w\-:]+)\s*=\s*(['"])(.*)\2$/);
+        // contains(@attr, 'value')
+        const containsMatch = inner.match(/^contains\(\s*@([\w\-:]+)\s*,\s*(['"])(.*)\2\s*\)$/i);
+        // position()=n
+        const positionMatch = inner.match(/^position\(\)\s*=\s*(\d+)$/i);
+        if (attrEqMatch) {
+            const attrName = attrEqMatch[1];
+            const attrValue = escapeCssString(attrEqMatch[3]);
+            attrSelectors.push(`[${attrName}='${attrValue}']`);
+        }
+        else if (containsMatch) {
+            const attrName = containsMatch[1];
+            const attrValue = escapeCssString(containsMatch[3]);
+            attrSelectors.push(`[${attrName}*='${attrValue}']`);
+        }
+        else if (/^\d+$/.test(inner)) {
+            nthIndex = inner;
+        }
+        else if (positionMatch) {
+            nthIndex = positionMatch[1];
+        }
+        else if (/^last\(\)$/i.test(inner)) {
+            nthIndex = 'last';
+        }
+        // Unrecognized predicates (e.g. text()-based) are skipped: they have
+        // no reliable CSS equivalent and are not safe to guess at.
+    }
+    let css = tag;
+    css += attrSelectors.join('');
+    if (nthIndex === 'last') {
+        css += ':nth-last-of-type(1)';
+    }
+    else if (nthIndex) {
+        css += `:nth-of-type(${nthIndex})`;
+    }
+    return css;
+}
+function escapeCssString(value) {
+    return value.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+}

package/dist/utils/alertPopup/isAlertPresent.d.ts

@@ -0,0 +1,2 @@
+import { IAlertChecker } from "./isAlertPresentInterface";
+export declare const isAlertPresent: IAlertChecker;

package/dist/utils/alertPopup/isAlertPresent.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAlertPresent = void 0;
+const isAlertPresent = async (driver, timeout = 0) => {
+    try {
+        if (!driver)
+            return false;
+        await driver.waitUntil(async () => await driver.isAlertOpen(), { timeout });
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+exports.isAlertPresent = isAlertPresent;

package/dist/utils/alertPopup/isAlertPresentInterface.d.ts

@@ -0,0 +1,3 @@
+export interface IAlertChecker {
+    (driver: WebdriverIO.Browser, timeout?: number): Promise<boolean>;
+}

package/dist/utils/alertPopup/isAlertPresentInterface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/browserCap/capability.d.ts

@@ -0,0 +1,27 @@
+import { BrowserId } from "../../core/types/browserType.js";
+export declare function getCapabilities(browserName: BrowserId, path?: string, profile?: string, customCaps?: string[]): {
+    browserName: string;
+    "wdio:enforceWebDriverClassic": boolean;
+    "goog:chromeOptions": {
+        args: string[];
+        prefs: Record<string, any>;
+    };
+} | {
+    browserName: string;
+    "wdio:enforceWebDriverClassic": boolean;
+    acceptInsecureCerts: boolean;
+    "moz:firefoxOptions": {
+        args: string[];
+        prefs: Record<string, any>;
+    };
+} | {
+    browserName: string;
+    "wdio:enforceWebDriverClassic": boolean;
+    "ms:edgeOptions": {
+        args: string[];
+        prefs: Record<string, any>;
+    };
+} | {
+    browserName: string;
+    "wdio:enforceWebDriverClassic": boolean;
+};

package/dist/utils/browserCap/capability.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCapabilities = getCapabilities;
+const logData_js_1 = require("../logger/logData.js");
+function getCapabilities(browserName, path, profile, customCaps = []) {
+    const isLinux = process.platform === 'linux';
+    const caps = customCaps.map(c => c.toLowerCase());
+    const hasCap = (name) => caps.includes(name.toLowerCase());
+    const getChromiumArgs = (isEdge) => {
+        const args = [
+            ...(path ? [`--user-data-dir=${path}`] : []),
+            ...(profile ? [`--profile-directory=${profile}`] : []),
+            ...(isLinux ? ['--ozone-platform=x11'] : []),
+        ];
+        if (hasCap("headless"))
+            args.push('--headless=new');
+        if (hasCap("incognito"))
+            args.push(isEdge ? '--inprivate' : '--incognito');
+        if (hasCap("ignoreCertificates"))
+            args.push('--ignore-certificate-errors');
+        if (hasCap("startMaximized"))
+            args.push('--start-maximized');
+        if (hasCap("disableGpu"))
+            args.push('--disable-gpu');
+        if (hasCap("disableNotifications"))
+            args.push('--disable-notifications');
+        if (hasCap("disableExtensions"))
+            args.push('--disable-extensions');
+        if (hasCap("disablePopups"))
+            args.push('--disable-popup-blocking');
+        if (hasCap("muteAudio"))
+            args.push('--mute-audio');
+        if (hasCap("noSandbox"))
+            args.push('--no-sandbox', '--disable-dev-shm-usage');
+        if (hasCap("disableWebSecurity"))
+            args.push('--disable-web-security');
+        if (hasCap("disableLocalNetwork"))
+            args.push('--disable-local-network-saving-common-name');
+        return args;
+    };
+    const getChromiumPrefs = () => {
+        const prefs = {};
+        prefs["download.default_directory"] = logData_js_1.downloadDir;
+        prefs["download.prompt_for_download"] = false;
+        prefs["download.directory_upgrade"] = true;
+        prefs["safebrowsing.enabled"] = true;
+        if (hasCap("geolocation"))
+            prefs["profile.default_content_setting_values.geolocation"] = 2;
+        if (hasCap("camera"))
+            prefs["profile.default_content_setting_values.media_stream_camera"] = 2;
+        if (hasCap("microphone"))
+            prefs["profile.default_content_setting_values.media_stream_mic"] = 2;
+        if (hasCap("popups") || hasCap("disablePopups"))
+            prefs["profile.default_content_settings.popups"] = 0;
+        if (hasCap("passwordManager")) {
+            prefs["credentials_enable_service"] = false;
+            prefs["profile.password_manager_enabled"] = false;
+        }
+        return prefs;
+    };
+    const getFirefoxOptions = () => {
+        const args = [
+            ...(path ? ['-profile', path] : []),
+            ...(isLinux ? ['--ozone-platform=x11'] : []),
+        ];
+        if (hasCap("headless"))
+            args.push('-headless');
+        if (hasCap("incognito"))
+            args.push('-private');
+        if (hasCap("disableGpu"))
+            args.push('--disable-gpu');
+        if (hasCap("disableExtensions"))
+            args.push('-safe-mode');
+        const prefs = {};
+        // Always redirect downloads to session/tempFile so VerifyPDF can reliably find them
+        prefs["browser.download.dir"] = logData_js_1.downloadDir;
+        prefs["browser.download.folderList"] = 2; // 2 = use custom download dir
+        prefs["browser.download.useDownloadDir"] = true;
+        prefs["browser.helperApps.neverAsk.saveToDisk"] = "application/pdf,application/octet-stream";
+        prefs["pdfjs.disabled"] = true; // prevent Firefox from opening PDFs inline
+        if (hasCap("disableNotifications") || hasCap("notifications"))
+            prefs["dom.webnotifications.enabled"] = false;
+        if (hasCap("disablePopups") || hasCap("popups"))
+            prefs["dom.disable_open_during_load"] = false;
+        if (hasCap("muteAudio"))
+            prefs["media.volume_scale"] = "0.0";
+        if (hasCap("disableWebSecurity"))
+            prefs["security.fileuri.strict_origin_policy"] = false;
+        if (hasCap("geolocation"))
+            prefs["geo.enabled"] = false;
+        if (hasCap("camera"))
+            prefs["media.navigator.permission.disabled"] = true;
+        if (hasCap("microphone"))
+            prefs["media.peerconnection.enabled"] = false;
+        if (hasCap("passwordManager"))
+            prefs["signon.rememberSignons"] = false;
+        return { args, prefs };
+    };
+    const firefoxOptions = getFirefoxOptions();
+    const browserCapabilities = {
+        chrome: {
+            browserName: 'chrome',
+            "wdio:enforceWebDriverClassic": true,
+            "goog:chromeOptions": {
+                args: getChromiumArgs(false),
+                prefs: getChromiumPrefs()
+            },
+        },
+        firefox: {
+            browserName: 'firefox',
+            "wdio:enforceWebDriverClassic": true,
+            acceptInsecureCerts: hasCap("ignoreCertificates"),
+            "moz:firefoxOptions": {
+                args: firefoxOptions.args,
+                prefs: firefoxOptions.prefs
+            },
+        },
+        edge: {
+            browserName: 'MicrosoftEdge',
+            "wdio:enforceWebDriverClassic": true,
+            "ms:edgeOptions": {
+                args: getChromiumArgs(true),
+                prefs: getChromiumPrefs()
+            },
+        },
+        safari: {
+            browserName: 'safari',
+            "wdio:enforceWebDriverClassic": true
+        }
+    };
+    return browserCapabilities[browserName];
+}

package/dist/utils/browserCap/systemCapabilities.d.ts

@@ -0,0 +1,6 @@
+export declare const systemCapability: {
+    chrome: string[];
+    edge: string[];
+    firefox: string[];
+    safari: never[];
+};

package/dist/utils/browserCap/systemCapabilities.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.systemCapability = void 0;
+exports.systemCapability = {
+    chrome: [
+        "download.default_directory",
+        "download.prompt_for_download",
+        "download.directory_upgrade",
+        "safebrowsing.enabled"
+    ],
+    edge: [
+        "download.default_directory",
+        "download.prompt_for_download",
+        "download.directory_upgrade",
+        "safebrowsing.enabled"
+    ],
+    firefox: [
+        "browser.download.dir",
+        "browser.download.folderList",
+        "browser.download.useDownloadDir",
+        "browser.helperApps.neverAsk.saveToDisk",
+        "pdfjs.disabled"
+    ],
+    safari: []
+};

package/dist/utils/cloudConfig/cloudPath.d.ts

@@ -0,0 +1,2 @@
+import { CloudConfig } from "../../core/interfaces/cloudConfigInterface";
+export declare function getPath(cloudConfig: CloudConfig): string;

package/dist/utils/cloudConfig/cloudPath.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPath = getPath;
+function getPath(cloudConfig) {
+    return `/${cloudConfig.path}?accessKey=${cloudConfig.accessKey}&licenseId=${cloudConfig.licenseId}&projectName=${cloudConfig.projectName}/`;
+}

package/dist/utils/crossOrigin/crossOriginHelper.d.ts

@@ -0,0 +1,5 @@
+import { RawDomInjectionResult, ICombineDomResult, InjectIframeFunction, ICrossOriginElementInfo } from "./crossOriginInterface.js";
+export declare function markCrossOriginElements(iframeDom: string): string;
+export declare function combineDom(result: ICombineDomResult): string;
+export declare function processCrossOriginIframes(browser: WebdriverIO.Browser, parentResult: RawDomInjectionResult, injectIframeFn: InjectIframeFunction): Promise<string>;
+export declare function findCrossOriginIframeForElement(pageDom: string, fireflinkIndex: string): ICrossOriginElementInfo | null;

package/dist/utils/crossOrigin/crossOriginHelper.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.markCrossOriginElements = markCrossOriginElements;
+exports.combineDom = combineDom;
+exports.processCrossOriginIframes = processCrossOriginIframes;
+exports.findCrossOriginIframeForElement = findCrossOriginIframeForElement;
+const logData_js_1 = require("../logger/logData.js");
+function markCrossOriginElements(iframeDom) {
+    return iframeDom.replace(/<([a-zA-Z][^<>]*)>/g, (match, p1) => {
+        if (p1.startsWith("!") || p1.startsWith("?")) {
+            return match;
+        }
+        if (!match.includes("ff-cross-origin=")) {
+            return match.slice(0, -1) + ' ff-cross-origin="true">';
+        }
+        return match;
+    });
+}
+function combineDom(result) {
+    const parentDom = result.parent.dom;
+    let combinedDom = parentDom;
+    for (const iframeInfo of result.crossOriginIframes) {
+        let iframeDom = iframeInfo.result?.dom;
+        if (!iframeDom) {
+            continue;
+        }
+        iframeDom = markCrossOriginElements(iframeDom);
+        const xpath = iframeInfo.xpath;
+        if (!xpath) {
+            continue;
+        }
+        const marker = `ff-xpath="${xpath}"`;
+        const index = combinedDom.indexOf(marker);
+        if (index === -1) {
+            continue;
+        }
+        const iframeStart = combinedDom.lastIndexOf("<iframe", index);
+        if (iframeStart === -1) {
+            continue;
+        }
+        const iframeEnd = combinedDom.indexOf(">", index);
+        if (iframeEnd === -1) {
+            continue;
+        }
+        const insertPosition = iframeEnd + 1;
+        combinedDom =
+            combinedDom.slice(0, insertPosition) +
+                "\n<!-- CROSS-ORIGIN IFRAME DOM START -->\n" +
+                iframeDom +
+                "\n<!-- CROSS-ORIGIN IFRAME DOM END -->\n" +
+                combinedDom.slice(insertPosition);
+    }
+    return combinedDom;
+}
+async function processCrossOriginIframes(browser, parentResult, injectIframeFn) {
+    if (!parentResult || !parentResult.dom) {
+        return parentResult?.dom || "";
+    }
+    const crossOriginIframes = parentResult.crossOriginIframes || [];
+    if (!crossOriginIframes.length) {
+        return parentResult.dom;
+    }
+    let nextIndex = parentResult.nextNodeIndex || 0;
+    const iframeResults = [];
+    for (const iframeInfo of crossOriginIframes) {
+        const title = iframeInfo.title;
+        const src = iframeInfo.src;
+        const xpath = iframeInfo.xpath;
+        const name = iframeInfo.name;
+        try {
+            await browser.switchFrame(null);
+            let iframeElement = null;
+            if (title) {
+                try {
+                    const el = await browser.$(`//iframe[@title='${title}']`);
+                    if (await el.isExisting())
+                        iframeElement = el;
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+            if (!iframeElement && src) {
+                try {
+                    const el = await browser.$(`//iframe[contains(@src,'${src}')]`);
+                    if (await el.isExisting())
+                        iframeElement = el;
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+            if (!iframeElement && name) {
+                try {
+                    const el = await browser.$(`//iframe[@name='${name}']`);
+                    if (await el.isExisting())
+                        iframeElement = el;
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+            if (!iframeElement && xpath) {
+                try {
+                    const el = await browser.$(xpath);
+                    if (await el.isExisting())
+                        iframeElement = el;
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+            if (!iframeElement) {
+                throw new Error(`Unable to locate cross-origin iframe with title=${title}, src=${src}`);
+            }
+            await browser.switchFrame(iframeElement);
+            const iframeResult = await injectIframeFn(browser, nextIndex);
+            if (iframeResult && typeof iframeResult.nextNodeIndex === "number") {
+                nextIndex = iframeResult.nextNodeIndex;
+            }
+            iframeResults.push({
+                title,
+                src,
+                name,
+                xpath,
+                result: iframeResult
+            });
+        }
+        catch (e) {
+            iframeResults.push({
+                title,
+                src,
+                name,
+                xpath,
+                error: e.message || String(e)
+            });
+            logData_js_1.logger.error(`Failed iframe: ${title || src || xpath} | ${e.message || String(e)}`);
+        }
+        finally {
+            try {
+                await browser.switchFrame(null);
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    }
+    return combineDom({
+        parent: parentResult,
+        crossOriginIframes: iframeResults
+    });
+}
+function findCrossOriginIframeForElement(pageDom, fireflinkIndex) {
+    if (!pageDom || !fireflinkIndex)
+        return null;
+    const escaped = fireflinkIndex.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const marker = new RegExp(`<[^>]+\\bff-inspect\\s*=\\s*["']${escaped}["'][^>]*>`, "i");
+    const match = marker.exec(pageDom);
+    if (!match)
+        return null;
+    const tag = match[0];
+    const isCrossOrigin = /ff-cross-origin\s*=\s*["']true["']/i.test(tag);
+    if (!isCrossOrigin)
+        return null;
+    const elemIndex = match.index;
+    const iframeStart = pageDom.lastIndexOf("<iframe", elemIndex);
+    if (iframeStart === -1)
+        return null;
+    const iframeTagEnd = pageDom.indexOf(">", iframeStart);
+    if (iframeTagEnd === -1 || iframeTagEnd > elemIndex)
+        return null;
+    const iframeTag = pageDom.substring(iframeStart, iframeTagEnd + 1);
+    const getAttr = (name) => {
+        const attrMatch = new RegExp(`\\b${name}\\s*=\\s*["']([^"']*)["']`, "i").exec(iframeTag);
+        return attrMatch ? attrMatch[1] : undefined;
+    };
+    const frameMeta = {
+        id: getAttr("id"),
+        name: getAttr("name"),
+        title: getAttr("title"),
+        aria: getAttr("aria-label"),
+        src: getAttr("src"),
+    };
+    const blockStart = pageDom.indexOf("<!-- CROSS-ORIGIN IFRAME DOM START -->", iframeTagEnd);
+    const blockEnd = pageDom.indexOf("<!-- CROSS-ORIGIN IFRAME DOM END -->", blockStart);
+    let iframeDom;
+    if (blockStart !== -1 && blockEnd !== -1 && elemIndex > blockStart && elemIndex < blockEnd) {
+        iframeDom = pageDom.substring(blockStart + "<!-- CROSS-ORIGIN IFRAME DOM START -->".length, blockEnd).trim();
+    }
+    return {
+        isCrossOrigin: true,
+        frameMeta,
+        iframeDom,
+    };
+}

package/dist/utils/crossOrigin/crossOriginInterface.d.ts

@@ -0,0 +1,43 @@
+import { FrameMeta } from "../iframesExtraction/iframeInterface.js";
+export interface CrossOriginIframeInfo {
+    xpath?: string | null;
+    src?: string | null;
+    title?: string | null;
+    name?: string | null;
+    result?: RawDomInjectionResult;
+    error?: string;
+}
+export interface RawDomInjectionResult {
+    dom: string;
+    crossOriginIframes: CrossOriginIframeInfo[];
+    nextNodeIndex: number;
+}
+export interface ICombineDomResult {
+    parent: {
+        dom: string;
+        [key: string]: any;
+    };
+    crossOriginIframes: Array<{
+        xpath?: string | null;
+        result?: {
+            dom?: string;
+        };
+        [key: string]: any;
+    }>;
+}
+export type InjectIframeFunction = (browser: WebdriverIO.Browser, startIndex: number) => Promise<RawDomInjectionResult>;
+export interface ICrossOriginElementInfo {
+    isCrossOrigin: boolean;
+    frameMeta?: FrameMeta;
+    iframeDom?: string;
+}
+export type MarkCrossOriginElementsFn = (iframeDom: string) => string;
+export type CombineDomFn = (result: ICombineDomResult) => string;
+export type ProcessCrossOriginIframesFn = (browser: WebdriverIO.Browser, parentResult: RawDomInjectionResult, injectIframeFn: InjectIframeFunction) => Promise<string>;
+export type FindCrossOriginIframeForElementFn = (pageDom: string, fireflinkIndex: string) => ICrossOriginElementInfo | null;
+export interface ICrossOriginHelper {
+    markCrossOriginElements: MarkCrossOriginElementsFn;
+    combineDom: CombineDomFn;
+    processCrossOriginIframes: ProcessCrossOriginIframesFn;
+    findCrossOriginIframeForElement: FindCrossOriginIframeForElementFn;
+}

package/dist/utils/crossOrigin/crossOriginInterface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/downloadWatcher/pdfDownloadWatcher.d.ts

@@ -0,0 +1,8 @@
+export declare function waitForDownloadComplete(downloadDir: string, timeoutMs?: number): Promise<{
+    file: {
+        name: string;
+        fullPath: string;
+        mtime: number;
+    };
+    durationSeconds: number;
+}>;