ff-automationv2 2.2.13 → 2.2.15

package/dist/automation/actions/interaction/elementLessAction/MobCheckIfAppIsClosed.d.ts

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

package/dist/automation/actions/interaction/elementLessAction/MobCheckIfAppIsClosed.js

@@ -0,0 +1,20 @@
+export async function MOB_CheckIfAppIsClosed(args) {
+    try {
+        const state = await args.driver.queryAppState(await args.driver.getCurrentPackage());
+        const isClosed = state !== 4;
+        if (!isClosed) {
+            throw new Error("App is not closed");
+        }
+        args.scriptDataAppender.add(async () => {
+            return {
+                nlpName: 'MOB_CheckIfAppIsClosed',
+                stepInputs: [],
+                elementsData: []
+            };
+        });
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_CheckIfAppIsClosed");
+        throw new Error(`enter action failed:`, { cause: error });
+    }
+}

package/dist/automation/actions/interaction/elementLessAction/MobRunAppInBackgroundInterface.d.ts

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

package/dist/automation/actions/interaction/elementLessAction/MobRunAppInBackgroundInterface.js

@@ -0,0 +1,18 @@
+export async function MOB_RunAppInBackground(args) {
+    try {
+        await args.driver.execute('mobile: backgroundApp', {
+            seconds: Number(args.value)
+        });
+        args.scriptDataAppender.add(async () => {
+            return {
+                nlpName: 'MOB_RunAppInBackground',
+                stepInputs: [args.value],
+                elementsData: []
+            };
+        });
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_RunAppInBackground");
+        throw new Error("MOB_RunAppInBackground failed", { cause: error });
+    }
+}

package/dist/automation/actions/interaction/enterActions/EnterInputIntoElementFromClipBoardInterface_mob.d.ts

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

package/dist/automation/actions/interaction/enterActions/EnterInputIntoElementFromClipBoardInterface_mob.js

@@ -0,0 +1,26 @@
+import { logger } from "../../../../utils/logger/logData.js";
+export async function MOB_EnterInputIntoElementFromClipBoard(args) {
+    try {
+        const element = await args.driver.$(args.selector);
+        const base64Value = await args.driver.getClipboard('plaintext');
+        const value = Buffer.from(base64Value, 'base64').toString('utf-8');
+        logger.info(`Value from clipboard: ${value}`);
+        await element.addValue(value);
+        args.scriptDataAppender.add(async () => {
+            return {
+                nlpName: 'MOB_EnterInputIntoElementFromClipBoard',
+                stepInputs: [],
+                elementsData: [{
+                        name: args.elementName,
+                        type: args.elementType,
+                        locators: [{ "xpath": args.selector }],
+                        platform: args.platform
+                    }]
+            };
+        });
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_EnterInputIntoElementFromClipBoard");
+        throw new Error(`enter action failed:`, { cause: error });
+    }
+}

package/dist/automation/actions/interaction/enterActions/enterInput.js

@@ -5,7 +5,7 @@ export async function enterInput(args) {
             try {
                 const { xpathPath } = enterActionHelperMob(args.pageDOM, args.fireflinkIndex);
                 const element = await args.driver.$(xpathPath);
-                await element.setValue(args.value);
+                await element.addValue(args.value);
                 const text = await element.getAttribute("text");
                 if (text !== args.value) {
                     const { execSync } = await import("child_process");
@@ -34,7 +34,7 @@ export async function enterInput(args) {
             try {
                 const { ffNumber, xpathPath } = enterActionHelper(args.pageDOM, args.fireflinkIndex);
                 const element = await args.driver.$(xpathPath);
-                await element.setValue(args.value);
+                await element.addValue(args.value);
                 args.scriptDataAppender.add(async () => {
                     const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="Fire-Flink-${ffNumber}"]`);
                     return {

package/dist/automation/actions/interaction/enterActions/enterInputAndPress.js

@@ -9,7 +9,7 @@ export async function enterInputAndPress(args) {
                 const inputValue = parts[0]?.trim() || "";
                 const keyValue = parts[1]?.trim().toLowerCase() || "";
                 if (inputValue) {
-                    await element.setValue(inputValue);
+                    await element.addValue(inputValue);
                 }
                 if (keyValue) {
                     switch (keyValue) {

package/dist/automation/actions/interaction/enterActions/enterusingJs.js

@@ -6,7 +6,7 @@ export async function enterInputUsingJs(args) {
         logger.info(`Enter input using JS for element with ffNumber: ${ffNumber}, xpathPath: ${xpathPath}`);
         const element = await args.driver.$(xpathPath);
         await element.scrollIntoView({ block: 'center', inline: 'center' });
-        await element.setValue(args.value);
+        await element.addValue(args.value);
         args.scriptDataAppender.add(async () => {
             const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="Fire-Flink-${ffNumber}"]`);
             return {

package/dist/automation/actions/interaction/enterActions/waitAndEnter.js

@@ -19,7 +19,7 @@ export async function waitAndEnter(args) {
                 const element = await args.driver.$(xpathPath);
                 // Wait before typing
                 await args.driver.pause(waitTimeSeconds * 1000);
-                await element.setValue(inputValue);
+                await element.addValue(inputValue);
                 args.scriptDataAppender.add(async () => {
                     return {
                         nlpName: "MOB_WaitAndSendKeys",
@@ -47,8 +47,8 @@ export async function waitAndEnter(args) {
                 const element = await args.driver.$(xpathPath);
                 // Wait before typing
                 await args.driver.pause(waitTimeSeconds * 1000);
-                await element.scrollIntoView({ block: "center", inline: "center" });
-                await element.setValue(inputValue);
+                await element.scrollIntoView({ block: 'center', inline: 'center' });
+                await element.addValue(inputValue);
                 args.scriptDataAppender.add(async () => {
                     const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="Fire-Flink-${ffNumber}"]`);
                     return {

package/dist/automation/actions/interaction/find/MOB_FindElement.d.ts

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

package/dist/automation/actions/interaction/find/MOB_FindElement.js

@@ -0,0 +1,34 @@
+export async function MOB_FindElement(args) {
+    try {
+        const parentElement = await args.driver.$(args.selector);
+        const children = await parentElement.$$("./*");
+        const childInfo = [];
+        for (const el of children) {
+            childInfo.push({
+                class: await el.getAttribute("class"),
+                resource_id: await el.getAttribute("resource-id"),
+                text: await el.getAttribute("text"),
+                content_desc: await el.getAttribute("content-desc"),
+            });
+        }
+        args.scriptDataAppender.add(async () => {
+            return {
+                nlpName: "MOB_FindElement",
+                stepInputs: [],
+                elementsData: [{
+                        name: args.elementName,
+                        type: args.elementType,
+                        locators: [{
+                                "locatorType": "xpath",
+                                "locatorValue": args.selector
+                            }],
+                        platform: args.platform
+                    }]
+            };
+        });
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_FindElements");
+        throw new Error("find elements action failed", { cause: error });
+    }
+}

package/dist/automation/actions/interaction/find/findElements.js

@@ -2,14 +2,28 @@ export async function findElements(args) {
     switch (args.platform) {
         case "android":
             try {
+                const parentElement = await args.driver.$(args.selector);
+                const children = await parentElement.$$(".//*");
+                const childInfo = [];
+                for (const el of children) {
+                    childInfo.push({
+                        class: await el.getAttribute("class"),
+                        resource_id: await el.getAttribute("resource-id"),
+                        text: await el.getAttribute("text"),
+                        content_desc: await el.getAttribute("content-desc"),
+                    });
+                }
                 args.scriptDataAppender.add(async () => {
                     return {
                         nlpName: "MOB_FindElements",
-                        stepInputs: ["xpath", args.value],
+                        stepInputs: [],
                         elementsData: [{
                                 name: args.elementName,
                                 type: args.elementType,
-                                locators: [{ "xpath": args.selector }],
+                                locators: [{
+                                        locatorType: "xpath",
+                                        locatorValue: args.value
+                                    }],
                                 platform: args.platform
                             }]
                     };

package/dist/automation/actions/interaction/get/getScreenshot.js

@@ -1,38 +1,36 @@
-import fs from "fs";
-import path from "path";
 export const getScreenshot = async (args) => {
     const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
     let fileName = args.value
         ? args.value.trim().replace(/\s+/g, "_")
         : `Screenshot_${timestamp}`;
-    // Ensure .png extension
     if (!fileName.toLowerCase().endsWith(".png")) {
         fileName += ".png";
     }
-    const folderPath = path.resolve("./screenshots");
-    if (!fs.existsSync(folderPath)) {
-        fs.mkdirSync(folderPath);
-    }
-    const filePath = path.join(folderPath, fileName);
     switch (args.platform) {
         case "android":
+            try {
+                args.scriptDataAppender.add(async () => ({
+                    nlpName: "MOB_GetScreenshot",
+                    stepInputs: [fileName],
+                    elementsData: []
+                }));
+            }
+            catch (error) {
+                args.scriptDataAppender.setErrorNLP("MOB_GetScreenshot");
+                throw new Error("GetScreenshot action failed", { cause: error });
+            }
+            break;
         case "web":
         default:
             try {
-                //  ACTUAL SCREENSHOT
-                await args.driver.saveScreenshot(filePath);
                 args.scriptDataAppender.add(async () => ({
-                    nlpName: args.platform === "android"
-                        ? "MOB_GetScreenshot"
-                        : "GetScreenshot",
+                    nlpName: "GetScreenshot",
                     stepInputs: [fileName],
                     elementsData: []
                 }));
             }
             catch (error) {
-                args.scriptDataAppender.setErrorNLP(args.platform === "android"
-                    ? "MOB_GetScreenshot"
-                    : "GetScreenshot");
+                args.scriptDataAppender.setErrorNLP("GetScreenshot");
                 throw new Error("GetScreenshot action failed", { cause: error });
             }
             break;

package/dist/automation/actions/interaction/get/getScreenshotAs.js

@@ -1,30 +1,16 @@
-import fs from "fs";
-import path from "path";
 export const getScreenshotAs = async (args) => {
     const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-    let fileName = args.value ? args.value : `Screenshot_${timestamp}.png`;
-    // ✅ Ensure .png extension
+    let fileName = args.elementName ? args.elementName : `Screenshot_${timestamp}.png`;
     if (!fileName.endsWith(".png")) {
         fileName += ".png";
     }
-    const folderPath = path.resolve("./screenshots");
-    if (!fs.existsSync(folderPath)) {
-        fs.mkdirSync(folderPath);
-    }
-    const filePath = path.join(folderPath, fileName);
     switch (args.platform) {
         case "android":
-        case "web":
-        default:
             try {
                 const element = await args.driver.$(args.selector);
                 await element.waitForDisplayed({ timeout: 10000 });
-                // ✅ Screenshot capture
-                await element.saveScreenshot(filePath);
                 args.scriptDataAppender.add(async () => ({
-                    nlpName: args.platform === "android"
-                        ? "MOB_GetScreenshotAs"
-                        : "GetScreenshotAs",
+                    nlpName: "MOB_GetScreenshotAs",
                     stepInputs: [fileName],
                     elementsData: [{
                             name: args.elementName,
@@ -39,5 +25,29 @@ export const getScreenshotAs = async (args) => {
                 throw new Error("GetScreenshotAs action failed", { cause: error });
             }
             break;
+        case "web":
+        default:
+            try {
+                const element = await args.driver.$(args.selector);
+                await element.waitForDisplayed({ timeout: 10000 });
+                args.scriptDataAppender.add(async () => {
+                    const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex}"]`);
+                    return {
+                        nlpName: "GetScreenshotAs",
+                        stepInputs: [fileName],
+                        elementsData: [{
+                                name: args.elementName,
+                                type: args.elementType,
+                                locators: ffElement.locators,
+                                platform: args.platform
+                            }]
+                    };
+                });
+            }
+            catch (error) {
+                args.scriptDataAppender.setErrorNLP("GetScreenshotAs");
+                throw new Error("GetScreenshotAs action failed", { cause: error });
+            }
+            break;
     }
 };

package/dist/automation/actions/interaction/pinch/PinchInByPercentMob.d.ts

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

package/dist/automation/actions/interaction/pinch/PinchInByPercentMob.js

@@ -0,0 +1,27 @@
+export async function MOB_PinchInByPercent(args) {
+    try {
+        const element = await args.driver.$(args.selector);
+        await args.driver.execute('mobile: pinchOpenGesture', {
+            elementId: element.elementId,
+            percent: Number(args.value) / 100
+        });
+        args.scriptDataAppender.add(async () => {
+            return {
+                nlpName: 'MOB_PinchInByPercent',
+                stepInputs: [args.value],
+                elementsData: [{
+                        name: args.elementName,
+                        type: args.elementType,
+                        locators: [{
+                                xpath: args.selector
+                            }],
+                        platform: args.platform
+                    }]
+            };
+        });
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_PinchInByPercent");
+        throw new Error("MOB_PinchInByPercent failed", { cause: error });
+    }
+}

package/dist/automation/actions/interaction/pinch/PinchOutByPercentMob.d.ts

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

package/dist/automation/actions/interaction/pinch/PinchOutByPercentMob.js

@@ -0,0 +1,27 @@
+export async function MOB_PinchOutByPercent(args) {
+    try {
+        const element = await args.driver.$(args.selector);
+        await args.driver.execute('mobile: pinchCloseGesture', {
+            elementId: element.elementId,
+            percent: Number(args.value) / 100
+        });
+        args.scriptDataAppender.add(async () => {
+            return {
+                nlpName: 'MOB_PinchOutByPercent',
+                stepInputs: [args.value],
+                elementsData: [{
+                        name: args.elementName,
+                        type: args.elementType,
+                        locators: [{
+                                xpath: args.selector
+                            }],
+                        platform: args.platform
+                    }]
+            };
+        });
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_PinchOutByPercent");
+        throw new Error("MOB_PinchOutByPercent failed", { cause: error });
+    }
+}

package/dist/automation/actions/interaction/press/mobPressBackSpaceKey.d.ts

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

package/dist/automation/actions/interaction/press/mobPressBackSpaceKey.js

@@ -0,0 +1,16 @@
+export async function pressBackSpaceKey(args) {
+    try {
+        await args.driver.pressKeyCode(67);
+        args.scriptDataAppender.add(async () => {
+            return {
+                nlpName: 'MOB_PressBackSpaceKey',
+                stepInputs: [],
+                elementsData: []
+            };
+        });
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_PressBackSpaceKey");
+        throw new Error(`PressBackSpaceKey action failed :`, { cause: error });
+    }
+}

package/dist/automation/actions/interaction/press/mobPressSpaceKey.d.ts

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

package/dist/automation/actions/interaction/press/mobPressSpaceKey.js

@@ -0,0 +1,16 @@
+export async function pressSpaceKey(args) {
+    try {
+        await args.driver.pressKeyCode(62);
+        args.scriptDataAppender.add(async () => {
+            return {
+                nlpName: 'MOB_PressSpaceKey',
+                stepInputs: [],
+                elementsData: []
+            };
+        });
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_PressSpaceKey");
+        throw new Error(`PressSpaceKey action failed :`, { cause: error });
+    }
+}

package/dist/automation/actions/interaction/swipe/swipeDirectionNTimes.d.ts

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

package/dist/automation/actions/interaction/swipe/swipeDirectionNTimes.js

@@ -0,0 +1,27 @@
+import { executeSwipeMovement } from "../../../../utils/swipe/swipeMovement.js";
+export async function swipeDirectionNTimes(args) {
+    try {
+        const count = Number(args.num_of_scrolls) || 30;
+        const direction = args.direction || "down";
+        let previousDom = "";
+        for (let i = 0; i < count; i++) {
+            await executeSwipeMovement(args.driver, direction);
+            const currentDom = await args.driver.getPageSource();
+            if (currentDom === previousDom) {
+                throw new Error("End of page reached. Stopping swipe.");
+            }
+            previousDom = currentDom;
+        }
+        args.scriptDataAppender.add(async () => {
+            return {
+                nlpName: 'MOB_SwipeDirectionNTimes',
+                stepInputs: [direction, count.toString()],
+                elementsData: []
+            };
+        });
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_SwipeDirectionNTimes");
+        throw new Error("MOB_SwipeDirectionNTimes action failed", { cause: error });
+    }
+}

package/dist/automation/actions/interaction/swipe/swipeDownToElement.d.ts

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

package/dist/automation/actions/interaction/swipe/swipeDownToElement.js

@@ -0,0 +1,46 @@
+import { executeSwipeMovement } from "../../../../utils/swipe/swipeMovement.js";
+import { findElementInDom } from "../../../../utils/swipe/domSearchHelper.js";
+export async function swipeDownToElement(args) {
+    try {
+        const maxScrolls = Number(args.num_of_scrolls) || 30;
+        const direction = "down";
+        const searchText = args.value;
+        if (!searchText.trim()) {
+            throw new Error("SwipeDownToElement requires search text");
+        }
+        let found = false;
+        let discoveredXPath = "";
+        let previousDom = "";
+        for (let attempt = 1; attempt <= maxScrolls; attempt++) {
+            await executeSwipeMovement(args.driver, direction);
+            const currentDom = await args.driver.getPageSource();
+            if (currentDom === previousDom) {
+                throw new Error("End of page reached. Stopping swipe.");
+            }
+            previousDom = currentDom;
+            const result = await findElementInDom(args.driver, searchText);
+            if (result) {
+                discoveredXPath = result.xpath;
+                found = true;
+                break;
+            }
+        }
+        if (!found) {
+            throw new Error(`Element "${searchText}" not found after ${maxScrolls} attempts`);
+        }
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "MOB_SwipeDownToElement",
+            stepInputs: [],
+            elementsData: [{
+                    name: args.elementName || searchText,
+                    type: args.elementType,
+                    locators: [{ xpath: discoveredXPath }],
+                    platform: args.platform
+                }]
+        }));
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_SwipeDownToElement");
+        throw new Error("MOB_SwipeDownToElement action failed", { cause: error });
+    }
+}

package/dist/automation/actions/interaction/swipe/swipeLeftToElement.d.ts

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

package/dist/automation/actions/interaction/swipe/swipeLeftToElement.js

@@ -0,0 +1,46 @@
+import { executeSwipeMovement } from "../../../../utils/swipe/swipeMovement.js";
+import { findElementInDom } from "../../../../utils/swipe/domSearchHelper.js";
+export async function swipeLeftToElement(args) {
+    try {
+        const maxScrolls = Number(args.num_of_scrolls) || 30;
+        const direction = "left";
+        const searchText = args.value || args.elementName || "";
+        if (!searchText.trim()) {
+            throw new Error("SwipeLeftToElement requires search text");
+        }
+        let found = false;
+        let discoveredXPath = "";
+        let previousDom = "";
+        for (let attempt = 1; attempt <= maxScrolls; attempt++) {
+            await executeSwipeMovement(args.driver, direction);
+            const currentDom = await args.driver.getPageSource();
+            if (currentDom === previousDom) {
+                throw new Error("End of page reached. Stopping swipe.");
+            }
+            previousDom = currentDom;
+            const result = await findElementInDom(args.driver, searchText);
+            if (result) {
+                discoveredXPath = result.xpath;
+                found = true;
+                break;
+            }
+        }
+        if (!found) {
+            throw new Error(`Element "${searchText}" not found after ${maxScrolls} swipes`);
+        }
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "MOB_SwipeLeftToElement",
+            stepInputs: [],
+            elementsData: [{
+                    name: args.elementName || searchText,
+                    type: args.elementType,
+                    locators: [{ xpath: discoveredXPath }],
+                    platform: args.platform
+                }]
+        }));
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_SwipeLeftToElement");
+        throw new Error("MOB_SwipeLeftToElement action failed", { cause: error });
+    }
+}

package/dist/automation/actions/interaction/swipe/swipeRightToElement.d.ts

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

package/dist/automation/actions/interaction/swipe/swipeRightToElement.js

@@ -0,0 +1,46 @@
+import { executeSwipeMovement } from "../../../../utils/swipe/swipeMovement.js";
+import { findElementInDom } from "../../../../utils/swipe/domSearchHelper.js";
+export async function swipeRightToElement(args) {
+    try {
+        const maxScrolls = Number(args.num_of_scrolls) || 30;
+        const direction = "right";
+        const searchText = args.value;
+        if (!searchText.trim()) {
+            throw new Error("SwipeRightToElement requires search text");
+        }
+        let found = false;
+        let discoveredXPath = "";
+        let previousDom = "";
+        for (let attempt = 1; attempt <= maxScrolls; attempt++) {
+            await executeSwipeMovement(args.driver, direction);
+            const currentDom = await args.driver.getPageSource();
+            if (currentDom === previousDom) {
+                throw new Error("End of page reached. Stopping swipe.");
+            }
+            previousDom = currentDom;
+            const result = await findElementInDom(args.driver, searchText);
+            if (result) {
+                discoveredXPath = result.xpath;
+                found = true;
+                break;
+            }
+        }
+        if (!found) {
+            throw new Error(`Element "${searchText}" not found after ${maxScrolls} attempts`);
+        }
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "MOB_SwipeRightToElement",
+            stepInputs: [],
+            elementsData: [{
+                    name: args.elementName || searchText,
+                    type: args.elementType,
+                    locators: [{ xpath: discoveredXPath }],
+                    platform: args.platform
+                }]
+        }));
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_SwipeRightToElement");
+        throw new Error("MOB_SwipeRightToElement action failed", { cause: error });
+    }
+}

package/dist/automation/actions/interaction/swipe/swipeUpToElement.d.ts

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