ff-automationv2 2.1.3 → 2.2.0

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

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

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

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

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

@@ -0,0 +1,46 @@
+import { getAllTheOptionsFromListBoxAsTextInterface }
+  from "../../interface/getActionInterface.js";
+
+export const getAllTheOptionsFromListBoxAsText = async (
+  args: getAllTheOptionsFromListBoxAsTextInterface
+): Promise<void> => {
+
+  try {
+    const selectElement = await args.driver.$(args.selector);
+
+    const options = await selectElement.$$('option');
+
+    const _texts: string[] = [];
+
+    for (const option of options) {
+      const text = await option.getText();
+      _texts.push(text.trim());
+    }
+
+
+
+    args.scriptDataAppender.add(async () => {
+      const ffElement: any = await args.elementGetter.getFireFlinkElement(
+        args.pageDOM,
+        `[ff-inspect="${args.fireflinkIndex}"]`
+      );
+      return {
+        nlpName: "GetAllTheOptionsFromListBoxAsText",
+        stepInputs: [],
+        elementsData: [{
+          name: args.elementName,
+          type: args.elementType,
+          locators: ffElement.locators,
+          platform: args.platform
+        }]
+      };
+    });
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetAllTheOptionsFromListBoxAsText");
+    throw new Error(
+      "GetAllTheOptionsFromListBoxAsText action failed",
+      { cause: error }
+    );
+  }
+};

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

@@ -0,0 +1,54 @@
+import { getAllTheOptionsFromListBoxAsTextInSortedOrderInterface }
+  from "../../interface/getActionInterface.js";
+
+export const getAllTheOptionsFromListBoxAsTextInSortedOrder = async (
+  args: getAllTheOptionsFromListBoxAsTextInSortedOrderInterface
+): Promise<void> => {
+
+  try {
+    const selectElement = await args.driver.$(args.selector);
+
+    const options = await selectElement.$$('option');
+
+    const _texts: string[] = [];
+
+    for (const option of options) {
+      const text = await option.getText();
+      _texts.push(text.trim());
+    }
+
+    // value is strictly boolean now
+    const isAscending = args.value;
+
+    _texts.sort((a, b) => a.localeCompare(b));
+
+    if (!isAscending) {
+      _texts.reverse();
+    }
+
+
+    args.scriptDataAppender.add(async () => {
+      const ffElement: any = await args.elementGetter.getFireFlinkElement(
+        args.pageDOM,
+        `[ff-inspect="${args.fireflinkIndex}"]`
+      );
+      return {
+        nlpName: "GetAllTheOptionsFromListBoxAsTextInSortedOrder",
+        stepInputs: [args.value],
+        elementsData: [{
+          name: args.elementName,
+          type: args.elementType,
+          locators: ffElement.locators,
+          platform: args.platform
+        }]
+      };
+    });
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetAllTheOptionsFromListBoxAsTextInSortedOrder");
+    throw new Error(
+      "GetAllTheOptionsFromListBoxAsTextInSortedOrder action failed",
+      { cause: error }
+    );
+  }
+};

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

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

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

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

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

@@ -0,0 +1,83 @@
+import { getAttributeInterface } from "../../interface/getActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+
+export async function getAttribute(
+    args: getAttributeInterface
+): Promise<void> {
+    switch (args.platform) {
+        case "android":
+            try {
+
+                const attributeName = args.value;
+                if (attributeName === "") {
+                    throw new Error("For GetAttribute action Attributr is not Provided");
+                }
+
+
+                logger.info("Attribute value in getAttribute:", {
+                    attributeName
+                });
+
+
+                args.scriptDataAppender.add(async () => {
+
+                    return {
+                        nlpName: "MOB_GetAttribute",
+                        stepInputs: [attributeName],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: [{ "xpath": args.selector }],
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("MOB_GetAttribute");
+                throw new Error("GetAttribute action failed", { cause: error });
+            }
+            break;
+        case "web":
+        default:
+            try {
+                const attributeName = args.value;
+                if (attributeName === "") {
+                    throw new Error("For GetAttribute action Attributr is not Provided");
+                }
+
+
+                logger.info("Attribute value in getAttribute:", {
+                    attributeName
+                });
+
+
+                args.scriptDataAppender.add(async () => {
+                    const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                        args.pageDOM,
+                        `[ff-inspect="${args.fireflinkIndex}"]`
+                    );
+                    return {
+                        nlpName: "GetAttribute",
+                        stepInputs: [attributeName],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: ffElement.locators,
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("GetAttribute");
+                throw new Error("GetAttribute action failed", { cause: error });
+            }
+            break;
+    }
+
+}

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

@@ -0,0 +1,35 @@
+import { getAudioCurrentPlaybackRateInterface } from "../../interface/getActionInterface.js";
+
+export const getAudioCurrentPlaybackRate = async (
+    args: getAudioCurrentPlaybackRateInterface
+): Promise<void> => {
+
+    try {
+        const element = await args.driver.$(args.selector);
+
+        // playbackRate returns current speed (default is 1)
+        const _currentPlaybackRate = await element.getProperty("playbackRate");
+
+
+        args.scriptDataAppender.add(async () => {
+            const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                args.pageDOM,
+                `[ff-inspect="${args.fireflinkIndex}"]`
+            );
+            return {
+                nlpName: "GetAudioCurrentPlaybackRate",
+                stepInputs: [],
+                elementsData: [{
+                    name: args.elementName,
+                    type: args.elementType,
+                    locators: ffElement.locators,
+                    platform: args.platform
+                }]
+            };
+        });
+
+    } catch (error) {
+        args.scriptDataAppender.setErrorNLP("GetAudioCurrentPlaybackRate");
+        throw new Error("GetAudioCurrentPlaybackRate action failed", { cause: error });
+    }
+};

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

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

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

@@ -0,0 +1,36 @@
+import { getAudioCurrentVolumeInterface } from "../../interface/getActionInterface.js";
+
+export const getAudioCurrentVolume = async (
+    args: getAudioCurrentVolumeInterface
+): Promise<void> => {
+
+    try {
+        const element = await args.driver.$(args.selector);
+
+        // volume 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: "GetAudioCurrentVolume",
+                stepInputs: [],
+                elementsData: [{
+                    name: args.elementName,
+                    type: args.elementType,
+                    locators: ffElement.locators,
+                    platform: args.platform
+                }]
+            };
+        });
+
+    } catch (error) {
+        args.scriptDataAppender.setErrorNLP("GetAudioCurrentVolume");
+        throw new Error("GetAudioCurrentVolume action failed", { cause: error });
+    }
+};

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

@@ -0,0 +1,43 @@
+import { getAudioDecodedByteInterface } from "../../interface/getActionInterface.js";
+
+export const getAudioDecodedByte = async (
+    args: getAudioDecodedByteInterface
+): Promise<void> => {
+
+    try {
+        const element = await args.driver.$(args.selector);
+
+        // Get buffered duration (closest equivalent to decoded media)
+        const _decodedValue = await args.driver.execute((el: any) => {
+
+            if (el.buffered && el.buffered.length > 0) {
+                return el.buffered.end(0); // seconds buffered
+            }
+
+            return 0;
+
+        }, element);
+
+
+        args.scriptDataAppender.add(async () => {
+            const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                args.pageDOM,
+                `[ff-inspect="${args.fireflinkIndex}"]`
+            );
+            return {
+                nlpName: "GetAudioDecodedByte",
+                stepInputs: [],
+                elementsData: [{
+                    name: args.elementName,
+                    type: args.elementType,
+                    locators: ffElement.locators,
+                    platform: args.platform
+                }]
+            };
+        });
+
+    } catch (error) {
+        args.scriptDataAppender.setErrorNLP("GetAudioDecodedByte");
+        throw new Error("GetAudioDecodedByte action failed", { cause: error });
+    }
+};

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

@@ -0,0 +1,36 @@
+import { getAudioDefaultPlaybackRateInterface } from "../../interface/getActionInterface.js";
+
+export const getAudioDefaultPlaybackRate = async (
+    args: getAudioDefaultPlaybackRateInterface
+): Promise<void> => {
+
+    try {
+        const element = await args.driver.$(args.selector);
+
+        // defaultPlaybackRate returns original playback speed (default = 1)
+        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: "GetAudioDefaultPlaybackRate",
+                stepInputs: [],
+                elementsData: [{
+                    name: args.elementName,
+                    type: args.elementType,
+                    locators: ffElement.locators,
+                    platform: args.platform
+                }]
+            };
+        });
+
+    } catch (error) {
+        args.scriptDataAppender.setErrorNLP("GetAudioDefaultPlaybackRate");
+        throw new Error("GetAudioDefaultPlaybackRate action failed", { cause: error });
+    }
+};

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

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

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

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

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

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

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

@@ -0,0 +1,44 @@
+import { getAudioMediaSourceInterface } from "../../interface/getActionInterface.js";
+
+export const getAudioMediaSource = async (
+  args: getAudioMediaSourceInterface
+): Promise<void> => {
+
+  try {
+    const element = await args.driver.$(args.selector);
+
+    // ✅ Try direct src attribute first
+    let _audioSource = await element.getAttribute("src");
+
+    // ✅ If <source> tag is used inside <audio>
+    if (!_audioSource) {
+      const sourceElement = await element.$("source");
+      if (await sourceElement.isExisting()) {
+        _audioSource = await sourceElement.getAttribute("src");
+      }
+    }
+
+
+
+    args.scriptDataAppender.add(async () => {
+      const ffElement: any = await args.elementGetter.getFireFlinkElement(
+        args.pageDOM,
+        `[ff-inspect="${args.fireflinkIndex}"]`
+      );
+      return {
+        nlpName: "GetAudioMediaSource",
+        stepInputs: [],
+        elementsData: [{
+          name: args.elementName,
+          type: args.elementType,
+          locators: ffElement.locators,
+          platform: args.platform
+        }]
+      };
+    });
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetAudioMediaSource");
+    throw new Error("GetAudioMediaSource action failed", { cause: error });
+  }
+};