ff-automationv2 2.2.36-beta.0 → 2.2.36-beta.2

package/dist/automation/actions/interface/verifyActionInterface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/automation/actions/interface/waitActionInterface.d.ts

@@ -0,0 +1,151 @@
+import { ScriptDataAppender } from "../../../fireflinkData/fireflinkScript/scriptGenrationData.js";
+import { ElementGetter } from "../../../fireflinkData/fireflinkLocators/getListOfLocators.js";
+export interface waitInterface {
+    driver: WebdriverIO.Browser;
+    scriptDataAppender: ScriptDataAppender;
+    time: string;
+}
+export interface MOB_WaitTillAllElementsAreInvisibleInterface {
+    driver: WebdriverIO.Browser;
+    scriptDataAppender: ScriptDataAppender;
+    platform: string;
+}
+export interface MOB_WaitTillElementIsSelectedInterface {
+    driver: WebdriverIO.Browser;
+    selector: string;
+    scriptDataAppender: ScriptDataAppender;
+    elementName: string;
+    elementType: string;
+    platform: string;
+    pageDOM: any;
+    fireflinkIndex: string;
+    elementGetter: ElementGetter;
+}
+export interface MOB_WaitTillElementIsEnabledInterface {
+    driver: WebdriverIO.Browser;
+    selector: string;
+    scriptDataAppender: ScriptDataAppender;
+    elementName: string;
+    elementType: string;
+    platform: string;
+    pageDOM: any;
+    fireflinkIndex: string;
+    elementGetter: ElementGetter;
+}
+export interface MOB_WaitTillElementIsVisibleInterface {
+    driver: WebdriverIO.Browser;
+    selector: string;
+    scriptDataAppender: ScriptDataAppender;
+    elementName: string;
+    elementType: string;
+    platform: string;
+    pageDOM: any;
+    fireflinkIndex: string;
+    elementGetter: ElementGetter;
+}
+export interface MOB_WaitTillStalenessOfElementInterface {
+    driver: WebdriverIO.Browser;
+    selector: string;
+    scriptDataAppender: ScriptDataAppender;
+    elementName: string;
+    elementType: string;
+    platform: string;
+    pageDOM: any;
+    fireflinkIndex: string;
+    elementGetter: ElementGetter;
+}
+export interface MOB_WaitTillElementIsInvisibleInterface {
+    driver: WebdriverIO.Browser;
+    selector: string;
+    scriptDataAppender: ScriptDataAppender;
+    elementName: string;
+    elementType: string;
+    platform: string;
+    pageDOM: any;
+    fireflinkIndex: string;
+    elementGetter: ElementGetter;
+}
+export interface MOB_WaitTillAttributeOfElementContainsStringInterface {
+    driver: WebdriverIO.Browser;
+    selector: string;
+    scriptDataAppender: ScriptDataAppender;
+    attributeName: string;
+    value: string;
+    elementName: string;
+    elementType: string;
+    platform: string;
+    pageDOM: any;
+    fireflinkIndex: string;
+    elementGetter: ElementGetter;
+}
+export interface waitTillPresenceOfElementInterface {
+    driver: WebdriverIO.Browser;
+    selector: string;
+    value: string;
+    elementName: string;
+    elementType: string;
+    platform: string;
+    pageDOM: any;
+    fireflinkIndex: string;
+    elementGetter: ElementGetter;
+    scriptDataAppender: ScriptDataAppender;
+}
+export interface WaitTillPresenceOfAllElementsInterface {
+    driver: WebdriverIO.Browser;
+    selector: string;
+    value: string;
+    elementName: string;
+    elementType: string;
+    platform: string;
+    pageDOM: any;
+    fireflinkIndex: string;
+    elementGetter: ElementGetter;
+    scriptDataAppender: ScriptDataAppender;
+}
+export interface waitTillAttributeOfElementIsStringInterface {
+    driver: WebdriverIO.Browser;
+    selector: string;
+    value: string;
+    elementName: string;
+    elementType: string;
+    platform: string;
+    pageDOM: any;
+    fireflinkIndex: string;
+    elementGetter: ElementGetter;
+    scriptDataAppender: ScriptDataAppender;
+}
+export interface waitTillElementIsClickableInterface {
+    driver: WebdriverIO.Browser;
+    selector: string;
+    elementName: string;
+    elementType: string;
+    platform: string;
+    pageDOM: any;
+    fireflinkIndex: string;
+    elementGetter: ElementGetter;
+    scriptDataAppender: ScriptDataAppender;
+}
+export interface waitTillElementHasTextInterface {
+    driver: WebdriverIO.Browser;
+    selector: string;
+    value: string;
+    elementName: string;
+    elementType: string;
+    platform: string;
+    pageDOM: any;
+    fireflinkIndex: string;
+    elementGetter: ElementGetter;
+    scriptDataAppender: ScriptDataAppender;
+}
+export interface waitTillElementContainsTextInterface {
+    driver: WebdriverIO.Browser;
+    selector: string;
+    value: string;
+    elementName: string;
+    elementType: string;
+    platform: string;
+    pageDOM: any;
+    fireflinkIndex: string;
+    elementGetter: ElementGetter;
+    scriptDataAppender: ScriptDataAppender;
+}

package/dist/automation/actions/interface/waitActionInterface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/automation/browserSession/initiateBrowserSession.d.ts

@@ -0,0 +1,14 @@
+import { BrowserId } from "../../core/types/browserType.js";
+import { CloudConfig } from "../../core/interfaces/cloudConfigInterface.js";
+export declare class BrowserSession {
+    private driver;
+    private browserName;
+    private pageLoad;
+    private cloudSessionInstances;
+    private isCloud;
+    constructor(browserName: BrowserId, isCloud: boolean | undefined, capabilities: Record<string, any> | undefined, pageLoad: number, CloudConfig: CloudConfig | undefined);
+    private openBrowser;
+    open(path?: string, profile?: string, customCaps?: string[]): Promise<void>;
+    close(): Promise<void>;
+    getCurrentDriver(): Promise<WebdriverIO.Browser>;
+}

package/dist/automation/browserSession/initiateBrowserSession.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserSession = void 0;
+const webdriverio_1 = require("webdriverio");
+const capability_js_1 = require("../../utils/browserCap/capability.js");
+const initiateCloudSession_js_1 = require("../cloudSession/initiateCloudSession.js");
+class BrowserSession {
+    constructor(browserName, isCloud, capabilities, pageLoad, CloudConfig) {
+        this.driver = null;
+        this.browserName = browserName;
+        this.pageLoad = pageLoad;
+        this.isCloud = isCloud;
+        this.cloudSessionInstances = new initiateCloudSession_js_1.CloudSession(capabilities, CloudConfig);
+    }
+    async openBrowser(path, profile, customCaps) {
+        try {
+            const driver = await (0, webdriverio_1.remote)({
+                capabilities: (0, capability_js_1.getCapabilities)(this.browserName, path, profile, customCaps),
+                logLevel: "silent"
+            });
+            driver.setTimeout({ 'pageLoad': this.pageLoad });
+            await driver.waitUntil(async () => {
+                const state = await driver.execute(() => document.readyState);
+                return state === "complete";
+            });
+            return driver;
+        }
+        catch (error) {
+            throw new Error("Browser failed to open", { cause: error });
+        }
+    }
+    async open(path, profile, customCaps) {
+        this.driver = this.isCloud
+            ? await this.cloudSessionInstances.initialize()
+            : await this.openBrowser(path, profile, customCaps);
+    }
+    async close() {
+        try {
+            if (this.driver) {
+                await this.driver.deleteSession();
+                this.driver = null;
+            }
+            else {
+                throw new Error("Browser not initialized");
+            }
+        }
+        catch (error) {
+            throw new Error("Browser failed to close", { cause: error });
+        }
+    }
+    async getCurrentDriver() {
+        if (!this.driver) {
+            throw new Error("Browser is not initialized");
+        }
+        return this.driver;
+    }
+}
+exports.BrowserSession = BrowserSession;

package/dist/automation/cloudSession/initiateCloudSession.d.ts

@@ -0,0 +1,9 @@
+import { CloudConfig } from "../../core/interfaces/cloudConfigInterface.js";
+export declare class CloudSession {
+    private driver;
+    private capabilities;
+    private cloudConfig;
+    constructor(capabilities?: Record<string, any>, cloudConfig?: CloudConfig);
+    private createDriver;
+    initialize(): Promise<WebdriverIO.Browser>;
+}

package/dist/automation/cloudSession/initiateCloudSession.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudSession = void 0;
+const webdriverio_1 = require("webdriverio");
+const cloudServerPortType_js_1 = require("../../core/types/cloudServerPortType.js");
+const cloudPath_js_1 = require("../../utils/cloudConfig/cloudPath.js");
+class CloudSession {
+    constructor(capabilities, cloudConfig) {
+        this.driver = null;
+        this.capabilities = {
+            "wdio:enforceWebDriverClassic": true,
+            "devicefarm:networkLogEnable": false,
+            "fireflink:deviceType": "public",
+            ...(capabilities ?? {})
+        };
+        this.cloudConfig = cloudConfig ?? {};
+    }
+    async createDriver() {
+        try {
+            return await (0, webdriverio_1.remote)({
+                protocol: this.cloudConfig.protocol,
+                hostname: this.cloudConfig.hostname,
+                port: cloudServerPortType_js_1.CloudPort[this.cloudConfig.protocol ?? "https"],
+                path: (0, cloudPath_js_1.getPath)(this.cloudConfig),
+                capabilities: this.capabilities,
+                logLevel: "debug",
+                connectionRetryTimeout: 120000,
+                connectionRetryCount: 0
+            });
+        }
+        catch (error) {
+            throw new Error("Browser failed to open", { cause: error });
+        }
+    }
+    async initialize() {
+        this.driver = this.driver ?? await this.createDriver();
+        return this.driver;
+    }
+}
+exports.CloudSession = CloudSession;

package/dist/automation/driverState.d.ts

@@ -0,0 +1,2 @@
+import { IScriptGenerationData } from "../core/interfaces/scriptGenrationDataInterface.js";
+export declare const UserSessionAutomationTestCase: Record<string, IScriptGenerationData[]>;

package/dist/automation/driverState.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserSessionAutomationTestCase = void 0;
+exports.UserSessionAutomationTestCase = {};

package/dist/automation/mobileSession/initiateMobileSession.d.ts

@@ -0,0 +1,58 @@
+import { CloudConfig } from "../../core/interfaces/cloudConfigInterface.js";
+export interface IAndroidCapabilities {
+    platformName: "Android";
+    "appium:platformVersion": string;
+    "appium:deviceName": string;
+    "appium:udid": string;
+    "appium:automationName": "UiAutomator2";
+    "appium:ignoreHiddenApiPolicyError": boolean;
+    "appium:shouldUseCompactResponses": boolean;
+    "appium:ignoreUnimportantViews": boolean;
+    "appium:disableAndroidWatcher": boolean;
+    "appium:disableWindowAnimation": boolean;
+    "appium:uiautomator2ServerLaunchTimeout": number;
+    "appium:uiautomator2ServerReadTimeout": number;
+    "appium:waitForIdleTimeout": number;
+    "appium:waitForIdlePollingInterval": number;
+    "appium:waitForSelectorTimeout": number;
+    [key: string]: any;
+}
+export interface IIOSCapabilities {
+    platformName: "iOS";
+    "appium:platformVersion": string;
+    "appium:deviceName": string;
+    "appium:udid": string;
+    "appium:automationName": "XCUITest";
+    "appium:bundleId"?: string;
+    "appium:shouldUseCompactResponses"?: boolean;
+    "appium:waitForQuiescence"?: boolean;
+    "appium:wdaLaunchTimeout"?: number;
+    "appium:wdaConnectionTimeout"?: number;
+    "appium:agentPath"?: string;
+    "appium:bootstrapPath"?: string;
+    "appium:noReset"?: boolean;
+    "appium:showXcodeLog"?: boolean;
+    "appium:useNewWDA"?: boolean;
+    "appium:unicodeKeyboard"?: boolean;
+    "appium:resetKeyboard"?: boolean;
+    "appium:ignoreUnimportantViews"?: boolean;
+    "appium:disableWindowAnimation"?: boolean;
+    'appium:newCommandTimeout'?: number;
+    [key: string]: any;
+}
+export type IMobileCapabilities = IAndroidCapabilities | IIOSCapabilities;
+export declare class MobileSession {
+    private driver;
+    private appiumPort;
+    private currentAppPackage;
+    private deviceId;
+    private cloudSessionInstances;
+    private isCloud;
+    private adbPath;
+    constructor(appiumPort: number, isCloud: boolean | undefined, capabilities: Record<string, string | boolean> | undefined, CloudConfig: CloudConfig | undefined, adbPath: string | undefined);
+    private openApp;
+    createDriver(capabilities: IMobileCapabilities): Promise<void>;
+    launchApp(appPackage?: string, appActivity?: string): Promise<void>;
+    close(): Promise<void>;
+    getCurrentDriver(): Promise<WebdriverIO.Browser>;
+}

package/dist/automation/mobileSession/initiateMobileSession.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MobileSession = void 0;
+const webdriverio_1 = require("webdriverio");
+const child_process_1 = require("child_process");
+const initiateCloudSession_js_1 = require("../cloudSession/initiateCloudSession.js");
+class MobileSession {
+    constructor(appiumPort, isCloud, capabilities, CloudConfig, adbPath) {
+        this.driver = null;
+        this.currentAppPackage = "";
+        this.deviceId = "";
+        this.appiumPort = appiumPort;
+        this.isCloud = isCloud;
+        this.cloudSessionInstances = new initiateCloudSession_js_1.CloudSession(capabilities, CloudConfig);
+        this.adbPath = adbPath;
+    }
+    async openApp(arg) {
+        try {
+            const driver = await (0, webdriverio_1.remote)({
+                hostname: "localhost",
+                port: this.appiumPort,
+                path: "/wd/hub",
+                logLevel: "silent",
+                capabilities: arg.capabilities
+            });
+            return driver;
+        }
+        catch (error) {
+            const platform = arg.capabilities.platformName;
+            throw new Error(`${platform} App failed to open`, { cause: error });
+        }
+    }
+    async createDriver(capabilities) {
+        if (this.isCloud) {
+            this.driver = await this.cloudSessionInstances.initialize();
+            return;
+        }
+        this.deviceId = capabilities["appium:udid"];
+        try {
+            const response = await fetch(`http://127.0.0.1:${this.appiumPort}/wd/hub/status`);
+            if (response.status !== 200) {
+                throw new Error("Appium server is not running.");
+            }
+        }
+        catch (error) {
+            throw new Error("Appium server is not running or unreachable.", { cause: error });
+        }
+        this.driver = await this.openApp({ capabilities });
+    }
+    async launchApp(appPackage, appActivity) {
+        const driver = await this.getCurrentDriver();
+        this.currentAppPackage = appPackage || await driver.getCurrentPackage();
+        if (this.isCloud || driver.isIOS) {
+            await driver.activateApp(appPackage);
+            return;
+        }
+        try {
+            // let output: string = execSync(
+            //     `${this.adbPath} -s ${this.deviceId} shell pm clear ${appPackage} 2>&1`
+            // ).toString();
+            if (appActivity) {
+                const output = (0, child_process_1.execSync)(`${this.adbPath} -s ${this.deviceId} shell am start -n ${appPackage}/${appActivity} 2>&1`).toString();
+                if (output.toLowerCase().includes("device") && output.toLowerCase().includes("not found")) {
+                    throw new Error(`Device '${this.deviceId}' not found or offline.`);
+                }
+                if (output.includes("Error type 3") || output.includes("does not exist") || output.includes("Failed")) {
+                    throw new Error(`App not found or invalid activity: ${appPackage}/${appActivity} is not installed on the device`);
+                }
+            }
+            else {
+                if (appPackage) {
+                    await driver.activateApp(this.currentAppPackage);
+                }
+            }
+        }
+        catch (error) {
+            throw new Error(`App launch failed: ${error.message}`, { cause: error });
+        }
+    }
+    // async open(arg: { capabilities: IMobileCapabilities, keywords: string[] }): Promise<void> {
+    //     if (this.isCloud) {
+    //         this.driver = await this.cloudSessionInstances.initialize();
+    //         return;
+    //     }
+    //     const appPackage = arg.keywords[0];
+    //     const appActivity = arg.keywords?.[1];
+    //     this.currentAppPackage = appPackage;
+    //     try {
+    //         const response = await fetch(`http://127.0.0.1:${this.appiumPort}/wd/hub/status`);
+    //         if (response.status !== 200) {
+    //             throw new Error("Appium server is not running.");
+    //         }
+    //     } catch (error: any) {
+    //         throw new Error(
+    //             "Appium server is not running or unreachable.",
+    //             { cause: error }
+    //         );
+    //     }
+    //     try {
+    //         if (arg.capabilities.platformName === "Android") {
+    //             await execSync(
+    //                 `${this.adbPath} -s ${arg.capabilities["appium:udid"]} shell pm clear ${appPackage}`
+    //             ).toString();
+    //             await execSync(
+    //                 `${this.adbPath} -s ${arg.capabilities["appium:udid"]} shell am start -n ${appPackage}/${appActivity}`
+    //             ).toString();
+    //         }
+    //     } catch (error: any) {
+    //         const output = error.stderr?.toString() || error.message || "";
+    //         if (output.toLowerCase().includes("device") && output.toLowerCase().includes("not found")) {
+    //             throw new Error(
+    //                 `Device '${arg.capabilities["appium:udid"]}' not found or offline.`,
+    //                 { cause: error }
+    //             );
+    //         }
+    //         if (output.includes("Error type 3") || output.includes("does not exist") || output.includes("Failed")) {
+    //             throw new Error(
+    //                 `App not found or invalid activity: ${appPackage}/${appActivity} is not installed on the device`,
+    //                 { cause: error }
+    //             );
+    //         }
+    //         throw new Error(
+    //             `ADB execution failed: ${output}`,
+    //             { cause: error }
+    //         );
+    //     }
+    //     const startTime = Date.now();
+    //     this.driver = await this.openApp({ capabilities: arg.capabilities });
+    //     logger.info(`Application launched in ${Date.now() - startTime} ms`);
+    // }
+    async close() {
+        if (this.driver) {
+            if (this.isCloud) {
+                const appPackage = await this.driver.getCurrentPackage();
+                await this.driver.terminateApp(appPackage);
+                // this.driver = null;
+            }
+            else {
+                const appPackage = this.currentAppPackage;
+                await this.driver.terminateApp(appPackage);
+                // this.driver = null;
+            }
+        }
+        else {
+            throw new Error("Driver is not initialized");
+        }
+    }
+    async getCurrentDriver() {
+        if (!this.driver) {
+            throw new Error("Browser is not initialized");
+        }
+        return this.driver;
+    }
+}
+exports.MobileSession = MobileSession;

package/dist/core/Errors/InvalidFileTypeError.d.ts

@@ -0,0 +1,5 @@
+export declare class InvalidFileTypeError extends Error {
+    error: string;
+    errorDescription: string;
+    constructor(fileType: string);
+}

package/dist/core/Errors/InvalidFileTypeError.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidFileTypeError = void 0;
+class InvalidFileTypeError extends Error {
+    constructor(fileType) {
+        const description = `File verification for "${fileType}" files is currently not supported. ` +
+            `At the moment, only PDF files are supported. Please upload a PDF file and try again.`;
+        super(description);
+        this.name = "InvalidFileTypeError";
+        this.error = "Invalid File Type";
+        this.errorDescription = description;
+    }
+}
+exports.InvalidFileTypeError = InvalidFileTypeError;

package/dist/core/constants/allAction.d.ts

@@ -0,0 +1 @@
+export declare const allKeywordAction: string[];

package/dist/core/constants/allAction.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allKeywordAction = void 0;
+exports.allKeywordAction = [
+    "enter",
+    "wait",
+    "verify",
+    "scroll",
+    "navigate",
+    "navigateBack",
+    "click",
+    "maximize",
+    "minimize",
+    "get",
+    "upload",
+    "close",
+    "open",
+    "openApp",
+    "drag_and_drop",
+    "closeApp",
+    "switch",
+    "swipe",
+    "cleartext",
+    "tap",
+    "combined",
+    "mouseAction",
+    "switchToAndroid",
+    "switchToWeb",
+    "getOtp",
+    "enterOtp",
+    "arithmetic"
+];

package/dist/core/constants/defaultValues.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_PAGE_LOAD = 10000;

package/dist/core/constants/defaultValues.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PAGE_LOAD = void 0;
+exports.DEFAULT_PAGE_LOAD = 10000;

package/dist/core/constants/supportedActions.d.ts

@@ -0,0 +1,3 @@
+export declare const INPUTLESS_ACTIONS: string[];
+export declare const SKIPPED_ACTIONS: string[];
+export declare const ELEMENTLESS_ACTION: string[];