ff-automationv2 2.2.28 → 2.2.29

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyIfCookieNameIsDeleted = verifyIfCookieNameIsDeleted;
 const logData_js_1 = require("../../../../utils/logger/logData.js");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function verifyIfCookieNameIsDeleted(args) {
     try {
         const cookie = await args.driver.getCookies([args.value.trim()]);
@@ -12,11 +13,11 @@ async function verifyIfCookieNameIsDeleted(args) {
         if (isMatched === false) {
             throw new Error(`Cookie name is not deleted. Expected: ${args.value.trim()}, Actual: Cookie still exists`);
         }
-        args.scriptDataAppender.add(async () => ({
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
             nlpName: 'VerifyIfCookieNameIsDeleted',
-            stepInputs: [args.value.trim()],
-            elementsData: []
-        }));
+            stepInputs: [args.value.trim()]
+        });
     }
     catch (error) {
         args.scriptDataAppender.setErrorNLP("VerifyIfCookieNameIsDeleted");

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

@@ -2,13 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyIfCookieObjectIsPresent = verifyIfCookieObjectIsPresent;
 const logData_js_1 = require("../../../../utils/logger/logData.js");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function verifyIfCookieObjectIsPresent(args) {
     try {
         const cookies = await args.driver.getCookies();
         logData_js_1.logger.info("Available Cookies:", cookies);
         let cookieName;
         let cookieValue;
-        // Try parsing JSON cookie object
         try {
             const parsed = args.value.split(',');
             cookieName = parsed[0].trim();
@@ -29,11 +29,11 @@ async function verifyIfCookieObjectIsPresent(args) {
             throw new Error(`Cookie '${cookieName}' is not present.`);
         }
         logData_js_1.logger.info("Matched Cookie:", matchedCookie);
-        args.scriptDataAppender.add(async () => ({
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
             nlpName: 'VerifyIfCookieObjectIsPresent',
-            stepInputs: [args.value],
-            elementsData: []
-        }));
+            stepInputs: [args.value]
+        });
     }
     catch (error) {
         args.scriptDataAppender.setErrorNLP("VerifyIfCookieObjectIsPresent");

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyIfGivenOptionIsDuplicate = verifyIfGivenOptionIsDuplicate;
 const logData_js_1 = require("../../../../utils/logger/logData.js");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function verifyIfGivenOptionIsDuplicate(args) {
     try {
         const expectedText = args.value.trim();
@@ -15,21 +16,20 @@ async function verifyIfGivenOptionIsDuplicate(args) {
             }
         }
         logData_js_1.logger.info("Duplicate count:", { expectedText, count });
-        if (count > 1) {
-            throw new Error(`Option "${expectedText}" is duplicated ${count} times in the dropdown.`);
+        if (count == 1) {
+            throw new Error(`Option "${expectedText}" is not duplicated in the dropdown.`);
         }
-        args.scriptDataAppender.add(async () => {
-            const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex}"]`);
-            return {
-                nlpName: 'VerifyIfGivenOptionIsDuplicate',
-                stepInputs: [expectedText],
-                elementsData: [{
-                        name: args.elementName,
-                        type: args.elementType,
-                        locators: ffElement.locators,
-                        platform: args.platform
-                    }]
-            };
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: "VerifyIfGivenOptionIsDuplicate",
+            stepInputs: [expectedText],
+            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/VerifyIfImageIsBroken.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyIfImageIsBroken = verifyIfImageIsBroken;
 const logData_js_1 = require("../../../../utils/logger/logData.js");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function verifyIfImageIsBroken(args) {
     try {
         const imageUrl = args.value.trim();
@@ -21,11 +22,11 @@ async function verifyIfImageIsBroken(args) {
                 throw new Error(`Working image found: ${imageUrl}`);
             }
         }
-        args.scriptDataAppender.add(async () => ({
-            nlpName: 'VerifyIfImageIsBroken',
-            stepInputs: [args.value],
-            elementsData: []
-        }));
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: "VerifyIfImageIsBroken",
+            stepInputs: [args.value]
+        });
     }
     catch (error) {
         args.scriptDataAppender.setErrorNLP("VerifyIfImageIsBroken");

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyIfLinkIsBroken = verifyIfLinkIsBroken;
 const logData_js_1 = require("../../../../utils/logger/logData.js");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function verifyIfLinkIsBroken(args) {
     try {
         const link = args.value.trim();
@@ -21,11 +22,11 @@ async function verifyIfLinkIsBroken(args) {
                 throw new Error(`Working link found: ${link}`);
             }
         }
-        args.scriptDataAppender.add(async () => ({
-            nlpName: 'VerifyIfLinkIsBroken',
-            stepInputs: [args.value.trim()],
-            elementsData: []
-        }));
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: "VerifyIfLinkIsBroken",
+            stepInputs: [args.value.trim()]
+        });
     }
     catch (error) {
         args.scriptDataAppender.setErrorNLP("VerifyIfLinkIsBroken");

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyIfLinkIsWorking = verifyIfLinkIsWorking;
 const logData_js_1 = require("../../../../utils/logger/logData.js");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function verifyIfLinkIsWorking(args) {
     try {
         const url = args.value.trim();
@@ -18,11 +19,11 @@ async function verifyIfLinkIsWorking(args) {
         catch {
             throw new Error(`Link request failed: ${url}`);
         }
-        args.scriptDataAppender.add(async () => ({
-            nlpName: 'VerifyIfLinkIsWorking',
-            stepInputs: [args.value],
-            elementsData: []
-        }));
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: "VerifyIfLinkIsWorking",
+            stepInputs: [args.value]
+        });
     }
     catch (error) {
         args.scriptDataAppender.setErrorNLP("VerifyIfLinkIsWorking");

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyIfLinksAreBroken = verifyIfLinksAreBroken;
 const logData_js_1 = require("../../../../utils/logger/logData.js");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function verifyIfLinksAreBroken(args) {
     try {
         const links = args.value.split(",").map((link) => link.trim()).filter((link) => link.length > 0);
@@ -25,11 +26,11 @@ async function verifyIfLinksAreBroken(args) {
                 throw new Error(`Working link found: ${link}`);
             }
         }
-        args.scriptDataAppender.add(async () => ({
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
             nlpName: "VerifyIfLinksAreBroken",
-            stepInputs: [args.value],
-            elementsData: []
-        }));
+            stepInputs: [args.value]
+        });
     }
     catch (error) {
         args.scriptDataAppender.setErrorNLP("VerifyIfLinksAreBroken");

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyIfLinksAreWorking = verifyIfLinksAreWorking;
 const logData_js_1 = require("../../../../utils/logger/logData.js");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function verifyIfLinksAreWorking(args) {
     try {
         const links = args.value.split(",").map((link) => link.trim()).filter((link) => link.length > 0);
@@ -23,11 +24,11 @@ async function verifyIfLinksAreWorking(args) {
                 throw new Error(`Link request failed: ${link}`);
             }
         }
-        args.scriptDataAppender.add(async () => ({
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
             nlpName: "VerifyIfLinksAreWorking",
-            stepInputs: [args.value],
-            elementsData: []
-        }));
+            stepInputs: [args.value]
+        });
     }
     catch (error) {
         args.scriptDataAppender.setErrorNLP("VerifyIfLinksAreWorking");

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

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyIfOptionWithIndexIsDeselectedInElement = verifyIfOptionWithIndexIsDeselectedInElement;
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 const logData_js_1 = require("../../../../utils/logger/logData.js");
 async function verifyIfOptionWithIndexIsDeselectedInElement(args) {
     try {
         let result = true;
-        const expectedIndex = parseInt(args.value, 10);
+        const expectedIndex = args.value != null ? Number(args.value) : 1000;
         const element = await args.driver.$(args.selector);
         // Get all <option> elements
         const options = await element.$$("option");
@@ -31,18 +32,17 @@ async function verifyIfOptionWithIndexIsDeselectedInElement(args) {
         if (result === false) {
             throw new Error(`Option with index ${expectedIndex} is not deselected in the dropdown.`);
         }
-        args.scriptDataAppender.add(async () => {
-            const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex}"]`);
-            return {
-                nlpName: 'VerifyIfOptionWithIndexIsDeselectedInElement',
-                stepInputs: [expectedIndex],
-                elementsData: [{
-                        name: args.elementName,
-                        type: args.elementType,
-                        locators: ffElement.locators,
-                        platform: args.platform
-                    }]
-            };
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: "VerifyIfOptionWithIndexIsDeselectedInElement",
+            stepInputs: [expectedIndex],
+            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/VerifyIfOptionWithIndexIsSelectedInListBox.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyIfOptionWithIndexIsSelectedInListBox = verifyIfOptionWithIndexIsSelectedInListBox;
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 const logData_js_1 = require("../../../../utils/logger/logData.js");
 async function verifyIfOptionWithIndexIsSelectedInListBox(args) {
     try {
@@ -9,7 +10,7 @@ async function verifyIfOptionWithIndexIsSelectedInListBox(args) {
             logData_js_1.logger.info("Selector or value is missing.");
         }
         ;
-        const expectedIndex = parseInt(args.value, 10);
+        const expectedIndex = args.value != null ? Number(args.value) : 1000;
         const element = await args.driver.$(args.selector);
         if (!(await element.isExisting())) {
             logData_js_1.logger.info("Element does not exist for selector:");
@@ -36,18 +37,17 @@ async function verifyIfOptionWithIndexIsSelectedInListBox(args) {
         if (isSelected === false) {
             throw new Error(`Option with index ${expectedIndex} is not selected in the dropdown.`);
         }
-        args.scriptDataAppender.add(async () => {
-            const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex}"]`);
-            return {
-                nlpName: 'VerifyIfOptionWithIndexIsSelectedInListBox',
-                stepInputs: [expectedIndex],
-                elementsData: [{
-                        name: args.elementName,
-                        type: args.elementType,
-                        locators: ffElement.locators,
-                        platform: args.platform
-                    }]
-            };
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: "VerifyIfOptionWithIndexIsSelectedInListBox",
+            stepInputs: [expectedIndex],
+            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/VerifyIfOptionWithTextIsDeselected.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyIfOptionWithTextIsDeselected = verifyIfOptionWithTextIsDeselected;
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function verifyIfOptionWithTextIsDeselected(args) {
     try {
         const optionText = args.value;
@@ -10,18 +11,17 @@ async function verifyIfOptionWithTextIsDeselected(args) {
         if (!isSelected) {
             throw new Error(`Option with text ${optionText} is selected`);
         }
-        args.scriptDataAppender.add(async () => {
-            const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex}"]`);
-            return {
-                nlpName: 'VerifyIfOptionWithTextIsDeselected',
-                stepInputs: [optionText],
-                elementsData: [{
-                        name: args.elementName,
-                        type: args.elementType,
-                        locators: ffElement.locators,
-                        platform: args.platform
-                    }]
-            };
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: "VerifyIfOptionWithTextIsDeselected",
+            stepInputs: [optionText],
+            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/VerifyIfOptionWithValueIsDeselected.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyIfOptionWithValueIsDeselected = verifyIfOptionWithValueIsDeselected;
 const logData_js_1 = require("../../../../utils/logger/logData.js");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function verifyIfOptionWithValueIsDeselected(args) {
     try {
         let result = false;
@@ -22,18 +23,17 @@ async function verifyIfOptionWithValueIsDeselected(args) {
         if (result === true) {
             throw new Error(`Option with value "${expectedValue}" is not deselected in the dropdown.`);
         }
-        args.scriptDataAppender.add(async () => {
-            const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex}"]`);
-            return {
-                nlpName: 'VerifyIfOptionWithValueIsDeselected',
-                stepInputs: [expectedValue],
-                elementsData: [{
-                        name: args.elementName,
-                        type: args.elementType,
-                        locators: ffElement.locators,
-                        platform: args.platform
-                    }]
-            };
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: "VerifyIfOptionWithValueIsDeselected",
+            stepInputs: [expectedValue],
+            pageDOM: args.pageDOM,
+            elementGetter: args.elementGetter,
+            ffNumber: args.fireflinkIndex,
+            elementName: args.elementName,
+            elementType: args.elementType,
+            selector: args.selector,
+            platform: args.platform
         });
     }
     catch (error) {

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyIfOptionWithValueIsSelected = verifyIfOptionWithValueIsSelected;
 const logData_js_1 = require("../../../../utils/logger/logData.js");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function verifyIfOptionWithValueIsSelected(args) {
     try {
         let result = false;
@@ -22,18 +23,17 @@ async function verifyIfOptionWithValueIsSelected(args) {
         if (result === false) {
             throw new Error(`Option with value "${expectedValue}" is not selected in the dropdown.`);
         }
-        args.scriptDataAppender.add(async () => {
-            const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex}"]`);
-            return {
-                nlpName: 'VerifyIfOptionWithValueIsSelected',
-                stepInputs: [expectedValue],
-                elementsData: [{
-                        name: args.elementName,
-                        type: args.elementType,
-                        locators: ffElement.locators,
-                        platform: args.platform
-                    }]
-            };
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: "VerifyIfOptionWithValueIsSelected",
+            stepInputs: [expectedValue],
+            pageDOM: args.pageDOM,
+            elementGetter: args.elementGetter,
+            ffNumber: args.fireflinkIndex,
+            elementName: args.elementName,
+            elementType: args.elementType,
+            selector: args.selector,
+            platform: args.platform
         });
     }
     catch (error) {

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyIfOptionWithVisibleTextIsSelected = verifyIfOptionWithVisibleTextIsSelected;
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function verifyIfOptionWithVisibleTextIsSelected(args) {
     try {
         const optionText = args.value;
@@ -10,18 +11,17 @@ async function verifyIfOptionWithVisibleTextIsSelected(args) {
         if (!isSelected) {
             throw new Error(`Option with visible text ${optionText} is not selected`);
         }
-        args.scriptDataAppender.add(async () => {
-            const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex}"]`);
-            return {
-                nlpName: 'VerifyIfOptionWithVisibleTextIsSelected',
-                stepInputs: [optionText],
-                elementsData: [{
-                        name: args.elementName,
-                        type: args.elementType,
-                        locators: ffElement.locators,
-                        platform: args.platform
-                    }]
-            };
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: "VerifyIfOptionWithVisibleTextIsSelected",
+            stepInputs: [optionText],
+            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/VerifyIfSpecifiedOptionIsSelected.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyIfSpecifiedOptionIsSelected = verifyIfSpecifiedOptionIsSelected;
 const logData_js_1 = require("../../../../utils/logger/logData.js");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function verifyIfSpecifiedOptionIsSelected(args) {
     try {
         let result = false;
@@ -35,18 +36,17 @@ async function verifyIfSpecifiedOptionIsSelected(args) {
         if (result === false) {
             throw new Error(`Option with text "${expectedText}" is not selected in the dropdown.`);
         }
-        args.scriptDataAppender.add(async () => {
-            const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex}"]`);
-            return {
-                nlpName: 'VerifyIfSpecifiedOptionIsSelected',
-                stepInputs: [expectedText, caseSensitive],
-                elementsData: [{
-                        name: args.elementName,
-                        type: args.elementType,
-                        locators: ffElement.locators,
-                        platform: args.platform
-                    }]
-            };
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: "VerifyIfSpecifiedOptionIsSelected",
+            stepInputs: [expectedText, 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/VerifyIfStatusCodeOfALinkIsStatusCode.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyIfStatusCodeOfALinkIsStatusCode = verifyIfStatusCodeOfALinkIsStatusCode;
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function verifyIfStatusCodeOfALinkIsStatusCode(args) {
     try {
         const inputs = args.value.split(',');
-        const expectedStatusCode = parseInt(inputs[0]);
+        const expectedStatusCode = Number(inputs[0]);
         const url = inputs[1];
         const actualStatus = await args.driver.execute(async (url) => {
             try {
@@ -18,11 +19,11 @@ async function verifyIfStatusCodeOfALinkIsStatusCode(args) {
         if (actualStatus !== expectedStatusCode) {
             throw new Error(`Expected status ${expectedStatusCode} but received ${actualStatus} for ${url}`);
         }
-        args.scriptDataAppender.add(async () => ({
-            nlpName: 'VerifyIfStatusCodeOfALinkIsStatusCode',
-            stepInputs: [expectedStatusCode.toString(), url],
-            elementsData: []
-        }));
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: "VerifyIfStatusCodeOfALinkIsStatusCode",
+            stepInputs: [expectedStatusCode.toString(), url]
+        });
     }
     catch (error) {
         args.scriptDataAppender.setErrorNLP("VerifyIfStatusCodeOfALinkIsStatusCode");

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

@@ -1,35 +1,43 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyIfStatusCodesOfLinks = verifyIfStatusCodesOfLinks;
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function verifyIfStatusCodesOfLinks(args) {
     try {
-        const expectedStatusCode = parseInt(args.value);
-        const result = await args.driver.execute(async (expected) => {
-            const links = Array.from(document.querySelectorAll('a[href]'))
-                .map((a) => a.href)
-                .filter((url) => url && url.startsWith('http'));
-            const uniqueLinks = [...new Set(links)];
-            for (const url of uniqueLinks) {
-                try {
-                    const response = await fetch(url, { method: 'HEAD' });
-                    if (response.status !== expected) {
-                        return false;
-                    }
-                }
-                catch {
-                    return false;
+        const lastCommaIndex = args.value.lastIndexOf(",");
+        const linksPart = args.value.substring(0, lastCommaIndex).trim();
+        const statusCodePart = args.value.substring(lastCommaIndex + 1).trim();
+        const expectedStatusCode = parseInt(statusCodePart, 10);
+        const links = linksPart
+            .replace(/^\[/, "")
+            .replace(/\]$/, "")
+            .split(",")
+            .map(link => link.trim());
+        let result = true;
+        for (const link of links) {
+            try {
+                const response = await fetch(link, {
+                    method: "HEAD"
+                });
+                if (response.status !== expectedStatusCode) {
+                    result = false;
+                    break;
                 }
             }
-            return true;
-        }, expectedStatusCode);
+            catch {
+                result = false;
+                break;
+            }
+        }
         if (!result) {
             throw new Error(`Not all links returned status code ${expectedStatusCode}`);
         }
-        args.scriptDataAppender.add(async () => ({
-            nlpName: 'VerifyIfStatusCodesOfLinks',
-            stepInputs: [expectedStatusCode.toString()],
-            elementsData: []
-        }));
+        const formattedLinksPart = linksPart.replaceAll("[", "").replaceAll("]", "");
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: "VerifyIfStatusCodesOfLinks",
+            stepInputs: [formattedLinksPart, expectedStatusCode.toString()]
+        });
     }
     catch (error) {
         args.scriptDataAppender.setErrorNLP("VerifyIfStatusCodesOfLinks");