@wdio/nightwatch-devtools 1.1.1 → 1.3.0

package/dist/index.d.ts

@@ -1,10 +1,106 @@
+import { ScreencastOptions, DevToolsMode, TraceFormat } from '@wdio/devtools-shared';
+
+/** Nightwatch `eventHub` shape — only `runner` + `on()` are documented; the
+ *  rest of the public surface is `unknown` to us. */
+interface NightwatchEventHub {
+    runner?: string;
+    on(event: string, listener: (data: unknown) => void): void;
+    [key: string]: unknown;
+}
+interface DevToolsOptions {
+    port?: number;
+    hostname?: string;
+    /**
+     * Screencast recording options. When enabled, a continuous video of the
+     * browser session is recorded and saved as a .webm file at the end of the
+     * test run. Polling mode only on Nightwatch (no CDP push); works on every
+     * browser Nightwatch supports.
+     */
+    screencast?: ScreencastOptions;
+    /**
+     * Enable WebDriver BiDi capture (browser console + JS exceptions + network
+     * via `selenium-webdriver/bidi`). Requires `webSocketUrl: true` in your
+     * capabilities and a BiDi-capable chromedriver. When attached, the per-
+     * command perf-log network capture path is gated off to avoid duplicate
+     * entries. Defaults to `false` — opt-in.
+     */
+    bidi?: boolean;
+    /** `live` (default) launches the DevTools UI; `trace` skips it. */
+    mode?: DevToolsMode;
+    /** Trace output layout — `zip` (default) writes a single archive,
+     *  `ndjson-directory` unpacks into `trace-<id>/`. Only applies in trace mode. */
+    traceFormat?: TraceFormat;
+}
+interface NightwatchBrowser {
+    url: (url: string) => Promise<unknown>;
+    execute: (script: string | ((...args: unknown[]) => unknown), args?: unknown[]) => Promise<unknown>;
+    executeAsync: (script: (...args: unknown[]) => unknown, args?: unknown[]) => Promise<unknown>;
+    pause: (ms: number) => Promise<unknown>;
+    capabilities?: Record<string, unknown>;
+    desiredCapabilities?: Record<string, unknown>;
+    sessionId?: string;
+    /** Driver instance from selenium-webdriver — its public shape is wide; we
+     *  pass it through to BiDi attach helpers that do their own narrowing. */
+    driver?: unknown;
+    options?: {
+        testEnv?: string;
+        webdriver?: {
+            host?: string;
+        };
+        [key: string]: unknown;
+    };
+    currentTest?: {
+        name?: string;
+        module?: string;
+        group?: string;
+        [key: string]: unknown;
+    };
+    results?: unknown;
+    queue?: unknown;
+}
+
+/**
+ * Cucumber lifecycle for the Nightwatch plugin.
+ *
+ * Extracted from the plugin class to keep `index.ts` under the file-size cap
+ * and to isolate the cucumber-specific orchestration from the per-test
+ * (Mocha/Jasmine-style) lifecycle.
+ *
+ * The plugin passes itself as a `CucumberLifecycleCtx` — a narrow interface
+ * exposing only the fields and methods this module needs. The lifecycle
+ * helpers mutate the plugin's "current execution" state via the accessors on
+ * the ctx (they can't reach the plugin's private fields directly).
+ */
+
+/** Minimal shapes for the Cucumber objects we touch. Cucumber's own types
+ *  vary across major versions; we pin only fields we read. */
+interface CucumberPickleStep {
+    text?: string;
+    astNodeIds?: string[];
+    location?: {
+        line?: number;
+    };
+}
+interface CucumberPickle {
+    uri?: string;
+    name?: string;
+    location?: {
+        line?: number;
+    };
+    astNodeIds?: string[];
+    steps?: CucumberPickleStep[];
+}
+interface CucumberResult {
+    status?: string;
+}
+
 /**
  * Nightwatch DevTools Plugin
  *
  * Integrates Nightwatch with WebdriverIO DevTools following the WDIO service pattern.
  * Captures commands, network requests, and console logs during test execution in real-time.
  */
-import { type DevToolsOptions, type NightwatchBrowser } from './types.js';
+
 declare class NightwatchDevToolsPlugin {
     #private;
     private options;
@@ -16,24 +112,23 @@ declare class NightwatchDevToolsPlugin {
     private isScriptInjected;
     constructor(options?: DevToolsOptions);
     before(): Promise<void>;
-    cucumberBefore(browser: NightwatchBrowser, pickle: any): Promise<void>;
-    cucumberAfter(browser: NightwatchBrowser, result: any, pickle: any): Promise<void>;
-    /** Called from Cucumber BeforeStep hook — marks the step as running. */
-    cucumberBeforeStep(browser: NightwatchBrowser, pickleStep: any, _pickle: any): Promise<void>;
-    /** Called from Cucumber AfterStep hook — records the step result. */
-    cucumberAfterStep(_browser: NightwatchBrowser, result: any, pickleStep: any, _pickle: any): Promise<void>;
+    cucumberBefore(browser: NightwatchBrowser, pickle: CucumberPickle): Promise<void>;
+    cucumberAfter(browser: NightwatchBrowser, result: CucumberResult, pickle: CucumberPickle): Promise<void>;
+    cucumberBeforeStep(browser: NightwatchBrowser, pickleStep: CucumberPickleStep, pickle: CucumberPickle): Promise<void>;
+    cucumberAfterStep(browser: NightwatchBrowser, result: CucumberResult, pickleStep: CucumberPickleStep, pickle: CucumberPickle): Promise<void>;
     beforeEach(browser: NightwatchBrowser): Promise<void>;
     afterEach(browser: NightwatchBrowser): Promise<void>;
     after(browser?: NightwatchBrowser): Promise<void>;
-    registerEventHandlers(eventHub: any): void;
+    registerEventHandlers(eventHub: NightwatchEventHub): void;
 }
-export declare const cucumberHooksPath: string;
-export default function createNightwatchDevTools(options?: DevToolsOptions): {
+declare const cucumberHooksPath: string;
+declare function createNightwatchDevTools(options?: DevToolsOptions): {
     asyncHookTimeout: number;
-    before: (this: any) => Promise<void>;
-    beforeEach: (this: any, browser: NightwatchBrowser) => Promise<void>;
-    afterEach: (this: any, browser: NightwatchBrowser) => Promise<void>;
-    after: (this: any) => Promise<void>;
-    registerEventHandlers: (eventHub: any) => void;
+    before: (this: unknown) => Promise<void>;
+    beforeEach: (this: unknown, browser: NightwatchBrowser) => Promise<void>;
+    afterEach: (this: unknown, browser: NightwatchBrowser) => Promise<void>;
+    after: (this: unknown) => Promise<void>;
+    registerEventHandlers: (eventHub: NightwatchEventHub) => void;
 };
-export { NightwatchDevToolsPlugin };
+
+export { NightwatchDevToolsPlugin, cucumberHooksPath, createNightwatchDevTools as default };