@bctrl/sdk 1.0.1

package/dist/drivers/playwright/generated/element-handle.js

@@ -0,0 +1,501 @@
+/**
+ * AUTO-GENERATED FILE - DO NOT EDIT
+ *
+ * Generated from: packages/automation-spec/src/drivers/playwright/methods/
+ * Run `pnpm generate:playwright` to regenerate.
+ */
+import { serializeFunctionSource, } from '../../../internal/transport.js';
+import { RemoteBase } from '../remote-base.js';
+/**
+ * RemotePlaywrightElementHandle - Remote Playwright ElementHandle API over RPC.
+ *
+ * @see https://playwright.dev/docs/api/class-elementhandle
+ */
+export class RemotePlaywrightElementHandle extends RemoteBase {
+    createElementHandle;
+    createFrame;
+    createJSHandle;
+    constructor(id, sendRpc, createElementHandle, createFrame, createJSHandle) {
+        super(id, sendRpc);
+        this.createElementHandle = createElementHandle;
+        this.createFrame = createFrame;
+        this.createJSHandle = createJSHandle;
+    }
+    /**
+     * Return this handle as an ElementHandle.
+     * Since this is already an ElementHandle, returns itself.
+     * @see https://playwright.dev/docs/api/class-jshandle#js-handle-as-element
+     */
+    asElement() {
+        return this;
+    }
+    /**
+     * Click the element.
+     *
+     * @remarks
+     * This method clicks the element by performing actionability checks, scrolling into view, and simulating a mouse click. Discouraged in favor of locator.click().
+     *
+     * @see https://playwright.dev/docs/api/class-elementhandle#element-handle-click
+     */
+    async click(options) {
+        await this.rpc('click', [options]);
+    }
+    /**
+     * Double-click the element.
+     *
+     * @remarks
+     * Discouraged in favor of locator.dblclick().
+     *
+     * @see https://playwright.dev/docs/api/class-elementhandle#element-handle-dblclick
+     */
+    async dblclick(options) {
+        await this.rpc('dblclick', [options]);
+    }
+    /**
+     * Fill an input, textarea, or contenteditable element with the specified value.
+     *
+     * @remarks
+     * This method waits for actionability checks, focuses the element, fills it, and triggers an input event. Pass empty string to clear. Discouraged in favor of locator.fill().
+     *
+     * @see https://playwright.dev/docs/api/class-elementhandle#element-handle-fill
+     */
+    async fill(value, options) {
+        await this.rpc('fill', [value, options]);
+    }
+    /**
+     * Focus the element and type text into it character by character.
+     *
+     * @remarks
+     * Deprecated: In most cases use locator.fill() instead. Only use this for special keyboard handling. For special keys use press().
+     *
+     * @see https://playwright.dev/docs/api/class-elementhandle#element-handle-type
+     */
+    async type(text, options) {
+        await this.rpc('type', [text, options]);
+    }
+    /**
+     * Focus the element and press a key or key combination.
+     *
+     * @remarks
+     * Key can be a single character or a special key like "Enter", "Control+a", "Shift+ArrowDown". Discouraged in favor of locator.press().
+     *
+     * @see https://playwright.dev/docs/api/class-elementhandle#element-handle-press
+     */
+    async press(key, options) {
+        await this.rpc('press', [key, options]);
+    }
+    /**
+     * Hover over the element.
+     *
+     * @remarks
+     * This method hovers over the element by performing actionability checks, scrolling into view, and simulating mouse hover. Discouraged in favor of locator.hover().
+     *
+     * @see https://playwright.dev/docs/api/class-elementhandle#element-handle-hover
+     */
+    async hover(options) {
+        await this.rpc('hover', [options]);
+    }
+    /**
+     * Focus the element.
+     *
+     * @remarks
+     * Discouraged in favor of locator.focus().
+     *
+     * @see https://playwright.dev/docs/api/class-elementhandle#element-handle-focus
+     */
+    async focus() {
+        await this.rpc('focus', []);
+    }
+    /**
+     * Tap the element (for touch devices).
+     *
+     * @remarks
+     * This method taps the element by performing actionability checks, scrolling into view, centering, and dispatching touchstart/touchend events. Discouraged in favor of locator.tap().
+     *
+     * @see https://playwright.dev/docs/api/class-elementhandle#element-handle-tap
+     */
+    async tap(options) {
+        await this.rpc('tap', [options]);
+    }
+    /**
+     * Check a checkbox or radio element.
+     *
+     * @remarks
+     * If the element is already checked, this method returns immediately. Discouraged in favor of locator.check().
+     *
+     * @see https://playwright.dev/docs/api/class-elementhandle#element-handle-check
+     */
+    async check(options) {
+        await this.rpc('check', [options]);
+    }
+    /**
+     * Uncheck a checkbox element.
+     *
+     * @remarks
+     * If the element is already unchecked, this method returns immediately. Discouraged in favor of locator.uncheck().
+     *
+     * @see https://playwright.dev/docs/api/class-elementhandle#element-handle-uncheck
+     */
+    async uncheck(options) {
+        await this.rpc('uncheck', [options]);
+    }
+    /**
+     * Check or uncheck a checkbox or radio element.
+     *
+     * @remarks
+     * Discouraged in favor of locator.setChecked().
+     *
+     * @see https://playwright.dev/docs/api/class-elementhandle#element-handle-set-checked
+     */
+    async setChecked(checked, options) {
+        await this.rpc('setChecked', [checked, options]);
+    }
+    /**
+     * Select one or more options in a <select> element.
+     * @param values - Options to select. Can be value, label, or option object.
+     * @returns An array of selected option values.
+     *
+     * @remarks
+     * Discouraged in favor of locator.selectOption().
+     *
+     * @see https://playwright.dev/docs/api/class-elementhandle#element-handle-select-option
+     */
+    async selectOption(values, options) {
+        return this.rpc('selectOption', [values, options]);
+    }
+    /**
+     * Set the files for a file input element.
+     * @param files - File paths or file payloads to upload.
+     *
+     * @remarks
+     * Sets the value of the file input to these file paths or files. If some paths are relative, they are resolved relative to the current working directory. Clears selected files if empty array is passed. Discouraged in favor of locator.setInputFiles().
+     *
+     * @see https://playwright.dev/docs/api/class-elementhandle#element-handle-set-input-files
+     */
+    async setInputFiles(files, options) {
+        await this.rpc('setInputFiles', [files, options]);
+    }
+    /**
+     * Scroll the element into view if not already visible.
+     *
+     * @remarks
+     * If the element is detached from DOM, throws an error. Discouraged in favor of locator.scrollIntoViewIfNeeded().
+     *
+     * @see https://playwright.dev/docs/api/class-elementhandle#element-handle-scroll-into-view-if-needed
+     */
+    async scrollIntoViewIfNeeded(options) {
+        await this.rpc('scrollIntoViewIfNeeded', [options]);
+    }
+    /**
+     * Dispatch a DOM event on the element.
+     * @param type - DOM event type, e.g., "click".
+     * @param eventInit - Event-specific initialization properties.
+     *
+     * @remarks
+     * The event is composed, cancelable and bubbles by default. Regardless of visibility, this will dispatch the event. Discouraged in favor of locator.dispatchEvent().
+     *
+     * @see https://playwright.dev/docs/api/class-elementhandle#element-handle-dispatch-event
+     */
+    async dispatchEvent(type, eventInit) {
+        await this.rpc('dispatchEvent', [type, eventInit]);
+    }
+    /**
+     * Get the innerHTML of the element.
+     *
+     * @remarks
+     * Discouraged in favor of locator.innerHTML().
+     *
+     * @see https://playwright.dev/docs/api/class-elementhandle#element-handle-inner-html
+     */
+    async innerHTML() {
+        return this.rpc('innerHTML', []);
+    }
+    /**
+     * Get the innerText of the element.
+     *
+     * @remarks
+     * Discouraged in favor of locator.innerText().
+     *
+     * @see https://playwright.dev/docs/api/class-elementhandle#element-handle-inner-text
+     */
+    async innerText() {
+        return this.rpc('innerText', []);
+    }
+    /**
+     * Get the textContent of the element.
+     *
+     * @remarks
+     * Discouraged in favor of locator.textContent().
+     *
+     * @see https://playwright.dev/docs/api/class-elementhandle#element-handle-text-content
+     */
+    async textContent() {
+        return this.rpc('textContent', []);
+    }
+    /**
+     * Get an attribute value of the element.
+     * @param name - Attribute name to get.
+     *
+     * @remarks
+     * Discouraged in favor of locator.getAttribute().
+     *
+     * @see https://playwright.dev/docs/api/class-elementhandle#element-handle-get-attribute
+     */
+    async getAttribute(name) {
+        return this.rpc('getAttribute', [name]);
+    }
+    /**
+     * Get the input value for input, textarea, or select elements.
+     *
+     * @remarks
+     * Throws for non-input elements. Discouraged in favor of locator.inputValue().
+     *
+     * @see https://playwright.dev/docs/api/class-elementhandle#element-handle-input-value
+     */
+    async inputValue(options) {
+        return this.rpc('inputValue', [options]);
+    }
+    /**
+     * Check if the element is visible.
+     *
+     * @remarks
+     * Returns true if element is visible. Non-attached elements return false. Discouraged in favor of locator.isVisible().
+     *
+     * @see https://playwright.dev/docs/api/class-elementhandle#element-handle-is-visible
+     */
+    async isVisible() {
+        return this.rpc('isVisible', []);
+    }
+    /**
+     * Check if the element is hidden.
+     *
+     * @remarks
+     * Returns true if element is hidden. Non-attached elements return true. Discouraged in favor of locator.isHidden().
+     *
+     * @see https://playwright.dev/docs/api/class-elementhandle#element-handle-is-hidden
+     */
+    async isHidden() {
+        return this.rpc('isHidden', []);
+    }
+    /**
+     * Check if the element is enabled.
+     *
+     * @remarks
+     * Discouraged in favor of locator.isEnabled().
+     *
+     * @see https://playwright.dev/docs/api/class-elementhandle#element-handle-is-enabled
+     */
+    async isEnabled() {
+        return this.rpc('isEnabled', []);
+    }
+    /**
+     * Check if the element is disabled.
+     *
+     * @remarks
+     * Discouraged in favor of locator.isDisabled().
+     *
+     * @see https://playwright.dev/docs/api/class-elementhandle#element-handle-is-disabled
+     */
+    async isDisabled() {
+        return this.rpc('isDisabled', []);
+    }
+    /**
+     * Check if a checkbox or radio is checked.
+     *
+     * @remarks
+     * Throws if element is not a checkbox or radio. Discouraged in favor of locator.isChecked().
+     *
+     * @see https://playwright.dev/docs/api/class-elementhandle#element-handle-is-checked
+     */
+    async isChecked() {
+        return this.rpc('isChecked', []);
+    }
+    /**
+     * Check if the element is editable.
+     *
+     * @remarks
+     * Discouraged in favor of locator.isEditable().
+     *
+     * @see https://playwright.dev/docs/api/class-elementhandle#element-handle-is-editable
+     */
+    async isEditable() {
+        return this.rpc('isEditable', []);
+    }
+    /**
+     * Get the bounding box of the element.
+     * @returns Bounding box with x, y, width, height, or null if element is not visible.
+     *
+     * @remarks
+     * Discouraged in favor of locator.boundingBox().
+     *
+     * @see https://playwright.dev/docs/api/class-elementhandle#element-handle-bounding-box
+     */
+    async boundingBox() {
+        return this.rpc('boundingBox', []);
+    }
+    /**
+     * Get the content frame for iframe elements.
+     * @returns The frame content, or null if not an iframe.
+     *
+     * @see https://playwright.dev/docs/api/class-elementhandle#element-handle-content-frame
+     */
+    async contentFrame() {
+        const result = await this.rpc('contentFrame', []);
+        if (!result)
+            return null;
+        return this.createFrame(result.id);
+    }
+    /**
+     * Get the frame that owns this element.
+     * @returns The owner frame, or null if element is detached.
+     *
+     * @see https://playwright.dev/docs/api/class-elementhandle#element-handle-owner-frame
+     */
+    async ownerFrame() {
+        const result = await this.rpc('ownerFrame', []);
+        if (!result)
+            return null;
+        return this.createFrame(result.id);
+    }
+    /**
+     * Evaluate a function in the context of the element.
+     * @param pageFunction - Function or string to evaluate in the page context.
+     * @param arg - Argument to pass to the function.
+     *
+     * @remarks
+     * The element is passed as the first argument to the function. If the function returns a Promise, it will be awaited.
+     *
+     * @see https://playwright.dev/docs/api/class-elementhandle#element-handle-evaluate
+     */
+    async evaluate(pageFunction, arg) {
+        const _pageFunction = serializeFunctionSource(pageFunction);
+        return this.rpc('evaluate', [_pageFunction, arg]);
+    }
+    /**
+     * Evaluate a function and return a JSHandle to the result.
+     * @param pageFunction - Function or string to evaluate in the page context.
+     * @param arg - Argument to pass to the function.
+     *
+     * @remarks
+     * The element is passed as the first argument. Note: Returns serialized handle reference. Full JSHandle support not yet available.
+     *
+     * @see https://playwright.dev/docs/api/class-elementhandle#element-handle-evaluate-handle
+     */
+    async evaluateHandle(pageFunction, arg) {
+        const _pageFunction = serializeFunctionSource(pageFunction);
+        return this.rpc('evaluateHandle', [_pageFunction, arg]);
+    }
+    /**
+     * Query for a child element matching the selector.
+     * @returns The matching element or null if not found.
+     *
+     * @remarks
+     * Discouraged in favor of locator-based locator.locator().
+     *
+     * @see https://playwright.dev/docs/api/class-elementhandle#element-handle-query-selector
+     */
+    async $(selector) {
+        const result = await this.rpc('$', [selector]);
+        if (!result)
+            return null;
+        return this.createElementHandle(result.id);
+    }
+    /**
+     * Query for all child elements matching the selector.
+     * @returns An array of matching elements.
+     *
+     * @remarks
+     * Discouraged in favor of locator-based locator.locator().
+     *
+     * @see https://playwright.dev/docs/api/class-elementhandle#element-handle-query-selector-all
+     */
+    async $$(selector) {
+        const results = await this.rpc('$$', [selector]);
+        return results.map((r) => this.createElementHandle(r.id));
+    }
+    /**
+     * Evaluate a function on a child element matching the selector.
+     *
+     * @remarks
+     * Throws if no element matches. Discouraged in favor of locator.evaluate().
+     *
+     * @see https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector
+     */
+    async $eval(selector, pageFunction, arg) {
+        const _pageFunction = serializeFunctionSource(pageFunction);
+        return this.rpc('$eval', [selector, _pageFunction, arg]);
+    }
+    /**
+     * Evaluate a function on all child elements matching the selector.
+     *
+     * @remarks
+     * Discouraged in favor of locator.evaluateAll().
+     *
+     * @see https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector-all
+     */
+    async $$eval(selector, pageFunction, arg) {
+        const _pageFunction = serializeFunctionSource(pageFunction);
+        return this.rpc('$$eval', [selector, _pageFunction, arg]);
+    }
+    /**
+     * Wait for the element to reach a specific state.
+     * @param state - State to wait for: "visible", "hidden", "stable", "enabled", or "disabled".
+     *
+     * @remarks
+     * Discouraged in favor of web-first assertions.
+     *
+     * @see https://playwright.dev/docs/api/class-elementhandle#element-handle-wait-for-element-state
+     */
+    async waitForElementState(state, options) {
+        await this.rpc('waitForElementState', [state, options]);
+    }
+    /**
+     * Wait for a child element matching the selector.
+     * @returns The matching element, or null if waiting for hidden/detached.
+     *
+     * @remarks
+     * Discouraged in favor of locator-based assertions.
+     *
+     * @see https://playwright.dev/docs/api/class-elementhandle#element-handle-wait-for-selector
+     */
+    async waitForSelector(selector, options) {
+        const result = await this.rpc('waitForSelector', [selector, options]);
+        if (!result)
+            return null;
+        return this.createElementHandle(result.id);
+    }
+    /**
+     * Dispose of the handle, releasing it from the browser.
+     *
+     * @remarks
+     * After disposal, any method calls will throw. The SDK sets the disposed flag before the RPC call to prevent race conditions.
+     *
+     * @see https://playwright.dev/docs/api/class-jshandle#js-handle-dispose
+     */
+    async dispose() {
+        await this.rpc('dispose', []);
+        this.markClosed();
+    }
+    /**
+     * Get a JSHandle for a property of this element.
+     *
+     * @remarks
+     * Note: Returns serialized handle reference. Full JSHandle support not yet available.
+     *
+     * @see https://playwright.dev/docs/api/class-jshandle#js-handle-get-property
+     */
+    async getProperty(propertyName) {
+        return this.rpc('getProperty', [propertyName]);
+    }
+    /**
+     * Get the JSON value of the element.
+     *
+     * @remarks
+     * Throws if the object cannot be serialized to JSON (e.g., DOM nodes).
+     *
+     * @see https://playwright.dev/docs/api/class-jshandle#js-handle-json-value
+     */
+    async jsonValue() {
+        return this.rpc('jsonValue', []);
+    }
+}

package/dist/drivers/playwright/generated/frame-locator.d.ts

@@ -0,0 +1,34 @@
+/**
+ * AUTO-GENERATED FILE - DO NOT EDIT
+ *
+ * Generated from: packages/automation-spec/src/drivers/playwright/methods/
+ * Run `pnpm generate:playwright` to regenerate.
+ */
+import type { SimpleRpcSender } from '../../../internal/transport.js';
+import type { PlaywrightAriaRole, PlaywrightGetByRoleOptions, PlaywrightGetByTextOptions, PlaywrightGetByLabelOptions, PlaywrightGetByPlaceholderOptions, PlaywrightGetByAltTextOptions, PlaywrightGetByTitleOptions } from '../types.js';
+import { RemoteComponentBase } from '../remote-base.js';
+import type { RemotePlaywrightLocator } from './locator.js';
+/**
+ * RemotePlaywrightFrameLocator - Remote Playwright FrameLocator API over RPC.
+ *
+ * @see https://playwright.dev/docs/api/class-framelocator
+ */
+export declare class RemotePlaywrightFrameLocator extends RemoteComponentBase {
+    private frameSelector;
+    private createLocator;
+    constructor(sendRpc: SimpleRpcSender, frameSelector: string, createLocator: (selector: string) => RemotePlaywrightLocator);
+    private scoped;
+    locator(selector: string): RemotePlaywrightLocator;
+    getByRole(role: PlaywrightAriaRole, options?: PlaywrightGetByRoleOptions): RemotePlaywrightLocator;
+    getByText(text: string | RegExp, options?: PlaywrightGetByTextOptions): RemotePlaywrightLocator;
+    getByLabel(text: string | RegExp, options?: PlaywrightGetByLabelOptions): RemotePlaywrightLocator;
+    getByPlaceholder(text: string | RegExp, options?: PlaywrightGetByPlaceholderOptions): RemotePlaywrightLocator;
+    getByAltText(text: string | RegExp, options?: PlaywrightGetByAltTextOptions): RemotePlaywrightLocator;
+    getByTitle(text: string | RegExp, options?: PlaywrightGetByTitleOptions): RemotePlaywrightLocator;
+    getByTestId(testId: string | RegExp): RemotePlaywrightLocator;
+    first(): RemotePlaywrightFrameLocator;
+    last(): RemotePlaywrightFrameLocator;
+    nth(index: number): RemotePlaywrightFrameLocator;
+    frameLocator(selector: string): RemotePlaywrightFrameLocator;
+    owner(): RemotePlaywrightLocator;
+}

package/dist/drivers/playwright/generated/frame-locator.js

@@ -0,0 +1,63 @@
+/**
+ * AUTO-GENERATED FILE - DO NOT EDIT
+ *
+ * Generated from: packages/automation-spec/src/drivers/playwright/methods/
+ * Run `pnpm generate:playwright` to regenerate.
+ */
+import { RemoteComponentBase } from '../remote-base.js';
+/**
+ * RemotePlaywrightFrameLocator - Remote Playwright FrameLocator API over RPC.
+ *
+ * @see https://playwright.dev/docs/api/class-framelocator
+ */
+export class RemotePlaywrightFrameLocator extends RemoteComponentBase {
+    frameSelector;
+    createLocator;
+    constructor(sendRpc, frameSelector, createLocator) {
+        super(sendRpc);
+        this.frameSelector = frameSelector;
+        this.createLocator = createLocator;
+    }
+    scoped(selector) {
+        return `${this.frameSelector} >> ${selector}`;
+    }
+    locator(selector) {
+        return this.createLocator(this.scoped(selector));
+    }
+    getByRole(role, options) {
+        return this.createLocator(this.frameSelector).getByRole(role, options);
+    }
+    getByText(text, options) {
+        return this.createLocator(this.frameSelector).getByText(text, options);
+    }
+    getByLabel(text, options) {
+        return this.createLocator(this.frameSelector).getByLabel(text, options);
+    }
+    getByPlaceholder(text, options) {
+        return this.createLocator(this.frameSelector).getByPlaceholder(text, options);
+    }
+    getByAltText(text, options) {
+        return this.createLocator(this.frameSelector).getByAltText(text, options);
+    }
+    getByTitle(text, options) {
+        return this.createLocator(this.frameSelector).getByTitle(text, options);
+    }
+    getByTestId(testId) {
+        return this.createLocator(this.frameSelector).getByTestId(testId);
+    }
+    first() {
+        return this.nth(0);
+    }
+    last() {
+        return new RemotePlaywrightFrameLocator(this.sendRpc, this.scoped('nth=-1'), this.createLocator);
+    }
+    nth(index) {
+        return new RemotePlaywrightFrameLocator(this.sendRpc, this.scoped(`nth=${index}`), this.createLocator);
+    }
+    frameLocator(selector) {
+        return new RemotePlaywrightFrameLocator(this.sendRpc, this.scoped(selector), this.createLocator);
+    }
+    owner() {
+        return this.createLocator(this.frameSelector);
+    }
+}