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

package/dist/utils/downloadWatcher/pdfDownloadWatcher.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForDownloadComplete = waitForDownloadComplete;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const DOWNLOAD_TIMEOUT_MS = 30000;
+const POLL_INTERVAL_MS = 400;
+const STABILITY_WAIT_MS = 250;
+async function waitForDownloadComplete(downloadDir, timeoutMs = DOWNLOAD_TIMEOUT_MS) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+        if (fs_1.default.existsSync(downloadDir)) {
+            const allEntries = fs_1.default.readdirSync(downloadDir);
+            let hasActiveDownload = false;
+            const pdfFiles = [];
+            // Single pass: early exit if active download is present, stat only PDF files
+            for (const file of allEntries) {
+                const lower = file.toLowerCase();
+                if (lower.endsWith(".crdownload") || lower.endsWith(".part") || lower.endsWith(".tmp")) {
+                    hasActiveDownload = true;
+                    break;
+                }
+                if (lower.endsWith(".pdf")) {
+                    const fullPath = path_1.default.join(downloadDir, file);
+                    try {
+                        const stat = fs_1.default.statSync(fullPath);
+                        if (stat.isFile()) {
+                            pdfFiles.push({ name: file, fullPath, mtime: stat.mtimeMs, size: stat.size });
+                        }
+                    }
+                    catch {
+                        // File locked or in transition, skip for this cycle
+                    }
+                }
+            }
+            if (!hasActiveDownload && pdfFiles.length > 0) {
+                pdfFiles.sort((a, b) => b.mtime - a.mtime);
+                const latest = pdfFiles[0];
+                if (latest.size > 0) {
+                    await new Promise(res => setTimeout(res, STABILITY_WAIT_MS));
+                    try {
+                        const newStat = fs_1.default.statSync(latest.fullPath);
+                        if (newStat.size === latest.size && newStat.size > 0) {
+                            const durationSeconds = Math.max(1, Math.ceil((Date.now() - startTime) / 1000));
+                            return { file: latest, durationSeconds };
+                        }
+                    }
+                    catch {
+                        // Retry on next cycle
+                    }
+                }
+            }
+        }
+        await new Promise(res => setTimeout(res, POLL_INTERVAL_MS));
+    }
+    throw new Error(`PDF download did not complete within ${timeoutMs / 1000} seconds in directory: ${downloadDir}. ` +
+        `Ensure the download was triggered prior to VerifyPDF.`);
+}

package/dist/utils/frameWorkDetector/frameWorkDetector.d.ts

@@ -0,0 +1,6 @@
+import { frameWorkDetectorInterface } from "./frameWorkDetectorInterface.js";
+export declare class frameWorkDetector {
+    static detectFramework(driver: any): Promise<frameWorkDetectorInterface>;
+    static isAngular(driver: any): Promise<boolean>;
+    static isReact(driver: any): Promise<boolean>;
+}

package/dist/utils/frameWorkDetector/frameWorkDetector.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.frameWorkDetector = void 0;
+const logData_1 = require("../logger/logData");
+class frameWorkDetector {
+    // private static cachedFramework: frameWorkDetectorInterface | null = null;
+    static async detectFramework(driver) {
+        // if (this.cachedFramework) {
+        //     return this.cachedFramework;
+        // }
+        try {
+            const framework = await driver.execute(() => {
+                const isReact = !!(window.__REACT_DEVTOOLS_GLOBAL_HOOK__ ||
+                    [...document.querySelectorAll('*')].some(el => Object.keys(el).some(key => key.startsWith('__reactFiber$') ||
+                        key.startsWith('__reactProps$'))));
+                if (isReact)
+                    return { framework: "react", detected: true };
+                const isAngular = !!(window.ng ||
+                    document.querySelector('[ng-version], [ng-app]') ||
+                    [...document.querySelectorAll('*')].some(el => el.getAttributeNames().some(attr => attr.startsWith('_ngcontent') ||
+                        attr.startsWith('_nghost'))));
+                if (isAngular)
+                    return { framework: "angular", detected: true };
+                return { framework: "react", detected: false };
+            });
+            // this.cachedFramework = framework;
+            return framework;
+        }
+        catch (error) {
+            logData_1.logger.error(error.message);
+            return { framework: "react", detected: false };
+        }
+    }
+    static async isAngular(driver) {
+        const framework = await this.detectFramework(driver);
+        return framework.framework === "angular";
+    }
+    static async isReact(driver) {
+        const framework = await this.detectFramework(driver);
+        return framework.framework === "react";
+    }
+}
+exports.frameWorkDetector = frameWorkDetector;

package/dist/utils/frameWorkDetector/frameWorkDetectorInterface.d.ts

@@ -0,0 +1,10 @@
+declare global {
+    interface Window {
+        __REACT_DEVTOOLS_GLOBAL_HOOK__?: unknown;
+        ng?: unknown;
+    }
+}
+export interface frameWorkDetectorInterface {
+    framework: string;
+    detected: boolean;
+}

package/dist/utils/frameWorkDetector/frameWorkDetectorInterface.js

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

package/dist/utils/helpers/domSanitizer.d.ts

@@ -0,0 +1 @@
+export declare const sanitizeWebDom: (domString: string) => string;

package/dist/utils/helpers/domSanitizer.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeWebDom = void 0;
+const sanitizeWebDom = (domString) => {
+    return (domString || "")
+        .replace(/<noscript[\s\S]*?<\/noscript>/gi, "")
+        .replace(/<noscript[^>]*>/gi, "")
+        .replace(/<iframe\b/gi, "<ff-iframe")
+        .replace(/<\/iframe>/gi, "</ff-iframe>");
+};
+exports.sanitizeWebDom = sanitizeWebDom;

package/dist/utils/helpers/enterActionHelper.d.ts

@@ -0,0 +1,11 @@
+interface EnterActionResult {
+    ffNumber: number;
+    xpathPath: string;
+}
+interface EnterActionResultMob {
+    ffNumber: number;
+    xpathPath: string;
+}
+export declare const enterActionHelper: (pageDOM: string, ffNumber: string) => EnterActionResult;
+export declare function enterActionHelperMob(annotatedDom: string, num: string): EnterActionResultMob;
+export {};

package/dist/utils/helpers/enterActionHelper.js

@@ -0,0 +1,149 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enterActionHelper = void 0;
+exports.enterActionHelperMob = enterActionHelperMob;
+const jsdom_1 = require("jsdom");
+const xmldom_1 = require("@xmldom/xmldom");
+const xpathcreation_js_1 = require("./xpathcreation.js");
+const domSanitizer_js_1 = require("./domSanitizer.js");
+const logData_js_1 = require("../logger/logData.js");
+const xpath_1 = __importDefault(require("xpath"));
+const enterActionHelper = (pageDOM, ffNumber) => {
+    //  Extract numeric part
+    const match = ffNumber.match(/\d+$/);
+    let numericFF = match ? parseInt(match[0], 10) : 0;
+    const parser = new jsdom_1.JSDOM((0, domSanitizer_js_1.sanitizeWebDom)(pageDOM));
+    const doc = parser.window.document;
+    const isEditable = (el) => {
+        if (!el)
+            return false;
+        const tag = el.tagName?.toLowerCase();
+        return (["input", "textarea", "select"].includes(tag) ||
+            el.getAttribute("contenteditable") === "true");
+    };
+    const getXPath = (el) => {
+        if (!el)
+            return "";
+        const directXpath = el.getAttribute("ff-xpath");
+        if (directXpath)
+            return directXpath;
+        const ffAttr = el.getAttribute("ff-inspect");
+        if (ffAttr) {
+            return (0, xpathcreation_js_1.getWebXPathByFFIndex)(pageDOM, ffAttr).xpathPath || "";
+        }
+        return "";
+    };
+    const element = doc.querySelector(`[ff-inspect="Fire-Flink-${numericFF}"]`);
+    if (!element) {
+        const fallbackResult = (0, xpathcreation_js_1.getWebXPathByFFIndex)(pageDOM, `Fire-Flink-${numericFF}`);
+        return { ffNumber: numericFF, xpathPath: fallbackResult.xpathPath || "" };
+    }
+    let xpathPath = "";
+    //  Current element editable
+    if (isEditable(element)) {
+        xpathPath = getXPath(element);
+    }
+    else {
+        // Search editable child
+        let editableChild = null;
+        for (const child of Array.from(element.querySelectorAll("*"))) {
+            if (isEditable(child)) {
+                editableChild = child;
+                break;
+            }
+        }
+        if (editableChild) {
+            xpathPath = getXPath(editableChild);
+            const childFF = editableChild.getAttribute("ff-inspect");
+            const match = childFF?.match(/\d+$/);
+            if (match) {
+                numericFF = parseInt(match[0], 10);
+            }
+        }
+        else {
+            // Try next 10 FF elements
+            for (let offset = 1; offset <= 10; offset++) {
+                const nextNum = numericFF + offset;
+                const nextTarget = doc.querySelector(`[ff-inspect="Fire-Flink-${nextNum}"]`);
+                if (isEditable(nextTarget)) {
+                    numericFF = nextNum;
+                    xpathPath = getXPath(nextTarget);
+                    break;
+                }
+            }
+            // Final fallback
+            if (!xpathPath) {
+                xpathPath = getXPath(element);
+            }
+        }
+    }
+    if (!xpathPath) {
+        const fallbackResult = (0, xpathcreation_js_1.getWebXPathByFFIndex)(pageDOM, `Fire-Flink-${numericFF}`);
+        xpathPath = fallbackResult.xpathPath || "";
+    }
+    return {
+        ffNumber: numericFF,
+        xpathPath
+    };
+};
+exports.enterActionHelper = enterActionHelper;
+function enterActionHelperMob(annotatedDom, num) {
+    try {
+        const parser = new xmldom_1.DOMParser();
+        const match = num.match(/\d+$/);
+        const numericFF = match ? parseInt(match[0], 10) : 0;
+        const xmlDoc = parser.parseFromString(annotatedDom, "text/xml");
+        const xpathQuery = `//*[@FF-inspecter='${num}']`;
+        const nodes = xpath_1.default.select(xpathQuery, xmlDoc);
+        const element = nodes.length ? nodes[0] : null;
+        let xpathPath = "";
+        const getElementChildren = (node) => {
+            return Array.from(node?.childNodes || []).filter((n) => n.nodeType === 1);
+        };
+        if (element) {
+            const elementClass = (element.getAttribute("class") || "").toLowerCase();
+            if (elementClass.includes("edittext") ||
+                elementClass.includes("autocompletetextview") || elementClass.includes("XCUIElementTypeTextField")) {
+                const result = (0, xpathcreation_js_1.getFFIndexAndXPath)(annotatedDom, num);
+                xpathPath = result.xpathPath;
+            }
+            else {
+                const children = getElementChildren(element);
+                let editableChild = null;
+                for (const child of children) {
+                    const childClass = (child.getAttribute("class") || "").toLowerCase();
+                    if (childClass.includes("edittext") ||
+                        childClass.includes("autocompletetextview")) {
+                        editableChild = child;
+                        break;
+                    }
+                }
+                if (editableChild) {
+                    const childNum = editableChild.getAttribute("FF-inspecter")?.split("-").pop();
+                    if (childNum) {
+                        const result = (0, xpathcreation_js_1.getFFIndexAndXPath)(annotatedDom, `Fire-Flink-${childNum}`);
+                        xpathPath = result.xpathPath;
+                    }
+                }
+                else {
+                    const result = (0, xpathcreation_js_1.getFFIndexAndXPath)(annotatedDom, num);
+                    xpathPath = result.xpathPath;
+                }
+            }
+        }
+        else {
+            logData_js_1.logger.info(`No element found for ffNumber: ${numericFF} in MOB_Enter action`);
+        }
+        return {
+            ffNumber: numericFF,
+            xpathPath
+        };
+    }
+    catch (error) {
+        logData_js_1.logger.error(`Error in enterActionHelperMob: ${error}`);
+        throw error;
+    }
+}

package/dist/utils/helpers/imageUtils.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Ensures that a base64 string or Buffer has the correct data URI prefix for PNG images.
+ * @param image The base64 string or Buffer.
+ * @returns The base64 string with the `data:image/png;base64,` prefix.
+ */
+export declare function formatImageBase64(image: string | Buffer): string;

package/dist/utils/helpers/imageUtils.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatImageBase64 = formatImageBase64;
+/**
+ * Ensures that a base64 string or Buffer has the correct data URI prefix for PNG images.
+ * @param image The base64 string or Buffer.
+ * @returns The base64 string with the `data:image/png;base64,` prefix.
+ */
+function formatImageBase64(image) {
+    if (!image)
+        return "";
+    const base64 = Buffer.isBuffer(image) ? image.toString("base64") : image;
+    return base64.startsWith("data:") ? base64 : `data:image/png;base64,${base64}`;
+}

package/dist/utils/helpers/platformContext.d.ts

@@ -0,0 +1,3 @@
+import { platform } from "../../core/types/scriptTypesType.js";
+export declare function setPlatform(value: platform): void;
+export declare function getPlatform(): platform;

package/dist/utils/helpers/platformContext.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setPlatform = setPlatform;
+exports.getPlatform = getPlatform;
+let currentPlatform;
+function setPlatform(value) {
+    currentPlatform = value;
+}
+function getPlatform() {
+    return currentPlatform;
+}

package/dist/utils/helpers/platformSyntax.d.ts

@@ -0,0 +1 @@
+export declare function getPlatformSyntax(platform: string): "Web" | "Android" | "iOS";

package/dist/utils/helpers/platformSyntax.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPlatformSyntax = getPlatformSyntax;
+function getPlatformSyntax(platform) {
+    if (platform === "web") {
+        return "Web";
+    }
+    else if (platform === "android") {
+        return "Android";
+    }
+    else if (platform === "ios") {
+        return "iOS";
+    }
+    else {
+        return "Web";
+    }
+}

package/dist/utils/helpers/sameActionsHelper.d.ts

@@ -0,0 +1 @@
+export declare const sameActionHelper: Record<string, string>;

package/dist/utils/helpers/sameActionsHelper.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sameActionHelper = void 0;
+exports.sameActionHelper = {
+    MOB_Tap: "Click",
+    MOB_Enter: "SendKeys",
+    MOB_VerifyElementIsDisplayed: "VerifyElementIsDisplayed",
+    MOB_VerifyElementIsEnabled: "VerifyElementIsEnabled",
+    MOB_VerifyXLocationOfAndroidElement: "VerifyXLocationOfElement",
+    MOB_VerifyElementIsSelected: "VerifyElementIsSelected",
+    MOB_VerifyYLocationOfAndroidElement: "VerifyYLocationOfElement",
+    MOB_VerifyWidthOfElement: "VerifyWidthOfElement",
+    MOB_WaitAndClick: "WaitAndClick",
+    MOB_GetScreenshot: "GetScreenshot",
+    MOB_VerifyText: "VerifyText",
+    MOB_VerifyElementNotContainsText: "VerifyElementNotContainsText",
+    MOB_VerifyIfXAndYCoordinateOfElement: "VerifyIfXAndYCoordinateOfElement",
+    MOB_VerifyPartialAttributeValue: "VerifyPartialAttributeValue",
+    MOB_VerifyElementIsClickable: "VerifyElementIsClickable",
+    MOB_VerifyElementIsDisabled: "VerifyElementIsDisabled",
+    MOB_GetImplicitTimeOut: "GetImplicitTimeOut",
+    MOB_GetDriverInstance: "GetDriverInstance",
+    MOB_GetCurrentWindowHandle: "GetCurrentWindowHandle",
+    MOB_GetTagName: "GetTagName",
+    MOB_GetScreenshotOfElement: "GetScreenshotAs",
+    MOB_GetX: "GetXLocationOfWebElement",
+    MOB_GetListOfElementsFromLocatorTypeLocatorValue: "GetListOfElementsFromLocatorTypeLocatorValue",
+    MOB_GetLocationOfElement: "GetLocation",
+    MOB_GetY: "GetYLocationOfWebElement",
+    MOB_GetRect: "GetRect",
+    MOB_GetText: "GetText",
+    MOB_GetSize: "GetSize",
+    MOB_GetAttribute: "GetAttribute",
+    MOB_Clear: "Clear",
+    MOB_DoubleTap: "DoubleClick",
+    MOB_TapNTimes: "ClickNTimes",
+    MOB_VerifyPartialText: "VerifyPartialText",
+    MOB_VerifyAttributeValue: "VerifyAttributeValue",
+    MOB_ClearThenEnterInput: "ClearThenEnterInput",
+    MOB_EnterDataAndPressKey: "EnterDataAndPressKey",
+    MOB_WaitAndSendKeys: "WaitAndSendKeys",
+    MOB_VerifyHeightOfElement: "VerifyHeightOfWebElement",
+    MOB_WaitTillPresenceOfElement: "WaitTillPresenceOfElement",
+    MOB_WaitTillPresenceOfAllElements: "WaitTillPresenceOfAllElements",
+    MOB_WaitTillAttributeOfElementIsString: "WaitTillAttributeOfElementIsString",
+    MOB_EnterUrl: "EnterUrl",
+    MOB_SetClipBoardText: "SetClipBoardText",
+    MOB_PressAnyKeyNTimes: "PressAnyKeyNTimes",
+    MOB_FindElements: "FindElements",
+    MOB_WaitTillElementIsClickable: "WaitTillElementIsClickable",
+    MOB_CheckIfElementIsDisplayed: "CheckIfElementIsDisplayed",
+    MOB_PressAnyKey: "PressAnyKey",
+    MOB_WaitTillElementHasText: "WaitTillElementHasText",
+    MOB_WaitTillElementContainsText: "WaitTillElementContainsText",
+    MOB_PressEnterKey: "PressEnterKey",
+    MOB_VerifyElementIsNotDisplayed: "VerifyElementIsNotDisplayed",
+    MOB_VerifyElementIsDisplayedInSpecifiedTime: "VerifyElementIsDisplayedInSpecifiedTime",
+    MOB_VerifyElementIsEnabledInSpecifiedTime: "VerifyElementIsEnabledInSpecifiedTime",
+    MOB_VerifyElementIsSelectedInSpecifiedTime: "VerifyElementIsSelectedInSpecifiedTime"
+};

package/dist/utils/helpers/saveStepInputData.d.ts

@@ -0,0 +1,8 @@
+export interface StepInputDataArgs {
+    stepsInputData?: any[];
+    stepIndex?: any;
+    currentStep?: string;
+    manualStep?: string;
+    returnTypeVariableName?: string;
+}
+export declare function saveStepInputData(args: StepInputDataArgs | undefined, value: any): void;

package/dist/utils/helpers/saveStepInputData.js

@@ -0,0 +1,115 @@
+"use strict";
+// import { logger } from "../logger/logData.js";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveStepInputData = saveStepInputData;
+function saveStepInputData(args, value) {
+    if (!args || !args.stepsInputData || !Array.isArray(args.stepsInputData)) {
+        return;
+    }
+    const rawStepIndex = args.stepIndex !== undefined
+        ? args.stepIndex
+        : args.stepsInputData?.currentStepIndex;
+    const currentStep = args.currentStep || "";
+    const manualStep = args.manualStep ||
+        args.stepsInputData?.currentManualStep ||
+        currentStep;
+    const isOneToMany = typeof rawStepIndex === "string" && rawStepIndex.includes(".");
+    const baseStepIndex = isOneToMany
+        ? Number(rawStepIndex.split(".")[0])
+        : typeof rawStepIndex === "number"
+            ? rawStepIndex
+            : Number(rawStepIndex) || rawStepIndex;
+    let inputText;
+    if (value === null || value === undefined) {
+        inputText = "";
+    }
+    else if (typeof value === "object") {
+        try {
+            inputText = JSON.stringify(value);
+        }
+        catch {
+            inputText = String(value);
+        }
+    }
+    else {
+        inputText = String(value);
+    }
+    if (isOneToMany) {
+        const existingEntry = args.stepsInputData.find((entry) => entry && entry.stepindex === baseStepIndex);
+        if (existingEntry) {
+            if (manualStep && existingEntry.step !== manualStep) {
+                existingEntry.step = manualStep;
+            }
+            if (!Array.isArray(existingEntry.subSteps)) {
+                existingEntry.subSteps = [];
+            }
+            const alreadyRecorded = existingEntry.subSteps.some((s) => s.stepindex === String(rawStepIndex) &&
+                s.step === currentStep &&
+                s.value !== undefined);
+            if (alreadyRecorded) {
+                return;
+            }
+            existingEntry.subSteps.push({
+                stepindex: String(rawStepIndex),
+                step: currentStep,
+                inputText,
+                value,
+                ...(args.returnTypeVariableName ? { variableName: args.returnTypeVariableName } : {}),
+            });
+            // Do NOT store inputText or value on the parent object for one-to-many steps
+            delete existingEntry.inputText;
+            delete existingEntry.value;
+            // try {
+            //     logger?.info(
+            //         `[saveStepInputData] Appended sub-step ${rawStepIndex} to step ${baseStepIndex}:`,
+            //         existingEntry
+            //     )?.catch(() => { });
+            // } catch { }
+            return;
+        }
+        // First sub-step for this baseStepIndex
+        const record = {
+            stepindex: baseStepIndex,
+            step: manualStep,
+            subSteps: [
+                {
+                    stepindex: String(rawStepIndex),
+                    step: currentStep,
+                    inputText,
+                    value,
+                    ...(args.returnTypeVariableName ? { variableName: args.returnTypeVariableName } : {}),
+                },
+            ],
+        };
+        args.stepsInputData.push(record);
+        // try {
+        //     logger?.info(
+        //         `[saveStepInputData] Stored sub-step ${rawStepIndex} in step ${baseStepIndex}:`,
+        //         record
+        //     )?.catch(() => { });
+        // } catch { }
+        return;
+    }
+    // Normal 1-to-1 step
+    const isAlreadyRecorded = args.stepsInputData.some((entry) => entry &&
+        entry.stepindex === baseStepIndex &&
+        entry.step === manualStep &&
+        entry.value !== undefined);
+    if (isAlreadyRecorded) {
+        return;
+    }
+    const record = {
+        stepindex: baseStepIndex,
+        step: manualStep,
+        inputText,
+        value,
+        ...(args.returnTypeVariableName ? { variableName: args.returnTypeVariableName } : {}),
+    };
+    args.stepsInputData.push(record);
+    // try {
+    //     logger?.info(
+    //         `[saveStepInputData] Stored step ${baseStepIndex}:`,
+    //         record
+    //     )?.catch(() => { });
+    // } catch { }
+}

package/dist/utils/helpers/uploadPathHelper.d.ts

@@ -0,0 +1 @@
+export declare const resolveUploadPath: (rawPath: string) => string;

package/dist/utils/helpers/uploadPathHelper.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveUploadPath = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const resolveUploadPath = (rawPath) => {
+    const filePath = node_path_1.default.normalize(rawPath.trim().replace(/^["']|["']$/g, ""));
+    if (!node_fs_1.default.existsSync(filePath)) {
+        throw new Error(`Upload file not found: "${filePath}"`);
+    }
+    if (!node_fs_1.default.statSync(filePath).isFile()) {
+        throw new Error(`Upload path is not a file: "${filePath}"`);
+    }
+    return filePath;
+};
+exports.resolveUploadPath = resolveUploadPath;

package/dist/utils/helpers/xpathcreation.d.ts

@@ -0,0 +1,10 @@
+interface FFResult {
+    xpathPath: string;
+    ffInspector?: string;
+}
+export interface IWebXPathResult {
+    xpathPath: string;
+}
+export declare function getWebXPathByFFIndex(annotatedDom: string, fireflinkIndex: string): IWebXPathResult;
+export declare function getFFIndexAndXPath(annotatedDom: string, fireflinkIndex: string, platform?: string): FFResult;
+export {};