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

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

@@ -0,0 +1,70 @@
+"use strict";
+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);
+                await args.driver.waitUntil(async () => {
+                    return await element.isDisplayed();
+                }, {
+                    timeout,
+                    timeoutMsg: "Element not displayed within given time"
+                });
+                logData_js_1.logger.info("Element displayed successfully");
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: nlpName,
+                    stepInputs: [args.variableName ? `variable:${args.variableName}` : args.value],
+                    pageDOM: args.pageDOM,
+                    elementGetter: args.elementGetter,
+                    ffNumber: args.fireflinkIndex,
+                    elementName: args.elementName,
+                    elementType: args.elementType,
+                    selector: args.selector,
+                    platform: args.platform
+                });
+            }
+            catch (error) {
+                args.scriptDataAppender.setErrorNLP(nlpName);
+                throw new Error(`CheckIfElementIsDisplayed action failed`, { cause: error });
+            }
+            break;
+        case "web":
+        default:
+            try {
+                const element = await args.driver.$(args.selector);
+                const timeout = parseInt(args.value || "10000", 10);
+                await args.driver.waitUntil(async () => {
+                    return await element.isDisplayed();
+                }, {
+                    timeout,
+                    timeoutMsg: "Element not displayed within given time"
+                });
+                logData_js_1.logger.info("Element displayed successfully");
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: "CheckIfElementIsDisplayed",
+                    stepInputs: [args.variableName ? `variable:${args.variableName}` : 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("CheckIfElementIsDisplayed");
+                throw new Error(`CheckIfElementIsDisplayed action failed`, { cause: error });
+            }
+            break;
+    }
+}

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.d.ts

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

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

@@ -0,0 +1,119 @@
+"use strict";
+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 isWebView = args.pageDOM?.includes("ff-inspect");
+                let actual;
+                if (isWebView) {
+                    actual = (await element.getText()) || "";
+                }
+                else {
+                    const attributeName = args.platform === "ios" ? "value" : "text";
+                    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;
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: nlpName,
+                    stepInputs: [args.variableName ? `variable:${args.variableName}` : 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(nlpName);
+                throw new Error(`VerifyPartialText action failed `, { cause: error });
+            }
+            break;
+        case "web":
+        default:
+            try {
+                const element = await args.driver.$(args.selector);
+                const normalizeText = (text) => {
+                    if (!text)
+                        return "";
+                    // Remove zero-width characters
+                    text = text.replace(/\p{Cf}/gu, "");
+                    // Normalize spaces
+                    text = text.replace(/\s+/g, " ");
+                    return text.trim().toLowerCase();
+                };
+                const expected = normalizeText(args.value);
+                const texts = [];
+                // Visible text
+                const visibleText = await element.getText();
+                if (visibleText)
+                    texts.push(visibleText);
+                // Input value
+                const value = await element.getAttribute("value");
+                if (value)
+                    texts.push(value);
+                // Accessibility attributes
+                const attributes = ["placeholder", "aria-label", "name", "id"];
+                for (const attr of attributes) {
+                    const v = await element.getAttribute(attr);
+                    if (v)
+                        texts.push(v);
+                }
+                // Fallback attributes
+                const fallbackAttrs = ["textContent", "innerText"];
+                for (const attr of fallbackAttrs) {
+                    const v = await element.getAttribute(attr);
+                    if (v)
+                        texts.push(v);
+                }
+                // Debug (limited text logging)
+                const limited = texts.map(t => t.length > 50 ? t.substring(0, 50) + "..." : t);
+                logData_js_1.logger.info("Extracted texts for verification:", { extractedTexts: limited });
+                logData_js_1.logger.info("Expected text for verification:", { expectedText: expected });
+                let isMatched = false;
+                for (const t of texts) {
+                    const clean = normalizeText(t);
+                    if (clean.includes(expected)) {
+                        isMatched = true;
+                        break;
+                    }
+                }
+                const caseSensitive = false;
+                // FireFlink Logging
+                logData_js_1.logger.info("result of verify text:", { isMatched });
+                if (isMatched === false) {
+                    throw new Error(`Element does not contain the expected text. Expected to contain: "${args.value}", Actual texts: ${limited.join(" | ")}`);
+                }
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: "VerifyPartialText",
+                    stepInputs: [args.variableName ? `variable:${args.variableName}` : 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("VerifyPartialText");
+                throw new Error(`VerifyPartialText action failed `, { cause: error });
+            }
+            break;
+    }
+}

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

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

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

@@ -0,0 +1,124 @@
+"use strict";
+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 isWebView = args.pageDOM?.includes("ff-inspect");
+                let text;
+                if (isWebView) {
+                    text = (await element.getText()) || "";
+                }
+                else {
+                    const attributeName = args.platform === "ios" ? "value" : "text";
+                    text = (await element.getAttribute(attributeName)) || "";
+                }
+                const expected = (args.value || "").toLowerCase();
+                const isMatched = text.toLowerCase().trim() === expected.trim();
+                logData_js_1.logger.info("text", { text });
+                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}"`);
+                }
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: nlpName,
+                    stepInputs: [args.variableName ? `variable:${args.variableName}` : 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(nlpName);
+                throw new Error(`VerifyText action failed `, { cause: error });
+            }
+            break;
+        case "web":
+        default:
+            try {
+                const element = await args.driver.$(args.selector);
+                const normalizeText = (text) => {
+                    if (!text)
+                        return "";
+                    // Remove zero-width characters
+                    text = text.replace(/\p{Cf}/gu, "");
+                    // Normalize spaces
+                    text = text.replace(/\s+/g, " ");
+                    return text.trim().toLowerCase();
+                };
+                const expected = normalizeText(args.value);
+                const texts = [];
+                // Visible text
+                const visibleText = await element.getText();
+                if (visibleText)
+                    texts.push(visibleText);
+                // Input value
+                const value = await element.getAttribute("value");
+                logData_js_1.logger.info("Extracted value attribute for verification:", { value });
+                if (value)
+                    texts.push(value);
+                // Accessibility attributes
+                const attributes = ["placeholder", "aria-label", "name", "id"];
+                for (const attr of attributes) {
+                    const v = await element.getAttribute(attr);
+                    if (v)
+                        texts.push(v);
+                }
+                // Fallback attributes
+                const fallbackAttrs = ["textContent", "innerText"];
+                for (const attr of fallbackAttrs) {
+                    const v = await element.getAttribute(attr);
+                    if (v)
+                        texts.push(v);
+                }
+                // Debug (limited text logging)
+                const limited = texts.map(t => t.length > 50 ? t.substring(0, 50) + "..." : t);
+                logData_js_1.logger.info("Extracted texts for verification:", { extractedTexts: limited });
+                logData_js_1.logger.info("Expected text for verification:", { expectedText: expected });
+                let isMatched = false;
+                for (const t of texts) {
+                    const clean = normalizeText(t);
+                    if (expected === clean) {
+                        isMatched = true;
+                        break;
+                    }
+                }
+                // FireFlink Logging
+                logData_js_1.logger.info("result of verify text:", { isMatched });
+                const caseSensitive = false;
+                if (isMatched === false) {
+                    throw new Error(`Element text does not match expected. Expected: "${args.value}", Actual: "${texts.join(" | ")}"`);
+                }
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: "VerifyText",
+                    stepInputs: [args.variableName ? `variable:${args.variableName}` : 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("VerifyText");
+                throw new Error(`VerifyText action failed `, { cause: error });
+            }
+            break;
+    }
+}

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,28 @@
+"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) {
+            try {
+                await element.waitForDisplayed({ reverse: true, timeout: 5000 });
+            }
+            catch {
+                // ignore if element cannot be waited on
+                continue;
+            }
+        }
+        (0, appendScriptData_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: nlpName
+        });
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_WaitTillAllElementsAreInvisible");
+        throw new Error("MOB_WaitTillAllElementsAreInvisible action failed", { cause: error });
+    }
+};
+exports.MOB_WaitTillAllElementsAreInvisible = MOB_WaitTillAllElementsAreInvisible;

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,34 @@
+"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 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 });
+        (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(nlpName);
+        throw new Error("MOB_WaitTillAttributeOfElementContainsString action failed", { cause: error });
+    }
+};
+exports.MOB_WaitTillAttributeOfElementContainsString = MOB_WaitTillAttributeOfElementContainsString;

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>;

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

@@ -0,0 +1,27 @@
+"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 });
+        (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) {
+        args.scriptDataAppender.setErrorNLP("MOB_WaitTillElementIsEnabled");
+        throw new Error("MOB_WaitTillElementIsEnabled action failed", { cause: error });
+    }
+};
+exports.MOB_WaitTillElementIsEnabled = MOB_WaitTillElementIsEnabled;

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

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

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

@@ -0,0 +1,28 @@
+"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 });
+        (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(nlpName);
+        throw new Error("MOB_WaitTillElementIsInvisible action failed", { cause: error });
+    }
+};
+exports.MOB_WaitTillElementIsInvisible = MOB_WaitTillElementIsInvisible;

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

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

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

@@ -0,0 +1,27 @@
+"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 });
+        (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) {
+        args.scriptDataAppender.setErrorNLP("MOB_WaitTillElementIsSelected");
+        throw new Error("MOB_WaitTillElementIsSelected action failed", { cause: error });
+    }
+};
+exports.MOB_WaitTillElementIsSelected = MOB_WaitTillElementIsSelected;

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

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

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

@@ -0,0 +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 });
+        (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(nlpName);
+        throw new Error(`${nlpName} action failed`, { cause: error });
+    }
+};
+exports.MOB_WaitTillElementIsVisible = MOB_WaitTillElementIsVisible;

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

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

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

@@ -0,0 +1,27 @@
+"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 });
+        (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) {
+        args.scriptDataAppender.setErrorNLP("MOB_WaitTillStalenessOfElement");
+        throw new Error("MOB_WaitTillStalenessOfElement action failed", { cause: error });
+    }
+};
+exports.MOB_WaitTillStalenessOfElement = MOB_WaitTillStalenessOfElement;

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

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