puppeteer-ruby 0.43.1 → 0.44.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e723d5efd8074f8c70f1b94de1399f35ec39eca88fd86d1991b036db32d783a8
-  data.tar.gz: 463781ad3737b5db0f09b2ba9ec2ed8f62863991c011291437230c512671e0ba
+  metadata.gz: 6ade25ba8f8e99240ed29fdad9300af7b65cc12ddf09e45c43f7b672c6324ed4
+  data.tar.gz: 97d3bfc48b3a2e3729dd8857c2bb6deca7babd4d0b055195f2dbe7c01c941e97
 SHA512:
-  metadata.gz: 46462c2894970d02792d5021088252fce262f41f81531449a73d9d40745ede1742fe187cde65cae64222ba817366500d347ca310aa658147040e4fbfa5d1b5db
-  data.tar.gz: d5b6e7ae1e0efc6c1e69e7bb136f90dfdc1c2370c29ec4bf9a6877c22bbe38cd6a81f698f086dce3157800bdfc7bfcb06f7eb35b518434870fd95456dc1fbe3c
+  metadata.gz: 891d8c29ac63d25cdb34178024d7a9202675d77b121a903e24a51e9465e46a9b7a0a9b70a2d893d9b274724b5547d5bb90e133aa2c217052f3f523f952e1a0a3
+  data.tar.gz: eea1fb6ff2f179208932a3bb84ca96841b1b08ff588d914e88ace6ad9e31f71c567c21321e3376b019a265122e51a4352b3f0039dd6bea770dba2a383efe82e5

data/CHANGELOG.md

@@ -1,7 +1,13 @@
-### main [[diff](https://github.com/YusukeIwaki/puppeteer-ruby/compare/0.43.1...main)]
+### main [[diff](https://github.com/YusukeIwaki/puppeteer-ruby/compare/0.44.0...main)]
 
 - xxx
 
+### 0.44.0 [[diff](https://github.com/YusukeIwaki/puppeteer-ruby/compare/0.43.1...0.44.0)]
+
+- Port Puppeteer v17.0-v17.1 features.
+  - `wait_for_selector` no longer accept `root` parameter.
+
+
 ### 0.43.1 [[diff](https://github.com/YusukeIwaki/puppeteer-ruby/compare/0.43.0...0.43.1)]
 
 - Port Puppeteer v16.1 features, including bugfix and XPath query handler.

data/docs/api_coverage.md

@@ -1,6 +1,6 @@
 # API coverages
-- Puppeteer version: v16.2.0
-- puppeteer-ruby version: 0.43.1
+- Puppeteer version: v17.1.3
+- puppeteer-ruby version: 0.44.0
 
 ## Puppeteer
 
@@ -150,13 +150,6 @@
 * ~~removeAllListeners~~
 * ~~removeListener~~
 
-## ExecutionContext
-
-* evaluate
-* evaluateHandle => `#evaluate_handle`
-* frame
-* ~~queryObjects~~
-
 ## FileChooser
 
 * accept
@@ -172,12 +165,12 @@
 * $x => `#Sx`
 * addScriptTag => `#add_script_tag`
 * addStyleTag => `#add_style_tag`
+* addStyleTag => `#add_style_tag`
 * childFrames => `#child_frames`
 * click
 * content
 * evaluate
 * evaluateHandle => `#evaluate_handle`
-* executionContext => `#execution_context`
 * focus
 * goto
 * hover
@@ -251,7 +244,6 @@
 * dispose
 * evaluate
 * evaluateHandle => `#evaluate_handle`
-* executionContext => `#execution_context`
 * getProperties => `#properties`
 * getProperty => `#[]`
 * getProperty => `#[]`
@@ -289,6 +281,7 @@
 * $x => `#Sx`
 * addScriptTag => `#add_script_tag`
 * addStyleTag => `#add_style_tag`
+* addStyleTag => `#add_style_tag`
 * authenticate
 * bringToFront => `#bring_to_front`
 * browser
@@ -313,6 +306,7 @@
 * exposeFunction => `#expose_function`
 * focus
 * frames
+* ~~getDefaultTimeout~~
 * goBack => `#go_back`
 * goForward => `#go_forward`
 * goto
@@ -401,5 +395,4 @@
 
 * ~~evaluate~~
 * ~~evaluateHandle~~
-* ~~executionContext~~
 * ~~url~~

data/lib/puppeteer/aria_query_handler.rb

@@ -25,43 +25,83 @@ class Puppeteer::AriaQueryHandler
     query_options
   end
 
-  def query_one(element, selector)
-    context = element.execution_context
+  # @param element [Puppeteer::ElementHandle]
+  # @param selector [String]
+  private def query_one_id(element, selector)
     parse_result = parse_aria_selector(selector)
     res = element.query_ax_tree(accessible_name: parse_result[:name], role: parse_result[:role])
-    if res.empty?
+
+    if res.first.is_a?(Hash)
+      res.first['backendDOMNodeId']
+    else
       nil
+    end
+  end
+
+  def query_one(element, selector)
+    id = query_one_id(element, selector)
+
+    if id
+      element.frame.main_world.adopt_backend_node(id)
     else
-      context.adopt_backend_node_id(res.first['backendDOMNodeId'])
+      nil
     end
   end
 
-  def wait_for(dom_world, selector, visible: nil, hidden: nil, timeout: nil, root: nil)
+  def wait_for(element_or_frame, selector, visible: nil, hidden: nil, timeout: nil)
+    case element_or_frame
+    when Puppeteer::Frame
+      frame = element_or_frame
+      element = nil
+    when Puppeteer::ElementHandle
+      frame = element_or_frame.frame
+      element = frame.puppeteer_world.adopt_handle(element_or_frame)
+    else
+      raise ArgumentError.new("element_or_frame must be a Frame or ElementHandle. #{element_or_frame.inspect}")
+    end
+
     # addHandlerToWorld
-    binding_function = Puppeteer::DOMWorld::BindingFunction.new(
+    binding_function = Puppeteer::IsolaatedWorld::BindingFunction.new(
       name: 'ariaQuerySelector',
-      proc: -> (sel) { query_one(root || dom_world.send(:document), sel) },
+      proc: -> (sel) {
+        id = query_one_id(element || frame.puppeteer_world.document, sel)
+
+        if id
+          frame.puppeteer_world.adopt_backend_node(id)
+        else
+          nil
+        end
+      },
     )
-    dom_world.send(:wait_for_selector_in_page,
+    result = frame.puppeteer_world.send(:wait_for_selector_in_page,
       '(_, selector) => globalThis.ariaQuerySelector(selector)',
+      element,
       selector,
       visible: visible,
       hidden: hidden,
       timeout: timeout,
       binding_function: binding_function,
-      root: root,
     )
+
+    element&.dispose
+
+    if result.is_a?(Puppeteer::ElementHandle)
+      result.frame.main_world.transfer_handle(result)
+    else
+      result&.dispose
+      nil
+    end
   end
 
   def query_all(element, selector)
-    context = element.execution_context
+    world = element.frame.main_world
     parse_result = parse_aria_selector(selector)
     res = element.query_ax_tree(accessible_name: parse_result[:name], role: parse_result[:role])
     if res.empty?
       nil
     else
       promises = res.map do |ax_node|
-        context.send(:async_adopt_backend_node_id, ax_node['backendDOMNodeId'])
+        world.send(:async_adopt_backend_node, ax_node['backendDOMNodeId'])
       end
       await_all(*promises)
     end

data/lib/puppeteer/coverage.rb

@@ -108,7 +108,7 @@ class Puppeteer::Coverage
 
       # Filter out empty ranges.
       results.select do |range|
-        range[:end] - range[:start] > 1
+        range[:end] - range[:start] > 0
       end
     end
   end

data/lib/puppeteer/custom_query_handler.rb

@@ -21,12 +21,39 @@ class Puppeteer::CustomQueryHandler
     nil
   end
 
-  def wait_for(dom_world, selector, visible: nil, hidden: nil, timeout: nil, root: nil)
+  def wait_for(element_or_frame, selector, visible: nil, hidden: nil, timeout: nil)
+    case element_or_frame
+    when Puppeteer::Frame
+      frame = element_or_frame
+      element = nil
+    when Puppeteer::ElementHandle
+      frame = element_or_frame.frame
+      element = frame.puppeteer_world.adopt_handle(element_or_frame)
+    else
+      raise ArgumentError.new("element_or_frame must be a Frame or ElementHandle. #{element_or_frame.inspect}")
+    end
+
     unless @query_one
       raise NotImplementedError.new("#{self.class}##{__method__} is not implemented.")
     end
 
-    dom_world.send(:wait_for_selector_in_page, @query_one, selector, visible: visible, hidden: hidden, timeout: timeout, root: root)
+    result = frame.puppeteer_world.send(:wait_for_selector_in_page,
+      @query_one,
+      element,
+      selector,
+      visible: visible,
+      hidden: hidden,
+      timeout: timeout,
+    )
+
+    element&.dispose
+
+    if result.is_a?(Puppeteer::ElementHandle)
+      result.frame.main_world.transfer_handle(result)
+    else
+      result&.dispose
+      nil
+    end
   end
 
   def query_all(element, selector)

data/lib/puppeteer/element_handle.rb

@@ -12,16 +12,16 @@ class Puppeteer::ElementHandle < Puppeteer::JSHandle
   # @param client [Puppeteer::CDPSession]
   # @param remote_object [Puppeteer::RemoteObject]
   # @param frame [Puppeteer::Frame]
-  # @param page [Puppeteer::Page]
-  # @param frame_manager [Puppeteer::FrameManager]
-  def initialize(context:, client:, remote_object:, frame:, page:, frame_manager:)
+  def initialize(context:, client:, remote_object:, frame:)
     super(context: context, client: client, remote_object: remote_object)
     @frame = frame
-    @page = page
-    @frame_manager = frame_manager
+    @page = frame.page
+    @frame_manager = frame.frame_manager
     @disposed = false
   end
 
+  attr_reader :page, :frame, :frame_manager
+
   def inspect
     values = %i[context remote_object page disposed].map do |sym|
       value = instance_variable_get(:"@#{sym}")
@@ -60,18 +60,7 @@ class Puppeteer::ElementHandle < Puppeteer::JSHandle
   # (30 seconds). Pass `0` to disable timeout. The default value can be changed
   # by using the {@link Page.setDefaultTimeout} method.
   def wait_for_selector(selector, visible: nil, hidden: nil, timeout: nil)
-    frame = @context.frame
-
-    secondary_world = frame.secondary_world
-    adopted_root = secondary_world.execution_context.adopt_element_handle(self)
-    handle = secondary_world.wait_for_selector(selector, visible: visible, hidden: hidden, timeout: timeout, root: adopted_root)
-    adopted_root.dispose
-    return nil unless handle
-
-    main_world = frame.main_world
-    result = main_world.execution_context.adopt_element_handle(handle)
-    handle.dispose
-    result
+    query_handler_manager.detect_query_handler(selector).wait_for(self, visible: visible, hidden: hidden, timeout: timeout)
   end
 
   define_async_method :async_wait_for_selector
@@ -653,6 +642,6 @@ class Puppeteer::ElementHandle < Puppeteer::JSHandle
   # used in AriaQueryHandler
   def query_ax_tree(accessible_name: nil, role: nil)
     @remote_object.query_ax_tree(@client,
-    accessible_name: accessible_name, role: role)
+      accessible_name: accessible_name, role: role)
   end
 end

data/lib/puppeteer/execution_context.rb

@@ -7,7 +7,7 @@ class Puppeteer::ExecutionContext
 
   # @param client [Puppeteer::CDPSession]
   # @param context_payload [Hash]
-  # @param world [Puppeteer::DOMWorld?]
+  # @param world [Puppeteer::IsolaatedWorld?]
   def initialize(client, context_payload, world)
     @client = client
     @world = world
@@ -17,23 +17,16 @@ class Puppeteer::ExecutionContext
 
   attr_reader :client, :world
 
-  # only used in DOMWorld
+  # only used in IsolaatedWorld
   private def _context_id
     @context_id
   end
 
-  # only used in DOMWorld::BindingFunction#add_binding_to_context
+  # only used in IsolaatedWorld::BindingFunction#add_binding_to_context
   private def _context_name
     @context_name
   end
 
-  # @return [Puppeteer::Frame]
-  def frame
-    if_present(@world) do |world|
-      world.frame
-    end
-  end
-
   # @param page_function [String]
   # @return [Object]
   def evaluate(page_function, *args)
@@ -208,54 +201,4 @@ class Puppeteer::ExecutionContext
       context_id: @context_id,
     )
   end
-
-  # /**
-  #  * @param {!JSHandle} prototypeHandle
-  #  * @return {!Promise<!JSHandle>}
-  #  */
-  # async queryObjects(prototypeHandle) {
-  #   assert(!prototypeHandle._disposed, 'Prototype JSHandle is disposed!');
-  #   assert(prototypeHandle._remoteObject.objectId, 'Prototype JSHandle must not be referencing primitive value');
-  #   const response = await this._client.send('Runtime.queryObjects', {
-  #     prototypeObjectId: prototypeHandle._remoteObject.objectId
-  #   });
-  #   return createJSHandle(this, response.objects);
-  # }
-
-  # @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
-  private define_async_method :async_adopt_backend_node_id
-
-  # @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/frame.rb

@@ -37,8 +37,8 @@ class Puppeteer::Frame
   # @param client [Puppeteer::CDPSession]
   private def update_client(client)
     @client = client
-    @main_world = Puppeteer::DOMWorld.new(@client, @frame_manager, self, @frame_manager.timeout_settings)
-    @secondary_world = Puppeteer::DOMWorld.new(@client, @frame_manager, self, @frame_manager.timeout_settings)
+    @main_world = Puppeteer::IsolaatedWorld.new(@client, @frame_manager, self, @frame_manager.timeout_settings)
+    @puppeteer_world = Puppeteer::IsolaatedWorld.new(@client, @frame_manager, self, @frame_manager.timeout_settings)
   end
 
   def page
@@ -49,7 +49,7 @@ class Puppeteer::Frame
     @client != @frame_manager.client
   end
 
-  attr_accessor :frame_manager, :id, :loader_id, :lifecycle_events, :main_world, :secondary_world
+  attr_accessor :frame_manager, :id, :loader_id, :lifecycle_events, :main_world, :puppeteer_world
 
   def has_started_loading?
     @has_started_loading
@@ -154,14 +154,14 @@ class Puppeteer::Frame
 
   # @return [String]
   def content
-    @secondary_world.content
+    @puppeteer_world.content
   end
 
   # @param html [String]
   # @param timeout [Integer]
   # @param wait_until [String|Array<String>]
   def set_content(html, timeout: nil, wait_until: nil)
-    @secondary_world.set_content(html, timeout: timeout, wait_until: wait_until)
+    @puppeteer_world.set_content(html, timeout: timeout, wait_until: wait_until)
   end
 
   # @return [String]
@@ -212,35 +212,35 @@ class Puppeteer::Frame
   # @param button [String] "left"|"right"|"middle"
   # @param click_count [Number]
   def click(selector, delay: nil, button: nil, click_count: nil)
-    @secondary_world.click(selector, delay: delay, button: button, click_count: click_count)
+    @puppeteer_world.click(selector, delay: delay, button: button, click_count: click_count)
   end
 
   define_async_method :async_click
 
   # @param {string} selector
   def focus(selector)
-    @secondary_world.focus(selector)
+    @puppeteer_world.focus(selector)
   end
 
   define_async_method :async_focus
 
   # @param {string} selector
   def hover(selector)
-    @secondary_world.hover(selector)
+    @puppeteer_world.hover(selector)
   end
 
   # @param {string} selector
   # @param {!Array<string>} values
   # @return {!Promise<!Array<string>>}
   def select(selector, *values)
-    @secondary_world.select(selector, *values)
+    @puppeteer_world.select(selector, *values)
   end
 
   define_async_method :async_select
 
   # @param {string} selector
   def tap(selector)
-    @secondary_world.tap(selector)
+    @puppeteer_world.tap(selector)
   end
 
   define_async_method :async_tap
@@ -259,14 +259,8 @@ class Puppeteer::Frame
   # @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
-      return nil
-    end
-    main_execution_context = @main_world.execution_context
-    result = main_execution_context.adopt_element_handle(handle)
-    handle.dispose
-    result
+    query_handler_manager = Puppeteer::QueryHandlerManager.instance
+    query_handler_manager.detect_query_handler(selector).wait_for(self, visible: visible, hidden: hidden, timeout: timeout)
   end
 
   define_async_method :async_wait_for_selector
@@ -306,7 +300,7 @@ class Puppeteer::Frame
 
   # @return [String]
   def title
-    @secondary_world.title
+    @puppeteer_world.title
   end
 
   # @param frame_payload [Hash]
@@ -344,7 +338,7 @@ class Puppeteer::Frame
   def detach
     @detached = true
     @main_world.detach
-    @secondary_world.detach
+    @puppeteer_world.detach
     if @parent_frame
       @parent_frame._child_frames.delete(self)
     end

data/lib/puppeteer/frame_manager.rb

@@ -413,11 +413,11 @@ class Puppeteer::FrameManager
 
       if context_payload.dig('auxData', 'isDefault')
         world = frame.main_world
-      elsif context_payload['name'] == UTILITY_WORLD_NAME && !frame.secondary_world.has_context?
+      elsif context_payload['name'] == UTILITY_WORLD_NAME && !frame.puppeteer_world.has_context?
         # In case of multiple sessions to the same target, there's a race between
         # connections so we might end up creating multiple isolated worlds.
         # We can use either.
-        world = frame.secondary_world
+        world = frame.puppeteer_world
       end
     end
 

data/lib/puppeteer/{dom_world.rb → isolated_world.rb}

@@ -1,7 +1,7 @@
 require 'thread'
 
-# https://github.com/puppeteer/puppeteer/blob/master/src/DOMWorld.js
-class Puppeteer::DOMWorld
+# https://github.com/puppeteer/puppeteer/blob/master/src/IsolaatedWorld.js
+class Puppeteer::IsolaatedWorld
   using Puppeteer::DefineAsyncMethod
 
   class BindingFunction
@@ -152,7 +152,7 @@ class Puppeteer::DOMWorld
     raise 'Bug of puppeteer-ruby...'
   end
 
-  private def document
+  def document
     @document ||= evaluate_document.as_element
   end
 
@@ -416,16 +416,6 @@ class Puppeteer::DOMWorld
     handle.dispose
   end
 
-  # @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, root: nil)
-    # call wait_for_selector_in_page with custom query selector.
-    query_selector_manager = Puppeteer::QueryHandlerManager.instance
-    query_selector_manager.detect_query_handler(selector).wait_for(self, visible: visible, hidden: hidden, timeout: timeout, root: root)
-  end
-
   private def binding_identifier(name, context)
     "#{name}_#{context.send(:_context_id)}"
   end
@@ -497,7 +487,7 @@ class Puppeteer::DOMWorld
   # @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, selector, visible: nil, hidden: nil, timeout: nil, root: nil, binding_function: nil)
+  private def wait_for_selector_in_page(query_one, root, selector, visible: nil, hidden: nil, timeout: nil, binding_function: nil)
     option_wait_for_visible = visible || false
     option_wait_for_hidden = hidden || false
     option_timeout = timeout || @timeout_settings.timeout
@@ -531,12 +521,7 @@ class Puppeteer::DOMWorld
       root: option_root,
       binding_function: binding_function,
     )
-    handle = wait_task.await_promise
-    unless handle.as_element
-      handle.dispose
-      return nil
-    end
-    handle.as_element
+    wait_task.await_promise
   end
 
   # @param page_function [String]
@@ -601,4 +586,35 @@ class Puppeteer::DOMWorld
     }
     JAVASCRIPT
   end
+
+  # @param backend_node_id [Integer]
+  # @return [Puppeteer::ElementHandle]
+  def adopt_backend_node(backend_node_id)
+    response = @client.send_message('DOM.resolveNode',
+      backendNodeId: backend_node_id,
+      executionContextId: execution_context.send(:_context_id),
+    )
+    Puppeteer::JSHandle.create(
+      context: execution_context,
+      remote_object: Puppeteer::RemoteObject.new(response["object"]),
+    )
+  end
+  private define_async_method :async_adopt_backend_node
+
+  # @param element_handle [Puppeteer::ElementHandle]
+  # @return [Puppeteer::ElementHandle]
+  def adopt_handle(element_handle)
+    if element_handle.execution_context == execution_context
+      raise ArgumentError.new('Cannot adopt handle that already belongs to this execution context')
+    end
+
+    node_info = element_handle.remote_object.node_info(@client)
+    adopt_backend_node(node_info["node"]["backendNodeId"])
+  end
+
+  def transfer_handle(element_handle)
+    result = adopt_handle(element_handle)
+    element_handle.dispose
+    result
+  end
 end

data/lib/puppeteer/js_handle.rb

@@ -5,16 +5,12 @@ class Puppeteer::JSHandle
   # @param context [Puppeteer::ExecutionContext]
   # @param remote_object [Puppeteer::RemoteObject]
   def self.create(context:, remote_object:)
-    frame = context.frame
-    if remote_object.sub_type == 'node' && frame
-      frame_manager = frame.frame_manager
+    if remote_object.sub_type == 'node' && context.world
       Puppeteer::ElementHandle.new(
         context: context,
         client: context.client,
         remote_object: remote_object,
-        frame: frame,
-        page: frame_manager.page,
-        frame_manager: frame_manager,
+        frame: context.world.frame,
       )
     else
       Puppeteer::JSHandle.new(

data/lib/puppeteer/lifecycle_watcher.rb

@@ -93,13 +93,14 @@ class Puppeteer::LifecycleWatcher
     check_lifecycle_complete
   end
 
-  class AnotherRequestReceivedError < StandardError ; end
-
   # @param [Puppeteer::HTTPRequest] request
   def handle_request(request)
     return if request.frame != @frame || !request.navigation_request?
     @navigation_request = request
-    @navigation_response_received&.reject(AnotherRequestReceivedError.new('New navigation request was received'))
+    # Resolve previous navigation response in case there are multiple
+    # navigation requests reported by the backend. This generally should not
+    # happen by it looks like it's possible.
+    @navigation_response_received&.fulfill(nil)
     @navigation_response_received = resolvable_future
     if request.response && !@navigation_response_received.resolved?
       @navigation_response_received.fulfill(nil)

data/lib/puppeteer/page.rb

@@ -191,8 +191,7 @@ class Puppeteer::Page
     return if @file_chooser_interceptors.empty?
 
     frame = @frame_manager.frame(event['frameId'])
-    context = frame.execution_context
-    element = context.adopt_backend_node_id(event['backendNodeId'])
+    element = frame.main_world.adopt_backend_node(event['backendNodeId'])
     interceptors = @file_chooser_interceptors.to_a
     @file_chooser_interceptors.clear
     file_chooser = Puppeteer::FileChooser.new(element, event)
@@ -1070,7 +1069,8 @@ class Puppeteer::Page
     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 }
+      scale = rect[:scale] || 1
+      { x: x, y: y, width: rect[:width] + rect[:x] - x, height: rect[:height] + rect[:y] - y, scale: scale }
     end
 
     if screenshot_options.full_page?

data/lib/puppeteer/query_handler_manager.rb

@@ -61,8 +61,8 @@ class Puppeteer::QueryHandlerManager
       @query_handler.query_one(element_handle, @selector)
     end
 
-    def wait_for(dom_world, visible:, hidden:, timeout:, root:)
-      @query_handler.wait_for(dom_world, @selector, visible: visible, hidden: hidden, timeout: timeout, root: root)
+    def wait_for(element_or_frame, visible:, hidden:, timeout:)
+      @query_handler.wait_for(element_or_frame, @selector, visible: visible, hidden: hidden, timeout: timeout)
     end
 
     def query_all(element_handle)

data/lib/puppeteer/remote_object.rb

@@ -105,8 +105,8 @@ class Puppeteer::RemoteObject
       role: role,
     }.compact)
 
-    result['nodes'].reject do |node|
-      node['role']['value'] == 'text'
+    result['nodes'].select do |node|
+      node['role'] && node['role']['value'] != 'StaticText'
     end
   end
 

data/lib/puppeteer/version.rb

@@ -1,3 +1,3 @@
 module Puppeteer
-  VERSION = '0.43.1'
+  VERSION = '0.44.0'
 end

data/lib/puppeteer.rb

@@ -32,7 +32,6 @@ require 'puppeteer/css_coverage'
 require 'puppeteer/custom_query_handler'
 require 'puppeteer/devices'
 require 'puppeteer/dialog'
-require 'puppeteer/dom_world'
 require 'puppeteer/emulation_manager'
 require 'puppeteer/exception_details'
 require 'puppeteer/executable_path_finder'
@@ -43,6 +42,7 @@ require 'puppeteer/frame'
 require 'puppeteer/frame_manager'
 require 'puppeteer/http_request'
 require 'puppeteer/http_response'
+require 'puppeteer/isolated_world'
 require 'puppeteer/js_coverage'
 require 'puppeteer/js_handle'
 require 'puppeteer/keyboard'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: puppeteer-ruby
 version: !ruby/object:Gem::Version
-  version: 0.43.1
+  version: 0.44.0
 platform: ruby
 authors:
 - YusukeIwaki
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-09-18 00:00:00.000000000 Z
+date: 2022-09-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -272,7 +272,6 @@ files:
 - lib/puppeteer/device.rb
 - lib/puppeteer/devices.rb
 - lib/puppeteer/dialog.rb
-- lib/puppeteer/dom_world.rb
 - lib/puppeteer/element_handle.rb
 - lib/puppeteer/element_handle/bounding_box.rb
 - lib/puppeteer/element_handle/box_model.rb
@@ -294,6 +293,7 @@ files:
 - lib/puppeteer/http_request.rb
 - lib/puppeteer/http_response.rb
 - lib/puppeteer/if_present.rb
+- lib/puppeteer/isolated_world.rb
 - lib/puppeteer/js_coverage.rb
 - lib/puppeteer/js_handle.rb
 - lib/puppeteer/keyboard.rb