puppeteer-ruby 0.45.6 → 0.50.0.alpha5

data/lib/puppeteer/http_response.rb

@@ -1,9 +1,12 @@
+# rbs_inline: enabled
+
+require 'base64'
 require 'json'
 
 class Puppeteer::HTTPResponse
   include Puppeteer::IfPresent
 
-  class Redirected < StandardError
+  class Redirected < Puppeteer::Error
     def initialize
       super('Response body is unavailable for redirect responses')
     end
@@ -36,13 +39,13 @@ class Puppeteer::HTTPResponse
     @client = client
     @request = request
 
-    @body_loaded_promise = resolvable_future
+    @body_loaded_promise = Async::Promise.new
     @remote_address = RemoteAddress.new(
       ip: response_payload['remoteIPAddress'],
       port: response_payload['remotePort'],
     )
 
-    @status_text = parse_štatus_text_from_extra_info(extra_info) || response_payload['statusText']
+    @status_text = parse_status_text_from_extra_info(extra_info) || response_payload['statusText']
     @url = request.url
     @from_disk_cache = !!response_payload['fromDiskCache']
     @from_service_worker = !!response_payload['fromServiceWorker']
@@ -56,13 +59,14 @@ class Puppeteer::HTTPResponse
     @security_details = if_present(response_payload['securityDetails']) do |security_payload|
       SecurityDetails.new(security_payload)
     end
+    @timing = response_payload['timing']
 
     @internal = InternalAccessor.new(self)
   end
 
   attr_reader :internal
 
-  attr_reader :remote_address, :url, :status, :status_text, :headers, :security_details, :request
+  attr_reader :remote_address, :url, :status, :status_text, :headers, :security_details, :request, :timing
 
   def inspect
     values = %i[remote_address url status status_text headers security_details request].map do |sym|
@@ -72,7 +76,7 @@ class Puppeteer::HTTPResponse
     "#<Puppeteer::HTTPRequest #{values.join(' ')}>"
   end
 
-  private def parse_štatus_text_from_extra_info(extra_info)
+  private def parse_status_text_from_extra_info(extra_info)
     return nil if !extra_info || !extra_info['headersText']
     first_line = extra_info['headersText'].split("\r").first
     return nil unless first_line
@@ -88,34 +92,47 @@ class Puppeteer::HTTPResponse
     @status == 0 || (@status >= 200 && @status <= 299)
   end
 
+  # @rbs return: String -- Response body as binary string
   def buffer
-    await @body_loaded_promise
-    response = @client.send_message('Network.getResponseBody', requestId: @request.internal.request_id)
+    @body_loaded_promise.wait
+    response = @request.client.send_message('Network.getResponseBody', requestId: @request.internal.request_id)
     if response['base64Encoded']
       Base64.decode64(response['body'])
     else
       response['body']
     end
+  rescue Puppeteer::Connection::ProtocolError => err
+    if err.message.include?('No resource with given identifier found')
+      raise Puppeteer::Error.new(
+        'Could not load response body for this request. This might happen if the request is a preflight request.',
+      )
+    end
+    raise
   end
 
   # @param text [String]
+  # @rbs return: String -- Response body as text
   def text
     buffer
   end
 
   # @param json [Hash]
+  # @rbs return: Hash[untyped, untyped] -- Parsed JSON
   def json
     JSON.parse(text)
   end
 
+  # @rbs return: bool -- Whether response was served from cache
   def from_cache?
     @from_disk_cache || @request.internal.from_memory_cache?
   end
 
+  # @rbs return: bool -- Whether response was served from service worker
   def from_service_worker?
     @from_service_worker
   end
 
+  # @rbs return: Puppeteer::Frame -- Frame associated with the request
   def frame
     @request.frame
   end

data/lib/puppeteer/isolated_world.rb

@@ -56,11 +56,12 @@ class Puppeteer::IsolaatedWorld
     @frame_manager = frame_manager
     @frame = frame
     @timeout_settings = timeout_settings
-    @context_promise = resolvable_future
+    @context_promise = Async::Promise.new
     @task_manager = Puppeteer::TaskManager.new
     @bound_functions = {}
     @ctx_bindings = Set.new
     @detached = false
+    @context = nil
 
     @client.on_event('Runtime.bindingCalled', &method(:handle_binding_called))
   end
@@ -76,8 +77,9 @@ class Puppeteer::IsolaatedWorld
   def context=(context)
     if context
       @ctx_bindings.clear
+      @context = context
       unless @context_promise.resolved?
-        @context_promise.fulfill(context)
+        @context_promise.resolve(context)
       end
       @task_manager.async_rerun_all
     else
@@ -85,9 +87,17 @@ class Puppeteer::IsolaatedWorld
     end
   end
 
-  def delete_context(execution_context_id)
+  def delete_context(context_or_id)
     @document = nil
-    @context_promise = resolvable_future
+    if context_or_id
+      if context_or_id.is_a?(Puppeteer::ExecutionContext)
+        return unless @context.equal?(context_or_id)
+      elsif @context && @context.respond_to?(:_context_id, true)
+        return unless @context.send(:_context_id).to_s == context_or_id.to_s
+      end
+    end
+    @context = nil
+    @context_promise = Async::Promise.new
   end
 
   def has_context?
@@ -99,14 +109,20 @@ class Puppeteer::IsolaatedWorld
     @task_manager.terminate_all(Puppeteer::WaitTask::TerminatedError.new('waitForFunction failed: frame got detached.'))
   end
 
-  class DetachedError < StandardError; end
+  def detached?
+    @detached
+  end
+
+  class DetachedError < Puppeteer::Error; end
 
   # @return {!Promise<!Puppeteer.ExecutionContext>}
   def execution_context
     if @detached
       raise DetachedError.new("Execution Context is not available in detached frame \"#{@frame.url}\" (are you trying to evaluate?)")
     end
-    @context_promise.value!
+    return @context if @context
+
+    @context = @context_promise.wait
   end
 
   # @param {Function|string} pageFunction
@@ -135,13 +151,13 @@ class Puppeteer::IsolaatedWorld
     # sometimes execution_context.evaluate_handle('document') returns null object.
     # D, [2020-04-24T02:17:51.023631 #220] DEBUG -- : RECV << {"id"=>20, "result"=>{"result"=>{"type"=>"object", "subtype"=>"null", "value"=>nil}}, "sessionId"=>"78E9CF1E14D81294E320E7C20E5CDE06"}
     # retry if so.
-    Timeout.timeout(3) do
+    Puppeteer::AsyncUtils.async_timeout(3000, -> do
       loop do
         handle = execution_context.evaluate_handle('document')
         return handle if handle.is_a?(Puppeteer::ElementHandle)
       end
-    end
-  rescue Timeout::Error
+    end).wait
+  rescue Async::TimeoutError
     raise 'Bug of puppeteer-ruby...'
   end
 
@@ -179,8 +195,8 @@ class Puppeteer::IsolaatedWorld
   # `$$()` in JavaScript.
   # @param {string} selector
   # @return {!Promise<!Array<!Puppeteer.ElementHandle>>}
-  def query_selector_all(selector)
-    document.query_selector_all(selector)
+  def query_selector_all(selector, isolate: nil)
+    document.query_selector_all(selector, isolate: isolate)
   end
   alias_method :SS, :query_selector_all
 
@@ -188,12 +204,18 @@ class Puppeteer::IsolaatedWorld
   def content
     evaluate(<<-JAVASCRIPT)
     () => {
-      let retVal = '';
-      if (document.doctype)
-        retVal = new XMLSerializer().serializeToString(document.doctype);
-      if (document.documentElement)
-        retVal += document.documentElement.outerHTML;
-      return retVal;
+      let content = '';
+      for (const node of document.childNodes) {
+        switch (node) {
+          case document.documentElement:
+            content += document.documentElement.outerHTML;
+            break;
+          default:
+            content += new XMLSerializer().serializeToString(node);
+            break;
+        }
+      }
+      return content;
     }
     JAVASCRIPT
   end
@@ -218,7 +240,7 @@ class Puppeteer::IsolaatedWorld
 
     watcher = Puppeteer::LifecycleWatcher.new(@frame_manager, @frame, option_wait_until, option_timeout)
     begin
-      await_any(
+      Puppeteer::AsyncUtils.await_promise_race(
         watcher.timeout_or_termination_promise,
         watcher.lifecycle_promise,
       )
@@ -238,9 +260,7 @@ class Puppeteer::IsolaatedWorld
         return execution_context.
           evaluate_handle(ADD_SCRIPT_URL, url, id, type || '').
           as_element
-      rescue Puppeteer::ExecutionContext::EvaluationError # for Chrome
-        raise "Loading script from #{url} failed"
-      rescue Puppeteer::Connection::ProtocolError # for Firefox
+      rescue Puppeteer::ExecutionContext::EvaluationError, Puppeteer::Connection::ProtocolError
         raise "Loading script from #{url} failed"
       end
     end
@@ -300,9 +320,7 @@ class Puppeteer::IsolaatedWorld
     if url
       begin
         return execution_context.evaluate_handle(ADD_STYLE_URL, url).as_element
-      rescue Puppeteer::ExecutionContext::EvaluationError # for Chrome
-        raise "Loading style from #{url} failed"
-      rescue Puppeteer::Connection::ProtocolError # for Firefox
+      rescue Puppeteer::ExecutionContext::EvaluationError, Puppeteer::Connection::ProtocolError
         raise "Loading style from #{url} failed"
       end
     end
@@ -350,7 +368,7 @@ class Puppeteer::IsolaatedWorld
     }
   JAVASCRIPT
 
-  class ElementNotFoundError < StandardError
+  class ElementNotFoundError < Puppeteer::Error
     def initialize(selector)
       super("No node found for selector: #{selector}")
     end
@@ -359,10 +377,11 @@ class Puppeteer::IsolaatedWorld
   # @param selector [String]
   # @param delay [Number]
   # @param button [String] "left"|"right"|"middle"
-  # @param click_count [Number]
-  def click(selector, delay: nil, button: nil, click_count: nil)
+  # @param click_count [Number] Deprecated: use count (click_count only sets clickCount)
+  # @param count [Number]
+  def click(selector, delay: nil, button: nil, click_count: nil, count: nil)
     handle = query_selector(selector) or raise ElementNotFoundError.new(selector)
-    handle.click(delay: delay, button: button, click_count: click_count)
+    handle.click(delay: delay, button: button, click_count: click_count, count: count)
     handle.dispose
   end
 
@@ -382,6 +401,11 @@ class Puppeteer::IsolaatedWorld
   #   await handle.hover();
   #   await handle.dispose();
   # }
+  def hover(selector)
+    handle = query_selector(selector) or raise ElementNotFoundError.new(selector)
+    handle.hover
+    handle.dispose
+  end
 
   # @param selector [String]
   # @return [Array<String>]
@@ -480,26 +504,25 @@ class Puppeteer::IsolaatedWorld
   # @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]
-  private def wait_for_selector_in_page(query_one, root, selector, visible: nil, hidden: nil, timeout: nil, binding_function: nil)
+  private def wait_for_selector_in_page(query_one, root, selector, visible: nil, hidden: nil, timeout: nil, polling: nil, binding_function: nil)
     option_wait_for_visible = visible || false
     option_wait_for_hidden = hidden || false
-    option_timeout = timeout || @timeout_settings.timeout
+    option_timeout = timeout.nil? ? @timeout_settings.timeout : timeout
     option_root = root
 
-    polling =
-      if option_wait_for_visible || option_wait_for_hidden
-        'raf'
-      else
-        'mutation'
-      end
+    option_polling = polling || 'mutation'
+    if option_wait_for_visible || option_wait_for_hidden
+      option_polling = 'raf'
+    end
     title = "selector #{selector}#{option_wait_for_hidden ? 'to be hidden' : ''}"
 
     selector_predicate = make_predicate_string(
       predicate_arg_def: '(root, selector, waitForVisible, waitForHidden)',
       predicate_query_handler: query_one,
       async: true,
-      predicate_body: <<~JAVASCRIPT
-        const node = await predicateQueryHandler(root, selector)
+      predicate_body: <<~JAVASCRIPT,
+        const resolvedRoot = root || document;
+        const node = await predicateQueryHandler(resolvedRoot, selector)
         return checkWaitForOptions(node, waitForVisible, waitForHidden);
       JAVASCRIPT
     )
@@ -508,10 +531,10 @@ class Puppeteer::IsolaatedWorld
       dom_world: self,
       predicate_body: selector_predicate,
       title: title,
-      polling: polling,
+      polling: option_polling,
       timeout: option_timeout,
-      args: [selector, option_wait_for_visible, option_wait_for_hidden],
       root: option_root,
+      args: [option_root, selector, option_wait_for_visible, option_wait_for_hidden],
       binding_function: binding_function,
     )
     wait_task.await_promise
@@ -524,7 +547,7 @@ class Puppeteer::IsolaatedWorld
   # @return [Puppeteer::JSHandle]
   def wait_for_function(page_function, args: [], polling: nil, timeout: nil)
     option_polling = polling || 'raf'
-    option_timeout = timeout || @timeout_settings.timeout
+    option_timeout = timeout.nil? ? @timeout_settings.timeout : timeout
 
     Puppeteer::WaitTask.new(
       dom_world: self,

data/lib/puppeteer/js_coverage.rb

@@ -54,12 +54,14 @@ class Puppeteer::JSCoverage
     @script_sources.clear
     @event_listeners = []
     @event_listeners << @client.add_event_listener('Debugger.scriptParsed') do |event|
-      future { on_script_parsed(event) }
+      Async do
+        Puppeteer::AsyncUtils.future_with_logging { on_script_parsed(event) }.call
+      end
     end
     @event_listeners << @client.add_event_listener('Runtime.executionContextsCleared') do
       on_execution_contexts_cleared
     end
-    await_all(
+    Puppeteer::AsyncUtils.await_promise_all(
       @client.async_send_message('Profiler.enable'),
       @client.async_send_message('Profiler.startPreciseCoverage',
         callCount: @include_raw_script_coverage,
@@ -99,7 +101,7 @@ class Puppeteer::JSCoverage
     raise 'JSCoverage is not enabled' unless @enabled
     @enabled = false
 
-    results = await_all(
+    results = Puppeteer::AsyncUtils.await_promise_all(
       @client.async_send_message('Profiler.takePreciseCoverage'),
       @client.async_send_message('Profiler.stopPreciseCoverage'),
       @client.async_send_message('Profiler.disable'),

data/lib/puppeteer/js_handle.rb

@@ -1,3 +1,7 @@
+# rbs_inline: enabled
+
+require 'time'
+
 class Puppeteer::JSHandle
   using Puppeteer::DefineAsyncMethod
   include Puppeteer::IfPresent
@@ -29,6 +33,7 @@ class Puppeteer::JSHandle
     @client = client
     @remote_object = remote_object
     @disposed = false
+    @moved = false
   end
 
   attr_reader :context, :remote_object
@@ -92,7 +97,7 @@ class Puppeteer::JSHandle
   def properties
     response = @remote_object.properties(@client)
     response['result'].each_with_object({}) do |prop, h|
-      next unless prop['enumerable']
+      next unless prop['enumerable'] && prop['value']
       h[prop['name']] = Puppeteer::JSHandle.create(
         context: @context,
         remote_object: Puppeteer::RemoteObject.new(prop['value']),
@@ -101,21 +106,29 @@ class Puppeteer::JSHandle
   end
 
   def json_value
-    # original logic was:
-    #   if (this._remoteObject.objectId) {
-    #     const response = await this._client.send('Runtime.callFunctionOn', {
-    #       functionDeclaration: 'function() { return this; }',
-    #       objectId: this._remoteObject.objectId,
-    #       returnByValue: true,
-    #       awaitPromise: true,
-    #     });
-    #     return helper.valueFromRemoteObject(response.result);
+    # Node.js Puppeteer:
+    #   if (!this.#remoteObject.objectId) {
+    #     return valueFromRemoteObject(this.#remoteObject);
     #   }
-    #   return helper.valueFromRemoteObject(this._remoteObject);
-    #
-    # However it would be better that RemoteObject is responsible for
-    # the logic `if (this._remoteObject.objectId) { ... }`.
-    @remote_object.evaluate_self(@client)&.value || @remote_object.value
+    #   const value = await this.evaluate(object => object);
+    #   if (value === undefined) {
+    #     throw new Error('Could not serialize referenced object');
+    #   }
+    #   return value;
+    if !@remote_object.object_id?
+      return @remote_object.value
+    end
+
+    if @remote_object.sub_type == 'date'
+      iso_value = evaluate('(object) => object.toISOString()')
+      return Time.iso8601(iso_value) if iso_value
+    end
+
+    value = evaluate('(object) => object')
+    if value.nil?
+      raise Puppeteer::Error.new('Could not serialize referenced object')
+    end
+    value
   end
 
   def as_element
@@ -133,6 +146,24 @@ class Puppeteer::JSHandle
     @disposed
   end
 
+  # @rbs return: void
+  def dispose_symbol
+    if @moved
+      @moved = false
+      return
+    end
+
+    dispose
+  end
+
+  define_async_method :async_dispose_symbol
+
+  # @rbs return: self
+  def move
+    @moved = true
+    self
+  end
+
   def to_s
     # original logic was:
     #   if (this._remoteObject.objectId) {
@@ -143,6 +174,17 @@ class Puppeteer::JSHandle
     #
     # However it would be better that RemoteObject is responsible for
     # the logic `if (this._remoteObject.objectId) { ... }`.
-    if_present(@remote_object.type_str) { |type_str| "JSHandle@#{type_str}" } || "JSHandle:#{@remote_object.value || 'undefined'}"
+    if_present(@remote_object.type_str) { |type_str| "JSHandle@#{type_str}" } || "JSHandle:#{stringify_remote_value}"
+  end
+
+  # @rbs return: String
+  private def stringify_remote_value
+    value = @remote_object.value
+    return value unless value.nil?
+
+    return 'undefined' if @remote_object.type == 'undefined'
+    return 'null' if @remote_object.sub_type == 'null'
+
+    'undefined'
   end
 end

data/lib/puppeteer/keyboard.rb

@@ -1,10 +1,13 @@
+# rbs_inline: enabled
+
 require_relative './keyboard/key_description'
 require_relative './keyboard/us_keyboard_layout'
 
 class Puppeteer::Keyboard
   using Puppeteer::DefineAsyncMethod
 
-  # @param {!Puppeteer.CDPSession} client
+  # @rbs client: Puppeteer::CDPSession -- CDP session
+  # @rbs return: void -- No return value
   def initialize(client)
     @client = client
     @modifiers = 0
@@ -13,8 +16,10 @@ class Puppeteer::Keyboard
 
   attr_reader :modifiers
 
-  # @param key [String]
-  # @param text [String]
+  # @rbs key: String -- Key name
+  # @rbs text: String? -- Text to input
+  # @rbs commands: Array[String]? -- Editing commands
+  # @rbs return: void -- No return value
   def down(key, text: nil, commands: nil)
     description = key_description_for_string(key)
 
@@ -41,8 +46,6 @@ class Puppeteer::Keyboard
 
   define_async_method :async_down
 
-  # @param {string} key
-  # @return {number}
   private def modifier_bit(key)
     case key
     when 'Alt'
@@ -58,8 +61,6 @@ class Puppeteer::Keyboard
     end
   end
 
-  # @param {string} keyString
-  # @return {KeyDescription}
   private def key_description_for_string(key_string)
     shift = (@modifiers & 8) != 0
     description = {}
@@ -106,7 +107,8 @@ class Puppeteer::Keyboard
     KeyDescription.new(**description)
   end
 
-  # @param key [String]
+  # @rbs key: String -- Key name
+  # @rbs return: void -- No return value
   def up(key)
     description = key_description_for_string(key)
 
@@ -125,22 +127,24 @@ class Puppeteer::Keyboard
 
   define_async_method :async_up
 
-  # @param char [string]
+  # @rbs char: String -- Character to insert
+  # @rbs return: void -- No return value
   def send_character(char)
     @client.send_message('Input.insertText', text: char)
   end
 
   define_async_method :async_send_character
 
-  # @param text [String]
-  # @return [Future]
+  # @rbs text: String -- Text to type
+  # @rbs delay: Numeric? -- Delay between key presses (ms)
+  # @rbs return: void -- No return value
   def type_text(text, delay: nil)
     text.each_char do |char|
       if KEY_DEFINITIONS.include?(char.to_sym)
         press(char, delay: delay)
       else
         if delay
-          sleep(delay.to_i / 1000.0)
+          Puppeteer::AsyncUtils.sleep_seconds(delay.to_i / 1000.0)
         end
         send_character(char)
       end
@@ -149,13 +153,22 @@ class Puppeteer::Keyboard
 
   define_async_method :async_type_text
 
-  # @param key [String]
-  # @param text [String]
-  # @return [Future]
-  def press(key, delay: nil, text: nil, commands: nil)
+  # @rbs key: String -- Key name
+  # @rbs delay: Numeric? -- Delay between key events (ms)
+  # @rbs text: String? -- Text to input
+  # @rbs commands: Array[String]? -- Editing commands
+  # @rbs block: Proc? -- Optional block for key combo usage
+  # @rbs return: void -- No return value
+  def press(key, delay: nil, text: nil, commands: nil, &block)
     down(key, text: text, commands: commands)
     if delay
-      sleep(delay.to_i / 1000.0)
+      Puppeteer::AsyncUtils.sleep_seconds(delay.to_i / 1000.0)
+    end
+    if block
+      block.call
+      if delay
+        Puppeteer::AsyncUtils.sleep_seconds(delay.to_i / 1000.0)
+      end
     end
     up(key)
   end

data/lib/puppeteer/launcher/browser_options.rb

@@ -31,6 +31,8 @@ module Puppeteer::Launcher
       # `default_viewport: nil` must be respected here.
       @default_viewport = options.key?(:default_viewport) ? options[:default_viewport] : Puppeteer::Viewport.new(width: 800, height: 600)
       @slow_mo = options[:slow_mo] || 0
+      @network_enabled = options.fetch(:network_enabled, true)
+      @protocol_timeout = options[:protocol_timeout]
 
       # only for Puppeteer.connect
       @target_filter = options[:target_filter]
@@ -44,7 +46,7 @@ module Puppeteer::Launcher
       end
     end
 
-    attr_reader :default_viewport, :slow_mo, :target_filter, :is_page_target
+    attr_reader :default_viewport, :slow_mo, :target_filter, :is_page_target, :network_enabled, :protocol_timeout
 
     def ignore_https_errors?
       @ignore_https_errors

data/lib/puppeteer/launcher/chrome.rb

@@ -56,7 +56,6 @@ module Puppeteer::Launcher
         end
       use_pipe = chrome_arguments.include?('--remote-debugging-pipe')
       runner = Puppeteer::BrowserRunner.new(
-        false,
         chrome_executable,
         chrome_arguments,
         user_data_dir,
@@ -78,6 +77,7 @@ module Puppeteer::Launcher
             timeout: @launch_options.timeout,
             slow_mo: @browser_options.slow_mo,
             preferred_revision: @preferred_revision,
+            protocol_timeout: @browser_options.protocol_timeout,
           )
 
           Puppeteer::Browser.create(
@@ -86,6 +86,7 @@ module Puppeteer::Launcher
             context_ids: [],
             ignore_https_errors: @browser_options.ignore_https_errors?,
             default_viewport: @browser_options.default_viewport,
+            network_enabled: @browser_options.network_enabled,
             process: runner.proc,
             close_callback: -> { runner.close },
             target_filter_callback: nil,
@@ -97,10 +98,12 @@ module Puppeteer::Launcher
         end
 
       begin
-        browser.wait_for_target(
-          predicate: ->(target) { target.type == 'page' },
-          timeout: @launch_options.timeout,
-        )
+        if @launch_options.wait_for_initial_page?
+          browser.wait_for_target(
+            predicate: ->(target) { target.type == 'page' },
+            timeout: @launch_options.timeout,
+          )
+        end
       rescue
         browser.close
         raise

data/lib/puppeteer/launcher/launch_options.rb

@@ -31,6 +31,7 @@ module Puppeteer::Launcher
     # @property {boolean=} dumpio
     # @property {!Object<string, string | undefined>=} env
     # @property {boolean=} pipe
+    # @property {boolean=} wait_for_initial_page
     def initialize(options)
       @channel = options[:channel]
       @executable_path = options[:executable_path]
@@ -42,10 +43,10 @@ module Puppeteer::Launcher
       @dumpio = options[:dumpio] || false
       @env = options[:env] || ENV
       @pipe = options[:pipe] || false
-      @extra_prefs_firefox = options[:extra_prefs_firefox] || {}
+      @wait_for_initial_page = options.fetch(:wait_for_initial_page, true)
     end
 
-    attr_reader :channel, :executable_path, :ignore_default_args, :timeout, :env, :extra_prefs_firefox
+    attr_reader :channel, :executable_path, :ignore_default_args, :timeout, :env
 
     def handle_SIGINT?
       @handle_SIGINT
@@ -66,5 +67,9 @@ module Puppeteer::Launcher
     def pipe?
       @pipe
     end
+
+    def wait_for_initial_page?
+      @wait_for_initial_page
+    end
   end
 end