Struct Browser 

pub struct Browser { /* private fields */ }

Puppeteer’s Browser (puppeteer-core 25.10.0), a remote object served by browser-commander serve --stdio.

Extends EventEmitter; the inherited methods are repeated here.

Implementations

impl Browser

pub async fn on( &self, type_: Value, handler: impl Into<JsFunction>, ) -> Result<Browser, BridgeError>

EventEmitter.on

on<Key extends keyof EventsWithWildcard<Events>>(type: Key, handler: Handler<EventsWithWildcard<Events>[Key]>): this

pub async fn off( &self, type_: Value, handler: Option<JsFunction>, ) -> Result<Browser, BridgeError>

EventEmitter.off

off<Key extends keyof EventsWithWildcard<Events>>(type: Key, handler?: Handler<EventsWithWildcard<Events>[Key]>): this

pub async fn emit( &self, type_: Value, event: Value, ) -> Result<bool, BridgeError>

EventEmitter.emit

emit<Key extends keyof EventsWithWildcard<Events>>(type: Key, event: EventsWithWildcard<Events>[Key]): boolean

pub async fn once( &self, type_: Value, handler: impl Into<JsFunction>, ) -> Result<Browser, BridgeError>

EventEmitter.once

once<Key extends keyof EventsWithWildcard<Events>>(type: Key, handler: Handler<EventsWithWildcard<Events>[Key]>): this

pub async fn listener_count(&self, type_: Value) -> Result<f64, BridgeError>

EventEmitter.listenerCount

listenerCount(type: keyof EventsWithWildcard<Events>): number

pub async fn remove_all_listeners( &self, type_: Option<Value>, ) -> Result<Browser, BridgeError>

EventEmitter.removeAllListeners

removeAllListeners(type?: keyof EventsWithWildcard<Events>): this

pub async fn process(&self) -> Result<Option<Value>, BridgeError>

Browser.process

process(): ChildProcess | null

pub async fn create_browser_context( &self, options: Option<Value>, ) -> Result<BrowserContext, BridgeError>

Browser.createBrowserContext

createBrowserContext(options?: BrowserContextOptions): Promise<BrowserContext>

pub async fn browser_contexts(&self) -> Result<Vec<BrowserContext>, BridgeError>

Browser.browserContexts

browserContexts(): BrowserContext[]

pub async fn default_browser_context( &self, ) -> Result<BrowserContext, BridgeError>

Browser.defaultBrowserContext

defaultBrowserContext(): BrowserContext

pub async fn ws_endpoint(&self) -> Result<String, BridgeError>

Browser.wsEndpoint

wsEndpoint(): string

pub async fn new_page( &self, options: Option<Value>, ) -> Result<Page, BridgeError>

Browser.newPage

newPage(options?: CreatePageOptions): Promise<Page>

pub async fn get_window_bounds( &self, window_id: &str, ) -> Result<Value, BridgeError>

Browser.getWindowBounds

getWindowBounds(windowId: WindowId): Promise<WindowBounds>

pub async fn set_window_bounds( &self, window_id: &str, window_bounds: Value, ) -> Result<(), BridgeError>

Browser.setWindowBounds

setWindowBounds(windowId: WindowId, windowBounds: WindowBounds): Promise<void>

pub async fn targets(&self) -> Result<Vec<Target>, BridgeError>

Browser.targets

targets(): Target[]

pub async fn target(&self) -> Result<Target, BridgeError>

Browser.target

target(): Target

pub async fn wait_for_target( &self, predicate: impl Into<JsFunction>, options: Option<Value>, ) -> Result<Target, BridgeError>

Browser.waitForTarget

waitForTarget(predicate: (x: Target) => boolean | Promise<boolean>, options?: WaitForTargetOptions): Promise<Target>

pub async fn pages( &self, include_all: Option<bool>, ) -> Result<Vec<Page>, BridgeError>

Browser.pages

pages(includeAll?: boolean): Promise<Page[]>

pub async fn version(&self) -> Result<String, BridgeError>

Browser.version

version(): Promise<string>

pub async fn user_agent(&self) -> Result<String, BridgeError>

Browser.userAgent

userAgent(): Promise<string>

pub async fn close(&self) -> Result<(), BridgeError>

Browser.close

close(): Promise<void>

pub async fn disconnect(&self) -> Result<(), BridgeError>

Browser.disconnect

disconnect(): Promise<void>

pub async fn cookies(&self) -> Result<Vec<Value>, BridgeError>

Browser.cookies

cookies(): Promise<Cookie[]>

pub async fn set_cookie(&self, cookies: &[Value]) -> Result<(), BridgeError>

Browser.setCookie

setCookie(...cookies: CookieData[]): Promise<void>

pub async fn delete_cookie(&self, cookies: &[Value]) -> Result<(), BridgeError>

Browser.deleteCookie

deleteCookie(...cookies: Cookie[]): Promise<void>

pub async fn delete_matching_cookies( &self, filters: &[Value], ) -> Result<(), BridgeError>

Browser.deleteMatchingCookies

deleteMatchingCookies(...filters: DeleteCookiesRequest[]): Promise<void>

pub async fn set_permission( &self, origin: &str, permissions: &[Value], ) -> Result<(), BridgeError>

Browser.setPermission

setPermission(origin: string, ...permissions: Array<{ permission: PermissionDescriptor_2; state: PermissionState_2; }> ): Promise<void>

pub async fn install_extension( &self, path: &str, options: Option<Value>, ) -> Result<String, BridgeError>

Browser.installExtension

installExtension(path: string, options?: ExtensionInstallOptions): Promise<string>

pub async fn uninstall_extension(&self, id: &str) -> Result<(), BridgeError>

Browser.uninstallExtension

uninstallExtension(id: string): Promise<void>

pub async fn install_pwa(&self, options: Value) -> Result<String, BridgeError>

Browser.installPWA

installPWA(options: InstallPWAOptions): Promise<string>

pub async fn uninstall_pwa(&self, options: Value) -> Result<(), BridgeError>

Browser.uninstallPWA

uninstallPWA(options: UninstallPWAOptions): Promise<void>

pub async fn launch_pwa(&self, options: Value) -> Result<Page, BridgeError>

Browser.launchPWA

launchPWA(options: LaunchPWAOptions): Promise<Page>

pub async fn get_pwa_state(&self, options: Value) -> Result<Value, BridgeError>

Browser.getPWAState

getPWAState(options: GetPWAStateOptions): Promise<PWAState>

pub async fn screens(&self) -> Result<Vec<Value>, BridgeError>

Browser.screens

screens(): Promise<ScreenInfo[]>

pub async fn add_screen(&self, params: Value) -> Result<Value, BridgeError>

Browser.addScreen

addScreen(params: AddScreenParams): Promise<ScreenInfo>

pub async fn remove_screen(&self, screen_id: &str) -> Result<(), BridgeError>

Browser.removeScreen

removeScreen(screenId: string): Promise<void>

pub async fn connected(&self) -> Result<bool, BridgeError>

Browser.connected

get connected(): boolean

pub async fn debug_info(&self) -> Result<Value, BridgeError>

Browser.debugInfo

get debugInfo(): DebugInfo

pub async fn extensions(&self) -> Result<Value, BridgeError>

Browser.extensions

extensions(): Promise<Map<string, Extension>>

Trait Implementations

impl Clone for Browser

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Browser

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromWire for Browser

fn from_wire(client: &BridgeClient, value: Value) -> Result<Self, BridgeError>

Convert, failing with BridgeError::Decode on a type mismatch.

impl PartialEq for Browser

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Remote for Browser

const TYPE: &'static str = "Browser"

The Puppeteer type it wraps (Page).

fn from_remote(remote: RemoteHandle) -> Self

Wrap a handle without checking its type.

fn remote(&self) -> &RemoteHandle

The handle behind the wrapper.

fn cast<T: Remote>(&self) -> T

View the same object as another type, for example an ElementHandle as the JSHandle it extends.

impl StructuralPartialEq for Browser