@toolstackhq/cdpwright 1.1.0 → 1.3.0

package/dist/{expect-BY8vnFfi.d.ts → expect-Cd5SNFuF.d.ts}

@@ -71,12 +71,40 @@ declare class AutomationEvents {
     emit<K extends keyof AutomationEventMap>(event: K, payload: AutomationEventMap[K]): void;
 }
 
-type LocatorOptions = {};
+type SelectorLocatorOptions = {
+    pierceShadowDom?: boolean;
+    timeoutMs?: number;
+};
+type TextLocatorOptions$1 = {
+    exact?: boolean;
+    timeoutMs?: number;
+};
+type RoleLocatorOptions$1 = {
+    name?: string | RegExp;
+    exact?: boolean;
+    includeHidden?: boolean;
+    timeoutMs?: number;
+};
+type LocatorQuery = {
+    kind: "selector";
+    selector: string;
+    options?: SelectorLocatorOptions;
+} | {
+    kind: "text";
+    text: string | RegExp;
+    options?: TextLocatorOptions$1;
+} | {
+    kind: "role";
+    role: string;
+    options?: RoleLocatorOptions$1;
+};
 declare class Locator {
     private frame;
-    private selector;
-    private options;
-    constructor(frame: Frame, selector: string, options?: LocatorOptions);
+    private query;
+    constructor(frame: Frame, query: LocatorQuery);
+    getEvents(): AutomationEvents;
+    getFrameId(): string;
+    describe(): string;
     click(options?: {
         timeoutMs?: number;
     }): Promise<void>;
@@ -87,13 +115,35 @@ declare class Locator {
         timeoutMs?: number;
     }): Promise<void>;
     exists(): Promise<boolean>;
+    isVisible(): Promise<boolean | null>;
+    isEnabled(): Promise<boolean | null>;
+    isChecked(): Promise<boolean | null>;
     text(): Promise<string | null>;
+    value(): Promise<string | null>;
+    attribute(name: string): Promise<string | null>;
+    classes(): Promise<string[] | null>;
+    css(property: string): Promise<string | null>;
+    hasFocus(): Promise<boolean | null>;
+    isInViewport(fully?: boolean): Promise<boolean | null>;
+    isEditable(): Promise<boolean | null>;
+    count(): Promise<number>;
+    private queryTimeoutOptions;
 }
 
 type FrameSelectorOptions = {
     pierceShadowDom?: boolean;
     timeoutMs?: number;
 };
+type TextLocatorOptions = {
+    exact?: boolean;
+    timeoutMs?: number;
+};
+type RoleLocatorOptions = {
+    name?: string | RegExp;
+    exact?: boolean;
+    includeHidden?: boolean;
+    timeoutMs?: number;
+};
 type ClickOptions = {
     timeoutMs?: number;
 };
@@ -123,12 +173,15 @@ declare class Frame {
         url?: string;
         parentId?: string;
     }): void;
+    getEvents(): AutomationEvents;
     evaluate<T = unknown>(fnOrString: string | ((...args: any[]) => any), ...args: any[]): Promise<T>;
     query(selector: string, options?: FrameSelectorOptions): Promise<QueryResult | null>;
     queryAll(selector: string, options?: FrameSelectorOptions): Promise<QueryResult[]>;
     queryXPath(selector: string, options?: FrameSelectorOptions): Promise<QueryResult | null>;
     queryAllXPath(selector: string, options?: FrameSelectorOptions): Promise<QueryResult[]>;
     locator(selector: string, options?: FrameSelectorOptions): Locator;
+    getByText(text: string | RegExp, options?: TextLocatorOptions): Locator;
+    getByRole(role: string, options?: RoleLocatorOptions): Locator;
     click(selector: string, options?: ClickOptions): Promise<void>;
     dblclick(selector: string, options?: ClickOptions): Promise<void>;
     type(selector: string, text: string, options?: TypeOptions): Promise<void>;
@@ -145,6 +198,22 @@ declare class Frame {
     private writeLocatorHtml;
     exists(selector: string, options?: FrameSelectorOptions): Promise<boolean>;
     isVisible(selector: string, options?: FrameSelectorOptions): Promise<boolean>;
+    clickLocator(query: LocatorQuery, options?: ClickOptions): Promise<void>;
+    dblclickLocator(query: LocatorQuery, options?: ClickOptions): Promise<void>;
+    typeLocator(query: LocatorQuery, text: string, options?: TypeOptions): Promise<void>;
+    existsLocator(query: LocatorQuery): Promise<boolean>;
+    isVisibleLocator(query: LocatorQuery): Promise<boolean | null>;
+    isEnabledLocator(query: LocatorQuery): Promise<boolean | null>;
+    isCheckedLocator(query: LocatorQuery): Promise<boolean | null>;
+    textLocator(query: LocatorQuery): Promise<string | null>;
+    valueLocator(query: LocatorQuery): Promise<string | null>;
+    attributeLocator(query: LocatorQuery, name: string): Promise<string | null>;
+    classesLocator(query: LocatorQuery): Promise<string[] | null>;
+    cssLocator(query: LocatorQuery, property: string): Promise<string | null>;
+    hasFocusLocator(query: LocatorQuery): Promise<boolean | null>;
+    isInViewportLocator(query: LocatorQuery, fully?: boolean): Promise<boolean | null>;
+    isEditableLocator(query: LocatorQuery): Promise<boolean | null>;
+    countLocator(query: LocatorQuery): Promise<number>;
     text(selector: string, options?: FrameSelectorOptions): Promise<string | null>;
     textSecure(selector: string, options?: FrameSelectorOptions): Promise<string | null>;
     selectOption(selector: string, value: string): Promise<void>;
@@ -162,6 +231,13 @@ declare class Frame {
     hasFocus(selector: string, options?: FrameSelectorOptions): Promise<boolean | null>;
     isInViewport(selector: string, options?: FrameSelectorOptions, fully?: boolean): Promise<boolean | null>;
     isEditable(selector: string, options?: FrameSelectorOptions): Promise<boolean | null>;
+    private performClickLocator;
+    private locatorDescription;
+    private resolveLocatorElementBox;
+    private evalOnLocator;
+    private buildLocatorExpression;
+    private serializeLocatorQuery;
+    private serializeTextQuery;
     private performClick;
     private resolveElementBox;
     private querySelectorInternal;
@@ -215,6 +291,16 @@ declare class Page {
         predicate?: (frame: Frame) => boolean;
     }): Frame | null;
     locator(selector: string): Locator;
+    getByText(text: string | RegExp, options?: {
+        exact?: boolean;
+        timeoutMs?: number;
+    }): Locator;
+    getByRole(role: string, options?: {
+        name?: string | RegExp;
+        exact?: boolean;
+        includeHidden?: boolean;
+        timeoutMs?: number;
+    }): Locator;
     goto(url: string, options?: GotoOptions): Promise<void>;
     query(selector: string): Promise<QueryResult | null>;
     queryAll(selector: string): Promise<QueryResult[]>;
@@ -242,11 +328,13 @@ declare class Page {
     setFileInput(selector: string, name: string, contents: string, options?: {
         mimeType?: string;
     }): Promise<void>;
+    content(): Promise<string>;
     screenshot(options?: ScreenshotOptions): Promise<Buffer<ArrayBuffer>>;
     screenshotBase64(options?: Omit<ScreenshotOptions, "path">): Promise<string>;
     pdf(options?: PdfOptions): Promise<Buffer>;
     getEvents(): AutomationEvents;
     getDefaultTimeout(): number;
+    waitForLoad(timeoutMs?: number): Promise<void>;
     private buildFrameTree;
     private ensureFrame;
     private onFrameAttached;
@@ -262,13 +350,29 @@ declare class Page {
 type ExpectSelectorOptions = {
     timeoutMs?: number;
 };
+type ExpectTarget = {
+    label: string;
+    frameId: string;
+    exists(): Promise<boolean>;
+    isVisible(): Promise<boolean | null>;
+    isEnabled(): Promise<boolean | null>;
+    isChecked(): Promise<boolean | null>;
+    text(): Promise<string | null>;
+    value(): Promise<string | null>;
+    attribute(name: string): Promise<string | null>;
+    count(): Promise<number>;
+    classes(): Promise<string[] | null>;
+    css(property: string): Promise<string | null>;
+    hasFocus(): Promise<boolean | null>;
+    isInViewport(fully?: boolean): Promise<boolean | null>;
+    isEditable(): Promise<boolean | null>;
+};
 declare class ElementExpectation {
-    private frame;
-    private selector;
+    private target;
     private options;
     private negate;
     private events;
-    constructor(frame: Frame, selector: string, options: ExpectSelectorOptions, negate: boolean, events: AutomationEvents);
+    constructor(target: ExpectTarget, options: ExpectSelectorOptions, negate: boolean, events: AutomationEvents);
     get not(): ElementExpectation;
     toExist(): Promise<void>;
     toBeVisible(): Promise<void>;
@@ -309,11 +413,13 @@ declare function expect(page: Page): {
         predicate?: (frame: Frame) => boolean;
     }) => ExpectFrame;
 };
+declare function expect(locator: Locator): ElementExpectation;
 
 declare module "../core/Page.js" {
     interface Page {
         expect(): ReturnType<typeof expect>;
         expect(selector: string, options?: ExpectSelectorOptions): ElementExpectation;
+        expect(locator: Locator): ElementExpectation;
         find: {
             locators: (options?: {
                 highlight?: boolean;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { C as Connection, L as Logger, A as AutomationEvents, P as Page, a as LogLevel } from './expect-BY8vnFfi.js';
-export { F as Frame, b as Locator, e as expect } from './expect-BY8vnFfi.js';
+import { C as Connection, L as Logger, A as AutomationEvents, P as Page, a as LogLevel } from './expect-Cd5SNFuF.js';
+export { F as Frame, b as Locator, e as expect } from './expect-Cd5SNFuF.js';
 import { ChildProcess } from 'child_process';
 
 declare class BrowserContext {
@@ -17,12 +17,24 @@ declare class Browser {
     private events;
     private cleanupTasks;
     private contexts;
-    constructor(connection: Connection, child: ChildProcess, logger: Logger, events: AutomationEvents, cleanupTasks?: Array<() => void>);
+    readonly wsEndpoint: string;
+    readonly pid: number;
+    constructor(connection: Connection, child: ChildProcess | null, logger: Logger, events: AutomationEvents, cleanupTasks?: Array<() => void>, wsEndpoint?: string);
     on(event: "action:start" | "action:end" | "assertion:start" | "assertion:end", handler: (payload: any) => void): void;
     newContext(): Promise<BrowserContext>;
     newPage(options?: {
         browserContextId?: string;
     }): Promise<Page>;
+    /** Attach to an existing page by target ID. */
+    attachPage(targetId: string): Promise<Page>;
+    /** List open page targets. */
+    pages(): Promise<Array<{
+        targetId: string;
+        url: string;
+        title: string;
+    }>>;
+    /** Disconnect without killing the browser process. */
+    disconnect(): Promise<void>;
     disposeContext(contextId: string): Promise<void>;
     close(): Promise<void>;
 }
@@ -54,11 +66,20 @@ declare class AssertionError extends Error {
 type AutomatonLaunchOptions = LaunchOptions & {
     logger?: Logger;
 };
+type ConnectOptions = {
+    logLevel?: LogLevel;
+    logger?: Logger;
+    logEvents?: boolean;
+    logActions?: boolean;
+    logAssertions?: boolean;
+};
 declare const automaton: {
     launch(options?: AutomatonLaunchOptions): Promise<Browser>;
+    connect(wsEndpoint: string, options?: ConnectOptions): Promise<Browser>;
 };
 declare const chromium: {
     launch(options?: AutomatonLaunchOptions): Promise<Browser>;
+    connect(wsEndpoint: string, options?: ConnectOptions): Promise<Browser>;
 };
 
-export { AssertionError, AutomationEvents, type AutomatonLaunchOptions, Browser, BrowserContext, LogLevel, Logger, Page, automaton, chromium };
+export { AssertionError, AutomationEvents, type AutomatonLaunchOptions, Browser, BrowserContext, type ConnectOptions, LogLevel, Logger, Page, automaton, chromium };

package/dist/index.js

@@ -4,7 +4,7 @@ import {
   Locator,
   Page,
   expect
-} from "./chunk-M5G6EMAS.js";
+} from "./chunk-EIAXMGD5.js";
 
 // src/browser/ChromiumManager.ts
 import fs2 from "fs";
@@ -292,12 +292,16 @@ var Browser = class {
   events;
   cleanupTasks;
   contexts = /* @__PURE__ */ new Set();
-  constructor(connection, child, logger, events, cleanupTasks = []) {
+  wsEndpoint;
+  pid;
+  constructor(connection, child, logger, events, cleanupTasks = [], wsEndpoint = "") {
     this.connection = connection;
     this.process = child;
     this.logger = logger;
     this.events = events;
     this.cleanupTasks = cleanupTasks;
+    this.wsEndpoint = wsEndpoint;
+    this.pid = child?.pid ?? 0;
   }
   on(event, handler) {
     this.events.on(event, handler);
@@ -319,6 +323,23 @@ var Browser = class {
     await page.initialize();
     return page;
   }
+  /** Attach to an existing page by target ID. */
+  async attachPage(targetId) {
+    const { sessionId } = await this.connection.send("Target.attachToTarget", { targetId, flatten: true });
+    const session = this.connection.createSession(sessionId);
+    const page = new Page(session, this.logger, this.events);
+    await page.initialize();
+    return page;
+  }
+  /** List open page targets. */
+  async pages() {
+    const result = await this.connection.send("Target.getTargets");
+    return result.targetInfos.filter((t) => t.type === "page").map((t) => ({ targetId: t.targetId, url: t.url, title: t.title }));
+  }
+  /** Disconnect without killing the browser process. */
+  async disconnect() {
+    await this.connection.close();
+  }
   async disposeContext(contextId) {
     if (!contextId) return;
     try {
@@ -338,7 +359,7 @@ var Browser = class {
     } catch {
     }
     await this.connection.close();
-    if (!this.process.killed) {
+    if (this.process && !this.process.killed) {
       this.process.kill();
     }
     for (const task of this.cleanupTasks) {
@@ -680,6 +701,7 @@ var ChromiumManager = class {
     }
     if (options.maximize) {
       args.push("--start-maximized");
+      args.push("--window-size=1920,1080");
     }
     if (options.args) {
       args.push(...options.args);
@@ -708,7 +730,7 @@ var ChromiumManager = class {
         logger.info(`Assertion ${payload.name}`, ...args2);
       });
     }
-    const browser = new Browser(connection, child, logger, events, cleanupTasks);
+    const browser = new Browser(connection, child, logger, events, cleanupTasks, wsEndpoint);
     return browser;
   }
   resolveCacheRoot(platform) {
@@ -873,6 +895,33 @@ var automaton = {
   async launch(options = {}) {
     const manager = new ChromiumManager(options.logger);
     return manager.launch(options);
+  },
+  async connect(wsEndpoint, options = {}) {
+    const logger = options.logger ?? new Logger(options.logLevel ?? "warn");
+    const connection = new Connection(wsEndpoint, logger);
+    await connection.waitForOpen();
+    const events = new AutomationEvents();
+    const logEvents = options.logEvents ?? true;
+    const logActions = options.logActions ?? true;
+    const logAssertions = options.logAssertions ?? true;
+    if (logEvents && logActions) {
+      events.on("action:end", (payload) => {
+        const selector = payload.sensitive ? void 0 : payload.selector;
+        const args = [];
+        if (selector) args.push(selector);
+        if (typeof payload.durationMs === "number") args.push(`${payload.durationMs}ms`);
+        logger.info(`Action ${payload.name}`, ...args);
+      });
+    }
+    if (logEvents && logAssertions) {
+      events.on("assertion:end", (payload) => {
+        const args = [];
+        if (payload.selector) args.push(payload.selector);
+        if (typeof payload.durationMs === "number") args.push(`${payload.durationMs}ms`);
+        logger.info(`Assertion ${payload.name}`, ...args);
+      });
+    }
+    return new Browser(connection, null, logger, events, [], wsEndpoint);
   }
 };
 var chromium = automaton;