@bctrl/sdk 1.0.1

package/dist/drivers/puppeteer/generated/http-response.js

@@ -0,0 +1,169 @@
+/**
+ * AUTO-GENERATED FILE - DO NOT EDIT
+ *
+ * Generated from: packages/automation-spec/src/drivers/puppeteer/methods/puppeteer-methods.ts
+ * Run `pnpm generate:puppeteer` to regenerate.
+ */
+/**
+ * Type guard to check if a value is a serialized HTTPResponse.
+ */
+export function isSerializedHTTPResponse(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'responseId' in value &&
+        'url' in value &&
+        'status' in value);
+}
+/**
+ * RemotePuppeteerHTTPResponse - Remote Puppeteer HTTPResponse API over RPC.
+ *
+ * @see https://pptr.dev/api/puppeteer.httpresponse
+ */
+export class RemotePuppeteerHTTPResponse {
+    sendRpc;
+    _responseId;
+    _factories;
+    constructor(sendRpc, data, factories) {
+        this.sendRpc = sendRpc;
+        this._responseId = data.responseId;
+        this._factories = factories;
+        this._data = data;
+    }
+    _data;
+    /**
+     * The response ID.
+     * @internal
+     */
+    get id() {
+        return this._data.responseId;
+    }
+    /**
+     * Helper to send RPC calls prefixed with the response ID.
+     * @internal
+     */
+    rpc(method, args) {
+        return this.sendRpc(`response:${this._data.responseId}:${method}`, args);
+    }
+    /**
+     * The URL of the response.
+     * @see https://pptr.dev/api/puppeteer.httpresponse.url
+     */
+    url() {
+        return this._data.url;
+    }
+    /**
+     * The status code of the response (e.g., 200, 404).
+     * @see https://pptr.dev/api/puppeteer.httpresponse.status
+     */
+    status() {
+        return this._data.status;
+    }
+    /**
+     * The status text of the response (e.g., 'OK', 'Not Found').
+     * @see https://pptr.dev/api/puppeteer.httpresponse.statustext
+     */
+    statusText() {
+        return this._data.statusText;
+    }
+    /**
+     * An object with HTTP headers associated with the response.
+     * All header names are lowercase.
+     * @see https://pptr.dev/api/puppeteer.httpresponse.headers
+     */
+    headers() {
+        return this._data.headers;
+    }
+    /**
+     * True if the response was successful (status in the range 200-299).
+     * @see https://pptr.dev/api/puppeteer.httpresponse.ok
+     */
+    ok() {
+        return this._data.ok;
+    }
+    /**
+     * True if the response was served from the browser's disk cache.
+     * @see https://pptr.dev/api/puppeteer.httpresponse.fromcache
+     */
+    fromCache() {
+        return this._data.fromCache;
+    }
+    /**
+     * True if the response was served by a service worker.
+     * @see https://pptr.dev/api/puppeteer.httpresponse.fromserviceworker
+     */
+    fromServiceWorker() {
+        return this._data.fromServiceWorker;
+    }
+    /**
+     * The IP address and port number used to connect to the remote server.
+     * @see https://pptr.dev/api/puppeteer.httpresponse.remoteaddress
+     */
+    remoteAddress() {
+        return this._data.remoteAddress ?? { ip: undefined, port: undefined };
+    }
+    /**
+     * Security details if the response was received over HTTPS, null otherwise.
+     * @see https://pptr.dev/api/puppeteer.httpresponse.securitydetails
+     */
+    securityDetails() {
+        return this._data.securityDetails ?? null;
+    }
+    /**
+     * Timing information related to the response.
+     * @see https://pptr.dev/api/puppeteer.httpresponse.timing
+     */
+    timing() {
+        return this._data.timing ?? null;
+    }
+    /**
+     * Promise which resolves to a buffer with the response body.
+     * @see https://pptr.dev/api/puppeteer.httpresponse.buffer
+     */
+    async buffer() {
+        const base64 = await this.rpc('buffer', []);
+        return Buffer.from(base64, 'base64');
+    }
+    /**
+     * Promise which resolves to the response body as text.
+     * @see https://pptr.dev/api/puppeteer.httpresponse.text
+     */
+    async text() {
+        return this.rpc('text', []);
+    }
+    /**
+     * Promise which resolves to the response body as JSON.
+     * @throws Error if the response body cannot be parsed as JSON.
+     * @see https://pptr.dev/api/puppeteer.httpresponse.json
+     */
+    async json() {
+        return this.rpc('json', []);
+    }
+    /**
+     * Alias for text() - returns the response body as a string.
+     * Note: In real Puppeteer, content() is an internal method.
+     * This is provided for convenience.
+     */
+    async content() {
+        return this.text();
+    }
+    /**
+     * A matching HTTPRequest object for this response.
+     * @see https://pptr.dev/api/puppeteer.httpresponse.request
+     */
+    request() {
+        if (!this._data.requestId || !this._factories?.createRequest) {
+            return null;
+        }
+        return this._factories.createRequest(this._data.requestId);
+    }
+    /**
+     * The Frame that initiated this response, or null if navigating to error pages.
+     * @see https://pptr.dev/api/puppeteer.httpresponse.frame
+     */
+    frame() {
+        if (!this._data.frameId || !this._factories?.createFrame) {
+            return null;
+        }
+        return this._factories.createFrame(this._data.frameId);
+    }
+}

package/dist/drivers/puppeteer/generated/js-handle.d.ts

@@ -0,0 +1,104 @@
+/**
+ * AUTO-GENERATED FILE - DO NOT EDIT
+ *
+ * Generated from: packages/automation-spec/src/drivers/puppeteer/methods/puppeteer-methods.ts
+ * Run `pnpm generate:puppeteer` to regenerate.
+ */
+import type { RemotePuppeteerElementHandle } from './element-handle.js';
+/** RPC sender function type for JSHandle operations. */
+export type JSHandleRpcSender = <T = unknown>(method: string, args: unknown[]) => Promise<T>;
+/** Factory function to create new JSHandle instances. */
+export type JSHandleFactory = (handleId: string) => RemotePuppeteerJSHandle;
+/** Factory function to create ElementHandle instances (for asElement). */
+export type ElementHandleFactoryForJSHandle = (handleId: string) => RemotePuppeteerElementHandle;
+/** Serialized JSHandle response from backend. */
+export interface SerializedJSHandle {
+    __bctrl_type: 'JSHandle';
+    id: string;
+    handleType: 'JSHandle' | 'ElementHandle';
+}
+/** Type guard for serialized JSHandle responses. */
+export declare function isSerializedJSHandle(value: unknown): value is SerializedJSHandle;
+/**
+ * RemotePuppeteerJSHandle - Remote Puppeteer JSHandle API over RPC.
+ *
+ * @see https://pptr.dev/api/puppeteer.jshandle
+ */
+export declare class RemotePuppeteerJSHandle<T = unknown> {
+    readonly handleId: string;
+    protected sendRpc: JSHandleRpcSender;
+    protected createJSHandle: JSHandleFactory;
+    protected elementHandleFactory: ElementHandleFactoryForJSHandle | undefined;
+    constructor(handleId: string, sendRpc: JSHandleRpcSender, createJSHandle: JSHandleFactory, elementHandleFactory?: ElementHandleFactoryForJSHandle);
+    protected _disposed: boolean;
+    /**
+     * Check if this handle has been disposed.
+     */
+    get disposed(): boolean;
+    /**
+     * Internal RPC helper that checks disposed state.
+     */
+    protected rpc<R = unknown>(method: string, args: unknown[]): Promise<R>;
+    /**
+     * Evaluates the given function with the current handle as its first argument.
+     * @param pageFunction - Function to evaluate, receiving this handle's value as first arg.
+     * @param args - Additional arguments to pass to the function.
+     *
+     * @remarks
+     * The element/value referenced by this handle is passed as the first argument to the function.
+     *
+     * @example
+     * ```typescript
+     * const windowHandle = await page.evaluateHandle(() => window);
+     * const href = await windowHandle.evaluate(win => win.location.href);
+     * ```
+     *
+     * @see https://pptr.dev/api/puppeteer.jshandle.evaluate
+     */
+    evaluate<Params extends unknown[] = unknown[], Func extends (value: T, ...args: Params) => unknown = (value: T, ...args: Params) => unknown>(pageFunction: Func | string, ...args: unknown[]): Promise<Awaited<ReturnType<Func>>>;
+    /**
+     * Evaluates the given function with the current handle as its first argument and returns a new JSHandle.
+     * @param pageFunction - Function to evaluate, receiving this handle's value as first arg.
+     * @param args - Additional arguments to pass to the function.
+     *
+     * @example
+     * ```typescript
+     * const windowHandle = await page.evaluateHandle(() => window);
+     * const documentHandle = await windowHandle.evaluateHandle(win => win.document);
+     * ```
+     *
+     * @see https://pptr.dev/api/puppeteer.jshandle.evaluatehandle
+     */
+    evaluateHandle<Params extends unknown[] = unknown[], Func extends (value: T, ...args: Params) => unknown = (value: T, ...args: Params) => unknown>(pageFunction: Func | string, ...args: unknown[]): Promise<RemotePuppeteerJSHandle<Awaited<ReturnType<Func>>>>;
+    /**
+     * Fetches a single property from the referenced object.
+     * @param propertyName - The name of the property to fetch.
+     * @returns A JSHandle for the property value.
+     *
+     * @example
+     * ```typescript
+     * const handle = await page.evaluateHandle(() => ({ foo: 'bar' }));
+     * const fooHandle = await handle.getProperty('foo');
+     * console.log(await fooHandle.jsonValue()); // 'bar'
+     * ```
+     *
+     * @see https://pptr.dev/api/puppeteer.jshandle.getproperty
+     */
+    getProperty<K extends keyof T>(propertyName: K | string): Promise<RemotePuppeteerJSHandle<T[K]>>;
+    /**
+     * Returns a vanilla object representing the serializable portions of the referenced object.
+     *
+     * @remarks
+     * If the object has a `toJSON` function, it will **not** be called.
+     *
+     * @example
+     * ```typescript
+     * const handle = await page.evaluateHandle(() => ({ foo: 'bar' }));
+     * const value = await handle.jsonValue();
+     * console.log(value); // { foo: 'bar' }
+     * ```
+     *
+     * @see https://pptr.dev/api/puppeteer.jshandle.jsonvalue
+     */
+    jsonValue(): Promise<T>;
+}

package/dist/drivers/puppeteer/generated/js-handle.js

@@ -0,0 +1,125 @@
+/**
+ * AUTO-GENERATED FILE - DO NOT EDIT
+ *
+ * Generated from: packages/automation-spec/src/drivers/puppeteer/methods/puppeteer-methods.ts
+ * Run `pnpm generate:puppeteer` to regenerate.
+ */
+import { serializeFunctionSource } from '../../../internal/transport.js';
+/** Type guard for serialized JSHandle responses. */
+export function isSerializedJSHandle(value) {
+    return (value !== null &&
+        typeof value === 'object' &&
+        '__bctrl_type' in value &&
+        value.__bctrl_type === 'JSHandle' &&
+        'id' in value &&
+        typeof value.id === 'string' &&
+        'handleType' in value &&
+        typeof value.handleType === 'string');
+}
+/**
+ * RemotePuppeteerJSHandle - Remote Puppeteer JSHandle API over RPC.
+ *
+ * @see https://pptr.dev/api/puppeteer.jshandle
+ */
+export class RemotePuppeteerJSHandle {
+    handleId;
+    sendRpc;
+    createJSHandle;
+    elementHandleFactory;
+    constructor(handleId, sendRpc, createJSHandle, elementHandleFactory) {
+        this.handleId = handleId;
+        this.sendRpc = sendRpc;
+        this.createJSHandle = createJSHandle;
+        this.elementHandleFactory = elementHandleFactory;
+    }
+    _disposed = false;
+    /**
+     * Check if this handle has been disposed.
+     */
+    get disposed() {
+        return this._disposed;
+    }
+    /**
+     * Internal RPC helper that checks disposed state.
+     */
+    async rpc(method, args) {
+        if (this._disposed) {
+            throw new Error('JSHandle has been disposed');
+        }
+        return this.sendRpc(method, args);
+    }
+    /**
+     * Evaluates the given function with the current handle as its first argument.
+     * @param pageFunction - Function to evaluate, receiving this handle's value as first arg.
+     * @param args - Additional arguments to pass to the function.
+     *
+     * @remarks
+     * The element/value referenced by this handle is passed as the first argument to the function.
+     *
+     * @example
+     * ```typescript
+     * const windowHandle = await page.evaluateHandle(() => window);
+     * const href = await windowHandle.evaluate(win => win.location.href);
+     * ```
+     *
+     * @see https://pptr.dev/api/puppeteer.jshandle.evaluate
+     */
+    async evaluate(pageFunction, ...args) {
+        const _pageFunction = serializeFunctionSource(pageFunction);
+        return this.rpc('evaluate', [_pageFunction, ...args]);
+    }
+    /**
+     * Evaluates the given function with the current handle as its first argument and returns a new JSHandle.
+     * @param pageFunction - Function to evaluate, receiving this handle's value as first arg.
+     * @param args - Additional arguments to pass to the function.
+     *
+     * @example
+     * ```typescript
+     * const windowHandle = await page.evaluateHandle(() => window);
+     * const documentHandle = await windowHandle.evaluateHandle(win => win.document);
+     * ```
+     *
+     * @see https://pptr.dev/api/puppeteer.jshandle.evaluatehandle
+     */
+    async evaluateHandle(pageFunction, ...args) {
+        const _pageFunction = serializeFunctionSource(pageFunction);
+        const result = await this.rpc('evaluateHandle', [_pageFunction, ...args]);
+        return this.createJSHandle(result.id);
+    }
+    /**
+     * Fetches a single property from the referenced object.
+     * @param propertyName - The name of the property to fetch.
+     * @returns A JSHandle for the property value.
+     *
+     * @example
+     * ```typescript
+     * const handle = await page.evaluateHandle(() => ({ foo: 'bar' }));
+     * const fooHandle = await handle.getProperty('foo');
+     * console.log(await fooHandle.jsonValue()); // 'bar'
+     * ```
+     *
+     * @see https://pptr.dev/api/puppeteer.jshandle.getproperty
+     */
+    async getProperty(propertyName) {
+        const result = await this.rpc('getProperty', [propertyName]);
+        return this.createJSHandle(result.id);
+    }
+    /**
+     * Returns a vanilla object representing the serializable portions of the referenced object.
+     *
+     * @remarks
+     * If the object has a `toJSON` function, it will **not** be called.
+     *
+     * @example
+     * ```typescript
+     * const handle = await page.evaluateHandle(() => ({ foo: 'bar' }));
+     * const value = await handle.jsonValue();
+     * console.log(value); // { foo: 'bar' }
+     * ```
+     *
+     * @see https://pptr.dev/api/puppeteer.jshandle.jsonvalue
+     */
+    async jsonValue() {
+        return this.rpc('jsonValue', []);
+    }
+}

package/dist/drivers/puppeteer/generated/keyboard.d.ts

@@ -0,0 +1,79 @@
+/**
+ * AUTO-GENERATED FILE - DO NOT EDIT
+ *
+ * Generated from: packages/automation-spec/src/drivers/puppeteer/methods/puppeteer-methods.ts
+ * Run `pnpm generate:puppeteer` to regenerate.
+ */
+import type { SimpleRpcSender } from '../../../internal/transport.js';
+import { RemoteComponentBase } from '../remote-base.js';
+import type { PuppeteerKeyDownOptions, PuppeteerKeyInput, PuppeteerKeyPressOptions, PuppeteerKeyboardTypeOptions } from '../types.js';
+/**
+ * RemotePuppeteerKeyboard - Remote Puppeteer Keyboard API over RPC.
+ *
+ * @see https://pptr.dev/api/puppeteer.keyboard
+ */
+export declare class RemotePuppeteerKeyboard extends RemoteComponentBase {
+    constructor(sendRpc: SimpleRpcSender);
+    /**
+     * Dispatches a `keydown` event.
+     * @param key - Name of key to press, such as `ArrowLeft`.
+     * @param options - Options for the key down event.
+     *
+     * @remarks
+     * If `key` is a single character and no modifier keys besides `Shift` are being held down,
+     * a `keypress`/`input` event will also be generated. The `text` option can be specified
+     * to force an input event to be generated.
+     *
+     * Modifier keys DO affect `keyboard.down`. Holding down `Shift` will type the text in upper case.
+     *
+     * @see https://pptr.dev/api/puppeteer.keyboard.down
+     */
+    down(key: PuppeteerKeyInput, options?: PuppeteerKeyDownOptions): Promise<void>;
+    /**
+     * Dispatches a `keyup` event.
+     * @param key - Name of key to release, such as `ArrowLeft`.
+     *
+     * @see https://pptr.dev/api/puppeteer.keyboard.up
+     */
+    up(key: PuppeteerKeyInput): Promise<void>;
+    /**
+     * Shortcut for `Keyboard.down` and `Keyboard.up`.
+     * @param key - Name of key to press, such as `ArrowLeft`.
+     * @param options - Options for the key press event including `delay`, `text`, and `commands`.
+     *
+     * @remarks
+     * If `key` is a single character and no modifier keys besides `Shift` are being held down,
+     * a `keypress`/`input` event will also be generated. The `text` option can be specified
+     * to force an input event to be generated.
+     *
+     * Modifier keys DO affect `keyboard.press`. Holding down `Shift` will type the text in upper case.
+     *
+     * @see https://pptr.dev/api/puppeteer.keyboard.press
+     */
+    press(key: PuppeteerKeyInput, options?: PuppeteerKeyPressOptions): Promise<void>;
+    /**
+     * Dispatches a `keypress` and `input` event. This does not send a `keydown` or `keyup` event.
+     * @param char - Character to send into the page.
+     *
+     * @remarks
+     * Modifier keys DO NOT affect `keyboard.sendCharacter`. Holding down `Shift` will not
+     * type the text in upper case.
+     *
+     * @see https://pptr.dev/api/puppeteer.keyboard.sendcharacter
+     */
+    sendCharacter(char: string): Promise<void>;
+    /**
+     * Sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the text.
+     * @param text - A text to type into a focused element.
+     * @param options - Options for typing including `delay` between key presses.
+     *
+     * @remarks
+     * To press a special key, like `Control` or `ArrowDown`, use `Keyboard.press`.
+     *
+     * Modifier keys DO NOT affect `keyboard.type`. Holding down `Shift` will not type the text
+     * in upper case.
+     *
+     * @see https://pptr.dev/api/puppeteer.keyboard.type
+     */
+    type(text: string, options?: PuppeteerKeyboardTypeOptions): Promise<void>;
+}

package/dist/drivers/puppeteer/generated/keyboard.js

@@ -0,0 +1,89 @@
+/**
+ * AUTO-GENERATED FILE - DO NOT EDIT
+ *
+ * Generated from: packages/automation-spec/src/drivers/puppeteer/methods/puppeteer-methods.ts
+ * Run `pnpm generate:puppeteer` to regenerate.
+ */
+import { RemoteComponentBase } from '../remote-base.js';
+/**
+ * RemotePuppeteerKeyboard - Remote Puppeteer Keyboard API over RPC.
+ *
+ * @see https://pptr.dev/api/puppeteer.keyboard
+ */
+export class RemotePuppeteerKeyboard extends RemoteComponentBase {
+    constructor(sendRpc) {
+        super(sendRpc);
+    }
+    /**
+     * Dispatches a `keydown` event.
+     * @param key - Name of key to press, such as `ArrowLeft`.
+     * @param options - Options for the key down event.
+     *
+     * @remarks
+     * If `key` is a single character and no modifier keys besides `Shift` are being held down,
+     * a `keypress`/`input` event will also be generated. The `text` option can be specified
+     * to force an input event to be generated.
+     *
+     * Modifier keys DO affect `keyboard.down`. Holding down `Shift` will type the text in upper case.
+     *
+     * @see https://pptr.dev/api/puppeteer.keyboard.down
+     */
+    async down(key, options) {
+        await this.rpc('keyboard.down', [key, options]);
+    }
+    /**
+     * Dispatches a `keyup` event.
+     * @param key - Name of key to release, such as `ArrowLeft`.
+     *
+     * @see https://pptr.dev/api/puppeteer.keyboard.up
+     */
+    async up(key) {
+        await this.rpc('keyboard.up', [key]);
+    }
+    /**
+     * Shortcut for `Keyboard.down` and `Keyboard.up`.
+     * @param key - Name of key to press, such as `ArrowLeft`.
+     * @param options - Options for the key press event including `delay`, `text`, and `commands`.
+     *
+     * @remarks
+     * If `key` is a single character and no modifier keys besides `Shift` are being held down,
+     * a `keypress`/`input` event will also be generated. The `text` option can be specified
+     * to force an input event to be generated.
+     *
+     * Modifier keys DO affect `keyboard.press`. Holding down `Shift` will type the text in upper case.
+     *
+     * @see https://pptr.dev/api/puppeteer.keyboard.press
+     */
+    async press(key, options) {
+        await this.rpc('keyboard.press', [key, options]);
+    }
+    /**
+     * Dispatches a `keypress` and `input` event. This does not send a `keydown` or `keyup` event.
+     * @param char - Character to send into the page.
+     *
+     * @remarks
+     * Modifier keys DO NOT affect `keyboard.sendCharacter`. Holding down `Shift` will not
+     * type the text in upper case.
+     *
+     * @see https://pptr.dev/api/puppeteer.keyboard.sendcharacter
+     */
+    async sendCharacter(char) {
+        await this.rpc('keyboard.sendCharacter', [char]);
+    }
+    /**
+     * Sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the text.
+     * @param text - A text to type into a focused element.
+     * @param options - Options for typing including `delay` between key presses.
+     *
+     * @remarks
+     * To press a special key, like `Control` or `ArrowDown`, use `Keyboard.press`.
+     *
+     * Modifier keys DO NOT affect `keyboard.type`. Holding down `Shift` will not type the text
+     * in upper case.
+     *
+     * @see https://pptr.dev/api/puppeteer.keyboard.type
+     */
+    async type(text, options) {
+        await this.rpc('keyboard.type', [text, options]);
+    }
+}