@bctrl/sdk 1.0.1

package/dist/drivers/playwright/generated/browser-context.js

@@ -0,0 +1,458 @@
+/**
+ * AUTO-GENERATED FILE - DO NOT EDIT
+ *
+ * Generated from: packages/automation-spec/src/drivers/playwright/methods/
+ * Run `pnpm generate:playwright` to regenerate.
+ */
+import { extractHandleId, serializeFunctionSource, } from '../../../internal/transport.js';
+import { RemoteBase } from '../remote-base.js';
+import { getRemoteListenerBinding } from '../../../base/event-binding.js';
+import { RemotePlaywrightClock } from './clock.js';
+import { RemotePlaywrightTracing } from './tracing.js';
+import { RemotePlaywrightAPIRequestContext } from './api-request-context.js';
+/**
+ * RemotePlaywrightBrowserContext - Remote Playwright BrowserContext API over RPC.
+ *
+ * @see https://playwright.dev/docs/api/class-browsercontext
+ */
+export class RemotePlaywrightBrowserContext extends RemoteBase {
+    constructor(id, sendRpc, createPage, browserRef) {
+        super(id, sendRpc);
+        this.createPage = createPage;
+        this._browser = browserRef ?? null;
+    }
+    _browser;
+    _defaultTimeout = 30000;
+    _defaultNavigationTimeout = 30000;
+    _listeners = new Map();
+    _clock = null;
+    _request = null;
+    _tracing = null;
+    createPage;
+    notifyFirstListener(event) {
+        const binding = getRemoteListenerBinding(this);
+        if (!binding)
+            return;
+        binding.onFirstListener(event);
+    }
+    notifyNoListeners(event) {
+        const binding = getRemoteListenerBinding(this);
+        if (!binding)
+            return;
+        binding.onNoListeners(event);
+    }
+    /**
+     * Returns the browser this context belongs to.
+     * @see https://playwright.dev/docs/api/class-browsercontext#browser-context-browser
+     */
+    browser() {
+        return this._browser;
+    }
+    /**
+     * Playwright Clock API for mocking time.
+     * @see https://playwright.dev/docs/api/class-clock
+     */
+    get clock() {
+        if (!this._clock) {
+            this._clock = new RemotePlaywrightClock(this.sendRpc, this.id);
+        }
+        return this._clock;
+    }
+    /**
+     * API testing helper associated with this context.
+     * @see https://playwright.dev/docs/api/class-browsercontext#browser-context-request
+     */
+    get request() {
+        if (!this._request) {
+            this._request = new RemotePlaywrightAPIRequestContext(this.sendRpc);
+        }
+        return this._request;
+    }
+    /**
+     * Tracing helper for recording execution traces.
+     * @see https://playwright.dev/docs/api/class-browsercontext#browser-context-tracing
+     */
+    get tracing() {
+        if (!this._tracing) {
+            this._tracing = new RemotePlaywrightTracing(this.sendRpc, this.id);
+        }
+        return this._tracing;
+    }
+    /**
+     * Sets the default maximum navigation timeout.
+     * @see https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-navigation-timeout
+     */
+    async setDefaultNavigationTimeout(timeout) {
+        await this.sendRpc('setDefaultNavigationTimeout', [this.id, timeout]);
+        this._defaultNavigationTimeout = timeout;
+    }
+    /**
+     * Sets the default maximum time for all methods accepting timeout option.
+     * @see https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout
+     */
+    async setDefaultTimeout(timeout) {
+        await this.sendRpc('setDefaultTimeout', [this.id, timeout]);
+        this._defaultTimeout = timeout;
+    }
+    on(event, handler) {
+        const listeners = this._listeners.get(event) ?? [];
+        const hadListeners = listeners.length > 0;
+        listeners.push({ handler, once: false });
+        this._listeners.set(event, listeners);
+        if (!hadListeners) {
+            this.notifyFirstListener(event);
+        }
+        return this;
+    }
+    once(event, handler) {
+        const listeners = this._listeners.get(event) ?? [];
+        const hadListeners = listeners.length > 0;
+        listeners.push({ handler, once: true });
+        this._listeners.set(event, listeners);
+        if (!hadListeners) {
+            this.notifyFirstListener(event);
+        }
+        return this;
+    }
+    off(event, handler) {
+        if (!handler) {
+            const hadListeners = (this._listeners.get(event)?.length ?? 0) > 0;
+            this._listeners.delete(event);
+            if (hadListeners) {
+                this.notifyNoListeners(event);
+            }
+            return this;
+        }
+        const listeners = this._listeners.get(event);
+        if (!listeners)
+            return this;
+        const remaining = listeners.filter((entry) => entry.handler !== handler);
+        if (remaining.length === 0) {
+            this._listeners.delete(event);
+            if (listeners.length > 0) {
+                this.notifyNoListeners(event);
+            }
+        }
+        else {
+            this._listeners.set(event, remaining);
+        }
+        return this;
+    }
+    addListener(event, handler) {
+        return this.on(event, handler);
+    }
+    removeListener(event, handler) {
+        return this.off(event, handler);
+    }
+    listenerCount(event) {
+        return this._listeners.get(event)?.length ?? 0;
+    }
+    emit(event, payload) {
+        const listeners = this._listeners.get(event);
+        if (!listeners || listeners.length === 0)
+            return false;
+        const listenersCopy = [...listeners];
+        const toRemove = [];
+        for (const entry of listenersCopy) {
+            try {
+                entry.handler(payload);
+            }
+            catch (error) {
+                console.error(`Error in BrowserContext event handler for "${event}":`, error);
+            }
+            if (entry.once) {
+                toRemove.push(entry);
+            }
+        }
+        if (toRemove.length > 0) {
+            const remaining = listeners.filter((entry) => !toRemove.includes(entry));
+            if (remaining.length === 0) {
+                this._listeners.delete(event);
+                if (listeners.length > 0) {
+                    this.notifyNoListeners(event);
+                }
+            }
+            else {
+                this._listeners.set(event, remaining);
+            }
+        }
+        return true;
+    }
+    /**
+     * Removes all listeners for the specified event, or all events if no event is specified.
+     * @see https://playwright.dev/docs/api/class-browsercontext#browser-context-remove-all-listeners
+     */
+    removeAllListeners(event) {
+        if (event === undefined) {
+            const existingEvents = Array.from(this._listeners.entries())
+                .filter(([, listeners]) => listeners.length > 0)
+                .map(([eventName]) => eventName);
+            this._listeners.clear();
+            for (const eventName of existingEvents) {
+                this.notifyNoListeners(eventName);
+            }
+        }
+        else {
+            const hadListeners = (this._listeners.get(event)?.length ?? 0) > 0;
+            this._listeners.delete(event);
+            if (hadListeners) {
+                this.notifyNoListeners(event);
+            }
+        }
+        return this;
+    }
+    /**
+     * Returns all open pages in the context.
+     *
+     * @see https://playwright.dev/docs/api/class-browsercontext#browser-context-pages
+     */
+    async pages() {
+        const pageIds = await this.rpc('pages', []);
+        return pageIds.map((id) => this.createPage(id));
+    }
+    /**
+     * Returns all service workers in the context.
+     *
+     * @remarks
+     * Service workers are only available on Chromium-based browsers.
+     *
+     * @see https://playwright.dev/docs/api/class-browsercontext#browser-context-service-workers
+     */
+    async serviceWorkers() {
+        return this.rpc('serviceWorkers', []);
+    }
+    /**
+     * Creates a new page in the browser context.
+     *
+     * @see https://playwright.dev/docs/api/class-browsercontext#browser-context-new-page
+     */
+    async newPage() {
+        const pageId = await this.rpc('newPage', []);
+        return this.createPage(pageId);
+    }
+    /**
+     * Returns the newly created CDP session attached to the given page.
+     * @param page - Target page to create CDP session for.
+     *
+     * @remarks
+     * CDP Sessions are only supported on Chromium-based browsers.
+     *
+     * @see https://playwright.dev/docs/api/class-browsercontext#browser-context-new-cdp-session
+     */
+    async newCDPSession(page) {
+        const _page = extractHandleId(page);
+        return this.rpc('newCDPSession', [_page]);
+    }
+    /**
+     * Adds cookies into this browser context. All pages within this context will have these cookies installed.
+     *
+     * @see https://playwright.dev/docs/api/class-browsercontext#browser-context-add-cookies
+     */
+    async addCookies(cookies) {
+        await this.rpc('addCookies', [cookies]);
+    }
+    /**
+     * Returns cookies for the specified URLs, or all cookies if no URLs are specified.
+     *
+     * @see https://playwright.dev/docs/api/class-browsercontext#browser-context-cookies
+     */
+    async cookies(urls) {
+        return this.rpc('cookies', [urls]);
+    }
+    /**
+     * Removes cookies from context. Accepts optional filter to remove specific cookies.
+     *
+     * @remarks
+     * If no options are provided, removes all cookies from the context.
+     *
+     * @see https://playwright.dev/docs/api/class-browsercontext#browser-context-clear-cookies
+     */
+    async clearCookies(options) {
+        await this.rpc('clearCookies', [options]);
+    }
+    /**
+     * Grants specified permissions to the browser context.
+     *
+     * @remarks
+     * Only grants corresponding permissions to the given origin if specified.
+     *
+     * @see https://playwright.dev/docs/api/class-browsercontext#browser-context-grant-permissions
+     */
+    async grantPermissions(permissions, options) {
+        await this.rpc('grantPermissions', [permissions, options]);
+    }
+    /**
+     * Clears all permission overrides for the browser context.
+     *
+     * @see https://playwright.dev/docs/api/class-browsercontext#browser-context-clear-permissions
+     */
+    async clearPermissions() {
+        await this.rpc('clearPermissions', []);
+    }
+    /**
+     * Adds a script which would be evaluated in one of the following scenarios: whenever a page is created in the context or navigated.
+     *
+     * @remarks
+     * The script is evaluated before any page script. Use when you want to inject JavaScript before the page loads.
+     *
+     * @see https://playwright.dev/docs/api/class-browsercontext#browser-context-add-init-script
+     */
+    async addInitScript(script, arg) {
+        const _script = serializeFunctionSource(script);
+        await this.rpc('addInitScript', [_script, arg]);
+    }
+    /**
+     * Adds a function called name on the window object of every frame in every page in the context.
+     *
+     * @remarks
+     * When called, the function executes callback and returns a Promise which resolves to the return value of callback. The first argument of the callback function contains information about the caller.
+     *
+     * @see https://playwright.dev/docs/api/class-browsercontext#browser-context-expose-binding
+     */
+    async exposeBinding(name, callback, options) {
+        const _callback = serializeFunctionSource(callback);
+        await this.rpc('exposeBinding', [name, _callback, options]);
+    }
+    /**
+     * Routing provides the capability to modify network requests that are made by any page in the browser context.
+     *
+     * @remarks
+     * Once routing is enabled, every request matching the url pattern will stall unless it is continued, fulfilled, or aborted.
+     *
+     * @see https://playwright.dev/docs/api/class-browsercontext#browser-context-route
+     */
+    async route(url, handler, options) {
+        const _handler = serializeFunctionSource(handler);
+        await this.rpc('route', [url, _handler, options]);
+    }
+    /**
+     * If specified, network requests that are made in the context will be served from the HAR file.
+     * @param har - Path to a HAR file with recorded network data.
+     *
+     * @remarks
+     * Read more about Replaying from HAR.
+     *
+     * @see https://playwright.dev/docs/api/class-browsercontext#browser-context-route-from-har
+     */
+    async routeFromHAR(har, options) {
+        await this.rpc('routeFromHAR', [har, options]);
+    }
+    /**
+     * Removes a route created with browserContext.route(). When handler is not specified, removes all routes for the url.
+     *
+     * @see https://playwright.dev/docs/api/class-browsercontext#browser-context-unroute
+     */
+    async unroute(url, handler) {
+        const _handler = serializeFunctionSource(handler);
+        await this.rpc('unroute', [url, _handler]);
+    }
+    /**
+     * Removes all routes created with browserContext.route() and browserContext.routeFromHAR().
+     *
+     * @see https://playwright.dev/docs/api/class-browsercontext#browser-context-unroute-all
+     */
+    async unrouteAll(options) {
+        await this.rpc('unrouteAll', [options]);
+    }
+    /**
+     * Sets extra HTTP headers that will be sent with every request in the context.
+     *
+     * @remarks
+     * These headers are merged with page-specific extra HTTP headers set with page.setExtraHTTPHeaders(). If page overrides a particular header, page-specific header value will be used instead of the browser context header value.
+     *
+     * @see https://playwright.dev/docs/api/class-browsercontext#browser-context-set-extra-http-headers
+     */
+    async setExtraHTTPHeaders(headers) {
+        await this.rpc('setExtraHTTPHeaders', [headers]);
+    }
+    /**
+     * Sets HTTP credentials for HTTP authentication.
+     *
+     * @remarks
+     * Deprecated: Browsers may cache credentials after successful authentication. Create a new browser context instead.
+     *
+     * @see https://playwright.dev/docs/api/class-browsercontext#browser-context-set-http-credentials
+     */
+    async setHTTPCredentials(httpCredentials) {
+        await this.rpc('setHTTPCredentials', [httpCredentials]);
+    }
+    /**
+     * Sets whether to emulate network being offline for the browser context.
+     *
+     * @see https://playwright.dev/docs/api/class-browsercontext#browser-context-set-offline
+     */
+    async setOffline(offline) {
+        await this.rpc('setOffline', [offline]);
+    }
+    /**
+     * Sets the contexts geolocation. Passing null clears geolocation.
+     *
+     * @remarks
+     * Requires the geolocation permission to be granted.
+     *
+     * @see https://playwright.dev/docs/api/class-browsercontext#browser-context-set-geolocation
+     */
+    async setGeolocation(geolocation) {
+        await this.rpc('setGeolocation', [geolocation]);
+    }
+    /**
+     * Returns storage state for this browser context.
+     *
+     * @remarks
+     * Contains current cookies and local storage snapshot.
+     *
+     * @see https://playwright.dev/docs/api/class-browsercontext#browser-context-storage-state
+     */
+    async storageState(options) {
+        return this.rpc('storageState', [options]);
+    }
+    /**
+     * Waits for event to fire and passes its value into the predicate function.
+     *
+     * @remarks
+     * Returns when the predicate returns truthy value. Will throw an error if the context closes before the event is fired.
+     *
+     * @see https://playwright.dev/docs/api/class-browsercontext#browser-context-wait-for-event
+     */
+    async waitForEvent(event, optionsOrPredicate) {
+        return this.rpc('waitForEvent', [event, optionsOrPredicate]);
+    }
+    /**
+     * Allows modifying WebSocket connections made by pages in the context.
+     * @param url - URL pattern to match WebSocket connections.
+     * @param handler - Handler function to route the WebSocket.
+     *
+     * @remarks
+     * Only WebSockets created after this method was called will be routed. It is recommended to call this method before creating any pages.
+     *
+     * @see https://playwright.dev/docs/api/class-browsercontext#browser-context-route-web-socket
+     */
+    async routeWebSocket(url, handler) {
+        const _handler = serializeFunctionSource(handler);
+        await this.rpc('routeWebSocket', [url, _handler]);
+    }
+    /**
+     * Closes the browser context. All the pages that belong to the browser context will be closed.
+     *
+     * @remarks
+     * The default browser context cannot be closed.
+     *
+     * @see https://playwright.dev/docs/api/class-browsercontext#browser-context-close
+     */
+    async close(options) {
+        await this.rpc('close', [options]);
+        this.markClosed();
+    }
+    /**
+     * Returns all background pages in the context.
+     *
+     * @remarks
+     * Deprecated. Background pages are only supported on Chromium-based browsers.
+     *
+     * @see https://playwright.dev/docs/api/class-browsercontext#browser-context-background-pages
+     */
+    async backgroundPages() {
+        const pageIds = await this.rpc('backgroundPages', []);
+        return pageIds.map((id) => this.createPage(id));
+    }
+}

package/dist/drivers/playwright/generated/browser.d.ts

@@ -0,0 +1,120 @@
+/**
+ * AUTO-GENERATED FILE - DO NOT EDIT
+ *
+ * Generated from: packages/automation-spec/src/drivers/playwright/methods/
+ * Run `pnpm generate:playwright` to regenerate.
+ */
+import type { HasHandleId, SimpleRpcSender } from '../../../internal/transport.js';
+import type { PlaywrightNewContextOptions, PlaywrightNewPageOptions, PlaywrightStartTracingOptions } from '../types.js';
+import { RemoteBase } from '../remote-base.js';
+import type { RemotePlaywrightBrowserContext } from './browser-context.js';
+import type { RemotePlaywrightPage } from './page.js';
+/**
+ * RemotePlaywrightBrowser - Remote Playwright Browser API over RPC.
+ *
+ * @see https://playwright.dev/docs/api/class-browser
+ */
+export declare class RemotePlaywrightBrowser extends RemoteBase {
+    constructor(id: string, sendRpc: SimpleRpcSender, createBrowserContext: (id: string) => RemotePlaywrightBrowserContext, createPage: (id: string) => RemotePlaywrightPage);
+    private _listeners;
+    private createBrowserContext;
+    private createPage;
+    /**
+     * Stops Chromium Tracing and returns the trace data.
+     * @remarks This is a Chromium-only API.
+     * @see https://playwright.dev/docs/api/class-browser#browser-stop-tracing
+     */
+    stopTracing(): Promise<Buffer>;
+    /**
+     * Removes all listeners for the specified event, or all events if no event is specified.
+     * @see https://playwright.dev/docs/api/class-browser#browser-remove-all-listeners
+     */
+    removeAllListeners(event?: string): this;
+    /**
+     * Get the browser type name (chromium, firefox, or webkit) that was used to launch this browser.
+     *
+     * @remarks
+     * Note: Returns the name string. This is async in the remote SDK, unlike the native Playwright API.
+     *
+     * @see https://playwright.dev/docs/api/class-browser#browser-browser-type
+     */
+    browserType(): Promise<'chromium' | 'firefox' | 'webkit'>;
+    /**
+     * Returns the browser version.
+     *
+     * @remarks
+     * Note: This is async in the remote SDK, unlike the native Playwright API.
+     *
+     * @see https://playwright.dev/docs/api/class-browser#browser-version
+     */
+    version(): Promise<string>;
+    /**
+     * Indicates that the browser is connected.
+     *
+     * @remarks
+     * Note: This is async in the remote SDK, unlike the native Playwright API.
+     *
+     * @see https://playwright.dev/docs/api/class-browser#browser-is-connected
+     */
+    isConnected(): Promise<boolean>;
+    /**
+     * Returns an array of all open browser contexts.
+     *
+     * @remarks
+     * In a newly created browser, this will return zero browser contexts. Note: This is async in the remote SDK, unlike the native Playwright API.
+     *
+     * @see https://playwright.dev/docs/api/class-browser#browser-contexts
+     */
+    contexts(): Promise<RemotePlaywrightBrowserContext[]>;
+    /**
+     * Creates a new browser context. It will not share cookies/cache with other browser contexts.
+     *
+     * @remarks
+     * If directly using this method to create BrowserContexts, it is best practice to explicitly close the returned context via browserContext.close() when your code is done with the BrowserContext, and before calling browser.close().
+     *
+     * @see https://playwright.dev/docs/api/class-browser#browser-new-context
+     */
+    newContext(options?: PlaywrightNewContextOptions): Promise<RemotePlaywrightBrowserContext>;
+    /**
+     * Creates a new page in a new browser context. Closing this page will close the context as well.
+     *
+     * @remarks
+     * This is a convenience API that should only be used for single-page scenarios and short snippets. Production code and testing frameworks should explicitly create browser.newContext() followed by browserContext.newPage() to control their exact life times.
+     *
+     * @see https://playwright.dev/docs/api/class-browser#browser-new-page
+     */
+    newPage(options?: PlaywrightNewPageOptions): Promise<RemotePlaywrightPage>;
+    /**
+     * Returns the newly created browser session.
+     *
+     * @remarks
+     * CDP Sessions are only supported on Chromium-based browsers.
+     *
+     * @see https://playwright.dev/docs/api/class-browser#browser-new-browser-cdp-session
+     */
+    newBrowserCDPSession(): Promise<{
+        sessionId: string;
+    }>;
+    /**
+     * Starts Chromium Tracing.
+     * @param page - Optional page to capture screenshots from.
+     * @param options - Tracing options.
+     *
+     * @remarks
+     * This is a Chromium-only API. Only one trace can be active at a time per browser.
+     *
+     * @see https://playwright.dev/docs/api/class-browser#browser-start-tracing
+     */
+    startTracing(page?: HasHandleId, options?: PlaywrightStartTracingOptions): Promise<void>;
+    /**
+     * Closes the browser and all of its pages (if any were opened).
+     *
+     * @remarks
+     * The Browser object itself is considered to be disposed and cannot be used anymore. This is similar to force-quitting the browser.
+     *
+     * @see https://playwright.dev/docs/api/class-browser#browser-close
+     */
+    close(options?: {
+        reason?: string;
+    }): Promise<void>;
+}