@toolstackhq/cdpwright 1.0.0

package/dist/expect-CY70zJc0.d.ts

@@ -0,0 +1,318 @@
+type LogLevel = "error" | "warn" | "info" | "debug" | "trace";
+declare class Logger {
+    private level;
+    constructor(level?: LogLevel);
+    setLevel(level: LogLevel): void;
+    error(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    debug(message: string, ...args: unknown[]): void;
+    trace(message: string, ...args: unknown[]): void;
+    log(level: LogLevel, message: string, ...args: unknown[]): void;
+}
+
+declare class Session {
+    private connection;
+    private sessionId;
+    private emitter;
+    constructor(connection: Connection, sessionId: string);
+    on(event: string, handler: (params: unknown) => void): void;
+    once(event: string, handler: (params: unknown) => void): void;
+    send<T = unknown>(method: string, params?: Record<string, unknown>): Promise<T>;
+    dispatch(method: string, params: unknown): void;
+}
+
+declare class Connection {
+    private ws;
+    private id;
+    private callbacks;
+    private sessions;
+    private emitter;
+    private logger;
+    private closed;
+    constructor(url: string, logger: Logger);
+    waitForOpen(): Promise<void>;
+    createSession(sessionId: string): Session;
+    removeSession(sessionId: string): void;
+    on(event: string, handler: (params: unknown) => void): void;
+    send<T = unknown>(method: string, params?: Record<string, unknown>, sessionId?: string): Promise<T>;
+    close(): Promise<void>;
+    private onError;
+    private onClose;
+    private failPending;
+    private onMessage;
+}
+
+type ActionEvent = {
+    name: string;
+    selector?: string;
+    frameId?: string;
+    durationMs?: number;
+    sensitive?: boolean;
+    status?: "passed" | "failed";
+};
+type AssertionEvent = {
+    name: string;
+    selector?: string;
+    frameId?: string;
+    durationMs?: number;
+    status?: "passed" | "failed";
+};
+type AutomationEventMap = {
+    "action:start": ActionEvent;
+    "action:end": ActionEvent;
+    "assertion:start": AssertionEvent;
+    "assertion:end": AssertionEvent;
+};
+declare class AutomationEvents {
+    private emitter;
+    on<K extends keyof AutomationEventMap>(event: K, handler: (payload: AutomationEventMap[K]) => void): void;
+    off<K extends keyof AutomationEventMap>(event: K, handler: (payload: AutomationEventMap[K]) => void): void;
+    emit<K extends keyof AutomationEventMap>(event: K, payload: AutomationEventMap[K]): void;
+}
+
+type LocatorOptions = {};
+declare class Locator {
+    private frame;
+    private selector;
+    private options;
+    constructor(frame: Frame, selector: string, options?: LocatorOptions);
+    click(options?: {
+        timeoutMs?: number;
+    }): Promise<void>;
+    dblclick(options?: {
+        timeoutMs?: number;
+    }): Promise<void>;
+    type(text: string, options?: {
+        timeoutMs?: number;
+    }): Promise<void>;
+    exists(): Promise<boolean>;
+    text(): Promise<string | null>;
+}
+
+type FrameSelectorOptions = {
+    pierceShadowDom?: boolean;
+    timeoutMs?: number;
+};
+type ClickOptions = {
+    timeoutMs?: number;
+};
+type TypeOptions = {
+    timeoutMs?: number;
+    sensitive?: boolean;
+};
+type QueryResult = {
+    objectId: string;
+    contextId: number;
+};
+declare class Frame {
+    readonly id: string;
+    name?: string;
+    url?: string;
+    parentId?: string;
+    private session;
+    private logger;
+    private events;
+    private contextId?;
+    private defaultTimeout;
+    constructor(id: string, session: Session, logger: Logger, events: AutomationEvents);
+    setExecutionContext(contextId?: number): void;
+    getExecutionContext(): number | undefined;
+    setMeta(meta: {
+        name?: string;
+        url?: string;
+        parentId?: string;
+    }): void;
+    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;
+    click(selector: string, options?: ClickOptions): Promise<void>;
+    dblclick(selector: string, options?: ClickOptions): Promise<void>;
+    type(selector: string, text: string, options?: TypeOptions): Promise<void>;
+    typeSecure(selector: string, text: string, options?: TypeOptions): Promise<void>;
+    fillInput(selector: string, value: string, options?: {
+        timeoutMs?: number;
+    }): Promise<void>;
+    findLocators(options?: {
+        highlight?: boolean;
+        outputPath?: string;
+        outputJson?: string;
+        outputHtml?: string;
+    }): Promise<any[]>;
+    private writeLocatorHtml;
+    exists(selector: string, options?: FrameSelectorOptions): Promise<boolean>;
+    isVisible(selector: string, options?: FrameSelectorOptions): Promise<boolean>;
+    text(selector: string, options?: FrameSelectorOptions): Promise<string | null>;
+    textSecure(selector: string, options?: FrameSelectorOptions): Promise<string | null>;
+    selectOption(selector: string, value: string): Promise<void>;
+    setFileInput(selector: string, name: string, contents: string, options?: {
+        mimeType?: string;
+    }): Promise<void>;
+    attribute(selector: string, name: string, options?: FrameSelectorOptions): Promise<string | null>;
+    value(selector: string, options?: FrameSelectorOptions): Promise<string | null>;
+    valueSecure(selector: string, options?: FrameSelectorOptions): Promise<string | null>;
+    isEnabled(selector: string, options?: FrameSelectorOptions): Promise<boolean | null>;
+    isChecked(selector: string, options?: FrameSelectorOptions): Promise<boolean | null>;
+    count(selector: string, options?: FrameSelectorOptions): Promise<number>;
+    classes(selector: string, options?: FrameSelectorOptions): Promise<string[] | null>;
+    css(selector: string, property: string, options?: FrameSelectorOptions): Promise<string | null>;
+    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 performClick;
+    private resolveElementBox;
+    private querySelectorInternal;
+    private querySelectorAllInternal;
+    private evaluateInContext;
+    private releaseObject;
+    private buildElementExpression;
+    private evalOnSelector;
+}
+
+type GotoOptions = {
+    waitUntil?: "domcontentloaded" | "load";
+    timeoutMs?: number;
+    allowFileUrl?: boolean;
+};
+type ScreenshotOptions = {
+    path?: string;
+    format?: "png" | "jpeg";
+    quality?: number;
+};
+declare class Page {
+    private session;
+    private logger;
+    private events;
+    private framesById;
+    private mainFrameId?;
+    private lifecycleEvents;
+    private defaultTimeout;
+    constructor(session: Session, logger: Logger, events: AutomationEvents);
+    initialize(): Promise<void>;
+    frames(): Frame[];
+    mainFrame(): Frame;
+    frame(options: {
+        name?: string;
+        urlIncludes?: string;
+        predicate?: (frame: Frame) => boolean;
+    }): Frame | null;
+    locator(selector: string): Locator;
+    goto(url: string, options?: GotoOptions): Promise<void>;
+    query(selector: string): Promise<QueryResult | null>;
+    queryAll(selector: string): Promise<QueryResult[]>;
+    queryXPath(selector: string): Promise<QueryResult | null>;
+    queryAllXPath(selector: string): Promise<QueryResult[]>;
+    click(selector: string, options?: {
+        timeoutMs?: number;
+    }): Promise<void>;
+    dblclick(selector: string, options?: {
+        timeoutMs?: number;
+    }): Promise<void>;
+    type(selector: string, text: string, options?: {
+        timeoutMs?: number;
+    }): Promise<void>;
+    typeSecure(selector: string, text: string, options?: {
+        timeoutMs?: number;
+    }): Promise<void>;
+    fillInput(selector: string, value: string, options?: {
+        timeoutMs?: number;
+    }): Promise<void>;
+    evaluate<T = unknown>(fnOrString: string | ((...args: any[]) => any), ...args: any[]): Promise<T>;
+    textSecure(selector: string): Promise<string | null>;
+    valueSecure(selector: string): Promise<string | null>;
+    selectOption(selector: string, value: string): Promise<void>;
+    setFileInput(selector: string, name: string, contents: string, options?: {
+        mimeType?: string;
+    }): Promise<void>;
+    screenshot(options?: ScreenshotOptions): Promise<Buffer<ArrayBuffer>>;
+    screenshotBase64(options?: Omit<ScreenshotOptions, "path">): Promise<string>;
+    getEvents(): AutomationEvents;
+    getDefaultTimeout(): number;
+    private buildFrameTree;
+    private ensureFrame;
+    private onFrameAttached;
+    private onFrameNavigated;
+    private onFrameDetached;
+    private onExecutionContextCreated;
+    private onExecutionContextDestroyed;
+    private onExecutionContextsCleared;
+    private onLifecycleEvent;
+    private waitForLifecycle;
+}
+
+type ExpectSelectorOptions = {
+    timeoutMs?: number;
+};
+declare class ElementExpectation {
+    private frame;
+    private selector;
+    private options;
+    private negate;
+    private events;
+    constructor(frame: Frame, selector: string, options: ExpectSelectorOptions, negate: boolean, events: AutomationEvents);
+    get not(): ElementExpectation;
+    toExist(): Promise<void>;
+    toBeVisible(): Promise<void>;
+    toBeHidden(): Promise<void>;
+    toBeEnabled(): Promise<void>;
+    toBeDisabled(): Promise<void>;
+    toBeChecked(): Promise<void>;
+    toBeUnchecked(): Promise<void>;
+    toHaveText(textOrRegex: string | RegExp): Promise<void>;
+    toHaveExactText(textOrRegex: string | RegExp): Promise<void>;
+    toContainText(textOrRegex: string | RegExp): Promise<void>;
+    toHaveValue(valueOrRegex: string | RegExp): Promise<void>;
+    toHaveAttribute(name: string, valueOrRegex?: string | RegExp): Promise<void>;
+    toHaveId(idOrRegex: string | RegExp): Promise<void>;
+    toHaveName(nameOrRegex: string | RegExp): Promise<void>;
+    toHaveCount(expected: number): Promise<void>;
+    toHaveClass(nameOrRegex: string | RegExp): Promise<void>;
+    toHaveClasses(expected: string[]): Promise<void>;
+    toHaveCss(property: string, valueOrRegex: string | RegExp): Promise<void>;
+    toHaveFocus(): Promise<void>;
+    toBeInViewport(options?: {
+        fully?: boolean;
+    }): Promise<void>;
+    toBeEditable(): Promise<void>;
+    private assert;
+}
+declare class ExpectFrame {
+    private frame;
+    private events;
+    constructor(frame: Frame, events: AutomationEvents);
+    element(selector: string, options?: ExpectSelectorOptions): ElementExpectation;
+}
+declare function expect(page: Page): {
+    element: (selector: string, options?: ExpectSelectorOptions) => ElementExpectation;
+    frame: (options: {
+        name?: string;
+        urlIncludes?: string;
+        predicate?: (frame: Frame) => boolean;
+    }) => ExpectFrame;
+};
+
+declare module "../core/Page.js" {
+    interface Page {
+        expect(): ReturnType<typeof expect>;
+        expect(selector: string, options?: ExpectSelectorOptions): ElementExpectation;
+        find: {
+            locators: (options?: {
+                highlight?: boolean;
+                outputPath?: string;
+                outputJson?: string;
+                outputHtml?: string;
+            }) => Promise<any[]>;
+        };
+        findLocators(options?: {
+            highlight?: boolean;
+            outputPath?: string;
+            outputJson?: string;
+            outputHtml?: string;
+        }): Promise<any[]>;
+    }
+}
+
+export { AutomationEvents as A, Connection as C, ElementExpectation as E, Frame as F, Logger as L, Page as P, type LogLevel as a, Locator as b, ExpectFrame as c, type ExpectSelectorOptions as d, expect as e };

package/dist/index.d.ts

@@ -0,0 +1,64 @@
+import { C as Connection, L as Logger, A as AutomationEvents, P as Page, a as LogLevel } from './expect-CY70zJc0.js';
+export { F as Frame, b as Locator, e as expect } from './expect-CY70zJc0.js';
+import { ChildProcess } from 'child_process';
+
+declare class BrowserContext {
+    private browser;
+    private id;
+    constructor(browser: Browser, id: string);
+    getId(): string;
+    newPage(): Promise<Page>;
+    close(): Promise<void>;
+}
+declare class Browser {
+    private connection;
+    private process;
+    private logger;
+    private events;
+    private cleanupTasks;
+    private contexts;
+    constructor(connection: Connection, child: ChildProcess, logger: Logger, events: AutomationEvents, cleanupTasks?: Array<() => void>);
+    on(event: "action:start" | "action:end" | "assertion:start" | "assertion:end", handler: (payload: any) => void): void;
+    newContext(): Promise<BrowserContext>;
+    newPage(options?: {
+        browserContextId?: string;
+    }): Promise<Page>;
+    disposeContext(contextId: string): Promise<void>;
+    close(): Promise<void>;
+}
+
+type LaunchOptions = {
+    headless?: boolean;
+    args?: string[];
+    timeoutMs?: number;
+    logLevel?: LogLevel;
+    logEvents?: boolean;
+    logActions?: boolean;
+    logAssertions?: boolean;
+    executablePath?: string;
+    userDataDir?: string;
+    maximize?: boolean;
+};
+
+declare class AssertionError extends Error {
+    selector?: string;
+    timeoutMs?: number;
+    lastState?: unknown;
+    constructor(message: string, options?: {
+        selector?: string;
+        timeoutMs?: number;
+        lastState?: unknown;
+    });
+}
+
+type AutomatonLaunchOptions = LaunchOptions & {
+    logger?: Logger;
+};
+declare const automaton: {
+    launch(options?: AutomatonLaunchOptions): Promise<Browser>;
+};
+declare const chromium: {
+    launch(options?: AutomatonLaunchOptions): Promise<Browser>;
+};
+
+export { AssertionError, AutomationEvents, type AutomatonLaunchOptions, Browser, BrowserContext, LogLevel, Logger, Page, automaton, chromium };