ff-automationv2 2.1.3 → 2.2.0

package/src/automation/actions/interaction/get/getAudioWidth.ts

@@ -0,0 +1,38 @@
+import { getAudioWidthInterface } from "../../interface/getActionInterface.js";
+
+export const getAudioWidth = async (
+  args: getAudioWidthInterface
+): Promise<void> => {
+
+  try {
+    const element = await args.driver.$(args.selector);
+
+    // Get rendered width of the audio element
+    const _audioWidth = await args.driver.execute((el: any) => {
+      return el.offsetWidth;
+    }, element);
+
+
+
+    args.scriptDataAppender.add(async () => {
+      const ffElement: any = await args.elementGetter.getFireFlinkElement(
+        args.pageDOM,
+        `[ff-inspect="${args.fireflinkIndex}"]`
+      );
+      return {
+        nlpName: "GetAudioWidth",
+        stepInputs: [],
+        elementsData: [{
+          name: args.elementName,
+          type: args.elementType,
+          locators: ffElement.locators,
+          platform: args.platform
+        }]
+      };
+    });
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetAudioWidth");
+    throw new Error("GetAudioWidth action failed", { cause: error });
+  }
+};

package/src/automation/actions/interaction/get/getBestPracticesScore.ts

@@ -0,0 +1,20 @@
+import { getBestPracticesScoreInterface } from "../../interface/getActionInterface.js";
+
+export const getBestPracticesScore = async (
+    args: getBestPracticesScoreInterface
+) => {
+    try {
+        const inputs = (args.value || "").split(",").map(v => v.trim());
+        const stepInputs = [inputs[0] || "", inputs[1] || ""];
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "GetBestPracticesScore",
+            stepInputs: stepInputs,
+            elementsData: []
+        }));
+
+    } catch (error) {
+        args.scriptDataAppender.setErrorNLP("GetBestPracticesScore");
+        throw new Error("GetBestPracticesScore action failed", { cause: error });
+    }
+};

package/src/automation/actions/interaction/get/getBrowserCount.ts

@@ -0,0 +1,17 @@
+import { getBrowserCountInterface } from "../../interface/getActionInterface.js";
+
+export const getBrowserCount = async (
+  args: getBrowserCountInterface
+) => {
+  try {
+    args.scriptDataAppender.add(async () => ({
+      nlpName: "GetBrowserCount",
+      stepInputs: [],
+      elementsData: []
+    }));
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetBrowserCount");
+    throw new Error("GetBrowserCount action failed", { cause: error });
+  }
+};

package/src/automation/actions/interaction/get/getBrowserVersion.ts

@@ -0,0 +1,16 @@
+import { getBrowserVersionInterface } from "../../interface/getActionInterface.js";
+
+export const getBrowserVersion = async (args: getBrowserVersionInterface) => {
+
+  try {
+    args.scriptDataAppender.add(async () => ({
+      nlpName: "GetBrowserVersion",
+      stepInputs: [],
+      elementsData: []
+    }));
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetBrowserVersion");
+    throw new Error("GetBrowserVersion action failed", { cause: error });
+  }
+};

package/src/automation/actions/interaction/get/getCapabilityNames.ts

@@ -0,0 +1,18 @@
+import { getCapabilityNamesInterface } from "../../interface/getActionInterface.js";
+
+export const getCapabilityNames = async (
+  args: getCapabilityNamesInterface
+) => {
+
+  try {
+    args.scriptDataAppender.add(async () => ({
+      nlpName: "GetCapabilityNames",
+      stepInputs: [],
+      elementsData: []
+    }));
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetCapabilityNames");
+    throw new Error("GetCapabilityNames action failed", { cause: error });
+  }
+};

package/src/automation/actions/interaction/get/getClipBoardText.ts

@@ -0,0 +1,16 @@
+import { getClipBoardTextInterface } from "../../interface/getActionInterface.js";
+
+export const getClipBoardText = async (args: getClipBoardTextInterface) => {
+
+  try {
+    args.scriptDataAppender.add(async () => ({
+      nlpName: "GetClipBoardText",
+      stepInputs: [],
+      elementsData: []
+    }));
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetClipBoardText");
+    throw new Error("GetClipBoardText action failed", { cause: error })
+  }
+};

package/src/automation/actions/interaction/get/getCollectiveApiResponseTime.ts

@@ -0,0 +1,27 @@
+import { getCollectiveApiResponseTimeInterface } from "../../interface/getActionInterface.js";
+
+export const getCollectiveApiResponseTime = async (
+    args: getCollectiveApiResponseTimeInterface
+) => {
+    try {
+        const targetUrl = args.value?.trim();
+        let responseTimes: string = "";
+        if (targetUrl) {
+            responseTimes = (await args.driver.execute((url) => {
+                return window.performance.getEntriesByType('resource')
+                    .filter(e => e.name.includes(url))
+                    .map(e => String(e.duration));
+            }, targetUrl)).join(",");
+        }
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "GetCollectiveApiResponseTime",
+            stepInputs: [responseTimes],
+            elementsData: []
+        }));
+
+    } catch (error) {
+        args.scriptDataAppender.setErrorNLP("GetCollectiveApiResponseTime");
+        throw new Error("GetCollectiveApiResponseTime action failed", { cause: error });
+    }
+};

package/src/automation/actions/interaction/get/getCollectiveApiStatusCode.ts

@@ -0,0 +1,29 @@
+import { getCollectiveApiStatusCodeInterface } from "../../interface/getActionInterface.js";
+
+export const getCollectiveApiStatusCode = async (
+    args: getCollectiveApiStatusCodeInterface
+) => {
+    try {
+        const targetUrl = args.value?.trim();
+
+        let statusCodes: string = "";
+        if (targetUrl) {
+
+            const count = await args.driver.execute((url) => {
+                return window.performance.getEntriesByType('resource')
+                    .filter(e => e.name.includes(url)).length;
+            }, targetUrl);
+            statusCodes = (Array(count).fill("200")).join(","); // Placeholder
+        }
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "GetCollectiveApiStatusCode",
+            stepInputs: [statusCodes],
+            elementsData: []
+        }));
+
+    } catch (error) {
+        args.scriptDataAppender.setErrorNLP("GetCollectiveApiStatusCode");
+        throw new Error("GetCollectiveApiStatusCode action failed", { cause: error });
+    }
+};

package/src/automation/actions/interaction/get/getCssValue.ts

@@ -0,0 +1,38 @@
+import { getCssValueInterface } from "../../interface/getActionInterface.js";
+
+export const getCssValue = async (
+  args: getCssValueInterface
+): Promise<void> => {
+
+  try {
+    const element = await args.driver.$(args.selector);
+
+    // stepInputs contains CSS property name
+    const cssPropertyName = args.value;
+
+    const _cssValue = await element.getCSSProperty(cssPropertyName);
+
+
+
+    args.scriptDataAppender.add(async () => {
+      const ffElement: any = await args.elementGetter.getFireFlinkElement(
+        args.pageDOM,
+        `[ff-inspect="${args.fireflinkIndex}"]`
+      );
+      return {
+        nlpName: "GetCssValue",
+        stepInputs: [cssPropertyName],
+        elementsData: [{
+          name: args.elementName,
+          type: args.elementType,
+          locators: ffElement.locators,
+          platform: args.platform
+        }]
+      };
+    });
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetCssValue");
+    throw new Error("GetCssValue action failed", { cause: error });
+  }
+};

package/src/automation/actions/interaction/get/getCurrentDayOfTheWeek.ts

@@ -0,0 +1,18 @@
+import { getCurrentDayOfTheWeekInterface } from "../../interface/getActionInterface.js";
+
+export const getCurrentDayOfTheWeek = async (
+  args: getCurrentDayOfTheWeekInterface
+) => {
+
+  try {
+    args.scriptDataAppender.add(async () => ({
+      nlpName: "GetCurrentDayOfTheWeek",
+      stepInputs: [],
+      elementsData: []
+    }));
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetCurrentDayOfTheWeek");
+    throw new Error("GetCurrentDayOfTheWeek action failed", { cause: error });
+  }
+};

package/src/automation/actions/interaction/get/getCurrentSecondsFromCurrentSystemTime.ts

@@ -0,0 +1,19 @@
+import { getCurrentSecondsFromCurrentSystemTimeInterface } from "../../interface/getActionInterface.js";
+
+export const getCurrentSecondsFromCurrentSystemTime = async (
+  args: getCurrentSecondsFromCurrentSystemTimeInterface
+) => {
+
+  try {
+
+    args.scriptDataAppender.add(async () => ({
+      nlpName: "GetCurrentSecondsFromCurrentSystemTime",
+      stepInputs: [],
+      elementsData: []
+    }));
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetCurrentSecondsFromCurrentSystemTime");
+    throw new Error("GetCurrentSecondsFromCurrentSystemTime action failed", { cause: error });
+  }
+};

package/src/automation/actions/interaction/get/getCurrentSystemDate.ts

@@ -0,0 +1,18 @@
+import { getCurrentSystemDateInterface } from "../../interface/getActionInterface.js";
+
+export const getCurrentSystemDate = async (
+  args: getCurrentSystemDateInterface
+) => {
+
+  try {
+    args.scriptDataAppender.add(async () => ({
+      nlpName: "GetCurrentSystemDate",
+      stepInputs: [],
+      elementsData: []
+    }));
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetCurrentSystemDate");
+    throw new Error("GetCurrentSystemDate action failed", { cause: error })
+  }
+};

package/src/automation/actions/interaction/get/getCurrentSystemDay.ts

@@ -0,0 +1,16 @@
+import { getCurrentSystemDayInterface } from "../../interface/getActionInterface.js";
+
+export const getCurrentSystemDay = async (args: getCurrentSystemDayInterface) => {
+
+  try {
+    args.scriptDataAppender.add(async () => ({
+      nlpName: "GetCurrentSystemDay",
+      stepInputs: [],
+      elementsData: []
+    }));
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetCurrentSystemDay");
+    throw new Error("GetCurrentSystemDay action failed", { cause: error });
+  }
+};

package/src/automation/actions/interaction/get/getCurrentSystemMonth.ts

@@ -0,0 +1,16 @@
+import { getCurrentSystemMonthInterface } from "../../interface/getActionInterface.js";
+
+export const getCurrentSystemMonth = async (args: getCurrentSystemMonthInterface) => {
+
+  try {
+    args.scriptDataAppender.add(async () => ({
+      nlpName: "GetCurrentSystemMonth",
+      stepInputs: [],
+      elementsData: []
+    }));
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetCurrentSystemMonth");
+    throw new Error("GetCurrentSystemMonth action failed", { cause: error });
+  }
+};

package/src/automation/actions/interaction/get/getCurrentSystemTime.ts

@@ -0,0 +1,18 @@
+import { getCurrentSystemTimeInterface } from "../../interface/getActionInterface.js";
+
+export const getCurrentSystemTime = async (
+  args: getCurrentSystemTimeInterface
+) => {
+
+  try {
+    args.scriptDataAppender.add(async () => ({
+      nlpName: "GetCurrentSystemTime",
+      stepInputs: [],
+      elementsData: []
+    }));
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetCurrentSystemTime");
+    throw new Error("GetCurrentSystemTime action failed", { cause: error });
+  }
+};

package/src/automation/actions/interaction/get/getCurrentSystemYear.ts

@@ -0,0 +1,18 @@
+import { getCurrentSystemYearInterface } from "../../interface/getActionInterface.js";
+
+export const getCurrentSystemYear = async (
+  args: getCurrentSystemYearInterface
+) => {
+
+  try {
+    args.scriptDataAppender.add(async () => ({
+      nlpName: "GetCurrentSystemYear",
+      stepInputs: [],
+      elementsData: []
+    }));
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetCurrentSystemYear");
+    throw new Error("GetCurrentSystemYear action failed", { cause: error });
+  }
+};

package/src/automation/actions/interaction/get/getCurrentWindowHandle.ts

@@ -0,0 +1,36 @@
+import { getCurrentWindowHandleInterface } from "../../interface/getActionInterface.js";
+
+export const getCurrentWindowHandle = async (
+  args: getCurrentWindowHandleInterface
+) => {
+  switch (args.platform) {
+    case "android":
+      try {
+        args.scriptDataAppender.add(async () => ({
+          nlpName: "MOB_GetCurrentWindowHandle",
+          stepInputs: [],
+          elementsData: []
+        }));
+
+      } catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_GetCurrentWindowHandle");
+        throw new Error("GetCurrentWindowHandle action failed", { cause: error });
+      }
+      break;
+    case "web":
+    default:
+      try {
+        args.scriptDataAppender.add(async () => ({
+          nlpName: "GetCurrentWindowHandle",
+          stepInputs: [],
+          elementsData: []
+        }));
+
+      } catch (error) {
+        args.scriptDataAppender.setErrorNLP("GetCurrentWindowHandle");
+        throw new Error("GetCurrentWindowHandle action failed", { cause: error });
+      }
+      break;
+  }
+
+};

package/src/automation/actions/interaction/get/getDataFromApiRequestHeaderForJsonPath.ts

@@ -0,0 +1,21 @@
+import { getDataFromApiRequestHeaderForJsonPathInterface } from "../../interface/getActionInterface.js";
+
+export const getDataFromApiRequestHeaderForJsonPath = async (
+    args: getDataFromApiRequestHeaderForJsonPathInterface
+) => {
+    try {
+        // Logic: Extracting data from request headers requires CDP
+        const inputs = (args.value || "").split(",").map(v => v.trim());
+        const stepInputs = [inputs[0] || "", inputs[1] || "", inputs[2] || ""];
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "GetDataFromApiRequestHeaderForJsonPath",
+            stepInputs: stepInputs,
+            elementsData: []
+        }));
+
+    } catch (error) {
+        args.scriptDataAppender.setErrorNLP("GetDataFromApiRequestHeaderForJsonPath");
+        throw new Error("GetDataFromApiRequestHeaderForJsonPath action failed", { cause: error });
+    }
+};

package/src/automation/actions/interaction/get/getDataFromApiResponseForJsonPath.ts

@@ -0,0 +1,21 @@
+import { getDataFromApiResponseForJsonPathInterface } from "../../interface/getActionInterface.js";
+
+export const getDataFromApiResponseForJsonPath = async (
+    args: getDataFromApiResponseForJsonPathInterface
+) => {
+    try {
+        // Logic: Extracting data from response body via JSON path requires CDP
+        const inputs = (args.value || "").split(",").map(v => v.trim());
+        const stepInputs = [inputs[0] || "", inputs[1] || "", inputs[2] || ""];
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "GetDataFromApiResponseForJsonPath",
+            stepInputs: stepInputs,
+            elementsData: []
+        }));
+
+    } catch (error) {
+        args.scriptDataAppender.setErrorNLP("GetDataFromApiResponseForJsonPath");
+        throw new Error("GetDataFromApiResponseForJsonPath action failed", { cause: error });
+    }
+};

package/src/automation/actions/interaction/get/getDateWithGivenFormat.ts

@@ -0,0 +1,35 @@
+import { getDateWithGivenFormatInterface } from "../../interface/getActionInterface.js";
+
+export const getDateWithGivenFormat = async (
+    args: getDateWithGivenFormatInterface
+) => {
+    try {
+        const format = args.value || "dd-MM-yyyy";
+        const date = new Date();
+
+        const day = String(date.getDate()).padStart(2, '0');
+        const month = String(date.getMonth() + 1).padStart(2, '0');
+        const year = String(date.getFullYear());
+        const hours = String(date.getHours()).padStart(2, '0');
+        const minutes = String(date.getMinutes()).padStart(2, '0');
+        const seconds = String(date.getSeconds()).padStart(2, '0');
+
+        const formattedDate = format
+            .replace(/dd/gi, day)
+            .replace(/MM/g, month)
+            .replace(/yyyy/gi, year)
+            .replace(/HH/gi, hours)
+            .replace(/mm/g, minutes)
+            .replace(/ss/gi, seconds);
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "GetDateWithGivenFormat",
+            stepInputs: [formattedDate],
+            elementsData: []
+        }));
+
+    } catch (error) {
+        args.scriptDataAppender.setErrorNLP("GetDateWithGivenFormat");
+        throw new Error("GetDateWithGivenFormat action failed", { cause: error });
+    }
+};

package/src/automation/actions/interaction/get/getDriverInstance.ts

@@ -0,0 +1,35 @@
+import { getDriverInstanceInterface } from "../../interface/getActionInterface.js";
+
+export const getDriverInstance = async (args: getDriverInstanceInterface) => {
+  switch (args.platform) {
+    case "android":
+      try {
+        args.scriptDataAppender.add(async () => ({
+          nlpName: "MOB_GetDriverInstance",
+          stepInputs: [],
+          elementsData: []
+        }));
+
+      } catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_GetDriverInstance");
+        throw new Error("GetDriverInstance action failed", { cause: error });
+      }
+      break;
+    case "web":
+    default:
+      try {
+        args.scriptDataAppender.add(async () => ({
+          nlpName: "GetDriverInstance",
+          stepInputs: [],
+          elementsData: []
+        }));
+
+      } catch (error) {
+        args.scriptDataAppender.setErrorNLP("GetDriverInstance");
+        throw new Error("GetDriverInstance action failed", { cause: error });
+      }
+
+      break;
+  }
+
+};

package/src/automation/actions/interaction/get/getFirstContentfulPaint.ts

@@ -0,0 +1,16 @@
+import { getFirstContentfulPaintInterface } from "../../interface/getActionInterface.js";
+
+export const getFirstContentfulPaint = async (args: getFirstContentfulPaintInterface) => {
+
+  try {
+    args.scriptDataAppender.add(async () => ({
+      nlpName: "GetFirstContentfulPaint",
+      stepInputs: [],
+      elementsData: []
+    }));
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetFirstContentfulPaint");
+    throw new Error("GetFirstContentfulPaint action failed", { cause: error })
+  }
+};

package/src/automation/actions/interaction/get/getFirstSelectedOption.ts

@@ -0,0 +1,44 @@
+import { getFirstSelectedOptionInterface } from "../../interface/getActionInterface.js";
+
+export const getFirstSelectedOption = async (
+  args: getFirstSelectedOptionInterface
+): Promise<void> => {
+
+  try {
+    const selectElement = await args.driver.$(args.selector);
+
+    const options = await selectElement.$$('option');
+
+    let _firstSelected = null;
+
+    for (const option of options) {
+      if (await option.isSelected()) {
+        _firstSelected = option;
+        break;
+      }
+    }
+
+
+
+    args.scriptDataAppender.add(async () => {
+      const ffElement: any = await args.elementGetter.getFireFlinkElement(
+        args.pageDOM,
+        `[ff-inspect="${args.fireflinkIndex}"]`
+      );
+      return {
+        nlpName: "GetFirstSelectedOption",
+        stepInputs: [],
+        elementsData: [{
+          name: args.elementName,
+          type: args.elementType,
+          locators: ffElement.locators,
+          platform: args.platform
+        }]
+      };
+    });
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetFirstSelectedOption");
+    throw new Error("GetFirstSelectedOption action failed", { cause: error });
+  }
+};

package/src/automation/actions/interaction/get/getFullPaintTime.ts

@@ -0,0 +1,16 @@
+import { getFullPaintTimeInterface } from "../../interface/getActionInterface.js";
+
+export const getFullPaintTime = async (args: getFullPaintTimeInterface) => {
+
+  try {
+    args.scriptDataAppender.add(async () => ({
+      nlpName: "GetFullPaintTime",
+      stepInputs: [],
+      elementsData: []
+    }));
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetFullPaintTime");
+    throw new Error("GetFullPaintTime action failed", { cause: error })
+  }
+};

package/src/automation/actions/interaction/get/getHTMLCodeOfPage.ts

@@ -0,0 +1,18 @@
+import { getHTMLCodeOfPageInterface } from "../../interface/getActionInterface.js";
+
+export const getHTMLCodeOfPage = async (
+  args: getHTMLCodeOfPageInterface
+) => {
+
+  try {
+    args.scriptDataAppender.add(async () => ({
+      nlpName: "GetHTMLCodeOfPage",
+      stepInputs: [],
+      elementsData: []
+    }));
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetHTMLCodeOfPage");
+    throw new Error("GetHTMLCodeOfPage action failed", { cause: error });
+  }
+};

package/src/automation/actions/interaction/get/getHeightOfBrowserWindow.ts

@@ -0,0 +1,18 @@
+import { getHeightOfBrowserWindowInterface } from "../../interface/getActionInterface.js"
+
+export const getHeightOfBrowserWindow = async (
+    args: getHeightOfBrowserWindowInterface
+) => {
+
+    try {
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "GetHeightOfBrowserWindow",
+            stepInputs: [],
+            elementsData: []
+        }));
+
+    } catch (error) {
+        args.scriptDataAppender.setErrorNLP("GetHeightOfBrowserWindow");
+        throw new Error("GetHeightOfBrowserWindow action failed", { cause: error });
+    }
+};

package/src/automation/actions/interaction/get/getHeightOfWebElement.ts

@@ -0,0 +1,36 @@
+import { getHeightOfWebElementInterface } from "../../interface/getActionInterface.js";
+
+export const getHeightOfWebElement = async (
+  args: getHeightOfWebElementInterface
+): Promise<void> => {
+
+  try {
+    const element = await args.driver.$(args.selector);
+
+    const _size = await element.getSize();
+    const _height = _size.height;
+
+
+
+    args.scriptDataAppender.add(async () => {
+      const ffElement: any = await args.elementGetter.getFireFlinkElement(
+        args.pageDOM,
+        `[ff-inspect="${args.fireflinkIndex}"]`
+      );
+      return {
+        nlpName: "GetHeightOfWebElement",
+        stepInputs: [],
+        elementsData: [{
+          name: args.elementName,
+          type: args.elementType,
+          locators: ffElement.locators,
+          platform: args.platform
+        }]
+      };
+    });
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetHeightOfWebElement");
+    throw new Error("GetHeightOfWebElement action failed", { cause: error });
+  }
+};