Struct Frame 

pub struct Frame { /* private fields */ }

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

Extends EventEmitter; the inherited methods are repeated here.

Implementations

impl Frame

pub async fn on( &self, type_: Value, handler: impl Into<JsFunction>, ) -> Result<Frame, 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<Frame, 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<Frame, 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<Frame, BridgeError>

EventEmitter.removeAllListeners

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

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

Frame.page

page(): Page

pub async fn goto( &self, url: &str, options: Option<Value>, ) -> Result<Option<HTTPResponse>, BridgeError>

Frame.goto

goto(url: string, options?: GoToOptions): Promise<HTTPResponse | null>

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

Frame.waitForNavigation

waitForNavigation(options?: WaitForOptions): Promise<HTTPResponse | null>

pub async fn frame_element(&self) -> Result<Option<JSHandle>, BridgeError>

Frame.frameElement

frameElement(): Promise<HandleFor<HTMLIFrameElement> | null>

pub async fn evaluate_handle( &self, page_function: impl Into<JsFunction>, args: &[Value], ) -> Result<JSHandle, BridgeError>

Frame.evaluateHandle

evaluateHandle<Params extends unknown[], Func extends EvaluateFunc<Params> = EvaluateFunc<Params>>(pageFunction: Func | string, ...args: Params ): Promise<HandleFor<Awaited<ReturnType<Func>>>>

pub async fn evaluate( &self, page_function: impl Into<JsFunction>, args: &[Value], ) -> Result<Value, BridgeError>

Frame.evaluate

evaluate<Params extends unknown[], Func extends EvaluateFunc<Params> = EvaluateFunc<Params>>(pageFunction: Func | string, ...args: Params ): Promise<Awaited<ReturnType<Func>>>

pub async fn locator( &self, selector: impl Into<JsFunction>, ) -> Result<Locator, BridgeError>

Frame.locator

locator<Selector extends string>(selector: Selector): Locator<NodeFor<Selector>>
locator<Ret>(func: () => Awaitable<Ret>): Locator<Ret>

pub async fn query_selector( &self, selector: &str, ) -> Result<Option<ElementHandle>, BridgeError>

Frame.$

$<Selector extends string>(selector: Selector): Promise<ElementHandle<NodeFor<Selector>> | null>

pub async fn query_selector_all( &self, selector: &str, options: Option<Value>, ) -> Result<Vec<ElementHandle>, BridgeError>

Frame.$$

$$<Selector extends string>(selector: Selector, options?: QueryOptions): Promise<Array<ElementHandle<NodeFor<Selector>>>>

pub async fn eval_on_selector( &self, selector: &str, page_function: impl Into<JsFunction>, args: &[Value], ) -> Result<Value, BridgeError>

Frame.$eval

$eval<Selector extends string, Params extends unknown[], Func extends EvaluateFuncWith<NodeFor<Selector>, Params> = EvaluateFuncWith<NodeFor<Selector>, Params >>(selector: Selector, pageFunction: string | Func, ...args: Params ): Promise<Awaited<ReturnType<Func>>>

pub async fn eval_on_selector_all( &self, selector: &str, page_function: impl Into<JsFunction>, args: &[Value], ) -> Result<Value, BridgeError>

Frame.$$eval

$$eval<Selector extends string, Params extends unknown[], Func extends EvaluateFuncWith<Array<NodeFor<Selector>>, Params> = EvaluateFuncWith<Array<NodeFor<Selector>>, Params>>(selector: Selector, pageFunction: string | Func, ...args: Params ): Promise<Awaited<ReturnType<Func>>>

pub async fn wait_for_selector( &self, selector: &str, options: Option<Value>, ) -> Result<Option<ElementHandle>, BridgeError>

Frame.waitForSelector

waitForSelector<Selector extends string>(selector: Selector, options?: WaitForSelectorOptions): Promise<ElementHandle<NodeFor<Selector>> | null>

pub async fn wait_for_function( &self, page_function: impl Into<JsFunction>, options: Option<Value>, args: &[Value], ) -> Result<JSHandle, BridgeError>

Frame.waitForFunction

waitForFunction<Params extends unknown[], Func extends EvaluateFunc<Params> = EvaluateFunc<Params>>(pageFunction: Func | string, options?: FrameWaitForFunctionOptions, ...args: Params ): Promise<HandleFor<Awaited<ReturnType<Func>>>>

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

Frame.content

content(): Promise<string>

pub async fn set_content( &self, html: &str, options: Option<Value>, ) -> Result<(), BridgeError>

Frame.setContent

setContent(html: string, options?: SetContentWaitForOptions): Promise<void>

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

Frame.name

name(): string

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

Frame.url

url(): string

pub async fn parent_frame(&self) -> Result<Option<Frame>, BridgeError>

Frame.parentFrame

parentFrame(): Frame | null

pub async fn child_frames(&self) -> Result<Vec<Frame>, BridgeError>

Frame.childFrames

childFrames(): Frame[]

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

Frame.detached

get detached(): boolean

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

Frame.isDetached

isDetached(): boolean

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

Frame.addScriptTag

addScriptTag(options: FrameAddScriptTagOptions): Promise<ElementHandle<HTMLScriptElement>>

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

Frame.addStyleTag

addStyleTag(options: Omit<FrameAddStyleTagOptions, 'url'>): Promise<ElementHandle<HTMLStyleElement>>
addStyleTag(options: FrameAddStyleTagOptions): Promise<ElementHandle<HTMLLinkElement>>

pub async fn click( &self, selector: &str, options: Option<Value>, ) -> Result<(), BridgeError>

Frame.click

click(selector: string, options?: Readonly<ClickOptions>): Promise<void>

pub async fn focus(&self, selector: &str) -> Result<(), BridgeError>

Frame.focus

focus(selector: string): Promise<void>

pub async fn hover(&self, selector: &str) -> Result<(), BridgeError>

Frame.hover

hover(selector: string): Promise<void>

pub async fn select( &self, selector: &str, values: &[&str], ) -> Result<Vec<String>, BridgeError>

Frame.select

select(selector: string, ...values: string[]): Promise<string[]>

pub async fn tap(&self, selector: &str) -> Result<(), BridgeError>

Frame.tap

tap(selector: string): Promise<void>

pub async fn type( &self, selector: &str, text: &str, options: Option<Value>, ) -> Result<(), BridgeError>

Frame.type

type(selector: string, text: string, options?: Readonly<KeyboardTypeOptions>): Promise<void>

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

Frame.title

title(): Promise<string>

pub async fn extension_realms(&self) -> Result<Vec<Realm>, BridgeError>

Frame.extensionRealms

extensionRealms(): Realm[]

Trait Implementations

impl Clone for Frame

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 Frame

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

Formats the value using the given formatter.

impl FromWire for Frame

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

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

impl PartialEq for Frame

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

Equality operator ==.

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

Inequality operator !=.

impl Remote for Frame

const TYPE: &'static str = "Frame"

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 Frame