Skip to content

Playwright is a framework for Web Testing and Automation. It allows testing Chromium, Firefox and WebKit with a single API.

feat(api): rename Inspector to Screencast (#39607)

Yury Semikhatskyb465d0419dc4
diff --git a/docs/src/api/class-page.md b/docs/src/api/class-page.md
index 10544cb6ca..0300069b02 100644
--- a/docs/src/api/class-page.md
+++ b/docs/src/api/class-page.md
@@ -2607,25 +2607,6 @@ Throws for non-input elements. However, if the element is inside the `<label>` e
### option: Page.inputValue.timeout = %%-input-timeout-js-%%
* since: v1.13
-## method: Page.inspector
-* since: v1.59
-* langs: js
-- returns: <[Inspector]>
-
-Returns the [Inspector] object associated with this page.
-
-**Usage**
-
-```js
-const inspector = page.inspector();
-inspector.on('screencastFrame', data => {
- console.log('received frame, jpeg size:', data.length);
-});
-await inspector.startScreencast();
-// ... perform actions ...
-await inspector.stopScreencast();
-```
-
## async method: Page.isChecked
* since: v1.8
* discouraged: Use locator-based [`method: Locator.isChecked`] instead. Read more about [locators](../locators.md).
@@ -3907,6 +3888,26 @@ Handler function to route the WebSocket.
Handler function to route the WebSocket.
+## method: Page.screencast
+* since: v1.59
+* langs: js
+- returns: <[Screencast]>
+
+Returns the [Screencast] object associated with this page.
+
+**Usage**
+
+```js
+const screencast = page.screencast();
+screencast.on('screencastFrame', data => {
+ console.log('received frame, jpeg size:', data.length);
+});
+await screencast.start();
+// ... perform actions ...
+await screencast.stop();
+```
+
+
## async method: Page.screenshot
* since: v1.8
- returns: <[Buffer]>
diff --git a/docs/src/api/class-inspector.md b/docs/src/api/class-screencast.md
similarity index 52%
rename from docs/src/api/class-inspector.md
rename to docs/src/api/class-screencast.md
index 14d719134d..b013d1e54a 100644
--- a/docs/src/api/class-inspector.md
+++ b/docs/src/api/class-screencast.md
@@ -1,10 +1,10 @@
-# class: Inspector
+# class: Screencast
* since: v1.59
* langs: js
-Interface to the Playwright inspector.
+Interface for capturing screencast frames from a page.
-## event: Inspector.screencastFrame
+## event: Screencast.screencastFrame
* since: v1.59
- argument: <[Object]>
- `data` <[Buffer]> JPEG-encoded frame data.
@@ -14,34 +14,34 @@ Emitted for each captured JPEG screencast frame while the screencast is running.
**Usage**
```js
-const inspector = page.inspector();
-inspector.on('screencastframe', ({ data, width, height }) => {
+const screencast = page.screencast();
+screencast.on('screencastframe', ({ data, width, height }) => {
console.log(`frame ${width}x${height}, jpeg size: ${data.length}`);
require('fs').writeFileSync('frame.jpg', data);
});
-await inspector.startScreencast({ maxSize: { width: 1200, height: 800 } });
+await screencast.start({ maxSize: { width: 1200, height: 800 } });
// ... perform actions ...
-await inspector.stopScreencast();
+await screencast.stop();
```
-## async method: Inspector.startScreencast
+## async method: Screencast.start
* since: v1.59
-Starts capturing screencast frames. Frames are emitted as [`event: Inspector.screencastFrame`] events.
+Starts capturing screencast frames. Frames are emitted as [`event: Screencast.screencastFrame`] events.
**Usage**
```js
-const inspector = page.inspector();
-inspector.on('screencastframe', ({ data, width, height }) => {
+const screencast = page.screencast();
+screencast.on('screencastframe', ({ data, width, height }) => {
console.log(`frame ${width}x${height}, size: ${data.length}`);
});
-await inspector.startScreencast({ maxSize: { width: 800, height: 600 } });
+await screencast.start({ maxSize: { width: 800, height: 600 } });
// ... perform actions ...
-await inspector.stopScreencast();
+await screencast.stop();
```
-### option: Inspector.startScreencast.maxSize
+### option: Screencast.start.maxSize
* since: v1.59
- `maxSize` ?<[Object]>
- `width` <[int]> Max frame width in pixels.
@@ -49,15 +49,15 @@ await inspector.stopScreencast();
Maximum screencast frame dimensions. The output frame may be smaller to preserve the page aspect ratio. Defaults to 800×800.
-## async method: Inspector.stopScreencast
+## async method: Screencast.stop
* since: v1.59
-Stops the screencast started with [`method: Inspector.startScreencast`].
+Stops the screencast started with [`method: Screencast.start`].
**Usage**
```js
-await inspector.startScreencast();
+await screencast.start();
// ... perform actions ...
-await inspector.stopScreencast();
+await screencast.stop();
```
diff --git a/packages/playwright-client/types/types.d.ts b/packages/playwright-client/types/types.d.ts
index 8af199cbed..94a3e2df32 100644
--- a/packages/playwright-client/types/types.d.ts
+++ b/packages/playwright-client/types/types.d.ts
@@ -3508,24 +3508,6 @@ export interface Page {
timeout?: number;
}): Promise<string>;
- /**
- * Returns the [Inspector](https://playwright.dev/docs/api/class-inspector) object associated with this page.
- *
- * **Usage**
- *
- * ```js
- * const inspector = page.inspector();
- * inspector.on('screencastFrame', data => {
- * console.log('received frame, jpeg size:', data.length);
- * });
- * await inspector.startScreencast();
- * // ... perform actions ...
- * await inspector.stopScreencast();
- * ```
- *
- */
- inspector(): Inspector;
-
/**
* **NOTE** Use locator-based [locator.isChecked([options])](https://playwright.dev/docs/api/class-locator#locator-is-checked)
* instead. Read more about [locators](https://playwright.dev/docs/locators).
@@ -4246,6 +4228,24 @@ export interface Page {
*/
routeWebSocket(url: string|RegExp|URLPattern|((url: URL) => boolean), handler: ((websocketroute: WebSocketRoute) => Promise<any>|any)): Promise<void>;
+ /**
+ * Returns the [Screencast](https://playwright.dev/docs/api/class-screencast) object associated with this page.
+ *
+ * **Usage**
+ *
+ * ```js
+ * const screencast = page.screencast();
+ * screencast.on('screencastFrame', data => {
+ * console.log('received frame, jpeg size:', data.length);
+ * });
+ * await screencast.start();
+ * // ... perform actions ...
+ * await screencast.stop();
+ * ```
+ *
+ */
+ screencast(): Screencast;
+
/**
* Returns the buffer with the captured screenshot.
* @param options
@@ -20601,165 +20601,6 @@ export interface FrameLocator {
owner(): Locator;
}
-/**
- * Interface to the Playwright inspector.
- */
-export interface Inspector {
- /**
- * Emitted for each captured JPEG screencast frame while the screencast is running.
- *
- * **Usage**
- *
- * ```js
- * const inspector = page.inspector();
- * inspector.on('screencastframe', ({ data, width, height }) => {
- * console.log(`frame ${width}x${height}, jpeg size: ${data.length}`);
- * require('fs').writeFileSync('frame.jpg', data);
- * });
- * await inspector.startScreencast({ maxSize: { width: 1200, height: 800 } });
- * // ... perform actions ...
- * await inspector.stopScreencast();
- * ```
- *
- */
- on(event: 'screencastframe', listener: (data: {
- /**
- * JPEG-encoded frame data.
- */
- data: Buffer;
- }) => any): this;
-
- /**
- * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.
- */
- once(event: 'screencastframe', listener: (data: {
- /**
- * JPEG-encoded frame data.
- */
- data: Buffer;
- }) => any): this;
-
- /**
- * Emitted for each captured JPEG screencast frame while the screencast is running.
- *
- * **Usage**
- *
- * ```js
- * const inspector = page.inspector();
- * inspector.on('screencastframe', ({ data, width, height }) => {
- * console.log(`frame ${width}x${height}, jpeg size: ${data.length}`);
- * require('fs').writeFileSync('frame.jpg', data);
- * });
- * await inspector.startScreencast({ maxSize: { width: 1200, height: 800 } });
- * // ... perform actions ...
- * await inspector.stopScreencast();
- * ```
- *
- */
- addListener(event: 'screencastframe', listener: (data: {
- /**
- * JPEG-encoded frame data.
- */
- data: Buffer;
- }) => any): this;
-
- /**
- * Removes an event listener added by `on` or `addListener`.
- */
- removeListener(event: 'screencastframe', listener: (data: {
- /**
- * JPEG-encoded frame data.
- */
- data: Buffer;
- }) => any): this;
-
- /**
- * Removes an event listener added by `on` or `addListener`.
- */
- off(event: 'screencastframe', listener: (data: {
- /**
- * JPEG-encoded frame data.
- */
- data: Buffer;
- }) => any): this;
-
- /**
- * Emitted for each captured JPEG screencast frame while the screencast is running.
- *
- * **Usage**
- *
- * ```js
- * const inspector = page.inspector();
- * inspector.on('screencastframe', ({ data, width, height }) => {
- * console.log(`frame ${width}x${height}, jpeg size: ${data.length}`);
- * require('fs').writeFileSync('frame.jpg', data);
- * });
- * await inspector.startScreencast({ maxSize: { width: 1200, height: 800 } });
- * // ... perform actions ...
- * await inspector.stopScreencast();
- * ```
- *
- */
- prependListener(event: 'screencastframe', listener: (data: {
- /**
- * JPEG-encoded frame data.
- */
- data: Buffer;
- }) => any): this;
-
- /**
- * Starts capturing screencast frames. Frames are emitted as
- * [inspector.on('screencastframe')](https://playwright.dev/docs/api/class-inspector#inspector-event-screencast-frame)
- * events.
- *
- * **Usage**
- *
- * ```js
- * const inspector = page.inspector();
- * inspector.on('screencastframe', ({ data, width, height }) => {
- * console.log(`frame ${width}x${height}, size: ${data.length}`);
- * });
- * await inspector.startScreencast({ maxSize: { width: 800, height: 600 } });
- * // ... perform actions ...
- * await inspector.stopScreencast();
- * ```
- *
- * @param options
- */
- startScreencast(options?: {
- /**
- * Maximum screencast frame dimensions. The output frame may be smaller to preserve the page aspect ratio. Defaults to
- * 800×800.
- */
- maxSize?: {
- /**
- * Max frame width in pixels.
- */
- width: number;
-
- /**
- * Max frame height in pixels.
- */
- height: number;
- };
- }): Promise<void>;
-
- /**
- * Stops the screencast started with
- * [inspector.startScreencast([options])](https://playwright.dev/docs/api/class-inspector#inspector-start-screencast).
- *
- * **Usage**
- *
- * ```js
- * await inspector.startScreencast();
- * // ... perform actions ...
- * await inspector.stopScreencast();
- * ```
- *
- */
- stopScreencast(): Promise<void>;
-}
-
/**
* Keyboard provides an api for managing a virtual keyboard. The high level api is
* [keyboard.type(text[, options])](https://playwright.dev/docs/api/class-keyboard#keyboard-type), which takes raw
@@ -21944,6 +21785,165 @@ export interface Route {
request(): Request;
}
+/**
+ * Interface for capturing screencast frames from a page.
+ */
+export interface Screencast {
+ /**
+ * Emitted for each captured JPEG screencast frame while the screencast is running.
+ *
+ * **Usage**
+ *
+ * ```js
+ * const screencast = page.screencast();
+ * screencast.on('screencastframe', ({ data, width, height }) => {
+ * console.log(`frame ${width}x${height}, jpeg size: ${data.length}`);
+ * require('fs').writeFileSync('frame.jpg', data);
+ * });
+ * await screencast.start({ maxSize: { width: 1200, height: 800 } });
+ * // ... perform actions ...
+ * await screencast.stop();
+ * ```
+ *
+ */
+ on(event: 'screencastframe', listener: (data: {
+ /**
+ * JPEG-encoded frame data.
+ */
+ data: Buffer;
+ }) => any): this;
+
+ /**
+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.
+ */
+ once(event: 'screencastframe', listener: (data: {
+ /**
+ * JPEG-encoded frame data.
+ */
+ data: Buffer;
+ }) => any): this;
+
+ /**
+ * Emitted for each captured JPEG screencast frame while the screencast is running.
+ *
+ * **Usage**
+ *
+ * ```js
+ * const screencast = page.screencast();
+ * screencast.on('screencastframe', ({ data, width, height }) => {
+ * console.log(`frame ${width}x${height}, jpeg size: ${data.length}`);
+ * require('fs').writeFileSync('frame.jpg', data);
+ * });
+ * await screencast.start({ maxSize: { width: 1200, height: 800 } });
+ * // ... perform actions ...
+ * await screencast.stop();
+ * ```
+ *
+ */
+ addListener(event: 'screencastframe', listener: (data: {
+ /**
+ * JPEG-encoded frame data.
+ */
+ data: Buffer;
+ }) => any): this;
+
+ /**
+ * Removes an event listener added by `on` or `addListener`.
+ */
+ removeListener(event: 'screencastframe', listener: (data: {
+ /**
+ * JPEG-encoded frame data.
+ */
+ data: Buffer;
+ }) => any): this;
+
+ /**
+ * Removes an event listener added by `on` or `addListener`.
+ */
+ off(event: 'screencastframe', listener: (data: {
+ /**
+ * JPEG-encoded frame data.
+ */
+ data: Buffer;
+ }) => any): this;
+
+ /**
+ * Emitted for each captured JPEG screencast frame while the screencast is running.
+ *
+ * **Usage**
+ *
+ * ```js
+ * const screencast = page.screencast();
+ * screencast.on('screencastframe', ({ data, width, height }) => {
+ * console.log(`frame ${width}x${height}, jpeg size: ${data.length}`);
+ * require('fs').writeFileSync('frame.jpg', data);
+ * });
+ * await screencast.start({ maxSize: { width: 1200, height: 800 } });
+ * // ... perform actions ...
+ * await screencast.stop();
+ * ```
+ *
+ */
+ prependListener(event: 'screencastframe', listener: (data: {
+ /**
+ * JPEG-encoded frame data.
+ */
+ data: Buffer;
+ }) => any): this;
+
+ /**
+ * Starts capturing screencast frames. Frames are emitted as
+ * [screencast.on('screencastframe')](https://playwright.dev/docs/api/class-screencast#screencast-event-screencast-frame)
+ * events.
+ *
+ * **Usage**
+ *
+ * ```js
+ * const screencast = page.screencast();
+ * screencast.on('screencastframe', ({ data, width, height }) => {
+ * console.log(`frame ${width}x${height}, size: ${data.length}`);
+ * });
+ * await screencast.start({ maxSize: { width: 800, height: 600 } });
+ * // ... perform actions ...
+ * await screencast.stop();
+ * ```
+ *
+ * @param options
+ */
+ start(options?: {
+ /**
+ * Maximum screencast frame dimensions. The output frame may be smaller to preserve the page aspect ratio. Defaults to
+ * 800×800.
+ */
+ maxSize?: {
+ /**
+ * Max frame width in pixels.
+ */
+ width: number;
+
+ /**
+ * Max frame height in pixels.
+ */
+ height: number;
+ };
+ }): Promise<void>;
+
+ /**
+ * Stops the screencast started with
+ * [screencast.start([options])](https://playwright.dev/docs/api/class-screencast#screencast-start).
+ *
+ * **Usage**
+ *
+ * ```js
+ * await screencast.start();
+ * // ... perform actions ...
+ * await screencast.stop();
+ * ```
+ *
+ */
+ stop(): Promise<void>;
+}
+
/**
* Selectors can be used to install custom selector engines. See [extensibility](https://playwright.dev/docs/extensibility) for more
* information.
diff --git a/packages/playwright-core/src/client/api.ts b/packages/playwright-core/src/client/api.ts
index 86b4eb2be3..9db785ed4f 100644
--- a/packages/playwright-core/src/client/api.ts
+++ b/packages/playwright-core/src/client/api.ts
@@ -29,7 +29,7 @@ export { Electron, ElectronApplication } from './electron';
export { FrameLocator, Locator } from './locator';
export { ElementHandle } from './elementHandle';
export { FileChooser } from './fileChooser';
-export type { Inspector } from './inspector';
+export type { Screencast } from './screencast';
export type { Logger } from './types';
export { TimeoutError } from './errors';
export { Frame } from './frame';
diff --git a/packages/playwright-core/src/client/page.ts b/packages/playwright-core/src/client/page.ts
index 996b6e303b..bb4a249b3b 100644
--- a/packages/playwright-core/src/client/page.ts
+++ b/packages/playwright-core/src/client/page.ts
@@ -31,7 +31,7 @@ import { Keyboard, Mouse, Touchscreen } from './input';
import { JSHandle, assertMaxArguments, parseResult, serializeArgument } from './jsHandle';
import { Request, Response, Route, RouteHandler, WebSocket, WebSocketRoute, WebSocketRouteHandler, validateHeaders } from './network';
import { Video } from './video';
-import { Inspector } from './inspector';
+import { Screencast } from './screencast';
import { Waiter } from './waiter';
import { Worker } from './worker';
import { TimeoutSettings } from './timeoutSettings';
@@ -102,7 +102,7 @@ export class Page extends ChannelOwner<channels.PageChannel> implements api.Page
readonly _bindings = new Map<string, (source: structs.BindingSource, ...args: any[]) => any>();
readonly _timeoutSettings: TimeoutSettings;
private _video: Video;
- private _inspector: Inspector;
+ private _screencast: Screencast;
readonly _opener: Page | null;
private _closeReason: string | undefined;
_closeWasCalled: boolean = false;
@@ -137,7 +137,7 @@ export class Page extends ChannelOwner<channels.PageChannel> implements api.Page
this._closed = initializer.isClosed;
this._opener = Page.fromNullable(initializer.opener);
this._video = new Video(this, this._connection, initializer.video ? Artifact.from(initializer.video) : undefined);
- this._inspector = new Inspector(this);
+ this._screencast = new Screencast(this);
this._channel.on('bindingCall', ({ binding }) => this._onBinding(BindingCall.from(binding)));
this._channel.on('close', () => this._onClose());
@@ -287,8 +287,8 @@ export class Page extends ChannelOwner<channels.PageChannel> implements api.Page
return this._video;
}
- inspector(): Inspector {
- return this._inspector;
+ screencast(): Screencast {
+ return this._screencast;
}
async pickLocator(): Promise<Locator> {
diff --git a/packages/playwright-core/src/client/inspector.ts b/packages/playwright-core/src/client/screencast.ts
similarity index 83%
rename from packages/playwright-core/src/client/inspector.ts
rename to packages/playwright-core/src/client/screencast.ts
index 81abf45bb5..618e54e8c7 100644
--- a/packages/playwright-core/src/client/inspector.ts
+++ b/packages/playwright-core/src/client/screencast.ts
@@ -19,7 +19,7 @@ import { EventEmitter } from './eventEmitter';
import type * as api from '../../types/types';
import type { Page } from './page';
-export class Inspector extends EventEmitter implements api.Inspector {
+export class Screencast extends EventEmitter implements api.Screencast {
private readonly _page: Page;
constructor(page: Page) {
@@ -28,11 +28,11 @@ export class Inspector extends EventEmitter implements api.Inspector {
this._page._channel.on('screencastFrame', ({ data }) => this.emit('screencastframe', { data }));
}
- async startScreencast(options: { maxSize?: { width: number, height: number } } = {}): Promise<void> {
+ async start(options: { maxSize?: { width: number, height: number } } = {}): Promise<void> {
await this._page._channel.startScreencast(options);
}
- async stopScreencast(): Promise<void> {
+ async stop(): Promise<void> {
await this._page._channel.stopScreencast();
}
}
diff --git a/packages/playwright-core/src/devtools/devtoolsController.ts b/packages/playwright-core/src/devtools/devtoolsController.ts
index fcb4206a74..31bbdfcb76 100644
--- a/packages/playwright-core/src/devtools/devtoolsController.ts
+++ b/packages/playwright-core/src/devtools/devtoolsController.ts
@@ -178,7 +178,7 @@ export class DevToolsConnection implements Transport, DevToolsChannel {
if (this.selectedPage) {
this._pageListeners.forEach(d => d.dispose());
this._pageListeners = [];
- await this.selectedPage.inspector().stopScreencast();
+ await this.selectedPage.screencast().stop();
}
this.selectedPage = page;
@@ -198,11 +198,11 @@ export class DevToolsConnection implements Transport, DevToolsChannel {
if (frame === page.mainFrame())
this._sendTabList();
}),
- eventsHelper.addEventListener(page.inspector(), 'screencastframe', ({ data }) => this._writeFrame(data, page.viewportSize()?.width ?? 0, page.viewportSize()?.height ?? 0))
+ eventsHelper.addEventListener(page.screencast(), 'screencastframe', ({ data }) => this._writeFrame(data, page.viewportSize()?.width ?? 0, page.viewportSize()?.height ?? 0))
);
const maxSize = { width: 1280, height: 800 };
- await page.inspector().startScreencast({ maxSize });
+ await page.screencast().start({ maxSize });
}
private _deselectPage() {
@@ -210,7 +210,7 @@ export class DevToolsConnection implements Transport, DevToolsChannel {
return;
this._pageListeners.forEach(d => d.dispose());
this._pageListeners = [];
- this.selectedPage.inspector().stopScreencast().catch(() => {});
+ this.selectedPage.screencast().stop().catch(() => {});
this.selectedPage = null;
this._lastFrameData = null;
this._lastViewportSize = null;
diff --git a/packages/playwright-core/types/types.d.ts b/packages/playwright-core/types/types.d.ts
index 8af199cbed..94a3e2df32 100644
--- a/packages/playwright-core/types/types.d.ts
+++ b/packages/playwright-core/types/types.d.ts
@@ -3508,24 +3508,6 @@ export interface Page {
timeout?: number;
}): Promise<string>;
- /**
- * Returns the [Inspector](https://playwright.dev/docs/api/class-inspector) object associated with this page.
- *
- * **Usage**
- *
- * ```js
- * const inspector = page.inspector();
- * inspector.on('screencastFrame', data => {
- * console.log('received frame, jpeg size:', data.length);
- * });
- * await inspector.startScreencast();
- * // ... perform actions ...
- * await inspector.stopScreencast();
- * ```
- *
- */
- inspector(): Inspector;
-
/**
* **NOTE** Use locator-based [locator.isChecked([options])](https://playwright.dev/docs/api/class-locator#locator-is-checked)
* instead. Read more about [locators](https://playwright.dev/docs/locators).
@@ -4246,6 +4228,24 @@ export interface Page {
*/
routeWebSocket(url: string|RegExp|URLPattern|((url: URL) => boolean), handler: ((websocketroute: WebSocketRoute) => Promise<any>|any)): Promise<void>;
+ /**
+ * Returns the [Screencast](https://playwright.dev/docs/api/class-screencast) object associated with this page.
+ *
+ * **Usage**
+ *
+ * ```js
+ * const screencast = page.screencast();
+ * screencast.on('screencastFrame', data => {
+ * console.log('received frame, jpeg size:', data.length);
+ * });
+ * await screencast.start();
+ * // ... perform actions ...
+ * await screencast.stop();
+ * ```
+ *
+ */
+ screencast(): Screencast;
+
/**
* Returns the buffer with the captured screenshot.
* @param options
@@ -20601,165 +20601,6 @@ export interface FrameLocator {
owner(): Locator;
}
-/**
- * Interface to the Playwright inspector.
- */
-export interface Inspector {
- /**
- * Emitted for each captured JPEG screencast frame while the screencast is running.
- *
- * **Usage**
- *
- * ```js
- * const inspector = page.inspector();
- * inspector.on('screencastframe', ({ data, width, height }) => {
- * console.log(`frame ${width}x${height}, jpeg size: ${data.length}`);
- * require('fs').writeFileSync('frame.jpg', data);
- * });
- * await inspector.startScreencast({ maxSize: { width: 1200, height: 800 } });
- * // ... perform actions ...
- * await inspector.stopScreencast();
- * ```
- *
- */
- on(event: 'screencastframe', listener: (data: {
- /**
- * JPEG-encoded frame data.
- */
- data: Buffer;
- }) => any): this;
-
- /**
- * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.
- */
- once(event: 'screencastframe', listener: (data: {
- /**
- * JPEG-encoded frame data.
- */
- data: Buffer;
- }) => any): this;
-
- /**
- * Emitted for each captured JPEG screencast frame while the screencast is running.
- *
- * **Usage**
- *
- * ```js
- * const inspector = page.inspector();
- * inspector.on('screencastframe', ({ data, width, height }) => {
- * console.log(`frame ${width}x${height}, jpeg size: ${data.length}`);
- * require('fs').writeFileSync('frame.jpg', data);
- * });
- * await inspector.startScreencast({ maxSize: { width: 1200, height: 800 } });
- * // ... perform actions ...
- * await inspector.stopScreencast();
- * ```
- *
- */
- addListener(event: 'screencastframe', listener: (data: {
- /**
- * JPEG-encoded frame data.
- */
- data: Buffer;
- }) => any): this;
-
- /**
- * Removes an event listener added by `on` or `addListener`.
- */
- removeListener(event: 'screencastframe', listener: (data: {
- /**
- * JPEG-encoded frame data.
- */
- data: Buffer;
- }) => any): this;
-
- /**
- * Removes an event listener added by `on` or `addListener`.
- */
- off(event: 'screencastframe', listener: (data: {
- /**
- * JPEG-encoded frame data.
- */
- data: Buffer;
- }) => any): this;
-
- /**
- * Emitted for each captured JPEG screencast frame while the screencast is running.
- *
- * **Usage**
- *
- * ```js
- * const inspector = page.inspector();
- * inspector.on('screencastframe', ({ data, width, height }) => {
- * console.log(`frame ${width}x${height}, jpeg size: ${data.length}`);
- * require('fs').writeFileSync('frame.jpg', data);
- * });
- * await inspector.startScreencast({ maxSize: { width: 1200, height: 800 } });
- * // ... perform actions ...
- * await inspector.stopScreencast();
- * ```
- *
- */
- prependListener(event: 'screencastframe', listener: (data: {
- /**
- * JPEG-encoded frame data.
- */
- data: Buffer;
- }) => any): this;
-
- /**
- * Starts capturing screencast frames. Frames are emitted as
- * [inspector.on('screencastframe')](https://playwright.dev/docs/api/class-inspector#inspector-event-screencast-frame)
- * events.
- *
- * **Usage**
- *
- * ```js
- * const inspector = page.inspector();
- * inspector.on('screencastframe', ({ data, width, height }) => {
- * console.log(`frame ${width}x${height}, size: ${data.length}`);
- * });
- * await inspector.startScreencast({ maxSize: { width: 800, height: 600 } });
- * // ... perform actions ...
- * await inspector.stopScreencast();
- * ```
- *
- * @param options
- */
- startScreencast(options?: {
- /**
- * Maximum screencast frame dimensions. The output frame may be smaller to preserve the page aspect ratio. Defaults to
- * 800×800.
- */
- maxSize?: {
- /**
- * Max frame width in pixels.
- */
- width: number;
-
- /**
- * Max frame height in pixels.
- */
- height: number;
- };
- }): Promise<void>;
-
- /**
- * Stops the screencast started with
- * [inspector.startScreencast([options])](https://playwright.dev/docs/api/class-inspector#inspector-start-screencast).
- *
- * **Usage**
- *
- * ```js
- * await inspector.startScreencast();
- * // ... perform actions ...
- * await inspector.stopScreencast();
- * ```
- *
- */
- stopScreencast(): Promise<void>;
-}
-
/**
* Keyboard provides an api for managing a virtual keyboard. The high level api is
* [keyboard.type(text[, options])](https://playwright.dev/docs/api/class-keyboard#keyboard-type), which takes raw
@@ -21944,6 +21785,165 @@ export interface Route {
request(): Request;
}
+/**
+ * Interface for capturing screencast frames from a page.
+ */
+export interface Screencast {
+ /**
+ * Emitted for each captured JPEG screencast frame while the screencast is running.
+ *
+ * **Usage**
+ *
+ * ```js
+ * const screencast = page.screencast();
+ * screencast.on('screencastframe', ({ data, width, height }) => {
+ * console.log(`frame ${width}x${height}, jpeg size: ${data.length}`);
+ * require('fs').writeFileSync('frame.jpg', data);
+ * });
+ * await screencast.start({ maxSize: { width: 1200, height: 800 } });
+ * // ... perform actions ...
+ * await screencast.stop();
+ * ```
+ *
+ */
+ on(event: 'screencastframe', listener: (data: {
+ /**
+ * JPEG-encoded frame data.
+ */
+ data: Buffer;
+ }) => any): this;
+
+ /**
+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.
+ */
+ once(event: 'screencastframe', listener: (data: {
+ /**
+ * JPEG-encoded frame data.
+ */
+ data: Buffer;
+ }) => any): this;
+
+ /**
+ * Emitted for each captured JPEG screencast frame while the screencast is running.
+ *
+ * **Usage**
+ *
+ * ```js
+ * const screencast = page.screencast();
+ * screencast.on('screencastframe', ({ data, width, height }) => {
+ * console.log(`frame ${width}x${height}, jpeg size: ${data.length}`);
+ * require('fs').writeFileSync('frame.jpg', data);
+ * });
+ * await screencast.start({ maxSize: { width: 1200, height: 800 } });
+ * // ... perform actions ...
+ * await screencast.stop();
+ * ```
+ *
+ */
+ addListener(event: 'screencastframe', listener: (data: {
+ /**
+ * JPEG-encoded frame data.
+ */
+ data: Buffer;
+ }) => any): this;
+
+ /**
+ * Removes an event listener added by `on` or `addListener`.
+ */
+ removeListener(event: 'screencastframe', listener: (data: {
+ /**
+ * JPEG-encoded frame data.
+ */
+ data: Buffer;
+ }) => any): this;
+
+ /**
+ * Removes an event listener added by `on` or `addListener`.
+ */
+ off(event: 'screencastframe', listener: (data: {
+ /**
+ * JPEG-encoded frame data.
+ */
+ data: Buffer;
+ }) => any): this;
+
+ /**
+ * Emitted for each captured JPEG screencast frame while the screencast is running.
+ *
+ * **Usage**
+ *
+ * ```js
+ * const screencast = page.screencast();
+ * screencast.on('screencastframe', ({ data, width, height }) => {
+ * console.log(`frame ${width}x${height}, jpeg size: ${data.length}`);
+ * require('fs').writeFileSync('frame.jpg', data);
+ * });
+ * await screencast.start({ maxSize: { width: 1200, height: 800 } });
+ * // ... perform actions ...
+ * await screencast.stop();
+ * ```
+ *
+ */
+ prependListener(event: 'screencastframe', listener: (data: {
+ /**
+ * JPEG-encoded frame data.
+ */
+ data: Buffer;
+ }) => any): this;
+
+ /**
+ * Starts capturing screencast frames. Frames are emitted as
+ * [screencast.on('screencastframe')](https://playwright.dev/docs/api/class-screencast#screencast-event-screencast-frame)
+ * events.
+ *
+ * **Usage**
+ *
+ * ```js
+ * const screencast = page.screencast();
+ * screencast.on('screencastframe', ({ data, width, height }) => {
+ * console.log(`frame ${width}x${height}, size: ${data.length}`);
+ * });
+ * await screencast.start({ maxSize: { width: 800, height: 600 } });
+ * // ... perform actions ...
+ * await screencast.stop();
+ * ```
+ *
+ * @param options
+ */
+ start(options?: {
+ /**
+ * Maximum screencast frame dimensions. The output frame may be smaller to preserve the page aspect ratio. Defaults to
+ * 800×800.
+ */
+ maxSize?: {
+ /**
+ * Max frame width in pixels.
+ */
+ width: number;
+
+ /**
+ * Max frame height in pixels.
+ */
+ height: number;
+ };
+ }): Promise<void>;
+
+ /**
+ * Stops the screencast started with
+ * [screencast.start([options])](https://playwright.dev/docs/api/class-screencast#screencast-start).
+ *
+ * **Usage**
+ *
+ * ```js
+ * await screencast.start();
+ * // ... perform actions ...
+ * await screencast.stop();
+ * ```
+ *
+ */
+ stop(): Promise<void>;
+}
+
/**
* Selectors can be used to install custom selector engines. See [extensibility](https://playwright.dev/docs/extensibility) for more
* information.
diff --git a/tests/library/screencast.spec.ts b/tests/library/screencast.spec.ts
new file mode 100644
index 0000000000..f17bac1463
--- /dev/null
+++ b/tests/library/screencast.spec.ts
@@ -0,0 +1,125 @@
+/**
+ * Copyright Microsoft Corporation. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { expect, browserTest as test } from '../config/browserTest';
+import { rafraf } from '../config/utils';
+
+test.skip(({ mode }) => mode !== 'default', 'screencast is not available in remote mode');
+
+test('screencast.start emits screencastframe events', async ({ browser, server, trace }) => {
+ test.skip(trace === 'on', 'trace=on has different screencast image configuration');
+ const context = await browser.newContext({ viewport: { width: 1000, height: 400 } });
+ const page = await context.newPage();
+
+ const frames: { data: Buffer }[] = [];
+ page.screencast().on('screencastframe', frame => frames.push(frame));
+
+ const maxSize = { width: 500, height: 400 };
+ await page.screencast().start({ maxSize });
+ await page.goto(server.EMPTY_PAGE);
+ await page.evaluate(() => document.body.style.backgroundColor = 'red');
+ await rafraf(page, 100);
+ await page.screencast().stop();
+
+ expect(frames.length).toBeGreaterThan(0);
+ for (const frame of frames) {
+ // Each frame must be a valid JPEG (starts with FF D8)
+ expect(frame.data[0]).toBe(0xff);
+ expect(frame.data[1]).toBe(0xd8);
+ const { width, height } = jpegDimensions(frame.data);
+ // Frame should be scaled down to fit the maximum size.
+ expect(width).toBe(500);
+ expect(height).toBe(200);
+ }
+
+ await context.close();
+});
+
+test('start throws if already running', async ({ browser, trace }) => {
+ test.skip(trace === 'on', 'trace=on enables screencast with different options');
+
+ const size = { width: 500, height: 400 };
+ const context = await browser.newContext({ viewport: size });
+ const page = await context.newPage();
+
+ await page.screencast().start({ maxSize: size });
+ await expect(page.screencast().start({ maxSize: { width: 320, height: 240 } })).rejects.toThrow('Screencast is already running');
+
+ await page.screencast().stop();
+ await context.close();
+});
+
+test('start allows restart with different options after stop', async ({ browser, trace }) => {
+ test.skip(trace === 'on', 'trace=on enables screencast with different options');
+
+ const context = await browser.newContext({ viewport: { width: 500, height: 400 } });
+ const page = await context.newPage();
+
+ await page.screencast().start({ maxSize: { width: 500, height: 400 } });
+ await page.screencast().stop();
+ // Different options should succeed once the previous screencast is stopped.
+ await page.screencast().start({ maxSize: { width: 320, height: 240 } });
+ await page.screencast().stop();
+ await context.close();
+});
+
+test('start throws when video recording is running with different params', async ({ browser, trace }) => {
+ test.skip(trace === 'on', 'trace=on enables screencast with different options');
+
+ const videoSize = { width: 500, height: 400 };
+ const context = await browser.newContext({ viewport: videoSize });
+ const page = await context.newPage();
+
+ await page.video().start({ size: videoSize });
+ await expect(page.screencast().start({ maxSize: { width: 320, height: 240 } })).rejects.toThrow('Screencast is already running with different options');
+
+ await page.video().stop();
+ await context.close();
+});
+
+test('video.start does not emit screencastframe events', async ({ page, server, trace }) => {
+ test.skip(trace === 'on', 'trace=on enables screencast frame events');
+
+ const frames = [];
+ page.screencast().on('screencastframe', frame => frames.push(frame));
+
+ await page.video().start({ size: { width: 320, height: 240 } });
+ await page.goto(server.EMPTY_PAGE);
+ await page.evaluate(() => document.body.style.backgroundColor = 'red');
+ await rafraf(page, 100);
+ await page.video().stop();
+
+ expect(frames).toHaveLength(0);
+});
+
+function jpegDimensions(buffer: Buffer): { width: number, height: number } {
+ let i = 2; // skip SOI marker (FF D8)
+ while (i < buffer.length - 8) {
+ if (buffer[i] !== 0xFF)
+ break;
+ const marker = buffer[i + 1];
+ const segmentLength = buffer.readUInt16BE(i + 2);
+ // SOF markers: C0 (baseline), C2 (progressive), C1, C3, C5-C7, C9-CB, CD-CF
+ if ((marker >= 0xC0 && marker <= 0xC3) || (marker >= 0xC5 && marker <= 0xC7) ||
+ (marker >= 0xC9 && marker <= 0xCB) || (marker >= 0xCD && marker <= 0xCF)) {
+ const height = buffer.readUInt16BE(i + 5);
+ const width = buffer.readUInt16BE(i + 7);
+ return { width, height };
+ }
+ i += 2 + segmentLength;
+ }
+ throw new Error('Could not parse JPEG dimensions');
+}
diff --git a/tests/library/video.spec.ts b/tests/library/video.spec.ts
index da6ddf7a8e..2e9242b319 100644
--- a/tests/library/video.spec.ts
+++ b/tests/library/video.spec.ts
@@ -896,91 +896,6 @@ it.describe('screencast', () => {
expectFrames(videoPath, size, isAlmostWhite);
});
- it('inspector.startScreencast emits screencastframe events', async ({ browser, server, trace }) => {
- it.skip(trace === 'on', 'trace=on has different screencast image configuration');
- const context = await browser.newContext({ viewport: { width: 1000, height: 400 } });
- const page = await context.newPage();
-
- const frames: { data: Buffer }[] = [];
- page.inspector().on('screencastframe', frame => frames.push(frame));
-
- const maxSize = { width: 500, height: 400 };
- await page.inspector().startScreencast({ maxSize });
- await page.goto(server.EMPTY_PAGE);
- await page.evaluate(() => document.body.style.backgroundColor = 'red');
- await rafraf(page, 100);
- await page.inspector().stopScreencast();
-
- expect(frames.length).toBeGreaterThan(0);
- for (const frame of frames) {
- // Each frame must be a valid JPEG (starts with FF D8)
- expect(frame.data[0]).toBe(0xff);
- expect(frame.data[1]).toBe(0xd8);
- const { width, height } = jpegDimensions(frame.data);
- // Frame should be scaled down to fit the maximum size.
- expect(width).toBe(500);
- expect(height).toBe(200);
- }
-
- await context.close();
- });
-
- it('startScreencast throws if already running', async ({ browser, trace }) => {
- it.skip(trace === 'on', 'trace=on enables screencast with different options');
-
- const size = { width: 500, height: 400 };
- const context = await browser.newContext({ viewport: size });
- const page = await context.newPage();
-
- await page.inspector().startScreencast({ maxSize: size });
- await expect(page.inspector().startScreencast({ maxSize: { width: 320, height: 240 } })).rejects.toThrow('Screencast is already running');
-
- await page.inspector().stopScreencast();
- await context.close();
- });
-
- it('startScreencast allows restart with different options after stop', async ({ browser, trace }) => {
- it.skip(trace === 'on', 'trace=on enables screencast with different options');
-
- const context = await browser.newContext({ viewport: { width: 500, height: 400 } });
- const page = await context.newPage();
-
- await page.inspector().startScreencast({ maxSize: { width: 500, height: 400 } });
- await page.inspector().stopScreencast();
- // Different options should succeed once the previous screencast is stopped.
- await page.inspector().startScreencast({ maxSize: { width: 320, height: 240 } });
- await page.inspector().stopScreencast();
- await context.close();
- });
-
- it('startScreencast throws when video recording is running with different params', async ({ browser, trace }) => {
- it.skip(trace === 'on', 'trace=on enables screencast with different options');
-
- const videoSize = { width: 500, height: 400 };
- const context = await browser.newContext({ viewport: videoSize });
- const page = await context.newPage();
-
- await page.video().start({ size: videoSize });
- await expect(page.inspector().startScreencast({ maxSize: { width: 320, height: 240 } })).rejects.toThrow('Screencast is already running with different options');
-
- await page.video().stop();
- await context.close();
- });
-
- it('video.start does not emit screencastframe events', async ({ page, server, trace }) => {
- it.skip(trace === 'on', 'trace=on enables screencast frame events');
-
- const frames = [];
- page.inspector().on('screencastframe', frame => frames.push(frame));
-
- await page.video().start({ size: { width: 320, height: 240 } });
- await page.goto(server.EMPTY_PAGE);
- await page.evaluate(() => document.body.style.backgroundColor = 'red');
- await rafraf(page, 100);
- await page.video().stop();
-
- expect(frames).toHaveLength(0);
- });
});
it('should saveAs video', async ({ browser }, testInfo) => {
@@ -1004,22 +919,3 @@ it('should saveAs video', async ({ browser }, testInfo) => {
await page.video().saveAs(saveAsPath);
expect(fs.existsSync(saveAsPath)).toBeTruthy();
});
-
-function jpegDimensions(buffer: Buffer): { width: number, height: number } {
- let i = 2; // skip SOI marker (FF D8)
- while (i < buffer.length - 8) {
- if (buffer[i] !== 0xFF)
- break;
- const marker = buffer[i + 1];
- const segmentLength = buffer.readUInt16BE(i + 2);
- // SOF markers: C0 (baseline), C2 (progressive), C1, C3, C5-C7, C9-CB, CD-CF
- if ((marker >= 0xC0 && marker <= 0xC3) || (marker >= 0xC5 && marker <= 0xC7) ||
- (marker >= 0xC9 && marker <= 0xCB) || (marker >= 0xCD && marker <= 0xCF)) {
- const height = buffer.readUInt16BE(i + 5);
- const width = buffer.readUInt16BE(i + 7);
- return { width, height };
- }
- i += 2 + segmentLength;
- }
- throw new Error('Could not parse JPEG dimensions');
-}