ff-automationv2 2.2.28 → 2.2.29

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

@@ -1,26 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MOB_WaitTillElementIsVisible = void 0;
+const appendScriptData_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData");
 const MOB_WaitTillElementIsVisible = async (args) => {
+    const nlpName = args.platform === "ios" ? "IOS_WaitTillElementIsVisible" : "MOB_WaitTillElementIsVisible";
     try {
         const element = await args.driver.$(args.selector);
         await element.waitForDisplayed({ timeout: 5000 });
-        args.scriptDataAppender.add(async () => {
-            return {
-                nlpName: "MOB_WaitTillElementIsVisible",
-                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_WaitTillElementIsVisible");
-        throw new Error("MOB_WaitTillElementIsVisible action failed", { cause: error });
+        args.scriptDataAppender.setErrorNLP(nlpName);
+        throw new Error(`${nlpName} action failed`, { cause: error });
     }
 };
 exports.MOB_WaitTillElementIsVisible = MOB_WaitTillElementIsVisible;

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

@@ -1,21 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MOB_WaitTillStalenessOfElement = void 0;
+const appendScriptData_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData");
 const MOB_WaitTillStalenessOfElement = async (args) => {
     try {
         const element = await args.driver.$(args.selector);
         await element.waitForDisplayed({ timeout: 5000 });
-        args.scriptDataAppender.add(async () => {
-            return {
-                nlpName: "MOB_WaitTillStalenessOfElement",
-                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_WaitTillStalenessOfElement",
+            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/wait.js

@@ -1,14 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.wait = wait;
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function wait(args) {
     try {
         await args.driver.pause(Number(args.time) * 1000);
-        args.scriptDataAppender.add(async () => ({
-            nlpName: 'Sleep',
-            elementsData: [],
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: "Sleep",
             stepInputs: [args.time]
-        }));
+        });
     }
     catch (error) {
         args.scriptDataAppender.setErrorNLP("Sleep");

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

@@ -1,9 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.waitTillAttributeOfElementIsString = waitTillAttributeOfElementIsString;
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function waitTillAttributeOfElementIsString(args) {
+    const nlpName = args.platform === "ios" ? "IOS_WaitAttributeOfElementContainsString" : "MOB_WaitTillAttributeOfElementIsString";
     switch (args.platform) {
         case "android":
+        case "ios":
             try {
                 const element = await args.driver.$(args.selector);
                 const parts = args.value.split(",");
@@ -16,21 +19,21 @@ async function waitTillAttributeOfElementIsString(args) {
                     timeout: 6000,
                     timeoutMsg: `Attribute ${attr} did not become ${expectedValue}`
                 });
-                args.scriptDataAppender.add(async () => {
-                    return {
-                        nlpName: 'MOB_WaitTillAttributeOfElementIsString',
-                        stepInputs: [],
-                        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: [attr, 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_WaitTillAttributeOfElementIsString");
+                args.scriptDataAppender.setErrorNLP(nlpName);
                 throw new Error(`WaitTillAttributeOfElementIsString action failed`, { cause: error });
             }
             break;
@@ -48,18 +51,17 @@ async function waitTillAttributeOfElementIsString(args) {
                     timeout: 10000,
                     timeoutMsg: `Attribute ${attr} did not become ${expectedValue}`
                 });
-                args.scriptDataAppender.add(async () => {
-                    const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex}"]`);
-                    return {
-                        nlpName: 'WaitTillAttributeOfElementIsString',
-                        stepInputs: [],
-                        elementsData: [{
-                                name: args.elementName,
-                                type: args.elementType,
-                                locators: ffElement.locators,
-                                platform: args.platform
-                            }]
-                    };
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: "WaitTillAttributeOfElementIsString",
+                    stepInputs: [attr, expectedValue],
+                    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/waitTillElementContainsText.js

@@ -1,9 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.waitTillElementContainsText = waitTillElementContainsText;
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function waitTillElementContainsText(args) {
+    const nlpName = args.platform === "ios" ? "IOS_WaitTillElementContainsText" : "MOB_WaitTillElementContainsText";
     switch (args.platform) {
         case "android":
+        case "ios":
             try {
                 const element = await args.driver.$(args.selector);
                 await args.driver.waitUntil(async () => {
@@ -13,21 +16,21 @@ async function waitTillElementContainsText(args) {
                     timeout: 10000,
                     timeoutMsg: `Element ${args.elementName} text did not contain ${args.value}`
                 });
-                args.scriptDataAppender.add(async () => {
-                    return {
-                        nlpName: 'MOB_WaitTillElementContainsText',
-                        stepInputs: [],
-                        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: [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_WaitTillElementContainsText");
+                args.scriptDataAppender.setErrorNLP(nlpName);
                 throw new Error(`WaitTillElementContainsText action failed`, { cause: error });
             }
             break;
@@ -42,18 +45,17 @@ async function waitTillElementContainsText(args) {
                     timeout: 10000,
                     timeoutMsg: `Element ${args.elementName} text did not contain ${args.value}`
                 });
-                args.scriptDataAppender.add(async () => {
-                    const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex}"]`);
-                    return {
-                        nlpName: 'WaitTillElementContainsText',
-                        stepInputs: [],
-                        elementsData: [{
-                                name: args.elementName,
-                                type: args.elementType,
-                                locators: ffElement.locators,
-                                platform: args.platform
-                            }]
-                    };
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: "WaitTillElementContainsText",
+                    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/wait/waitTillElementHasText.js

@@ -1,30 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.waitTillElementHasText = waitTillElementHasText;
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function waitTillElementHasText(args) {
+    const nlpName = args.platform === "ios" ? "IOS_WaitTillElementHasText" : "MOB_WaitTillElementHasText";
     switch (args.platform) {
         case "android":
+        case "ios":
             try {
                 const element = await args.driver.$(args.selector);
                 await element.waitForDisplayed({
                     timeout: 10000,
                     timeoutMsg: `Element ${args.elementName} did not display`
                 });
-                args.scriptDataAppender.add(async () => {
-                    return {
-                        nlpName: 'MOB_WaitTillElementHasText',
-                        stepInputs: [],
-                        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: [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_WaitTillElementHasText");
+                args.scriptDataAppender.setErrorNLP(nlpName);
                 throw new Error(`WaitTillElementHasText action failed`, { cause: error });
             }
             break;
@@ -36,18 +39,17 @@ async function waitTillElementHasText(args) {
                     timeout: 10000,
                     timeoutMsg: `Element ${args.elementName} did not display`
                 });
-                args.scriptDataAppender.add(async () => {
-                    const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex}"]`);
-                    return {
-                        nlpName: 'WaitTillElementHasText',
-                        stepInputs: [],
-                        elementsData: [{
-                                name: args.elementName,
-                                type: args.elementType,
-                                locators: ffElement.locators,
-                                platform: args.platform
-                            }]
-                    };
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: "WaitTillElementHasText",
+                    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/wait/waitTillElementIsClickable.js

@@ -1,34 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.waitTillElementIsClickable = waitTillElementIsClickable;
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function waitTillElementIsClickable(args) {
+    const nlpName = args.platform === "ios" ? "IOS_WaitTillElementIsClickable" : "MOB_WaitTillElementIsClickable";
     switch (args.platform) {
         case "android":
+        case "ios":
             try {
                 const element = await args.driver.$(args.selector);
                 await element.waitForExist({ timeout: 10000 });
                 await element.waitForDisplayed({ timeout: 10000 });
                 await args.driver.waitUntil(async () => {
-                    return await element.isEnabled();
+                    const attributeName = args.platform === "ios" ? "accessible" : "clickable";
+                    return await element.getAttribute(attributeName);
                 }, {
                     timeout: 10000,
                     timeoutMsg: `Element ${args.elementName} did not become clickable`
                 });
-                args.scriptDataAppender.add(async () => {
-                    return {
-                        nlpName: 'MOB_WaitTillElementIsClickable',
-                        stepInputs: [],
-                        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: [],
+                    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_WaitTillElementIsClickable");
+                args.scriptDataAppender.setErrorNLP(nlpName);
                 throw new Error(`WaitTillElementIsClickable action failed`, { cause: error });
             }
             break;
@@ -40,18 +44,17 @@ async function waitTillElementIsClickable(args) {
                     timeout: 10000,
                     timeoutMsg: `Element ${args.elementName} did not become clickable`
                 });
-                args.scriptDataAppender.add(async () => {
-                    const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex}"]`);
-                    return {
-                        nlpName: 'WaitTillElementIsClickable',
-                        stepInputs: [],
-                        elementsData: [{
-                                name: args.elementName,
-                                type: args.elementType,
-                                locators: ffElement.locators,
-                                platform: args.platform
-                            }]
-                    };
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: "WaitTillElementIsClickable",
+                    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/waitTillPresenceOfAllElements.js

@@ -2,22 +2,36 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.waitTillPresenceOfAllElements = waitTillPresenceOfAllElements;
 const logData_js_1 = require("../../../../utils/logger/logData.js");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function waitTillPresenceOfAllElements(args) {
+    const nlpName = args.platform === "ios" ? "IOS_WaitTillPresenceOfAllElements" : "MOB_WaitTillPresenceOfAllElements";
     switch (args.platform) {
         case "android":
+        case "ios":
             try {
                 const parts = args.value.split(",");
                 const locatorType = parts[0].trim();
                 const locatorValue = parts[1].trim();
-                const elements = await args.driver.$$(locatorType === "xpath"
-                    ? locatorValue
-                    : locatorType === "text"
-                        ? `android=new UiSelector().text("${locatorValue}")`
-                        : locatorType === "content-desc"
-                            ? `~${locatorValue}`
-                            : locatorType === "resource-id"
-                                ? `id=${locatorValue}`
-                                : locatorValue);
+                const elements = await args.driver.$$(args.platform === "android"
+                    ? locatorType === "xpath"
+                        ? locatorValue
+                        : locatorType === "text"
+                            ? `android=new UiSelector().text("${locatorValue}")`
+                            : locatorType === "content-desc"
+                                ? `~${locatorValue}`
+                                : locatorType === "resource-id"
+                                    ? `id=${locatorValue}`
+                                    : locatorValue
+                    : // iOS
+                        locatorType === "xpath"
+                            ? locatorValue
+                            : locatorType === "name"
+                                ? `-ios predicate string:name == "${locatorValue}"`
+                                : locatorType === "label"
+                                    ? `-ios predicate string:label == "${locatorValue}"`
+                                    : locatorType === "value"
+                                        ? `-ios predicate string:value == "${locatorValue}"`
+                                        : `-ios predicate string:name CONTAINS "${locatorValue}" OR label CONTAINS "${locatorValue}" OR value CONTAINS "${locatorValue}"`);
                 logData_js_1.logger.info(`Waiting for ${elements.length} elements to be present`);
                 await args.driver.waitUntil(async () => {
                     return await elements.length > 0;
@@ -25,16 +39,14 @@ async function waitTillPresenceOfAllElements(args) {
                     timeout: 6000,
                     timeoutMsg: "Elements not present"
                 });
-                args.scriptDataAppender.add(async () => {
-                    return {
-                        nlpName: 'MOB_WaitTillPresenceOfAllElements',
-                        stepInputs: [locatorType, locatorValue],
-                        elementsData: []
-                    };
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: nlpName,
+                    stepInputs: [locatorType, locatorValue]
                 });
             }
             catch (error) {
-                args.scriptDataAppender.setErrorNLP("MOB_WaitTillPresenceOfAllElements");
+                args.scriptDataAppender.setErrorNLP(nlpName);
                 throw new Error(`WaitTillPresenceOfAllElements action failed`, { cause: error });
             }
             break;
@@ -51,12 +63,10 @@ async function waitTillPresenceOfAllElements(args) {
                     timeout: 10000,
                     timeoutMsg: "Elements not present"
                 });
-                args.scriptDataAppender.add(async () => {
-                    return {
-                        nlpName: 'WaitTillPresenceOfAllElements',
-                        stepInputs: [locatorType, locatorValue],
-                        elementsData: []
-                    };
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: "WaitTillPresenceOfAllElements",
+                    stepInputs: [locatorType, locatorValue]
                 });
             }
             catch (error) {

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

@@ -1,27 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.waitTillPresenceOfElement = waitTillPresenceOfElement;
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function waitTillPresenceOfElement(args) {
+    const nlpName = args.platform === "ios" ? "IOS_WaitTillPresenceOfElement" : "MOB_WaitTillPresenceOfElement";
     switch (args.platform) {
         case "android":
+        case "ios":
             try {
                 const element = await args.driver.$(args.selector);
                 await element.waitForExist({ timeout: 10000 });
-                args.scriptDataAppender.add(async () => {
-                    return {
-                        nlpName: 'MOB_WaitTillPresenceOfElement',
-                        stepInputs: [],
-                        elementsData: [{
-                                name: args.elementName,
-                                type: args.elementType,
-                                locators: [{ xpath: args.value }],
-                                platform: args.platform
-                            }]
-                    };
+                (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("MOB_WaitTillPresenceOfElement");
+                args.scriptDataAppender.setErrorNLP(nlpName);
                 throw new Error(`WaitTillPresenceOfElement action failed`, { cause: error });
             }
             break;
@@ -30,18 +33,17 @@ async function waitTillPresenceOfElement(args) {
             try {
                 const element = await args.driver.$(args.selector);
                 await element.waitForExist({ timeout: 10000 });
-                args.scriptDataAppender.add(async () => {
-                    const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex}"]`);
-                    return {
-                        nlpName: 'WaitTillPresenceOfElement',
-                        stepInputs: [],
-                        elementsData: [{
-                                name: args.elementName,
-                                type: args.elementType,
-                                locators: ffElement.locators,
-                                platform: args.platform
-                            }]
-                    };
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: 'WaitTillPresenceOfElement',
+                    stepInputs: [],
+                    pageDOM: args.pageDOM,
+                    elementGetter: args.elementGetter,
+                    ffNumber: args.fireflinkIndex,
+                    elementName: args.elementName,
+                    elementType: args.elementType,
+                    selector: args.selector,
+                    platform: args.platform
                 });
             }
             catch (error) {