chore: remove unnecessary interfaces wrapping regular selenium types

Author: juliandescottes

src/firefox/core.ts

@@ -2,83 +2,14 @@
  * Core WebDriver + BiDi connection management
  */
 
-import { Builder, Browser, Capabilities } from 'selenium-webdriver';
+import { Builder, Browser, Capabilities, WebDriver } from 'selenium-webdriver';
 import firefox from 'selenium-webdriver/firefox.js';
 import { mkdirSync, openSync, closeSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import type { FirefoxLaunchOptions } from './types.js';
 import { log, logDebug } from '../utils/logger.js';
 
-// ---------------------------------------------------------------------------
-// Shared driver interface — the minimal surface used by all consumers
-// (DomInteractions, PageManagement, SnapshotManager, UidResolver).
-// ---------------------------------------------------------------------------
-
-export interface IElement {
-  click(): Promise<void>;
-  clear(): Promise<void>;
-  sendKeys(...args: Array<string | number>): Promise<void>;
-  isDisplayed(): Promise<boolean>;
-  takeScreenshot(): Promise<string>;
-}
-
-export interface IBiDiSocket {
-  readyState: number;
-  on(event: string, listener: (data: unknown) => void): void;
-  off(event: string, listener: (data: unknown) => void): void;
-  send(data: string): void;
-}
-
-export interface IBiDi {
-  socket: IBiDiSocket;
-  subscribe?: (event: string, contexts?: string[]) => Promise<void>;
-}
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-export interface IDriver {
-  getTitle(): Promise<string>;
-  getCurrentUrl(): Promise<string>;
-  getWindowHandle(): Promise<string>;
-  getAllWindowHandles(): Promise<string[]>;
-  get(url: string): Promise<void>;
-  getPageSource(): Promise<string>;
-  executeScript<T>(script: string | ((...a: any[]) => any), ...args: unknown[]): Promise<T>;
-  executeAsyncScript<T>(script: string | ((...a: any[]) => any), ...args: unknown[]): Promise<T>;
-  takeScreenshot(): Promise<string>;
-  close(): Promise<void>;
-  findElement(locator: any): Promise<IElement>;
-  switchTo(): {
-    window(handle: string): Promise<void>;
-    newWindow(type: string): Promise<{ handle: string }>;
-    alert(): Promise<{
-      accept(): Promise<void>;
-      dismiss(): Promise<void>;
-      getText(): Promise<string>;
-      sendKeys(text: string): Promise<void>;
-    }>;
-  };
-  navigate(): {
-    back(): Promise<void>;
-    forward(): Promise<void>;
-    refresh(): Promise<void>;
-  };
-  manage(): {
-    window(): {
-      setRect(rect: { width: number; height: number }): Promise<void>;
-    };
-  };
-  actions(opts?: { async?: boolean }): {
-    move(opts: { x?: number; y?: number; origin?: unknown }): any;
-    click(): any;
-    doubleClick(el?: unknown): any;
-    perform(): Promise<void>;
-    clear(): Promise<void>;
-  };
-  getBidi(): Promise<IBiDi>;
-}
-/* eslint-enable @typescript-eslint/no-explicit-any */
-
 // ---------------------------------------------------------------------------
 // Geckodriver binary finder — used only for --connect-existing mode
 // ---------------------------------------------------------------------------
@@ -135,7 +66,7 @@ async function findGeckodriver(): Promise<string> {
 }
 
 export class FirefoxCore {
-  private driver: IDriver | null = null;
+  private driver: WebDriver | null = null;
   private currentContextId: string | null = null;
   private originalEnv: Record<string, string | undefined> = {};
   private logFilePath: string | undefined;
@@ -177,8 +108,7 @@ export class FirefoxCore {
       // createSession() returns synchronously; the session is established async under the hood.
       // Passing geckodriverPath to ServiceBuilder prevents getBinaryPaths() from running,
       // which would otherwise invoke selenium-manager with --browser firefox.
-      const seleniumDriver = firefox.Driver.createSession(caps, serviceBuilder.build());
-      this.driver = seleniumDriver as unknown as IDriver;
+      this.driver = firefox.Driver.createSession(caps, serviceBuilder.build());
     } else {
       // Set up output file for capturing Firefox stdout/stderr
       if (this.options.logFile) {
@@ -255,12 +185,11 @@ export class FirefoxCore {
         log(`📝 Capturing Firefox output to: ${this.logFilePath}`);
       }
 
-      // selenium WebDriver satisfies IDriver structurally at runtime
-      this.driver = (await new Builder()
+      this.driver = await new Builder()
         .forBrowser(Browser.FIREFOX)
         .setFirefoxOptions(firefoxOptions)
         .setFirefoxService(serviceBuilder)
-        .build()) as unknown as IDriver;
+        .build();
     }
 
     log(
@@ -285,7 +214,7 @@ export class FirefoxCore {
   /**
    * Get driver instance (throw if not connected)
    */
-  getDriver(): IDriver {
+  getDriver(): WebDriver {
     if (!this.driver) {
       throw new Error('Driver not connected');
     }
@@ -395,7 +324,9 @@ export class FirefoxCore {
     }
 
     const bidi = await this.driver.getBidi();
-    const ws = bidi.socket;
+    // bidi.socket is a Node.js `ws` WebSocket (EventEmitter-style), but typed as browser WebSocket
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const ws = bidi.socket as any;
 
     // Wait for WebSocket to be ready before sending
     await this.waitForWebSocketOpen(ws);

src/firefox/dom.ts

@@ -2,13 +2,12 @@
  * DOM interactions: evaluate, element lookup, input actions
  */
 
-import { Key } from 'selenium-webdriver';
-import type { IDriver, IElement } from './core.js';
+import { By, Key, WebDriver, WebElement } from 'selenium-webdriver';
 
 export class DomInteractions {
   constructor(
-    private driver: IDriver,
-    private resolveUid?: (uid: string) => Promise<IElement>
+    private driver: WebDriver,
+    private resolveUid?: (uid: string) => Promise<WebElement>
   ) {}
 
   /**
@@ -33,12 +32,12 @@ export class DomInteractions {
   /**
    * Poll for an element matching a CSS selector until found or timeout.
    */
-  private async waitForElement(selector: string, timeout = 5000): Promise<IElement> {
+  private async waitForElement(selector: string, timeout = 5000): Promise<WebElement> {
     const deadline = Date.now() + timeout;
     let lastError: Error | undefined;
     while (Date.now() < deadline) {
       try {
-        return await this.driver.findElement({ using: 'css selector', value: selector });
+        return await this.driver.findElement(By.css(selector));
       } catch (e) {
         lastError = e instanceof Error ? e : new Error(String(e));
       }
@@ -50,7 +49,7 @@ export class DomInteractions {
   /**
    * Wait until an element reports isDisplayed(), ignoring failures.
    */
-  private async waitForVisible(el: IElement, timeout = 5000): Promise<void> {
+  private async waitForVisible(el: WebElement, timeout = 5000): Promise<void> {
     const deadline = Date.now() + timeout;
     while (Date.now() < deadline) {
       try {

src/firefox/index.ts

@@ -3,7 +3,8 @@
  */
 
 import type { FirefoxLaunchOptions, ConsoleMessage } from './types.js';
-import { FirefoxCore, type IElement } from './core.js';
+import { WebElement } from 'selenium-webdriver';
+import { FirefoxCore } from './core.js';
 import { logDebug } from '../utils/logger.js';
 import { ConsoleEvents, NetworkEvents } from './events/index.js';
 import { DomInteractions } from './dom.js';
@@ -366,7 +367,7 @@ export class FirefoxClient {
     return this.snapshot.resolveUidToSelector(uid);
   }
 
-  async resolveUidToElement(uid: string): Promise<IElement> {
+  async resolveUidToElement(uid: string): Promise<WebElement> {
     if (!this.snapshot) {
       throw new Error('Not connected');
     }

src/firefox/pages.ts

@@ -2,12 +2,12 @@
  * Page/Tab/Window management
  */
 
-import type { IDriver } from './core.js';
+import { WebDriver } from 'selenium-webdriver';
 import { log } from '../utils/logger.js';
 
 export class PageManagement {
   constructor(
-    private driver: IDriver,
+    private driver: WebDriver,
     private getCurrentContextId: () => string | null,
     private setCurrentContextId: (id: string) => void
   ) {}

src/firefox/snapshot/manager.ts

@@ -3,7 +3,7 @@
  * Handles snapshot creation using bundled injected script
  */
 
-import type { IDriver, IElement } from '../core.js';
+import { WebDriver, WebElement } from 'selenium-webdriver';
 import { readFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -25,12 +25,12 @@ export interface SnapshotOptions {
  * Uses bundled injected script for snapshot creation
  */
 export class SnapshotManager {
-  private driver: IDriver;
+  private driver: WebDriver;
   private resolver: UidResolver;
   private injectedScript: string | null = null;
   private currentSnapshotId = 0;
 
-  constructor(driver: IDriver) {
+  constructor(driver: WebDriver) {
     this.driver = driver;
     this.resolver = new UidResolver(driver);
   }
@@ -159,7 +159,7 @@ export class SnapshotManager {
   /**
    * Resolve UID to WebElement (with staleness check and caching)
    */
-  async resolveUidToElement(uid: string): Promise<IElement> {
+  async resolveUidToElement(uid: string): Promise<WebElement> {
     return await this.resolver.resolveUidToElement(uid);
   }
 

src/firefox/snapshot/resolver.ts

@@ -3,14 +3,14 @@
  * Handles UID validation, resolution to selectors/elements, and element caching
  */
 
-import type { IDriver, IElement } from '../core.js';
+import { By, WebDriver, WebElement } from 'selenium-webdriver';
 import { logDebug } from '../../utils/logger.js';
 import type { UidEntry } from './types.js';
 
-interface IElementCacheEntry {
+interface WebElementCacheEntry {
   selector: string;
   xpath?: string;
-  cachedElement: IElement;
+  cachedElement: WebElement;
   snapshotId: number;
   timestamp: number;
 }
@@ -21,10 +21,10 @@ interface IElementCacheEntry {
  */
 export class UidResolver {
   private uidToEntry = new Map<string, UidEntry>();
-  private elementCache = new Map<string, IElementCacheEntry>();
+  private elementCache = new Map<string, WebElementCacheEntry>();
   private currentSnapshotId = 0;
 
-  constructor(private driver: IDriver) {}
+  constructor(private driver: WebDriver) {}
 
   /**
    * Update current snapshot ID
@@ -98,7 +98,7 @@ export class UidResolver {
    * Resolve UID to element (with staleness check and caching)
    * Tries CSS first, falls back to XPath
    */
-  async resolveUidToElement(uid: string): Promise<IElement> {
+  async resolveUidToElement(uid: string): Promise<WebElement> {
     this.validateUid(uid);
 
     const entry = this.uidToEntry.get(uid);
@@ -122,7 +122,7 @@ export class UidResolver {
 
     // Try CSS selector first
     try {
-      const element = await this.driver.findElement({ using: 'css selector', value: entry.css });
+      const element = await this.driver.findElement(By.css(entry.css));
 
       // Update cache
       this.elementCache.set(uid, {
@@ -142,7 +142,7 @@ export class UidResolver {
       const xpathSelector = entry.xpath;
       if (xpathSelector) {
         try {
-          const element = await this.driver.findElement({ using: 'xpath', value: xpathSelector });
+          const element = await this.driver.findElement(By.xpath(xpathSelector));
 
           // Update cache
           this.elementCache.set(uid, {

src/firefox/snapshot/types.ts

@@ -2,7 +2,7 @@
  * Snapshot types and interfaces
  */
 
-import type { IElement } from '../core.js';
+import type { WebElement } from 'selenium-webdriver';
 
 /**
  * UID entry with CSS and XPath selectors
@@ -100,7 +100,7 @@ export interface InjectedScriptResult {
 export interface ElementCacheEntry {
   selector: string;
   xpath?: string;
-  cachedElement?: IElement;
+  cachedElement?: WebElement;
   snapshotId: number;
   timestamp: number;
 }