puppeteer-ruby 0.0.2

data/lib/puppeteer/mouse.rb

@@ -0,0 +1,120 @@
+class Puppeteer::Mouse
+  using Puppeteer::AsyncAwaitBehavior
+
+  module Button
+    NONE = 'none'
+    LEFT = 'left'
+    RIGHT = 'right'
+    MIDDLE = 'middle'
+  end
+
+  # @param {Puppeteer.CDPSession} client
+  # @param keyboard [Puppeteer::Keyboard]
+  def initialize(client, keyboard)
+    @client = client
+    @keyboard = keyboard
+
+    @x = 0
+    @y = 0
+    @button = Button::NONE
+  end
+
+  # @param x [number]
+  # @param y [number]
+  # @param steps [number]
+  def move(x, y, steps: nil)
+    move_steps = (steps || 1).to_i
+
+    from_x = @x
+    from_y = @y
+    @x = x
+    @y = y
+
+    return if move_steps <= 0
+
+    move_steps.times do |i|
+      n = i + 1
+      @client.send_message('Input.dispatchMouseEvent',
+        type: 'mouseMoved',
+        button: @button,
+        x: from_x + (@x - from_x) * n / steps,
+        y: from_y + (@y - from_y) * n / steps,
+        modifiers: @keyboard.modifiers,
+      )
+    end
+  end
+
+  # @param x [number]
+  # @param y [number]
+  # @param steps [number]
+  # @return [Future]
+  async def async_move(x, y, steps: nil)
+    move(x, y, steps: steps)
+  end
+
+  # @param x [number]
+  # @param y [number]
+  # @param {!{delay?: number, button?: "left"|"right"|"middle", clickCount?: number}=} options
+  def click(x, y, delay: nil, button: nil, click_count: nil)
+    if delay
+      await_all(
+        async_move(x, y),
+        async_down(button: button, click_count: click_count),
+      )
+      sleep(delay / 1000.0)
+      up(button: button, click_count: click_count)
+    else
+      await_all(
+        async_move(x, y),
+        async_down(button: button, click_count: click_count),
+        async_up(button: button, click_count: click_count),
+      )
+    end
+  end
+
+  # @param x [number]
+  # @param y [number]
+  # @param {!{delay?: number, button?: "left"|"right"|"middle", clickCount?: number}=} options
+  # @return [Future]
+  async def async_click(x, y, delay: nil, button: nil, click_count: nil)
+    click(x, y, delay: delay, button: button, click_count: click_count)
+  end
+
+  # @param {!{button?: "left"|"right"|"middle", clickCount?: number}=} options
+  def down(button: nil, click_count: nil)
+    @button = button || Button::LEFT
+    @client.send_message('Input.dispatchMouseEvent',
+      type: 'mousePressed',
+      button: @button,
+      x: @x,
+      y: @y,
+      modifiers: @keyboard.modifiers,
+      clickCount: click_count || 1,
+    )
+  end
+
+  # @param {!{button?: "left"|"right"|"middle", clickCount?: number}=} options
+  # @return [Future]
+  async def async_down(button: nil, click_count: nil)
+    down(button: button, click_count: click_count)
+  end
+
+  # @param {!{button?: "left"|"right"|"middle", clickCount?: number}=} options
+  def up(button: nil, click_count: nil)
+    @button = Button::NONE
+    @client.send_message('Input.dispatchMouseEvent',
+      type: 'mouseReleased',
+      button: button || Button::LEFT,
+      x: @x,
+      y: @y,
+      modifiers: @keyboard.modifiers,
+      clickCount: click_count || 1,
+    )
+  end
+
+  # @param {!{button?: "left"|"right"|"middle", clickCount?: number}=} options
+  # @return [Future]
+  async def async_up(button: nil, click_count: nil)
+    up(button: button, click_count: click_count)
+  end
+end

data/lib/puppeteer/network_manager.rb

@@ -0,0 +1,122 @@
+class Puppeteer::NetworkManager
+  include Puppeteer::EventCallbackable
+
+  class Credentials
+    # @param username [String|NilClass]
+    # @param password [String|NilClass]
+    def initialize(username:, password:)
+      @username = username
+      @password = password
+    end
+    attr_reader :username, :password
+  end
+
+  # @param {!Puppeteer.CDPSession} client
+  # @param {boolean} ignoreHTTPSErrors
+  # @param {!Puppeteer.FrameManager} frameManager
+  def initialize(client, ignore_https_errors, frame_manager)
+    @client = client
+    @ignore_https_errors = ignore_https_errors
+    @frame_manager = frame_manager
+
+    # @type {!Map<string, !Request>}
+    @request_id_to_request = {}
+
+    # @type {!Map<string, !Protocol.Network.requestWillBeSentPayload>}
+    @request_id_to_request_with_be_sent_event
+
+    @extra_http_headers = {}
+
+    @offline = false
+
+    # /** @type {!Set<string>} */
+    # this._attemptedAuthentications = new Set();
+    @user_request_interception_enabled = false
+    @protocol_request_interception_enabled = false
+    @user_cache_disabled = false
+    # /** @type {!Map<string, string>} */
+    # this._requestIdToInterceptionId = new Map();
+  end
+
+  def init
+    @client.send_message('Network.enable')
+    if @ignore_https_errors
+      @client.send_message('Security.setIgnoreCertificateErrors', ignore: true)
+    end
+  end
+
+  # @param username [String|NilClass]
+  # @param password [String|NilClass]
+  def authenticate(username:, password:)
+    @credentials = Credentials.new(username: username, password: password)
+    update_protocol_request_interception
+  end
+
+  # @param {!Object<string, string>} extraHTTPHeaders
+  def extra_http_headers=(headers)
+    new_extra_http_headers = {}
+    headers.each do |key, value|
+      unless value.is_a?(String)
+        raise ArgumentError.new("Expected value of header \"#{key}\" to be String, but \"#{value}\" is found.")
+      end
+      new_extra_http_headers[key.downcase] = value
+    end
+    @extra_http_headers = new_extra_http_headers
+    @client.send_message('Network.setExtraHTTPHeaders', headers: new_extra_http_headers)
+  end
+
+  # @return {!Object<string, string>}
+  def extra_http_headers
+    @extra_http_headers.dup
+  end
+
+  # @param value [TrueClass|FalseClass]
+  def offline_mode=(value)
+    return if @offline == value
+    @offline = value
+    @client.send_message('Network.emulateNetworkConditions',
+      offline: @offline,
+      # values of 0 remove any active throttling. crbug.com/456324#c9
+      latency: 0,
+      downloadThroughput: -1,
+      uploadThroughput: -1,
+    )
+  end
+
+  # @param user_agent [String]
+  def user_agent=(user_agent)
+    @client.send_message('Network.setUserAgentOverride', userAgent: user_agent)
+  end
+
+  def cache_enabled=(enabled)
+    @user_cache_disabled = !enabled
+    update_protocol_cache_disabled
+  end
+
+  def request_interception=(enabled)
+    @user_request_interception_enabled = enabled
+    update_protocol_request_interception
+  end
+
+  private def update_protocol_request_interception
+    enabled = @user_request_interception_enabled || !@credentials.nil?
+    return if @protocol_request_interception_enabled == enabled
+    @protocol_request_interception_enabled = enabled
+
+    if enabled
+      update_protocol_cache_disabled
+      @client.send_message('Fetch.enable',
+        handleAuthRequests: true,
+        patterns: [{urlPattern: '*'}],
+      )
+    else
+      update_protocol_cache_disabled
+      @client.async_send_message('Fetch.disable')
+    end
+  end
+
+  private def update_protocol_cache_disabled
+    cache_disabled = @user_cache_disabled || @protocol_request_interception_enabled
+    @client.send_message('Network.setCacheDisabled', cacheDisabled: cache_disabled)
+  end
+end

data/lib/puppeteer/page.rb

@@ -0,0 +1,1001 @@
+require 'base64'
+
+require_relative './page/screenshot_options'
+
+class Puppeteer::Page
+  include Puppeteer::EventCallbackable
+  include Puppeteer::IfPresent
+  using Puppeteer::AsyncAwaitBehavior
+
+  # @param {!Puppeteer.CDPSession} client
+  # @param {!Puppeteer.Target} target
+  # @param {boolean} ignoreHTTPSErrors
+  # @param {?Puppeteer.Viewport} defaultViewport
+  # @param {!Puppeteer.TaskQueue} screenshotTaskQueue
+  # @return {!Promise<!Page>}
+  def self.create(client, target, ignore_https_errors, default_viewport, screenshot_task_queue)
+    page = Puppeteer::Page.new(client, target, ignore_https_errors, screenshot_task_queue)
+    page.init
+    if default_viewport
+      page.viewport = default_viewport
+    end
+    page
+  end
+
+  # @param {!Puppeteer.CDPSession} client
+  # @param {!Puppeteer.Target} target
+  # @param {boolean} ignoreHTTPSErrors
+  # @param {!Puppeteer.TaskQueue} screenshotTaskQueue
+  def initialize(client, target, ignore_https_errors, screenshot_task_queue)
+    @closed = false
+    @client = client
+    @target = target
+    @keyboard = Puppeteer::Keyboard.new(client)
+    @mouse = Puppeteer::Mouse.new(client, @keyboard)
+    @timeout_settings = Puppeteer::TimeoutSettings.new
+    @touchscreen = Puppeteer::TouchScreen.new(client, @keyboard)
+    #@accessibility = Accessibility.new(client)
+    @frame_manager = Puppeteer::FrameManager.new(client, self, ignore_https_errors, @timeout_settings)
+    @emulation_manager = Puppeteer::EmulationManager.new(client)
+    #@tracing = Tracing.new(client)
+    @page_bindings = {}
+    #@coverage = Coverage.new(client)
+    @javascript_enabled = true
+    @screenshot_task_queue = screenshot_task_queue
+
+    @workers = {}
+    @client.on_event 'Target.attachedToTarget' do |event|
+      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
+      end
+
+      session = Puppeteer::Connection.from_session(@client).session(event['sessionId'])
+      #   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);
+    end
+    @client.on_event 'Target.detachedFromTarget' do |event|
+      session_id = event['sessionId']
+      worker = @workers[session_id]
+      return unless worker
+
+      emit_event('Events.Page.WorkerDestroyed', worker)
+      @workers.delete(session_id)
+    end
+
+    @frame_manager.on_event 'Events.FrameManager.FrameAttached' do |event|
+      emit_event 'Events.Page.FrameAttached', event
+    end
+    @frame_manager.on_event 'Events.FrameManager.FrameDetached' do |event|
+      emit_event 'Events.Page.FrameDetached', event
+    end
+    @frame_manager.on_event 'Events.FrameManager.FrameNavigated' do |event|
+      emit_event 'Events.Page.FrameNavigated', event
+    end
+
+    network_manager = @frame_manager.network_manager
+    network_manager.on_event 'Events.NetworkManager.Request' do |event|
+      emit_event 'Events.Page.Request', event
+    end
+    network_manager.on_event 'Events.NetworkManager.Response' do |event|
+      emit_event 'Events.Page.Response', event
+    end
+    network_manager.on_event 'Events.NetworkManager.RequestFailed' do |event|
+      emit_event 'Events.Page.RequestFailed', event
+    end
+    network_manager.on_event 'Events.NetworkManager.RequestFinished' do |event|
+      emit_event 'Events.Page.RequestFinished', event
+    end
+    # this._fileChooserInterceptionIsDisabled = false;
+    # this._fileChooserInterceptors = new Set();
+
+    @client.on_event 'Page.domContentEventFired' do |event|
+      emit_event 'Events.Page.DOMContentLoaded'
+    end
+    @client.on_event 'Page.loadEventFired' do |event|
+      emit_event 'Events.Page.Load'
+    end
+    # client.on('Runtime.consoleAPICalled', event => this._onConsoleAPI(event));
+    # client.on('Runtime.bindingCalled', event => this._onBindingCalled(event));
+    # client.on('Page.javascriptDialogOpening', event => this._onDialog(event));
+    # client.on('Runtime.exceptionThrown', exception => this._handleException(exception.exceptionDetails));
+    # client.on('Inspector.targetCrashed', event => this._onTargetCrashed());
+    # client.on('Performance.metrics', event => this._emitMetrics(event));
+    @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
+      emit_event 'Events.Page.Close'
+      @closed = true
+    end
+  end
+
+  def init
+    await_all(
+      @frame_manager.async_init,
+      @client.async_send_message('Target.setAutoAttach', autoAttach: true, waitForDebuggerOnStart: false, flatten: true),
+      @client.async_send_message('Performance.enable'),
+      @client.async_send_message('Log.enable'),
+    )
+  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);
+  # }
+
+  # /**
+  #  * @param {!{timeout?: number}=} options
+  #  * @return !Promise<!FileChooser>}
+  #  */
+  # async waitForFileChooser(options = {}) {
+  #   if (!this._fileChooserInterceptors.size)
+  #     await this._client.send('Page.setInterceptFileChooserDialog', {enabled: true});
+
+  #   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 {!{longitude: number, latitude: number, accuracy: (number|undefined)}} options
+  #  */
+  # async setGeolocation(options) {
+  #   const { longitude, latitude, accuracy = 0} = options;
+  #   if (longitude < -180 || longitude > 180)
+  #     throw new Error(`Invalid longitude "${longitude}": precondition -180 <= LONGITUDE <= 180 failed.`);
+  #   if (latitude < -90 || latitude > 90)
+  #     throw new Error(`Invalid latitude "${latitude}": precondition -90 <= LATITUDE <= 90 failed.`);
+  #   if (accuracy < 0)
+  #     throw new Error(`Invalid accuracy "${accuracy}": precondition 0 <= ACCURACY failed.`);
+  #   await this._client.send('Emulation.setGeolocationOverride', {longitude, latitude, accuracy});
+  # }
+
+  attr_reader :target
+
+  def browser
+    @target.browser
+  end
+
+  def browser_context
+    @target.browser_context
+  end
+
+  class TargetCrashedError < StandardError ; end
+
+  private def handle_target_crashed
+    emit_event 'error', TargetCrashedError.new('Page crashed!')
+  end
+
+  private def handle_log_entry_added(event)
+    entry = event["entry"]
+    level = entry["level"]
+    text = entry["text"]
+    source = entry["source"]
+    url = entry["url"]
+    line_number = entry["lineNumber"]
+
+    if_present(entry["args"]) do |args|
+      args.map do |arg|
+        Puppeteer::RemoteObject.new(arg).async_release(@client)
+      end
+    end
+    if source != 'worker'
+      console_message_location = Puppeteer::ConsoleMessage::Location.new(
+                                    url: url, line_number: line_number)
+      emit_event("Events.Page.Console",
+        Puppeteer::ConsoleMessage.new(level, text, [], console_message_location))
+    end
+  end
+
+  def main_frame
+    @frame_manager.main_frame
+  end
+
+  attr_reader :keyboard, :touch_screen, :coverage, :accessibility
+
+  def frames
+    @frame_manager.frames
+  end
+
+  def workers
+    @workers.values
+  end
+
+  # @param value [Bool]
+  def request_interception=(value)
+    @frame_manager.network_manager.request_interception = value
+  end
+
+  def offline_mode=(enabled)
+    @frame_manager.network_manager.offline_mode = enabled
+  end
+
+  # @param {number} timeout
+  def default_navigation_timeout=(timeout)
+    @timeout_settings.default_navigation_timeout = timeout
+  end
+
+  # @param {number} timeout
+  def default_timeout=(timeout)
+    @timeout_settings.default_timeout = timeout
+  end
+
+  # `$()` in JavaScript. $ is not allowed to use as a method name in Ruby.
+  # @param {string} selector
+  # @return {!Promise<?Puppeteer.ElementHandle>}
+  def S(selector)
+    main_frame.S(selector)
+  end
+
+  # `$$()` in JavaScript. $ is not allowed to use as a method name in Ruby.
+  # @param {string} selector
+  # @return {!Promise<!Array<!Puppeteer.ElementHandle>>}
+  def SS(selector)
+    main_frame.SS(selector)
+  end
+
+  # @param {Function|string} pageFunction
+  # @param {!Array<*>} args
+  # @return {!Promise<!Puppeteer.JSHandle>}
+  def evaluate_handle(page_function, *args)
+    context = main_frame.execution_context
+    context.evaluate_handle(page_function, *args)
+  end
+
+  # @param {!Puppeteer.JSHandle} prototypeHandle
+  # @return {!Promise<!Puppeteer.JSHandle>}
+  def query_objects(prototype_handle)
+    context = main_frame.execution_context
+    context.query_objects(prototype_handle)
+  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)>}
+  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 {string} selector
+  # @param {Function|string} pageFunction
+  # @param {!Array<*>} args
+  # @return {!Promise<(!Object|undefined)>}
+  def SSeval(selector, page_function, *args)
+    main_frame.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>>}
+  def Sx(expression)
+    main_frame.Sx(expression)
+  end
+
+  # /**
+  #  * @param {!Array<string>} urls
+  #  * @return {!Promise<!Array<Network.Cookie>>}
+  #  */
+  # async cookies(...urls) {
+  #   return (await this._client.send('Network.getCookies', {
+  #     urls: urls.length ? urls : [this.url()]
+  #   })).cookies;
+  # }
+
+  # /**
+  #  * @param {Array<Protocol.Network.deleteCookiesParameters>} cookies
+  #  */
+  # async deleteCookie(...cookies) {
+  #   const pageURL = this.url();
+  #   for (const cookie of cookies) {
+  #     const item = Object.assign({}, cookie);
+  #     if (!cookie.url && pageURL.startsWith('http'))
+  #       item.url = pageURL;
+  #     await this._client.send('Network.deleteCookies', item);
+  #   }
+  # }
+
+  # /**
+  #  * @param {Array<Network.CookieParam>} cookies
+  #  */
+  # async setCookie(...cookies) {
+  #   const pageURL = this.url();
+  #   const startsWithHTTP = pageURL.startsWith('http');
+  #   const items = cookies.map(cookie => {
+  #     const item = Object.assign({}, cookie);
+  #     if (!item.url && startsWithHTTP)
+  #       item.url = pageURL;
+  #     assert(item.url !== 'about:blank', `Blank page can not have cookie "${item.name}"`);
+  #     assert(!String.prototype.startsWith.call(item.url || '', 'data:'), `Data URL page can not have cookie "${item.name}"`);
+  #     return item;
+  #   });
+  #   await this.deleteCookie(...items);
+  #   if (items.length)
+  #     await this._client.send('Network.setCookies', { cookies: items });
+  # }
+
+  class ScriptTag
+    # @param {!{content?: string, path?: string, type?: string, url?: string}} options
+    def initialize(content: nil, path: nil, type: nil, url: nil)
+      @content = content
+      @path = path
+      @type = type
+      @url = url
+    end
+    attr_reader :content, :path, :type, :url
+  end
+
+  # @param style_tag [Puppeteer::Page::ScriptTag]
+  # @return {!Promise<!ElementHandle>}
+  def add_script_tag(script_tag)
+    main_frame.add_script_tag(script_tag)
+  end
+
+  class StyleTag
+    # @param {!{content?: string, path?: string, url?: string}} options
+    def initialize(content: nil, path: nil, url: nil)
+      @content = content
+      @path = path
+      @url = url
+    end
+    attr_reader :content, :path, :url
+  end
+
+  # @param style_tag [Puppeteer::Page::StyleTag]
+  # @return {!Promise<!ElementHandle>}
+  def add_style_tag(style_tag)
+    main_frame.add_style_tag(style_tag)
+  end
+
+  # /**
+  #  * @param {string} name
+  #  * @param {Function} puppeteerFunction
+  #  */
+  # async exposeFunction(name, puppeteerFunction) {
+  #   if (this._pageBindings.has(name))
+  #     throw new Error(`Failed to add page binding with name ${name}: window['${name}'] already exists!`);
+  #   this._pageBindings.set(name, puppeteerFunction);
+
+  #   const expression = helper.evaluationString(addPageBinding, name);
+  #   await this._client.send('Runtime.addBinding', {name: name});
+  #   await this._client.send('Page.addScriptToEvaluateOnNewDocument', {source: expression});
+  #   await Promise.all(this.frames().map(frame => frame.evaluate(expression).catch(debugError)));
+
+  #   function addPageBinding(bindingName) {
+  #     const binding = window[bindingName];
+  #     window[bindingName] = (...args) => {
+  #       const me = window[bindingName];
+  #       let callbacks = me['callbacks'];
+  #       if (!callbacks) {
+  #         callbacks = new Map();
+  #         me['callbacks'] = callbacks;
+  #       }
+  #       const seq = (me['lastSeq'] || 0) + 1;
+  #       me['lastSeq'] = seq;
+  #       const promise = new Promise((resolve, reject) => callbacks.set(seq, {resolve, reject}));
+  #       binding(JSON.stringify({name: bindingName, seq, args}));
+  #       return promise;
+  #     };
+  #   }
+  # }
+
+  # @param username [String?]
+  # @param password [String?]
+  def authenticate(username: nil, password: nil)
+    @frame_manager.network_manager.authenticate(username: username, password: password)
+  end
+
+  # @param headers [Hash]
+  def extra_http_headers=(headers)
+    @frame_manager.network_manager.extra_http_headers = headers
+  end
+
+  # @param user_agent [String]
+  def user_agent=(user_agent)
+    @frame_manager.network_manager.user_agent = user_agent
+  end
+
+  # /**
+  #  * @return {!Promise<!Metrics>}
+  #  */
+  # async metrics() {
+  #   const response = await this._client.send('Performance.getMetrics');
+  #   return this._buildMetricsObject(response.metrics);
+  # }
+
+  # /**
+  #  * @param {!Protocol.Performance.metricsPayload} event
+  #  */
+  # _emitMetrics(event) {
+  #   this.emit(Events.Page.Metrics, {
+  #     title: event.title,
+  #     metrics: this._buildMetricsObject(event.metrics)
+  #   });
+  # }
+
+  # /**
+  #  * @param {?Array<!Protocol.Performance.Metric>} metrics
+  #  * @return {!Metrics}
+  #  */
+  # _buildMetricsObject(metrics) {
+  #   const result = {};
+  #   for (const metric of metrics || []) {
+  #     if (supportedMetrics.has(metric.name))
+  #       result[metric.name] = metric.value;
+  #   }
+  #   return result;
+  # }
+
+  # /**
+  #  * @param {!Protocol.Runtime.ExceptionDetails} exceptionDetails
+  #  */
+  # _handleException(exceptionDetails) {
+  #   const message = helper.getExceptionMessage(exceptionDetails);
+  #   const err = new Error(message);
+  #   err.stack = ''; // Don't report clientside error with a node stack attached
+  #   this.emit(Events.Page.PageError, err);
+  # }
+
+  # /**
+  #  * @param {!Protocol.Runtime.consoleAPICalledPayload} event
+  #  */
+  # async _onConsoleAPI(event) {
+  #   if (event.executionContextId === 0) {
+  #     // DevTools protocol stores the last 1000 console messages. These
+  #     // messages are always reported even for removed execution contexts. In
+  #     // this case, they are marked with executionContextId = 0 and are
+  #     // reported upon enabling Runtime agent.
+  #     //
+  #     // Ignore these messages since:
+  #     // - there's no execution context we can use to operate with message
+  #     //   arguments
+  #     // - these messages are reported before Puppeteer clients can subscribe
+  #     //   to the 'console'
+  #     //   page event.
+  #     //
+  #     // @see https://github.com/puppeteer/puppeteer/issues/3865
+  #     return;
+  #   }
+  #   const context = this._frameManager.executionContextById(event.executionContextId);
+  #   const values = event.args.map(arg => createJSHandle(context, arg));
+  #   this._addConsoleMessage(event.type, values, event.stackTrace);
+  # }
+
+  # /**
+  #  * @param {!Protocol.Runtime.bindingCalledPayload} event
+  #  */
+  # async _onBindingCalled(event) {
+  #   const {name, seq, args} = JSON.parse(event.payload);
+  #   let expression = null;
+  #   try {
+  #     const result = await this._pageBindings.get(name)(...args);
+  #     expression = helper.evaluationString(deliverResult, name, seq, result);
+  #   } catch (error) {
+  #     if (error instanceof Error)
+  #       expression = helper.evaluationString(deliverError, name, seq, error.message, error.stack);
+  #     else
+  #       expression = helper.evaluationString(deliverErrorValue, name, seq, error);
+  #   }
+  #   this._client.send('Runtime.evaluate', { expression, contextId: event.executionContextId }).catch(debugError);
+
+  #   /**
+  #    * @param {string} name
+  #    * @param {number} seq
+  #    * @param {*} result
+  #    */
+  #   function deliverResult(name, seq, result) {
+  #     window[name]['callbacks'].get(seq).resolve(result);
+  #     window[name]['callbacks'].delete(seq);
+  #   }
+
+  #   /**
+  #    * @param {string} name
+  #    * @param {number} seq
+  #    * @param {string} message
+  #    * @param {string} stack
+  #    */
+  #   function deliverError(name, seq, message, stack) {
+  #     const error = new Error(message);
+  #     error.stack = stack;
+  #     window[name]['callbacks'].get(seq).reject(error);
+  #     window[name]['callbacks'].delete(seq);
+  #   }
+
+  #   /**
+  #    * @param {string} name
+  #    * @param {number} seq
+  #    * @param {*} value
+  #    */
+  #   function deliverErrorValue(name, seq, value) {
+  #     window[name]['callbacks'].get(seq).reject(value);
+  #     window[name]['callbacks'].delete(seq);
+  #   }
+  # }
+
+  # /**
+  #  * @param {string} type
+  #  * @param {!Array<!Puppeteer.JSHandle>} args
+  #  * @param {Protocol.Runtime.StackTrace=} stackTrace
+  #  */
+  # _addConsoleMessage(type, args, stackTrace) {
+  #   if (!this.listenerCount(Events.Page.Console)) {
+  #     args.forEach(arg => arg.dispose());
+  #     return;
+  #   }
+  #   const textTokens = [];
+  #   for (const arg of args) {
+  #     const remoteObject = arg._remoteObject;
+  #     if (remoteObject.objectId)
+  #       textTokens.push(arg.toString());
+  #     else
+  #       textTokens.push(helper.valueFromRemoteObject(remoteObject));
+  #   }
+  #   const location = stackTrace && stackTrace.callFrames.length ? {
+  #     url: stackTrace.callFrames[0].url,
+  #     lineNumber: stackTrace.callFrames[0].lineNumber,
+  #     columnNumber: stackTrace.callFrames[0].columnNumber,
+  #   } : {};
+  #   const message = new ConsoleMessage(type, textTokens.join(' '), args, location);
+  #   this.emit(Events.Page.Console, message);
+  # }
+
+  # _onDialog(event) {
+  #   let dialogType = null;
+  #   if (event.type === 'alert')
+  #     dialogType = Dialog.Type.Alert;
+  #   else if (event.type === 'confirm')
+  #     dialogType = Dialog.Type.Confirm;
+  #   else if (event.type === 'prompt')
+  #     dialogType = Dialog.Type.Prompt;
+  #   else if (event.type === 'beforeunload')
+  #     dialogType = Dialog.Type.BeforeUnload;
+  #   assert(dialogType, 'Unknown javascript dialog type: ' + event.type);
+  #   const dialog = new Dialog(this._client, dialogType, event.message, event.defaultPrompt);
+  #   this.emit(Events.Page.Dialog, dialog);
+  # }
+
+  # @return [String]
+  def url
+    main_frame.url
+  end
+
+  # @return [String]
+  def content
+    main_frame.content
+  end
+
+  # @param {string} html
+  # @param {!{timeout?: number, waitUntil?: string|!Array<string>}=} options
+  def set_content(html, timeout: nil, wait_until: nil)
+    main_frame.set_content(html, timeout: timeout, wait_until: wait_until)
+  end
+
+  # @param {string} html
+  def content=(html)
+    main_frame.set_content(html)
+  end
+
+  # @param url [String]
+  # @param rederer [String]
+  # @param timeout [number|nil]
+  # @param wait_until [string|nil] 'load' | 'domcontentloaded' | 'networkidle0' | 'networkidle2'
+  def goto(url, referer: nil, timeout: nil, wait_until: nil)
+    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>}
+  def reload(timeout: nil, wait_until: nil)
+    # const [response] = await Promise.all([
+    #   this.waitForNavigation(options),
+    #   this._client.send('Page.reload')
+    # ]);
+    # return response;
+  end
+
+  # @param timeout [number|nil]
+  # @param wait_until [string|nil] 'load' | 'domcontentloaded' | 'networkidle0' | 'networkidle2'
+  private def wait_for_navigation(timeout: nil, wait_until: nil)
+    main_frame.wait_for_navigation(timeout: timeout, wait_until: wait_until)
+  end
+
+  # @param timeout [number|nil]
+  # @param wait_until [string|nil] 'load' | 'domcontentloaded' | 'networkidle0' | 'networkidle2'
+  # @return [Future]
+  async def async_wait_for_navigation(timeout: nil, wait_until: nil)
+    wait_for_navigation(timeout: timeout, wait_until: wait_until)
+  end
+
+  # /**
+  #  * @param {(string|Function)} urlOrPredicate
+  #  * @param {!{timeout?: number}=} options
+  #  * @return {!Promise<!Puppeteer.Request>}
+  #  */
+  # async waitForRequest(urlOrPredicate, options = {}) {
+  #   const {
+  #     timeout = this._timeoutSettings.timeout(),
+  #   } = options;
+  #   return helper.waitForEvent(this._frameManager.networkManager(), Events.NetworkManager.Request, request => {
+  #     if (helper.isString(urlOrPredicate))
+  #       return (urlOrPredicate === request.url());
+  #     if (typeof urlOrPredicate === 'function')
+  #       return !!(urlOrPredicate(request));
+  #     return false;
+  #   }, timeout, this._sessionClosePromise());
+  # }
+
+  # /**
+  #  * @param {(string|Function)} urlOrPredicate
+  #  * @param {!{timeout?: number}=} options
+  #  * @return {!Promise<!Puppeteer.Response>}
+  #  */
+  # async waitForResponse(urlOrPredicate, options = {}) {
+  #   const {
+  #     timeout = this._timeoutSettings.timeout(),
+  #   } = options;
+  #   return helper.waitForEvent(this._frameManager.networkManager(), Events.NetworkManager.Response, response => {
+  #     if (helper.isString(urlOrPredicate))
+  #       return (urlOrPredicate === response.url());
+  #     if (typeof urlOrPredicate === 'function')
+  #       return !!(urlOrPredicate(response));
+  #     return false;
+  #   }, timeout, this._sessionClosePromise());
+  # }
+
+  # @param timeout [number|nil]
+  # @param wait_until [string|nil] 'load' | 'domcontentloaded' | 'networkidle0' | 'networkidle2'
+  def go_back(timeout: nil, wait_until: nil)
+    go(-1, timeout: timeout, wait_until: wait_until)
+  end
+
+  # @param timeout [number|nil]
+  # @param wait_until [string|nil] 'load' | 'domcontentloaded' | 'networkidle0' | 'networkidle2'
+  def go_forward(timeout: nil, wait_until: nil)
+    go(+1, timeout: timeout, wait_until: wait_until)
+  end
+
+  private def go(delta, timeout: nil, wait_until: nil)
+    history = @client.send_message('Page.getNavigationHistory')
+    entries = history['entries']
+    index = history['currentIndex'] + delta
+    if_present(entries[index]) do |entry|
+      await_all(
+        async_wait_for_navigation(timeout: timeout, wait_until: wait_until),
+        @client.async_send_message('Page.navigateToHistoryEntry', entryId: entry['id'])
+      )
+    end
+  end
+
+  # @param device [Device]
+  def emulate(device)
+    self.viewport = device.viewport
+    self.user_agent = device.user_agent
+  end
+
+  # @param {boolean} enabled
+  def javascript_enabled=(enabled)
+    return if (@javascript_enabled == enabled)
+    @javascript_enabled = enabled
+    @client.send_message('Emulation.setScriptExecutionDisabled', value: !enabled);
+  end
+
+  # /**
+  #  * @param {boolean} enabled
+  #  */
+  # async setBypassCSP(enabled) {
+  #   await this._client.send('Page.setBypassCSP', { enabled });
+  # }
+
+  # /**
+  #  * @param {?string} type
+  #  */
+  # async emulateMediaType(type) {
+  #   assert(type === 'screen' || type === 'print' || type === null, 'Unsupported media type: ' + type);
+  #   await this._client.send('Emulation.setEmulatedMedia', {media: type || ''});
+  # }
+
+  # /**
+  #  * @param {?Array<MediaFeature>} features
+  #  */
+  # async emulateMediaFeatures(features) {
+  #   if (features === null)
+  #     await this._client.send('Emulation.setEmulatedMedia', {features: null});
+  #   if (Array.isArray(features)) {
+  #     features.every(mediaFeature => {
+  #       const name = mediaFeature.name;
+  #       assert(/^prefers-(?:color-scheme|reduced-motion)$/.test(name), 'Unsupported media feature: ' + name);
+  #       return true;
+  #     });
+  #     await this._client.send('Emulation.setEmulatedMedia', {features: features});
+  #   }
+  # }
+
+  # @param timezone_id [String?]
+  def emulate_timezone(timezone_id)
+    @client.send_message('Emulation.setTimezoneOverride', timezoneId: timezoneId || '')
+  rescue => err
+    if err.message.include?('Invalid timezone')
+      raise ArgumentError.new("Invalid timezone ID: #{timezone_id}")
+    else
+      raise err
+    end
+  end
+
+  # @param viewport [Viewport]
+  def viewport=(viewport)
+    needs_reload = @emulation_manager.emulate_viewport(viewport)
+    @viewport = viewport
+    reload if needs_reload
+  end
+
+  attr_reader :viewport
+
+  # @param {Function|string} pageFunction
+  # @param {!Array<*>} args
+  # @return {!Promise<*>}
+  def evaluate(page_function, *args)
+    main_frame.evaluate(page_function, *args)
+  end
+
+  # /**
+  #  * @param {Function|string} pageFunction
+  #  * @param {!Array<*>} args
+  #  */
+  # async evaluateOnNewDocument(pageFunction, ...args) {
+  #   const source = helper.evaluationString(pageFunction, ...args);
+  #   await this._client.send('Page.addScriptToEvaluateOnNewDocument', { source });
+  # }
+
+  # @param {boolean} enabled
+  def cache_enabled=(enabled)
+    @frame_manager.network_manager.cache_enabled = enabled
+  end
+
+  # @return {!Promise<string>}
+  def title
+    @title
+  end
+
+  # /**
+  #  * @param {!ScreenshotOptions=} options
+  #  * @return {!Promise<!Buffer|!String>}
+  #  */
+  def screenshot(options = {})
+    screenshot_options = ScreenshotOptions.new(options)
+
+    #@screenshot_task_queue.post_task(-> { screenshot_task(screenshot_options.type, screenshot_options) })
+    screenshot_task(screenshot_options.type, screenshot_options)
+  end
+
+  # @param {"png"|"jpeg"} format
+  # @param {!ScreenshotOptions=} options
+  # @return {!Promise<!Buffer|!String>}
+  private def screenshot_task(format, screenshot_options)
+    @client.send_message('Target.activateTarget', targetId: @target.target_id);
+
+    clip = if_present(screenshot_options.clip) do |rect|
+      x = rect[:x].round
+      y = rect[:y].round
+      { x: x, y: y, width: rect[:width] + rect[:x] - x, height: rect[:height] + rect[:y] - y, scale: 1 }
+    end
+
+    if screenshot_options.full_page?
+      metrics = @client.send_message('Page.getLayoutMetrics')
+      width = metrics['contentSize']['width'].ceil
+      height = metrics['contentSize']['height'].ceil
+
+      # Overwrite clip for full page at all times.
+      clip = { x: 0, y: 0, width: width, height: height, scale: 1 }
+
+      screen_orientation =
+        if @viewport.landscape?
+          { angle: 90, type: 'landscapePrimary' }
+        else
+          { angle: 0, type: 'portraitPrimary' }
+        end
+      @client.send_message('Emulation.setDeviceMetricsOverride',
+        mobile: @viewport.mobile?,
+        width: width,
+        height: height,
+        deviceScaleFactor: @viewport.device_scale_factor,
+        screenOrientation: screen_orientation)
+    end
+
+    should_set_default_background = screenshot_options.omit_background? && format == 'png'
+    if should_set_default_background
+      @client.send_message('Emulation.setDefaultBackgroundColorOverride', color: { r: 0, g: 0, b: 0, a: 0 })
+    end
+    screenshot_params = {
+      format: format,
+      quality: screenshot_options.quality,
+      clip: clip,
+    }.compact
+    result = @client.send_message('Page.captureScreenshot', screenshot_params)
+    if should_set_default_background
+      @client.send_message('Emulation.setDefaultBackgroundColorOverride')
+    end
+
+    if screenshot_options.full_page? && @viewport
+      self.viewport = @viewport
+    end
+
+    buffer =
+      if screenshot_options.encoding == 'base64'
+        result['data']
+      else
+        Base64.decode64(result['data'])
+      end
+
+    if screenshot_options.path
+      File.binwrite(screenshot_options.path, buffer)
+    end
+
+    buffer
+  end
+
+  # /**
+  #  * @param {!PDFOptions=} options
+  #  * @return {!Promise<!Buffer>}
+  #  */
+  # async pdf(options = {}) {
+  #   const {
+  #     scale = 1,
+  #     displayHeaderFooter = false,
+  #     headerTemplate = '',
+  #     footerTemplate = '',
+  #     printBackground = false,
+  #     landscape = false,
+  #     pageRanges = '',
+  #     preferCSSPageSize = false,
+  #     margin = {},
+  #     path = null
+  #   } = options;
+
+  #   let paperWidth = 8.5;
+  #   let paperHeight = 11;
+  #   if (options.format) {
+  #     const format = Page.PaperFormats[options.format.toLowerCase()];
+  #     assert(format, 'Unknown paper format: ' + options.format);
+  #     paperWidth = format.width;
+  #     paperHeight = format.height;
+  #   } else {
+  #     paperWidth = convertPrintParameterToInches(options.width) || paperWidth;
+  #     paperHeight = convertPrintParameterToInches(options.height) || paperHeight;
+  #   }
+
+  #   const marginTop = convertPrintParameterToInches(margin.top) || 0;
+  #   const marginLeft = convertPrintParameterToInches(margin.left) || 0;
+  #   const marginBottom = convertPrintParameterToInches(margin.bottom) || 0;
+  #   const marginRight = convertPrintParameterToInches(margin.right) || 0;
+
+  #   const result = await this._client.send('Page.printToPDF', {
+  #     transferMode: 'ReturnAsStream',
+  #     landscape,
+  #     displayHeaderFooter,
+  #     headerTemplate,
+  #     footerTemplate,
+  #     printBackground,
+  #     scale,
+  #     paperWidth,
+  #     paperHeight,
+  #     marginTop,
+  #     marginBottom,
+  #     marginLeft,
+  #     marginRight,
+  #     pageRanges,
+  #     preferCSSPageSize
+  #   });
+  #   return await helper.readProtocolStream(this._client, result.stream, path);
+  # }
+
+  # @param {!{runBeforeUnload: (boolean|undefined)}=} options
+  def close
+    # assert(!!this._client._connection, 'Protocol error: Connection closed. Most likely the page has been closed.');
+    # const runBeforeUnload = !!options.runBeforeUnload;
+    # if (runBeforeUnload) {
+    #   await this._client.send('Page.close');
+    # } else {
+    #   await this._client._connection.send('Target.closeTarget', { targetId: this._target._targetId });
+    #   await this._target._isClosedPromise;
+    # }
+  end
+
+  # @return [boolean]
+  def closed?
+    @closed
+  end
+
+  attr_reader :mouse
+
+  # @param {string} selector
+  # @param {!{delay?: number, button?: "left"|"right"|"middle", clickCount?: number}=} options
+  def click(selector, delay: nil, button: nil, click_count: nil)
+    main_frame.click(selector, delay: delay, button: button, click_count: click_count)
+  end
+
+  # @param {string} selector
+  def focus(selector)
+    main_frame.focus(selector)
+  end
+
+  # @param {string} selector
+  def hover(selector)
+    main_frame.hover(selector)
+  end
+
+  # @param {string} selector
+  # @param {!Array<string>} values
+  # @return {!Promise<!Array<string>>}
+  def select(selector, *values)
+    main_frame.select(selector, *values)
+  end
+
+  # @param {string} selector
+  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)
+  end
+
+  # /**
+  #  * @param {(string|number|Function)} selectorOrFunctionOrTimeout
+  #  * @param {!{visible?: boolean, hidden?: boolean, timeout?: number, polling?: string|number}=} options
+  #  * @param {!Array<*>} args
+  #  * @return {!Promise<!Puppeteer.JSHandle>}
+  #  */
+  # waitFor(selectorOrFunctionOrTimeout, options = {}, ...args) {
+  #   return this.mainFrame().waitFor(selectorOrFunctionOrTimeout, options, ...args);
+  # }
+
+  # @param {string} selector
+  # @param {!{visible?: boolean, hidden?: boolean, timeout?: number}=} options
+  # @return {!Promise<?Puppeteer.ElementHandle>}
+  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>}
+  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 {Function|string} pageFunction
+  # @param {!{polling?: string|number, timeout?: number}=} options
+  # @param {!Array<*>} args
+  # @return {!Promise<!Puppeteer.JSHandle>}
+  def wait_for_function(page_function, options = {}, *args)
+    main_frame.wait_for_function(page_function, options, *args)
+  end
+end