ff-automationv2 2.1.3 → 2.2.0

package/src/automation/actions/interaction/maximize/maximize.ts

@@ -0,0 +1,15 @@
+import type { MaximizeInterface } from "../../interface/maximizeAndMinimizeInterface.js";
+export async function maximize(maximizeInterface: MaximizeInterface): Promise<void> {
+    try {
+        const { driver, scriptDataAppender } = maximizeInterface;
+        await driver.maximizeWindow();
+        scriptDataAppender.add(async () => ({
+            nlpName: "Maximize",
+            elementsData: [],
+            stepInputs: []
+        }));
+    } catch (error: any) {
+        maximizeInterface.scriptDataAppender.setErrorNLP("Maximize")
+        throw new Error("Maximize action failed", { cause: error });
+    }
+}

package/src/automation/actions/interaction/maximize/minimize.ts

@@ -0,0 +1,17 @@
+import { MinimizeInterface } from "../../interface/maximizeAndMinimizeInterface.js";
+
+export async function minimize(minimizeInterface: MinimizeInterface): Promise<void> {
+    try {
+        const { driver, scriptDataAppender } = minimizeInterface;
+        await driver.minimizeWindow();
+        await scriptDataAppender.add(async () => ({
+            nlpName: "MinimizeBrowser",
+            elementsData: [],
+            stepInputs: []
+        }));
+    }
+    catch (error) {
+        minimizeInterface.scriptDataAppender.setErrorNLP("MinimizeBrowser")
+        throw new Error("MinimizeBrowser action failed", { cause: error });
+    }
+}

package/src/automation/actions/interaction/navigation/goBack.ts

@@ -0,0 +1,14 @@
+import { goBackInterface } from "../../interface/navigationActionInterface.js";
+export async function goBack(args: goBackInterface): Promise<void> {
+    try {
+        await args.driver.back();
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'NavigateBack',
+            elementsData: [],
+            stepInputs: []
+        }));
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("NavigateBack")
+        throw new Error("Navigate action failed", { cause: error });
+    }
+}

package/src/automation/actions/interaction/navigation/navigate.ts

@@ -0,0 +1,16 @@
+import { navigateToUrlInterface } from "../../interface/navigationActionInterface.js";
+export async function navigate(args: navigateToUrlInterface): Promise<void> {
+
+    try {
+        await args.driver.url(args.url);
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'NavigateToURL',
+            elementsData: [],
+            stepInputs: [args.url]
+        }));
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("NavigateToURL")
+        throw new Error("Navigate action failed", { cause: error });
+    }
+}

package/src/automation/actions/interaction/navigation/refresh.ts

@@ -0,0 +1,14 @@
+import { refreshInterface } from "../../interface/navigationActionInterface.js";
+export async function pageRefresh(args: refreshInterface): Promise<void> {
+    try {
+        await args.driver.refresh();
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'refresh',
+            elementsData: [],
+            stepInputs: []
+        }));
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("refresh")
+        throw new Error("Refresh action failed", { cause: error });
+    }
+}   

package/src/automation/actions/interaction/press/mobPressBackKey.ts

@@ -0,0 +1,19 @@
+import { PressBackKeyInterface } from "../../interface/pressActionInterface.js";
+export async function pressBackKey(args: PressBackKeyInterface): Promise<void> {
+    try {
+
+        await args.driver.back();
+        args.scriptDataAppender.add(async () => {
+
+            return {
+                nlpName: 'MOB_PressBackKey',
+                stepInputs: [],
+                elementsData: []
+            };
+
+        });
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("MOB_PressBackKey")
+        throw new Error(`PressBackKey action failed :`, { cause: error });
+    }
+}

package/src/automation/actions/interaction/press/pressAnyKey.ts

@@ -0,0 +1,89 @@
+import { PressAnyKeyInterface } from "../../interface/pressActionInterface.js";
+
+export async function pressAnyKey(
+    args: PressAnyKeyInterface
+): Promise<void> {
+    switch (args.platform) {
+        case "android":
+            try {
+                const keyValue = args.value;
+
+                if (!keyValue) {
+                    throw new Error("Please Mention Key in step");
+                }
+
+
+                switch (keyValue) {
+                    case "enter":
+                        await args.driver.keys("\uE007");
+                        break;
+                    case "tab":
+                        await args.driver.keys("\uE004");
+                        break;
+                    case "escape":
+                        await args.driver.keys("\uE00C");
+                        break;
+                    default:
+                        await args.driver.keys("\uE007");
+                }
+
+
+
+
+                args.scriptDataAppender.add(async () => {
+
+                    return {
+                        nlpName: "MOB_PressAnyKey",
+                        stepInputs: [keyValue],
+                        elementsData: []
+                    };
+                });
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("MOB_PressAnyKey");
+                throw new Error("press any key action failed", { cause: error });
+            }
+            break;
+        case "web":
+        default:
+            try {
+                const keyValue = args.value;
+
+                if (!keyValue) {
+                    throw new Error("Please Mention Key in step");
+                }
+
+
+                switch (keyValue) {
+                    case "enter":
+                        await args.driver.keys("\uE007");
+                        break;
+                    case "tab":
+                        await args.driver.keys("\uE004");
+                        break;
+                    case "escape":
+                        await args.driver.keys("\uE00C");
+                        break;
+                    default:
+                        await args.driver.keys("\uE007");
+                }
+
+
+
+                args.scriptDataAppender.add(async () => {
+
+                    return {
+                        nlpName: "PressAnyKey",
+                        stepInputs: [keyValue],
+                        elementsData: []
+                    };
+                });
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("PressAnyKey");
+                throw new Error("press any key action failed", { cause: error });
+            }
+            break;
+    }
+
+}

package/src/automation/actions/interaction/press/pressAnyKeyNTimes.ts

@@ -0,0 +1,100 @@
+import { PressAnyKeyNTimesInterface } from "../../interface/pressActionInterface.js";
+
+export async function pressAnyKeyNTimes(
+    args: PressAnyKeyNTimesInterface
+): Promise<void> {
+    switch (args.platform) {
+        case "android":
+            try {
+
+
+
+                const parts = String(args.value).split(",");
+
+                const keyValue = parts[0]?.trim().toLowerCase() || "";
+                const nValue = parseInt(parts[1]?.trim() || "1", 10);
+
+                if (!keyValue) {
+                    throw new Error("Please Mention Key in step");
+                }
+
+                for (let i = 0; i < nValue; i++) {
+                    switch (keyValue) {
+                        case "enter":
+                            await args.driver.keys("\uE007");
+                            break;
+                        case "tab":
+                            await args.driver.keys("\uE004");
+                            break;
+                        case "escape":
+                            await args.driver.keys("\uE00C");
+                            break;
+                        default:
+                            await args.driver.keys(keyValue);
+                    }
+                }
+
+
+
+                args.scriptDataAppender.add(async () => {
+
+                    return {
+                        nlpName: "MOB_PressAnyKeyNTimes",
+                        stepInputs: [keyValue, nValue],
+                        elementsData: []
+                    };
+                });
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("MOB_PressAnyKeyNTimes");
+                throw new Error("press any key n times action failed", { cause: error });
+            }
+            break;
+        case "web":
+        default:
+            try {
+
+
+                const parts = String(args.value).split(",");
+
+                const keyValue = parts[0]?.trim().toLowerCase() || "";
+                const nValue = parseInt(parts[1]?.trim() || "1", 10);
+
+                if (!keyValue) {
+                    throw new Error("Please Mention Key in step");
+                }
+
+                for (let i = 0; i < nValue; i++) {
+                    switch (keyValue) {
+                        case "enter":
+                            await args.driver.keys("\uE007");
+                            break;
+                        case "tab":
+                            await args.driver.keys("\uE004");
+                            break;
+                        case "escape":
+                            await args.driver.keys("\uE00C");
+                            break;
+                        default:
+                            await args.driver.keys(keyValue);
+                    }
+                }
+
+
+
+                args.scriptDataAppender.add(async () => {
+                    return {
+                        nlpName: "PressAnyKeyNTimes",
+                        stepInputs: [keyValue, nValue],   // Always array
+                        elementsData: []
+                    };
+                });
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("PressAnyKeyNTimes");
+                throw new Error("press any key n times action failed", { cause: error });
+            }
+            break;
+    }
+
+}

package/src/automation/actions/interaction/press/pressEnterKey.ts

@@ -0,0 +1,45 @@
+import { PressEnterKeyInterface } from "../../interface/pressActionInterface.js";
+
+export async function pressEnterKey(
+    args: PressEnterKeyInterface
+): Promise<void> {
+    switch (args.platform) {
+        case "android":
+            try {
+                await args.driver.keys("\uE007");
+
+                args.scriptDataAppender.add(async () => {
+
+                    return {
+                        nlpName: "MOB_PressEnterKey",
+                        stepInputs: [],
+                        elementsData: []
+                    };
+                });
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("MOB_PressEnterKey");
+                throw new Error("press enter key action failed", { cause: error });
+            }
+            break;
+        case "web":
+        default:
+            try {
+                await args.driver.keys("\uE007");
+                args.scriptDataAppender.add(async () => {
+
+                    return {
+                        nlpName: "PressEnterKey",
+                        stepInputs: [],
+                        elementsData: []
+                    };
+                });
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("PressEnterKey");
+                throw new Error("press enter key action failed", { cause: error });
+            }
+            break;
+    }
+
+}

package/src/automation/actions/interaction/scroll/scrollHorizontallyTillElementIsVisible.ts

@@ -0,0 +1,29 @@
+import { scrollHorizontallyTillElementIsVisibleInterface } from "../../interface/scrollActionInterface";
+
+export async function scrollHorizontallyTillElementIsVisible(args: scrollHorizontallyTillElementIsVisibleInterface): Promise<void> {
+    const { driver, selector, scriptDataAppender, elementGetter, fireflinkIndex, pageDOM, elementName, elementType, platform } = args;
+    try {
+        const element = await driver.$(selector);
+        await element.scrollIntoView({ block: 'center', inline: 'center' });
+
+        scriptDataAppender.add(async () => {
+            const ffElement: any = await elementGetter.getFireFlinkElement(
+                pageDOM,
+                `[ff-inspect="${fireflinkIndex}"]`
+            );
+            return {
+                nlpName: 'ScrollHorizontallyTillElementIsVisible',
+                stepInputs: [],
+                elementsData: [{
+                    name: elementName,
+                    type: elementType,
+                    locators: ffElement.locators,
+                    platform: platform
+                }]
+            };
+        });
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("ScrollHorizontallyTillElementIsVisible")
+        throw new Error("ScrollHorizontallyTillElementIsVisible action failed", { cause: error });
+    }
+}

package/src/automation/actions/interaction/scroll/scrollPageToSpecificLocation.ts

@@ -0,0 +1,37 @@
+import { scrollPageToSpecificLocationInterface } from "../../interface/scrollActionInterface.js";
+
+export const scrollPageToSpecificLocation = async (
+    args: scrollPageToSpecificLocationInterface
+) => {
+    try {
+        const location = args.value?.trim().toLowerCase();
+
+        if (location === "bottom") {
+            await args.driver.execute(() => window.scrollTo(0, document.body.scrollHeight));
+        } else if (location === "top") {
+            await args.driver.execute(() => window.scrollTo(0, 0));
+        } else {
+            // Try parsing coordinates or pixel value
+            const coords = location?.split(",").map(c => parseInt(c.trim()));
+            if (coords && coords.length === 2 && !isNaN(coords[0]) && !isNaN(coords[1])) {
+                await args.driver.execute((x, y) => window.scrollTo(x, y), coords[0], coords[1]);
+            } else if (coords && coords.length === 1 && !isNaN(coords[0])) {
+                await args.driver.execute((y) => window.scrollTo(0, y), coords[0]);
+            }
+        }
+
+        const inputs = (args.value || "").split(",").map(v => v.trim());
+        const x = inputs[0] ? parseInt(inputs[0]) : 0;
+        const y = inputs[1] ? parseInt(inputs[1]) : 0;
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "ScrollPageToSpecificLocation",
+            stepInputs: [String(isNaN(x) ? 0 : x), String(isNaN(y) ? 0 : y)],
+            elementsData: []
+        }));
+
+    } catch (error) {
+        args.scriptDataAppender.setErrorNLP("ScrollPageToSpecificLocation");
+        throw new Error("ScrollPageToSpecificLocation action failed", { cause: error });
+    }
+};

package/src/automation/actions/interaction/scroll/scrollToElement.ts

@@ -0,0 +1,28 @@
+import { scrollToElementInterface } from "../../interface/scrollActionInterface.js";
+
+export async function scrollToElement(args: scrollToElementInterface): Promise<void> {
+    try {
+        const element = await args.driver.$(args.selector);
+        await element.scrollIntoView({ block: 'center', inline: 'center' });
+
+        args.scriptDataAppender.add(async () => {
+            const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                args.pageDOM,
+                `[ff-inspect="${args.fireflinkIndex}"]`
+            );
+            return {
+                nlpName: 'ScrollToElement',
+                stepInputs: [],
+                elementsData: [{
+                    name: args.elementName,
+                    type: args.elementType,
+                    locators: ffElement.locators,
+                    platform: args.platform
+                }]
+            };
+        });
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("ScrollToElement")
+        throw new Error("ScrollToElement action failed", { cause: error });
+    }
+}

package/src/automation/actions/interaction/scroll/scrollVerticallyTillElementIsVisible.ts

@@ -0,0 +1,29 @@
+import { scrollVerticallyTillElementIsVisibleInterface } from "../../interface/scrollActionInterface";
+
+export async function scrollVerticallyTillElementIsVisible(args: scrollVerticallyTillElementIsVisibleInterface): Promise<void> {
+    const { driver, selector, scriptDataAppender, elementGetter, fireflinkIndex, pageDOM, elementName, elementType, platform } = args;
+    try {
+        const element = await driver.$(selector);
+        await element.scrollIntoView({ block: 'center', inline: 'center' });
+
+        scriptDataAppender.add(async () => {
+            const ffElement: any = await elementGetter.getFireFlinkElement(
+                pageDOM,
+                `[ff-inspect="${fireflinkIndex}"]`
+            );
+            return {
+                nlpName: 'ScrollVerticallyTillElementIsVisible',
+                stepInputs: [],
+                elementsData: [{
+                    name: elementName,
+                    type: elementType,
+                    locators: ffElement.locators,
+                    platform: platform
+                }]
+            };
+        });
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("ScrollVerticallyTillElementIsVisible")
+        throw new Error("ScrollVerticallyTillElementIsVisible action failed", { cause: error });
+    }
+}

package/src/automation/actions/interaction/set/setClipBoardText.ts

@@ -0,0 +1,46 @@
+import { setClipBoardTextInterface } from "../../interface/setActionInterface.js";
+
+export async function setClipBoardText(
+    args: setClipBoardTextInterface
+): Promise<void> {
+
+
+    switch (args.platform) {
+
+        case "android":
+            try {
+
+                args.scriptDataAppender.add(async () => {
+                    return {
+                        nlpName: 'MOB_SetClipBoardText',
+                        stepInputs: [args.value],
+                        elementsData: []
+                    };
+                });
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("MOB_SetClipBoardText")
+                throw new Error(`SetClipBoardText action failed`, { cause: error });
+            }
+            break;
+
+
+        case "web":
+        default:
+            try {
+
+                args.scriptDataAppender.add(async () => {
+                    return {
+                        nlpName: 'SetClipBoardText',
+                        stepInputs: [args.value],
+                        elementsData: []
+                    };
+                });
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("SetClipBoardText")
+                throw new Error(`SetClipBoardText action failed`, { cause: error });
+            }
+            break;
+    }
+}

package/src/automation/actions/interaction/shadowDom/shadowDomClick.ts

@@ -0,0 +1,25 @@
+import { ClickShadowInterface } from "../../interface/shadowDomInterface.js";
+import { SHADOW_DOM_CLICK_JS } from "../../../../utils/javascript/jsForShadowRoot.js";
+
+export async function clickShadowElement(args: ClickShadowInterface): Promise<void> {
+  try {
+
+    const executableJS = SHADOW_DOM_CLICK_JS.replace("arguments[0]", `"${args.selector}"`);
+    await args.driver.execute(
+      SHADOW_DOM_CLICK_JS,
+      args.selector
+    );
+
+    args.scriptDataAppender.add(async () => ({
+      nlpName: 'ExecuteJavaScript',
+      elementsData: [],
+      stepInputs: [executableJS]
+    }));
+
+  } catch (error: any) {
+
+    args.scriptDataAppender.setErrorNLP("ExecuteJavaScript");
+    throw new Error(`Shadow Click action failed`, { cause: error });
+  }
+}
+

package/src/automation/actions/interaction/shadowDom/shadowDomEnter.ts

@@ -0,0 +1,27 @@
+import { EnterInputShadowInterface } from "../../interface/shadowDomInterface.js";
+import { SHADOW_DOM_ENTER_JS } from "../../../../utils/javascript/jsForShadowRoot.js";
+
+export async function enterInputShadow(args: EnterInputShadowInterface): Promise<void> {
+    try {
+
+        const executableJS = SHADOW_DOM_ENTER_JS.replace("arguments[0]", `"${args.selector}"`).replace("arguments[1]", `"${args.value}"`);
+
+        await args.driver.execute(
+            SHADOW_DOM_ENTER_JS,
+            args.selector,
+            args.value
+        );
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'ExecuteJavaScript',
+            elementsData: [],
+            stepInputs: [executableJS]
+        }));
+
+    } catch (error: any) {
+
+        args.scriptDataAppender.setErrorNLP("ExecuteJavaScript");
+
+        throw new Error(`Shadow Enter Input action failed`, { cause: error });
+    }
+}

package/src/automation/actions/interaction/shadowDom/shadowDomGetText.ts

@@ -0,0 +1,28 @@
+import { ShadowGetTextInterface } from "../../interface/shadowDomInterface.js";
+import { SHADOW_DOM_GET_TEXT_JS } from "../../../../utils/javascript/jsForShadowRoot.js";
+
+export async function getTextShadowElement(args: ShadowGetTextInterface): Promise<void> {
+  try {
+
+
+    const executableJS = SHADOW_DOM_GET_TEXT_JS.replace("arguments[0]", `"${args.selector}"`);
+
+    await args.driver.execute(
+      SHADOW_DOM_GET_TEXT_JS,
+      args.selector
+    );
+
+
+    args.scriptDataAppender.add(async () => ({
+      nlpName: 'ExecuteJavaScript',
+      stepInputs: [executableJS],
+      elementsData: []
+    }));
+
+  } catch (error: any) {
+
+    args.scriptDataAppender.setErrorNLP("ExecuteJavaScript");
+
+    throw new Error(`Shadow Get Text action failed`, { cause: error });
+  }
+}

package/src/automation/actions/interaction/shadowDom/shadowDomUpload.ts

@@ -0,0 +1,37 @@
+import { ShadowUploadInterface } from "../../interface/shadowDomInterface.js";
+import { SHADOW_DOM_UPLOAD_JS } from "../../../../utils/javascript/jsForShadowRoot.js";
+
+export async function uploadFileShadowElement(
+  args: ShadowUploadInterface
+): Promise<void> {
+  try {
+
+    const executableJS = SHADOW_DOM_UPLOAD_JS.replace("arguments[0]", `"${args.selector}"`);
+
+    const fileInput = await args.driver.execute(
+      SHADOW_DOM_UPLOAD_JS,
+      args.selector
+    );
+
+    if (!fileInput) {
+      throw new Error("Shadow file input not found");
+    }
+
+    const remoteFilePath = await args.driver.uploadFile(args.value);
+
+    await (fileInput as any).setValue(remoteFilePath);
+
+
+    args.scriptDataAppender.add(async () => ({
+      nlpName: 'ExecuteJavaScript',
+      stepInputs: [executableJS],
+      elementsData: []
+    }));
+
+  } catch (error: any) {
+
+    args.scriptDataAppender.setErrorNLP("ExecuteJavaScript");
+
+    throw new Error(`Shadow Upload action failed`, { cause: error });
+  }
+}

package/src/automation/actions/interaction/shadowDom/shadowDomVerifyPartialText.ts

@@ -0,0 +1,29 @@
+import { ShadowVerifyPartialTextInterface } from "../../interface/shadowDomInterface.js";
+import { SHADOW_DOM_VERIFY_PARTIAL_TEXT_JS } from "../../../../utils/javascript/jsForShadowRoot.js";
+export async function verifyPartialTextShadowElement(
+  args: ShadowVerifyPartialTextInterface
+): Promise<void> {
+  try {
+
+    const executableJS = SHADOW_DOM_VERIFY_PARTIAL_TEXT_JS.replace("arguments[0]", `"${args.selector}"`).replace("arguments[1]", `"${args.value}"`);
+
+    await args.driver.execute(
+      SHADOW_DOM_VERIFY_PARTIAL_TEXT_JS,
+      args.selector,
+      args.value
+    );
+
+    args.scriptDataAppender.add(async () => ({
+      nlpName: 'ExecuteJavaScript',
+      stepInputs: [executableJS],
+      elementsData: []
+    }));
+
+
+  } catch (error: any) {
+
+    args.scriptDataAppender.setErrorNLP("ExecuteJavaScript");
+
+    throw new Error(`Shadow Verify Partial Text action failed`, { cause: error });
+  }
+}