ff-automationv2 2.2.13 → 2.2.15

package/dist/core/main/actionHandlerFactory.js

@@ -907,8 +907,14 @@ export function createActionHandlers(context) {
         MOB_PressBackKey: withExecutor(async (executor) => {
             await executor.MOB_PressBackKey();
         }),
-        WaitTillPresenceOfElement: withExecutor(async (executor, result) => {
-            await executor.WaitTillPresenceOfElement(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        MOB_PressBackSpaceKey: withExecutor(async (executor) => {
+            await executor.MOB_PressBackSpaceKey();
+        }),
+        MOB_PressSpaceKey: withExecutor(async (executor) => {
+            await executor.MOB_PressSpaceKey();
+        }),
+        WaitTillPresenceOfElement: withExecutor(async (executor, args) => {
+            await executor.WaitTillPresenceOfElement(args.pageDOM, args.selector, args.value, args.fireflinkIndex, args.elementName, args.elementType);
         }),
         WaitTillPresenceOfAllElements: withExecutor(async (executor, result) => {
             await executor.WaitTillPresenceOfAllElements(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
@@ -928,6 +934,9 @@ export function createActionHandlers(context) {
         FindElements: withExecutor(async (executor, result) => {
             await executor.FindElements(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
         }),
+        MOB_FindElement: withExecutor(async (executor, result) => {
+            await executor.MOB_FindElement(result.selector, result.elementName, result.elementType);
+        }),
         WaitTillElementIsClickable: withExecutor(async (executor, result) => {
             await executor.WaitTillElementIsClickable(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
         }),
@@ -937,6 +946,9 @@ export function createActionHandlers(context) {
         PressAnyKey: withExecutor(async (executor, result) => {
             await executor.PressAnyKey(result.value);
         }),
+        MOB_WaitTillPresenceOfElement: withExecutor(async (executor, args) => {
+            await executor.WaitTillPresenceOfElement(args.pageDOM, args.selector, args.value, args.fireflinkIndex, args.elementName, args.elementType);
+        }),
         WaitTillElementHasText: withExecutor(async (executor, result) => {
             await executor.WaitTillElementHasText(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
         }),
@@ -1108,5 +1120,53 @@ export function createActionHandlers(context) {
         MOB_SetEmulatorPowerPercentage: withExecutor(async (executor, result) => {
             await executor.MOB_SetEmulatorPowerPercentage(result.value);
         }),
+        MOB_SwipeToElement: withExecutor(async (executor, result) => {
+            await executor.swipeToElement(result.value, result.elementName, result.elementType, result.num_of_scrolls);
+        }),
+        MOB_SwipeUpToElement: withExecutor(async (executor, result) => {
+            await executor.swipeUpToElement(result.value, result.elementName, result.elementType, result.num_of_scrolls);
+        }),
+        MOB_SwipeDownToElement: withExecutor(async (executor, result) => {
+            await executor.swipeDownToElement(result.value, result.elementName, result.elementType, result.num_of_scrolls);
+        }),
+        MOB_SwipeLeftToElement: withExecutor(async (executor, result) => {
+            await executor.swipeLeftToElement(result.value, result.elementName, result.elementType, result.num_of_scrolls);
+        }),
+        MOB_SwipeRightToElement: withExecutor(async (executor, result) => {
+            await executor.swipeRightToElement(result.value, result.elementName, result.elementType, result.num_of_scrolls);
+        }),
+        MOB_SwipeNTimes: withExecutor(async (executor, result) => {
+            await executor.swipeNTimes(result.num_of_scrolls, result.direction);
+        }),
+        MOB_Builtin_Swipe: withExecutor(async (executor, result) => {
+            await executor.swipeDirectionNTimes(result.num_of_scrolls, result.direction);
+        }),
+        MOB_SwipeDirectionNTimes: withExecutor(async (executor, result) => {
+            await executor.swipeDirectionNTimes(result.num_of_scrolls, result.direction);
+        }),
+        MOB_SwipeToElementForMWeb: withExecutor(async (executor, result) => {
+            await executor.swipeToElementForMWeb(result.value, result.elementName, result.elementType);
+        }),
+        MOB_SwipeUsingReferenceElement: withExecutor(async (executor, result) => {
+            await executor.swipeUsingReferenceElement(result.value, result.elementName, result.elementType, result.num_of_scrolls, result.direction);
+        }),
+        MOB_EnterInputIntoElementFromClipBoard: withExecutor(async (executor, result) => {
+            await executor.MOB_EnterInputIntoElementFromClipBoard(result.selector, result.elementName, result.elementType);
+        }),
+        MOB_CheckIfAppIsClosed: withExecutor(async (executor) => {
+            await executor.MOB_CheckIfAppIsClosed();
+        }),
+        MOB_RunAppInBackground: withExecutor(async (executor, result) => {
+            await executor.MOB_RunAppInBackground(result.value);
+        }),
+        MOB_PinchInByPercent: withExecutor(async (executor, result) => {
+            await executor.MOB_PinchInByPercent(result.selector, result.value, result.elementName, result.elementType);
+        }),
+        MOB_PinchOutByPercent: withExecutor(async (executor, result) => {
+            await executor.MOB_PinchOutByPercent(result.selector, result.value, result.elementName, result.elementType);
+        }),
+        MOB_DoubleTapAtSpecifiedLocation: withExecutor(async (executor, result) => {
+            await executor.MOB_DoubleTapAtSpecifiedLocation(result.value, result.elementName, result.elementType);
+        }),
     };
 }

package/dist/core/main/runAutomationScript.d.ts

@@ -2,7 +2,6 @@ import { IAutomationRunner } from "../interfaces/automationRunnerInterface.js";
 import { AutomationRequest } from "../../core/interfaces/executionDetails.js";
 export declare class AutomationRunner implements IAutomationRunner {
     static sessionTerminationDetails: Record<string, boolean>;
-    private usedElementNames;
     private KafkaPayload;
     static getSessionTerminationInfo(testCaseId: string): boolean;
     static updateSessionTerminationInfo(testCaseId: string): void;

package/dist/core/main/runAutomationScript.js

@@ -19,13 +19,12 @@ import { isAlertPresent } from "../../utils/alertPopup/isAlertPresent.js";
 import { TOAST_WATCHER_JS } from "../../utils/javascript/jsForToaster.js";
 import { Find_element_by_ff_js_script } from "../../utils/javascript/jsFindElement.js";
 import { getFFIndexAndXPath } from "../../utils/helpers/xpathcreation.js";
-import { logger } from "../../utils/logger/logData.js";
+import { initLogger, logger } from "../../utils/logger/logData.js";
 import { sameActionHelper } from "../../utils/helpers/sameActionsHelper.js";
 import { error } from "node:console";
 import { annotateScreenshot } from "../../imageAnalysisMobile/annotatedScreenshotMobile.js";
 export class AutomationRunner {
     constructor() {
-        this.usedElementNames = [];
         this.KafkaPayload = {};
     }
     static getSessionTerminationInfo(testCaseId) {
@@ -49,7 +48,15 @@ export class AutomationRunner {
                             logger.info("Android session deleted successfully");
                         },
                         web: async () => {
-                            logger.info("Still browser session is active, session id :", driver.sessionId);
+                            if (request.isCloud) {
+                                if (driver?.sessionId) {
+                                    await driver.deleteSession();
+                                }
+                                logger.info("Cloud session closed");
+                            }
+                            if (driver?.sessionId) {
+                                logger.info("Still browser session is active, session id :", driver.sessionId);
+                            }
                         }
                     };
                     await (platformHandlers[platform] ?? platformHandlers.web)();
@@ -73,13 +80,14 @@ export class AutomationRunner {
         }
     }
     async run(request) {
-        this.usedElementNames = [];
+        const usedElementNames = [];
+        initLogger(request.sessionPath);
         if (request.isTerminate)
             return AutomationRunner.updateSessionTerminationInfo(request.testCaseId);
         AutomationRunner.sessionTerminationDetails[request.testCaseId] = request.isTerminate;
         const apiService = new FireFlinkApiService();
-        const fireflinkServiceInstance = new fireflinkService(apiService, request.kafkaProducerInstance);
-        const instanceDetails = await fireflinkServiceInstance.runGetInstancesDetails(request.projectId, request.token, request.serverHost);
+        const fireflinkServiceInstance = new fireflinkService(apiService);
+        const instanceDetails = await fireflinkServiceInstance.runGetInstancesDetails(request.projectId, request.token, request.serverData);
         const aiInfo = getAiInstanceInfo(instanceDetails.responseObject);
         const context = new ExecutionContext(request);
         const configProvider = new ServiceProviderBaseUrlProvider();
@@ -102,6 +110,16 @@ export class AutomationRunner {
         }
         const start_time = new Date().getTime();
         for (const step of listOfSteps) {
+            let stepResult;
+            let stepResultVision;
+            let stepAction;
+            let fireflinkIndex;
+            let selector;
+            let xpath;
+            let frameAction;
+            let iframeDomHtml = null;
+            let doc;
+            let beforeHandles = null;
             try {
                 if (AutomationRunner.getSessionTerminationInfo(request.testCaseId)) {
                     logger.info(`Execution terminated successfully. Script: ${request.scriptName}, Test Case ID: ${request.testCaseId}`);
@@ -123,13 +141,13 @@ export class AutomationRunner {
                     const baseName = elementName;
                     let newName = baseName;
                     let count = 0;
-                    while (this.usedElementNames.includes(newName)) {
+                    while (usedElementNames.includes(newName)) {
                         count++;
                         newName = `${baseName}_${count}`;
                     }
                     elementName = newName;
                     result.response.elementName = elementName;
-                    this.usedElementNames.push(elementName);
+                    usedElementNames.push(elementName);
                 }
                 if (!allKeywordAction.includes(action)) {
                     throw new Error(`Unsupported action at action or keyword exracter: ${action}`);
@@ -141,16 +159,6 @@ export class AutomationRunner {
                     stepCount++;
                     continue;
                 }
-                let stepResult;
-                let stepResultVision;
-                let stepAction;
-                let fireflinkIndex;
-                let selector;
-                let xpath;
-                let frameAction = null;
-                let iframeDomHtml = null;
-                let doc = null;
-                let beforeHandles = null;
                 if (platform == "web") {
                     driver = await context.session.getCurrentDriver();
                 }
@@ -545,26 +553,28 @@ export class AutomationRunner {
             licenseType: request.licenseType,
             licenseId: request.licenseId,
             userId: request.userId,
-            topic: request.topic,
             projectType: request.projectType,
             tokensConsumed: (await stepProcessor.getResultTokenUsage()).totalTokens,
-            errorInfo: errorInfo
+            ...(errorInfo && Object.keys(errorInfo).length > 0 && { errorInfo })
         };
         try {
             await context.scriptAppender.waitForAllSteps();
-            this.KafkaPayload.topic = request.topic;
+            // logger.info(context.scriptAppender.getData(), payload)
+            this.KafkaPayload.topic = `Topic-FIREFLINK-api-requests-${request.serverHost}`;
             this.KafkaPayload.message = {
                 ...payload,
                 scriptGenerationData: context.scriptAppender.getData(),
                 serverHost: request.serverHost
             };
+            logger.info(this.KafkaPayload);
             await fireflinkServiceInstance.produceMessageToKafka(this.KafkaPayload);
         }
         catch (error) {
-            throw new Error("Failed to send payload to FireFlink API:", { cause: error });
+            throw new Error("Failed to produce message :", { cause: error });
         }
         finally {
-            await this.cleanup(context, domInfo, extractedRelevantDom, stepProcessor, fireflinkServiceInstance, request, platform, driver);
+            await this.cleanup(context, domInfo, extractedRelevantDom, stepProcessor, fireflinkServiceInstance, request, platform, (await context.session.getCurrentDriver().catch(() => null)) ??
+                (await context.androidSession.getCurrentDriver().catch(() => null)));
         }
     }
 }

package/dist/service/fireflink.service.d.ts

@@ -1,10 +1,8 @@
 import { IFireflinkService, IFireFlinkApiService, IKafkaPayload } from "../core/interfaces/fireflinkScriptPayloadInterface.js";
-import { Producer } from "kafkajs";
 export declare class fireflinkService implements IFireflinkService {
     private apiService;
-    private kafkaProducerInstance;
     private kafkaProducer;
-    constructor(apiService: IFireFlinkApiService, kafkaProducerInstance: Producer);
-    runGetInstancesDetails(projectId: string, token: string, serverHost: string): Promise<any>;
+    constructor(apiService: IFireFlinkApiService);
+    runGetInstancesDetails(projectId: string, token: string, serverData: string): Promise<any>;
     produceMessageToKafka(kafkaArgs: IKafkaPayload): Promise<void>;
 }

package/dist/service/fireflink.service.js

@@ -1,12 +1,11 @@
 import { KafkaProducerService } from "./kafka/fireflinkKafka.service.js";
 import { logger } from "../utils/logger/logData.js";
 export class fireflinkService {
-    constructor(apiService, kafkaProducerInstance) {
+    constructor(apiService) {
         this.apiService = apiService;
-        this.kafkaProducerInstance = kafkaProducerInstance;
-        this.kafkaProducer = new KafkaProducerService(this.kafkaProducerInstance);
+        this.kafkaProducer = new KafkaProducerService();
     }
-    async runGetInstancesDetails(projectId, token, serverHost) {
+    async runGetInstancesDetails(projectId, token, serverData) {
         const headers = {
             Accept: "*/*",
             "Accept-Language": "en-US,en;q=0.9",
@@ -14,7 +13,7 @@ export class fireflinkService {
             projectId: projectId || "",
             Authorization: `Bearer ${token}`,
         };
-        const url = `${serverHost}/project/optimize/v3/ai-service-provider/selected-instance?projectId=${projectId}`;
+        const url = `${serverData}/project/optimize/v3/ai-service-provider/selected-instance?projectId=${projectId}`;
         try {
             const finalResult = await this.apiService.getInstancesDetailsApi(headers, url);
             if (finalResult) {

package/dist/service/kafka/fireflinkKafka.service.d.ts

@@ -1,7 +1,7 @@
-import { Producer } from "kafkajs";
 import { IKafkaPayload } from "../../core/interfaces/fireflinkScriptPayloadInterface.js";
 export declare class KafkaProducerService {
+    private kafka;
     private kafkaProducer;
-    constructor(kafkaProducer: Producer | any);
+    constructor();
     produceMessage(kafkaArgs: IKafkaPayload): Promise<void>;
 }

package/dist/service/kafka/fireflinkKafka.service.js

@@ -1,7 +1,21 @@
+import { Kafka } from "kafkajs";
 import { logger } from "../../utils/logger/logData.js";
+import fs from "fs";
+import dotenv from "dotenv";
+dotenv.config();
 export class KafkaProducerService {
-    constructor(kafkaProducer) {
-        this.kafkaProducer = kafkaProducer;
+    constructor() {
+        this.kafka = new Kafka({
+            clientId: process.env.KAFKA_CLIENT_ID,
+            brokers: process.env.KAFKA_BROKERS.split(","),
+            ssl: {
+                ca: [fs.readFileSync(process.env.KAFKA_SSL_CA, "utf-8")],
+                key: fs.readFileSync(process.env.KAFKA_SSL_KEY, "utf-8"),
+                cert: fs.readFileSync(process.env.KAFKA_SSL_CERT, "utf-8"),
+                rejectUnauthorized: true,
+            },
+        });
+        this.kafkaProducer = this.kafka.producer();
     }
     async produceMessage(kafkaArgs) {
         try {
@@ -12,7 +26,7 @@ export class KafkaProducerService {
                 messages: [{ value: JSON.stringify(kafkaArgs.message) }],
             });
             await this.kafkaProducer.disconnect();
-            logger.info("Kafka produced message successfully and Kafka produced disconnected successfully");
+            logger.info("Kafka produced message successfully and Kafka producer disconnected successfully");
         }
         catch (error) {
             await this.kafkaProducer.disconnect();

package/dist/utils/logger/logData.d.ts

@@ -1,3 +1,4 @@
+export declare function initLogger(basePath: string): void;
 export declare const logger: {
     info: (...args: any[]) => Promise<void>;
     error: (...args: any[]) => Promise<void>;

package/dist/utils/logger/logData.js

@@ -1,37 +1,53 @@
 import fs from "fs/promises";
 import path from "path";
 import beautify from "js-beautify";
-const logsDir = path.resolve(process.cwd(), "logs");
-const domDir = path.resolve(process.cwd(), "dom");
-const screenshotsDir = path.resolve(process.cwd(), "screenshots");
-const now = new Date();
-const istDate = new Intl.DateTimeFormat("sv-SE", {
-    timeZone: "Asia/Kolkata",
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit",
-    hour: "2-digit",
-    minute: "2-digit",
-    second: "2-digit",
-    fractionalSecondDigits: 3,
-    hour12: false,
-})
-    .format(now)
-    .replace(" ", "T");
-const logFilePath = path.join(logsDir, "ai-execution-logs.txt");
+let sessionPath;
+let logsDir;
+let domDir;
+let screenshotsDir;
+let logFilePath;
+export function initLogger(basePath) {
+    sessionPath = basePath;
+    logsDir = path.resolve(sessionPath, "logs");
+    domDir = path.resolve(sessionPath, "dom");
+    screenshotsDir = path.resolve(sessionPath, "screenshots");
+    logFilePath = path.join(logsDir, "ai-execution-logs.txt");
+}
 async function ensureDirs() {
+    if (!logsDir)
+        throw new Error("Logger not initialized");
     await fs.mkdir(logsDir, { recursive: true });
     await fs.mkdir(domDir, { recursive: true });
     await fs.mkdir(screenshotsDir, { recursive: true });
 }
-ensureDirs();
+function getISTDate() {
+    return new Intl.DateTimeFormat("sv-SE", {
+        timeZone: "Asia/Kolkata",
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        fractionalSecondDigits: 3,
+        hour12: false,
+    })
+        .format(new Date())
+        .replace(" ", "T");
+}
 export const logger = {
     info: async (...args) => {
+        if (!logFilePath)
+            throw new Error("Logger not initialized");
+        await ensureDirs();
         const formattedArgs = args.map((arg) => typeof arg === "object" ? JSON.stringify(arg, null, 2) : arg);
-        const message = `[INFO] ${istDate}+05:30 - ${formattedArgs.join(" ")}\n`;
+        const message = `[INFO] ${getISTDate()}+05:30 - ${formattedArgs.join(" ")}\n`;
         await fs.appendFile(logFilePath, message, "utf-8");
     },
     error: async (...args) => {
+        if (!logFilePath)
+            throw new Error("Logger not initialized");
+        await ensureDirs();
         const formatted = args.map((arg) => {
             if (arg instanceof Error) {
                 let output = arg.stack || `${arg.name}: ${arg.message}`;
@@ -71,6 +87,9 @@ export const logger = {
         return formatted.join(" ");
     },
     saveDOM: async (domContent, fileName) => {
+        if (!domDir)
+            throw new Error("Logger not initialized");
+        await ensureDirs();
         const timestamp = new Date().toLocaleString().replace(/[:.]/g, "-");
         let finalFileName;
         let formattedContent;
@@ -90,17 +109,25 @@ export const logger = {
         await fs.writeFile(filePath, formattedContent, "utf-8");
     },
     saveJSON: async (data, fileName) => {
+        if (!domDir)
+            throw new Error("Logger not initialized");
+        await ensureDirs();
         const timestamp = new Date().toLocaleString().replace(/[:.]/g, "-");
-        const finalFileName = fileName ? `${fileName}.json` : `data-${timestamp}.json`;
+        const finalFileName = fileName
+            ? `${fileName}.json`
+            : `data-${timestamp}.json`;
         const filePath = path.join(domDir, finalFileName);
         const safeData = JSON.stringify(data, (key, value) => {
             if (key === "element")
-                return undefined; // remove DOM node
+                return undefined;
             return value;
         }, 2);
         await fs.writeFile(filePath, safeData, "utf-8");
     },
     saveImage: async (imageBuffer, fileName) => {
+        if (!screenshotsDir)
+            throw new Error("Logger not initialized");
+        await ensureDirs();
         const filePath = path.join(screenshotsDir, fileName);
         await fs.writeFile(filePath, imageBuffer);
     },

package/dist/utils/swipe/domSearchHelper.d.ts

@@ -0,0 +1,5 @@
+export declare function findElementInDom(driver: WebdriverIO.Browser, text: string): Promise<{
+    element: import("webdriverio").ChainablePromiseElement;
+    xpath: string;
+    annotatedDom: string;
+} | null>;

package/dist/utils/swipe/domSearchHelper.js

@@ -0,0 +1,42 @@
+import { getAnnotatedDOMForMobile } from "../DomExtraction/jsForAttributeInjection.js";
+import { DomSimplifier } from "../../domAnalysis/simplifyAndFlatten.js";
+import { getFFIndexAndXPath } from "../helpers/xpathcreation.js";
+export async function findElementInDom(driver, text) {
+    const simplifier = new DomSimplifier();
+    const keywords = text
+        .toLowerCase()
+        .split(/\s+/)
+        .filter(Boolean);
+    const { dom: annotatedDom } = await getAnnotatedDOMForMobile(driver);
+    const { flatNodes } = simplifier.simplifyMobile(annotatedDom);
+    const sequenceMatch = (value, words) => {
+        const v = value.toLowerCase();
+        const pattern = new RegExp("\\b" + words.join("\\s*") + "\\b", "i");
+        return pattern.test(v);
+    };
+    for (const nodeObj of flatNodes) {
+        const node = nodeObj.node;
+        const textVal = (node["text"] || "").toLowerCase();
+        const descVal = (node["content-desc"] || "").toLowerCase();
+        const ridVal = (node["resource-id"] || "").toLowerCase();
+        if (sequenceMatch(textVal, keywords) ||
+            sequenceMatch(descVal, keywords) ||
+            sequenceMatch(ridVal, keywords)) {
+            const ffIndex = node["FF-inspecter"];
+            if (!ffIndex)
+                continue;
+            const xpath = getFFIndexAndXPath(annotatedDom, ffIndex);
+            if (!xpath)
+                continue;
+            const element = await driver.$(xpath.xpathPath);
+            if (await element.isExisting()) {
+                return {
+                    element,
+                    xpath: xpath.xpathPath,
+                    annotatedDom
+                };
+            }
+        }
+    }
+    return null;
+}

package/dist/utils/swipe/swipeMovement.d.ts

@@ -0,0 +1 @@
+export declare function executeSwipeMovement(driver: WebdriverIO.Browser, direction: string): Promise<void>;

package/dist/utils/swipe/swipeMovement.js

@@ -0,0 +1,81 @@
+export async function executeSwipeMovement(driver, direction) {
+    if (direction === 'left' || direction === 'right') {
+        const horizontalContainers = [
+            '//android.widget.HorizontalScrollView',
+            '//androidx.recyclerview.widget.RecyclerView'
+        ];
+        let hsv = null;
+        for (const selector of horizontalContainers) {
+            const el = await driver.$(selector);
+            if (await el.isExisting()) {
+                hsv = el;
+                break;
+            }
+        }
+        if (hsv && typeof hsv.getRect === "function") {
+            const rect = await hsv.getRect();
+            const y = rect.y + Math.floor(rect.height / 2);
+            let startX, endX;
+            if (direction === 'left') {
+                startX = rect.x + Math.floor(rect.width * 0.8);
+                endX = rect.x + Math.floor(rect.width * 0.2);
+            }
+            else {
+                startX = rect.x + Math.floor(rect.width * 0.2);
+                endX = rect.x + Math.floor(rect.width * 0.8);
+            }
+            await performW3CSwipe(driver, startX, y, endX, y);
+            return;
+        }
+    }
+    const size = await driver.getWindowSize();
+    const midX = size.width / 2;
+    let startX, startY, endX, endY;
+    if (direction === 'up') {
+        startX = midX;
+        startY = size.height * 0.6;
+        endX = midX;
+        endY = size.height * 0.1;
+    }
+    else if (direction === 'down') {
+        startX = midX;
+        startY = size.height * 0.4;
+        endX = midX;
+        endY = size.height * 0.8;
+    }
+    else if (direction === 'left') {
+        startX = size.width * 0.8;
+        startY = size.height * 0.5;
+        endX = size.width * 0.2;
+        endY = size.height * 0.5;
+    }
+    else if (direction === 'right') {
+        startX = size.width * 0.2;
+        startY = size.height * 0.5;
+        endX = size.width * 0.8;
+        endY = size.height * 0.5;
+    }
+    else {
+        startX = midX;
+        startY = size.height * 0.8;
+        endX = midX;
+        endY = size.height * 0.2;
+    }
+    await performW3CSwipe(driver, startX, startY, endX, endY);
+}
+async function performW3CSwipe(driver, startX, startY, endX, endY) {
+    await driver.performActions([
+        {
+            type: 'pointer',
+            id: 'finger1',
+            parameters: { pointerType: 'touch' },
+            actions: [
+                { type: 'pointerMove', duration: 0, x: Math.floor(startX), y: Math.floor(startY) },
+                { type: 'pointerDown', button: 0 },
+                { type: 'pointerMove', duration: 800, x: Math.floor(endX), y: Math.floor(endY) },
+                { type: 'pointerUp', button: 0 }
+            ]
+        }
+    ]);
+    await driver.pause(1000);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ff-automationv2",
-  "version": "2.2.13",
+  "version": "2.2.15",
   "private": false,
   "type": "module",
   "description": "This lib is used to automate the manual testcase",
@@ -23,7 +23,6 @@
     "prepare": "husky",
     "lint": "eslint src --max-warnings=0",
     "test": "npm run build && node dist/tests/test12.js",
-    "test1": "npm run build && node dist/tests/test.js",
     "llm": "npm run build && node dist/tests/testllm.js",
     "dev": "npm run build && node dist/index.js",
     "start": "node dist/index.js",
@@ -50,8 +49,8 @@
     "nodemon": "3.1.11",
     "ts-node": "10.9.2",
     "typescript": "^5.9.3",
-    "typescript-eslint": "8.56.0",
-    "webdriverio": "9.26.1"
+    "webdriverio": "9.26.1",
+    "typescript-eslint": "8.56.0"
   },
   "dependencies": {
     "@xmldom/xmldom": "^0.8.11",