puppeteer-ruby 0.0.4 → 0.0.10

data/lib/puppeteer/element_handle/bounding_box.rb

@@ -0,0 +1,12 @@
+class Puppeteer::ElementHandle < Puppeteer::JSHandle
+  class BoundingBox
+    def initialize(x:, y:, width:, height:)
+      @x = x
+      @y = y
+      @width = width
+      @height = height
+    end
+
+    attr_reader :x, :y, :width, :height
+  end
+end

data/lib/puppeteer/element_handle/box_model.rb

@@ -0,0 +1,19 @@
+class Puppeteer::ElementHandle < Puppeteer::JSHandle
+  class BoxModel
+    QUAD_ATTRIBUTE_NAMES = %i(content padding border margin)
+    # @param result [Hash]
+    def initialize(result_model)
+      QUAD_ATTRIBUTE_NAMES.each do |attr_name|
+        quad = result_model[attr_name.to_s]
+        instance_variable_set(
+          :"@#{attr_name}",
+          quad.each_slice(2).map { |x, y| Point.new(x: x, y: y) },
+        )
+      end
+      @width = result_model['width']
+      @height = result_model['height']
+    end
+    attr_reader(*QUAD_ATTRIBUTE_NAMES)
+    attr_reader :width, :height
+  end
+end

data/lib/puppeteer/element_handle/point.rb

@@ -0,0 +1,26 @@
+class Puppeteer::ElementHandle < Puppeteer::JSHandle
+  # A class to represent (x, y)-coordinates
+  # supporting + and / operators.
+  class Point
+    def initialize(x:, y:)
+      @x = x
+      @y = y
+    end
+
+    def +(other)
+      Point.new(
+        x: @x + other.x,
+        y: @y + other.y,
+      )
+    end
+
+    def /(num)
+      Point.new(
+        x: @x / num,
+        y: @y / num,
+      )
+    end
+
+    attr_reader :x, :y
+  end
+end

data/lib/puppeteer/errors.rb

@@ -1,4 +1,2 @@
-# ref: https://github.com/puppeteer/puppeteer/blob/master/lib/Errors.js
+# ref: https://github.com/puppeteer/puppeteer/blob/master/src/Errors.ts
 class Puppeteer::TimeoutError < StandardError; end
-
-class Puppeteer::WebSocktTransportError < StandardError; end

data/lib/puppeteer/execution_context.rb

@@ -122,7 +122,7 @@ class Puppeteer::ExecutionContext
       remote_object = Puppeteer::RemoteObject.new(result['result'])
 
       if exception_details
-        raise EvaluationError.new("Evaluation failed: #{exceptionDetails}")
+        raise EvaluationError.new("Evaluation failed: #{exception_details}")
       end
 
       if @return_by_value
@@ -216,20 +216,39 @@ class Puppeteer::ExecutionContext
   #   return createJSHandle(this, response.objects);
   # }
 
-  # /**
-  #  * @param {Puppeteer.ElementHandle} elementHandle
-  #  * @return {Promise<Puppeteer.ElementHandle>}
-  #  */
-  # async _adoptElementHandle(elementHandle) {
-  #   assert(elementHandle.executionContext() !== this, 'Cannot adopt handle that already belongs to this execution context');
-  #   assert(this._world, 'Cannot adopt handle without DOMWorld');
-  #   const nodeInfo = await this._client.send('DOM.describeNode', {
-  #     objectId: elementHandle._remoteObject.objectId,
-  #   });
-  #   const {object} = await this._client.send('DOM.resolveNode', {
-  #     backendNodeId: nodeInfo.node.backendNodeId,
-  #     executionContextId: this._contextId,
-  #   });
-  #   return /** @type {Puppeteer.ElementHandle}*/(createJSHandle(this, object));
-  # }
+  # @param backend_node_id [Integer]
+  # @return [Puppeteer::ElementHandle]
+  def adopt_backend_node_id(backend_node_id)
+    response = @client.send_message('DOM.resolveNode',
+      backendNodeId: backend_node_id,
+      executionContextId: @context_id,
+    )
+    Puppeteer::JSHandle.create(
+      context: self,
+      remote_object: Puppeteer::RemoteObject.new(response["object"]),
+    )
+  end
+
+  # @param element_handle [Puppeteer::ElementHandle]
+  # @return [Puppeteer::ElementHandle]
+  def adopt_element_handle(element_handle)
+    if element_handle.execution_context == self
+      raise ArgumentError.new('Cannot adopt handle that already belongs to this execution context')
+    end
+
+    unless @world
+      raise 'Cannot adopt handle without DOMWorld'
+    end
+
+    node_info = element_handle.remote_object.node_info(@client)
+    response = @client.send_message('DOM.resolveNode',
+      backendNodeId: node_info["node"]["backendNodeId"],
+      executionContextId: @context_id,
+    )
+
+    Puppeteer::JSHandle.create(
+      context: self,
+      remote_object: Puppeteer::RemoteObject.new(response["object"]),
+    )
+  end
 end

data/lib/puppeteer/file_chooser.rb

@@ -0,0 +1,29 @@
+class Puppeteer::FileChooser
+  # @param element [Puppeteer::ElementHandle]
+  # @param event [Hash]
+  def initialize(element, event)
+    @element = element
+    @multiple = event['mode'] != 'selectSingle'
+    @handled = false
+  end
+
+  def multiple?
+    @multiple
+  end
+
+  # @param file_paths [Array<String>]
+  def accept(file_paths)
+    if @handled
+      raise 'Cannot accept FileChooser which is already handled!'
+    end
+    @handled = true
+    @element.upload_file(*file_paths)
+  end
+
+  def cancel
+    if @handled
+      raise 'Cannot cancel FileChooser which is already handled!'
+    end
+    @handled = true
+  end
+end

data/lib/puppeteer/frame.rb

@@ -173,11 +173,11 @@ class Puppeteer::Frame
     @secondary_world.tap(selector)
   end
 
-  # @param {string} selector
-  # @param {string} text
-  # @param {{delay: (number|undefined)}=} options
-  def type(selector, text, delay: nil)
-    @main_world.type(selector, text, delay: delay)
+  # @param selector [String]
+  # @param text [String]
+  # @param delay [Number]
+  def type_text(selector, text, delay: nil)
+    @main_world.type_text(selector, text, delay: delay)
   end
 
   # /**
@@ -202,9 +202,10 @@ class Puppeteer::Frame
   #   return Promise.reject(new Error('Unsupported target type: ' + (typeof selectorOrFunctionOrTimeout)));
   # }
 
-  # @param {string} selector
-  # @param {!{visible?: boolean, hidden?: boolean, timeout?: number}=} options
-  # @return {!Promise<?Puppeteer.ElementHandle>}
+  # @param selector [String]
+  # @param visible [Boolean] Wait for element visible (not 'display: none' nor 'visibility: hidden') on true. default to false.
+  # @param hidden [Boolean] Wait for element invisible ('display: none' nor 'visibility: hidden') on true. default to false.
+  # @param timeout [Integer]
   def wait_for_selector(selector, visible: nil, hidden: nil, timeout: nil)
     handle = @secondary_world.wait_for_selector(selector, visible: visible, hidden: hidden, timeout: timeout)
     if !handle
@@ -216,9 +217,10 @@ class Puppeteer::Frame
     result
   end
 
-  # @param {string} xpath
-  # @param {!{visible?: boolean, hidden?: boolean, timeout?: number}=} options
-  # @return {!Promise<?Puppeteer.ElementHandle>}
+  # @param xpath [String]
+  # @param visible [Boolean] Wait for element visible (not 'display: none' nor 'visibility: hidden') on true. default to false.
+  # @param hidden [Boolean] Wait for element invisible ('display: none' nor 'visibility: hidden') on true. default to false.
+  # @param timeout [Integer]
   def wait_for_xpath(xpath, visible: nil, hidden: nil, timeout: nil)
     handle = @secondary_world.wait_for_xpath(xpath, visible: visible, hidden: hidden, timeout: timeout)
     if !handle
@@ -248,6 +250,10 @@ class Puppeteer::Frame
     # TODO(lushnikov): remove this once requestInterception has loaderId exposed.
     @navigation_url = frame_payload['url']
     @url = frame_payload['url']
+
+    # Ensure loaderId updated.
+    # The order of [Page.lifecycleEvent name="init"] and [Page.frameNavigated] is random... for some reason...
+    @loader_id = frame_payload['loaderId']
   end
 
   # @param url [String]

data/lib/puppeteer/frame_manager.rb

@@ -219,7 +219,7 @@ class Puppeteer::FrameManager
 
   # @param frame_payload [Hash]
   def handle_frame_navigated(frame_payload)
-    is_main_frame = !frame_payload['parent_id']
+    is_main_frame = !frame_payload['parentId']
     frame =
       if is_main_frame
         @main_frame
@@ -285,8 +285,6 @@ class Puppeteer::FrameManager
     frame.navigated_within_document(url)
     emit_event 'Events.FrameManager.FrameNavigatedWithinDocument', frame
     emit_event 'Events.FrameManager.FrameNavigated', frame
-    handle_frame_manager_frame_navigated_within_document(frame)
-    handle_frame_manager_frame_navigated(frame)
   end
 
   # @param frame_id [String]

data/lib/puppeteer/js_handle.rb

@@ -89,8 +89,9 @@ class Puppeteer::JSHandle
     response['result'].each_with_object({}) do |prop, h|
       next unless prop['enumerable']
       h[prop['name']] = Puppeteer::JSHandle.create(
-                          context: @context,
-                          remote_object: Puppeteer::RemoteObject.new(prop['value']))
+        context: @context,
+        remote_object: Puppeteer::RemoteObject.new(prop['value']),
+      )
     end
   end
 

data/lib/puppeteer/launcher.rb

@@ -6,7 +6,6 @@ require_relative './launcher/launch_options'
 
 # https://github.com/puppeteer/puppeteer/blob/master/lib/Launcher.js
 module Puppeteer::Launcher
-
   # @param {string} projectRoot
   # @param {string} preferredRevision
   # @param {boolean} isPuppeteerCore

data/lib/puppeteer/launcher/chrome.rb

@@ -149,8 +149,54 @@ module Puppeteer::Launcher
 
     # @param {!(Launcher.BrowserOptions & {browserWSEndpoint?: string, browserURL?: string, transport?: !Puppeteer.ConnectionTransport})} options
     # @return {!Promise<!Browser>}
-    def connect(options)
-      raise NotImplementedError.new('Puppeteer.connect is not implemented yet')
+    def connect(options = {})
+      @browser_options = BrowserOptions.new(options)
+      browser_ws_endpoint = options[:browser_ws_endpoint]
+      browser_url = options[:browser_url]
+      transport = options[:transport]
+
+      connection =
+        if browser_ws_endpoint && browser_url.nil? && transport.nil?
+          connect_with_browser_ws_endpoint(browser_ws_endpoint)
+        elsif browser_ws_endpoint.nil? && browser_url && transport.nil?
+          connect_with_browser_url(browser_url)
+        elsif browser_ws_endpoint.nil? && browser_url.nil? && transport
+          connect_with_transport(transport)
+        else
+          raise ArgumentError.new("Exactly one of browserWSEndpoint, browserURL or transport must be passed to puppeteer.connect")
+        end
+
+      result = connection.send_message('Target.getBrowserContexts')
+      browser_context_ids = result['browserContextIds']
+
+      Puppeteer::Browser.create(
+        connection: connection,
+        context_ids: browser_context_ids,
+        ignore_https_errors: @browser_options.ignore_https_errors?,
+        default_viewport: @browser_options.default_viewport,
+        process: nil,
+        close_callback: -> { connection.send_message('Browser.close') },
+      )
+    end
+
+    # @return [Puppeteer::Connection]
+    private def connect_with_browser_ws_endpoint(browser_ws_endpoint)
+      transport = Puppeteer::WebSocketTransport.create(browser_ws_endpoint)
+      Puppeteer::Connection.new(browser_ws_endpoint, transport, @browser_options.slow_mo)
+    end
+
+    # @return [Puppeteer::Connection]
+    private def connect_with_browser_url(browser_url)
+      raise NotImplementedError.new('Puppeteer#connect with browserUrl is not implemented yet.')
+      # const connectionURL = await getWSEndpoint(browserURL);
+      # const connectionTransport = await WebSocketTransport.create(
+      #   connectionURL
+      # );
+    end
+
+    # @return [Puppeteer::Connection]
+    private def connect_with_transport(transport)
+      Puppeteer::Connection.new('', transport, @browser_options.slow_mo)
     end
 
     # @return {string}

data/lib/puppeteer/lifecycle_watcher.rb

@@ -73,7 +73,7 @@ class Puppeteer::LifecycleWatcher
       terminate(TerminatedError.new('Navigation failed because browser has disconnected!'))
     end
     @listener_ids['frame_manager'] = [
-      @frame_manager.add_event_listener('Events.FrameManager.LifecycleEvent') do |frame|
+      @frame_manager.add_event_listener('Events.FrameManager.LifecycleEvent') do |_|
         check_lifecycle_complete
       end,
       @frame_manager.add_event_listener('Events.FrameManager.FrameNavigatedWithinDocument', &method(:navigated_within_document)),
@@ -149,10 +149,10 @@ class Puppeteer::LifecycleWatcher
     if @frame.loader_id == @initial_loader_id && !@has_same_document_navigation
       return
     end
-    if @has_same_document_navigation
+    if @has_same_document_navigation && @same_document_navigation_promise.pending?
       @same_document_navigation_promise.fulfill(true)
     end
-    if @frame.loader_id != @initial_loader_id
+    if @frame.loader_id != @initial_loader_id && @new_document_navigation_promise.pending?
       @new_document_navigation_promise.fulfill(true)
     end
   end

data/lib/puppeteer/page.rb

@@ -48,10 +48,10 @@ class Puppeteer::Page
       if event['targetInfo']['type'] != 'worker'
         # If we don't detach from service workers, they will never die.
         await @client.send_message('Target.detachFromTarget', sessionId: event['sessionId'])
-        return
+        next
       end
 
-      session = Puppeteer::Connection.from_session(@client).session(event['sessionId'])
+      session = Puppeteer::Connection.from_session(@client).session(event['sessionId']) # rubocop:disable Lint/UselessAssignment
       #   const worker = new Worker(session, event.targetInfo.url, this._addConsoleMessage.bind(this), this._handleException.bind(this));
       #   this._workers.set(event.sessionId, worker);
       #   this.emit(Events.Page.WorkerCreated, worker);
@@ -59,7 +59,7 @@ class Puppeteer::Page
     @client.on_event 'Target.detachedFromTarget' do |event|
       session_id = event['sessionId']
       worker = @workers[session_id]
-      return unless worker
+      next unless worker
 
       emit_event('Events.Page.WorkerDestroyed', worker)
       @workers.delete(session_id)
@@ -88,8 +88,8 @@ class Puppeteer::Page
     network_manager.on_event 'Events.NetworkManager.RequestFinished' do |event|
       emit_event 'Events.Page.RequestFinished', event
     end
-    # this._fileChooserInterceptionIsDisabled = false;
-    # this._fileChooserInterceptors = new Set();
+    @file_chooser_interception_is_disabled = false
+    @file_chooser_interceptors = Set.new
 
     @client.on_event 'Page.domContentEventFired' do |event|
       emit_event 'Events.Page.DOMContentLoaded'
@@ -106,8 +106,10 @@ class Puppeteer::Page
     @client.on_event 'Log.entryAdded' do |event|
       handle_log_entry_added(event)
     end
-    # client.on('Page.fileChooserOpened', event => this._onFileChooser(event));
-    @target.on_close do
+    @client.on_event 'Page.fileChooserOpened' do |event|
+      handle_file_chooser(event)
+    end
+    @target.is_closed_promise.then do
       emit_event 'Events.Page.Close'
       @closed = true
     end
@@ -122,41 +124,53 @@ class Puppeteer::Page
     )
   end
 
-  # /**
-  #  * @param {!Protocol.Page.fileChooserOpenedPayload} event
-  #  */
-  # async _onFileChooser(event) {
-  #   if (!this._fileChooserInterceptors.size)
-  #     return;
-  #   const frame = this._frameManager.frame(event.frameId);
-  #   const context = await frame.executionContext();
-  #   const element = await context._adoptBackendNodeId(event.backendNodeId);
-  #   const interceptors = Array.from(this._fileChooserInterceptors);
-  #   this._fileChooserInterceptors.clear();
-  #   const fileChooser = new FileChooser(this._client, element, event);
-  #   for (const interceptor of interceptors)
-  #     interceptor.call(null, fileChooser);
-  # }
+  def handle_file_chooser(event)
+    return if @file_chooser_interceptors.empty?
+
+    frame = @frame_manager.frame(event['frameId'])
+    context = frame.execution_context
+    element = context.adopt_backend_node_id(event['backendNodeId'])
+    interceptors = @file_chooser_interceptors.to_a
+    @file_chooser_interceptors.clear
+    file_chooser = Puppeteer::FileChooser.new(element, event)
+    interceptors.each do |promise|
+      promise.fulfill(file_chooser)
+    end
+  end
 
-  # /**
-  #  * @param {!{timeout?: number}=} options
-  #  * @return !Promise<!FileChooser>}
-  #  */
-  # async waitForFileChooser(options = {}) {
-  #   if (!this._fileChooserInterceptors.size)
-  #     await this._client.send('Page.setInterceptFileChooserDialog', {enabled: true});
+  class FileChooserTimeoutError < StandardError
+    def initialize(timeout:)
+      super("waiting for filechooser failed: timeout #{timeout}ms exceeded")
+    end
+  end
 
-  #   const {
-  #     timeout = this._timeoutSettings.timeout(),
-  #   } = options;
-  #   let callback;
-  #   const promise = new Promise(x => callback = x);
-  #   this._fileChooserInterceptors.add(callback);
-  #   return helper.waitWithTimeout(promise, 'waiting for file chooser', timeout).catch(e => {
-  #     this._fileChooserInterceptors.delete(callback);
-  #     throw e;
-  #   });
-  # }
+  # @param timeout [Integer]
+  # @return [Puppeteer::FileChooser]
+  def wait_for_file_chooser(timeout: nil)
+    if @file_chooser_interceptors.empty?
+      @client.send_message('Page.setInterceptFileChooserDialog', enabled: true)
+    end
+
+    option_timeout = timeout || @timeout_settings.timeout
+    promise = resolvable_future
+    @file_chooser_interceptors << promise
+
+    begin
+      Timeout.timeout(option_timeout / 1000.0) do
+        promise.value!
+      end
+    rescue Timeout::Error
+      raise FileChooserTimeoutError.new(timeout: option_timeout)
+    ensure
+      @file_chooser_interceptors.delete(promise)
+    end
+  end
+
+  # @param timeout [Integer]
+  # @return [Future<Puppeteer::FileChooser>]
+  async def async_wait_for_file_chooser(timeout: nil)
+    wait_for_file_chooser(timeout: timeout)
+  end
 
 
   # /**
@@ -204,7 +218,9 @@ class Puppeteer::Page
     end
     if source != 'worker'
       console_message_location = Puppeteer::ConsoleMessage::Location.new(
-                                    url: url, line_number: line_number)
+        url: url,
+        line_number: line_number,
+      )
       emit_event('Events.Page.Console',
         Puppeteer::ConsoleMessage.new(level, text, [], console_message_location))
     end
@@ -273,23 +289,37 @@ class Puppeteer::Page
   end
 
   # `$eval()` in JavaScript. $ is not allowed to use as a method name in Ruby.
-  # @param {string} selector
-  # @param {Function|string} pageFunction
-  # @param {!Array<*>} args
-  # @return {!Promise<(!Object|undefined)>}
+  # @param selector [String]
+  # @param page_function [String]
+  # @return [Object]
   def Seval(selector, page_function, *args)
     main_frame.Seval(selector, page_function, *args)
   end
 
+  # `$eval()` in JavaScript. $ is not allowed to use as a method name in Ruby.
+  # @param selector [String]
+  # @param page_function [String]
+  # @return [Future]
+  async def async_Seval(selector, page_function, *args)
+    Seval(selector, page_function, *args)
+  end
+
   # `$$eval()` in JavaScript. $ is not allowed to use as a method name in Ruby.
-  # @param {string} selector
-  # @param {Function|string} pageFunction
-  # @param {!Array<*>} args
-  # @return {!Promise<(!Object|undefined)>}
+  # @param selector [String]
+  # @param page_function [String]
+  # @return [Object]
   def SSeval(selector, page_function, *args)
     main_frame.SSeval(selector, page_function, *args)
   end
 
+  # `$$eval()` in JavaScript. $ is not allowed to use as a method name in Ruby.
+  # @param selector [String]
+  # @param page_function [String]
+  # @return [Future]
+  async def async_SSeval(selector, page_function, *args)
+    SSeval(selector, page_function, *args)
+  end
+
   # `$x()` in JavaScript. $ is not allowed to use as a method name in Ruby.
   # @param {string} expression
   # @return {!Promise<!Array<!Puppeteer.ElementHandle>>}
@@ -608,14 +638,14 @@ class Puppeteer::Page
     main_frame.goto(url, referer: referer, timeout: timeout, wait_until: wait_until)
   end
 
-  # @param {!{timeout?: number, waitUntil?: string|!Array<string>}=} options
-  # @return {!Promise<?Puppeteer.Response>}
+  # @param timeout [number|nil]
+  # @param wait_until [string|nil] 'load' | 'domcontentloaded' | 'networkidle0' | 'networkidle2'
+  # @return [Puppeteer::Response]
   def reload(timeout: nil, wait_until: nil)
-    # const [response] = await Promise.all([
-    #   this.waitForNavigation(options),
-    #   this._client.send('Page.reload')
-    # ]);
-    # return response;
+    await_all(
+      async_wait_for_navigation(timeout: timeout, wait_until: wait_until),
+      @client.async_send_message('Page.reload'),
+    ).first
   end
 
   # @param timeout [number|nil]
@@ -966,16 +996,21 @@ class Puppeteer::Page
     main_frame.select(selector, *values)
   end
 
-  # @param {string} selector
+  # @param selector [String]
   def tap(selector)
     main_frame.tap(selector)
   end
 
-  # @param {string} selector
-  # @param {string} text
-  # @param {{delay: (number|undefined)}=} options
-  def type(selector, text, delay: nil)
-    main_frame.type(selector, text, delay: delay)
+  # @param selector [String]
+  async def async_tap(selector)
+    tap(selector)
+  end
+
+  # @param selector [String]
+  # @param text [String]
+  # @param delay [Number]
+  def type_text(selector, text, delay: nil)
+    main_frame.type_text(selector, text, delay: delay)
   end
 
   # /**
@@ -988,20 +1023,38 @@ class Puppeteer::Page
   #   return this.mainFrame().waitFor(selectorOrFunctionOrTimeout, options, ...args);
   # }
 
-  # @param {string} selector
-  # @param {!{visible?: boolean, hidden?: boolean, timeout?: number}=} options
-  # @return {!Promise<?Puppeteer.ElementHandle>}
+  # @param selector [String]
+  # @param visible [Boolean] Wait for element visible (not 'display: none' nor 'visibility: hidden') on true. default to false.
+  # @param hidden [Boolean] Wait for element invisible ('display: none' nor 'visibility: hidden') on true. default to false.
+  # @param timeout [Integer]
   def wait_for_selector(selector, visible: nil, hidden: nil, timeout: nil)
     main_frame.wait_for_selector(selector, visible: visible, hidden: hidden, timeout: timeout)
   end
 
-  # @param {string} xpath
-  # @param {!{visible?: boolean, hidden?: boolean, timeout?: number}=} options
-  # @return {!Promise<?Puppeteer.ElementHandle>}
+  # @param selector [String]
+  # @param visible [Boolean] Wait for element visible (not 'display: none' nor 'visibility: hidden') on true. default to false.
+  # @param hidden [Boolean] Wait for element invisible ('display: none' nor 'visibility: hidden') on true. default to false.
+  # @param timeout [Integer]
+  async def async_wait_for_selector(selector, visible: nil, hidden: nil, timeout: nil)
+    wait_for_selector(selector, visible: visible, hidden: hidden, timeout: timeout)
+  end
+
+  # @param xpath [String]
+  # @param visible [Boolean] Wait for element visible (not 'display: none' nor 'visibility: hidden') on true. default to false.
+  # @param hidden [Boolean] Wait for element invisible ('display: none' nor 'visibility: hidden') on true. default to false.
+  # @param timeout [Integer]
   def wait_for_xpath(xpath, visible: nil, hidden: nil, timeout: nil)
     main_frame.wait_for_xpath(xpath, visible: visible, hidden: hidden, timeout: timeout)
   end
 
+  # @param xpath [String]
+  # @param visible [Boolean] Wait for element visible (not 'display: none' nor 'visibility: hidden') on true. default to false.
+  # @param hidden [Boolean] Wait for element invisible ('display: none' nor 'visibility: hidden') on true. default to false.
+  # @param timeout [Integer]
+  async def async_wait_for_xpath(xpath, visible: nil, hidden: nil, timeout: nil)
+    wait_for_xpath(xpath, visible: visible, hidden: hidden, timeout: timeout)
+  end
+
   # @param {Function|string} pageFunction
   # @param {!{polling?: string|number, timeout?: number}=} options
   # @param {!Array<*>} args