Class: Playwright::ElementHandle

Inherits:
JSHandle show all
Defined in:
lib/playwright_api/element_handle.rb

Overview

  • extends: ‘JSHandle`

ElementHandle represents an in-page DOM element. ElementHandles can be created with the [‘method: Page.$`] method.

“‘js const { chromium } = require(’playwright’); // Or ‘firefox’ or ‘webkit’.

(async () => 

const browser = await chromium.launch();
const page = await browser.newPage();
await page.goto('https://example.com');
const hrefElement = await page.$('a');
await hrefElement.click();
// ...

)(); “‘

ElementHandle prevents DOM element from garbage collection unless the handle is disposed with [‘method: JSHandle.dispose`]. ElementHandles are auto-disposed when their origin frame gets navigated.

ElementHandle instances can be used as an argument in [‘method: Page.$eval`] and [`method: Page.evaluate`] methods.

Instance Method Summary collapse

Methods inherited from JSHandle

#as_element, #dispose, #evaluate, #evaluate_handle, #get_properties, #get_property, #json_value

Methods inherited from PlaywrightApi

from_channel_owner

Instance Method Details

#bounding_box ⇒ Object

This method returns the bounding box of the element, or ‘null` if the element is not visible. The bounding box is calculated relative to the main frame viewport - which is usually the same as the browser window.

Scrolling affects the returned bonding box, similarly to [Element.getBoundingClientRect](developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect). That means ‘x` and/or `y` may be negative.

Elements from child frames return the bounding box relative to the main frame, unlike the [Element.getBoundingClientRect](developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect).

Assuming the page is static, it is safe to use bounding box coordinates to perform input. For example, the following snippet should click the center of the element.

“‘js const box = await elementHandle.boundingBox(); await page.mouse.click(box.x + box.width / 2, box.y + box.height / 2); “`

Raises:

  • (NotImplementedError) 


106
107
108
 
# File 'lib/playwright_api/element_handle.rb', line 106

def bounding_box
  raise NotImplementedError.new('bounding_box is not implemented yet.')
end

#check(force: nil, noWaitAfter: nil, timeout: nil) ⇒ Object

This method checks the element by performing the following steps:

  1. Ensure that element is a checkbox or a radio input. If not, this method rejects. If the element is already checked, this method returns immediately.

  2. Wait for [actionability](./actionability.md) checks on the element, unless ‘force` option is set.

  3. Scroll the element into view if needed.

  4. Use [‘property: Page.mouse`] to click in the center of the element.

  5. Wait for initiated navigations to either succeed or fail, unless ‘noWaitAfter` option is set.

  6. Ensure that the element is now checked. If not, this method rejects.

If the element is detached from the DOM at any moment during the action, this method rejects.

When all steps combined have not finished during the specified ‘timeout`, this method rejects with a `TimeoutError`. Passing zero timeout disables this.

Raises:

  • (NotImplementedError) 


123
124
125
 
# File 'lib/playwright_api/element_handle.rb', line 123

def check(force: nil, noWaitAfter: nil, timeout: nil)
  raise NotImplementedError.new('check is not implemented yet.')
end

#checked? ⇒ Boolean

Returns whether the element is checked. Throws if the element is not a checkbox or radio input.

Raises:

  • (NotImplementedError) 


253
254
255
 
# File 'lib/playwright_api/element_handle.rb', line 253

def checked?
  raise NotImplementedError.new('checked? is not implemented yet.')
end

#click(button: nil, clickCount: nil, delay: nil, force: nil, modifiers: nil, noWaitAfter: nil, position: nil, timeout: nil) ⇒ Object

This method clicks the element by performing the following steps:

  1. Wait for [actionability](./actionability.md) checks on the element, unless ‘force` option is set.

  2. Scroll the element into view if needed.

  3. Use [‘property: Page.mouse`] to click in the center of the element, or the specified `position`.

  4. Wait for initiated navigations to either succeed or fail, unless ‘noWaitAfter` option is set.

If the element is detached from the DOM at any moment during the action, this method rejects.

When all steps combined have not finished during the specified ‘timeout`, this method rejects with a `TimeoutError`. Passing zero timeout disables this.

Raises:

  • (NotImplementedError) 


137
138
139
140
141
142
143
144
145
146
147
 
# File 'lib/playwright_api/element_handle.rb', line 137

def click(
      button: nil,
      clickCount: nil,
      delay: nil,
      force: nil,
      modifiers: nil,
      noWaitAfter: nil,
      position: nil,
      timeout: nil)
  raise NotImplementedError.new('click is not implemented yet.')
end

#content_frame ⇒ Object

Returns the content frame for element handles referencing iframe nodes, or ‘null` otherwise

Raises:

  • (NotImplementedError) 


150
151
152
 
# File 'lib/playwright_api/element_handle.rb', line 150

def content_frame
  raise NotImplementedError.new('content_frame is not implemented yet.')
end

#dblclick(button: nil, delay: nil, force: nil, modifiers: nil, noWaitAfter: nil, position: nil, timeout: nil) ⇒ Object

This method double clicks the element by performing the following steps:

  1. Wait for [actionability](./actionability.md) checks on the element, unless ‘force` option is set.

  2. Scroll the element into view if needed.

  3. Use [‘property: Page.mouse`] to double click in the center of the element, or the specified `position`.

  4. Wait for initiated navigations to either succeed or fail, unless ‘noWaitAfter` option is set. Note that if the first click of the `dblclick()` triggers a navigation event, this method will reject.

If the element is detached from the DOM at any moment during the action, this method rejects.

When all steps combined have not finished during the specified ‘timeout`, this method rejects with a `TimeoutError`. Passing zero timeout disables this.

> NOTE ‘elementHandle.dblclick()` dispatches two `click` events and a single `dblclick` event.

Raises:

  • (NotImplementedError) 


167
168
169
170
171
172
173
174
175
176
 
# File 'lib/playwright_api/element_handle.rb', line 167

def dblclick(
      button: nil,
      delay: nil,
      force: nil,
      modifiers: nil,
      noWaitAfter: nil,
      position: nil,
      timeout: nil)
  raise NotImplementedError.new('dblclick is not implemented yet.')
end

#disabled? ⇒ Boolean

Returns whether the element is disabled, the opposite of [enabled](./actionability.md#enabled).

Raises:

  • (NotImplementedError) 


258
259
260
 
# File 'lib/playwright_api/element_handle.rb', line 258

def disabled?
  raise NotImplementedError.new('disabled? is not implemented yet.')
end

#dispatch_event(type, eventInit: nil) ⇒ Object

The snippet below dispatches the ‘click` event on the element. Regardless of the visibility state of the elment, `click` is dispatched. This is equivalend to calling [element.click()](developer.mozilla.org/en-US/docs/Web/API/HTMLElement/click).

“‘js await elementHandle.dispatchEvent(’click’); “‘

Under the hood, it creates an instance of an event based on the given ‘type`, initializes it with `eventInit` properties and dispatches it on the element. Events are `composed`, `cancelable` and bubble by default.

Since ‘eventInit` is event-specific, please refer to the events documentation for the lists of initial properties:

You can also specify ‘JSHandle` as the property value if you want live objects to be passed into the event:

“‘js // Note you can only create DataTransfer in Chromium and Firefox const dataTransfer = await page.evaluateHandle(() => new DataTransfer()); await elementHandle.dispatchEvent(’dragstart’, { dataTransfer }); “‘

Raises:

  • (NotImplementedError) 


207
208
209
 
# File 'lib/playwright_api/element_handle.rb', line 207

def dispatch_event(type, eventInit: nil)
  raise NotImplementedError.new('dispatch_event is not implemented yet.')
end

#editable? ⇒ Boolean

Returns whether the element is [editable](./actionability.md#editable).

Raises:

  • (NotImplementedError) 


263
264
265
 
# File 'lib/playwright_api/element_handle.rb', line 263

def editable?
  raise NotImplementedError.new('editable? is not implemented yet.')
end

#enabled? ⇒ Boolean

Returns whether the element is [enabled](./actionability.md#enabled).

Raises:

  • (NotImplementedError) 


268
269
270
 
# File 'lib/playwright_api/element_handle.rb', line 268

def enabled?
  raise NotImplementedError.new('enabled? is not implemented yet.')
end

#eval_on_selector(selector, pageFunction, arg: nil) ⇒ Object

Returns the return value of ‘pageFunction`

The method finds an element matching the specified selector in the ‘ElementHandle`s subtree and passes it as a first argument to `pageFunction`. See [Working with selectors](./selectors.md#working-with-selectors) for more details. If no elements match the selector, the method throws an error.

If ‘pageFunction` returns a [Promise], then `frame.$eval` would wait for the promise to resolve and return its value.

Examples:

“‘js const tweetHandle = await page.$(’.tweet’); expect(await tweetHandle.$eval(‘.like’, node => node.innerText)).toBe(‘100’); expect(await tweetHandle.$eval(‘.retweets’, node => node.innerText)).toBe(‘10’); “‘

Raises:

  • (NotImplementedError) 


58
59
60
 
# File 'lib/playwright_api/element_handle.rb', line 58

def eval_on_selector(selector, pageFunction, arg: nil)
  raise NotImplementedError.new('eval_on_selector is not implemented yet.')
end

#eval_on_selector_all(selector, pageFunction, arg: nil) ⇒ Object

Returns the return value of ‘pageFunction`

The method finds all elements matching the specified selector in the ‘ElementHandle`’s subtree and passes an array of matched elements as a first argument to ‘pageFunction`. See [Working with selectors](./selectors.md#working-with-selectors) for more details.

If ‘pageFunction` returns a [Promise], then `frame.$$eval` would wait for the promise to resolve and return its value.

Examples:

“‘html <div class=“feed”>

<div class="tweet">Hello!</div>
<div class="tweet">Hi!</div>

</div> “‘

“‘js const feedHandle = await page.$(’.feed’); expect(await feedHandle.$$eval(‘.tweet’, nodes => nodes.map(n => n.innerText))).toEqual([‘Hello!’, ‘Hi!’]); “‘

Raises:

  • (NotImplementedError) 


84
85
86
 
# File 'lib/playwright_api/element_handle.rb', line 84

def eval_on_selector_all(selector, pageFunction, arg: nil)
  raise NotImplementedError.new('eval_on_selector_all is not implemented yet.')
end

#fill(value, noWaitAfter: nil, timeout: nil) ⇒ Object

This method waits for [actionability](./actionability.md) checks, focuses the element, fills it and triggers an ‘input` event after filling. If the element is not an `<input>`, `<textarea>` or `[contenteditable]` element, this method throws an error. Note that you can pass an empty string to clear the input field.

Raises:

  • (NotImplementedError) 


214
215
216
 
# File 'lib/playwright_api/element_handle.rb', line 214

def fill(value, noWaitAfter: nil, timeout: nil)
  raise NotImplementedError.new('fill is not implemented yet.')
end

#focus ⇒ Object

Calls [focus](developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus) on the element.

Raises:

  • (NotImplementedError) 


219
220
221
 
# File 'lib/playwright_api/element_handle.rb', line 219

def focus
  raise NotImplementedError.new('focus is not implemented yet.')
end

#get_attribute(name) ⇒ Object

Returns element attribute value.

Raises:

  • (NotImplementedError) 


224
225
226
 
# File 'lib/playwright_api/element_handle.rb', line 224

def get_attribute(name)
  raise NotImplementedError.new('get_attribute is not implemented yet.')
end

#hidden? ⇒ Boolean

Returns whether the element is hidden, the opposite of [visible](./actionability.md#visible).

Raises:

  • (NotImplementedError) 


273
274
275
 
# File 'lib/playwright_api/element_handle.rb', line 273

def hidden?
  raise NotImplementedError.new('hidden? is not implemented yet.')
end

#hover(force: nil, modifiers: nil, position: nil, timeout: nil) ⇒ Object

This method hovers over the element by performing the following steps:

  1. Wait for [actionability](./actionability.md) checks on the element, unless ‘force` option is set.

  2. Scroll the element into view if needed.

  3. Use [‘property: Page.mouse`] to hover over the center of the element, or the specified `position`.

  4. Wait for initiated navigations to either succeed or fail, unless ‘noWaitAfter` option is set.

If the element is detached from the DOM at any moment during the action, this method rejects.

When all steps combined have not finished during the specified ‘timeout`, this method rejects with a `TimeoutError`. Passing zero timeout disables this.

Raises:

  • (NotImplementedError) 


238
239
240
 
# File 'lib/playwright_api/element_handle.rb', line 238

def hover(force: nil, modifiers: nil, position: nil, timeout: nil)
  raise NotImplementedError.new('hover is not implemented yet.')
end

#inner_html ⇒ Object

Returns the ‘element.innerHTML`.

Raises:

  • (NotImplementedError) 


243
244
245
 
# File 'lib/playwright_api/element_handle.rb', line 243

def inner_html
  raise NotImplementedError.new('inner_html is not implemented yet.')
end

#inner_text ⇒ Object

Returns the ‘element.innerText`.

Raises:

  • (NotImplementedError) 


248
249
250
 
# File 'lib/playwright_api/element_handle.rb', line 248

def inner_text
  raise NotImplementedError.new('inner_text is not implemented yet.')
end

#owner_frame ⇒ Object

Returns the frame containing the given element.

Raises:

  • (NotImplementedError) 


283
284
285
 
# File 'lib/playwright_api/element_handle.rb', line 283

def owner_frame
  raise NotImplementedError.new('owner_frame is not implemented yet.')
end

#press(key, delay: nil, noWaitAfter: nil, timeout: nil) ⇒ Object

Focuses the element, and then uses [‘method: Keyboard.down`] and [`method: Keyboard.up`].

‘key` can specify the intended [keyboardEvent.key](developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key) value or a single character to generate the text for. A superset of the `key` values can be found [here](developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values). Examples of the keys are:

‘F1` - `F12`, `Digit0`- `Digit9`, `KeyA`- `KeyZ`, `Backquote`, `Minus`, `Equal`, `Backslash`, `Backspace`, `Tab`, `Delete`, `Escape`, `ArrowDown`, `End`, `Enter`, `Home`, `Insert`, `PageDown`, `PageUp`, `ArrowRight`, `ArrowUp`, etc.

Following modification shortcuts are also supported: ‘Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`.

Holding down ‘Shift` will type the text that corresponds to the `key` in the upper case.

If ‘key` is a single character, it is case-sensitive, so the values `a` and `A` will generate different respective texts.

Shortcuts such as ‘key: “Control+o”` or `key: “Control+Shift+T”` are supported as well. When speficied with the modifier, modifier is pressed and being held while the subsequent key is being pressed.

Raises:

  • (NotImplementedError) 


305
306
307
 
# File 'lib/playwright_api/element_handle.rb', line 305

def press(key, delay: nil, noWaitAfter: nil, timeout: nil)
  raise NotImplementedError.new('press is not implemented yet.')
end

#query_selector(selector) ⇒ Object

The method finds an element matching the specified selector in the ‘ElementHandle`’s subtree. See [Working with selectors](./selectors.md#working-with-selectors) for more details. If no elements match the selector, returns ‘null`.

Raises:

  • (NotImplementedError) 


31
32
33
 
# File 'lib/playwright_api/element_handle.rb', line 31

def query_selector(selector)
  raise NotImplementedError.new('query_selector is not implemented yet.')
end

#query_selector_all(selector) ⇒ Object

The method finds all elements matching the specified selector in the ‘ElementHandle`s subtree. See [Working with selectors](./selectors.md#working-with-selectors) for more details. If no elements match the selector, returns empty array.

Raises:

  • (NotImplementedError) 


38
39
40
 
# File 'lib/playwright_api/element_handle.rb', line 38

def query_selector_all(selector)
  raise NotImplementedError.new('query_selector_all is not implemented yet.')
end

#screenshot(omitBackground: nil, path: nil, quality: nil, timeout: nil, type: nil) ⇒ Object

Returns the buffer with the captured screenshot.

This method waits for the [actionability](./actionability.md) checks, then scrolls element into view before taking a screenshot. If the element is detached from DOM, the method throws an error.

Raises:

  • (NotImplementedError) 


313
314
315
316
317
318
319
320
 
# File 'lib/playwright_api/element_handle.rb', line 313

def screenshot(
      omitBackground: nil,
      path: nil,
      quality: nil,
      timeout: nil,
      type: nil)
  raise NotImplementedError.new('screenshot is not implemented yet.')
end

#scroll_into_view_if_needed(timeout: nil) ⇒ Object

This method waits for [actionability](./actionability.md) checks, then tries to scroll element into view, unless it is completely visible as defined by [IntersectionObserver](developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API)‘s “`ratio“`.

Throws when ‘elementHandle` does not point to an element [connected](developer.mozilla.org/en-US/docs/Web/API/Node/isConnected) to a Document or a ShadowRoot.

Raises:

  • (NotImplementedError) 


328
329
330
 
# File 'lib/playwright_api/element_handle.rb', line 328

def scroll_into_view_if_needed(timeout: nil)
  raise NotImplementedError.new('scroll_into_view_if_needed is not implemented yet.')
end

#select_option(values, noWaitAfter: nil, timeout: nil) ⇒ Object

Returns the array of option values that have been successfully selected.

Triggers a ‘change` and `input` event once all the provided options have been selected. If element is not a `<select>` element, the method throws an error.

“‘js // single selection matching the value handle.selectOption(’blue’);

// single selection matching both the value and the label handle.selectOption({ label: ‘Blue’ });

// multiple selection handle.selectOption(‘red’, ‘green’, ‘blue’);

// multiple selection for blue, red and second option handle.selectOption({ value: ‘blue’ }, { index: 2 }, ‘red’); “‘

Raises:

  • (NotImplementedError) 


351
352
353
 
# File 'lib/playwright_api/element_handle.rb', line 351

def select_option(values, noWaitAfter: nil, timeout: nil)
  raise NotImplementedError.new('select_option is not implemented yet.')
end

#select_text(timeout: nil) ⇒ Object

This method waits for [actionability](./actionability.md) checks, then focuses the element and selects all its text content.

Raises:

  • (NotImplementedError) 


357
358
359
 
# File 'lib/playwright_api/element_handle.rb', line 357

def select_text(timeout: nil)
  raise NotImplementedError.new('select_text is not implemented yet.')
end

#set_input_files(files, noWaitAfter: nil, timeout: nil) ⇒ Object

This method expects ‘elementHandle` to point to an [input element](developer.mozilla.org/en-US/docs/Web/HTML/Element/input).

Sets the value of the file input to these file paths or files. If some of the ‘filePaths` are relative paths, then they are resolved relative to the the current working directory. For empty array, clears the selected files.

Raises:

  • (NotImplementedError) 


366
367
368
 
# File 'lib/playwright_api/element_handle.rb', line 366

def set_input_files(files, noWaitAfter: nil, timeout: nil)
  raise NotImplementedError.new('set_input_files is not implemented yet.')
end

#tap_point(force: nil, modifiers: nil, noWaitAfter: nil, position: nil, timeout: nil) ⇒ Object

This method taps the element by performing the following steps:

  1. Wait for [actionability](./actionability.md) checks on the element, unless ‘force` option is set.

  2. Scroll the element into view if needed.

  3. Use [‘property: Page.touchscreen`] to tap the center of the element, or the specified `position`.

  4. Wait for initiated navigations to either succeed or fail, unless ‘noWaitAfter` option is set.

If the element is detached from the DOM at any moment during the action, this method rejects.

When all steps combined have not finished during the specified ‘timeout`, this method rejects with a `TimeoutError`. Passing zero timeout disables this.

> NOTE ‘elementHandle.tap()` requires that the `hasTouch` option of the browser context be set to true.

Raises:

  • (NotImplementedError) 


382
383
384
385
386
387
388
389
 
# File 'lib/playwright_api/element_handle.rb', line 382

def tap_point(
      force: nil,
      modifiers: nil,
      noWaitAfter: nil,
      position: nil,
      timeout: nil)
  raise NotImplementedError.new('tap_point is not implemented yet.')
end

#text_content ⇒ Object

Returns the ‘node.textContent`.

Raises:

  • (NotImplementedError) 


392
393
394
 
# File 'lib/playwright_api/element_handle.rb', line 392

def text_content
  raise NotImplementedError.new('text_content is not implemented yet.')
end

#type_text(text, delay: nil, noWaitAfter: nil, timeout: nil) ⇒ Object

Focuses the element, and then sends a ‘keydown`, `keypress`/`input`, and `keyup` event for each character in the text.

To press a special key, like ‘Control` or `ArrowDown`, use [`method: ElementHandle.press`].

“‘js await elementHandle.type(’Hello’); // Types instantly await elementHandle.type(‘World’, 100); // Types slower, like a user “‘

An example of typing into a text field and then submitting the form:

“‘js const elementHandle = await page.$(’input’); await elementHandle.type(‘some text’); await elementHandle.press(‘Enter’); “‘

Raises:

  • (NotImplementedError) 


414
415
416
 
# File 'lib/playwright_api/element_handle.rb', line 414

def type_text(text, delay: nil, noWaitAfter: nil, timeout: nil)
  raise NotImplementedError.new('type_text is not implemented yet.')
end

#uncheck(force: nil, noWaitAfter: nil, timeout: nil) ⇒ Object

This method checks the element by performing the following steps:

  1. Ensure that element is a checkbox or a radio input. If not, this method rejects. If the element is already unchecked, this method returns immediately.

  2. Wait for [actionability](./actionability.md) checks on the element, unless ‘force` option is set.

  3. Scroll the element into view if needed.

  4. Use [‘property: Page.mouse`] to click in the center of the element.

  5. Wait for initiated navigations to either succeed or fail, unless ‘noWaitAfter` option is set.

  6. Ensure that the element is now unchecked. If not, this method rejects.

If the element is detached from the DOM at any moment during the action, this method rejects.

When all steps combined have not finished during the specified ‘timeout`, this method rejects with a `TimeoutError`. Passing zero timeout disables this.

Raises:

  • (NotImplementedError) 


431
432
433
 
# File 'lib/playwright_api/element_handle.rb', line 431

def uncheck(force: nil, noWaitAfter: nil, timeout: nil)
  raise NotImplementedError.new('uncheck is not implemented yet.')
end

#visible? ⇒ Boolean

Returns whether the element is [visible](./actionability.md#visible).

Raises:

  • (NotImplementedError) 


278
279
280
 
# File 'lib/playwright_api/element_handle.rb', line 278

def visible?
  raise NotImplementedError.new('visible? is not implemented yet.')
end

#wait_for_element_state(state, timeout: nil) ⇒ Object

Returns when the element satisfies the ‘state`.

Depending on the ‘state` parameter, this method waits for one of the [actionability](./actionability.md) checks to pass. This method throws when the element is detached while waiting, unless waiting for the `“hidden”` state.

  • ‘“visible”` Wait until the element is [visible](./actionability.md#visible).

  • ‘“hidden”` Wait until the element is [not visible](./actionability.md#visible) or [not attached](./actionability.md#attached). Note that waiting for hidden does not throw when the element detaches.

  • ‘“stable”` Wait until the element is both [visible](./actionability.md#visible) and [stable](./actionability.md#stable).

  • ‘“enabled”` Wait until the element is [enabled](./actionability.md#enabled).

  • ‘“disabled”` Wait until the element is [not enabled](./actionability.md#enabled).

  • ‘“editable”` Wait until the element is [editable](./actionability.md#editable).

If the element does not satisfy the condition for the ‘timeout` milliseconds, this method will throw.

Raises:

  • (NotImplementedError) 


449
450
451
 
# File 'lib/playwright_api/element_handle.rb', line 449

def wait_for_element_state(state, timeout: nil)
  raise NotImplementedError.new('wait_for_element_state is not implemented yet.')
end

#wait_for_selector(selector, state: nil, timeout: nil) ⇒ Object

Returns element specified by selector when it satisfies ‘state` option. Returns `null` if waiting for `hidden` or `detached`.

Wait for the ‘selector` relative to the element handle to satisfy `state` option (either appear/disappear from dom, or become visible/hidden). If at the moment of calling the method `selector` already satisfies the condition, the method will return immediately. If the selector doesn’t satisfy the condition for the ‘timeout` milliseconds, the function will throw.

“‘js await page.setContent(`<div><span></span></div>`); const div = await page.$(’div’); // Waiting for the ‘span’ selector relative to the div. const span = await div.waitForSelector(‘span’, { state: ‘attached’ }); “‘

> NOTE This method does not work across navigations, use [‘method: Page.waitForSelector`] instead.

Raises:

  • (NotImplementedError) 


470
471
472
 
# File 'lib/playwright_api/element_handle.rb', line 470

def wait_for_selector(selector, state: nil, timeout: nil)
  raise NotImplementedError.new('wait_for_selector is not implemented yet.')
end