ff-automationv2 2.2.28 → 2.2.29

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

@@ -2,34 +2,47 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyElementIsSelected = verifyElementIsSelected;
 const logData_js_1 = require("../../../../utils/logger/logData.js");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function verifyElementIsSelected(args) {
+    const nlpName = args.platform === "ios" ? "IOS_IsSelected" : "MOB_IsSelected";
     switch (args.platform) {
         case "android":
+        case "ios":
             try {
                 const element = await args.driver.$(args.selector);
                 if (!element) {
                     logData_js_1.logger.info("Element not found");
                 }
-                const isSelected = await element.getAttribute("selected");
+                let isSelected;
+                if (args.platform === "ios") {
+                    isSelected = await element.isSelected();
+                }
+                else {
+                    const checked = await element.getAttribute("checked") || "";
+                    const selected = await element.getAttribute("selected") || "";
+                    isSelected =
+                        checked === "true" ||
+                            selected === "true";
+                }
                 logData_js_1.logger.info("Element selected status:", { isSelected });
-                if (isSelected !== "true") {
-                    throw new Error(`Element is not selected. Expected: true, Actual: ${isSelected}`);
+                if (isSelected === false) {
+                    throw new Error(`Element is not selected. Expected: selected, Actual: not selected`);
                 }
-                args.scriptDataAppender.add(async () => {
-                    return {
-                        nlpName: 'MOB_IsSelected',
-                        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_IsSelected");
+                args.scriptDataAppender.setErrorNLP(nlpName);
                 throw new Error(`VerifyElementIsSelected action failed `, { cause: error });
             }
             break;
@@ -45,18 +58,17 @@ async function verifyElementIsSelected(args) {
                 if (isSelected === false) {
                     throw new Error(`Element is not selected. Expected: selected, Actual: not selected`);
                 }
-                args.scriptDataAppender.add(async () => {
-                    const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex}"]`);
-                    return {
-                        nlpName: 'IsSelected',
-                        stepInputs: [],
-                        elementsData: [{
-                                name: args.elementName,
-                                type: args.elementType,
-                                locators: ffElement.locators,
-                                platform: args.platform
-                            }]
-                    };
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: 'IsSelected',
+                    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/verify/VerifyElementIsSelectedInSpecifiedTime.d.ts

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

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

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

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyElementNotContainsText = verifyElementNotContainsText;
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function verifyElementNotContainsText(args) {
     switch (args.platform) {
         case "android":
@@ -11,17 +12,17 @@ async function verifyElementNotContainsText(args) {
                 if (expected == args.value) {
                     throw new Error(`Element do contain the text. Expected: not containing "${args.value}", Actual: contains "${expected}"`);
                 }
-                args.scriptDataAppender.add(async () => {
-                    return {
-                        nlpName: 'MOB_VerifyElementNotContainsText',
-                        stepInputs: [args.value, caseSensitive],
-                        elementsData: [{
-                                name: args.elementName,
-                                type: args.elementType,
-                                locators: [{ "name": "xpath", "value": args.selector }],
-                                platform: args.platform
-                            }]
-                    };
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: "MOB_VerifyElementNotContainsText",
+                    stepInputs: [args.value, caseSensitive],
+                    pageDOM: args.pageDOM,
+                    elementGetter: args.elementGetter,
+                    ffNumber: args.fireflinkIndex,
+                    elementName: args.elementName,
+                    elementType: args.elementType,
+                    selector: args.selector,
+                    platform: args.platform
                 });
             }
             catch (error) {
@@ -78,18 +79,17 @@ async function verifyElementNotContainsText(args) {
                 if (isMatched === true) {
                     throw new Error(`Element contains the text. Expected: not containing "${args.value}", Actual: contains "${args.value}"`);
                 }
-                args.scriptDataAppender.add(async () => {
-                    const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex}"]`);
-                    return {
-                        nlpName: 'VerifyElementNotContainsText',
-                        stepInputs: [args.value, caseSensitive],
-                        elementsData: [{
-                                name: args.elementName,
-                                type: args.elementType,
-                                locators: ffElement.locators,
-                                platform: args.platform
-                            }]
-                    };
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: "VerifyElementNotContainsText",
+                    stepInputs: [args.value, caseSensitive],
+                    pageDOM: args.pageDOM,
+                    elementGetter: args.elementGetter,
+                    ffNumber: args.fireflinkIndex,
+                    elementName: args.elementName,
+                    elementType: args.elementType,
+                    selector: args.selector,
+                    platform: args.platform
                 });
             }
             catch (error) {

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyHeightOfWebElement = verifyHeightOfWebElement;
 const logData_js_1 = require("../../../../utils/logger/logData.js");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function verifyHeightOfWebElement(args) {
     switch (args.platform) {
         case "android":
@@ -19,17 +20,17 @@ async function verifyHeightOfWebElement(args) {
                 if (isMatched === false) {
                     throw new Error(`Element height does not match. Expected: ${expectedHeight}, Actual: ${size.height}`);
                 }
-                args.scriptDataAppender.add(async () => {
-                    return {
-                        nlpName: 'MOB_VerifyHeightOfElement',
-                        stepInputs: [args.value],
-                        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: "MOB_VerifyHeightOfElement",
+                    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) {
@@ -52,18 +53,17 @@ async function verifyHeightOfWebElement(args) {
                 if (isMatched === false) {
                     throw new Error(`Element height does not match. Expected: ${expectedHeight}, Actual: ${size.height}`);
                 }
-                args.scriptDataAppender.add(async () => {
-                    const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex}"]`);
-                    return {
-                        nlpName: 'VerifyHeightOfWebElement',
-                        stepInputs: [args.value],
-                        elementsData: [{
-                                name: args.elementName,
-                                type: args.elementType,
-                                locators: ffElement.locators,
-                                platform: args.platform
-                            }]
-                    };
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: "VerifyHeightOfWebElement",
+                    stepInputs: [args.value],
+                    pageDOM: args.pageDOM,
+                    elementGetter: args.elementGetter,
+                    ffNumber: args.fireflinkIndex,
+                    elementName: args.elementName,
+                    elementType: args.elementType,
+                    selector: args.selector,
+                    platform: args.platform
                 });
             }
             catch (error) {

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

@@ -1,37 +1,67 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyHexCodeForGivenXYCoordinates = verifyHexCodeForGivenXYCoordinates;
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
+const logData_js_1 = require("../../../../utils/logger/logData.js");
 async function verifyHexCodeForGivenXYCoordinates(args) {
     try {
         const inputs = args.value.split(',');
         const expectedHexCode = inputs[0].trim();
         const x = parseInt(inputs[1]);
         const y = parseInt(inputs[2]);
-        const actualHexCode = await args.driver.execute(async (x, y) => {
+        let color = "";
+        const result = await args.driver.execute((x, y) => {
             const el = document.elementFromPoint(x, y);
-            if (!el)
-                return "";
+            if (!el) {
+                return {
+                    success: false,
+                    message: "Element not found"
+                };
+            }
             const style = window.getComputedStyle(el);
-            const color = style.backgroundColor || style.color;
+            color = style.backgroundColor || style.color;
             const match = color.match(/^rgba?\((\d+),\s*(\d+),\s*(\d+)/);
-            if (!match)
-                return color;
+            if (!match) {
+                return {
+                    success: true,
+                    color,
+                    hexCode: color
+                };
+            }
             const r = parseInt(match[1]);
             const g = parseInt(match[2]);
             const b = parseInt(match[3]);
-            return "#" + ((1 << 24) + (r << 16) + (g << 8) + b)
-                .toString(16)
-                .slice(1)
-                .toUpperCase();
+            const hexCode = "#" +
+                ((1 << 24) + (r << 16) + (g << 8) + b)
+                    .toString(16)
+                    .slice(1)
+                    .toUpperCase();
+            return {
+                success: true,
+                color,
+                hexCode
+            };
         }, x, y);
+        if (!result.success) {
+            throw new Error(result.message);
+        }
+        // logger.info("Actual hex code: ", actualHexCode);
+        // logger.info("Expected hex code: ", expectedHexCode);
+        // if (actualHexCode.toUpperCase() !== expectedHexCode.toUpperCase()) {
+        //     throw new Error(`Hex code does not match`);
+        // }
+        const actualHexCode = result.hexCode;
+        logData_js_1.logger.info(`Expected Hex Code: ${expectedHexCode}, Actual Hex Code: ${actualHexCode}, Color: ${result.color},success: ${result.success}`);
+        logData_js_1.logger.info("Actual hex code: ", actualHexCode);
+        logData_js_1.logger.info("Expected hex code: ", expectedHexCode);
         if (actualHexCode.toUpperCase() !== expectedHexCode.toUpperCase()) {
-            throw new Error(`Hex code does not match`);
+            throw new Error(`Hex code does not match. Expected: ${expectedHexCode}, Actual: ${actualHexCode}`);
         }
-        args.scriptDataAppender.add(async () => ({
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
             nlpName: 'VerifyHexCodeForGivenXYCoordinates',
             stepInputs: [x.toString(), y.toString(), expectedHexCode],
-            elementsData: []
-        }));
+        });
     }
     catch (error) {
         args.scriptDataAppender.setErrorNLP("VerifyHexCodeForGivenXYCoordinates");

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyIfAllCookiesAreDeleted = verifyIfAllCookiesAreDeleted;
 const logData_js_1 = require("../../../../utils/logger/logData.js");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function verifyIfAllCookiesAreDeleted(args) {
     try {
         const cookies = await args.driver.getCookies();
@@ -10,11 +11,10 @@ async function verifyIfAllCookiesAreDeleted(args) {
             logData_js_1.logger.info("Cookies are still present.");
             throw new Error("Cookies are still present.");
         }
-        args.scriptDataAppender.add(async () => ({
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
             nlpName: 'VerifyIfAllCookiesAreDeleted',
-            stepInputs: [],
-            elementsData: []
-        }));
+        });
     }
     catch (error) {
         args.scriptDataAppender.setErrorNLP("VerifyIfAllCookiesAreDeleted");

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyIfAudioEnded = verifyIfAudioEnded;
 const logData_js_1 = require("../../../../utils/logger/logData.js");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function verifyIfAudioEnded(args) {
     try {
         const element = await args.driver.$(args.selector);
@@ -13,18 +14,17 @@ async function verifyIfAudioEnded(args) {
             logData_js_1.logger.info("Audio ended status:", isEnded);
             throw new Error("Audio is not ended.");
         }
-        args.scriptDataAppender.add(async () => {
-            const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex}"]`);
-            return {
-                nlpName: 'VerifyIfAudioEnded',
-                stepInputs: [],
-                elementsData: [{
-                        name: args.elementName,
-                        type: args.elementType,
-                        locators: ffElement.locators,
-                        platform: args.platform
-                    }]
-            };
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: 'VerifyIfAudioEnded',
+            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/verify/VerifyIfAudioIsMuted.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyIfAudioIsMuted = verifyIfAudioIsMuted;
 const logData_js_1 = require("../../../../utils/logger/logData.js");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function verifyIfAudioIsMuted(args) {
     try {
         const element = await args.driver.$(args.selector);
@@ -13,18 +14,17 @@ async function verifyIfAudioIsMuted(args) {
             logData_js_1.logger.info("Audio muted status:", isMuted);
             throw new Error("Audio is not muted.");
         }
-        args.scriptDataAppender.add(async () => {
-            const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex}"]`);
-            return {
-                nlpName: 'VerifyIfAudioIsMuted',
-                stepInputs: [],
-                elementsData: [{
-                        name: args.elementName,
-                        type: args.elementType,
-                        locators: ffElement.locators,
-                        platform: args.platform
-                    }]
-            };
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: 'VerifyIfAudioIsMuted',
+            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/verify/VerifyIfAudioIsPaused.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyIfAudioIsPaused = verifyIfAudioIsPaused;
 const logData_js_1 = require("../../../../utils/logger/logData.js");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function verifyIfAudioIsPaused(args) {
     try {
         const element = await args.driver.$(args.selector);
@@ -13,18 +14,17 @@ async function verifyIfAudioIsPaused(args) {
             logData_js_1.logger.info("Audio paused status:", isPaused);
             throw new Error("Audio is not paused.");
         }
-        args.scriptDataAppender.add(async () => {
-            const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex}"]`);
-            return {
-                nlpName: 'VerifyIfAudioIsPaused',
-                stepInputs: [],
-                elementsData: [{
-                        name: args.elementName,
-                        type: args.elementType,
-                        locators: ffElement.locators,
-                        platform: args.platform
-                    }]
-            };
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: 'VerifyIfAudioIsPaused',
+            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/verify/VerifyIfAudioIsPlaying.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyIfAudioIsPlaying = verifyIfAudioIsPlaying;
 const logData_js_1 = require("../../../../utils/logger/logData.js");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function verifyIfAudioIsPlaying(args) {
     try {
         const element = await args.driver.$(args.selector);
@@ -20,18 +21,17 @@ async function verifyIfAudioIsPlaying(args) {
             logData_js_1.logger.error("Audio is not playing.");
             throw new Error("Audio is not playing.");
         }
-        args.scriptDataAppender.add(async () => {
-            const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex}"]`);
-            return {
-                nlpName: 'VerifyIfAudioIsPlaying',
-                stepInputs: [],
-                elementsData: [{
-                        name: args.elementName,
-                        type: args.elementType,
-                        locators: ffElement.locators,
-                        platform: args.platform
-                    }]
-            };
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: 'VerifyIfAudioIsPlaying',
+            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/verify/VerifyIfBrowserWindowIsClosed.js

@@ -2,21 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyIfBrowserWindowIsClosed = verifyIfBrowserWindowIsClosed;
 const logData_js_1 = require("../../../../utils/logger/logData.js");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function verifyIfBrowserWindowIsClosed(args) {
     try {
-        try {
-            await args.driver.getWindowHandle();
+        if (await args.driver.getWindowHandle()) {
             logData_js_1.logger.info("Browser window is still open.");
             throw new Error("Browser window is still open.");
         }
-        catch {
-            logData_js_1.logger.info("Browser window is closed as expected.");
+        else {
+            logData_js_1.logger.info("Browser window is closed.");
         }
-        args.scriptDataAppender.add(async () => ({
-            nlpName: 'VerifyIfBrowserWindowIsClosed',
-            stepInputs: [],
-            elementsData: []
-        }));
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: 'VerifyIfBrowserWindowIsClosed'
+        });
     }
     catch (error) {
         args.scriptDataAppender.setErrorNLP("VerifyIfBrowserWindowIsClosed");

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

@@ -2,11 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyIfCookieNameIsAdded = verifyIfCookieNameIsAdded;
 const logData_js_1 = require("../../../../utils/logger/logData.js");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function verifyIfCookieNameIsAdded(args) {
     try {
         const cookieName = args.value.trim();
         const cookies = await args.driver.getCookies();
-        logData_js_1.logger.info("Current cookies:", { cookies });
+        // logger.info("Current cookies:", { cookies });
         const isMatched = cookies.some((cookie) => cookie.name === cookieName);
         if (isMatched === false) {
             throw new Error(`Cookie name is not added. Expected: ${cookieName}, Actual: Cookie not found`);
@@ -15,11 +16,11 @@ async function verifyIfCookieNameIsAdded(args) {
             isMatched,
             cookieName
         });
-        args.scriptDataAppender.add(async () => ({
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
             nlpName: 'VerifyIfCookieNameIsAdded',
-            stepInputs: [cookieName],
-            elementsData: []
-        }));
+            stepInputs: [cookieName]
+        });
     }
     catch (error) {
         args.scriptDataAppender.setErrorNLP("VerifyIfCookieNameIsAdded");