ff-automationv2 2.1.3 → 2.2.0

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

@@ -0,0 +1,36 @@
+import { getVideoCurrentVolumeInterface } from "../../interface/getActionInterface.js";
+
+export const getVideoCurrentVolume = async (
+  args: getVideoCurrentVolumeInterface
+): Promise<void> => {
+
+  try {
+    const element = await args.driver.$(args.selector);
+
+    // volume property returns value between 0.0 and 1.0
+    const _currentVolume = await element.getProperty("volume");
+
+
+
+    args.scriptDataAppender.add(async () => {
+      const ffElement: any = await args.elementGetter.getFireFlinkElement(
+        args.pageDOM,
+        `[ff-inspect="${args.fireflinkIndex}"]`
+      );
+      return {
+        nlpName: "GetVideoCurrentVolume",
+        stepInputs: [],
+        elementsData: [{
+          name: args.elementName,
+          type: args.elementType,
+          locators: ffElement.locators,
+          platform: args.platform
+        }]
+      };
+    });
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetVideoCurrentVolume");
+    throw new Error("GetVideoCurrentVolume action failed", { cause: error });
+  }
+};

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

@@ -0,0 +1,52 @@
+import { getVideoDecodedByteInterface } from "../../interface/getActionInterface.js";
+
+export const getVideoDecodedByte = async (
+  args: getVideoDecodedByteInterface
+): Promise<void> => {
+
+  try {
+    const element = await args.driver.$(args.selector);
+
+    // Get decoded video frames (modern + fallback support)
+    const _decodedFrames = await args.driver.execute(
+      (el: any) => {
+
+        // Modern browsers
+        if (el.getVideoPlaybackQuality) {
+          return el.getVideoPlaybackQuality().totalVideoFrames;
+        }
+
+        // WebKit fallback (older Chrome/Safari)
+        if (el.webkitDecodedFrameCount) {
+          return el.webkitDecodedFrameCount;
+        }
+
+        return 0;
+      },
+      element
+    );
+
+
+
+    args.scriptDataAppender.add(async () => {
+      const ffElement: any = await args.elementGetter.getFireFlinkElement(
+        args.pageDOM,
+        `[ff-inspect="${args.fireflinkIndex}"]`
+      );
+      return {
+        nlpName: "GetVideoDecodedByte",
+        stepInputs: [],
+        elementsData: [{
+          name: args.elementName,
+          type: args.elementType,
+          locators: ffElement.locators,
+          platform: args.platform
+        }]
+      };
+    });
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetVideoDecodedByte");
+    throw new Error("GetVideoDecodedByte action failed", { cause: error });
+  }
+};

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

@@ -0,0 +1,36 @@
+import { getVideoDefaultPlaybackRateInterface } from "../../interface/getActionInterface.js";
+
+export const getVideoDefaultPlaybackRate = async (
+  args: getVideoDefaultPlaybackRateInterface
+): Promise<void> => {
+
+  try {
+    const element = await args.driver.$(args.selector);
+
+    // defaultPlaybackRate gives the original playback speed of the video
+    const _defaultPlaybackRate = await element.getProperty("defaultPlaybackRate");
+
+
+    args.scriptDataAppender.add(async () => {
+
+      const ffElement: any = await args.elementGetter.getFireFlinkElement(
+        args.pageDOM,
+        `[ff-inspect="${args.fireflinkIndex}"]`
+      );
+      return {
+        nlpName: "GetVideoDefaultPlaybackRate",
+        stepInputs: [],
+        elementsData: [{
+          name: args.elementName,
+          type: args.elementType,
+          locators: ffElement.locators,
+          platform: args.platform
+        }]
+      };
+    });
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetVideoDefaultPlaybackRate");
+    throw new Error("GetVideoDefaultPlaybackRate action failed", { cause: error });
+  }
+};

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

@@ -0,0 +1,40 @@
+import { getVideoDimensionInterface } from "../../interface/getActionInterface.js";
+
+export const getVideoDimension = async (
+  args: getVideoDimensionInterface
+): Promise<void> => {
+
+  try {
+    const element = await args.driver.$(args.selector);
+
+    // Get intrinsic video resolution
+    const videoWidth = await element.getProperty("videoWidth");
+    const videoHeight = await element.getProperty("videoHeight");
+
+    // Optional: combine into dimension string if needed internally
+    const _dimension = `${videoWidth}x${videoHeight}`;
+
+
+
+    args.scriptDataAppender.add(async () => {
+      const ffElement: any = await args.elementGetter.getFireFlinkElement(
+        args.pageDOM,
+        `[ff-inspect="${args.fireflinkIndex}"]`
+      );
+      return {
+        nlpName: "GetVideoDimension",
+        stepInputs: [],
+        elementsData: [{
+          name: args.elementName,
+          type: args.elementType,
+          locators: ffElement.locators,
+          platform: args.platform
+        }]
+      };
+    });
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetVideoDimension");
+    throw new Error("GetVideoDimension action failed", { cause: error });
+  }
+};

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

@@ -0,0 +1,36 @@
+import { getVideoHeightInterface } from "../../interface/getActionInterface.js";
+
+export const getVideoHeight = async (
+    args: getVideoHeightInterface
+): Promise<void> => {
+
+    try {
+        const element = await args.driver.$(args.selector);
+
+        // Get actual rendered video height (videoHeight gives intrinsic height)
+        const _heightValue = await element.getProperty("videoHeight");
+
+
+
+        args.scriptDataAppender.add(async () => {
+            const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                args.pageDOM,
+                `[ff-inspect="${args.fireflinkIndex}"]`
+            );
+            return {
+                nlpName: "GetVideoHeight",
+                stepInputs: [],
+                elementsData: [{
+                    name: args.elementName,
+                    type: args.elementType,
+                    locators: ffElement.locators,
+                    platform: args.platform
+                }]
+            };
+        });
+
+    } catch (error) {
+        args.scriptDataAppender.setErrorNLP("GetVideoHeight");
+        throw new Error("GetVideoHeight action failed", { cause: error });
+    }
+};

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

@@ -0,0 +1,36 @@
+import { getVideoMediaLengthInterface } from "../../interface/getActionInterface.js";
+
+export const getVideoMediaLength = async (
+  args: getVideoMediaLengthInterface
+): Promise<void> => {
+
+  try {
+    const element = await args.driver.$(args.selector);
+
+    // duration returns total media length in seconds
+    const _videoDuration = await element.getProperty("duration");
+
+
+
+    args.scriptDataAppender.add(async () => {
+      const ffElement: any = await args.elementGetter.getFireFlinkElement(
+        args.pageDOM,
+        `[ff-inspect="${args.fireflinkIndex}"]`
+      );
+      return {
+        nlpName: "GetVideoMediaLength",
+        stepInputs: [],
+        elementsData: [{
+          name: args.elementName,
+          type: args.elementType,
+          locators: ffElement.locators,
+          platform: args.platform
+        }]
+      };
+    });
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetVideoMediaLength");
+    throw new Error("GetVideoMediaLength action failed", { cause: error });
+  }
+};

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

@@ -0,0 +1,46 @@
+import { getVideoMediaSourceInterface } from "../../interface/getActionInterface.js";
+
+export const getVideoMediaSource = async (
+  args: getVideoMediaSourceInterface
+): Promise<void> => {
+
+  try {
+    const element = await args.driver.$(args.selector);
+
+    // Get video source URL (for <video> tag)
+    const videoSource = await element.getAttribute("src");
+
+    // If <source> tag is used inside <video>
+    let finalSource = videoSource;
+
+    if (!finalSource) {
+      const sourceElement = await element.$("source");
+      if (await sourceElement.isExisting()) {
+        finalSource = await sourceElement.getAttribute("src");
+      }
+    }
+
+
+    args.scriptDataAppender.add(async () => {
+
+      const ffElement: any = await args.elementGetter.getFireFlinkElement(
+        args.pageDOM,
+        `[ff-inspect="${args.fireflinkIndex}"]`
+      );
+      return {
+        nlpName: "GetVideoMediaSource",
+        stepInputs: [],
+        elementsData: [{
+          name: args.elementName,
+          type: args.elementType,
+          locators: ffElement.locators,
+          platform: args.platform
+        }]
+      };
+    });
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetVideoMediaSource");
+    throw new Error("GetVideoMediaSource action failed", { cause: error });
+  }
+};

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,36 @@
+import { getWrappedElementInterface } from "../../interface/getActionInterface.js";
+
+export const getWrappedElement = async (
+  args: getWrappedElementInterface
+): Promise<void> => {
+
+  try {
+    const element = await args.driver.$(args.selector);
+
+    // In WDIO, this is already the wrapped element
+    const _wrappedElement = element;
+
+
+
+    args.scriptDataAppender.add(async () => {
+      const ffElement: any = await args.elementGetter.getFireFlinkElement(
+        args.pageDOM,
+        `[ff-inspect="${args.fireflinkIndex}"]`
+      );
+      return {
+        nlpName: "GetWrappedElement",
+        stepInputs: [],
+        elementsData: [{
+          name: args.elementName,
+          type: args.elementType,
+          locators: ffElement.locators,
+          platform: args.platform
+        }]
+      };
+    });
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetWrappedElement");
+    throw new Error("GetWrappedElement action failed", { cause: error });
+  }
+};

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

@@ -0,0 +1,47 @@
+import { getWrappedOptionFromListBoxAsTextInterface } from "../../interface/getActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+
+export async function getWrappedOptionFromListBoxAsText(
+    args: getWrappedOptionFromListBoxAsTextInterface
+): Promise<string[]> {
+    try {
+        // 🔹 Get element from driver
+        const element = await args.driver.$(args.selector);
+
+        // 🔹 Get all <option> elements inside dropdown
+        const options = await element.$$("option");
+        const optionTexts: string[] = [];
+
+        for (const option of options) {
+            const text = await option.getText();
+            optionTexts.push(text.trim());
+        }
+
+        logger.info("Wrapped options in getWrappedOptionFromListBoxAsText:", { optionTexts });
+
+
+        args.scriptDataAppender.add(async () => {
+            const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                args.pageDOM,
+                `[ff-inspect="${args.fireflinkIndex}"]`
+            );
+            return {
+
+                nlpName: "GetWrappedOptionFromListBoxAsText",
+                stepInputs: [],
+                elementsData: [{
+                    name: args.elementName,
+                    type: args.elementType,
+                    locators: ffElement.locators,
+                    platform: args.platform
+                }]
+            };
+        });
+
+        return optionTexts;
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("GetWrappedOptionFromListBoxAsText");
+        throw new Error("GetWrappedOptionFromListBoxAsText action failed", { cause: error });
+    }
+}

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

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

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

@@ -0,0 +1,71 @@
+import { logger } from "../../../../utils/logger/logData.js";
+import { getXLocationOfWebElementInterface } from "../../interface/getActionInterface.js";
+
+export const getXLocationOfWebElement = async (
+  args: getXLocationOfWebElementInterface
+): Promise<void> => {
+  switch (args.platform) {
+    case "android":
+      try {
+        const element = await args.driver.$(args.selector);
+
+        const _location = await element.getLocation();
+        const _x = _location.x;
+
+        logger.info(`X Location of element: ${_x}`);
+
+        args.scriptDataAppender.add(async () => {
+
+          return {
+            nlpName: "MOB_GetX",
+            stepInputs: [],
+            elementsData: [{
+              name: args.elementName,
+              type: args.elementType,
+              locators: [{ "xpath": args.selector }],
+              platform: args.platform
+            }]
+          };
+        });
+
+      } catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_GetX");
+        throw new Error("GetXLocationOfWebElement action failed", { cause: error });
+      }
+      break;
+    case "web":
+    default:
+      try {
+        const element = await args.driver.$(args.selector);
+
+        const _location = await element.getLocation();
+        const _x = _location.x;
+
+        logger.info(`X Location of element: ${_x}`);
+
+        args.scriptDataAppender.add(async () => {
+          const ffElement: any = await args.elementGetter.getFireFlinkElement(
+            args.pageDOM,
+            `[ff-inspect="${args.fireflinkIndex}"]`
+          );
+          return {
+            nlpName: "GetXLocationOfWebElement",
+            stepInputs: [],
+            elementsData: [{
+              name: args.elementName,
+              type: args.elementType,
+              locators: ffElement.locators,
+              platform: args.platform
+            }]
+          };
+        });
+
+      } catch (error) {
+        args.scriptDataAppender.setErrorNLP("GetXLocationOfWebElement");
+        throw new Error("GetXLocationOfWebElement action failed", { cause: error });
+      }
+      break;
+  }
+
+
+};

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

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

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

@@ -0,0 +1,70 @@
+import { logger } from "../../../../utils/logger/logData.js";
+import { getYLocationOfWebElementInterface } from "../../interface/getActionInterface.js";
+
+export const getYLocationOfWebElement = async (
+  args: getYLocationOfWebElementInterface
+): Promise<void> => {
+  switch (args.platform) {
+    case "android":
+      try {
+        const element = await args.driver.$(args.selector);
+
+        const _location = await element.getLocation();
+        const _y = _location.y;
+
+        logger.info(`X Location of element: ${_y}`);
+
+        args.scriptDataAppender.add(async () => {
+
+          return {
+            nlpName: "MOB_GetY",
+            stepInputs: [],
+            elementsData: [{
+              name: args.elementName,
+              type: args.elementType,
+              locators: [{ "xpath": args.selector }],
+              platform: args.platform
+            }]
+          };
+        });
+
+      } catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_GetY");
+        throw new Error("GetXLocationOfWebElement action failed", { cause: error });
+      }
+      break;
+    case "web":
+    default:
+      try {
+        const element = await args.driver.$(args.selector);
+
+        const _location = await element.getLocation();
+        const _y = _location.y;
+
+
+
+        args.scriptDataAppender.add(async () => {
+          const ffElement: any = await args.elementGetter.getFireFlinkElement(
+            args.pageDOM,
+            `[ff-inspect="${args.fireflinkIndex}"]`
+          );
+          return {
+            nlpName: "GetYLocationOfWebElement",
+            stepInputs: [],
+            elementsData: [{
+              name: args.elementName,
+              type: args.elementType,
+              locators: ffElement.locators,
+              platform: args.platform
+            }]
+          };
+        });
+
+      } catch (error) {
+        args.scriptDataAppender.setErrorNLP("GetYLocationOfWebElement");
+        throw new Error("GetYLocationOfWebElement action failed", { cause: error });
+      }
+      break;
+  }
+
+}

package/src/automation/actions/interaction/iframe/switchToDefaultContent.ts

@@ -0,0 +1,15 @@
+import { SwitchToDefaultContentInterface } from "../../interface/IframeInterface.js";
+export async function switchToDefaultContent(args: SwitchToDefaultContentInterface): Promise<void> {
+    try {
+        await args.driver.switchToFrame(null);
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'SwitchToDefaultContent',
+            elementsData: [],
+            stepInputs: []
+        }));
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("SwitchToDefaultContent")
+        throw new Error("SwitchToDefaultContent action failed", { cause: error });
+    }
+}