Struct ElementHandle 

pub struct ElementHandle { /* private fields */ }

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

Extends JSHandle; the inherited methods are repeated here.

Implementations

impl ElementHandle

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

JSHandle.evaluate

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

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

JSHandle.evaluateHandle

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

pub async fn get_property( &self, property_name: Value, ) -> Result<JSHandle, BridgeError>

JSHandle.getProperty

getProperty<K extends keyof T>(propertyName: HandleOr<K>): Promise<HandleFor<T[K]>>
getProperty(propertyName: string): Promise<JSHandle<unknown>>

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

JSHandle.getProperties

getProperties(): Promise<Map<string, JSHandle>>

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

JSHandle.jsonValue

jsonValue(): Promise<T>

pub async fn as_element(&self) -> Result<Option<ElementHandle>, BridgeError>

JSHandle.asElement

asElement(): ElementHandle<Node> | null

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

JSHandle.dispose

dispose(): Promise<void>

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

JSHandle.toString

toString(): string

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

JSHandle.remoteObject

remoteObject(): Protocol.Runtime.RemoteObject

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

ElementHandle.frame

get frame(): Frame

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

ElementHandle.$

$<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>

ElementHandle.$$

$$<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>

ElementHandle.$eval

$eval<Selector extends string, Params extends unknown[], Func extends EvaluateFuncWith<NodeFor<Selector>, Params> = EvaluateFuncWith<NodeFor<Selector>, Params >>(selector: Selector, pageFunction: Func | string, ...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>

ElementHandle.$$eval

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

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

ElementHandle.waitForSelector

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

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

ElementHandle.isVisible

isVisible(): Promise<boolean>

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

ElementHandle.isHidden

isHidden(): Promise<boolean>

pub async fn to_element(&self, tag_name: Value) -> Result<JSHandle, BridgeError>

ElementHandle.toElement

toElement<K extends keyof HTMLElementTagNameMap | keyof SVGElementTagNameMap>(tagName: K): Promise<HandleFor<ElementFor<K>>>

pub async fn content_frame( &self, this: Option<&ElementHandle>, ) -> Result<Value, BridgeError>

ElementHandle.contentFrame

contentFrame(this: ElementHandle<HTMLIFrameElement>): Promise<Frame>
contentFrame(): Promise<Frame | null>

pub async fn clickable_point( &self, offset: Option<Value>, ) -> Result<Value, BridgeError>

ElementHandle.clickablePoint

clickablePoint(offset?: Offset): Promise<Point>

pub async fn hover(&self, this: &ElementHandle) -> Result<(), BridgeError>

ElementHandle.hover

hover(this: ElementHandle<Element>): Promise<void>

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

ElementHandle.click

click(this: ElementHandle<Element>, options?: Readonly<ClickOptions>): Promise<void>

pub async fn drag( &self, this: &ElementHandle, target: Value, ) -> Result<Option<Value>, BridgeError>

ElementHandle.drag

drag(this: ElementHandle<Element>, target: Point | ElementHandle<Element>): Promise<Protocol.Input.DragData | void>

pub async fn drag_enter( &self, this: &ElementHandle, data: Option<Value>, ) -> Result<(), BridgeError>

ElementHandle.dragEnter

dragEnter(this: ElementHandle<Element>, data?: Protocol.Input.DragData): Promise<void>

pub async fn drag_over( &self, this: &ElementHandle, data: Option<Value>, ) -> Result<(), BridgeError>

ElementHandle.dragOver

dragOver(this: ElementHandle<Element>, data?: Protocol.Input.DragData): Promise<void>

pub async fn drop( &self, this: &ElementHandle, element: Option<Value>, ) -> Result<(), BridgeError>

ElementHandle.drop

drop(this: ElementHandle<Element>, element: ElementHandle<Element>): Promise<void>
drop(this: ElementHandle<Element>, data?: Protocol.Input.DragData): Promise<void>

pub async fn drag_and_drop( &self, this: &ElementHandle, target: &ElementHandle, options: Option<Value>, ) -> Result<(), BridgeError>

ElementHandle.dragAndDrop

dragAndDrop(this: ElementHandle<Element>, target: ElementHandle<Node>, options?: { delay: number; }): Promise<void>

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

ElementHandle.select

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

pub async fn upload_file( &self, this: &ElementHandle, paths: &[&str], ) -> Result<(), BridgeError>

ElementHandle.uploadFile

uploadFile(this: ElementHandle<HTMLInputElement>, ...paths: string[] ): Promise<void>

pub async fn tap(&self, this: &ElementHandle) -> Result<(), BridgeError>

ElementHandle.tap

tap(this: ElementHandle<Element>): Promise<void>

pub async fn touch_start( &self, this: &ElementHandle, ) -> Result<TouchHandle, BridgeError>

ElementHandle.touchStart

touchStart(this: ElementHandle<Element>): Promise<TouchHandle>

pub async fn touch_move( &self, this: &ElementHandle, touch: Option<&TouchHandle>, ) -> Result<(), BridgeError>

ElementHandle.touchMove

touchMove(this: ElementHandle<Element>, touch?: TouchHandle): Promise<void>

pub async fn touch_end(&self, this: &ElementHandle) -> Result<(), BridgeError>

ElementHandle.touchEnd

touchEnd(this: ElementHandle<Element>): Promise<void>

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

ElementHandle.focus

focus(): Promise<void>

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

ElementHandle.type

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

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

ElementHandle.press

press(key: KeyInput, options?: Readonly<KeyPressOptions>): Promise<void>

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

ElementHandle.boundingBox

boundingBox(): Promise<BoundingBox | null>

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

ElementHandle.boxModel

boxModel(): Promise<BoxModel | null>

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

ElementHandle.screenshot

screenshot(options: Readonly<ScreenshotOptions> & { encoding: 'base64'; }): Promise<string>
screenshot(options?: Readonly<ScreenshotOptions>): Promise<Uint8Array>

pub async fn is_intersecting_viewport( &self, this: &ElementHandle, options: Option<Value>, ) -> Result<bool, BridgeError>

ElementHandle.isIntersectingViewport

isIntersectingViewport(this: ElementHandle<Element>, options?: { threshold?: number; }): Promise<boolean>

pub async fn scroll_into_view( &self, this: &ElementHandle, ) -> Result<(), BridgeError>

ElementHandle.scrollIntoView

scrollIntoView(this: ElementHandle<Element>): Promise<void>

pub async fn as_locator( &self, this: &ElementHandle, ) -> Result<Locator, BridgeError>

ElementHandle.asLocator

asLocator(this: ElementHandle<Element>): Locator<Element>

pub async fn autofill(&self, data: Value) -> Result<(), BridgeError>

ElementHandle.autofill

autofill(data: AutofillData): Promise<void>

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

ElementHandle.backendNodeId

backendNodeId(): Promise<number>

Trait Implementations

impl Clone for ElementHandle

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 ElementHandle

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

Formats the value using the given formatter.

impl FromWire for ElementHandle

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

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

impl PartialEq for ElementHandle

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

Equality operator ==.

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

Inequality operator !=.

impl Remote for ElementHandle

const TYPE: &'static str = "ElementHandle"

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 ElementHandle