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

package/dist/automation/actions/interaction/alert/clickCancelOnAlertPopup.d.ts

@@ -0,0 +1,2 @@
+import { clickCancelOnAlertInterface } from "../../interface/alertActionInterface.js";
+export declare function clickCancelOnAlertPopup(args: clickCancelOnAlertInterface): Promise<void>;

package/dist/automation/actions/interaction/alert/clickCancelOnAlertPopup.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clickCancelOnAlertPopup = clickCancelOnAlertPopup;
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
+async function clickCancelOnAlertPopup(args) {
+    try {
+        await args.driver.dismissAlert();
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: "ClickCancelOnAlertPopup",
+        });
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("ClickCancelOnAlertPopup");
+        throw new Error("Click Cancel on alert popup failed", { cause: error });
+    }
+}

package/dist/automation/actions/interaction/alert/clickOkOnAlertPopup.d.ts

@@ -0,0 +1,2 @@
+import { clickOkOnAlertInterface } from "../../interface/alertActionInterface.js";
+export declare function clickOkOnAlertPopup(args: clickOkOnAlertInterface): Promise<void>;

package/dist/automation/actions/interaction/alert/clickOkOnAlertPopup.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clickOkOnAlertPopup = clickOkOnAlertPopup;
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
+async function clickOkOnAlertPopup(args) {
+    try {
+        await args.driver.acceptAlert();
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: "ClickOkOnAlertPopup",
+        });
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("ClickOkOnAlertPopup");
+        throw new Error("Click OK on alert popup failed", { cause: error });
+    }
+}

package/dist/automation/actions/interaction/alert/enterDataToAlert.d.ts

@@ -0,0 +1,2 @@
+import { enterDataToAlertInterface } from "../../interface/alertActionInterface.js";
+export declare function enterDataToAlert(args: enterDataToAlertInterface): Promise<void>;

package/dist/automation/actions/interaction/alert/enterDataToAlert.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enterDataToAlert = enterDataToAlert;
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
+const saveStepInputData_js_1 = require("../../../../utils/helpers/saveStepInputData.js");
+async function enterDataToAlert(args) {
+    try {
+        await args.driver.sendAlertText(args.value);
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: "EnterDataToAlert",
+            stepInputs: [args.variableName ? `variable:${args.variableName}` : args.value],
+        });
+        (0, saveStepInputData_js_1.saveStepInputData)(args, args.value);
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("EnterDataToAlert");
+        throw new Error("Enter data to alert failed", { cause: error });
+    }
+}

package/dist/automation/actions/interaction/alert/getTextPresentOnAlertPopup.d.ts

@@ -0,0 +1,2 @@
+import { getTextPresentOnAlertPopupInterface } from "../../interface/alertActionInterface.js";
+export declare function getTextPresentOnAlertPopup(args: getTextPresentOnAlertPopupInterface): Promise<void>;

package/dist/automation/actions/interaction/alert/getTextPresentOnAlertPopup.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTextPresentOnAlertPopup = getTextPresentOnAlertPopup;
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
+const saveStepInputData_js_1 = require("../../../../utils/helpers/saveStepInputData.js");
+async function getTextPresentOnAlertPopup(args) {
+    try {
+        const text = await args.driver.getAlertText();
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: "GetTextPresentOnAlertPopup",
+            returnTypeVariableName: args.returnTypeVariableName
+        });
+        (0, saveStepInputData_js_1.saveStepInputData)(args, text);
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("GetTextPresentOnAlertPopup");
+        throw new Error("Get Text Present On Alert Popup failed", { cause: error });
+    }
+}

package/dist/automation/actions/interaction/alert/verifyAlertPopUpMessageContainsString.d.ts

@@ -0,0 +1,2 @@
+import { verifyAlertMessageInterface } from "../../interface/alertActionInterface.js";
+export declare function verifyAlertPopUpMessageContainsString(args: verifyAlertMessageInterface): Promise<void>;

package/dist/automation/actions/interaction/alert/verifyAlertPopUpMessageContainsString.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyAlertPopUpMessageContainsString = verifyAlertPopUpMessageContainsString;
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
+async function verifyAlertPopUpMessageContainsString(args) {
+    try {
+        const alertText = await args.driver.getAlertText();
+        if (alertText.toLowerCase().includes(args.value.toLowerCase())) {
+            (0, appendScriptData_js_1.appendScriptData)({
+                scriptDataAppender: args.scriptDataAppender,
+                nlpName: "VerifyAlertPopUpMessageContainsString",
+                stepInputs: [args.variableName ? `variable:${args.variableName}` : args.value]
+            });
+        }
+        else {
+            args.scriptDataAppender.setErrorNLP("VerifyAlertPopUpMessageContainsString");
+            throw new Error("Alert message does not contain expected string");
+        }
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("VerifyAlertPopUpMessageContainsString");
+        throw new Error("Verify alert popup message failed", { cause: error });
+    }
+}

package/dist/automation/actions/interaction/alert/verifyAlertPopupIsDisplayed.d.ts

@@ -0,0 +1,2 @@
+import { verifyAlertPopupIsDisplayedInterface } from "../../interface/alertActionInterface.js";
+export declare function verifyAlertPopupIsDisplayed(args: verifyAlertPopupIsDisplayedInterface): Promise<void>;

package/dist/automation/actions/interaction/alert/verifyAlertPopupIsDisplayed.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyAlertPopupIsDisplayed = verifyAlertPopupIsDisplayed;
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
+async function verifyAlertPopupIsDisplayed(args) {
+    try {
+        let value = "5";
+        if (args.value) {
+            value = args.value;
+        }
+        await args.driver.pause(Number(value) * 1000);
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: "VerifyAlertPopupIsDisplayed",
+            stepInputs: [args.variableName ? `variable:${args.variableName}` : value]
+        });
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("VerifyAlertPopupIsDisplayed");
+        throw new Error("Verify Alert Popup Is Displayed failed", { cause: error });
+    }
+}

package/dist/automation/actions/interaction/alert/verifyTextPresentOnAlertPopup.d.ts

@@ -0,0 +1,2 @@
+import { verifyExactAlertTextInterface } from "../../interface/alertActionInterface.js";
+export declare function verifyTextPresentOnAlertPopup(args: verifyExactAlertTextInterface): Promise<void>;

package/dist/automation/actions/interaction/alert/verifyTextPresentOnAlertPopup.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyTextPresentOnAlertPopup = verifyTextPresentOnAlertPopup;
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
+async function verifyTextPresentOnAlertPopup(args) {
+    try {
+        const alertText = await args.driver.getAlertText();
+        if (alertText.toLowerCase() === args.value.toLowerCase()) {
+            (0, appendScriptData_js_1.appendScriptData)({
+                scriptDataAppender: args.scriptDataAppender,
+                nlpName: "VerifyTextPresentOnAlertPopup",
+                stepInputs: [args.variableName ? `variable:${args.variableName}` : args.value]
+            });
+        }
+        else {
+            args.scriptDataAppender.setErrorNLP("VerifyTextPresentOnAlertPopup");
+            throw new Error("Alert message does not exactly match expected string");
+        }
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("VerifyTextPresentOnAlertPopup");
+        throw new Error("Verify text present on alert popup failed", { cause: error });
+    }
+}

package/dist/automation/actions/interaction/alert/waitTillAlertIsPresent.d.ts

@@ -0,0 +1,2 @@
+import { waitTillAlertIsPresentInterface } from "../../interface/alertActionInterface.js";
+export declare function waitTillAlertIsPresent(args: waitTillAlertIsPresentInterface): Promise<void>;

package/dist/automation/actions/interaction/alert/waitTillAlertIsPresent.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitTillAlertIsPresent = waitTillAlertIsPresent;
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
+async function waitTillAlertIsPresent(args) {
+    const { timeout = 10000 } = args;
+    try {
+        await args.driver.waitUntil(async () => await args.driver.isAlertOpen(), { timeout });
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: "WaitTillAlertIsPresent"
+        });
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("WaitTillAlertIsPresent");
+        throw new Error("Wait till alert is present failed", { cause: error });
+    }
+}

package/dist/automation/actions/interaction/arithmetic/arithmeticOperations.d.ts

@@ -0,0 +1,2 @@
+import { ArithmeticActionInterface } from "../../interface/arithmeticActionInterface.js";
+export declare function performArithmeticOperation(args: ArithmeticActionInterface): Promise<void>;

package/dist/automation/actions/interaction/arithmetic/arithmeticOperations.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.performArithmeticOperation = performArithmeticOperation;
+const logData_js_1 = require("../../../../utils/logger/logData.js");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
+const saveStepInputData_js_1 = require("../../../../utils/helpers/saveStepInputData.js");
+async function performArithmeticOperation(args) {
+    try {
+        const normalizedOp = (args.operation || "").toLowerCase().trim();
+        const num1 = parseFloat(args.operandOne);
+        const num2 = parseFloat(args.operandTwo || "0");
+        let result;
+        let operation = "";
+        switch (normalizedOp) {
+            case "add":
+                result = num1 + num2;
+                operation = "+";
+                break;
+            case "subtract":
+                result = num1 - num2;
+                operation = "-";
+                break;
+            case "multiply":
+                result = num1 * num2;
+                operation = "*";
+                break;
+            case "divide":
+                if (num2 === 0) {
+                    throw new Error("Division by zero in arithmetic operation.");
+                }
+                result = num1 / num2;
+                operation = "/";
+                break;
+            default:
+                throw new Error(`Unsupported arithmetic operation: '${args.operation}'. Supported operations are addition, subtraction, multiplication, division.`);
+        }
+        const calculatedResult = (result).toString();
+        args.returnTypeVariableName = args.returnTypeVariableName || args.variableName;
+        if (args.scriptDataAppender) {
+            const stepInputs = [
+                args.operandOneVariableName ? `variable:${args.operandOneVariableName}` : String(num1),
+                operation,
+                args.operandTwoVariableName ? `variable:${args.operandTwoVariableName}` : String(num2),
+            ];
+            (0, appendScriptData_js_1.appendScriptData)({
+                scriptDataAppender: args.scriptDataAppender,
+                nlpName: "ArithmeticOperationsOnOperands",
+                stepInputs,
+                elementGetter: args.elementGetter,
+                platform: args.platform,
+                returnTypeVariableName: args.returnTypeVariableName,
+            });
+        }
+        (0, saveStepInputData_js_1.saveStepInputData)(args, calculatedResult);
+        logData_js_1.logger.info(`Arithmetic operation performed: ${num1} ${operation} ${num2} = ${result}`);
+    }
+    catch (error) {
+        args.scriptDataAppender?.setErrorNLP("ArithmeticOperationsOnOperands");
+        throw new Error(`Arithmetic action failed`, { cause: error });
+    }
+}

package/dist/automation/actions/interaction/clear/clear.d.ts

@@ -0,0 +1,2 @@
+import { clearActionInterface } from "../../interface/clearActionInterface.js";
+export declare function clear(args: clearActionInterface): Promise<void>;

package/dist/automation/actions/interaction/clear/clear.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clear = clear;
+const enterActionHelper_js_1 = require("../../../../utils/helpers/enterActionHelper.js");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
+async function clear(args) {
+    const nlpName = args.platform === "ios" ? "IOS_Clear" : "MOB_Clear";
+    switch (args.platform) {
+        case "android":
+        case "ios":
+            try {
+                const isWebView = args.pageDOM?.includes("ff-inspect");
+                const { ffNumber, xpathPath } = isWebView
+                    ? (0, enterActionHelper_js_1.enterActionHelper)(args.pageDOM, args.fireflinkIndex)
+                    : (0, enterActionHelper_js_1.enterActionHelperMob)(args.pageDOM, args.fireflinkIndex);
+                await args.driver.$(xpathPath).clearValue();
+                const ffElementNumber = `Fire-Flink-${ffNumber}`;
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: nlpName,
+                    stepInputs: [],
+                    pageDOM: args.pageDOM,
+                    elementGetter: args.elementGetter,
+                    ffNumber: ffElementNumber,
+                    elementName: args.elementName,
+                    elementType: args.elementType,
+                    selector: args.selector,
+                    platform: args.platform
+                });
+            }
+            catch (error) {
+                args.scriptDataAppender.setErrorNLP(nlpName);
+                throw new Error("clear action failed", { cause: error });
+            }
+            break;
+        case "web":
+        default:
+            try {
+                const { ffNumber, xpathPath } = (0, enterActionHelper_js_1.enterActionHelper)(args.pageDOM, args.fireflinkIndex);
+                await args.driver.$(xpathPath).clearValue();
+                const ffElementNumber = `Fire-Flink-${ffNumber}`;
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: 'Clear',
+                    stepInputs: [],
+                    pageDOM: args.pageDOM,
+                    elementGetter: args.elementGetter,
+                    ffNumber: ffElementNumber,
+                    elementName: args.elementName,
+                    elementType: args.elementType,
+                    selector: xpathPath,
+                    platform: args.platform
+                });
+            }
+            catch (error) {
+                args.scriptDataAppender.setErrorNLP("Clear");
+                throw new Error("clear action failed", { cause: error });
+            }
+            break;
+    }
+}

package/dist/automation/actions/interaction/clear/clearAndEnter.d.ts

@@ -0,0 +1,2 @@
+import { clearAndEnterActionInterface } from "../../interface/clearActionInterface.js";
+export declare function clearAndEnter(args: clearAndEnterActionInterface): Promise<void>;

package/dist/automation/actions/interaction/clear/clearAndEnter.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearAndEnter = clearAndEnter;
+const enterActionHelper_js_1 = require("../../../../utils/helpers/enterActionHelper.js");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
+const saveStepInputData_js_1 = require("../../../../utils/helpers/saveStepInputData.js");
+async function clearAndEnter(args) {
+    const nlpName = args.platform === "ios" ? "IOS_ClearThenEnterInput" : "MOB_ClearThenEnterInput";
+    switch (args.platform) {
+        case "android":
+        case "ios":
+            try {
+                const isWebView = args.pageDOM?.includes("ff-inspect");
+                const { ffNumber, xpathPath } = isWebView
+                    ? (0, enterActionHelper_js_1.enterActionHelper)(args.pageDOM, args.fireflinkIndex)
+                    : (0, enterActionHelper_js_1.enterActionHelperMob)(args.pageDOM, args.fireflinkIndex);
+                const element = args.driver.$(xpathPath);
+                await element.clearValue();
+                await element.setValue(args.value);
+                const ffElementNumber = `Fire-Flink-${ffNumber}`;
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: nlpName,
+                    stepInputs: [args.variableName ? `variable:${args.variableName}` : args.value],
+                    pageDOM: args.pageDOM,
+                    elementGetter: args.elementGetter,
+                    ffNumber: ffElementNumber,
+                    elementName: args.elementName,
+                    elementType: args.elementType,
+                    selector: args.selector,
+                    platform: args.platform
+                });
+                (0, saveStepInputData_js_1.saveStepInputData)(args, args.value);
+            }
+            catch (error) {
+                args.scriptDataAppender.setErrorNLP(nlpName);
+                throw new Error("clear and enter action failed", { cause: error });
+            }
+            break;
+        case "web":
+        default:
+            try {
+                const { ffNumber, xpathPath } = (0, enterActionHelper_js_1.enterActionHelper)(args.pageDOM, args.fireflinkIndex);
+                const element = args.driver.$(xpathPath);
+                await element.clearValue();
+                await element.setValue(args.value);
+                const ffElementNumber = `Fire-Flink-${ffNumber}`;
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: "ClearThenEnterInput",
+                    stepInputs: [args.variableName ? `variable:${args.variableName}` : args.value],
+                    pageDOM: args.pageDOM,
+                    elementGetter: args.elementGetter,
+                    ffNumber: ffElementNumber,
+                    elementName: args.elementName,
+                    elementType: args.elementType,
+                    selector: xpathPath,
+                    platform: args.platform
+                });
+                (0, saveStepInputData_js_1.saveStepInputData)(args, args.value);
+            }
+            catch (error) {
+                args.scriptDataAppender.setErrorNLP("ClearThenEnterInput");
+                throw new Error("clear and enter action failed", { cause: error });
+            }
+            break;
+    }
+}

package/dist/automation/actions/interaction/click/MOB_DoubleTapAtSpecifiedLocation.d.ts

@@ -0,0 +1,2 @@
+import { MOB_DoubleTapAtSpecifiedLocation } from "../../interface/clickActionInterface.js";
+export declare function MOB_DoubleTapAtSpecifiedLocation(args: MOB_DoubleTapAtSpecifiedLocation): Promise<void>;

package/dist/automation/actions/interaction/click/MOB_DoubleTapAtSpecifiedLocation.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MOB_DoubleTapAtSpecifiedLocation = MOB_DoubleTapAtSpecifiedLocation;
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
+async function MOB_DoubleTapAtSpecifiedLocation(args) {
+    try {
+        const input = args.value || "";
+        const match = input.match(/(\d+)[,\s]+(\d+)/);
+        if (!match) {
+            throw new Error(`Could not extract coordinates from: ${input}`);
+        }
+        const x = Number(match[1]);
+        const y = Number(match[2]);
+        await args.driver.execute('mobile: doubleClickGesture', {
+            x: x,
+            y: y
+        });
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: 'MOB_DoubleTapAtSpecifiedLocation',
+            stepInputs: [x, y],
+        });
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_DoubleTapAtSpecifiedLocation");
+        throw new Error("MOB_DoubleTapAtSpecifiedLocation failed", { cause: error });
+    }
+}

package/dist/automation/actions/interaction/click/click.d.ts

@@ -0,0 +1,2 @@
+import { ClickInterface } from "../../interface/clickActionInterface.js";
+export declare function click(args: ClickInterface): Promise<void>;

package/dist/automation/actions/interaction/click/click.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.click = click;
+const logData_js_1 = require("../../../../utils/logger/logData.js");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
+async function click(args) {
+    const nlpName = args.platform === "ios" ? "IOS_Tap" : "MOB_Tap";
+    switch (args.platform) {
+        case "android":
+        case "ios":
+            try {
+                const element = await args.driver.$(args.selector);
+                await element.click();
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: nlpName,
+                    stepInputs: [],
+                    pageDOM: args.pageDOM,
+                    elementGetter: args.elementGetter,
+                    ffNumber: args.fireflinkIndex,
+                    elementName: args.elementName,
+                    elementType: args.elementType,
+                    selector: args.selector,
+                    platform: args.platform
+                });
+            }
+            catch (error) {
+                args.scriptDataAppender.setErrorNLP(nlpName);
+                throw new Error(`Tap action failed`, { cause: error });
+            }
+            break;
+        case "web":
+        default:
+            try {
+                let element = await args.driver.$(args.selector);
+                let jsClick = false;
+                await args.driver.execute((el) => {
+                    el.scrollIntoView({
+                        block: "center",
+                        inline: "nearest"
+                    });
+                }, element);
+                try {
+                    element = await args.driver.$(args.selector);
+                    await element.click();
+                }
+                catch (clickError) {
+                    try {
+                        logData_js_1.logger.info(`normal click failed : ${String(clickError?.message || clickError).slice(0, 50)}`);
+                        await args.driver.executeScript("arguments[0].click();", [element]);
+                        jsClick = true;
+                    }
+                    catch (jsError) {
+                        try {
+                            logData_js_1.logger.info(`js click failed : ${String(jsError?.message || jsError).slice(0, 50)}`);
+                            await args.driver.execute((el) => {
+                                el.click();
+                            }, element);
+                        }
+                        catch (innerError) {
+                            if (String(jsError?.message || jsError).includes("stale")) {
+                                logData_js_1.logger.info(`stale element error : ${String(jsError?.message || jsError).slice(0, 50)}`);
+                                jsClick = false;
+                            }
+                            else {
+                                throw new Error("cause", { cause: innerError });
+                            }
+                        }
+                    }
+                }
+                const webNlp = jsClick ? "ClickUsingJS" : "Click";
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: webNlp,
+                    stepInputs: [],
+                    pageDOM: args.pageDOM,
+                    elementGetter: args.elementGetter,
+                    ffNumber: args.fireflinkIndex,
+                    elementName: args.elementName,
+                    elementType: args.elementType,
+                    selector: args.selector,
+                    platform: args.platform
+                });
+            }
+            catch (error) {
+                args.scriptDataAppender.setErrorNLP("Click");
+                throw new Error(`Click action failed`, { cause: error });
+            }
+            break;
+    }
+}

package/dist/automation/actions/interaction/click/clickNtimes.d.ts

@@ -0,0 +1,2 @@
+import { ClickNTimesInterface } from "../../interface/clickActionInterface.js";
+export declare function clickNTimes(args: ClickNTimesInterface): Promise<void>;

package/dist/automation/actions/interaction/click/clickNtimes.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clickNTimes = clickNTimes;
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
+async function clickNTimes(args) {
+    switch (args.platform) {
+        case "android":
+            try {
+                const element = await args.driver.$(args.selector);
+                for (let i = 0; i < Number(args.value); i++) {
+                    await element.click();
+                }
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: 'MOB_TapNTimes',
+                    stepInputs: [args.value],
+                    pageDOM: args.pageDOM,
+                    elementGetter: args.elementGetter,
+                    ffNumber: args.fireflinkIndex,
+                    elementName: args.elementName,
+                    elementType: args.elementType,
+                    selector: args.selector,
+                    platform: args.platform
+                });
+            }
+            catch (error) {
+                args.scriptDataAppender.setErrorNLP("MOB_TapNTimes");
+                throw new Error(`TapNTimes action failed :`, { cause: error });
+            }
+            break;
+        case "web":
+        default:
+            try {
+                const element = await args.driver.$(args.selector);
+                await args.driver.execute((el) => {
+                    el.scrollIntoView({
+                        block: "center",
+                        inline: "nearest"
+                    });
+                }, element);
+                for (let i = 0; i < Number(args.value); i++) {
+                    await element.click();
+                }
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: 'ClickNTimes',
+                    stepInputs: [args.value],
+                    pageDOM: args.pageDOM,
+                    elementGetter: args.elementGetter,
+                    ffNumber: args.fireflinkIndex,
+                    elementName: args.elementName,
+                    elementType: args.elementType,
+                    selector: args.selector,
+                    platform: args.platform
+                });
+            }
+            catch (error) {
+                args.scriptDataAppender.setErrorNLP("ClickNTimes");
+                throw new Error(`ClickNTimes action failed :`, { cause: error });
+            }
+            break;
+    }
+}

package/dist/automation/actions/interaction/click/clickUsingJs.d.ts

@@ -0,0 +1,2 @@
+import { ClickUsingJSInterface } from "../../interface/clickActionInterface.js";
+export declare function clickUsingJS(args: ClickUsingJSInterface): Promise<void>;

package/dist/automation/actions/interaction/click/clickUsingJs.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clickUsingJS = clickUsingJS;
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
+async function clickUsingJS(args) {
+    try {
+        const element = await args.driver.$(args.selector);
+        await args.driver.execute((el) => {
+            el.click();
+        }, element);
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: 'ClickUsingJS',
+            stepInputs: [],
+            pageDOM: args.pageDOM,
+            elementGetter: args.elementGetter,
+            ffNumber: args.fireflinkIndex,
+            elementName: args.elementName,
+            elementType: args.elementType,
+            selector: args.selector,
+            platform: args.platform
+        });
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("ClickUsingJS");
+        throw new Error(`ClickUsingJS action failed :`, { cause: error });
+    }
+}

package/dist/automation/actions/interaction/click/doubleClick.d.ts

@@ -0,0 +1,2 @@
+import { DoubleClickInterface } from "../../interface/clickActionInterface.js";
+export declare function doubleClick(args: DoubleClickInterface): Promise<void>;