puppeteer-bidi 0.0.1.beta10 → 0.0.1

data/lib/puppeteer/bidi/core/request.rb

@@ -6,6 +6,26 @@ module Puppeteer
     module Core
       # Request represents a network request
       class Request < EventEmitter
+        DESTINATION_RESOURCE_TYPES = {
+          "style" => "stylesheet",
+          "document" => "document",
+          "script" => "script",
+          "image" => "image",
+          "font" => "font",
+          "audio" => "media",
+          "video" => "media",
+          "track" => "texttrack",
+          "manifest" => "manifest",
+          "iframe" => "document",
+          "frame" => "document",
+          "fetch" => "fetch",
+          "object" => "other",
+          "embed" => "other",
+          "worker" => "other",
+          "sharedworker" => "other",
+          "serviceworker" => "other",
+        }.freeze
+
         include Disposable::DisposableMixin
 
         # Create a request instance from a beforeRequestSent event
@@ -27,8 +47,8 @@ module Puppeteer
           @error = nil
           @redirect = nil
           @response = nil
-          @response_content_promise = nil
-          @request_body_promise = nil
+          @response_content_task = nil
+          @request_body_task = nil
           @disposables = Disposable::DisposableStack.new
         end
 
@@ -101,7 +121,13 @@ module Puppeteer
         # Get resource type (non-standard)
         # @rbs return: String? -- Resource type
         def resource_type
-          @event.dig('request', 'goog:resourceType')
+          resource_type = @event.dig('request', 'goog:resourceType')
+          return resource_type if resource_type
+
+          destination = @event.dig('request', 'destination')
+          return nil unless destination
+
+          DESTINATION_RESOURCE_TYPES.fetch(destination, destination)
         end
 
         # Get POST data (non-standard)
@@ -128,7 +154,7 @@ module Puppeteer
         # @rbs headers: Array[Hash[String, untyped]]? -- Modified headers
         # @rbs cookies: Array[Hash[String, untyped]]? -- Modified cookies
         # @rbs body: Hash[String, untyped]? -- Modified body
-        # @rbs return: untyped
+        # @rbs return: Async::Task[untyped]
         def continue_request(url: nil, method: nil, headers: nil, cookies: nil, body: nil)
           params = { request: id }
           params[:url] = url if url
@@ -137,12 +163,13 @@ module Puppeteer
           params[:cookies] = cookies if cookies
           params[:body] = body if body
 
-          session.send_command('network.continueRequest', params)
+          session.async_send_command('network.continueRequest', params)
         end
 
         # Fail the request
+        # @rbs return: Async::Task[untyped]
         def fail_request
-          session.send_command('network.failRequest', { request: id })
+          session.async_send_command('network.failRequest', { request: id })
         end
 
         # Provide a response for the request
@@ -150,7 +177,7 @@ module Puppeteer
         # @rbs reason_phrase: String? -- Response reason phrase
         # @rbs headers: Array[Hash[String, untyped]]? -- Response headers
         # @rbs body: Hash[String, untyped]? -- Response body
-        # @rbs return: untyped
+        # @rbs return: Async::Task[untyped]
         def provide_response(status_code: nil, reason_phrase: nil, headers: nil, body: nil)
           params = { request: id }
           params[:statusCode] = status_code if status_code
@@ -158,20 +185,24 @@ module Puppeteer
           params[:headers] = headers if headers
           params[:body] = body if body
 
-          session.send_command('network.provideResponse', params)
+          session.async_send_command('network.provideResponse', params)
         end
 
         # Fetch POST data for the request
-        # @rbs return: String? -- POST data
+        # @rbs return: Async::Task[String?] -- POST data
         def fetch_post_data
-          return nil unless has_post_data?
-          return @request_body_promise if @request_body_promise
+          unless has_post_data?
+            return Async do
+              nil
+            end
+          end
+          return @request_body_task if @request_body_task
 
-          @request_body_promise = begin
-            result = session.send_command('network.getData', {
+          @request_body_task = Async do
+            result = session.async_send_command('network.getData', {
               dataType: 'request',
               request: id
-            })
+            }).wait
 
             bytes = result['bytes']
             if bytes['type'] == 'string'
@@ -183,34 +214,36 @@ module Puppeteer
         end
 
         # Get response content
-        # @rbs return: String -- Response content as binary string
+        # @rbs return: Async::Task[String] -- Response content as binary string
         def response_content
-          return @response_content_promise if @response_content_promise
-
-          @response_content_promise = begin
-            result = session.send_command('network.getData', {
-              dataType: 'response',
-              request: id
-            })
-
-            bytes = result['bytes']
-            if bytes['type'] == 'base64'
-              [bytes['value']].pack('m0')
-            else
-              bytes['value']
-            end
-          rescue => e
-            if e.message.include?('No resource with given identifier found')
-              raise 'Could not load response body for this request. This might happen if the request is a preflight request.'
+          return @response_content_task if @response_content_task
+
+          @response_content_task = Async do
+            begin
+              result = session.async_send_command('network.getData', {
+                dataType: 'response',
+                request: id
+              }).wait
+
+              bytes = result['bytes']
+              if bytes['type'] == 'base64'
+                [bytes['value']].pack('m0')
+              else
+                bytes['value']
+              end
+            rescue => e
+              if e.message.include?('No resource with given identifier found')
+                raise 'Could not load response body for this request. This might happen if the request is a preflight request.'
+              end
+              raise
             end
-            raise
           end
         end
 
         # Continue with authentication
         # @rbs action: String -- 'provideCredentials', 'default', or 'cancel'
         # @rbs credentials: Hash[String, untyped]? -- Credentials hash with username and password
-        # @rbs return: untyped
+        # @rbs return: Async::Task[untyped]
         def continue_with_auth(action:, credentials: nil)
           params = {
             request: id,
@@ -218,7 +251,7 @@ module Puppeteer
           }
           params[:credentials] = credentials if action == 'provideCredentials'
 
-          session.send_command('network.continueWithAuth', params)
+          session.async_send_command('network.continueWithAuth', params)
         end
 
         protected
@@ -283,6 +316,17 @@ module Puppeteer
             dispose
           end
 
+          # Listen for response started
+          session.on('network.responseStarted') do |event|
+            next unless event['context'] == @browsing_context.id
+            next unless event.dig('request', 'request') == id
+            next unless event['redirectCount'] == @event['redirectCount']
+
+            @response = event['response']
+            @event['request']['timings'] = event.dig('request', 'timings')
+            emit(:response, @response)
+          end
+
           # Listen for response completed
           session.on('network.responseCompleted') do |event|
             next unless event['context'] == @browsing_context.id

data/lib/puppeteer/bidi/core/user_context.rb

@@ -97,7 +97,7 @@ module Puppeteer
 
         # Get cookies for this user context
         # @rbs source_origin: String? -- Source origin
-        # @rbs return: Array[Hash[String, untyped]] -- Cookies
+        # @rbs return: Async::Task[Array[Hash[String, untyped]]] -- Cookies
         def get_cookies(**options)
           raise UserContextClosedError, @reason if closed?
 
@@ -109,8 +109,10 @@ module Puppeteer
           }
           params[:partition][:sourceOrigin] = source_origin if source_origin
 
-          result = session.async_send_command('storage.getCookies', params)
-          result['cookies']
+          Async do
+            result = session.async_send_command('storage.getCookies', params).wait
+            result['cookies']
+          end
         end
 
         # Set a cookie in this user context

data/lib/puppeteer/bidi/element_handle.rb

@@ -240,6 +240,65 @@ module Puppeteer
         evaluate('element => element.focus()')
       end
 
+      # Select options on a <select> element
+      # Triggers 'change' and 'input' events once all options are selected.
+      # If not a select element, throws an error.
+      # @rbs *values: String -- Option values to select
+      # @rbs return: Array[String] -- Actually selected option values
+      def select(*values)
+        assert_not_disposed
+
+        # Validate all values are strings
+        values.each_with_index do |value, index|
+          unless value.is_a?(String)
+            raise ArgumentError, "Values must be strings. Found value of type #{value.class} at index #{index}"
+          end
+        end
+
+        # Use isolated realm to avoid user modifications to global objects (like Event).
+        realm = frame.isolated_realm
+        adopted_element = realm.adopt_handle(self)
+
+        begin
+          adopted_element.evaluate(<<~JS, values)
+            (element, vals) => {
+              const values = new Set(vals);
+              if (!(element instanceof HTMLSelectElement)) {
+                throw new Error('Element is not a <select> element.');
+              }
+
+              const selectedValues = new Set();
+              if (!element.multiple) {
+                for (const option of element.options) {
+                  option.selected = false;
+                }
+                for (const option of element.options) {
+                  if (values.has(option.value)) {
+                    option.selected = true;
+                    selectedValues.add(option.value);
+                    break;
+                  }
+                }
+              } else {
+                for (const option of element.options) {
+                  option.selected = values.has(option.value);
+                  if (option.selected) {
+                    selectedValues.add(option.value);
+                  }
+                }
+              }
+
+              element.dispatchEvent(new Event('input', {bubbles: true}));
+              element.dispatchEvent(new Event('change', {bubbles: true}));
+
+              return Array.from(selectedValues.values());
+            }
+          JS
+        ensure
+          adopted_element&.dispose
+        end
+      end
+
       # Hover over the element
       # Scrolls element into view if needed and moves mouse to element center
       # @rbs return: void
@@ -299,6 +358,70 @@ module Puppeteer
         evaluate('element => element.scrollIntoView({block: "center", inline: "center", behavior: "instant"})')
       end
 
+      # Create a locator based on this element handle.
+      # @rbs return: Locator -- Locator instance
+      def as_locator
+        assert_not_disposed
+
+        NodeLocator.create_from_handle(frame, self)
+      end
+
+      # Take a screenshot of the element.
+      # Following Puppeteer's implementation: ElementHandle.screenshot
+      # @rbs path: String? -- File path to save screenshot
+      # @rbs type: String -- Image type ('png' or 'jpeg')
+      # @rbs clip: Hash[Symbol, Numeric]? -- Clip region relative to element
+      # @rbs scroll_into_view: bool -- Scroll element into view before screenshot
+      # @rbs return: String -- Base64-encoded image data
+      def screenshot(path: nil, type: 'png', clip: nil, scroll_into_view: true)
+        assert_not_disposed
+
+        page = frame.page
+
+        # Scroll into view if needed
+        scroll_into_view_if_needed if scroll_into_view
+
+        # Get element's bounding box - must not be empty
+        # Note: bounding_box returns viewport-relative coordinates from getBoundingClientRect()
+        element_box = non_empty_visible_bounding_box
+
+        # Get page scroll offset from visualViewport to convert to document coordinates
+        scroll_offset = evaluate(<<~JS)
+          () => {
+            if (!window.visualViewport) {
+              throw new Error('window.visualViewport is not supported.');
+            }
+            return {
+              pageLeft: window.visualViewport.pageLeft,
+              pageTop: window.visualViewport.pageTop
+            };
+          }
+        JS
+
+        # Build element clip in document coordinates (viewport coords + scroll offset)
+        # Following Puppeteer's implementation: elementClip.x += pageLeft; elementClip.y += pageTop
+        element_clip = {
+          x: element_box.x + scroll_offset['pageLeft'],
+          y: element_box.y + scroll_offset['pageTop'],
+          width: element_box.width,
+          height: element_box.height
+        }
+
+        # Apply user-specified clip if provided
+        if clip
+          element_clip[:x] += clip[:x]
+          element_clip[:y] += clip[:y]
+          element_clip[:width] = clip[:width]
+          element_clip[:height] = clip[:height]
+        end
+
+        page.screenshot(
+          path: path,
+          type: type,
+          clip: element_clip
+        )
+      end
+
       # Check if element is intersecting the viewport
       # @rbs threshold: Numeric -- Intersection ratio threshold
       # @rbs return: bool -- Whether element intersects viewport
@@ -353,6 +476,10 @@ module Puppeteer
             if (!(element instanceof Element)) {
               return null;
             }
+            // Element is not visible
+            if (element.getClientRects().length === 0) {
+              return null;
+            }
             const rect = element.getBoundingClientRect();
             return {x: rect.x, y: rect.y, width: rect.width, height: rect.height};
           }
@@ -360,12 +487,12 @@ module Puppeteer
 
         return nil unless result
 
-        # Return nil if element has zero dimensions (not visible)
-        return nil if result['width'].zero? && result['height'].zero?
+        offset = top_left_corner_of_frame
+        return nil unless offset
 
         BoundingBox.new(
-          x: result['x'],
-          y: result['y'],
+          x: result['x'] + offset[:x],
+          y: result['y'] + offset[:y],
           width: result['width'],
           height: result['height']
         )
@@ -450,12 +577,23 @@ module Puppeteer
 
         return nil unless model
 
+        offset = top_left_corner_of_frame
+        return nil unless offset
+
         # Convert raw arrays to Point objects for each quad
         BoxModel.new(
-          content: model['content'].map { |p| Point.new(x: p['x'], y: p['y']) },
-          padding: model['padding'].map { |p| Point.new(x: p['x'], y: p['y']) },
-          border: model['border'].map { |p| Point.new(x: p['x'], y: p['y']) },
-          margin: model['margin'].map { |p| Point.new(x: p['x'], y: p['y']) },
+          content: model['content'].map do |p|
+            Point.new(x: p['x'] + offset[:x], y: p['y'] + offset[:y])
+          end,
+          padding: model['padding'].map do |p|
+            Point.new(x: p['x'] + offset[:x], y: p['y'] + offset[:y])
+          end,
+          border: model['border'].map do |p|
+            Point.new(x: p['x'] + offset[:x], y: p['y'] + offset[:y])
+          end,
+          margin: model['margin'].map do |p|
+            Point.new(x: p['x'] + offset[:x], y: p['y'] + offset[:y])
+          end,
           width: model['width'],
           height: model['height']
         )
@@ -591,6 +729,60 @@ module Puppeteer
         JS
       end
 
+      # Get bounding box ensuring it's non-empty and visible
+      # @rbs return: BoundingBox -- Non-empty bounding box
+      def non_empty_visible_bounding_box
+        box = bounding_box
+        raise 'Node is either not visible or not an HTMLElement' unless box
+        raise 'Node has 0 width.' if box.width.zero?
+        raise 'Node has 0 height.' if box.height.zero?
+
+        box
+      end
+
+      # Get top-left corner offset of the element's frame relative to the main frame
+      # @rbs return: Hash[Symbol, Numeric]? -- Offset hash or nil if not visible
+      def top_left_corner_of_frame
+        point = { x: 0, y: 0 }
+        current_frame = frame
+
+        while (parent_frame = current_frame.parent_frame)
+          handle = current_frame.frame_element
+          raise 'Unsupported frame type' unless handle
+
+          begin
+            parent_box = handle.evaluate(<<~JS)
+              element => {
+                // Element is not visible.
+                if (element.getClientRects().length === 0) {
+                  return null;
+                }
+                const rect = element.getBoundingClientRect();
+                const style = window.getComputedStyle(element);
+                return {
+                  left: rect.left +
+                    parseInt(style.paddingLeft, 10) +
+                    parseInt(style.borderLeftWidth, 10),
+                  top: rect.top +
+                    parseInt(style.paddingTop, 10) +
+                    parseInt(style.borderTopWidth, 10)
+                };
+              }
+            JS
+          ensure
+            handle.dispose unless handle.disposed?
+          end
+
+          return nil unless parent_box
+
+          point[:x] += parent_box['left']
+          point[:y] += parent_box['top']
+          current_frame = parent_frame
+        end
+
+        point
+      end
+
       # String representation includes element type
       # @rbs return: String -- String representation
       def to_s

data/lib/puppeteer/bidi/errors.rb

@@ -39,5 +39,9 @@ module Puppeteer
     # Raised when a timeout occurs (e.g., navigation timeout)
     class TimeoutError < Error
     end
+
+    # Raised when an operation is unsupported in this environment
+    class UnsupportedOperationError < Error
+    end
   end
 end

data/lib/puppeteer/bidi/frame.rb

@@ -117,6 +117,24 @@ module Puppeteer
         end
       end
 
+      # Create a locator for a selector or function.
+      # @rbs selector: String? -- Selector to locate
+      # @rbs function: String? -- JavaScript function for function locator
+      # @rbs return: Locator -- Locator instance
+      def locator(selector = nil, function: nil)
+        assert_not_detached
+
+        if function
+          raise ArgumentError, "selector and function cannot both be set" if selector
+
+          FunctionLocator.create(self, function)
+        elsif selector
+          NodeLocator.create(self, selector)
+        else
+          raise ArgumentError, "selector or function must be provided"
+        end
+      end
+
       # Evaluate a function on the first element matching the selector
       # @rbs selector: String -- Selector to query
       # @rbs page_function: String -- JavaScript function to evaluate
@@ -199,6 +217,24 @@ module Puppeteer
         end
       end
 
+      # Select options on a <select> element matching the selector
+      # Triggers 'change' and 'input' events once all options are selected.
+      # @rbs selector: String -- Selector for <select> element
+      # @rbs *values: String -- Option values to select
+      # @rbs return: Array[String] -- Actually selected option values
+      def select(selector, *values)
+        assert_not_detached
+
+        handle = query_selector(selector)
+        raise SelectorNotFoundError, selector unless handle
+
+        begin
+          handle.select(*values)
+        ensure
+          handle.dispose
+        end
+      end
+
       # Get the frame URL
       # @rbs return: String -- Current URL
       def url
@@ -214,10 +250,7 @@ module Puppeteer
         response = wait_for_navigation(timeout: timeout, wait_until: wait_until) do
           @browsing_context.navigate(url, wait: 'interactive').wait
         end
-        # Return HTTPResponse with the final URL
-        # Note: Currently we don't track HTTP status codes from BiDi protocol
-        # Assuming successful navigation (200 OK)
-        HTTPResponse.new(url: @browsing_context.url, status: 200)
+        response
       end
 
       # Set frame content
@@ -367,6 +400,12 @@ module Puppeteer
         # Track navigation type for response creation
         navigation_type = nil  # :full_page, :fragment, or :history
         navigation_obj = nil  # The navigation object we're waiting for
+        load_listener_registered = false
+
+        # Define load_listener upfront to satisfy type checker
+        load_listener = proc do
+          promise.resolve(:full_page) unless promise.resolved?
+        end
 
         # Helper to set up navigation listeners
         setup_navigation_listeners = proc do |navigation|
@@ -389,8 +428,9 @@ module Puppeteer
           end
 
           # Also listen for load/domcontentloaded events to complete navigation
-          @browsing_context.once(load_event) do
-            promise.resolve(:full_page) unless promise.resolved?
+          unless load_listener_registered
+            @browsing_context.once(load_event, &load_listener)
+            load_listener_registered = true
           end
         end
 
@@ -461,11 +501,9 @@ module Puppeteer
           end
 
           # Return HTTPResponse for full page navigation, nil for fragment/history
-          if result == :full_page
-            HTTPResponse.new(url: @browsing_context.url, status: 200)
-          else
-            nil
-          end
+          return nil unless result == :full_page
+
+          navigation_response_for(navigation_obj)
         rescue Async::TimeoutError
           raise Puppeteer::Bidi::TimeoutError, "Navigation timeout of #{timeout}ms exceeded"
         ensure
@@ -474,6 +512,7 @@ module Puppeteer
           @browsing_context.off(:history_updated, &history_listener)
           @browsing_context.off(:fragment_navigated, &fragment_listener)
           @browsing_context.off(:closed, &closed_listener)
+          @browsing_context.off(load_event, &load_listener) if load_listener_registered
         end
       end
 
@@ -556,6 +595,26 @@ module Puppeteer
         @browsing_context.on(:fragment_navigated) do
           page.emit(:framenavigated, self)
         end
+
+        @browsing_context.on(:request) do |data|
+          request = data[:request]
+          http_request = HTTPRequest.from(
+            request,
+            self,
+            page.network_interception_enabled?
+          )
+
+          request.once(:success) do
+            page.emit(:requestfinished, http_request)
+          end
+
+          request.once(:error) do
+            page.emit(:requestfailed, http_request)
+          end
+          page.request_interception_semaphore.async do
+            http_request.finalize_interceptions
+          end
+        end
       end
 
       # Create a Frame for a child browsing context
@@ -592,6 +651,51 @@ module Puppeteer
         raise FrameDetachedError, "Attempted to use detached Frame '#{_id}'." if @browsing_context.closed?
       end
 
+      def navigation_response_for(navigation)
+        return nil unless navigation&.request
+
+        request = navigation.request
+        resolved_request = request.last_redirect || request
+        http_request = HTTPRequest.for_core_request(resolved_request)
+        return http_request.response if http_request&.response
+
+        wait_for_request_completion(request)
+
+        resolved_request = request.last_redirect || request
+        http_request = HTTPRequest.for_core_request(resolved_request)
+        http_request&.response
+      end
+
+      def wait_for_request_completion(request)
+        loop do
+          return if request.response || request.error
+
+          promise = Async::Promise.new
+          success_listener = proc do
+            promise.resolve(:done) unless promise.resolved?
+          end
+          error_listener = proc do
+            promise.resolve(:done) unless promise.resolved?
+          end
+          redirect_listener = proc do |redirect_request|
+            promise.resolve(redirect_request) unless promise.resolved?
+          end
+
+          request.on(:success, &success_listener)
+          request.on(:error, &error_listener)
+          request.on(:redirect, &redirect_listener)
+
+          result = promise.wait
+          request.off(:success, &success_listener)
+          request.off(:error, &error_listener)
+          request.off(:redirect, &redirect_listener)
+
+          return if result == :done
+
+          request = result
+        end
+      end
+
     end
   end
 end