ff-automationv2 2.2.27 → 2.2.29

package/dist/automation/actions/interaction/verify/VerifyYLocationOfElement.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyYLocationOfElement = verifyYLocationOfElement;
 const logData_js_1 = require("../../../../utils/logger/logData.js");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function verifyYLocationOfElement(args) {
     switch (args.platform) {
         case "android":
@@ -15,17 +16,20 @@ async function verifyYLocationOfElement(args) {
                     actualY: location.y,
                     expectedY
                 });
-                args.scriptDataAppender.add(async () => {
-                    return {
-                        nlpName: 'MOB_VerifyYLocationOfAndroidElement',
-                        stepInputs: [args.value],
-                        elementsData: [{
-                                name: args.elementName,
-                                type: args.elementType,
-                                locators: [{ "name": "xpath", "value": args.selector }],
-                                platform: args.platform
-                            }]
-                    };
+                if (isMatched === false) {
+                    throw new Error(`Element y location does not match expected. Expected: ${expectedY}px, Actual: ${location.y}px`);
+                }
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: "MOB_VerifyYLocationOfAndroidElement",
+                    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) {
@@ -45,18 +49,17 @@ async function verifyYLocationOfElement(args) {
                     actualY: location.y,
                     expectedY
                 });
-                args.scriptDataAppender.add(async () => {
-                    const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex}"]`);
-                    return {
-                        nlpName: 'VerifyYLocationOfElement',
-                        stepInputs: [args.value],
-                        elementsData: [{
-                                name: args.elementName,
-                                type: args.elementType,
-                                locators: ffElement.locators,
-                                platform: args.platform
-                            }]
-                    };
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: "VerifyYLocationOfElement",
+                    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) {

package/dist/automation/actions/interaction/verify/checkIfElementIsDisplayed.js

@@ -2,9 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkIfElementIsDisplayed = checkIfElementIsDisplayed;
 const logData_js_1 = require("../../../../utils/logger/logData.js");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function checkIfElementIsDisplayed(args) {
+    const nlpName = args.platform === "ios" ? "IOS_CheckIfElementIsDisplayed" : "MOB_CheckIfElementIsDisplayed";
     switch (args.platform) {
         case "android":
+        case "ios":
             try {
                 const element = await args.driver.$(args.selector);
                 const timeout = parseInt(args.value || "10000", 10);
@@ -15,19 +18,21 @@ async function checkIfElementIsDisplayed(args) {
                     timeoutMsg: "Element not displayed within given time"
                 });
                 logData_js_1.logger.info("Element displayed successfully");
-                args.scriptDataAppender.add(async () => ({
-                    nlpName: 'MOB_CheckIfElementIsDisplayed',
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: nlpName,
                     stepInputs: [args.value],
-                    elementsData: [{
-                            name: args.elementName,
-                            type: args.elementType,
-                            locators: [{ "name": "xpath", "value": args.selector }],
-                            platform: args.platform
-                        }]
-                }));
+                    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_CheckIfElementIsDisplayed");
+                args.scriptDataAppender.setErrorNLP(nlpName);
                 throw new Error(`CheckIfElementIsDisplayed action failed`, { cause: error });
             }
             break;
@@ -43,18 +48,17 @@ async function checkIfElementIsDisplayed(args) {
                     timeoutMsg: "Element not displayed within given time"
                 });
                 logData_js_1.logger.info("Element displayed successfully");
-                args.scriptDataAppender.add(async () => {
-                    const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex}"]`);
-                    return {
-                        nlpName: 'CheckIfElementIsDisplayed',
-                        stepInputs: [args.value],
-                        elementsData: [{
-                                name: args.elementName,
-                                type: args.elementType,
-                                locators: ffElement.locators,
-                                platform: args.platform
-                            }]
-                    };
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: "CheckIfElementIsDisplayed",
+                    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) {

package/dist/automation/actions/interaction/verify/verifyElementIsDisplayedWithinSpecifiedTime.d.ts

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

package/dist/automation/actions/interaction/verify/verifyElementIsDisplayedWithinSpecifiedTime.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyElementIsDisplayedInSpecifiedTime = verifyElementIsDisplayedInSpecifiedTime;
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
+const logData_js_1 = require("../../../../utils/logger/logData.js");
+async function verifyElementIsDisplayedInSpecifiedTime(args) {
+    const nlpName = args.platform === "ios" ? "IOS_VerifyElementIsDisplayed" : "MOB_VerifyElementIsDisplayed";
+    switch (args.platform) {
+        case "android":
+        case "ios":
+            try {
+                logData_js_1.logger.info("The value is ", args.value.split(",")[1]);
+                let isDisplayed = false;
+                await args.driver.waitUntil(async () => {
+                    const element = await args.driver.$(args.value);
+                    if (!element) {
+                        return false;
+                    }
+                    isDisplayed = await element.isDisplayed();
+                    return isDisplayed;
+                }, {
+                    timeout: Number(args.value.split(",")[1]),
+                    timeoutMsg: "Element is not displayed within the specified time"
+                });
+                logData_js_1.logger.info("Android Element display status:", { isDisplayed });
+                if (!isDisplayed) {
+                    throw new Error(`Element is not displayed. Expected: displayed, Actual: not displayed`);
+                }
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: nlpName,
+                    stepInputs: [args.value.split(",")[1]],
+                    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(`VerifyElementIsDisplayed action failed`, { cause: error });
+            }
+            break;
+        case "web":
+        default:
+            try {
+                let isDisplayed = false;
+                await args.driver.waitUntil(async () => {
+                    const element = await args.driver.$(args.selector);
+                    if (!element) {
+                        return false;
+                    }
+                    isDisplayed = await element.isDisplayed();
+                    return isDisplayed;
+                }, {
+                    timeout: Number(args.value),
+                    timeoutMsg: "Element is not displayed within the specified time"
+                });
+                logData_js_1.logger.info("Web Element display status:", { isDisplayed });
+                if (!isDisplayed) {
+                    throw new Error(`Element is not displayed. Expected: displayed, Actual: not displayed`);
+                }
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: "VerifyElementIsDisplayed",
+                    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("VerifyElementIsDisplayed");
+                throw new Error(`VerifyElementIsDisplayed action failed`, { cause: error });
+            }
+            break;
+    }
+}

package/dist/automation/actions/interaction/verify/verifypartialtext.js

@@ -2,32 +2,36 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyPartialText = verifyPartialText;
 const logData_js_1 = require("../../../../utils/logger/logData.js");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function verifyPartialText(args) {
+    const nlpName = args.platform === "ios" ? "IOS_VerifyPartialText" : "MOB_VerifyPartialText";
     switch (args.platform) {
         case "android":
+        case "ios":
             try {
                 const element = await args.driver.$(args.selector);
-                const actual = await element.getAttribute("text");
+                const attributeName = args.platform === "ios" ? "value" : "text";
+                const actual = (await element.getAttribute(attributeName)) || "";
                 const expected = args.value;
                 if (!actual?.includes(expected)) {
                     throw new Error(`Element does not contain the expected text. Expected to contain: "${args.value}", Actual: "${actual}"`);
                 }
                 const caseSensitive = false;
-                args.scriptDataAppender.add(async () => {
-                    return {
-                        nlpName: 'MOB_VerifyPartialText',
-                        stepInputs: [expected, caseSensitive],
-                        elementsData: [{
-                                name: args.elementName,
-                                type: args.elementType,
-                                locators: [{ "name": "xpath", "value": args.selector }],
-                                platform: args.platform
-                            }]
-                    };
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: nlpName,
+                    stepInputs: [expected, caseSensitive],
+                    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_VerifyPartialText");
+                args.scriptDataAppender.setErrorNLP(nlpName);
                 throw new Error(`VerifyPartialText action failed `, { cause: error });
             }
             break;
@@ -86,18 +90,17 @@ async function verifyPartialText(args) {
                 if (isMatched === false) {
                     throw new Error(`Element does not contain the expected text. Expected to contain: "${args.value}", Actual texts: ${limited.join(" | ")}`);
                 }
-                args.scriptDataAppender.add(async () => {
-                    const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex}"]`);
-                    return {
-                        nlpName: 'VerifyPartialText',
-                        stepInputs: [expected, caseSensitive],
-                        elementsData: [{
-                                name: args.elementName,
-                                type: args.elementType,
-                                locators: ffElement.locators,
-                                platform: args.platform
-                            }]
-                    };
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: "VerifyPartialText",
+                    stepInputs: [expected, caseSensitive],
+                    pageDOM: args.pageDOM,
+                    elementGetter: args.elementGetter,
+                    ffNumber: args.fireflinkIndex,
+                    elementName: args.elementName,
+                    elementType: args.elementType,
+                    selector: args.selector,
+                    platform: args.platform
                 });
             }
             catch (error) {

package/dist/automation/actions/interaction/verify/verifytext.js

@@ -2,39 +2,40 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyText = verifyText;
 const logData_js_1 = require("../../../../utils/logger/logData.js");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function verifyText(args) {
+    const nlpName = args.platform === "ios" ? "IOS_VerifyText" : "MOB_VerifyText";
     switch (args.platform) {
         case "android":
+        case "ios":
             try {
                 const element = await args.driver.$(args.selector);
-                const text = (await element.getAttribute("text")) || "";
-                const contentDesc = (await element.getAttribute("content-desc")) || "";
+                const attributeName = args.platform === "ios" ? "value" : "text";
+                const text = (await element.getAttribute(attributeName)) || "";
                 const expected = (args.value || "").toLowerCase();
-                const isMatched = text.toLowerCase().trim() === expected.trim() ||
-                    contentDesc.toLowerCase().trim() === expected.trim();
+                const isMatched = text.toLowerCase().trim() === expected.trim();
                 logData_js_1.logger.info("text", { text });
-                logData_js_1.logger.info("contentDesc", { contentDesc });
                 logData_js_1.logger.info("expected", { expected });
                 logData_js_1.logger.info("result of verify text:", { isMatched });
                 const caseSensitive = false; // Assuming case-insensitive for logging
                 if (isMatched === false) {
                     throw new Error(`Element text does not match expected. Expected: "${args.value}", Actual: "${expected}"`);
                 }
-                args.scriptDataAppender.add(async () => {
-                    return {
-                        nlpName: 'MOB_VerifyText',
-                        stepInputs: [expected, caseSensitive],
-                        elementsData: [{
-                                name: args.elementName,
-                                type: args.elementType,
-                                locators: [{ "name": "xpath", "value": args.selector }],
-                                platform: args.platform
-                            }]
-                    };
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: nlpName,
+                    stepInputs: [expected, caseSensitive],
+                    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_VerifyText");
+                args.scriptDataAppender.setErrorNLP(nlpName);
                 throw new Error(`VerifyText action failed `, { cause: error });
             }
             break;
@@ -90,22 +91,21 @@ async function verifyText(args) {
                 }
                 // FireFlink Logging
                 logData_js_1.logger.info("result of verify text:", { isMatched });
-                const caseSensitive = false; // Assuming case-insensitive for logging
+                const caseSensitive = false;
                 if (isMatched === false) {
                     throw new Error(`Element text does not match expected. Expected: "${args.value}", Actual: "${texts.join(" | ")}"`);
                 }
-                args.scriptDataAppender.add(async () => {
-                    const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex}"]`);
-                    return {
-                        nlpName: 'VerifyText',
-                        stepInputs: [expected, caseSensitive],
-                        elementsData: [{
-                                name: args.elementName,
-                                type: args.elementType,
-                                locators: ffElement.locators,
-                                platform: args.platform
-                            }]
-                    };
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: "VerifyText",
+                    stepInputs: [expected, caseSensitive],
+                    pageDOM: args.pageDOM,
+                    elementGetter: args.elementGetter,
+                    ffNumber: args.fireflinkIndex,
+                    elementName: args.elementName,
+                    elementType: args.elementType,
+                    selector: args.selector,
+                    platform: args.platform
                 });
             }
             catch (error) {

package/dist/automation/actions/interaction/wait/MOB_WaitTillAllElementsAreInvisible.ts.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MOB_WaitTillAllElementsAreInvisible = void 0;
+const appendScriptData_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData");
 const MOB_WaitTillAllElementsAreInvisible = async (args) => {
+    const nlpName = args.platform === "ios" ? "IOS_WaitUntilAllElementIsInvisible" : "MOB_WaitTillAllElementsAreInvisible";
     try {
         const elements = await args.driver.$$("*");
         for (const element of elements) {
@@ -13,12 +15,9 @@ const MOB_WaitTillAllElementsAreInvisible = async (args) => {
                 continue;
             }
         }
-        args.scriptDataAppender.add(async () => {
-            return {
-                nlpName: "MOB_WaitTillAllElementsAreInvisible",
-                stepInputs: [],
-                elementsData: []
-            };
+        (0, appendScriptData_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: nlpName
         });
     }
     catch (error) {

package/dist/automation/actions/interaction/wait/MOB_WaitTillAttributeOfElementContainsString.js

@@ -1,30 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MOB_WaitTillAttributeOfElementContainsString = void 0;
+const appendScriptData_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData");
 const MOB_WaitTillAttributeOfElementContainsString = async (args) => {
+    const nlpName = args.platform === "ios" ? "IOS_WaitTillAttributeOfElementContainsString" : "MOB_WaitTillAttributeOfElementContainsString";
     try {
-        const attributeName = args.attributeName || "text";
-        const expectedValue = args.value;
+        const parts = args.value.split(",");
+        const attributeName = parts[0].trim();
+        const expectedValue = parts[1].trim();
         const element = await args.driver.$(args.selector);
         await args.driver.waitUntil(async () => {
             const attrValue = await element.getAttribute(attributeName);
             return attrValue && attrValue.includes(expectedValue);
         }, { timeout: 5000 });
-        args.scriptDataAppender.add(async () => {
-            return {
-                nlpName: "MOB_WaitTillAttributeOfElementContainsString",
-                stepInputs: [attributeName, expectedValue],
-                elementsData: [{
-                        name: args.elementName,
-                        type: args.elementType,
-                        locators: [{ "name": "xpath", "value": args.selector }],
-                        platform: args.platform
-                    }]
-            };
+        (0, appendScriptData_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: nlpName,
+            stepInputs: [attributeName, expectedValue],
+            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_WaitTillAttributeOfElementContainsString");
+        args.scriptDataAppender.setErrorNLP(nlpName);
         throw new Error("MOB_WaitTillAttributeOfElementContainsString action failed", { cause: error });
     }
 };

package/dist/automation/actions/interaction/wait/MOB_WaitTillElementIsEnabled.js

@@ -1,21 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MOB_WaitTillElementIsEnabled = void 0;
+const appendScriptData_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData");
 const MOB_WaitTillElementIsEnabled = async (args) => {
     try {
         const element = await args.driver.$(args.selector);
         await element.waitForEnabled({ timeout: 5000 });
-        args.scriptDataAppender.add(async () => {
-            return {
-                nlpName: "MOB_WaitTillElementIsEnabled",
-                stepInputs: [],
-                elementsData: [{
-                        name: args.elementName,
-                        type: args.elementType,
-                        locators: [{ "name": "xpath", "value": args.selector }],
-                        platform: args.platform
-                    }]
-            };
+        (0, appendScriptData_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: "MOB_WaitTillElementIsEnabled",
+            stepInputs: [],
+            pageDOM: args.pageDOM,
+            elementGetter: args.elementGetter,
+            ffNumber: args.fireflinkIndex,
+            elementName: args.elementName,
+            elementType: args.elementType,
+            selector: args.selector,
+            platform: args.platform
         });
     }
     catch (error) {

package/dist/automation/actions/interaction/wait/MOB_WaitTillElementIsInvisible.js

@@ -1,25 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MOB_WaitTillElementIsInvisible = void 0;
+const appendScriptData_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData");
 const MOB_WaitTillElementIsInvisible = async (args) => {
+    const nlpName = args.platform === "ios" ? "IOS_WaitUntilElementIsInvisible" : "MOB_WaitTillElementIsInvisible";
     try {
         const element = await args.driver.$(args.selector);
         await element.waitForDisplayed({ reverse: true, timeout: 5000 });
-        args.scriptDataAppender.add(async () => {
-            return {
-                nlpName: "MOB_WaitTillElementIsInvisible",
-                stepInputs: [],
-                elementsData: [{
-                        name: args.elementName,
-                        type: args.elementType,
-                        locators: [{ "name": "xpath", "value": args.selector }],
-                        platform: args.platform
-                    }]
-            };
+        (0, appendScriptData_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("MOB_WaitTillElementIsInvisible");
+        args.scriptDataAppender.setErrorNLP(nlpName);
         throw new Error("MOB_WaitTillElementIsInvisible action failed", { cause: error });
     }
 };

package/dist/automation/actions/interaction/wait/MOB_WaitTillElementIsSelected.js

@@ -1,21 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MOB_WaitTillElementIsSelected = void 0;
+const appendScriptData_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData");
 const MOB_WaitTillElementIsSelected = async (args) => {
     try {
         const element = await args.driver.$(args.selector);
         await args.driver.waitUntil(async () => await element.isSelected(), { timeout: 5000 });
-        args.scriptDataAppender.add(async () => {
-            return {
-                nlpName: "MOB_WaitTillElementIsSelected",
-                stepInputs: [],
-                elementsData: [{
-                        name: args.elementName,
-                        type: args.elementType,
-                        locators: [{ "name": "xpath", "value": args.selector }],
-                        platform: args.platform
-                    }]
-            };
+        (0, appendScriptData_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: "MOB_WaitTillElementIsSelected",
+            stepInputs: [],
+            pageDOM: args.pageDOM,
+            elementGetter: args.elementGetter,
+            ffNumber: args.fireflinkIndex,
+            elementName: args.elementName,
+            elementType: args.elementType,
+            selector: args.selector,
+            platform: args.platform
         });
     }
     catch (error) {