ff-automationv2 2.2.7 → 2.2.10

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

@@ -0,0 +1,16 @@
+export const MOB_VerifyIfDeviceIsLocked = async (args) => {
+    try {
+        const _locked = await args.driver.isLocked();
+        args.scriptDataAppender.add(async () => {
+            return {
+                nlpName: "MOB_VerifyIfDeviceIsLocked",
+                stepInputs: [],
+                elementsData: []
+            };
+        });
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_VerifyIfDeviceIsLocked");
+        throw new Error("MOB_VerifyIfDeviceIsLocked action failed", { cause: error });
+    }
+};

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

@@ -0,0 +1,2 @@
+import { MOB_VerifyIfDeviceIsUnlockedInterface } from "../../interface/verifyActionInterface";
+export declare const MOB_VerifyIfDeviceIsUnlocked: (args: MOB_VerifyIfDeviceIsUnlockedInterface) => Promise<void>;

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

@@ -0,0 +1,17 @@
+export const MOB_VerifyIfDeviceIsUnlocked = async (args) => {
+    try {
+        const locked = await args.driver.isLocked();
+        const _unlocked = !locked;
+        args.scriptDataAppender.add(async () => {
+            return {
+                nlpName: "MOB_VerifyIfDeviceIsUnlocked",
+                stepInputs: [],
+                elementsData: []
+            };
+        });
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_VerifyIfDeviceIsUnlocked");
+        throw new Error("MOB_VerifyIfDeviceIsUnlocked action failed", { cause: error });
+    }
+};

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

@@ -0,0 +1,2 @@
+import { MOB_VerifyIfGpsOffInterface } from "../../interface/verifyActionInterface";
+export declare const MOB_VerifyIfGpsOff: (args: MOB_VerifyIfGpsOffInterface) => Promise<void>;

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

@@ -0,0 +1,17 @@
+export const MOB_VerifyIfGpsOff = async (args) => {
+    try {
+        const location = await args.driver.getGeoLocation();
+        const _gpsOff = !location;
+        args.scriptDataAppender.add(async () => {
+            return {
+                nlpName: "MOB_VerifyIfGpsOff",
+                stepInputs: [],
+                elementsData: []
+            };
+        });
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_VerifyIfGpsOff");
+        throw new Error("MOB_VerifyIfGpsOff action failed", { cause: error });
+    }
+};

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

@@ -0,0 +1,2 @@
+import { MOB_VerifyIfGpsOnInterface } from "../../interface/verifyActionInterface";
+export declare const MOB_VerifyIfGpsOn: (args: MOB_VerifyIfGpsOnInterface) => Promise<void>;

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

@@ -0,0 +1,17 @@
+export const MOB_VerifyIfGpsOn = async (args) => {
+    try {
+        const location = await args.driver.getGeoLocation();
+        const _gpsOn = !!location;
+        args.scriptDataAppender.add(async () => {
+            return {
+                nlpName: "MOB_VerifyIfGpsOn",
+                stepInputs: [],
+                elementsData: []
+            };
+        });
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_VerifyIfGpsOn");
+        throw new Error("MOB_VerifyIfGpsOn action failed", { cause: error });
+    }
+};

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

@@ -0,0 +1,2 @@
+import { MOB_VerifyIfKeyboardIsHiddenInterface } from "../../interface/verifyActionInterface";
+export declare const MOB_VerifyIfKeyboardIsHidden: (args: MOB_VerifyIfKeyboardIsHiddenInterface) => Promise<void>;

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

@@ -0,0 +1,17 @@
+export const MOB_VerifyIfKeyboardIsHidden = async (args) => {
+    try {
+        const shown = await args.driver.isKeyboardShown();
+        const _hidden = !shown;
+        args.scriptDataAppender.add(async () => {
+            return {
+                nlpName: "MOB_VerifyIfKeyboardIsHidden",
+                stepInputs: [],
+                elementsData: []
+            };
+        });
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_VerifyIfKeyboardIsHidden");
+        throw new Error("MOB_VerifyIfKeyboardIsHidden action failed", { cause: error });
+    }
+};

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

@@ -0,0 +1,2 @@
+import { MOB_VerifyIfKeyboardIsShownInterface } from "../../interface/verifyActionInterface";
+export declare const MOB_VerifyIfKeyboardIsShown: (args: MOB_VerifyIfKeyboardIsShownInterface) => Promise<void>;

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

@@ -0,0 +1,16 @@
+export const MOB_VerifyIfKeyboardIsShown = async (args) => {
+    try {
+        const _shown = await args.driver.isKeyboardShown();
+        args.scriptDataAppender.add(async () => {
+            return {
+                nlpName: "MOB_VerifyIfKeyboardIsShown",
+                stepInputs: [],
+                elementsData: []
+            };
+        });
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_VerifyIfKeyboardIsShown");
+        throw new Error("MOB_VerifyIfKeyboardIsShown action failed", { cause: error });
+    }
+};

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

@@ -0,0 +1,2 @@
+import { MOB_VerifyIfWifiOffInterface } from "../../interface/verifyActionInterface";
+export declare const MOB_VerifyIfWifiOff: (args: MOB_VerifyIfWifiOffInterface) => Promise<void>;

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

@@ -0,0 +1,17 @@
+export const MOB_VerifyIfWifiOff = async (args) => {
+    try {
+        const connection = await args.driver.getNetworkConnection();
+        const _wifiOff = !(connection === 2 || connection === 6);
+        args.scriptDataAppender.add(async () => {
+            return {
+                nlpName: "MOB_VerifyIfWifiOff",
+                stepInputs: [],
+                elementsData: []
+            };
+        });
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_VerifyIfWifiOff");
+        throw new Error("MOB_VerifyIfWifiOff action failed", { cause: error });
+    }
+};

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

@@ -0,0 +1,2 @@
+import { MOB_VerifyIfWifiOnInterface } from "../../interface/verifyActionInterface";
+export declare const MOB_VerifyIfWifiOn: (args: MOB_VerifyIfWifiOnInterface) => Promise<void>;

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

@@ -0,0 +1,17 @@
+export const MOB_VerifyIfWifiOn = async (args) => {
+    try {
+        const connection = await args.driver.getNetworkConnection();
+        const _wifiOn = connection === 2 || connection === 6;
+        args.scriptDataAppender.add(async () => {
+            return {
+                nlpName: "MOB_VerifyIfWifiOn",
+                stepInputs: [],
+                elementsData: []
+            };
+        });
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_VerifyIfWifiOn");
+        throw new Error("MOB_VerifyIfWifiOn action failed", { cause: error });
+    }
+};

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

@@ -1,28 +1,64 @@
 import { logger } from "../../../../utils/logger/logData.js";
 export async function verifyAttributeValue(args) {
     switch (args.platform) {
+        // ================= ANDROID =================
         case "android":
             try {
                 const element = await args.driver.$(args.selector);
-                const parts = args.value.split(",");
-                const attrName = parts[0].trim();
-                const expectedValue = parts[1].trim();
-                const caseSensitive = false;
-                const actualValue = (await element.getAttribute(attrName)) ||
-                    "";
-                const isMatched = actualValue.toLowerCase() === expectedValue.toLowerCase();
-                logger.info("Attribute value verification result:", { isMatched, actualValue, expectedValue });
-                if (isMatched === false) {
-                    throw new Error(`Attribute value does not match. Expected: ${expectedValue}, Actual: ${actualValue}`);
+                if (!element) {
+                    throw new Error("Element not found");
                 }
+                // -------- SAFE PARSING --------
+                let attrName = "text"; // default for mobile
+                let expectedValue = "";
+                if (args.value && args.value.includes(",")) {
+                    const parts = args.value.split(",");
+                    attrName = parts[0]?.trim() || "text";
+                    expectedValue = parts[1]?.trim() || "";
+                }
+                else {
+                    expectedValue = args.value?.trim() || "";
+                }
+                // -------- GET ACTUAL VALUE --------
+                let actualValue = "";
+                switch (attrName.toLowerCase()) {
+                    case "text":
+                        actualValue = await element.getText();
+                        break;
+                    case "content-desc":
+                        actualValue = await element.getAttribute("content-desc") || "";
+                        break;
+                    case "resource-id":
+                        actualValue = await element.getAttribute("resource-id") || "";
+                        break;
+                    case "enabled":
+                        actualValue = await element.getAttribute("enabled") || "";
+                        break;
+                    default:
+                        actualValue = await element.getAttribute(attrName) || "";
+                }
+                // -------- MATCH LOGIC (FLEXIBLE) --------
+                const isMatched = actualValue
+                    .toLowerCase()
+                    .includes(expectedValue.toLowerCase());
+                logger.info("Attribute value verification result:", {
+                    attrName,
+                    expectedValue,
+                    actualValue,
+                    isMatched
+                });
+                if (!isMatched) {
+                    throw new Error(`Attribute value mismatch. Expected to contain: "${expectedValue}", Actual: "${actualValue}"`);
+                }
+                // -------- APPENDER --------
                 args.scriptDataAppender.add(async () => {
                     return {
-                        nlpName: 'MOB_VerifyAttributeValue',
-                        stepInputs: [attrName, expectedValue, caseSensitive],
+                        nlpName: "MOB_VerifyAttributeValue",
+                        stepInputs: [attrName, expectedValue, false],
                         elementsData: [{
                                 name: args.elementName,
                                 type: args.elementType,
-                                locators: [{ "xpath": args.selector }],
+                                locators: [{ xpath: args.selector }],
                                 platform: args.platform
                             }]
                     };
@@ -30,30 +66,58 @@ export async function verifyAttributeValue(args) {
             }
             catch (error) {
                 args.scriptDataAppender.setErrorNLP("MOB_VerifyAttributeValue");
-                throw new Error(`VerifyAttributeValue action failed `, { cause: error });
+                throw new Error(`VerifyAttributeValue action failed`, { cause: error });
             }
             break;
+        // ================= WEB =================
         case "web":
         default:
             try {
                 const element = await args.driver.$(args.selector);
-                const parts = args.value.split(",");
-                const attrName = parts[0].trim();
-                const expectedValue = parts[1].trim();
-                const caseSensitive = false;
-                const actualValue = (await element.getAttribute(attrName)) ||
-                    (await element.getText()) ||
-                    "";
-                const isMatched = actualValue.toLowerCase() === expectedValue.toLowerCase();
-                logger.info("Attribute value verification result:", { isMatched, actualValue, expectedValue });
-                if (isMatched === false) {
-                    throw new Error(`Attribute value does not match. Expected: ${expectedValue}, Actual: ${actualValue}`);
+                if (!element) {
+                    throw new Error("Element not found");
+                }
+                // -------- SAFE PARSING --------
+                let attrName = "text";
+                let expectedValue = "";
+                if (args.value && args.value.includes(",")) {
+                    const parts = args.value.split(",");
+                    attrName = parts[0]?.trim() || "text";
+                    expectedValue = parts[1]?.trim() || "";
+                }
+                else {
+                    expectedValue = args.value?.trim() || "";
+                }
+                // -------- GET VALUE (ATTRIBUTE OR TEXT FALLBACK) --------
+                let actualValue = "";
+                if (attrName === "text") {
+                    actualValue = await element.getText();
+                }
+                else {
+                    actualValue =
+                        (await element.getAttribute(attrName)) ||
+                            (await element.getText()) ||
+                            "";
+                }
+                // -------- MATCH LOGIC --------
+                const isMatched = actualValue
+                    .toLowerCase()
+                    .includes(expectedValue.toLowerCase());
+                logger.info("Attribute value verification result:", {
+                    attrName,
+                    expectedValue,
+                    actualValue,
+                    isMatched
+                });
+                if (!isMatched) {
+                    throw new Error(`Attribute value mismatch. Expected to contain: "${expectedValue}", Actual: "${actualValue}"`);
                 }
+                // -------- APPENDER --------
                 args.scriptDataAppender.add(async () => {
                     const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex}"]`);
                     return {
-                        nlpName: 'VerifyAttributeValue',
-                        stepInputs: [attrName, expectedValue, caseSensitive],
+                        nlpName: "VerifyAttributeValue",
+                        stepInputs: [attrName, expectedValue, false],
                         elementsData: [{
                                 name: args.elementName,
                                 type: args.elementType,
@@ -65,7 +129,7 @@ export async function verifyAttributeValue(args) {
             }
             catch (error) {
                 args.scriptDataAppender.setErrorNLP("VerifyAttributeValue");
-                throw new Error(`VerifyAttributeValue action failed `, { cause: error });
+                throw new Error(`VerifyAttributeValue action failed`, { cause: error });
             }
             break;
     }

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

@@ -4,8 +4,9 @@ export async function verifyHeightOfWebElement(args) {
         case "android":
             try {
                 const element = await args.driver.$(args.selector);
-                const expectedHeight = parseInt(args.value, 10);
+                const expectedHeight = Number(args.value);
                 const size = await element.getSize();
+                logger.info(`Expected height :${expectedHeight}`);
                 const isMatched = size.height === expectedHeight;
                 logger.info("Height verification result:", {
                     isMatched,

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

@@ -2,12 +2,10 @@ import { logger } from "../../../../utils/logger/logData.js";
 export async function verifyListBoxOptionsAreSorted(args) {
     try {
         const element = await args.driver.$(args.selector);
-        // Get all <option> elements
         const options = await element.$$("option");
         if (!options || await options.length === 0) {
             logger.info("No dropdown options found.");
         }
-        // Extract visible text safely (avoids Promise.all typing issue)
         const optionTexts = [];
         for (const option of options) {
             const text = await option.getText();

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

@@ -1,60 +1,121 @@
 import { logger } from "../../../../utils/logger/logData.js";
 export async function verifyPartialAttributeValue(args) {
     switch (args.platform) {
+        // ================= ANDROID =================
         case "android":
             try {
                 const element = await args.driver.$(args.selector);
-                const parts = args.value.split(",");
-                const attrName = parts[0].trim();
-                const expectedValue = parts[1].trim();
-                const caseSensitive = false;
-                const actualValue = (await element.getAttribute(attrName)) ||
-                    (await element.getText()) ||
-                    "";
-                const isMatched = actualValue.toLowerCase().includes(expectedValue.toLowerCase());
-                logger.info("Attribute value verification result:", { isMatched, actualValue, expectedValue });
-                if (isMatched === false) {
-                    throw new Error(`Attribute "${attrName}" value does not contain expected text. Expected to contain: "${expectedValue}", Actual: "${actualValue}"`);
+                if (!element) {
+                    throw new Error("Element not found");
                 }
-                args.scriptDataAppender.add(async () => {
-                    return {
-                        nlpName: 'MOB_VerifyPartialAttributeValue',
-                        stepInputs: [attrName, expectedValue, caseSensitive],
-                        elementsData: [{
-                                name: args.elementName,
-                                type: args.elementType,
-                                locators: [{ "xpath": args.selector }],
-                                platform: args.platform
-                            }]
-                    };
+                // -------- SAFE PARSING --------
+                let attrName = "text";
+                let expectedValue = "";
+                if (args.value && args.value.includes(",")) {
+                    const parts = args.value.split(",");
+                    attrName = parts[0]?.trim() || "text";
+                    expectedValue = parts[1]?.trim() || "";
+                }
+                else {
+                    expectedValue = args.value?.trim() || "";
+                }
+                // -------- GET VALUE --------
+                let actualValue = "";
+                switch (attrName.toLowerCase()) {
+                    case "text":
+                        actualValue = await element.getText();
+                        break;
+                    case "content-desc":
+                        actualValue = await element.getAttribute("content-desc") || "";
+                        break;
+                    case "resource-id":
+                        actualValue = await element.getAttribute("resource-id") || "";
+                        break;
+                    default:
+                        actualValue =
+                            (await element.getAttribute(attrName)) ||
+                                (await element.getText()) ||
+                                "";
+                }
+                // -------- PARTIAL MATCH --------
+                const isMatched = actualValue
+                    .toLowerCase()
+                    .includes(expectedValue.toLowerCase());
+                logger.info("Partial attribute verification:", {
+                    attrName,
+                    expectedValue,
+                    actualValue,
+                    isMatched
                 });
+                if (!isMatched) {
+                    throw new Error(`Attribute "${attrName}" does not contain "${expectedValue}". Actual: "${actualValue}"`);
+                }
+                // -------- APPENDER --------
+                args.scriptDataAppender.add(async () => ({
+                    nlpName: "MOB_VerifyPartialAttributeValue",
+                    stepInputs: [attrName, expectedValue, false],
+                    elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: [{ xpath: args.selector }],
+                            platform: args.platform
+                        }]
+                }));
             }
             catch (error) {
                 args.scriptDataAppender.setErrorNLP("MOB_VerifyPartialAttributeValue");
-                throw new Error(`VerifyPartialAttributeValue action failed `, { cause: error });
+                throw new Error(`VerifyPartialAttributeValue action failed`, { cause: error });
             }
             break;
+        // ================= WEB =================
         case "web":
         default:
             try {
                 const element = await args.driver.$(args.selector);
-                const parts = args.value.split(",");
-                const attrName = parts[0].trim();
-                const expectedValue = parts[1].trim();
-                const caseSensitive = false;
-                const actualValue = (await element.getAttribute(attrName)) ||
-                    (await element.getText()) ||
-                    "";
-                const isMatched = actualValue.toLowerCase().includes(expectedValue.toLowerCase());
-                logger.info("Attribute value verification result:", { isMatched, actualValue, expectedValue });
-                if (isMatched === false) {
-                    throw new Error(`Attribute "${attrName}" value does not contain expected text. Expected to contain: "${expectedValue}", Actual: "${actualValue}"`);
+                if (!element) {
+                    throw new Error("Element not found");
+                }
+                // -------- SAFE PARSING --------
+                let attrName = "text";
+                let expectedValue = "";
+                if (args.value && args.value.includes(",")) {
+                    const parts = args.value.split(",");
+                    attrName = parts[0]?.trim() || "text";
+                    expectedValue = parts[1]?.trim() || "";
+                }
+                else {
+                    expectedValue = args.value?.trim() || "";
+                }
+                // -------- GET VALUE --------
+                let actualValue = "";
+                if (attrName === "text") {
+                    actualValue = await element.getText();
+                }
+                else {
+                    actualValue =
+                        (await element.getAttribute(attrName)) ||
+                            (await element.getText()) ||
+                            "";
+                }
+                // -------- PARTIAL MATCH --------
+                const isMatched = actualValue
+                    .toLowerCase()
+                    .includes(expectedValue.toLowerCase());
+                logger.info("Partial attribute verification:", {
+                    attrName,
+                    expectedValue,
+                    actualValue,
+                    isMatched
+                });
+                if (!isMatched) {
+                    throw new Error(`Attribute "${attrName}" does not contain "${expectedValue}". Actual: "${actualValue}"`);
                 }
+                // -------- APPENDER --------
                 args.scriptDataAppender.add(async () => {
                     const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex}"]`);
                     return {
-                        nlpName: 'VerifyPartialAttributeValue',
-                        stepInputs: [attrName, expectedValue, caseSensitive],
+                        nlpName: "VerifyPartialAttributeValue",
+                        stepInputs: [attrName, expectedValue, false],
                         elementsData: [{
                                 name: args.elementName,
                                 type: args.elementType,
@@ -66,7 +127,7 @@ export async function verifyPartialAttributeValue(args) {
             }
             catch (error) {
                 args.scriptDataAppender.setErrorNLP("VerifyPartialAttributeValue");
-                throw new Error(`VerifyPartialAttributeValue action failed `, { cause: error });
+                throw new Error(`VerifyPartialAttributeValue action failed`, { cause: error });
             }
             break;
     }

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

@@ -6,7 +6,7 @@ export async function verifyPartialText(args) {
                 const element = await args.driver.$(args.selector);
                 const actual = await element.getAttribute("text");
                 const expected = args.value;
-                if (actual !== expected) {
+                if (!actual?.includes(expected)) {
                     throw new Error(`Element does not contain the expected text. Expected to contain: "${args.value}", Actual: "${actual}"`);
                 }
                 const caseSensitive = false;

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

@@ -7,8 +7,11 @@ export async function verifyText(args) {
                 const text = (await element.getAttribute("text")) || "";
                 const contentDesc = (await element.getAttribute("content-desc")) || "";
                 const expected = (args.value || "").toLowerCase();
-                const isMatched = text.toLowerCase() === expected ||
-                    contentDesc.toLowerCase() === expected;
+                const isMatched = text.toLowerCase().trim() === expected.trim() ||
+                    contentDesc.toLowerCase().trim() === expected.trim();
+                logger.info("text", { text });
+                logger.info("contentDesc", { contentDesc });
+                logger.info("expected", { expected });
                 logger.info("result of verify text:", { isMatched });
                 const caseSensitive = false; // Assuming case-insensitive for logging
                 if (isMatched === false) {

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

@@ -0,0 +1,2 @@
+import { MOB_WaitTillAllElementsAreInvisibleInterface } from "../../interface/waitActionInterface";
+export declare const MOB_WaitTillAllElementsAreInvisible: (args: MOB_WaitTillAllElementsAreInvisibleInterface) => Promise<void>;

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

@@ -0,0 +1,25 @@
+export const MOB_WaitTillAllElementsAreInvisible = async (args) => {
+    try {
+        const elements = await args.driver.$$("*");
+        for (const element of elements) {
+            try {
+                await element.waitForDisplayed({ reverse: true, timeout: 5000 });
+            }
+            catch {
+                // ignore if element cannot be waited on
+                continue;
+            }
+        }
+        args.scriptDataAppender.add(async () => {
+            return {
+                nlpName: "MOB_WaitTillAllElementsAreInvisible",
+                stepInputs: [],
+                elementsData: []
+            };
+        });
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_WaitTillAllElementsAreInvisible");
+        throw new Error("MOB_WaitTillAllElementsAreInvisible action failed", { cause: error });
+    }
+};

package/dist/automation/actions/interaction/wait/MOB_WaitTillAttributeOfElementContainsString.d.ts

@@ -0,0 +1,2 @@
+import { MOB_WaitTillAttributeOfElementContainsStringInterface } from "../../interface/waitActionInterface";
+export declare const MOB_WaitTillAttributeOfElementContainsString: (args: MOB_WaitTillAttributeOfElementContainsStringInterface) => Promise<void>;

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

@@ -0,0 +1,27 @@
+export const MOB_WaitTillAttributeOfElementContainsString = async (args) => {
+    try {
+        const attributeName = args.attributeName || "text";
+        const expectedValue = args.value;
+        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: [{ xpath: args.selector }],
+                        platform: args.platform
+                    }]
+            };
+        });
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_WaitTillAttributeOfElementContainsString");
+        throw new Error("MOB_WaitTillAttributeOfElementContainsString action failed", { cause: error });
+    }
+};

package/dist/automation/actions/interaction/wait/MOB_WaitTillElementIsEnabled.d.ts

@@ -0,0 +1,2 @@
+import { MOB_WaitTillElementIsEnabledInterface } from "../../interface/waitActionInterface";
+export declare const MOB_WaitTillElementIsEnabled: (args: MOB_WaitTillElementIsEnabledInterface) => Promise<void>;