From f96c3c3175e9b7cc5f70adac8034932a8ed83529 Mon Sep 17 00:00:00 2001 From: Roman Kuznetsov Date: Mon, 8 Jun 2026 10:02:29 +0300 Subject: [PATCH] feat: add bidi client --- .eslintrc.js | 8 + src/browser/bidi/connection.ts | 211 ++++++++ src/browser/bidi/constants.ts | 5 + src/browser/bidi/debug.ts | 3 + src/browser/bidi/emitter.ts | 41 ++ src/browser/bidi/error.ts | 52 ++ src/browser/bidi/index.ts | 78 +++ src/browser/bidi/modules/browser.ts | 77 +++ src/browser/bidi/modules/browsing-context.ts | 186 +++++++ src/browser/bidi/modules/emulation.ts | 133 +++++ src/browser/bidi/modules/input.ts | 47 ++ src/browser/bidi/modules/log.ts | 9 + src/browser/bidi/modules/network.ts | 147 ++++++ src/browser/bidi/modules/script.ts | 80 +++ src/browser/bidi/modules/session.ts | 55 ++ src/browser/bidi/modules/storage.ts | 39 ++ src/browser/bidi/modules/web-extension.ts | 30 ++ .../types/command-data/browser-command.ts | 92 ++++ .../command-data/browsing-context-command.ts | 282 ++++++++++ .../types/command-data/emulation-command.ts | 208 ++++++++ src/browser/bidi/types/command-data/index.ts | 31 ++ .../bidi/types/command-data/input-command.ts | 45 ++ .../types/command-data/network-command.ts | 218 ++++++++ .../bidi/types/command-data/script-command.ts | 105 ++++ .../types/command-data/session-command.ts | 55 ++ .../types/command-data/storage-command.ts | 88 ++++ .../command-data/web-extension-command.ts | 50 ++ .../event-data/browsing-context-event.ts | 163 ++++++ src/browser/bidi/types/event-data/index.ts | 19 + .../bidi/types/event-data/input-event.ts | 20 + .../bidi/types/event-data/log-event.ts | 10 + .../bidi/types/event-data/network-event.ts | 64 +++ .../bidi/types/event-data/script-event.ts | 40 ++ src/browser/bidi/types/generic.ts | 10 + src/browser/bidi/types/index.ts | 72 +++ src/browser/bidi/types/modules/browser.ts | 37 ++ .../bidi/types/modules/browsing-context.ts | 92 ++++ src/browser/bidi/types/modules/index.ts | 9 + src/browser/bidi/types/modules/input.ts | 132 +++++ src/browser/bidi/types/modules/log.ts | 34 ++ src/browser/bidi/types/modules/network.ts | 180 +++++++ src/browser/bidi/types/modules/script.ts | 492 ++++++++++++++++++ src/browser/bidi/types/modules/session.ts | 97 ++++ src/browser/bidi/types/modules/storage.ts | 5 + .../bidi/types/modules/web-extension.ts | 2 + .../bidi/types/result-data/browser-result.ts | 37 ++ .../result-data/browsing-context-result.ts | 92 ++++ .../types/result-data/emulation-result.ts | 46 ++ src/browser/bidi/types/result-data/index.ts | 31 ++ .../bidi/types/result-data/input-result.ts | 13 + .../bidi/types/result-data/network-result.ts | 63 +++ .../bidi/types/result-data/script-result.ts | 30 ++ .../bidi/types/result-data/session-result.ts | 47 ++ .../bidi/types/result-data/storage-result.ts | 24 + .../types/result-data/web-extension-result.ts | 13 + src/browser/cdp/error.ts | 2 +- src/browser/existing-browser.ts | 9 + src/ws-connection/error.ts | 6 +- 58 files changed, 4262 insertions(+), 4 deletions(-) create mode 100644 src/browser/bidi/connection.ts create mode 100644 src/browser/bidi/constants.ts create mode 100644 src/browser/bidi/debug.ts create mode 100644 src/browser/bidi/emitter.ts create mode 100644 src/browser/bidi/error.ts create mode 100644 src/browser/bidi/index.ts create mode 100644 src/browser/bidi/modules/browser.ts create mode 100644 src/browser/bidi/modules/browsing-context.ts create mode 100644 src/browser/bidi/modules/emulation.ts create mode 100644 src/browser/bidi/modules/input.ts create mode 100644 src/browser/bidi/modules/log.ts create mode 100644 src/browser/bidi/modules/network.ts create mode 100644 src/browser/bidi/modules/script.ts create mode 100644 src/browser/bidi/modules/session.ts create mode 100644 src/browser/bidi/modules/storage.ts create mode 100644 src/browser/bidi/modules/web-extension.ts create mode 100644 src/browser/bidi/types/command-data/browser-command.ts create mode 100644 src/browser/bidi/types/command-data/browsing-context-command.ts create mode 100644 src/browser/bidi/types/command-data/emulation-command.ts create mode 100644 src/browser/bidi/types/command-data/index.ts create mode 100644 src/browser/bidi/types/command-data/input-command.ts create mode 100644 src/browser/bidi/types/command-data/network-command.ts create mode 100644 src/browser/bidi/types/command-data/script-command.ts create mode 100644 src/browser/bidi/types/command-data/session-command.ts create mode 100644 src/browser/bidi/types/command-data/storage-command.ts create mode 100644 src/browser/bidi/types/command-data/web-extension-command.ts create mode 100644 src/browser/bidi/types/event-data/browsing-context-event.ts create mode 100644 src/browser/bidi/types/event-data/index.ts create mode 100644 src/browser/bidi/types/event-data/input-event.ts create mode 100644 src/browser/bidi/types/event-data/log-event.ts create mode 100644 src/browser/bidi/types/event-data/network-event.ts create mode 100644 src/browser/bidi/types/event-data/script-event.ts create mode 100644 src/browser/bidi/types/generic.ts create mode 100644 src/browser/bidi/types/index.ts create mode 100644 src/browser/bidi/types/modules/browser.ts create mode 100644 src/browser/bidi/types/modules/browsing-context.ts create mode 100644 src/browser/bidi/types/modules/index.ts create mode 100644 src/browser/bidi/types/modules/input.ts create mode 100644 src/browser/bidi/types/modules/log.ts create mode 100644 src/browser/bidi/types/modules/network.ts create mode 100644 src/browser/bidi/types/modules/script.ts create mode 100644 src/browser/bidi/types/modules/session.ts create mode 100644 src/browser/bidi/types/modules/storage.ts create mode 100644 src/browser/bidi/types/modules/web-extension.ts create mode 100644 src/browser/bidi/types/result-data/browser-result.ts create mode 100644 src/browser/bidi/types/result-data/browsing-context-result.ts create mode 100644 src/browser/bidi/types/result-data/emulation-result.ts create mode 100644 src/browser/bidi/types/result-data/index.ts create mode 100644 src/browser/bidi/types/result-data/input-result.ts create mode 100644 src/browser/bidi/types/result-data/network-result.ts create mode 100644 src/browser/bidi/types/result-data/script-result.ts create mode 100644 src/browser/bidi/types/result-data/session-result.ts create mode 100644 src/browser/bidi/types/result-data/storage-result.ts create mode 100644 src/browser/bidi/types/result-data/web-extension-result.ts diff --git a/.eslintrc.js b/.eslintrc.js index 89a2aae12..e7ef1c12f 100644 --- a/.eslintrc.js +++ b/.eslintrc.js @@ -20,6 +20,14 @@ module.exports = { "@typescript-eslint/no-var-requires": "off", }, }, + { + // Generated 1:1 WebDriver BiDi protocol typings contain forward and recursive + // type references, which TypeScript hoists safely. + files: ["src/browser/bidi/types/**/*.ts"], + rules: { + "no-use-before-define": "off", + }, + }, { files: ["test/**"], rules: { diff --git a/src/browser/bidi/connection.ts b/src/browser/bidi/connection.ts new file mode 100644 index 000000000..d91476d00 --- /dev/null +++ b/src/browser/bidi/connection.ts @@ -0,0 +1,211 @@ +import type { RawData } from "ws"; +import { inspect } from "node:util"; +import { debugBidi } from "./debug"; +import { + BIDIConnectionBreakError, + BIDIConnectionEstablishmentError, + BIDIConnectionTerminatedError, + BIDIConnectionTimeoutError, + BIDIRequestError, + BIDIRequestTimeoutError, +} from "./error"; +import { + BIDI_CONNECTION_RETRIES, + BIDI_CONNECTION_RETRY_BASE_DELAY, + BIDI_CONNECTION_TIMEOUT, + BIDI_REQUEST_RETRIES, + BIDI_REQUEST_RETRY_BASE_DELAY, +} from "./constants"; +import type { BiDiMessage, BiDiEvent, BiDiCommand } from "./types"; +import type { Browser } from "../types"; +import { WsConnection } from "../../ws-connection"; +import { WsError } from "../../ws-connection/error"; +import { exponentiallyWait } from "../../ws-connection/utils"; + +type OnEventMessageFn = (bidiEventMessage: BiDiEvent) => unknown; + +interface BiDiConnectionOptions { + sessionId: string; + headers?: Record; + requestTimeout: number; +} + +export class BIDIConnection { + public onEventMessage: OnEventMessageFn | null = null; + private readonly _sessionId: string; + + private readonly _wsConnection: WsConnection, string>; + + private constructor(bidiWsEndpoint: string, { headers, sessionId, requestTimeout }: BiDiConnectionOptions) { + this._sessionId = sessionId; + + this._wsConnection = new WsConnection, string>(bidiWsEndpoint, { + headers, + debugFn: debugBidi, + retries: { + count: BIDI_CONNECTION_RETRIES, + baseDelay: BIDI_CONNECTION_RETRY_BASE_DELAY, + }, + timeouts: { + request: requestTimeout, + createSession: BIDI_CONNECTION_TIMEOUT, + }, + errors: { + ConnectionEstablishment: BIDIConnectionEstablishmentError, + ConnectionBreak: BIDIConnectionBreakError, + ConnectionTerminated: BIDIConnectionTerminatedError, + ConnectionTimeout: BIDIConnectionTimeoutError, + RequestTimeout: BIDIRequestError, + }, + onMessage: this._onMessage.bind(this), + }); + } + + /** @description Creates BIDIConnection without establishing it */ + static create(browser: Browser): BIDIConnection | null { + const sessionId = browser.publicAPI.sessionId; + + const bidiWsEndpoint = browser.publicAPI.capabilities.webSocketUrl as unknown as string; + const headers = browser.publicAPI.options?.headers ?? {}; + + if (!bidiWsEndpoint) { + return null; + } + + return new this(bidiWsEndpoint, { headers, sessionId, requestTimeout: browser.config.httpTimeout }); + } + + close(): void { + this._wsConnection.close(); + } + + private _onMessage(data: RawData): void { + const message = data.toString("utf8"); + + try { + const jsonParsedMessage: BiDiMessage = JSON.parse(message); + + if (debugBidi.enabled) { + debugBidi( + `< ${inspect( + { sessionId: this._sessionId, ...jsonParsedMessage }, + { + depth: 3, + maxStringLength: 150, + breakLength: Infinity, + compact: true, + }, + )}`, + ); + } + + if (!("id" in jsonParsedMessage)) { + if (this.onEventMessage) { + this.onEventMessage(jsonParsedMessage); + } + + return; + } + + if (jsonParsedMessage.type === "error" && jsonParsedMessage.id === null) { + debugBidi( + `\u2718 Received error message without ID: ${jsonParsedMessage.message}\n${jsonParsedMessage.stacktrace}`, + ); + return; + } + + if (jsonParsedMessage.type === "success") { + this._wsConnection.provideResponseFor(jsonParsedMessage.id, jsonParsedMessage.result); + } else if (jsonParsedMessage.type === "error") { + this._wsConnection.provideResponseFor( + jsonParsedMessage.id as number, + new BIDIRequestError({ + message: jsonParsedMessage.message, + code: jsonParsedMessage.error, + requestId: jsonParsedMessage.id as number, + }), + ); + } + } catch (err) { + if (debugBidi.enabled) { + const data = [ + `\u2718 Couldn't process BIDI message`, + `\tSession ID: ${this._sessionId}`, + `\tError: ${inspect( + { sessionId: this._sessionId, ...(err || {}) }, + { + depth: 3, + maxStringLength: 150, + breakLength: Infinity, + compact: true, + }, + )}`, + `\tMessage: "${message}"`, + ]; + debugBidi(data.join("\n")); + } + } + } + + /** @description Performs high-level CDP request with retries and timeouts */ + async request(method: BiDiCommand["method"], params: BiDiCommand["params"] = {}): Promise { + let result!: T | WsError; + + for (let retriesLeft = BIDI_REQUEST_RETRIES; retriesLeft >= 0; retriesLeft--) { + const id = this._wsConnection.getRequestId(); + const requestMessage = JSON.stringify({ id, method, params }); + + if (debugBidi.enabled) { + debugBidi( + `> ${inspect( + { + sessionId: this._sessionId, + id, + method, + params, + }, + { + depth: 3, + maxStringLength: 150, + breakLength: Infinity, + compact: true, + }, + )}`, + ); + } + + result = (await this._wsConnection.makeRequest(id, requestMessage)) as T | WsError; + + if (!(result instanceof WsError) || !result.isRetryable() || retriesLeft <= 0) { + break; + } + + if (debugBidi.enabled) { + debugBidi( + `⟳ ${inspect({ + sessionId: this._sessionId, + id, + method, + params, + errorMessage: result.message, + retriesLeft: retriesLeft, + })}`, + ); + } + + // Intentionally avoiding wait after timeout + if (!(result instanceof BIDIRequestTimeoutError)) { + await exponentiallyWait({ + baseDelay: BIDI_REQUEST_RETRY_BASE_DELAY, + attempt: BIDI_REQUEST_RETRIES - retriesLeft, + }); + } + } + + if (result instanceof WsError) { + throw result; + } + + return result; + } +} diff --git a/src/browser/bidi/constants.ts b/src/browser/bidi/constants.ts new file mode 100644 index 000000000..0a89f6979 --- /dev/null +++ b/src/browser/bidi/constants.ts @@ -0,0 +1,5 @@ +export const BIDI_CONNECTION_TIMEOUT = 15000; // 15 sec +export const BIDI_CONNECTION_RETRIES = 3; +export const BIDI_CONNECTION_RETRY_BASE_DELAY = 500; +export const BIDI_REQUEST_RETRIES = 3; +export const BIDI_REQUEST_RETRY_BASE_DELAY = 500; diff --git a/src/browser/bidi/debug.ts b/src/browser/bidi/debug.ts new file mode 100644 index 000000000..a028045d4 --- /dev/null +++ b/src/browser/bidi/debug.ts @@ -0,0 +1,3 @@ +import debugModule from "debug"; + +export const debugBidi = debugModule("testplane:bidi"); diff --git a/src/browser/bidi/emitter.ts b/src/browser/bidi/emitter.ts new file mode 100644 index 000000000..ea88665a4 --- /dev/null +++ b/src/browser/bidi/emitter.ts @@ -0,0 +1,41 @@ +import * as logger from "../../utils/logger"; +import { EventEmitter } from "events"; + +// eslint-disable-next-line @typescript-eslint/no-explicit-any +type AnyFunc = (...args: any) => unknown; + +export class BIDIEmitter extends EventEmitter { + private _callbackMap: Map = new Map(); + + on(event: U, listener: (params: Events[U]) => void | Promise): this { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + const eventListenerWithErrorBoundary = (params: Events[U]): void | Promise => { + const logError = (e: unknown): void => { + logger.error(`Catched unhandled error in BiDi "${event}" handler: ${(e && (e as Error).stack) || e}`); + }; + + try { + const result = listener(params); + + return result instanceof Promise ? result.catch(logError) : result; + } catch (e) { + logError(e); + } + }; + + this._callbackMap.set(listener, eventListenerWithErrorBoundary); + + return super.on(event, eventListenerWithErrorBoundary); + } + + off(event: U, listener: (params: Events[U]) => void | Promise): this { + const eventListenerWithErrorBoundary = this._callbackMap.get(listener); + + if (eventListenerWithErrorBoundary) { + this._callbackMap.delete(listener); + super.off(event, eventListenerWithErrorBoundary); + } + + return this; + } +} diff --git a/src/browser/bidi/error.ts b/src/browser/bidi/error.ts new file mode 100644 index 000000000..ba0b87ea8 --- /dev/null +++ b/src/browser/bidi/error.ts @@ -0,0 +1,52 @@ +import { + WsError, + WsConnectionEstablishmentError, + WsConnectionTerminatedError, + WsConnectionBreakError, + WsConnectionTimeoutError, + WsRequestTimeoutError, +} from "../../ws-connection/error"; + +export class BIDIError extends WsError { + isRetryable(): boolean { + return false; + } +} + +export class BIDIConnectionEstablishmentError extends WsConnectionEstablishmentError {} +export class BIDIConnectionBreakError extends WsConnectionBreakError {} +export class BIDIConnectionTerminatedError extends WsConnectionTerminatedError {} +export class BIDIConnectionTimeoutError extends WsConnectionTimeoutError {} +export class BIDIRequestTimeoutError extends WsRequestTimeoutError {} + +export class BIDIRequestError extends WsError { + public stacktrace?: string; + + constructor({ + message, + code, + requestId, + stacktrace, + }: { + message: string; + code?: number | string; + requestId?: number; + stacktrace?: string; + }) { + super({ message, requestId, code }); + + this.stacktrace = stacktrace; + + if (stacktrace) { + this.message += `\n\tStacktrace:\n${stacktrace}`; + } + } + + isRetryable(): boolean { + return ( + this.code === "unknown error" || + this.code === "unable to capture screen" || + this.code === "unable to close browser" + ); + } +} diff --git a/src/browser/bidi/index.ts b/src/browser/bidi/index.ts new file mode 100644 index 000000000..3ea8b7dab --- /dev/null +++ b/src/browser/bidi/index.ts @@ -0,0 +1,78 @@ +import { BIDIConnection } from "./connection"; +import { BiDiBrowser } from "./modules/browser"; +import { BiDiBrowsingContext } from "./modules/browsing-context"; +import { BiDiEmulation } from "./modules/emulation"; +import { BiDiInput } from "./modules/input"; +import { BiDiLog } from "./modules/log"; +import { BiDiNetwork } from "./modules/network"; +import { BiDiScript } from "./modules/script"; +import { BiDiSession } from "./modules/session"; +import { BiDiStorage } from "./modules/storage"; +import { BiDiWebExtension } from "./modules/web-extension"; +import type { Browser } from "../types"; +import type { BiDiCommand, BiDiEvent } from "./types"; + +export class BIDI { + private readonly _connection: BIDIConnection; + public readonly browser: BiDiBrowser; + public readonly browsingContext: BiDiBrowsingContext; + public readonly emulation: BiDiEmulation; + public readonly input: BiDiInput; + public readonly log: BiDiLog; + public readonly network: BiDiNetwork; + public readonly script: BiDiScript; + public readonly session: BiDiSession; + public readonly storage: BiDiStorage; + public readonly webExtension: BiDiWebExtension; + + static create(browser: Browser): BIDI | null { + const connection = BIDIConnection.create(browser); + + return connection ? new this(connection) : null; + } + + constructor(connection: BIDIConnection) { + this._connection = connection; + this.browser = new BiDiBrowser(connection); + this.browsingContext = new BiDiBrowsingContext(connection); + this.emulation = new BiDiEmulation(connection); + this.input = new BiDiInput(connection); + this.log = new BiDiLog(); + this.network = new BiDiNetwork(connection); + this.script = new BiDiScript(connection); + this.session = new BiDiSession(connection); + this.storage = new BiDiStorage(connection); + this.webExtension = new BiDiWebExtension(connection); + this._connection.onEventMessage = this._onEventMessage.bind(this); + } + + async request(method: BiDiCommand["method"], params?: BiDiCommand["params"]): Promise { + return this._connection.request(method, params); + } + + close(): void { + this._connection.close(); + } + + private _onEventMessage(bidiEventMessage: BiDiEvent): void { + const [moduleName, event] = bidiEventMessage.method.split(".", 2); + + switch (moduleName) { + case "browsingContext": + this.browsingContext.emit(event, bidiEventMessage.params); + break; + case "input": + this.input.emit(event, bidiEventMessage.params); + break; + case "log": + this.log.emit(event, bidiEventMessage.params); + break; + case "network": + this.network.emit(event, bidiEventMessage.params); + break; + case "script": + this.script.emit(event, bidiEventMessage.params); + break; + } + } +} diff --git a/src/browser/bidi/modules/browser.ts b/src/browser/bidi/modules/browser.ts new file mode 100644 index 000000000..b77a8b4bb --- /dev/null +++ b/src/browser/bidi/modules/browser.ts @@ -0,0 +1,77 @@ +import type { BIDIConnection } from "../connection"; +import type { + BiDiBrowserCreateUserContextParameters, + BiDiBrowserGetClientWindowsResult, + BiDiBrowserGetUserContextsResult, + BiDiBrowserRemoveUserContextParameters, + BiDiBrowserRemoveUserContextResult, + BiDiBrowserSetClientWindowStateParameters, + BiDiBrowserSetClientWindowStateResult, + BiDiBrowserSetDownloadBehaviorParameters, + BiDiBrowserSetDownloadBehaviorResult, + BiDiBrowserUserContextInfo, +} from "../types"; + +/** @link https://www.w3.org/TR/webdriver-bidi/#module-browser */ +export class BiDiBrowser { + private readonly _connection: BIDIConnection; + + public constructor(connection: BIDIConnection) { + this._connection = connection; + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-browser-close + */ + async close(): Promise { + return this._connection.request("browser.close"); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-browser-createUserContext + */ + async createUserContext(params: BiDiBrowserCreateUserContextParameters): Promise { + return this._connection.request("browser.createUserContext", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-browser-getClientWindows + */ + async getClientWindows(): Promise { + return this._connection.request("browser.getClientWindows"); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-browser-getUserContexts + */ + async getUserContexts(): Promise { + return this._connection.request("browser.getUserContexts"); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-browser-removeUserContext + */ + async removeUserContext( + params: BiDiBrowserRemoveUserContextParameters, + ): Promise { + return this._connection.request("browser.removeUserContext", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-browser-setClientWindowState + */ + async setClientWindowState( + params: BiDiBrowserSetClientWindowStateParameters, + ): Promise { + return this._connection.request("browser.setClientWindowState", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-browser-setDownloadBehavior + */ + async setDownloadBehavior( + params: BiDiBrowserSetDownloadBehaviorParameters, + ): Promise { + return this._connection.request("browser.setDownloadBehavior", params); + } +} diff --git a/src/browser/bidi/modules/browsing-context.ts b/src/browser/bidi/modules/browsing-context.ts new file mode 100644 index 000000000..290c3fc13 --- /dev/null +++ b/src/browser/bidi/modules/browsing-context.ts @@ -0,0 +1,186 @@ +import { BIDIEmitter } from "../emitter"; +import type { BIDIConnection } from "../connection"; +import type { + BiDiBrowsingContextActivateParameters, + BiDiBrowsingContextActivateResult, + BiDiBrowsingContextCaptureScreenshotParameters, + BiDiBrowsingContextCaptureScreenshotResult, + BiDiBrowsingContextCloseParameters, + BiDiBrowsingContextCloseResult, + BiDiBrowsingContextCreateParameters, + BiDiBrowsingContextCreateResult, + BiDiBrowsingContextGetTreeParameters, + BiDiBrowsingContextGetTreeResult, + BiDiBrowsingContextDownloadEndParams, + BiDiBrowsingContextDownloadWillBeginParams, + BiDiBrowsingContextHandleUserPromptParameters, + BiDiBrowsingContextHandleUserPromptResult, + BiDiBrowsingContextHistoryUpdatedParameters, + BiDiBrowsingContextInfo, + BiDiBrowsingContextLocateNodesParameters, + BiDiBrowsingContextLocateNodesResult, + BiDiBrowsingContextNavigateParameters, + BiDiBrowsingContextNavigateResult, + BiDiBrowsingContextNavigationInfo, + BiDiBrowsingContextPrintParameters, + BiDiBrowsingContextPrintResult, + BiDiBrowsingContextReloadParameters, + BiDiBrowsingContextReloadResult, + BiDiBrowsingContextSetBypassCSPParameters, + BiDiBrowsingContextSetBypassCSPResult, + BiDiBrowsingContextSetViewportParameters, + BiDiBrowsingContextSetViewportResult, + BiDiBrowsingContextStartScreencastParameters, + BiDiBrowsingContextStartScreencastResult, + BiDiBrowsingContextStopScreencastParameters, + BiDiBrowsingContextStopScreencastResult, + BiDiBrowsingContextTraverseHistoryParameters, + BiDiBrowsingContextTraverseHistoryResult, + BiDiBrowsingContextUserPromptClosedParameters, + BiDiBrowsingContextUserPromptOpenedParameters, +} from "../types"; + +export interface BiDiBrowsingContextEvents { + contextCreated: BiDiBrowsingContextInfo; + contextDestroyed: BiDiBrowsingContextInfo; + navigationStarted: BiDiBrowsingContextNavigationInfo; + fragmentNavigated: BiDiBrowsingContextNavigationInfo; + historyUpdated: BiDiBrowsingContextHistoryUpdatedParameters; + domContentLoaded: BiDiBrowsingContextNavigationInfo; + load: BiDiBrowsingContextNavigationInfo; + downloadWillBegin: BiDiBrowsingContextDownloadWillBeginParams; + downloadEnd: BiDiBrowsingContextDownloadEndParams; + navigationAborted: BiDiBrowsingContextNavigationInfo; + navigationCommitted: BiDiBrowsingContextNavigationInfo; + navigationFailed: BiDiBrowsingContextNavigationInfo; + userPromptClosed: BiDiBrowsingContextUserPromptClosedParameters; + userPromptOpened: BiDiBrowsingContextUserPromptOpenedParameters; +} + +/** @link https://www.w3.org/TR/webdriver-bidi/#module-browsingContext */ +export class BiDiBrowsingContext extends BIDIEmitter { + private readonly _connection: BIDIConnection; + + public constructor(connection: BIDIConnection) { + super(); + + this._connection = connection; + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-browsingContext-activate + */ + async activate(params: BiDiBrowsingContextActivateParameters): Promise { + return this._connection.request("browsingContext.activate", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-browsingContext-captureScreenshot + */ + async captureScreenshot( + params: BiDiBrowsingContextCaptureScreenshotParameters, + ): Promise { + return this._connection.request("browsingContext.captureScreenshot", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-browsingContext-close + */ + async close(params: BiDiBrowsingContextCloseParameters): Promise { + return this._connection.request("browsingContext.close", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-browsingContext-create + */ + async create(params: BiDiBrowsingContextCreateParameters): Promise { + return this._connection.request("browsingContext.create", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-browsingContext-getTree + */ + async getTree(params: BiDiBrowsingContextGetTreeParameters): Promise { + return this._connection.request("browsingContext.getTree", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-browsingContext-handleUserPrompt + */ + async handleUserPrompt( + params: BiDiBrowsingContextHandleUserPromptParameters, + ): Promise { + return this._connection.request("browsingContext.handleUserPrompt", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-browsingContext-locateNodes + */ + async locateNodes(params: BiDiBrowsingContextLocateNodesParameters): Promise { + return this._connection.request("browsingContext.locateNodes", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-browsingContext-navigate + */ + async navigate(params: BiDiBrowsingContextNavigateParameters): Promise { + return this._connection.request("browsingContext.navigate", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-browsingContext-print + */ + async print(params: BiDiBrowsingContextPrintParameters): Promise { + return this._connection.request("browsingContext.print", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-browsingContext-reload + */ + async reload(params: BiDiBrowsingContextReloadParameters): Promise { + return this._connection.request("browsingContext.reload", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-browsingContext-setBypassCSP + */ + async setBypassCSP( + params: BiDiBrowsingContextSetBypassCSPParameters, + ): Promise { + return this._connection.request("browsingContext.setBypassCSP", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-browsingContext-setViewport + */ + async setViewport(params: BiDiBrowsingContextSetViewportParameters): Promise { + return this._connection.request("browsingContext.setViewport", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-browsingContext-startScreencast + */ + async startScreencast( + params: BiDiBrowsingContextStartScreencastParameters, + ): Promise { + return this._connection.request("browsingContext.startScreencast", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-browsingContext-stopScreencast + */ + async stopScreencast( + params: BiDiBrowsingContextStopScreencastParameters, + ): Promise { + return this._connection.request("browsingContext.stopScreencast", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-browsingContext-traverseHistory + */ + async traverseHistory( + params: BiDiBrowsingContextTraverseHistoryParameters, + ): Promise { + return this._connection.request("browsingContext.traverseHistory", params); + } +} diff --git a/src/browser/bidi/modules/emulation.ts b/src/browser/bidi/modules/emulation.ts new file mode 100644 index 000000000..2d908a878 --- /dev/null +++ b/src/browser/bidi/modules/emulation.ts @@ -0,0 +1,133 @@ +import type { BIDIConnection } from "../connection"; +import type { + BiDiEmulationSetForcedColorsModeThemeOverrideParameters, + BiDiEmulationSetForcedColorsModeThemeOverrideResult, + BiDiEmulationSetGeolocationOverrideParameters, + BiDiEmulationSetGeolocationOverrideResult, + BiDiEmulationSetLocaleOverrideParameters, + BiDiEmulationSetLocaleOverrideResult, + BiDiEmulationSetNetworkConditionsParameters, + BiDiEmulationSetNetworkConditionsResult, + BiDiEmulationSetScreenOrientationOverrideParameters, + BiDiEmulationSetScreenOrientationOverrideResult, + BiDiEmulationSetScreenSettingsOverrideParameters, + BiDiEmulationSetScreenSettingsOverrideResult, + BiDiEmulationSetScriptingEnabledParameters, + BiDiEmulationSetScriptingEnabledResult, + BiDiEmulationSetScrollbarTypeOverrideParameters, + BiDiEmulationSetScrollbarTypeOverrideResult, + BiDiEmulationSetTimezoneOverrideParameters, + BiDiEmulationSetTimezoneOverrideResult, + BiDiEmulationSetTouchOverrideParameters, + BiDiEmulationSetTouchOverrideResult, + BiDiEmulationSetUserAgentOverrideParameters, + BiDiEmulationSetUserAgentOverrideResult, +} from "../types"; + +/** @link https://www.w3.org/TR/webdriver-bidi/#module-emulation */ +export class BiDiEmulation { + private readonly _connection: BIDIConnection; + + public constructor(connection: BIDIConnection) { + this._connection = connection; + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-emulation-setForcedColorsModeThemeOverride + */ + async setForcedColorsModeThemeOverride( + params: BiDiEmulationSetForcedColorsModeThemeOverrideParameters, + ): Promise { + return this._connection.request("emulation.setForcedColorsModeThemeOverride", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-emulation-setGeolocationOverride + */ + async setGeolocationOverride( + params: BiDiEmulationSetGeolocationOverrideParameters, + ): Promise { + return this._connection.request("emulation.setGeolocationOverride", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-emulation-setLocaleOverride + */ + async setLocaleOverride( + params: BiDiEmulationSetLocaleOverrideParameters, + ): Promise { + return this._connection.request("emulation.setLocaleOverride", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-emulation-setNetworkConditions + */ + async setNetworkConditions( + params: BiDiEmulationSetNetworkConditionsParameters, + ): Promise { + return this._connection.request("emulation.setNetworkConditions", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-emulation-setScreenOrientationOverride + */ + async setScreenOrientationOverride( + params: BiDiEmulationSetScreenOrientationOverrideParameters, + ): Promise { + return this._connection.request("emulation.setScreenOrientationOverride", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-emulation-setScreenSettingsOverride + */ + async setScreenSettingsOverride( + params: BiDiEmulationSetScreenSettingsOverrideParameters, + ): Promise { + return this._connection.request("emulation.setScreenSettingsOverride", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-emulation-setScriptingEnabled + */ + async setScriptingEnabled( + params: BiDiEmulationSetScriptingEnabledParameters, + ): Promise { + return this._connection.request("emulation.setScriptingEnabled", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-emulation-setScrollbarTypeOverride + */ + async setScrollbarTypeOverride( + params: BiDiEmulationSetScrollbarTypeOverrideParameters, + ): Promise { + return this._connection.request("emulation.setScrollbarTypeOverride", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-emulation-setTimezoneOverride + */ + async setTimezoneOverride( + params: BiDiEmulationSetTimezoneOverrideParameters, + ): Promise { + return this._connection.request("emulation.setTimezoneOverride", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-emulation-setTouchOverride + */ + async setTouchOverride( + params: BiDiEmulationSetTouchOverrideParameters, + ): Promise { + return this._connection.request("emulation.setTouchOverride", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-emulation-setUserAgentOverride + */ + async setUserAgentOverride( + params: BiDiEmulationSetUserAgentOverrideParameters, + ): Promise { + return this._connection.request("emulation.setUserAgentOverride", params); + } +} diff --git a/src/browser/bidi/modules/input.ts b/src/browser/bidi/modules/input.ts new file mode 100644 index 000000000..998656dc8 --- /dev/null +++ b/src/browser/bidi/modules/input.ts @@ -0,0 +1,47 @@ +import { BIDIEmitter } from "../emitter"; +import type { BIDIConnection } from "../connection"; +import type { + BiDiInputFileDialogInfo, + BiDiInputPerformActionsParameters, + BiDiInputPerformActionsResult, + BiDiInputReleaseActionsParameters, + BiDiInputReleaseActionsResult, + BiDiInputSetFilesParameters, + BiDiInputSetFilesResult, +} from "../types"; + +export interface BiDiInputEvents { + fileDialogOpened: BiDiInputFileDialogInfo; +} + +/** @link https://www.w3.org/TR/webdriver-bidi/#module-input */ +export class BiDiInput extends BIDIEmitter { + private readonly _connection: BIDIConnection; + + public constructor(connection: BIDIConnection) { + super(); + + this._connection = connection; + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-input-performActions + */ + async performActions(params: BiDiInputPerformActionsParameters): Promise { + return this._connection.request("input.performActions", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-input-releaseActions + */ + async releaseActions(params: BiDiInputReleaseActionsParameters): Promise { + return this._connection.request("input.releaseActions", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-input-setFiles + */ + async setFiles(params: BiDiInputSetFilesParameters): Promise { + return this._connection.request("input.setFiles", params); + } +} diff --git a/src/browser/bidi/modules/log.ts b/src/browser/bidi/modules/log.ts new file mode 100644 index 000000000..a7cfe9a83 --- /dev/null +++ b/src/browser/bidi/modules/log.ts @@ -0,0 +1,9 @@ +import { BIDIEmitter } from "../emitter"; +import type { BiDiLogLogEntry } from "../types"; + +export interface BiDiLogEvents { + entryAdded: BiDiLogLogEntry; +} + +/** @link https://www.w3.org/TR/webdriver-bidi/#module-log */ +export class BiDiLog extends BIDIEmitter {} diff --git a/src/browser/bidi/modules/network.ts b/src/browser/bidi/modules/network.ts new file mode 100644 index 000000000..65ae9acec --- /dev/null +++ b/src/browser/bidi/modules/network.ts @@ -0,0 +1,147 @@ +import { BIDIEmitter } from "../emitter"; +import type { BIDIConnection } from "../connection"; +import type { + BiDiNetworkAddDataCollectorParameters, + BiDiNetworkAddDataCollectorResult, + BiDiNetworkAddInterceptParameters, + BiDiNetworkAddInterceptResult, + BiDiNetworkAuthRequiredParameters, + BiDiNetworkBeforeRequestSentParameters, + BiDiNetworkContinueRequestParameters, + BiDiNetworkContinueRequestResult, + BiDiNetworkContinueResponseParameters, + BiDiNetworkContinueResponseResult, + BiDiNetworkContinueWithAuthParameters, + BiDiNetworkContinueWithAuthResult, + BiDiNetworkDisownDataParameters, + BiDiNetworkDisownDataResult, + BiDiNetworkFailRequestParameters, + BiDiNetworkFailRequestResult, + BiDiNetworkFetchErrorParameters, + BiDiNetworkGetDataParameters, + BiDiNetworkGetDataResult, + BiDiNetworkProvideResponseParameters, + BiDiNetworkProvideResponseResult, + BiDiNetworkRemoveDataCollectorParameters, + BiDiNetworkRemoveDataCollectorResult, + BiDiNetworkRemoveInterceptParameters, + BiDiNetworkRemoveInterceptResult, + BiDiNetworkResponseCompletedParameters, + BiDiNetworkResponseStartedParameters, + BiDiNetworkSetCacheBehaviorParameters, + BiDiNetworkSetCacheBehaviorResult, + BiDiNetworkSetExtraHeadersParameters, + BiDiNetworkSetExtraHeadersResult, +} from "../types"; + +export interface BiDiNetworkEvents { + authRequired: BiDiNetworkAuthRequiredParameters; + beforeRequestSent: BiDiNetworkBeforeRequestSentParameters; + fetchError: BiDiNetworkFetchErrorParameters; + responseCompleted: BiDiNetworkResponseCompletedParameters; + responseStarted: BiDiNetworkResponseStartedParameters; +} + +/** @link https://www.w3.org/TR/webdriver-bidi/#module-network */ +export class BiDiNetwork extends BIDIEmitter { + private readonly _connection: BIDIConnection; + + public constructor(connection: BIDIConnection) { + super(); + + this._connection = connection; + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-network-addDataCollector + */ + async addDataCollector(params: BiDiNetworkAddDataCollectorParameters): Promise { + return this._connection.request("network.addDataCollector", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-network-addIntercept + */ + async addIntercept(params: BiDiNetworkAddInterceptParameters): Promise { + return this._connection.request("network.addIntercept", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-network-continueRequest + */ + async continueRequest(params: BiDiNetworkContinueRequestParameters): Promise { + return this._connection.request("network.continueRequest", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-network-continueResponse + */ + async continueResponse(params: BiDiNetworkContinueResponseParameters): Promise { + return this._connection.request("network.continueResponse", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-network-continueWithAuth + */ + async continueWithAuth(params: BiDiNetworkContinueWithAuthParameters): Promise { + return this._connection.request("network.continueWithAuth", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-network-disownData + */ + async disownData(params: BiDiNetworkDisownDataParameters): Promise { + return this._connection.request("network.disownData", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-network-failRequest + */ + async failRequest(params: BiDiNetworkFailRequestParameters): Promise { + return this._connection.request("network.failRequest", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-network-getData + */ + async getData(params: BiDiNetworkGetDataParameters): Promise { + return this._connection.request("network.getData", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-network-provideResponse + */ + async provideResponse(params: BiDiNetworkProvideResponseParameters): Promise { + return this._connection.request("network.provideResponse", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-network-removeDataCollector + */ + async removeDataCollector( + params: BiDiNetworkRemoveDataCollectorParameters, + ): Promise { + return this._connection.request("network.removeDataCollector", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-network-removeIntercept + */ + async removeIntercept(params: BiDiNetworkRemoveInterceptParameters): Promise { + return this._connection.request("network.removeIntercept", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-network-setCacheBehavior + */ + async setCacheBehavior(params: BiDiNetworkSetCacheBehaviorParameters): Promise { + return this._connection.request("network.setCacheBehavior", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-network-setExtraHeaders + */ + async setExtraHeaders(params: BiDiNetworkSetExtraHeadersParameters): Promise { + return this._connection.request("network.setExtraHeaders", params); + } +} diff --git a/src/browser/bidi/modules/script.ts b/src/browser/bidi/modules/script.ts new file mode 100644 index 000000000..45e01f922 --- /dev/null +++ b/src/browser/bidi/modules/script.ts @@ -0,0 +1,80 @@ +import { BIDIEmitter } from "../emitter"; +import type { BIDIConnection } from "../connection"; +import type { + BiDiScriptAddPreloadScriptParameters, + BiDiScriptAddPreloadScriptResult, + BiDiScriptCallFunctionParameters, + BiDiScriptCallFunctionResult, + BiDiScriptDisownParameters, + BiDiScriptDisownResult, + BiDiScriptEvaluateParameters, + BiDiScriptEvaluateResult, + BiDiScriptGetRealmsParameters, + BiDiScriptGetRealmsResult, + BiDiScriptMessageParameters, + BiDiScriptRealmDestroyedParameters, + BiDiScriptRealmInfo, + BiDiScriptRemovePreloadScriptParameters, + BiDiScriptRemovePreloadScriptResult, +} from "../types"; + +export interface BiDiScriptEvents { + message: BiDiScriptMessageParameters; + realmCreated: BiDiScriptRealmInfo; + realmDestroyed: BiDiScriptRealmDestroyedParameters; +} + +/** @link https://www.w3.org/TR/webdriver-bidi/#module-script */ +export class BiDiScript extends BIDIEmitter { + private readonly _connection: BIDIConnection; + + public constructor(connection: BIDIConnection) { + super(); + + this._connection = connection; + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-script-addPreloadScript + */ + async addPreloadScript(params: BiDiScriptAddPreloadScriptParameters): Promise { + return this._connection.request("script.addPreloadScript", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-script-callFunction + */ + async callFunction(params: BiDiScriptCallFunctionParameters): Promise { + return this._connection.request("script.callFunction", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-script-disown + */ + async disown(params: BiDiScriptDisownParameters): Promise { + return this._connection.request("script.disown", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-script-evaluate + */ + async evaluate(params: BiDiScriptEvaluateParameters): Promise { + return this._connection.request("script.evaluate", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-script-getRealms + */ + async getRealms(params: BiDiScriptGetRealmsParameters): Promise { + return this._connection.request("script.getRealms", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-script-removePreloadScript + */ + async removePreloadScript( + params: BiDiScriptRemovePreloadScriptParameters, + ): Promise { + return this._connection.request("script.removePreloadScript", params); + } +} diff --git a/src/browser/bidi/modules/session.ts b/src/browser/bidi/modules/session.ts new file mode 100644 index 000000000..7d95dd1d2 --- /dev/null +++ b/src/browser/bidi/modules/session.ts @@ -0,0 +1,55 @@ +import type { BIDIConnection } from "../connection"; +import type { + BiDiSessionEndResult, + BiDiSessionNewParameters, + BiDiSessionNewResult, + BiDiSessionStatusResult, + BiDiSessionSubscribeParameters, + BiDiSessionSubscribeResult, + BiDiSessionUnsubscribeParameters, + BiDiSessionUnsubscribeResult, +} from "../types"; + +/** @link https://www.w3.org/TR/webdriver-bidi/#module-session */ +export class BiDiSession { + private readonly _connection: BIDIConnection; + + public constructor(connection: BIDIConnection) { + this._connection = connection; + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-session-status + */ + async status(): Promise { + return this._connection.request("session.status"); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-session-new + */ + async new(params: BiDiSessionNewParameters): Promise { + return this._connection.request("session.new", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-session-end + */ + async end(): Promise { + return this._connection.request("session.end"); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-session-subscribe + */ + async subscribe(params: BiDiSessionSubscribeParameters): Promise { + return this._connection.request("session.subscribe", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-session-unsubscribe + */ + async unsubscribe(params: BiDiSessionUnsubscribeParameters): Promise { + return this._connection.request("session.unsubscribe", params); + } +} diff --git a/src/browser/bidi/modules/storage.ts b/src/browser/bidi/modules/storage.ts new file mode 100644 index 000000000..ddfe4fabd --- /dev/null +++ b/src/browser/bidi/modules/storage.ts @@ -0,0 +1,39 @@ +import type { BIDIConnection } from "../connection"; +import type { + BiDiStorageDeleteCookiesParameters, + BiDiStorageDeleteCookiesResult, + BiDiStorageGetCookiesParameters, + BiDiStorageGetCookiesResult, + BiDiStorageSetCookieParameters, + BiDiStorageSetCookieResult, +} from "../types"; + +/** @link https://www.w3.org/TR/webdriver-bidi/#module-storage */ +export class BiDiStorage { + private readonly _connection: BIDIConnection; + + public constructor(connection: BIDIConnection) { + this._connection = connection; + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-storage-getCookies + */ + async getCookies(params: BiDiStorageGetCookiesParameters): Promise { + return this._connection.request("storage.getCookies", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-storage-setCookie + */ + async setCookie(params: BiDiStorageSetCookieParameters): Promise { + return this._connection.request("storage.setCookie", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-storage-deleteCookies + */ + async deleteCookies(params: BiDiStorageDeleteCookiesParameters): Promise { + return this._connection.request("storage.deleteCookies", params); + } +} diff --git a/src/browser/bidi/modules/web-extension.ts b/src/browser/bidi/modules/web-extension.ts new file mode 100644 index 000000000..87c05b7fd --- /dev/null +++ b/src/browser/bidi/modules/web-extension.ts @@ -0,0 +1,30 @@ +import type { BIDIConnection } from "../connection"; +import type { + BiDiWebExtensionInstallParameters, + BiDiWebExtensionInstallResult, + BiDiWebExtensionUninstallParameters, + BiDiWebExtensionUninstallResult, +} from "../types"; + +/** @link https://www.w3.org/TR/webdriver-bidi/#module-webExtension */ +export class BiDiWebExtension { + private readonly _connection: BIDIConnection; + + public constructor(connection: BIDIConnection) { + this._connection = connection; + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-webExtension-install + */ + async install(params: BiDiWebExtensionInstallParameters): Promise { + return this._connection.request("webExtension.install", params); + } + + /** + * @link https://www.w3.org/TR/webdriver-bidi/#command-webExtension-uninstall + */ + async uninstall(params: BiDiWebExtensionUninstallParameters): Promise { + return this._connection.request("webExtension.uninstall", params); + } +} diff --git a/src/browser/bidi/types/command-data/browser-command.ts b/src/browser/bidi/types/command-data/browser-command.ts new file mode 100644 index 000000000..5a120d042 --- /dev/null +++ b/src/browser/bidi/types/command-data/browser-command.ts @@ -0,0 +1,92 @@ +import { JsInt, JsUInt, BiDiEmptyParams } from "../generic"; +import { BiDiBrowserDownloadBehavior, BiDiBrowserClientWindow, BiDiBrowserUserContext } from "../modules/browser"; +import { BiDiSessionProxyConfiguration, BiDiSessionUserPromptHandler } from "../modules/session"; + +// browser.Close +export type BiDiBrowserCloseCommand = { + method: "browser.close"; + params: BiDiEmptyParams; +}; + +// browser.CreateUserContext +export type BiDiBrowserCreateUserContextCommand = { + method: "browser.createUserContext"; + params: BiDiBrowserCreateUserContextParameters; +}; + +// browser.CreateUserContextParameters +export type BiDiBrowserCreateUserContextParameters = { + acceptInsecureCerts?: boolean; + proxy?: BiDiSessionProxyConfiguration; + unhandledPromptBehavior?: BiDiSessionUserPromptHandler; +}; + +// browser.GetClientWindows +export type BiDiBrowserGetClientWindowsCommand = { + method: "browser.getClientWindows"; + params: BiDiEmptyParams; +}; + +// browser.GetUserContexts +export type BiDiBrowserGetUserContextsCommand = { + method: "browser.getUserContexts"; + params: BiDiEmptyParams; +}; + +// browser.RemoveUserContext +export type BiDiBrowserRemoveUserContextCommand = { + method: "browser.removeUserContext"; + params: BiDiBrowserRemoveUserContextParameters; +}; + +// browser.RemoveUserContextParameters +export type BiDiBrowserRemoveUserContextParameters = { + userContext: BiDiBrowserUserContext; +}; + +// browser.SetClientWindowState +export type BiDiBrowserSetClientWindowStateCommand = { + method: "browser.setClientWindowState"; + params: BiDiBrowserSetClientWindowStateParameters; +}; + +// browser.SetClientWindowStateParameters +export type BiDiBrowserSetClientWindowStateParameters = { + clientWindow: BiDiBrowserClientWindow; +} & (BiDiBrowserClientWindowNamedState | BiDiBrowserClientWindowRectState); + +// browser.ClientWindowNamedState +export type BiDiBrowserClientWindowNamedState = { + state: "fullscreen" | "maximized" | "minimized"; +}; + +// browser.ClientWindowRectState +export type BiDiBrowserClientWindowRectState = { + state: "normal"; + width?: JsUInt; + height?: JsUInt; + x?: JsInt; + y?: JsInt; +}; + +// browser.SetDownloadBehavior +export type BiDiBrowserSetDownloadBehaviorCommand = { + method: "browser.setDownloadBehavior"; + params: BiDiBrowserSetDownloadBehaviorParameters; +}; + +// browser.SetDownloadBehaviorParameters +export type BiDiBrowserSetDownloadBehaviorParameters = { + downloadBehavior: BiDiBrowserDownloadBehavior | null; + userContexts?: BiDiBrowserUserContext[]; +}; + +// BrowserCommand +export type BiDiBrowserCommand = + | BiDiBrowserCloseCommand + | BiDiBrowserCreateUserContextCommand + | BiDiBrowserGetClientWindowsCommand + | BiDiBrowserGetUserContextsCommand + | BiDiBrowserRemoveUserContextCommand + | BiDiBrowserSetClientWindowStateCommand + | BiDiBrowserSetDownloadBehaviorCommand; diff --git a/src/browser/bidi/types/command-data/browsing-context-command.ts b/src/browser/bidi/types/command-data/browsing-context-command.ts new file mode 100644 index 000000000..329a59890 --- /dev/null +++ b/src/browser/bidi/types/command-data/browsing-context-command.ts @@ -0,0 +1,282 @@ +import { JsInt, JsUInt } from "../generic"; +import { + BiDiBrowsingContextBrowsingContext, + BiDiBrowsingContextLocator, + BiDiBrowsingContextReadinessState, + BiDiBrowsingContextScreencast, +} from "../modules/browsing-context"; +import { BiDiBrowserUserContext } from "../modules/browser"; +import { BiDiScriptSerializationOptions, BiDiScriptSharedReference } from "../modules/script"; + +// browsingContext.Activate +export type BiDiBrowsingContextActivateCommand = { + method: "browsingContext.activate"; + params: BiDiBrowsingContextActivateParameters; +}; + +// browsingContext.ActivateParameters +export type BiDiBrowsingContextActivateParameters = { + context: BiDiBrowsingContextBrowsingContext; +}; + +// browsingContext.CaptureScreenshot +export type BiDiBrowsingContextCaptureScreenshotCommand = { + method: "browsingContext.captureScreenshot"; + params: BiDiBrowsingContextCaptureScreenshotParameters; +}; + +// browsingContext.CaptureScreenshotParameters +export type BiDiBrowsingContextCaptureScreenshotParameters = { + context: BiDiBrowsingContextBrowsingContext; + origin?: "viewport" | "document"; + format?: BiDiBrowsingContextImageFormat; + clip?: BiDiBrowsingContextClipRectangle; +}; + +// browsingContext.ImageFormat +export type BiDiBrowsingContextImageFormat = { + type: string; + quality?: number; +}; + +// browsingContext.ClipRectangle +export type BiDiBrowsingContextClipRectangle = + | BiDiBrowsingContextBoxClipRectangle + | BiDiBrowsingContextElementClipRectangle; + +// browsingContext.ElementClipRectangle +export type BiDiBrowsingContextElementClipRectangle = { + type: "element"; + element: BiDiScriptSharedReference; +}; + +// browsingContext.BoxClipRectangle +export type BiDiBrowsingContextBoxClipRectangle = { + type: "box"; + x: number; + y: number; + width: number; + height: number; +}; + +// browsingContext.Close +export type BiDiBrowsingContextCloseCommand = { + method: "browsingContext.close"; + params: BiDiBrowsingContextCloseParameters; +}; + +// browsingContext.CloseParameters +export type BiDiBrowsingContextCloseParameters = { + context: BiDiBrowsingContextBrowsingContext; + promptUnload?: boolean; +}; + +// browsingContext.Create +export type BiDiBrowsingContextCreateCommand = { + method: "browsingContext.create"; + params: BiDiBrowsingContextCreateParameters; +}; + +// browsingContext.CreateType +export type BiDiBrowsingContextCreateType = "tab" | "window"; + +// browsingContext.CreateParameters +export type BiDiBrowsingContextCreateParameters = { + type: BiDiBrowsingContextCreateType; + referenceContext?: BiDiBrowsingContextBrowsingContext; + background?: boolean; + userContext?: BiDiBrowserUserContext; +}; + +// browsingContext.GetTree +export type BiDiBrowsingContextGetTreeCommand = { + method: "browsingContext.getTree"; + params: BiDiBrowsingContextGetTreeParameters; +}; + +// browsingContext.GetTreeParameters +export type BiDiBrowsingContextGetTreeParameters = { + maxDepth?: JsUInt; + root?: BiDiBrowsingContextBrowsingContext; +}; + +// browsingContext.HandleUserPrompt +export type BiDiBrowsingContextHandleUserPromptCommand = { + method: "browsingContext.handleUserPrompt"; + params: BiDiBrowsingContextHandleUserPromptParameters; +}; + +// browsingContext.HandleUserPromptParameters +export type BiDiBrowsingContextHandleUserPromptParameters = { + context: BiDiBrowsingContextBrowsingContext; + accept?: boolean; + userText?: string; +}; + +// browsingContext.LocateNodes +export type BiDiBrowsingContextLocateNodesCommand = { + method: "browsingContext.locateNodes"; + params: BiDiBrowsingContextLocateNodesParameters; +}; + +// browsingContext.LocateNodesParameters +export type BiDiBrowsingContextLocateNodesParameters = { + context: BiDiBrowsingContextBrowsingContext; + locator: BiDiBrowsingContextLocator; + maxNodeCount?: JsUInt; + serializationOptions?: BiDiScriptSerializationOptions; + startNodes?: BiDiScriptSharedReference[]; +}; + +// browsingContext.Navigate +export type BiDiBrowsingContextNavigateCommand = { + method: "browsingContext.navigate"; + params: BiDiBrowsingContextNavigateParameters; +}; + +// browsingContext.NavigateParameters +export type BiDiBrowsingContextNavigateParameters = { + context: BiDiBrowsingContextBrowsingContext; + url: string; + wait?: BiDiBrowsingContextReadinessState; +}; + +// browsingContext.Print +export type BiDiBrowsingContextPrintCommand = { + method: "browsingContext.print"; + params: BiDiBrowsingContextPrintParameters; +}; + +// browsingContext.PrintParameters +export type BiDiBrowsingContextPrintParameters = { + context: BiDiBrowsingContextBrowsingContext; + background?: boolean; + margin?: BiDiBrowsingContextPrintMarginParameters; + orientation?: "portrait" | "landscape"; + page?: BiDiBrowsingContextPrintPageParameters; + pageRanges?: (JsUInt | string)[]; + scale?: number; + shrinkToFit?: boolean; +}; + +// browsingContext.PrintMarginParameters +export type BiDiBrowsingContextPrintMarginParameters = { + bottom?: number; + left?: number; + right?: number; + top?: number; +}; + +// browsingContext.PrintPageParameters +export type BiDiBrowsingContextPrintPageParameters = { + height?: number; + width?: number; +}; + +// browsingContext.Reload +export type BiDiBrowsingContextReloadCommand = { + method: "browsingContext.reload"; + params: BiDiBrowsingContextReloadParameters; +}; + +// browsingContext.ReloadParameters +export type BiDiBrowsingContextReloadParameters = { + context: BiDiBrowsingContextBrowsingContext; + ignoreCache?: boolean; + wait?: BiDiBrowsingContextReadinessState; +}; + +// browsingContext.SetBypassCSP +export type BiDiBrowsingContextSetBypassCSPCommand = { + method: "browsingContext.setBypassCSP"; + params: BiDiBrowsingContextSetBypassCSPParameters; +}; + +// browsingContext.SetBypassCSPParameters +export type BiDiBrowsingContextSetBypassCSPParameters = { + bypass: true | null; + contexts?: BiDiBrowsingContextBrowsingContext[]; + userContexts?: BiDiBrowserUserContext[]; +}; + +// browsingContext.SetViewport +export type BiDiBrowsingContextSetViewportCommand = { + method: "browsingContext.setViewport"; + params: BiDiBrowsingContextSetViewportParameters; +}; + +// browsingContext.SetViewportParameters +export type BiDiBrowsingContextSetViewportParameters = { + context?: BiDiBrowsingContextBrowsingContext; + viewport?: BiDiBrowsingContextViewport | null; + devicePixelRatio?: number | null; + userContexts?: BiDiBrowserUserContext[]; +}; + +// browsingContext.Viewport +export type BiDiBrowsingContextViewport = { + width: JsUInt; + height: JsUInt; +}; + +// browsingContext.StartScreencast +export type BiDiBrowsingContextStartScreencastCommand = { + method: "browsingContext.startScreencast"; + params: BiDiBrowsingContextStartScreencastParameters; +}; + +// browsingContext.StartScreencastParameters +export type BiDiBrowsingContextStartScreencastParameters = { + context: BiDiBrowsingContextBrowsingContext; + mimeType?: string; + video?: BiDiBrowsingContextMediaTrackConstraints; + audio?: boolean; +}; + +// browsingContext.MediaTrackConstraints +export type BiDiBrowsingContextMediaTrackConstraints = { + width?: JsUInt; + height?: JsUInt; + frameRate?: JsUInt; +}; + +// browsingContext.StopScreencast +export type BiDiBrowsingContextStopScreencastCommand = { + method: "browsingContext.stopScreencast"; + params: BiDiBrowsingContextStopScreencastParameters; +}; + +// browsingContext.StopScreencastParameters +export type BiDiBrowsingContextStopScreencastParameters = { + screencast: BiDiBrowsingContextScreencast; +}; + +// browsingContext.TraverseHistory +export type BiDiBrowsingContextTraverseHistoryCommand = { + method: "browsingContext.traverseHistory"; + params: BiDiBrowsingContextTraverseHistoryParameters; +}; + +// browsingContext.TraverseHistoryParameters +export type BiDiBrowsingContextTraverseHistoryParameters = { + context: BiDiBrowsingContextBrowsingContext; + delta: JsInt; +}; + +// BrowsingContextCommand +export type BiDiBrowsingContextCommand = + | BiDiBrowsingContextActivateCommand + | BiDiBrowsingContextCaptureScreenshotCommand + | BiDiBrowsingContextCloseCommand + | BiDiBrowsingContextCreateCommand + | BiDiBrowsingContextGetTreeCommand + | BiDiBrowsingContextHandleUserPromptCommand + | BiDiBrowsingContextLocateNodesCommand + | BiDiBrowsingContextNavigateCommand + | BiDiBrowsingContextPrintCommand + | BiDiBrowsingContextReloadCommand + | BiDiBrowsingContextSetBypassCSPCommand + | BiDiBrowsingContextSetViewportCommand + | BiDiBrowsingContextStartScreencastCommand + | BiDiBrowsingContextStopScreencastCommand + | BiDiBrowsingContextTraverseHistoryCommand; diff --git a/src/browser/bidi/types/command-data/emulation-command.ts b/src/browser/bidi/types/command-data/emulation-command.ts new file mode 100644 index 000000000..287bcf2c5 --- /dev/null +++ b/src/browser/bidi/types/command-data/emulation-command.ts @@ -0,0 +1,208 @@ +import { JsUInt } from "../generic"; +import { BiDiBrowserUserContext } from "../modules/browser"; +import { BiDiBrowsingContextBrowsingContext } from "../modules/browsing-context"; + +// emulation.SetForcedColorsModeThemeOverride +export type BiDiEmulationSetForcedColorsModeThemeOverrideCommand = { + method: "emulation.setForcedColorsModeThemeOverride"; + params: BiDiEmulationSetForcedColorsModeThemeOverrideParameters; +}; + +// emulation.SetForcedColorsModeThemeOverrideParameters +export type BiDiEmulationSetForcedColorsModeThemeOverrideParameters = { + theme: BiDiEmulationForcedColorsModeTheme | null; + contexts?: BiDiBrowsingContextBrowsingContext[]; + userContexts?: BiDiBrowserUserContext[]; +}; + +// emulation.ForcedColorsModeTheme +export type BiDiEmulationForcedColorsModeTheme = "light" | "dark"; + +// emulation.SetGeolocationOverride +export type BiDiEmulationSetGeolocationOverrideCommand = { + method: "emulation.setGeolocationOverride"; + params: BiDiEmulationSetGeolocationOverrideParameters; +}; + +// emulation.SetGeolocationOverrideParameters +export type BiDiEmulationSetGeolocationOverrideParameters = { + contexts?: BiDiBrowsingContextBrowsingContext[]; + userContexts?: BiDiBrowserUserContext[]; +} & ({ coordinates: BiDiEmulationGeolocationCoordinates | null } | { error: BiDiEmulationGeolocationPositionError }); + +// emulation.GeolocationCoordinates +export type BiDiEmulationGeolocationCoordinates = { + latitude: number; + longitude: number; + accuracy?: number; + altitude?: number | null; + altitudeAccuracy?: number | null; + heading?: number | null; + speed?: number | null; +}; + +// emulation.GeolocationPositionError +export type BiDiEmulationGeolocationPositionError = { + type: "positionUnavailable"; +}; + +// emulation.SetLocaleOverride +export type BiDiEmulationSetLocaleOverrideCommand = { + method: "emulation.setLocaleOverride"; + params: BiDiEmulationSetLocaleOverrideParameters; +}; + +// emulation.SetLocaleOverrideParameters +export type BiDiEmulationSetLocaleOverrideParameters = { + locale: string | null; + contexts?: BiDiBrowsingContextBrowsingContext[]; + userContexts?: BiDiBrowserUserContext[]; +}; + +// emulation.SetNetworkConditions +export type BiDiEmulationSetNetworkConditionsCommand = { + method: "emulation.setNetworkConditions"; + params: BiDiEmulationSetNetworkConditionsParameters; +}; + +// emulation.SetNetworkConditionsParameters +export type BiDiEmulationSetNetworkConditionsParameters = { + networkConditions: BiDiEmulationNetworkConditions | null; + contexts?: BiDiBrowsingContextBrowsingContext[]; + userContexts?: BiDiBrowserUserContext[]; +}; + +// emulation.NetworkConditions +export type BiDiEmulationNetworkConditions = BiDiEmulationNetworkConditionsOffline; + +// emulation.NetworkConditionsOffline +export type BiDiEmulationNetworkConditionsOffline = { + type: "offline"; +}; + +// emulation.SetScreenOrientationOverride +export type BiDiEmulationSetScreenOrientationOverrideCommand = { + method: "emulation.setScreenOrientationOverride"; + params: BiDiEmulationSetScreenOrientationOverrideParameters; +}; + +// emulation.SetScreenOrientationOverrideParameters +export type BiDiEmulationSetScreenOrientationOverrideParameters = { + screenOrientation: BiDiEmulationScreenOrientation | null; + contexts?: BiDiBrowsingContextBrowsingContext[]; + userContexts?: BiDiBrowserUserContext[]; +}; + +// emulation.ScreenOrientationNatural +export type BiDiEmulationScreenOrientationNatural = "portrait" | "landscape"; + +// emulation.ScreenOrientationType +export type BiDiEmulationScreenOrientationType = + | "portrait-primary" + | "portrait-secondary" + | "landscape-primary" + | "landscape-secondary"; + +// emulation.ScreenOrientation +export type BiDiEmulationScreenOrientation = { + natural: BiDiEmulationScreenOrientationNatural; + type: BiDiEmulationScreenOrientationType; +}; + +// emulation.SetScreenSettingsOverride +export type BiDiEmulationSetScreenSettingsOverrideCommand = { + method: "emulation.setScreenSettingsOverride"; + params: BiDiEmulationSetScreenSettingsOverrideParameters; +}; + +// emulation.SetScreenSettingsOverrideParameters +export type BiDiEmulationSetScreenSettingsOverrideParameters = { + screenArea: BiDiEmulationScreenArea | null; + contexts?: BiDiBrowsingContextBrowsingContext[]; + userContexts?: BiDiBrowserUserContext[]; +}; + +// emulation.ScreenArea +export type BiDiEmulationScreenArea = { + width: JsUInt; + height: JsUInt; +}; + +// emulation.SetScriptingEnabled +export type BiDiEmulationSetScriptingEnabledCommand = { + method: "emulation.setScriptingEnabled"; + params: BiDiEmulationSetScriptingEnabledParameters; +}; + +// emulation.SetScriptingEnabledParameters +export type BiDiEmulationSetScriptingEnabledParameters = { + enabled: false | null; + contexts?: BiDiBrowsingContextBrowsingContext[]; + userContexts?: BiDiBrowserUserContext[]; +}; + +// emulation.SetScrollbarTypeOverride +export type BiDiEmulationSetScrollbarTypeOverrideCommand = { + method: "emulation.setScrollbarTypeOverride"; + params: BiDiEmulationSetScrollbarTypeOverrideParameters; +}; + +// emulation.SetScrollbarTypeOverrideParameters +export type BiDiEmulationSetScrollbarTypeOverrideParameters = { + scrollbarType: "classic" | "overlay" | null; + contexts?: BiDiBrowsingContextBrowsingContext[]; + userContexts?: BiDiBrowserUserContext[]; +}; + +// emulation.SetTimezoneOverride +export type BiDiEmulationSetTimezoneOverrideCommand = { + method: "emulation.setTimezoneOverride"; + params: BiDiEmulationSetTimezoneOverrideParameters; +}; + +// emulation.SetTimezoneOverrideParameters +export type BiDiEmulationSetTimezoneOverrideParameters = { + timezone: string | null; + contexts?: BiDiBrowsingContextBrowsingContext[]; + userContexts?: BiDiBrowserUserContext[]; +}; + +// emulation.SetTouchOverride +export type BiDiEmulationSetTouchOverrideCommand = { + method: "emulation.setTouchOverride"; + params: BiDiEmulationSetTouchOverrideParameters; +}; + +// emulation.SetTouchOverrideParameters +export type BiDiEmulationSetTouchOverrideParameters = { + maxTouchPoints: JsUInt | null; + contexts?: BiDiBrowsingContextBrowsingContext[]; + userContexts?: BiDiBrowserUserContext[]; +}; + +// emulation.SetUserAgentOverride +export type BiDiEmulationSetUserAgentOverrideCommand = { + method: "emulation.setUserAgentOverride"; + params: BiDiEmulationSetUserAgentOverrideParameters; +}; + +// emulation.SetUserAgentOverrideParameters +export type BiDiEmulationSetUserAgentOverrideParameters = { + userAgent: string | null; + contexts?: BiDiBrowsingContextBrowsingContext[]; + userContexts?: BiDiBrowserUserContext[]; +}; + +// EmulationCommand +export type BiDiEmulationCommand = + | BiDiEmulationSetForcedColorsModeThemeOverrideCommand + | BiDiEmulationSetGeolocationOverrideCommand + | BiDiEmulationSetLocaleOverrideCommand + | BiDiEmulationSetNetworkConditionsCommand + | BiDiEmulationSetScreenOrientationOverrideCommand + | BiDiEmulationSetScreenSettingsOverrideCommand + | BiDiEmulationSetScriptingEnabledCommand + | BiDiEmulationSetScrollbarTypeOverrideCommand + | BiDiEmulationSetTimezoneOverrideCommand + | BiDiEmulationSetTouchOverrideCommand + | BiDiEmulationSetUserAgentOverrideCommand; diff --git a/src/browser/bidi/types/command-data/index.ts b/src/browser/bidi/types/command-data/index.ts new file mode 100644 index 000000000..9d18ffbbe --- /dev/null +++ b/src/browser/bidi/types/command-data/index.ts @@ -0,0 +1,31 @@ +import { BiDiBrowserCommand } from "./browser-command"; +import { BiDiBrowsingContextCommand } from "./browsing-context-command"; +import { BiDiEmulationCommand } from "./emulation-command"; +import { BiDiInputCommand } from "./input-command"; +import { BiDiNetworkCommand } from "./network-command"; +import { BiDiScriptCommand } from "./script-command"; +import { BiDiSessionCommand } from "./session-command"; +import { BiDiStorageCommand } from "./storage-command"; +import { BiDiWebExtensionCommand } from "./web-extension-command"; + +export * from "./browser-command"; +export * from "./browsing-context-command"; +export * from "./emulation-command"; +export * from "./input-command"; +export * from "./network-command"; +export * from "./script-command"; +export * from "./session-command"; +export * from "./storage-command"; +export * from "./web-extension-command"; + +// CommandData +export type BiDiCommandData = + | BiDiBrowserCommand + | BiDiBrowsingContextCommand + | BiDiEmulationCommand + | BiDiInputCommand + | BiDiNetworkCommand + | BiDiScriptCommand + | BiDiSessionCommand + | BiDiStorageCommand + | BiDiWebExtensionCommand; diff --git a/src/browser/bidi/types/command-data/input-command.ts b/src/browser/bidi/types/command-data/input-command.ts new file mode 100644 index 000000000..eef1923d0 --- /dev/null +++ b/src/browser/bidi/types/command-data/input-command.ts @@ -0,0 +1,45 @@ +import { BiDiBrowsingContextBrowsingContext } from "../modules/browsing-context"; +import { BiDiInputSourceActions } from "../modules/input"; +import { BiDiScriptSharedReference } from "../modules/script"; + +// input.PerformActions +export type BiDiInputPerformActionsCommand = { + method: "input.performActions"; + params: BiDiInputPerformActionsParameters; +}; + +// input.PerformActionsParameters +export type BiDiInputPerformActionsParameters = { + context: BiDiBrowsingContextBrowsingContext; + actions: BiDiInputSourceActions[]; +}; + +// input.ReleaseActions +export type BiDiInputReleaseActionsCommand = { + method: "input.releaseActions"; + params: BiDiInputReleaseActionsParameters; +}; + +// input.ReleaseActionsParameters +export type BiDiInputReleaseActionsParameters = { + context: BiDiBrowsingContextBrowsingContext; +}; + +// input.SetFiles +export type BiDiInputSetFilesCommand = { + method: "input.setFiles"; + params: BiDiInputSetFilesParameters; +}; + +// input.SetFilesParameters +export type BiDiInputSetFilesParameters = { + context: BiDiBrowsingContextBrowsingContext; + element: BiDiScriptSharedReference; + files: string[]; +}; + +// InputCommand +export type BiDiInputCommand = + | BiDiInputPerformActionsCommand + | BiDiInputReleaseActionsCommand + | BiDiInputSetFilesCommand; diff --git a/src/browser/bidi/types/command-data/network-command.ts b/src/browser/bidi/types/command-data/network-command.ts new file mode 100644 index 000000000..813aae045 --- /dev/null +++ b/src/browser/bidi/types/command-data/network-command.ts @@ -0,0 +1,218 @@ +import { JsUInt } from "../generic"; +import { BiDiBrowserUserContext } from "../modules/browser"; +import { BiDiBrowsingContextBrowsingContext } from "../modules/browsing-context"; +import { + BiDiNetworkAuthCredentials, + BiDiNetworkBytesValue, + BiDiNetworkCollector, + BiDiNetworkCollectorType, + BiDiNetworkCookieHeader, + BiDiNetworkDataType, + BiDiNetworkHeader, + BiDiNetworkIntercept, + BiDiNetworkRequest, + BiDiNetworkSetCookieHeader, + BiDiNetworkUrlPattern, +} from "../modules/network"; + +// network.AddDataCollector +export type BiDiNetworkAddDataCollectorCommand = { + method: "network.addDataCollector"; + params: BiDiNetworkAddDataCollectorParameters; +}; + +// network.AddDataCollectorParameters +export type BiDiNetworkAddDataCollectorParameters = { + dataTypes: BiDiNetworkDataType[]; + maxEncodedDataSize: JsUInt; + collectorType?: BiDiNetworkCollectorType; + contexts?: BiDiBrowsingContextBrowsingContext[]; + userContexts?: BiDiBrowserUserContext[]; +}; + +// network.AddIntercept +export type BiDiNetworkAddInterceptCommand = { + method: "network.addIntercept"; + params: BiDiNetworkAddInterceptParameters; +}; + +// network.AddInterceptParameters +export type BiDiNetworkAddInterceptParameters = { + phases: BiDiNetworkInterceptPhase[]; + contexts?: BiDiBrowsingContextBrowsingContext[]; + urlPatterns?: BiDiNetworkUrlPattern[]; +}; + +// network.InterceptPhase +export type BiDiNetworkInterceptPhase = "beforeRequestSent" | "responseStarted" | "authRequired"; + +// network.ContinueRequest +export type BiDiNetworkContinueRequestCommand = { + method: "network.continueRequest"; + params: BiDiNetworkContinueRequestParameters; +}; + +// network.ContinueRequestParameters +export type BiDiNetworkContinueRequestParameters = { + request: BiDiNetworkRequest; + body?: BiDiNetworkBytesValue; + cookies?: BiDiNetworkCookieHeader[]; + headers?: BiDiNetworkHeader[]; + method?: string; + url?: string; +}; + +// network.ContinueResponse +export type BiDiNetworkContinueResponseCommand = { + method: "network.continueResponse"; + params: BiDiNetworkContinueResponseParameters; +}; + +// network.ContinueResponseParameters +export type BiDiNetworkContinueResponseParameters = { + request: BiDiNetworkRequest; + cookies?: BiDiNetworkSetCookieHeader[]; + credentials?: BiDiNetworkAuthCredentials; + headers?: BiDiNetworkHeader[]; + reasonPhrase?: string; + statusCode?: JsUInt; +}; + +// network.ContinueWithAuth +export type BiDiNetworkContinueWithAuthCommand = { + method: "network.continueWithAuth"; + params: BiDiNetworkContinueWithAuthParameters; +}; + +// network.ContinueWithAuthParameters +export type BiDiNetworkContinueWithAuthParameters = { + request: BiDiNetworkRequest; +} & (BiDiNetworkContinueWithAuthCredentials | BiDiNetworkContinueWithAuthNoCredentials); + +// network.ContinueWithAuthCredentials +export type BiDiNetworkContinueWithAuthCredentials = { + action: "provideCredentials"; + credentials: BiDiNetworkAuthCredentials; +}; + +// network.ContinueWithAuthNoCredentials +export type BiDiNetworkContinueWithAuthNoCredentials = { + action: "default" | "cancel"; +}; + +// network.DisownData +export type BiDiNetworkDisownDataCommand = { + method: "network.disownData"; + params: BiDiNetworkDisownDataParameters; +}; + +// network.DisownDataParameters +export type BiDiNetworkDisownDataParameters = { + dataType: BiDiNetworkDataType; + collector: BiDiNetworkCollector; + request: BiDiNetworkRequest; +}; + +// network.FailRequest +export type BiDiNetworkFailRequestCommand = { + method: "network.failRequest"; + params: BiDiNetworkFailRequestParameters; +}; + +// network.FailRequestParameters +export type BiDiNetworkFailRequestParameters = { + request: BiDiNetworkRequest; +}; + +// network.GetData +export type BiDiNetworkGetDataCommand = { + method: "network.getData"; + params: BiDiNetworkGetDataParameters; +}; + +// network.GetDataParameters +export type BiDiNetworkGetDataParameters = { + dataType: BiDiNetworkDataType; + collector?: BiDiNetworkCollector; + disown?: boolean; + request: BiDiNetworkRequest; +}; + +// network.ProvideResponse +export type BiDiNetworkProvideResponseCommand = { + method: "network.provideResponse"; + params: BiDiNetworkProvideResponseParameters; +}; + +// network.ProvideResponseParameters +export type BiDiNetworkProvideResponseParameters = { + request: BiDiNetworkRequest; + body?: BiDiNetworkBytesValue; + cookies?: BiDiNetworkSetCookieHeader[]; + headers?: BiDiNetworkHeader[]; + reasonPhrase?: string; + statusCode?: JsUInt; +}; + +// network.RemoveDataCollector +export type BiDiNetworkRemoveDataCollectorCommand = { + method: "network.removeDataCollector"; + params: BiDiNetworkRemoveDataCollectorParameters; +}; + +// network.RemoveDataCollectorParameters +export type BiDiNetworkRemoveDataCollectorParameters = { + collector: BiDiNetworkCollector; +}; + +// network.RemoveIntercept +export type BiDiNetworkRemoveInterceptCommand = { + method: "network.removeIntercept"; + params: BiDiNetworkRemoveInterceptParameters; +}; + +// network.RemoveInterceptParameters +export type BiDiNetworkRemoveInterceptParameters = { + intercept: BiDiNetworkIntercept; +}; + +// network.SetCacheBehavior +export type BiDiNetworkSetCacheBehaviorCommand = { + method: "network.setCacheBehavior"; + params: BiDiNetworkSetCacheBehaviorParameters; +}; + +// network.SetCacheBehaviorParameters +export type BiDiNetworkSetCacheBehaviorParameters = { + cacheBehavior: "default" | "bypass"; + contexts?: BiDiBrowsingContextBrowsingContext[]; +}; + +// network.SetExtraHeaders +export type BiDiNetworkSetExtraHeadersCommand = { + method: "network.setExtraHeaders"; + params: BiDiNetworkSetExtraHeadersParameters; +}; + +// network.SetExtraHeadersParameters +export type BiDiNetworkSetExtraHeadersParameters = { + headers: BiDiNetworkHeader[]; + contexts?: BiDiBrowsingContextBrowsingContext[]; + userContexts?: BiDiBrowserUserContext[]; +}; + +// NetworkCommand +export type BiDiNetworkCommand = + | BiDiNetworkAddDataCollectorCommand + | BiDiNetworkAddInterceptCommand + | BiDiNetworkContinueRequestCommand + | BiDiNetworkContinueResponseCommand + | BiDiNetworkContinueWithAuthCommand + | BiDiNetworkDisownDataCommand + | BiDiNetworkFailRequestCommand + | BiDiNetworkGetDataCommand + | BiDiNetworkProvideResponseCommand + | BiDiNetworkRemoveDataCollectorCommand + | BiDiNetworkRemoveInterceptCommand + | BiDiNetworkSetCacheBehaviorCommand + | BiDiNetworkSetExtraHeadersCommand; diff --git a/src/browser/bidi/types/command-data/script-command.ts b/src/browser/bidi/types/command-data/script-command.ts new file mode 100644 index 000000000..e1edddab4 --- /dev/null +++ b/src/browser/bidi/types/command-data/script-command.ts @@ -0,0 +1,105 @@ +import { BiDiBrowsingContextBrowsingContext } from "../modules/browsing-context"; +import { BiDiBrowserUserContext } from "../modules/browser"; +import { + BiDiScriptChannelValue, + BiDiScriptHandle, + BiDiScriptLocalValue, + BiDiScriptPreloadScript, + BiDiScriptRealmType, + BiDiScriptResultOwnership, + BiDiScriptSerializationOptions, + BiDiScriptTarget, +} from "../modules/script"; + +// script.AddPreloadScript +export type BiDiScriptAddPreloadScriptCommand = { + method: "script.addPreloadScript"; + params: BiDiScriptAddPreloadScriptParameters; +}; + +// script.AddPreloadScriptParameters +export type BiDiScriptAddPreloadScriptParameters = { + functionDeclaration: string; + arguments?: BiDiScriptChannelValue[]; + contexts?: BiDiBrowsingContextBrowsingContext[]; + userContexts?: BiDiBrowserUserContext[]; + sandbox?: string; +}; + +// script.CallFunction +export type BiDiScriptCallFunctionCommand = { + method: "script.callFunction"; + params: BiDiScriptCallFunctionParameters; +}; + +// script.CallFunctionParameters +export type BiDiScriptCallFunctionParameters = { + functionDeclaration: string; + awaitPromise: boolean; + target: BiDiScriptTarget; + arguments?: BiDiScriptLocalValue[]; + resultOwnership?: BiDiScriptResultOwnership; + serializationOptions?: BiDiScriptSerializationOptions; + this?: BiDiScriptLocalValue; + userActivation?: boolean; +}; + +// script.Disown +export type BiDiScriptDisownCommand = { + method: "script.disown"; + params: BiDiScriptDisownParameters; +}; + +// script.DisownParameters +export type BiDiScriptDisownParameters = { + handles: BiDiScriptHandle[]; + target: BiDiScriptTarget; +}; + +// script.Evaluate +export type BiDiScriptEvaluateCommand = { + method: "script.evaluate"; + params: BiDiScriptEvaluateParameters; +}; + +// script.EvaluateParameters +export type BiDiScriptEvaluateParameters = { + expression: string; + target: BiDiScriptTarget; + awaitPromise: boolean; + resultOwnership?: BiDiScriptResultOwnership; + serializationOptions?: BiDiScriptSerializationOptions; + userActivation?: boolean; +}; + +// script.GetRealms +export type BiDiScriptGetRealmsCommand = { + method: "script.getRealms"; + params: BiDiScriptGetRealmsParameters; +}; + +// script.GetRealmsParameters +export type BiDiScriptGetRealmsParameters = { + context?: BiDiBrowsingContextBrowsingContext; + type?: BiDiScriptRealmType; +}; + +// script.RemovePreloadScript +export type BiDiScriptRemovePreloadScriptCommand = { + method: "script.removePreloadScript"; + params: BiDiScriptRemovePreloadScriptParameters; +}; + +// script.RemovePreloadScriptParameters +export type BiDiScriptRemovePreloadScriptParameters = { + script: BiDiScriptPreloadScript; +}; + +// ScriptCommand +export type BiDiScriptCommand = + | BiDiScriptAddPreloadScriptCommand + | BiDiScriptCallFunctionCommand + | BiDiScriptDisownCommand + | BiDiScriptEvaluateCommand + | BiDiScriptGetRealmsCommand + | BiDiScriptRemovePreloadScriptCommand; diff --git a/src/browser/bidi/types/command-data/session-command.ts b/src/browser/bidi/types/command-data/session-command.ts new file mode 100644 index 000000000..4fcf56f71 --- /dev/null +++ b/src/browser/bidi/types/command-data/session-command.ts @@ -0,0 +1,55 @@ +import { BiDiEmptyParams } from "../generic"; +import { + BiDiSessionCapabilitiesRequest, + BiDiSessionSubscribeParameters, + BiDiSessionUnsubscribeByAttributesRequest, + BiDiSessionUnsubscribeByIDRequest, +} from "../modules/session"; + +// session.Status +export type BiDiSessionStatusCommand = { + method: "session.status"; + params: BiDiEmptyParams; +}; + +// session.New +export type BiDiSessionNewCommand = { + method: "session.new"; + params: BiDiSessionNewParameters; +}; + +// session.NewParameters +export type BiDiSessionNewParameters = { + capabilities: BiDiSessionCapabilitiesRequest; +}; + +// session.End +export type BiDiSessionEndCommand = { + method: "session.end"; + params: BiDiEmptyParams; +}; + +// session.Subscribe +export type BiDiSessionSubscribeCommand = { + method: "session.subscribe"; + params: BiDiSessionSubscribeParameters; +}; + +// session.Unsubscribe +export type BiDiSessionUnsubscribeCommand = { + method: "session.unsubscribe"; + params: BiDiSessionUnsubscribeParameters; +}; + +// session.UnsubscribeParameters +export type BiDiSessionUnsubscribeParameters = + | BiDiSessionUnsubscribeByAttributesRequest + | BiDiSessionUnsubscribeByIDRequest; + +// SessionCommand +export type BiDiSessionCommand = + | BiDiSessionStatusCommand + | BiDiSessionNewCommand + | BiDiSessionEndCommand + | BiDiSessionSubscribeCommand + | BiDiSessionUnsubscribeCommand; diff --git a/src/browser/bidi/types/command-data/storage-command.ts b/src/browser/bidi/types/command-data/storage-command.ts new file mode 100644 index 000000000..14e1dee37 --- /dev/null +++ b/src/browser/bidi/types/command-data/storage-command.ts @@ -0,0 +1,88 @@ +import { JsUInt } from "../generic"; +import { BiDiBrowsingContextBrowsingContext } from "../modules/browsing-context"; +import { BiDiNetworkBytesValue, BiDiNetworkSameSite } from "../modules/network"; + +// storage.GetCookies +export type BiDiStorageGetCookiesCommand = { + method: "storage.getCookies"; + params: BiDiStorageGetCookiesParameters; +}; + +// storage.CookieFilter +export type BiDiStorageCookieFilter = { + name?: string; + value?: BiDiNetworkBytesValue; + domain?: string; + path?: string; + size?: JsUInt; + httpOnly?: boolean; + secure?: boolean; + sameSite?: BiDiNetworkSameSite; + expiry?: JsUInt; +}; + +// storage.BrowsingContextPartitionDescriptor +export type BiDiStorageBrowsingContextPartitionDescriptor = { + type: "context"; + context: BiDiBrowsingContextBrowsingContext; +}; + +// storage.StorageKeyPartitionDescriptor +export type BiDiStorageStorageKeyPartitionDescriptor = { + type: "storageKey"; + userContext?: string; + sourceOrigin?: string; +}; + +// storage.PartitionDescriptor +export type BiDiStoragePartitionDescriptor = + | BiDiStorageBrowsingContextPartitionDescriptor + | BiDiStorageStorageKeyPartitionDescriptor; + +// storage.GetCookiesParameters +export type BiDiStorageGetCookiesParameters = { + filter?: BiDiStorageCookieFilter; + partition?: BiDiStoragePartitionDescriptor; +}; + +// storage.SetCookie +export type BiDiStorageSetCookieCommand = { + method: "storage.setCookie"; + params: BiDiStorageSetCookieParameters; +}; + +// storage.PartialCookie +export type BiDiStoragePartialCookie = { + name: string; + value: BiDiNetworkBytesValue; + domain: string; + path?: string; + httpOnly?: boolean; + secure?: boolean; + sameSite?: BiDiNetworkSameSite; + expiry?: JsUInt; +}; + +// storage.SetCookieParameters +export type BiDiStorageSetCookieParameters = { + cookie: BiDiStoragePartialCookie; + partition?: BiDiStoragePartitionDescriptor; +}; + +// storage.DeleteCookies +export type BiDiStorageDeleteCookiesCommand = { + method: "storage.deleteCookies"; + params: BiDiStorageDeleteCookiesParameters; +}; + +// storage.DeleteCookiesParameters +export type BiDiStorageDeleteCookiesParameters = { + filter?: BiDiStorageCookieFilter; + partition?: BiDiStoragePartitionDescriptor; +}; + +// StorageCommand +export type BiDiStorageCommand = + | BiDiStorageDeleteCookiesCommand + | BiDiStorageGetCookiesCommand + | BiDiStorageSetCookieCommand; diff --git a/src/browser/bidi/types/command-data/web-extension-command.ts b/src/browser/bidi/types/command-data/web-extension-command.ts new file mode 100644 index 000000000..b0d6766e9 --- /dev/null +++ b/src/browser/bidi/types/command-data/web-extension-command.ts @@ -0,0 +1,50 @@ +import { BiDiWebExtensionExtension } from "../modules/web-extension"; + +// webExtension.Install +export type BiDiWebExtensionInstallCommand = { + method: "webExtension.install"; + params: BiDiWebExtensionInstallParameters; +}; + +// webExtension.InstallParameters +export type BiDiWebExtensionInstallParameters = { + extensionData: BiDiWebExtensionExtensionData; +}; + +// webExtension.ExtensionData +export type BiDiWebExtensionExtensionData = + | BiDiWebExtensionExtensionArchivePath + | BiDiWebExtensionExtensionBase64Encoded + | BiDiWebExtensionExtensionPath; + +// webExtension.ExtensionPath +export type BiDiWebExtensionExtensionPath = { + type: "path"; + path: string; +}; + +// webExtension.ExtensionArchivePath +export type BiDiWebExtensionExtensionArchivePath = { + type: "archivePath"; + path: string; +}; + +// webExtension.ExtensionBase64Encoded +export type BiDiWebExtensionExtensionBase64Encoded = { + type: "base64"; + value: string; +}; + +// webExtension.Uninstall +export type BiDiWebExtensionUninstallCommand = { + method: "webExtension.uninstall"; + params: BiDiWebExtensionUninstallParameters; +}; + +// webExtension.UninstallParameters +export type BiDiWebExtensionUninstallParameters = { + extension: BiDiWebExtensionExtension; +}; + +// WebExtensionCommand +export type BiDiWebExtensionCommand = BiDiWebExtensionInstallCommand | BiDiWebExtensionUninstallCommand; diff --git a/src/browser/bidi/types/event-data/browsing-context-event.ts b/src/browser/bidi/types/event-data/browsing-context-event.ts new file mode 100644 index 000000000..8d6514b14 --- /dev/null +++ b/src/browser/bidi/types/event-data/browsing-context-event.ts @@ -0,0 +1,163 @@ +import { JsUInt } from "../generic"; +import { + BiDiBrowsingContextBaseNavigationInfo, + BiDiBrowsingContextBrowsingContext, + BiDiBrowsingContextDownload, + BiDiBrowsingContextInfo, + BiDiBrowsingContextNavigationInfo, + BiDiBrowsingContextUserPromptType, +} from "../modules/browsing-context"; +import { BiDiBrowserUserContext } from "../modules/browser"; +import { BiDiSessionUserPromptHandlerType } from "../modules/session"; + +// browsingContext.ContextCreated +export type BiDiBrowsingContextContextCreatedEvent = { + method: "browsingContext.contextCreated"; + params: BiDiBrowsingContextInfo; +}; + +// browsingContext.ContextDestroyed +export type BiDiBrowsingContextContextDestroyedEvent = { + method: "browsingContext.contextDestroyed"; + params: BiDiBrowsingContextInfo; +}; + +// browsingContext.NavigationStarted +export type BiDiBrowsingContextNavigationStartedEvent = { + method: "browsingContext.navigationStarted"; + params: BiDiBrowsingContextNavigationInfo; +}; + +// browsingContext.FragmentNavigated +export type BiDiBrowsingContextFragmentNavigatedEvent = { + method: "browsingContext.fragmentNavigated"; + params: BiDiBrowsingContextNavigationInfo; +}; + +// browsingContext.HistoryUpdated +export type BiDiBrowsingContextHistoryUpdatedEvent = { + method: "browsingContext.historyUpdated"; + params: BiDiBrowsingContextHistoryUpdatedParameters; +}; + +// browsingContext.HistoryUpdatedParameters +export type BiDiBrowsingContextHistoryUpdatedParameters = { + context: BiDiBrowsingContextBrowsingContext; + timestamp: JsUInt; + url: string; + userContext?: BiDiBrowserUserContext; +}; + +// browsingContext.DomContentLoaded +export type BiDiBrowsingContextDomContentLoadedEvent = { + method: "browsingContext.domContentLoaded"; + params: BiDiBrowsingContextNavigationInfo; +}; + +// browsingContext.Load +export type BiDiBrowsingContextLoadEvent = { + method: "browsingContext.load"; + params: BiDiBrowsingContextNavigationInfo; +}; + +// browsingContext.DownloadWillBegin +export type BiDiBrowsingContextDownloadWillBeginEvent = { + method: "browsingContext.downloadWillBegin"; + params: BiDiBrowsingContextDownloadWillBeginParams; +}; + +// browsingContext.DownloadWillBeginParams +export type BiDiBrowsingContextDownloadWillBeginParams = { + download: BiDiBrowsingContextDownload; + suggestedFilename: string; +} & BiDiBrowsingContextBaseNavigationInfo; + +// browsingContext.DownloadEnd +export type BiDiBrowsingContextDownloadEndEvent = { + method: "browsingContext.downloadEnd"; + params: BiDiBrowsingContextDownloadEndParams; +}; + +// browsingContext.DownloadEndParams +export type BiDiBrowsingContextDownloadEndParams = + | BiDiBrowsingContextDownloadCanceledParams + | BiDiBrowsingContextDownloadCompleteParams; + +// browsingContext.DownloadCanceledParams +export type BiDiBrowsingContextDownloadCanceledParams = { + status: "canceled"; + download: BiDiBrowsingContextDownload; +} & BiDiBrowsingContextBaseNavigationInfo; + +// browsingContext.DownloadCompleteParams +export type BiDiBrowsingContextDownloadCompleteParams = { + status: "complete"; + download: BiDiBrowsingContextDownload; + filepath: string | null; +} & BiDiBrowsingContextBaseNavigationInfo; + +// browsingContext.NavigationAborted +export type BiDiBrowsingContextNavigationAbortedEvent = { + method: "browsingContext.navigationAborted"; + params: BiDiBrowsingContextNavigationInfo; +}; + +// browsingContext.NavigationCommitted +export type BiDiBrowsingContextNavigationCommittedEvent = { + method: "browsingContext.navigationCommitted"; + params: BiDiBrowsingContextNavigationInfo; +}; + +// browsingContext.NavigationFailed +export type BiDiBrowsingContextNavigationFailedEvent = { + method: "browsingContext.navigationFailed"; + params: BiDiBrowsingContextNavigationInfo; +}; + +// browsingContext.UserPromptClosed +export type BiDiBrowsingContextUserPromptClosedEvent = { + method: "browsingContext.userPromptClosed"; + params: BiDiBrowsingContextUserPromptClosedParameters; +}; + +// browsingContext.UserPromptClosedParameters +export type BiDiBrowsingContextUserPromptClosedParameters = { + context: BiDiBrowsingContextBrowsingContext; + accepted: boolean; + type: BiDiBrowsingContextUserPromptType; + userContext?: BiDiBrowserUserContext; + userText?: string; +}; + +// browsingContext.UserPromptOpened +export type BiDiBrowsingContextUserPromptOpenedEvent = { + method: "browsingContext.userPromptOpened"; + params: BiDiBrowsingContextUserPromptOpenedParameters; +}; + +// browsingContext.UserPromptOpenedParameters +export type BiDiBrowsingContextUserPromptOpenedParameters = { + context: BiDiBrowsingContextBrowsingContext; + handler: BiDiSessionUserPromptHandlerType; + message: string; + type: BiDiBrowsingContextUserPromptType; + userContext?: BiDiBrowserUserContext; + defaultValue?: string; +}; + +// BrowsingContextEvent +export type BiDiBrowsingContextEvent = + | BiDiBrowsingContextContextCreatedEvent + | BiDiBrowsingContextContextDestroyedEvent + | BiDiBrowsingContextDomContentLoadedEvent + | BiDiBrowsingContextDownloadEndEvent + | BiDiBrowsingContextDownloadWillBeginEvent + | BiDiBrowsingContextFragmentNavigatedEvent + | BiDiBrowsingContextHistoryUpdatedEvent + | BiDiBrowsingContextLoadEvent + | BiDiBrowsingContextNavigationAbortedEvent + | BiDiBrowsingContextNavigationCommittedEvent + | BiDiBrowsingContextNavigationFailedEvent + | BiDiBrowsingContextNavigationStartedEvent + | BiDiBrowsingContextUserPromptClosedEvent + | BiDiBrowsingContextUserPromptOpenedEvent; diff --git a/src/browser/bidi/types/event-data/index.ts b/src/browser/bidi/types/event-data/index.ts new file mode 100644 index 000000000..fb4b6d33c --- /dev/null +++ b/src/browser/bidi/types/event-data/index.ts @@ -0,0 +1,19 @@ +import { BiDiBrowsingContextEvent } from "./browsing-context-event"; +import { BiDiInputEvent } from "./input-event"; +import { BiDiLogEvent } from "./log-event"; +import { BiDiNetworkEvent } from "./network-event"; +import { BiDiScriptEvent } from "./script-event"; + +export * from "./browsing-context-event"; +export * from "./input-event"; +export * from "./log-event"; +export * from "./network-event"; +export * from "./script-event"; + +// EventData +export type BiDiEventData = + | BiDiBrowsingContextEvent + | BiDiInputEvent + | BiDiLogEvent + | BiDiNetworkEvent + | BiDiScriptEvent; diff --git a/src/browser/bidi/types/event-data/input-event.ts b/src/browser/bidi/types/event-data/input-event.ts new file mode 100644 index 000000000..514099229 --- /dev/null +++ b/src/browser/bidi/types/event-data/input-event.ts @@ -0,0 +1,20 @@ +import { BiDiBrowsingContextBrowsingContext } from "../modules/browsing-context"; +import { BiDiBrowserUserContext } from "../modules/browser"; +import { BiDiScriptSharedReference } from "../modules/script"; + +// input.FileDialogOpened +export type BiDiInputFileDialogOpenedEvent = { + method: "input.fileDialogOpened"; + params: BiDiInputFileDialogInfo; +}; + +// input.FileDialogInfo +export type BiDiInputFileDialogInfo = { + context: BiDiBrowsingContextBrowsingContext; + userContext?: BiDiBrowserUserContext; + element?: BiDiScriptSharedReference; + multiple: boolean; +}; + +// InputEvent +export type BiDiInputEvent = BiDiInputFileDialogOpenedEvent; diff --git a/src/browser/bidi/types/event-data/log-event.ts b/src/browser/bidi/types/event-data/log-event.ts new file mode 100644 index 000000000..0954508f1 --- /dev/null +++ b/src/browser/bidi/types/event-data/log-event.ts @@ -0,0 +1,10 @@ +import { BiDiLogLogEntry } from "../modules/log"; + +// log.EntryAdded +export type BiDiLogEntryAddedEvent = { + method: "log.entryAdded"; + params: BiDiLogLogEntry; +}; + +// LogEvent +export type BiDiLogEvent = BiDiLogEntryAddedEvent; diff --git a/src/browser/bidi/types/event-data/network-event.ts b/src/browser/bidi/types/event-data/network-event.ts new file mode 100644 index 000000000..d783782fc --- /dev/null +++ b/src/browser/bidi/types/event-data/network-event.ts @@ -0,0 +1,64 @@ +import { BiDiNetworkBaseParameters, BiDiNetworkInitiator, BiDiNetworkResponseData } from "../modules/network"; + +// network.AuthRequired +export type BiDiNetworkAuthRequiredEvent = { + method: "network.authRequired"; + params: BiDiNetworkAuthRequiredParameters; +}; + +// network.AuthRequiredParameters +export type BiDiNetworkAuthRequiredParameters = BiDiNetworkBaseParameters & { + response: BiDiNetworkResponseData; +}; + +// network.BeforeRequestSent +export type BiDiNetworkBeforeRequestSentEvent = { + method: "network.beforeRequestSent"; + params: BiDiNetworkBeforeRequestSentParameters; +}; + +// network.BeforeRequestSentParameters +export type BiDiNetworkBeforeRequestSentParameters = BiDiNetworkBaseParameters & { + initiator?: BiDiNetworkInitiator; +}; + +// network.FetchError +export type BiDiNetworkFetchErrorEvent = { + method: "network.fetchError"; + params: BiDiNetworkFetchErrorParameters; +}; + +// network.FetchErrorParameters +export type BiDiNetworkFetchErrorParameters = BiDiNetworkBaseParameters & { + errorText: string; +}; + +// network.ResponseCompleted +export type BiDiNetworkResponseCompletedEvent = { + method: "network.responseCompleted"; + params: BiDiNetworkResponseCompletedParameters; +}; + +// network.ResponseCompletedParameters +export type BiDiNetworkResponseCompletedParameters = BiDiNetworkBaseParameters & { + response: BiDiNetworkResponseData; +}; + +// network.ResponseStarted +export type BiDiNetworkResponseStartedEvent = { + method: "network.responseStarted"; + params: BiDiNetworkResponseStartedParameters; +}; + +// network.ResponseStartedParameters +export type BiDiNetworkResponseStartedParameters = BiDiNetworkBaseParameters & { + response: BiDiNetworkResponseData; +}; + +// NetworkEvent +export type BiDiNetworkEvent = + | BiDiNetworkAuthRequiredEvent + | BiDiNetworkBeforeRequestSentEvent + | BiDiNetworkFetchErrorEvent + | BiDiNetworkResponseCompletedEvent + | BiDiNetworkResponseStartedEvent; diff --git a/src/browser/bidi/types/event-data/script-event.ts b/src/browser/bidi/types/event-data/script-event.ts new file mode 100644 index 000000000..0a9945f6c --- /dev/null +++ b/src/browser/bidi/types/event-data/script-event.ts @@ -0,0 +1,40 @@ +import { + BiDiScriptChannel, + BiDiScriptRealm, + BiDiScriptRealmInfo, + BiDiScriptRemoteValue, + BiDiScriptSource, +} from "../modules/script"; + +// script.Message +export type BiDiScriptMessageEvent = { + method: "script.message"; + params: BiDiScriptMessageParameters; +}; + +// script.MessageParameters +export type BiDiScriptMessageParameters = { + channel: BiDiScriptChannel; + data: BiDiScriptRemoteValue; + source: BiDiScriptSource; +}; + +// script.RealmCreated +export type BiDiScriptRealmCreatedEvent = { + method: "script.realmCreated"; + params: BiDiScriptRealmInfo; +}; + +// script.RealmDestroyed +export type BiDiScriptRealmDestroyedEvent = { + method: "script.realmDestroyed"; + params: BiDiScriptRealmDestroyedParameters; +}; + +// script.RealmDestroyedParameters +export type BiDiScriptRealmDestroyedParameters = { + realm: BiDiScriptRealm; +}; + +// ScriptEvent +export type BiDiScriptEvent = BiDiScriptMessageEvent | BiDiScriptRealmCreatedEvent | BiDiScriptRealmDestroyedEvent; diff --git a/src/browser/bidi/types/generic.ts b/src/browser/bidi/types/generic.ts new file mode 100644 index 000000000..1cfcfde69 --- /dev/null +++ b/src/browser/bidi/types/generic.ts @@ -0,0 +1,10 @@ +// js-int = -9007199254740991..9007199254740991 +export type JsInt = number; +// js-uint = 0..9007199254740991 +export type JsUInt = number; + +// EmptyParams = { Extensible } +export type BiDiEmptyParams = Record; + +// EmptyResult = { Extensible } +export type BiDiEmptyResult = Record; diff --git a/src/browser/bidi/types/index.ts b/src/browser/bidi/types/index.ts new file mode 100644 index 000000000..254c358a1 --- /dev/null +++ b/src/browser/bidi/types/index.ts @@ -0,0 +1,72 @@ +import { JsUInt } from "./generic"; +import { BiDiCommandData } from "./command-data"; +import { BiDiResultData } from "./result-data"; +import { BiDiEventData } from "./event-data"; + +export * from "./generic"; +export * from "./command-data"; +export * from "./result-data"; +export * from "./event-data"; +export * from "./modules"; + +// Command = { id: js-uint, CommandData, Extensible } +export type BiDiCommand = { + id: JsUInt; +} & BiDiCommandData; + +// Message = CommandResponse / ErrorResponse / Event +export type BiDiMessage = BiDiCommandResponse | BiDiErrorResponse | BiDiEvent; + +// CommandResponse = { type: "success", id: js-uint, result: ResultData, Extensible } +export type BiDiCommandResponse = { + type: "success"; + id: JsUInt; + result: BiDiResultData; +}; + +// ErrorResponse = { type: "error", id: js-uint / null, error: ErrorCode, message: text, ? stacktrace: text, Extensible } +export type BiDiErrorResponse = { + type: "error"; + id: JsUInt | null; + error: BiDiErrorCode; + message: string; + stacktrace?: string; +}; + +// Event = { type: "event", EventData, Extensible } +export type BiDiEvent = { + type: "event"; +} & BiDiEventData; + +// ErrorCode = "invalid argument" / ... +export type BiDiErrorCode = + | "invalid argument" + | "invalid selector" + | "invalid session id" + | "invalid web extension" + | "move target out of bounds" + | "no such alert" + | "no such network collector" + | "no such element" + | "no such frame" + | "no such handle" + | "no such history entry" + | "no such intercept" + | "no such network data" + | "no such node" + | "no such request" + | "no such screencast" + | "no such script" + | "no such storage partition" + | "no such user context" + | "no such web extension" + | "session not created" + | "unable to capture screen" + | "unable to close browser" + | "unable to set cookie" + | "unable to set file input" + | "unavailable network data" + | "underspecified storage partition" + | "unknown command" + | "unknown error" + | "unsupported operation"; diff --git a/src/browser/bidi/types/modules/browser.ts b/src/browser/bidi/types/modules/browser.ts new file mode 100644 index 000000000..e12de1406 --- /dev/null +++ b/src/browser/bidi/types/modules/browser.ts @@ -0,0 +1,37 @@ +import { JsInt, JsUInt } from "../generic"; + +// browser.ClientWindow +export type BiDiBrowserClientWindow = string; + +// browser.ClientWindowInfo +export type BiDiBrowserClientWindowInfo = { + active: boolean; + clientWindow: BiDiBrowserClientWindow; + height: JsUInt; + state: "fullscreen" | "maximized" | "minimized" | "normal"; + width: JsUInt; + x: JsInt; + y: JsInt; +}; + +// browser.UserContext +export type BiDiBrowserUserContext = string; + +// browser.UserContextInfo +export type BiDiBrowserUserContextInfo = { + userContext: BiDiBrowserUserContext; +}; + +// browser.DownloadBehavior +export type BiDiBrowserDownloadBehavior = BiDiBrowserDownloadBehaviorAllowed | BiDiBrowserDownloadBehaviorDenied; + +// browser.DownloadBehaviorAllowed +export type BiDiBrowserDownloadBehaviorAllowed = { + type: "allowed"; + destinationFolder: string; +}; + +// browser.DownloadBehaviorDenied +export type BiDiBrowserDownloadBehaviorDenied = { + type: "denied"; +}; diff --git a/src/browser/bidi/types/modules/browsing-context.ts b/src/browser/bidi/types/modules/browsing-context.ts new file mode 100644 index 000000000..971455999 --- /dev/null +++ b/src/browser/bidi/types/modules/browsing-context.ts @@ -0,0 +1,92 @@ +import { JsUInt } from "../generic"; +import { BiDiBrowserClientWindow, BiDiBrowserUserContext } from "./browser"; + +// browsingContext.BrowsingContext +export type BiDiBrowsingContextBrowsingContext = string; + +// browsingContext.InfoList +export type BiDiBrowsingContextInfoList = BiDiBrowsingContextInfo[]; + +// browsingContext.Info +export type BiDiBrowsingContextInfo = { + children: BiDiBrowsingContextInfoList | null; + clientWindow: BiDiBrowserClientWindow; + context: BiDiBrowsingContextBrowsingContext; + originalOpener: BiDiBrowsingContextBrowsingContext | null; + url: string; + userContext: BiDiBrowserUserContext; + parent?: BiDiBrowsingContextBrowsingContext | null; +}; + +// browsingContext.Locator +export type BiDiBrowsingContextLocator = + | BiDiBrowsingContextAccessibilityLocator + | BiDiBrowsingContextCssLocator + | BiDiBrowsingContextContextLocator + | BiDiBrowsingContextInnerTextLocator + | BiDiBrowsingContextXPathLocator; + +// browsingContext.AccessibilityLocator +export type BiDiBrowsingContextAccessibilityLocator = { + type: "accessibility"; + value: { + name?: string; + role?: string; + }; +}; + +// browsingContext.CssLocator +export type BiDiBrowsingContextCssLocator = { + type: "css"; + value: string; +}; + +// browsingContext.ContextLocator +export type BiDiBrowsingContextContextLocator = { + type: "context"; + value: { + context: BiDiBrowsingContextBrowsingContext; + }; +}; + +// browsingContext.InnerTextLocator +export type BiDiBrowsingContextInnerTextLocator = { + type: "innerText"; + value: string; + ignoreCase?: boolean; + matchType?: "full" | "partial"; + maxDepth?: JsUInt; +}; + +// browsingContext.XPathLocator +export type BiDiBrowsingContextXPathLocator = { + type: "xpath"; + value: string; +}; + +// browsingContext.Navigation +export type BiDiBrowsingContextNavigation = string; + +// browsingContext.Download +export type BiDiBrowsingContextDownload = string; + +// browsingContext.BaseNavigationInfo +export type BiDiBrowsingContextBaseNavigationInfo = { + context: BiDiBrowsingContextBrowsingContext; + navigation: BiDiBrowsingContextNavigation | null; + timestamp: JsUInt; + url: string; + userContext?: BiDiBrowserUserContext; +}; + +// browsingContext.NavigationInfo +export type BiDiBrowsingContextNavigationInfo = BiDiBrowsingContextBaseNavigationInfo; + +// browsingContext.ReadinessState +export type BiDiBrowsingContextReadinessState = "none" | "interactive" | "complete"; + +// browsingContext.UserPromptType +export type BiDiBrowsingContextUserPromptType = "alert" | "beforeunload" | "confirm" | "prompt"; + +// browsingContext.Screencast +export type BiDiBrowsingContextScreencast = string; diff --git a/src/browser/bidi/types/modules/index.ts b/src/browser/bidi/types/modules/index.ts new file mode 100644 index 000000000..6584364d1 --- /dev/null +++ b/src/browser/bidi/types/modules/index.ts @@ -0,0 +1,9 @@ +export * from "./browser"; +export * from "./browsing-context"; +export * from "./input"; +export * from "./log"; +export * from "./network"; +export * from "./script"; +export * from "./session"; +export * from "./storage"; +export * from "./web-extension"; diff --git a/src/browser/bidi/types/modules/input.ts b/src/browser/bidi/types/modules/input.ts new file mode 100644 index 000000000..dfe4669e8 --- /dev/null +++ b/src/browser/bidi/types/modules/input.ts @@ -0,0 +1,132 @@ +import { JsInt, JsUInt } from "../generic"; +import { BiDiScriptSharedReference } from "./script"; + +// input.ElementOrigin +export type BiDiInputElementOrigin = { + type: "element"; + element: BiDiScriptSharedReference; +}; + +// input.Origin +export type BiDiInputOrigin = "viewport" | "pointer" | BiDiInputElementOrigin; + +// input.PointerCommonProperties +export type BiDiInputPointerCommonProperties = { + width?: JsUInt; + height?: JsUInt; + pressure?: number; + tangentialPressure?: number; + twist?: number; + altitudeAngle?: number; + azimuthAngle?: number; +}; + +// input.PauseAction +export type BiDiInputPauseAction = { + type: "pause"; + duration?: JsUInt; +}; + +// input.KeyDownAction +export type BiDiInputKeyDownAction = { + type: "keyDown"; + value: string; +}; + +// input.KeyUpAction +export type BiDiInputKeyUpAction = { + type: "keyUp"; + value: string; +}; + +// input.PointerUpAction +export type BiDiInputPointerUpAction = { + type: "pointerUp"; + button: JsUInt; +}; + +// input.PointerDownAction +export type BiDiInputPointerDownAction = { + type: "pointerDown"; + button: JsUInt; +} & BiDiInputPointerCommonProperties; + +// input.PointerMoveAction +export type BiDiInputPointerMoveAction = { + type: "pointerMove"; + x: number; + y: number; + duration?: JsUInt; + origin?: BiDiInputOrigin; +} & BiDiInputPointerCommonProperties; + +// input.WheelScrollAction +export type BiDiInputWheelScrollAction = { + type: "scroll"; + x: JsInt; + y: JsInt; + deltaX: JsInt; + deltaY: JsInt; + duration?: JsUInt; + origin?: BiDiInputOrigin; +}; + +// input.NoneSourceAction +export type BiDiInputNoneSourceAction = BiDiInputPauseAction; + +// input.KeySourceAction +export type BiDiInputKeySourceAction = BiDiInputPauseAction | BiDiInputKeyDownAction | BiDiInputKeyUpAction; + +// input.PointerType +export type BiDiInputPointerType = "mouse" | "pen" | "touch"; + +// input.PointerParameters +export type BiDiInputPointerParameters = { + pointerType?: BiDiInputPointerType; +}; + +// input.PointerSourceAction +export type BiDiInputPointerSourceAction = + | BiDiInputPauseAction + | BiDiInputPointerDownAction + | BiDiInputPointerUpAction + | BiDiInputPointerMoveAction; + +// input.WheelSourceAction +export type BiDiInputWheelSourceAction = BiDiInputPauseAction | BiDiInputWheelScrollAction; + +// input.NoneSourceActions +export type BiDiInputNoneSourceActions = { + type: "none"; + id: string; + actions: BiDiInputNoneSourceAction[]; +}; + +// input.KeySourceActions +export type BiDiInputKeySourceActions = { + type: "key"; + id: string; + actions: BiDiInputKeySourceAction[]; +}; + +// input.PointerSourceActions +export type BiDiInputPointerSourceActions = { + type: "pointer"; + id: string; + parameters?: BiDiInputPointerParameters; + actions: BiDiInputPointerSourceAction[]; +}; + +// input.WheelSourceActions +export type BiDiInputWheelSourceActions = { + type: "wheel"; + id: string; + actions: BiDiInputWheelSourceAction[]; +}; + +// input.SourceActions +export type BiDiInputSourceActions = + | BiDiInputNoneSourceActions + | BiDiInputKeySourceActions + | BiDiInputPointerSourceActions + | BiDiInputWheelSourceActions; diff --git a/src/browser/bidi/types/modules/log.ts b/src/browser/bidi/types/modules/log.ts new file mode 100644 index 000000000..9c67db429 --- /dev/null +++ b/src/browser/bidi/types/modules/log.ts @@ -0,0 +1,34 @@ +import { JsUInt } from "../generic"; +import { BiDiScriptRemoteValue, BiDiScriptSource, BiDiScriptStackTrace } from "./script"; + +// log.Level +export type BiDiLogLevel = "debug" | "info" | "warn" | "error"; + +// log.Entry +export type BiDiLogLogEntry = BiDiLogGenericLogEntry | BiDiLogConsoleLogEntry | BiDiLogJavascriptLogEntry; + +// log.BaseLogEntry +export type BiDiLogBaseLogEntry = { + level: BiDiLogLevel; + source: BiDiScriptSource; + text: string | null; + timestamp: JsUInt; + stackTrace?: BiDiScriptStackTrace; +}; + +// log.GenericLogEntry +export type BiDiLogGenericLogEntry = BiDiLogBaseLogEntry & { + type: string; +}; + +// log.ConsoleLogEntry +export type BiDiLogConsoleLogEntry = BiDiLogBaseLogEntry & { + type: "console"; + method: string; + args: BiDiScriptRemoteValue[]; +}; + +// log.JavascriptLogEntry +export type BiDiLogJavascriptLogEntry = BiDiLogBaseLogEntry & { + type: "javascript"; +}; diff --git a/src/browser/bidi/types/modules/network.ts b/src/browser/bidi/types/modules/network.ts new file mode 100644 index 000000000..3d7de7055 --- /dev/null +++ b/src/browser/bidi/types/modules/network.ts @@ -0,0 +1,180 @@ +import { JsInt, JsUInt } from "../generic"; +import { BiDiBrowserUserContext } from "./browser"; +import { BiDiBrowsingContextBrowsingContext, BiDiBrowsingContextNavigation } from "./browsing-context"; +import { BiDiScriptStackTrace } from "./script"; + +// network.AuthChallenge +export type BiDiNetworkAuthChallenge = { + scheme: string; + realm: string; +}; + +// network.AuthCredentials +export type BiDiNetworkAuthCredentials = { + type: "password"; + username: string; + password: string; +}; + +// network.BaseParameters +export type BiDiNetworkBaseParameters = { + context: BiDiBrowsingContextBrowsingContext | null; + isBlocked: boolean; + navigation: BiDiBrowsingContextNavigation | null; + redirectCount: JsUInt; + request: BiDiNetworkRequestData; + timestamp: JsUInt; + userContext?: BiDiBrowserUserContext | null; + intercepts?: BiDiNetworkIntercept[]; +}; + +// network.BytesValue +export type BiDiNetworkBytesValue = BiDiNetworkStringValue | BiDiNetworkBase64Value; + +// network.StringValue +export type BiDiNetworkStringValue = { + type: "string"; + value: string; +}; + +// network.Base64Value +export type BiDiNetworkBase64Value = { + type: "base64"; + value: string; +}; + +// network.Collector +export type BiDiNetworkCollector = string; + +// network.CollectorType +export type BiDiNetworkCollectorType = "blob"; + +// network.SameSite +export type BiDiNetworkSameSite = "strict" | "lax" | "none" | "default"; + +// network.Cookie +export type BiDiNetworkCookie = { + name: string; + value: BiDiNetworkBytesValue; + domain: string; + path: string; + size: JsUInt; + httpOnly: boolean; + secure: boolean; + sameSite: BiDiNetworkSameSite; + expiry?: JsUInt; +}; + +// network.CookieHeader +export type BiDiNetworkCookieHeader = { + name: string; + value: BiDiNetworkBytesValue; +}; + +// network.DataType +export type BiDiNetworkDataType = "request" | "response"; + +// network.FetchTimingInfo +export type BiDiNetworkFetchTimingInfo = { + timeOrigin: number; + requestTime: number; + redirectStart: number; + redirectEnd: number; + fetchStart: number; + dnsStart: number; + dnsEnd: number; + connectStart: number; + connectEnd: number; + tlsStart: number; + requestStart: number; + responseStart: number; + responseEnd: number; +}; + +// network.Header +export type BiDiNetworkHeader = { + name: string; + value: BiDiNetworkBytesValue; +}; + +// network.Initiator +export type BiDiNetworkInitiator = { + columnNumber?: JsUInt; + lineNumber?: JsUInt; + request?: BiDiNetworkRequest; + stackTrace?: BiDiScriptStackTrace; + type?: "parser" | "script" | "preflight" | "other"; +}; + +// network.Intercept +export type BiDiNetworkIntercept = string; + +// network.Request +export type BiDiNetworkRequest = string; + +// network.RequestData +export type BiDiNetworkRequestData = { + request: BiDiNetworkRequest; + url: string; + method: string; + headers: BiDiNetworkHeader[]; + cookies: BiDiNetworkCookie[]; + headersSize: JsUInt; + bodySize: JsUInt | null; + destination: string; + initiatorType: string | null; + timings: BiDiNetworkFetchTimingInfo; +}; + +// network.ResponseContent +export type BiDiNetworkResponseContent = { + size: JsUInt; +}; + +// network.ResponseData +export type BiDiNetworkResponseData = { + url: string; + protocol: string; + status: JsUInt; + statusText: string; + fromCache: boolean; + headers: BiDiNetworkHeader[]; + mimeType: string; + bytesReceived: JsUInt; + headersSize: JsUInt | null; + bodySize: JsUInt | null; + content: BiDiNetworkResponseContent; + authChallenges?: BiDiNetworkAuthChallenge[]; +}; + +// network.SetCookieHeader +export type BiDiNetworkSetCookieHeader = { + name: string; + value: BiDiNetworkBytesValue; + domain?: string; + httpOnly?: boolean; + expiry?: string; + maxAge?: JsInt; + path?: string; + sameSite?: BiDiNetworkSameSite; + secure?: boolean; +}; + +// network.UrlPattern +export type BiDiNetworkUrlPattern = BiDiNetworkUrlPatternPattern | BiDiNetworkUrlPatternString; + +// network.UrlPatternPattern +export type BiDiNetworkUrlPatternPattern = { + type: "pattern"; + protocol?: string; + hostname?: string; + port?: string; + pathname?: string; + search?: string; +}; + +// network.UrlPatternString +export type BiDiNetworkUrlPatternString = { + type: "string"; + pattern: string; +}; diff --git a/src/browser/bidi/types/modules/script.ts b/src/browser/bidi/types/modules/script.ts new file mode 100644 index 000000000..f6fdba983 --- /dev/null +++ b/src/browser/bidi/types/modules/script.ts @@ -0,0 +1,492 @@ +import { JsUInt } from "../generic"; +import { BiDiBrowserUserContext } from "./browser"; +import { BiDiBrowsingContextBrowsingContext } from "./browsing-context"; + +// script.Channel +export type BiDiScriptChannel = string; + +// script.ChannelProperties +export type BiDiScriptChannelProperties = { + channel: BiDiScriptChannel; + serializationOptions?: BiDiScriptSerializationOptions; + ownership?: BiDiScriptResultOwnership; +}; + +// script.ChannelValue +export type BiDiScriptChannelValue = { + type: "channel"; + value: BiDiScriptChannelProperties; +}; + +// script.EvaluateResult +export type BiDiScriptEvaluateResult = BiDiScriptEvaluateResultSuccess | BiDiScriptEvaluateResultException; + +// script.EvaluateResultSuccess +export type BiDiScriptEvaluateResultSuccess = { + type: "success"; + result: BiDiScriptRemoteValue; + realm: BiDiScriptRealm; +}; + +// script.EvaluateResultException +export type BiDiScriptEvaluateResultException = { + type: "exception"; + exceptionDetails: BiDiScriptExceptionDetails; + realm: BiDiScriptRealm; +}; + +// script.ExceptionDetails +export type BiDiScriptExceptionDetails = { + columnNumber: JsUInt; + exception: BiDiScriptRemoteValue; + lineNumber: JsUInt; + stackTrace: BiDiScriptStackTrace; + text: string; +}; + +// script.Handle +export type BiDiScriptHandle = string; + +// script.InternalId +export type BiDiScriptInternalId = string; + +// script.LocalValue +export type BiDiScriptLocalValue = + | BiDiScriptRemoteReference + | BiDiScriptPrimitiveProtocolValue + | BiDiScriptChannelValue + | BiDiScriptArrayLocalValue + | BiDiScriptDateLocalValue + | BiDiScriptMapLocalValue + | BiDiScriptObjectLocalValue + | BiDiScriptRegExpLocalValue + | BiDiScriptSetLocalValue; + +// script.ListLocalValue +export type BiDiScriptListLocalValue = BiDiScriptLocalValue[]; + +// script.ArrayLocalValue +export type BiDiScriptArrayLocalValue = { + type: "array"; + value: BiDiScriptListLocalValue; +}; + +// script.DateLocalValue +export type BiDiScriptDateLocalValue = { + type: "date"; + value: string; +}; + +// script.MappingLocalValue +export type BiDiScriptMappingLocalValue = [BiDiScriptLocalValue | string, BiDiScriptLocalValue][]; + +// script.MapLocalValue +export type BiDiScriptMapLocalValue = { + type: "map"; + value: BiDiScriptMappingLocalValue; +}; + +// script.ObjectLocalValue +export type BiDiScriptObjectLocalValue = { + type: "object"; + value: BiDiScriptMappingLocalValue; +}; + +// script.RegExpValue +export type BiDiScriptRegExpValue = { + pattern: string; + flags?: string; +}; + +// script.RegExpLocalValue +export type BiDiScriptRegExpLocalValue = { + type: "regexp"; + value: BiDiScriptRegExpValue; +}; + +// script.SetLocalValue +export type BiDiScriptSetLocalValue = { + type: "set"; + value: BiDiScriptListLocalValue; +}; + +// script.PreloadScript +export type BiDiScriptPreloadScript = string; + +// script.Realm +export type BiDiScriptRealm = string; + +// script.PrimitiveProtocolValue +export type BiDiScriptPrimitiveProtocolValue = + | BiDiScriptUndefinedValue + | BiDiScriptNullValue + | BiDiScriptStringValue + | BiDiScriptNumberValue + | BiDiScriptBooleanValue + | BiDiScriptBigIntValue; + +// script.UndefinedValue +export type BiDiScriptUndefinedValue = { + type: "undefined"; +}; + +// script.NullValue +export type BiDiScriptNullValue = { + type: "null"; +}; + +// script.StringValue +export type BiDiScriptStringValue = { + type: "string"; + value: string; +}; + +// script.SpecialNumber +export type BiDiScriptSpecialNumber = "NaN" | "-0" | "Infinity" | "-Infinity"; + +// script.NumberValue +export type BiDiScriptNumberValue = { + type: "number"; + value: number | BiDiScriptSpecialNumber; +}; + +// script.BooleanValue +export type BiDiScriptBooleanValue = { + type: "boolean"; + value: boolean; +}; + +// script.BigIntValue +export type BiDiScriptBigIntValue = { + type: "bigint"; + value: string; +}; + +// script.RealmInfo +export type BiDiScriptRealmInfo = + | BiDiScriptWindowRealmInfo + | BiDiScriptDedicatedWorkerRealmInfo + | BiDiScriptSharedWorkerRealmInfo + | BiDiScriptServiceWorkerRealmInfo + | BiDiScriptWorkerRealmInfo + | BiDiScriptPaintWorkletRealmInfo + | BiDiScriptAudioWorkletRealmInfo + | BiDiScriptWorkletRealmInfo; + +// script.BaseRealmInfo +export type BiDiScriptBaseRealmInfo = { + realm: BiDiScriptRealm; + origin: string; +}; + +// script.WindowRealmInfo +export type BiDiScriptWindowRealmInfo = BiDiScriptBaseRealmInfo & { + type: "window"; + context: BiDiBrowsingContextBrowsingContext; + userContext?: BiDiBrowserUserContext; + sandbox?: string; +}; + +// script.DedicatedWorkerRealmInfo +export type BiDiScriptDedicatedWorkerRealmInfo = BiDiScriptBaseRealmInfo & { + type: "dedicated-worker"; + owners: [BiDiScriptRealm]; +}; + +// script.SharedWorkerRealmInfo +export type BiDiScriptSharedWorkerRealmInfo = BiDiScriptBaseRealmInfo & { + type: "shared-worker"; +}; + +// script.ServiceWorkerRealmInfo +export type BiDiScriptServiceWorkerRealmInfo = BiDiScriptBaseRealmInfo & { + type: "service-worker"; +}; + +// script.WorkerRealmInfo +export type BiDiScriptWorkerRealmInfo = BiDiScriptBaseRealmInfo & { + type: "worker"; +}; + +// script.PaintWorkletRealmInfo +export type BiDiScriptPaintWorkletRealmInfo = BiDiScriptBaseRealmInfo & { + type: "paint-worklet"; +}; + +// script.AudioWorkletRealmInfo +export type BiDiScriptAudioWorkletRealmInfo = BiDiScriptBaseRealmInfo & { + type: "audio-worklet"; +}; + +// script.WorkletRealmInfo +export type BiDiScriptWorkletRealmInfo = BiDiScriptBaseRealmInfo & { + type: "worklet"; +}; + +// script.RealmType +export type BiDiScriptRealmType = + | "window" + | "dedicated-worker" + | "shared-worker" + | "service-worker" + | "worker" + | "paint-worklet" + | "audio-worklet" + | "worklet"; + +// script.RemoteReference +export type BiDiScriptRemoteReference = BiDiScriptSharedReference | BiDiScriptRemoteObjectReference; + +// script.SharedReference +export type BiDiScriptSharedReference = { + sharedId: BiDiScriptSharedId; + handle?: BiDiScriptHandle; +}; + +// script.RemoteObjectReference +export type BiDiScriptRemoteObjectReference = { + handle: BiDiScriptHandle; + sharedId?: BiDiScriptSharedId; +}; + +// script.RemoteValue +export type BiDiScriptRemoteValue = + | BiDiScriptPrimitiveProtocolValue + | BiDiScriptSymbolRemoteValue + | BiDiScriptArrayRemoteValue + | BiDiScriptObjectRemoteValue + | BiDiScriptFunctionRemoteValue + | BiDiScriptRegExpRemoteValue + | BiDiScriptDateRemoteValue + | BiDiScriptMapRemoteValue + | BiDiScriptSetRemoteValue + | BiDiScriptWeakMapRemoteValue + | BiDiScriptWeakSetRemoteValue + | BiDiScriptGeneratorRemoteValue + | BiDiScriptErrorRemoteValue + | BiDiScriptProxyRemoteValue + | BiDiScriptPromiseRemoteValue + | BiDiScriptTypedArrayRemoteValue + | BiDiScriptArrayBufferRemoteValue + | BiDiScriptNodeListRemoteValue + | BiDiScriptHTMLCollectionRemoteValue + | BiDiScriptNodeRemoteValue + | BiDiScriptWindowProxyRemoteValue; + +// script.ListRemoteValue +export type BiDiScriptListRemoteValue = BiDiScriptRemoteValue[]; + +// script.MappingRemoteValue +export type BiDiScriptMappingRemoteValue = [BiDiScriptRemoteValue | string, BiDiScriptRemoteValue][]; + +// script.SymbolRemoteValue +export type BiDiScriptSymbolRemoteValue = { + type: "symbol"; + handle?: BiDiScriptHandle; + internalId?: BiDiScriptInternalId; +}; + +// script.ArrayRemoteValue +export type BiDiScriptArrayRemoteValue = { + type: "array"; + handle?: BiDiScriptHandle; + internalId?: BiDiScriptInternalId; + value?: BiDiScriptListRemoteValue; +}; + +// script.ObjectRemoteValue +export type BiDiScriptObjectRemoteValue = { + type: "object"; + handle?: BiDiScriptHandle; + internalId?: BiDiScriptInternalId; + value?: BiDiScriptMappingRemoteValue; +}; + +// script.FunctionRemoteValue +export type BiDiScriptFunctionRemoteValue = { + type: "function"; + handle?: BiDiScriptHandle; + internalId?: BiDiScriptInternalId; +}; + +// script.RegExpRemoteValue +export type BiDiScriptRegExpRemoteValue = BiDiScriptRegExpLocalValue & { + handle?: BiDiScriptHandle; + internalId?: BiDiScriptInternalId; +}; + +// script.DateRemoteValue +export type BiDiScriptDateRemoteValue = BiDiScriptDateLocalValue & { + handle?: BiDiScriptHandle; + internalId?: BiDiScriptInternalId; +}; + +// script.MapRemoteValue +export type BiDiScriptMapRemoteValue = { + type: "map"; + handle?: BiDiScriptHandle; + internalId?: BiDiScriptInternalId; + value?: BiDiScriptMappingRemoteValue; +}; + +// script.SetRemoteValue +export type BiDiScriptSetRemoteValue = { + type: "set"; + handle?: BiDiScriptHandle; + internalId?: BiDiScriptInternalId; + value?: BiDiScriptListRemoteValue; +}; + +// script.WeakMapRemoteValue +export type BiDiScriptWeakMapRemoteValue = { + type: "weakmap"; + handle?: BiDiScriptHandle; + internalId?: BiDiScriptInternalId; +}; + +// script.WeakSetRemoteValue +export type BiDiScriptWeakSetRemoteValue = { + type: "weakset"; + handle?: BiDiScriptHandle; + internalId?: BiDiScriptInternalId; +}; + +// script.GeneratorRemoteValue +export type BiDiScriptGeneratorRemoteValue = { + type: "generator"; + handle?: BiDiScriptHandle; + internalId?: BiDiScriptInternalId; +}; + +// script.ErrorRemoteValue +export type BiDiScriptErrorRemoteValue = { + type: "error"; + handle?: BiDiScriptHandle; + internalId?: BiDiScriptInternalId; +}; + +// script.ProxyRemoteValue +export type BiDiScriptProxyRemoteValue = { + type: "proxy"; + handle?: BiDiScriptHandle; + internalId?: BiDiScriptInternalId; +}; + +// script.PromiseRemoteValue +export type BiDiScriptPromiseRemoteValue = { + type: "promise"; + handle?: BiDiScriptHandle; + internalId?: BiDiScriptInternalId; +}; + +// script.TypedArrayRemoteValue +export type BiDiScriptTypedArrayRemoteValue = { + type: "typedarray"; + handle?: BiDiScriptHandle; + internalId?: BiDiScriptInternalId; +}; + +// script.ArrayBufferRemoteValue +export type BiDiScriptArrayBufferRemoteValue = { + type: "arraybuffer"; + handle?: BiDiScriptHandle; + internalId?: BiDiScriptInternalId; +}; + +// script.NodeListRemoteValue +export type BiDiScriptNodeListRemoteValue = { + type: "nodelist"; + handle?: BiDiScriptHandle; + internalId?: BiDiScriptInternalId; + value?: BiDiScriptListRemoteValue; +}; + +// script.HTMLCollectionRemoteValue +export type BiDiScriptHTMLCollectionRemoteValue = { + type: "htmlcollection"; + handle?: BiDiScriptHandle; + internalId?: BiDiScriptInternalId; + value?: BiDiScriptListRemoteValue; +}; + +// script.NodeRemoteValue +export type BiDiScriptNodeRemoteValue = { + type: "node"; + sharedId?: BiDiScriptSharedId; + handle?: BiDiScriptHandle; + internalId?: BiDiScriptInternalId; + value?: BiDiScriptNodeProperties; +}; + +// script.NodeProperties +export type BiDiScriptNodeProperties = { + nodeType: JsUInt; + childNodeCount: JsUInt; + attributes?: Record; + children?: BiDiScriptNodeRemoteValue[]; + localName?: string; + mode?: "open" | "closed"; + namespaceURI?: string; + nodeValue?: string; + shadowRoot?: BiDiScriptNodeRemoteValue | null; +}; + +// script.WindowProxyRemoteValue +export type BiDiScriptWindowProxyRemoteValue = { + type: "window"; + value: BiDiScriptWindowProxyProperties; + handle?: BiDiScriptHandle; + internalId?: BiDiScriptInternalId; +}; + +// script.WindowProxyProperties +export type BiDiScriptWindowProxyProperties = { + context: BiDiBrowsingContextBrowsingContext; +}; + +// script.ResultOwnership +export type BiDiScriptResultOwnership = "root" | "none"; + +// script.SerializationOptions +export type BiDiScriptSerializationOptions = { + maxDomDepth?: JsUInt | null; + maxObjectDepth?: JsUInt | null; + includeShadowTree?: "none" | "open" | "all"; +}; + +// script.SharedId +export type BiDiScriptSharedId = string; + +// script.StackFrame +export type BiDiScriptStackFrame = { + columnNumber: JsUInt; + functionName: string; + lineNumber: JsUInt; + url: string; +}; + +// script.StackTrace +export type BiDiScriptStackTrace = { + callFrames: BiDiScriptStackFrame[]; +}; + +// script.Source +export type BiDiScriptSource = { + realm: BiDiScriptRealm; + context?: BiDiBrowsingContextBrowsingContext; + userContext?: BiDiBrowserUserContext; +}; + +// script.RealmTarget +export type BiDiScriptRealmTarget = { + realm: BiDiScriptRealm; +}; + +// script.ContextTarget +export type BiDiScriptContextTarget = { + context: BiDiBrowsingContextBrowsingContext; + sandbox?: string; +}; + +// script.Target +export type BiDiScriptTarget = BiDiScriptContextTarget | BiDiScriptRealmTarget; diff --git a/src/browser/bidi/types/modules/session.ts b/src/browser/bidi/types/modules/session.ts new file mode 100644 index 000000000..f3a626c45 --- /dev/null +++ b/src/browser/bidi/types/modules/session.ts @@ -0,0 +1,97 @@ +import { JsUInt } from "../generic"; +import { BiDiBrowsingContextBrowsingContext } from "./browsing-context"; +import { BiDiBrowserUserContext } from "./browser"; + +// session.CapabilitiesRequest +export type BiDiSessionCapabilitiesRequest = { + alwaysMatch?: BiDiSessionCapabilityRequest; + firstMatch?: BiDiSessionCapabilityRequest[]; +}; + +// session.CapabilityRequest +export type BiDiSessionCapabilityRequest = { + acceptInsecureCerts?: boolean; + browserName?: string; + browserVersion?: string; + platformName?: string; + proxy?: BiDiSessionProxyConfiguration; + unhandledPromptBehavior?: BiDiSessionUserPromptHandler; +}; + +// session.ProxyConfiguration +export type BiDiSessionProxyConfiguration = + | BiDiSessionAutodetectProxyConfiguration + | BiDiSessionDirectProxyConfiguration + | BiDiSessionManualProxyConfiguration + | BiDiSessionPacProxyConfiguration + | BiDiSessionSystemProxyConfiguration; + +// session.AutodetectProxyConfiguration +export type BiDiSessionAutodetectProxyConfiguration = { + proxyType: "autodetect"; +}; + +// session.DirectProxyConfiguration +export type BiDiSessionDirectProxyConfiguration = { + proxyType: "direct"; +}; + +// session.ManualProxyConfiguration +export type BiDiSessionManualProxyConfiguration = { + proxyType: "manual"; + httpProxy?: string; + sslProxy?: string; + socksProxy?: string; + socksVersion?: JsUInt; + noProxy?: string[]; +}; + +// session.SocksProxyConfiguration +export type BiDiSessionSocksProxyConfiguration = { + socksProxy: string; + socksVersion: JsUInt; +}; + +// session.PacProxyConfiguration +export type BiDiSessionPacProxyConfiguration = { + proxyType: "pac"; + proxyAutoconfigUrl: string; +}; + +// session.SystemProxyConfiguration +export type BiDiSessionSystemProxyConfiguration = { + proxyType: "system"; +}; + +// session.UserPromptHandler +export type BiDiSessionUserPromptHandler = { + alert?: BiDiSessionUserPromptHandlerType; + beforeUnload?: BiDiSessionUserPromptHandlerType; + confirm?: BiDiSessionUserPromptHandlerType; + default?: BiDiSessionUserPromptHandlerType; + file?: BiDiSessionUserPromptHandlerType; + prompt?: BiDiSessionUserPromptHandlerType; +}; + +// session.UserPromptHandlerType +export type BiDiSessionUserPromptHandlerType = "accept" | "dismiss" | "ignore"; + +// session.Subscription +export type BiDiSessionSubscription = string; + +// session.SubscribeParameters +export type BiDiSessionSubscribeParameters = { + events: string[]; + contexts?: BiDiBrowsingContextBrowsingContext[]; + userContexts?: BiDiBrowserUserContext[]; +}; + +// session.UnsubscribeByIDRequest +export type BiDiSessionUnsubscribeByIDRequest = { + subscriptions: BiDiSessionSubscription[]; +}; + +// session.UnsubscribeByAttributesRequest +export type BiDiSessionUnsubscribeByAttributesRequest = { + events: string[]; +}; diff --git a/src/browser/bidi/types/modules/storage.ts b/src/browser/bidi/types/modules/storage.ts new file mode 100644 index 000000000..3686ceb79 --- /dev/null +++ b/src/browser/bidi/types/modules/storage.ts @@ -0,0 +1,5 @@ +// storage.PartitionKey +export type BiDiStoragePartitionKey = { + userContext?: string; + sourceOrigin?: string; +}; diff --git a/src/browser/bidi/types/modules/web-extension.ts b/src/browser/bidi/types/modules/web-extension.ts new file mode 100644 index 000000000..aaa4335bc --- /dev/null +++ b/src/browser/bidi/types/modules/web-extension.ts @@ -0,0 +1,2 @@ +// webExtension.Extension +export type BiDiWebExtensionExtension = string; diff --git a/src/browser/bidi/types/result-data/browser-result.ts b/src/browser/bidi/types/result-data/browser-result.ts new file mode 100644 index 000000000..bccf32e73 --- /dev/null +++ b/src/browser/bidi/types/result-data/browser-result.ts @@ -0,0 +1,37 @@ +import { BiDiEmptyResult } from "../generic"; +import { BiDiBrowserClientWindowInfo, BiDiBrowserUserContextInfo } from "../modules/browser"; + +// browser.CloseResult +export type BiDiBrowserCloseResult = BiDiEmptyResult; + +// browser.CreateUserContextResult +export type BiDiBrowserCreateUserContextResult = BiDiBrowserUserContextInfo; + +// browser.GetClientWindowsResult +export type BiDiBrowserGetClientWindowsResult = { + clientWindows: BiDiBrowserClientWindowInfo[]; +}; + +// browser.GetUserContextsResult +export type BiDiBrowserGetUserContextsResult = { + userContexts: BiDiBrowserUserContextInfo[]; +}; + +// browser.RemoveUserContextResult +export type BiDiBrowserRemoveUserContextResult = BiDiEmptyResult; + +// browser.SetClientWindowStateResult +export type BiDiBrowserSetClientWindowStateResult = BiDiBrowserClientWindowInfo; + +// browser.SetDownloadBehaviorResult +export type BiDiBrowserSetDownloadBehaviorResult = BiDiEmptyResult; + +// BrowserResult +export type BiDiBrowserResult = + | BiDiBrowserCloseResult + | BiDiBrowserCreateUserContextResult + | BiDiBrowserGetClientWindowsResult + | BiDiBrowserGetUserContextsResult + | BiDiBrowserRemoveUserContextResult + | BiDiBrowserSetClientWindowStateResult + | BiDiBrowserSetDownloadBehaviorResult; diff --git a/src/browser/bidi/types/result-data/browsing-context-result.ts b/src/browser/bidi/types/result-data/browsing-context-result.ts new file mode 100644 index 000000000..858246648 --- /dev/null +++ b/src/browser/bidi/types/result-data/browsing-context-result.ts @@ -0,0 +1,92 @@ +import { BiDiEmptyResult } from "../generic"; +import { + BiDiBrowsingContextBrowsingContext, + BiDiBrowsingContextInfoList, + BiDiBrowsingContextNavigation, + BiDiBrowsingContextScreencast, +} from "../modules/browsing-context"; +import { BiDiBrowserUserContext } from "../modules/browser"; +import { BiDiScriptNodeRemoteValue } from "../modules/script"; + +// browsingContext.ActivateResult +export type BiDiBrowsingContextActivateResult = BiDiEmptyResult; + +// browsingContext.CaptureScreenshotResult +export type BiDiBrowsingContextCaptureScreenshotResult = { + data: string; +}; + +// browsingContext.CloseResult +export type BiDiBrowsingContextCloseResult = BiDiEmptyResult; + +// browsingContext.CreateResult +export type BiDiBrowsingContextCreateResult = { + context: BiDiBrowsingContextBrowsingContext; + userContext?: BiDiBrowserUserContext; +}; + +// browsingContext.GetTreeResult +export type BiDiBrowsingContextGetTreeResult = { + contexts: BiDiBrowsingContextInfoList; +}; + +// browsingContext.HandleUserPromptResult +export type BiDiBrowsingContextHandleUserPromptResult = BiDiEmptyResult; + +// browsingContext.LocateNodesResult +export type BiDiBrowsingContextLocateNodesResult = { + nodes: BiDiScriptNodeRemoteValue[]; +}; + +// browsingContext.NavigateResult +export type BiDiBrowsingContextNavigateResult = { + navigation: BiDiBrowsingContextNavigation | null; + url: string; +}; + +// browsingContext.PrintResult +export type BiDiBrowsingContextPrintResult = { + data: string; +}; + +// browsingContext.ReloadResult +export type BiDiBrowsingContextReloadResult = BiDiBrowsingContextNavigateResult; + +// browsingContext.SetBypassCSPResult +export type BiDiBrowsingContextSetBypassCSPResult = BiDiEmptyResult; + +// browsingContext.SetViewportResult +export type BiDiBrowsingContextSetViewportResult = BiDiEmptyResult; + +// browsingContext.StartScreencastResult +export type BiDiBrowsingContextStartScreencastResult = { + screencast: BiDiBrowsingContextScreencast; + path: string; +}; + +// browsingContext.StopScreencastResult +export type BiDiBrowsingContextStopScreencastResult = { + path: string; + error?: string; +}; + +// browsingContext.TraverseHistoryResult +export type BiDiBrowsingContextTraverseHistoryResult = BiDiEmptyResult; + +// BrowsingContextResult +export type BiDiBrowsingContextResult = + | BiDiBrowsingContextActivateResult + | BiDiBrowsingContextCaptureScreenshotResult + | BiDiBrowsingContextCloseResult + | BiDiBrowsingContextCreateResult + | BiDiBrowsingContextGetTreeResult + | BiDiBrowsingContextHandleUserPromptResult + | BiDiBrowsingContextLocateNodesResult + | BiDiBrowsingContextNavigateResult + | BiDiBrowsingContextPrintResult + | BiDiBrowsingContextReloadResult + | BiDiBrowsingContextSetBypassCSPResult + | BiDiBrowsingContextSetViewportResult + | BiDiBrowsingContextStartScreencastResult + | BiDiBrowsingContextStopScreencastResult + | BiDiBrowsingContextTraverseHistoryResult; diff --git a/src/browser/bidi/types/result-data/emulation-result.ts b/src/browser/bidi/types/result-data/emulation-result.ts new file mode 100644 index 000000000..042340295 --- /dev/null +++ b/src/browser/bidi/types/result-data/emulation-result.ts @@ -0,0 +1,46 @@ +import { BiDiEmptyResult } from "../generic"; + +// emulation.SetForcedColorsModeThemeOverrideResult +export type BiDiEmulationSetForcedColorsModeThemeOverrideResult = BiDiEmptyResult; + +// emulation.SetGeolocationOverrideResult +export type BiDiEmulationSetGeolocationOverrideResult = BiDiEmptyResult; + +// emulation.SetLocaleOverrideResult +export type BiDiEmulationSetLocaleOverrideResult = BiDiEmptyResult; + +// emulation.SetNetworkConditionsResult +export type BiDiEmulationSetNetworkConditionsResult = BiDiEmptyResult; + +// emulation.SetScreenOrientationOverrideResult +export type BiDiEmulationSetScreenOrientationOverrideResult = BiDiEmptyResult; + +// emulation.SetScreenSettingsOverrideResult +export type BiDiEmulationSetScreenSettingsOverrideResult = BiDiEmptyResult; + +// emulation.SetScriptingEnabledResult +export type BiDiEmulationSetScriptingEnabledResult = BiDiEmptyResult; + +// emulation.SetScrollbarTypeOverrideResult +export type BiDiEmulationSetScrollbarTypeOverrideResult = BiDiEmptyResult; + +// emulation.SetTimezoneOverrideResult +export type BiDiEmulationSetTimezoneOverrideResult = BiDiEmptyResult; + +// emulation.SetTouchOverrideResult +export type BiDiEmulationSetTouchOverrideResult = BiDiEmptyResult; + +// emulation.SetUserAgentOverrideResult +export type BiDiEmulationSetUserAgentOverrideResult = BiDiEmptyResult; + +// EmulationResult +export type BiDiEmulationResult = + | BiDiEmulationSetForcedColorsModeThemeOverrideResult + | BiDiEmulationSetGeolocationOverrideResult + | BiDiEmulationSetLocaleOverrideResult + | BiDiEmulationSetScreenOrientationOverrideResult + | BiDiEmulationSetScriptingEnabledResult + | BiDiEmulationSetScrollbarTypeOverrideResult + | BiDiEmulationSetTimezoneOverrideResult + | BiDiEmulationSetTouchOverrideResult + | BiDiEmulationSetUserAgentOverrideResult; diff --git a/src/browser/bidi/types/result-data/index.ts b/src/browser/bidi/types/result-data/index.ts new file mode 100644 index 000000000..afb04fe63 --- /dev/null +++ b/src/browser/bidi/types/result-data/index.ts @@ -0,0 +1,31 @@ +import { BiDiBrowserResult } from "./browser-result"; +import { BiDiBrowsingContextResult } from "./browsing-context-result"; +import { BiDiEmulationResult } from "./emulation-result"; +import { BiDiInputResult } from "./input-result"; +import { BiDiNetworkResult } from "./network-result"; +import { BiDiScriptResult } from "./script-result"; +import { BiDiSessionResult } from "./session-result"; +import { BiDiStorageResult } from "./storage-result"; +import { BiDiWebExtensionResult } from "./web-extension-result"; + +export * from "./browser-result"; +export * from "./browsing-context-result"; +export * from "./emulation-result"; +export * from "./input-result"; +export * from "./network-result"; +export * from "./script-result"; +export * from "./session-result"; +export * from "./storage-result"; +export * from "./web-extension-result"; + +// ResultData +export type BiDiResultData = + | BiDiBrowserResult + | BiDiBrowsingContextResult + | BiDiEmulationResult + | BiDiInputResult + | BiDiNetworkResult + | BiDiScriptResult + | BiDiSessionResult + | BiDiStorageResult + | BiDiWebExtensionResult; diff --git a/src/browser/bidi/types/result-data/input-result.ts b/src/browser/bidi/types/result-data/input-result.ts new file mode 100644 index 000000000..6528b8b67 --- /dev/null +++ b/src/browser/bidi/types/result-data/input-result.ts @@ -0,0 +1,13 @@ +import { BiDiEmptyResult } from "../generic"; + +// input.PerformActionsResult +export type BiDiInputPerformActionsResult = BiDiEmptyResult; + +// input.ReleaseActionsResult +export type BiDiInputReleaseActionsResult = BiDiEmptyResult; + +// input.SetFilesResult +export type BiDiInputSetFilesResult = BiDiEmptyResult; + +// InputResult +export type BiDiInputResult = BiDiInputPerformActionsResult | BiDiInputReleaseActionsResult | BiDiInputSetFilesResult; diff --git a/src/browser/bidi/types/result-data/network-result.ts b/src/browser/bidi/types/result-data/network-result.ts new file mode 100644 index 000000000..e2cc0bb6c --- /dev/null +++ b/src/browser/bidi/types/result-data/network-result.ts @@ -0,0 +1,63 @@ +import { BiDiEmptyResult } from "../generic"; +import { BiDiNetworkBytesValue, BiDiNetworkCollector, BiDiNetworkIntercept } from "../modules/network"; + +// network.AddDataCollectorResult +export type BiDiNetworkAddDataCollectorResult = { + collector: BiDiNetworkCollector; +}; + +// network.AddInterceptResult +export type BiDiNetworkAddInterceptResult = { + intercept: BiDiNetworkIntercept; +}; + +// network.ContinueRequestResult +export type BiDiNetworkContinueRequestResult = BiDiEmptyResult; + +// network.ContinueResponseResult +export type BiDiNetworkContinueResponseResult = BiDiEmptyResult; + +// network.ContinueWithAuthResult +export type BiDiNetworkContinueWithAuthResult = BiDiEmptyResult; + +// network.DisownDataResult +export type BiDiNetworkDisownDataResult = BiDiEmptyResult; + +// network.FailRequestResult +export type BiDiNetworkFailRequestResult = BiDiEmptyResult; + +// network.GetDataResult +export type BiDiNetworkGetDataResult = { + bytes: BiDiNetworkBytesValue; +}; + +// network.ProvideResponseResult +export type BiDiNetworkProvideResponseResult = BiDiEmptyResult; + +// network.RemoveDataCollectorResult +export type BiDiNetworkRemoveDataCollectorResult = BiDiEmptyResult; + +// network.RemoveInterceptResult +export type BiDiNetworkRemoveInterceptResult = BiDiEmptyResult; + +// network.SetCacheBehaviorResult +export type BiDiNetworkSetCacheBehaviorResult = BiDiEmptyResult; + +// network.SetExtraHeadersResult +export type BiDiNetworkSetExtraHeadersResult = BiDiEmptyResult; + +// NetworkResult +export type BiDiNetworkResult = + | BiDiNetworkAddDataCollectorResult + | BiDiNetworkAddInterceptResult + | BiDiNetworkContinueRequestResult + | BiDiNetworkContinueResponseResult + | BiDiNetworkContinueWithAuthResult + | BiDiNetworkDisownDataResult + | BiDiNetworkFailRequestResult + | BiDiNetworkGetDataResult + | BiDiNetworkProvideResponseResult + | BiDiNetworkRemoveDataCollectorResult + | BiDiNetworkRemoveInterceptResult + | BiDiNetworkSetCacheBehaviorResult + | BiDiNetworkSetExtraHeadersResult; diff --git a/src/browser/bidi/types/result-data/script-result.ts b/src/browser/bidi/types/result-data/script-result.ts new file mode 100644 index 000000000..df328ccda --- /dev/null +++ b/src/browser/bidi/types/result-data/script-result.ts @@ -0,0 +1,30 @@ +import { BiDiEmptyResult } from "../generic"; +import { BiDiScriptEvaluateResult, BiDiScriptPreloadScript, BiDiScriptRealmInfo } from "../modules/script"; + +// script.AddPreloadScriptResult +export type BiDiScriptAddPreloadScriptResult = { + script: BiDiScriptPreloadScript; +}; + +// script.CallFunctionResult +export type BiDiScriptCallFunctionResult = BiDiScriptEvaluateResult; + +// script.DisownResult +export type BiDiScriptDisownResult = BiDiEmptyResult; + +// script.GetRealmsResult +export type BiDiScriptGetRealmsResult = { + realms: BiDiScriptRealmInfo[]; +}; + +// script.RemovePreloadScriptResult +export type BiDiScriptRemovePreloadScriptResult = BiDiEmptyResult; + +// ScriptResult +export type BiDiScriptResult = + | BiDiScriptAddPreloadScriptResult + | BiDiScriptCallFunctionResult + | BiDiScriptDisownResult + | BiDiScriptEvaluateResult + | BiDiScriptGetRealmsResult + | BiDiScriptRemovePreloadScriptResult; diff --git a/src/browser/bidi/types/result-data/session-result.ts b/src/browser/bidi/types/result-data/session-result.ts new file mode 100644 index 000000000..0d5143947 --- /dev/null +++ b/src/browser/bidi/types/result-data/session-result.ts @@ -0,0 +1,47 @@ +import { BiDiEmptyResult } from "../generic"; +import { + BiDiSessionProxyConfiguration, + BiDiSessionSubscription, + BiDiSessionUserPromptHandler, +} from "../modules/session"; + +// session.StatusResult +export type BiDiSessionStatusResult = { + ready: boolean; + message: string; +}; + +// session.NewResult +export type BiDiSessionNewResult = { + sessionId: string; + capabilities: { + acceptInsecureCerts: boolean; + browserName: string; + browserVersion: string; + platformName: string; + setWindowRect: boolean; + userAgent: string; + proxy?: BiDiSessionProxyConfiguration; + unhandledPromptBehavior?: BiDiSessionUserPromptHandler; + webSocketUrl?: string; + }; +}; + +// session.EndResult +export type BiDiSessionEndResult = BiDiEmptyResult; + +// session.SubscribeResult +export type BiDiSessionSubscribeResult = { + subscription: BiDiSessionSubscription; +}; + +// session.UnsubscribeResult +export type BiDiSessionUnsubscribeResult = BiDiEmptyResult; + +// SessionResult +export type BiDiSessionResult = + | BiDiSessionStatusResult + | BiDiSessionNewResult + | BiDiSessionEndResult + | BiDiSessionSubscribeResult + | BiDiSessionUnsubscribeResult; diff --git a/src/browser/bidi/types/result-data/storage-result.ts b/src/browser/bidi/types/result-data/storage-result.ts new file mode 100644 index 000000000..5002411d9 --- /dev/null +++ b/src/browser/bidi/types/result-data/storage-result.ts @@ -0,0 +1,24 @@ +import { BiDiNetworkCookie } from "../modules/network"; +import { BiDiStoragePartitionKey } from "../modules/storage"; + +// storage.DeleteCookiesResult +export type BiDiStorageDeleteCookiesResult = { + partitionKey: BiDiStoragePartitionKey; +}; + +// storage.GetCookiesResult +export type BiDiStorageGetCookiesResult = { + cookies: BiDiNetworkCookie[]; + partitionKey: BiDiStoragePartitionKey; +}; + +// storage.SetCookieResult +export type BiDiStorageSetCookieResult = { + partitionKey: BiDiStoragePartitionKey; +}; + +// StorageResult +export type BiDiStorageResult = + | BiDiStorageDeleteCookiesResult + | BiDiStorageGetCookiesResult + | BiDiStorageSetCookieResult; diff --git a/src/browser/bidi/types/result-data/web-extension-result.ts b/src/browser/bidi/types/result-data/web-extension-result.ts new file mode 100644 index 000000000..0c4b97081 --- /dev/null +++ b/src/browser/bidi/types/result-data/web-extension-result.ts @@ -0,0 +1,13 @@ +import { BiDiEmptyResult } from "../generic"; +import { BiDiWebExtensionExtension } from "../modules/web-extension"; + +// webExtension.InstallResult +export type BiDiWebExtensionInstallResult = { + extension: BiDiWebExtensionExtension; +}; + +// webExtension.UninstallResult +export type BiDiWebExtensionUninstallResult = BiDiEmptyResult; + +// WebExtensionResult +export type BiDiWebExtensionResult = BiDiWebExtensionInstallResult | BiDiWebExtensionUninstallResult; diff --git a/src/browser/cdp/error.ts b/src/browser/cdp/error.ts index 83244477c..683cec92a 100644 --- a/src/browser/cdp/error.ts +++ b/src/browser/cdp/error.ts @@ -21,7 +21,7 @@ export class CDPRequestTimeoutError extends WsRequestTimeoutError {} export class CDPRequestError extends WsError { isRetryable(): boolean { - if (!this.code) { + if (typeof this.code !== "number") { return true; } diff --git a/src/browser/existing-browser.ts b/src/browser/existing-browser.ts index 77651c972..84accad6d 100644 --- a/src/browser/existing-browser.ts +++ b/src/browser/existing-browser.ts @@ -19,6 +19,7 @@ import { NEW_ISSUE_LINK } from "../constants/help"; import { runWithoutHistory } from "./history"; import type { SessionOptions } from "./types"; import { Page } from "puppeteer-core"; +import { BIDI } from "./bidi"; import { CDP } from "./cdp"; import { WSDriverRequestAgent } from "./wsdriver"; import type { ElementReference } from "@testplane/wdio-protocols"; @@ -91,6 +92,7 @@ export class ExistingBrowser extends Browser { protected _meta: Record; protected _calibration?: CalibrationResult; protected _clientBridge?: ClientBridge; + protected _bidi: BIDI | null = null; protected _cdp: CDP | null = null; protected _wsDriver: WSDriverRequestAgent | null = null; protected _tags: Set = new Set(); @@ -106,6 +108,8 @@ export class ExistingBrowser extends Browser { async init({ sessionId, sessionCaps, sessionOpts }: SessionOptions, calibrator: Calibrator): Promise { this._session = await this._attachSession({ sessionId, sessionCaps, sessionOpts }); + this._bidi = BIDI.create(this); + const cdpPromise = CDP.create(this).then(cdp => { this._cdp = cdp; }); @@ -164,6 +168,7 @@ export class ExistingBrowser extends Browser { quit(): void { this._cdp?.close(); + this._bidi?.close(); this._wsDriver?.close(); this._meta = this._initMeta(); } @@ -620,6 +625,10 @@ export class ExistingBrowser extends Browser { return [...this._tags]; } + get bidi(): BIDI | null { + return this._bidi; + } + get cdp(): CDP | null { return this._cdp; } diff --git a/src/ws-connection/error.ts b/src/ws-connection/error.ts index 62e26ba77..cf2e911e6 100644 --- a/src/ws-connection/error.ts +++ b/src/ws-connection/error.ts @@ -1,10 +1,10 @@ import { WS_ERROR_CODE } from "./constants"; export abstract class WsError extends Error { - public code?: number; + public code?: number | string; public requestId?: number; - constructor({ message, code, requestId }: { message: string; code?: number; requestId?: number }) { + constructor({ message, code, requestId }: { message: string; code?: number | string; requestId?: number }) { let errorMessage = message; if (code) { @@ -33,7 +33,7 @@ export class WsConnectionEstablishmentError extends WsError { } isRetryable(): boolean { - if (this.code && this.code >= 400 && this.code < 500) { + if (typeof this.code === "number" && this.code >= 400 && this.code < 500) { return false; }