puppeteer-bidi 0.0.1.beta1

data/sig/puppeteer/bidi/element_handle.rbs

@@ -0,0 +1,238 @@
+# Generated from lib/puppeteer/bidi/element_handle.rb with RBS::Inline
+
+module Puppeteer
+  module Bidi
+    # ElementHandle represents a reference to a DOM element
+    # Based on Puppeteer's BidiElementHandle implementation
+    # This extends JSHandle with DOM-specific methods
+    class ElementHandle < JSHandle
+      # Bounding box data class representing element position and dimensions
+      class BoundingBox < Data
+        attr_reader x(): untyped
+
+        attr_reader y(): untyped
+
+        attr_reader width(): untyped
+
+        attr_reader height(): untyped
+
+        def self.new: (untyped x, untyped y, untyped width, untyped height) -> instance
+                    | (x: untyped, y: untyped, width: untyped, height: untyped) -> instance
+
+        def self.members: () -> [ :x, :y, :width, :height ]
+
+        def members: () -> [ :x, :y, :width, :height ]
+      end
+
+      # Point data class representing a coordinate
+      class Point < Data
+        attr_reader x(): untyped
+
+        attr_reader y(): untyped
+
+        def self.new: (untyped x, untyped y) -> instance
+                    | (x: untyped, y: untyped) -> instance
+
+        def self.members: () -> [ :x, :y ]
+
+        def members: () -> [ :x, :y ]
+      end
+
+      # Box model data class representing element's CSS box model
+      # Each quad (content, padding, border, margin) contains 4 Points representing corners
+      # Corners are ordered: top-left, top-right, bottom-right, bottom-left
+      class BoxModel < Data
+        attr_reader content(): untyped
+
+        attr_reader padding(): untyped
+
+        attr_reader border(): untyped
+
+        attr_reader margin(): untyped
+
+        attr_reader width(): untyped
+
+        attr_reader height(): untyped
+
+        def self.new: (untyped content, untyped padding, untyped border, untyped margin, untyped width, untyped height) -> instance
+                    | (content: untyped, padding: untyped, border: untyped, margin: untyped, width: untyped, height: untyped) -> instance
+
+        def self.members: () -> [ :content, :padding, :border, :margin, :width, :height ]
+
+        def members: () -> [ :content, :padding, :border, :margin, :width, :height ]
+      end
+
+      # Factory method to create ElementHandle from remote value
+      # @rbs remote_value: Hash[String, untyped]
+      # @rbs realm: Core::Realm
+      # @rbs return: ElementHandle
+      def self.from: (Hash[String, untyped] remote_value, Core::Realm realm) -> ElementHandle
+
+      # Query for a descendant element matching the selector
+      # Supports CSS selectors and prefixed selectors (xpath/, text/, aria/, pierce/)
+      # @rbs selector: String
+      # @rbs return: ElementHandle?
+      def query_selector: (String selector) -> ElementHandle?
+
+      # Query for all descendant elements matching the selector
+      # Supports CSS selectors and prefixed selectors (xpath/, text/, aria/, pierce/)
+      # @rbs selector: String
+      # @rbs return: Array[ElementHandle]
+      def query_selector_all: (String selector) -> Array[ElementHandle]
+
+      # Evaluate a function on the first element matching the selector
+      # @rbs selector: String
+      # @rbs page_function: String
+      # @rbs *args: untyped
+      # @rbs return: untyped
+      def eval_on_selector: (String selector, String page_function, *untyped args) -> untyped
+
+      # Evaluate a function on all elements matching the selector
+      # @rbs selector: String
+      # @rbs page_function: String
+      # @rbs *args: untyped
+      # @rbs return: untyped
+      def eval_on_selector_all: (String selector, String page_function, *untyped args) -> untyped
+
+      # Wait for an element matching the selector to appear as a descendant of this element
+      # @rbs selector: String
+      # @rbs visible: bool?
+      # @rbs hidden: bool?
+      # @rbs timeout: Numeric?
+      # @rbs &block: ((ElementHandle?) -> void)?
+      # @rbs return: ElementHandle?
+      def wait_for_selector: (String selector, ?visible: bool?, ?hidden: bool?, ?timeout: Numeric?) ?{ (?) -> untyped } -> ElementHandle?
+
+      # Click the element
+      # @rbs button: String
+      # @rbs count: Integer
+      # @rbs delay: Numeric?
+      # @rbs offset: Hash[Symbol, Numeric]?
+      # @rbs return: void
+      def click: (?button: String, ?count: Integer, ?delay: Numeric?, ?offset: Hash[Symbol, Numeric]?) -> void
+
+      # Type text into the element
+      # @rbs text: String
+      # @rbs delay: Numeric
+      # @rbs return: void
+      def type: (String text, ?delay: Numeric) -> void
+
+      # Press a key on the element
+      # @rbs key: String
+      # @rbs delay: Numeric?
+      # @rbs text: String?
+      # @rbs return: void
+      def press: (String key, ?delay: Numeric?, ?text: String?) -> void
+
+      # Get the frame this element belongs to
+      # Following Puppeteer's pattern: realm.environment
+      # @rbs return: Frame
+      def frame: () -> Frame
+
+      # Get the content frame for iframe/frame elements
+      # Returns the frame that the iframe/frame element refers to
+      # @rbs return: Frame?
+      def content_frame: () -> Frame?
+
+      # Check if the element is visible
+      # An element is considered visible if:
+      # - It has computed styles
+      # - Its visibility is not 'hidden' or 'collapse'
+      # - Its bounding box is not empty (width > 0 AND height > 0)
+      # @rbs return: bool
+      def visible?: () -> bool
+
+      # Check if the element is hidden
+      # An element is considered hidden if:
+      # - It has no computed styles
+      # - Its visibility is 'hidden' or 'collapse'
+      # - Its bounding box is empty (width == 0 OR height == 0)
+      # @rbs return: bool
+      def hidden?: () -> bool
+
+      # Convert the current handle to the given element type
+      # Validates that the element matches the expected tag name
+      # @rbs tag_name: String
+      # @rbs return: ElementHandle
+      def to_element: (String tag_name) -> ElementHandle
+
+      # Focus the element
+      # @rbs return: void
+      def focus: () -> void
+
+      # Hover over the element
+      # Scrolls element into view if needed and moves mouse to element center
+      # @rbs return: void
+      def hover: () -> void
+
+      # Upload files to this element (for <input type="file">)
+      # Following Puppeteer's implementation: ElementHandle.uploadFile -> Frame.setFiles
+      # @rbs *files: String
+      # @rbs return: void
+      def upload_file: (*String files) -> void
+
+      # Get the remote value as a SharedReference for BiDi commands
+      # @rbs return: Hash[Symbol, String]
+      def remote_value_as_shared_reference: () -> Hash[Symbol, String]
+
+      # Scroll element into view if needed
+      # @rbs return: void
+      def scroll_into_view_if_needed: () -> void
+
+      # Scroll element into view
+      # @rbs return: void
+      def scroll_into_view: () -> void
+
+      # Check if element is intersecting the viewport
+      # @rbs threshold: Numeric
+      # @rbs return: bool
+      def intersecting_viewport?: (?threshold: Numeric) -> bool
+
+      # Get clickable point for the element
+      # @rbs offset: Hash[Symbol, Numeric]?
+      # @rbs return: Point
+      def clickable_point: (?offset: Hash[Symbol, Numeric]?) -> Point
+
+      # Get the bounding box of the element
+      # Uses getBoundingClientRect() to get the element's position and size
+      # @rbs return: BoundingBox?
+      def bounding_box: () -> BoundingBox?
+
+      # Get the box model of the element (content, padding, border, margin)
+      # @rbs return: BoxModel?
+      def box_model: () -> BoxModel?
+
+      # Get the clickable box for the element
+      # Uses getClientRects() to handle wrapped/multi-line elements correctly
+      # Following Puppeteer's implementation:
+      # https://github.com/puppeteer/puppeteer/blob/main/packages/puppeteer-core/src/api/ElementHandle.ts#clickableBox
+      # @rbs return: Hash[Symbol, Numeric]?
+      def clickable_box: () -> Hash[Symbol, Numeric]?
+
+      private
+
+      # Intersect bounding boxes with frame viewport boundaries
+      # Modifies boxes in-place to clip them to visible area
+      # @rbs boxes: Array[Hash[String, Numeric]]
+      # @rbs return: void
+      def intersect_bounding_boxes_with_frame: (Array[Hash[String, Numeric]] boxes) -> void
+
+      # Intersect a single bounding box with given width/height boundaries
+      # Modifies box in-place
+      # @rbs box: Hash[String, Numeric]
+      # @rbs width: Numeric
+      # @rbs height: Numeric
+      # @rbs return: void
+      def intersect_bounding_box: (Hash[String, Numeric] box, Numeric width, Numeric height) -> void
+
+      # Check element visibility
+      # @rbs visible: bool
+      # @rbs return: bool
+      def check_visibility: (bool visible) -> bool
+
+      # String representation includes element type
+      # @rbs return: String
+      def to_s: () -> String
+    end
+  end
+end

data/sig/puppeteer/bidi/frame.rbs

@@ -0,0 +1,205 @@
+# Generated from lib/puppeteer/bidi/frame.rb with RBS::Inline
+
+module Puppeteer
+  module Bidi
+    # Frame represents a frame (main frame or iframe) in the page
+    # This is a high-level wrapper around Core::BrowsingContext
+    # Following Puppeteer's BidiFrame implementation
+    class Frame
+      attr_reader browsing_context: Core::BrowsingContext
+
+      # Factory method following Puppeteer's BidiFrame.from pattern
+      # @rbs parent: Page | Frame
+      # @rbs browsing_context: Core::BrowsingContext
+      # @rbs return: Frame
+      def self.from: (Page | Frame parent, Core::BrowsingContext browsing_context) -> Frame
+
+      # @rbs parent: Page | Frame
+      # @rbs browsing_context: Core::BrowsingContext
+      # @rbs return: void
+      def initialize: (Page | Frame parent, Core::BrowsingContext browsing_context) -> void
+
+      # @rbs return: FrameRealm
+      def main_realm: () -> FrameRealm
+
+      # @rbs return: FrameRealm
+      def isolated_realm: () -> FrameRealm
+
+      # Backwards compatibility for call sites that previously accessed Frame#realm.
+      # @rbs return: FrameRealm
+      def realm: () -> FrameRealm
+
+      # Get the page that owns this frame
+      # Traverses up the parent chain until reaching a Page
+      # @rbs return: Page
+      def page: () -> Page
+
+      # Get the parent frame
+      # @rbs return: Frame?
+      def parent_frame: () -> Frame?
+
+      # Evaluate JavaScript in the frame context
+      # @rbs script: String
+      # @rbs *args: untyped
+      # @rbs return: untyped
+      def evaluate: (String script, *untyped args) -> untyped
+
+      # Evaluate JavaScript and return a handle to the result
+      # @rbs script: String
+      # @rbs *args: untyped
+      # @rbs return: JSHandle
+      def evaluate_handle: (String script, *untyped args) -> JSHandle
+
+      # Get the document element handle
+      # @rbs return: ElementHandle
+      def document: () -> ElementHandle
+
+      # Query for an element matching the selector
+      # @rbs selector: String
+      # @rbs return: ElementHandle?
+      def query_selector: (String selector) -> ElementHandle?
+
+      # Query for all elements matching the selector
+      # @rbs selector: String
+      # @rbs return: Array[ElementHandle]
+      def query_selector_all: (String selector) -> Array[ElementHandle]
+
+      # Evaluate a function on the first element matching the selector
+      # @rbs selector: String
+      # @rbs page_function: String
+      # @rbs *args: untyped
+      # @rbs return: untyped
+      def eval_on_selector: (String selector, String page_function, *untyped args) -> untyped
+
+      # Evaluate a function on all elements matching the selector
+      # @rbs selector: String
+      # @rbs page_function: String
+      # @rbs *args: untyped
+      # @rbs return: untyped
+      def eval_on_selector_all: (String selector, String page_function, *untyped args) -> untyped
+
+      # Click an element matching the selector
+      # @rbs selector: String
+      # @rbs button: String
+      # @rbs count: Integer
+      # @rbs delay: Numeric?
+      # @rbs offset: Hash[Symbol, Numeric]?
+      # @rbs return: void
+      def click: (String selector, ?button: String, ?count: Integer, ?delay: Numeric?, ?offset: Hash[Symbol, Numeric]?) -> void
+
+      # Type text into an element matching the selector
+      # @rbs selector: String
+      # @rbs text: String
+      # @rbs delay: Numeric
+      # @rbs return: void
+      def type: (String selector, String text, ?delay: Numeric) -> void
+
+      # Hover over an element matching the selector
+      # @rbs selector: String
+      # @rbs return: void
+      def hover: (String selector) -> void
+
+      # Get the frame URL
+      # @rbs return: String
+      def url: () -> String
+
+      # Navigate to a URL
+      # @rbs url: String
+      # @rbs wait_until: String
+      # @rbs timeout: Numeric
+      # @rbs return: HTTPResponse?
+      def goto: (String url, ?wait_until: String, ?timeout: Numeric) -> HTTPResponse?
+
+      # Set frame content
+      # @rbs html: String
+      # @rbs wait_until: String
+      # @rbs return: void
+      def set_content: (String html, ?wait_until: String) -> void
+
+      # Set frame content using document.open/write/close
+      # This is a low-level method that doesn't wait for load events
+      # @rbs content: String
+      # @rbs return: void
+      def set_frame_content: (String content) -> void
+
+      # Get the frame name
+      # @rbs return: String
+      def name: () -> String
+
+      # Check if frame is detached
+      # @rbs return: bool
+      def detached?: () -> bool
+
+      # Get child frames
+      # Returns cached frame instances following Puppeteer's pattern
+      # @rbs return: Array[Frame]
+      def child_frames: () -> Array[Frame]
+
+      # Get the frame element (iframe/frame DOM element) for this frame
+      # Returns nil for the main frame
+      # Following Puppeteer's Frame.frameElement() implementation exactly
+      # @rbs return: ElementHandle?
+      def frame_element: () -> ElementHandle?
+
+      # Wait for navigation to complete
+      # @rbs timeout: Numeric
+      # @rbs wait_until: String | Array[String]
+      # @rbs &block: (-> void)?
+      # @rbs return: HTTPResponse?
+      def wait_for_navigation: (?timeout: Numeric, ?wait_until: String | Array[String]) ?{ (?) -> untyped } -> HTTPResponse?
+
+      # Wait for a function to return a truthy value
+      # @rbs page_function: String
+      # @rbs options: Hash[Symbol, untyped]
+      # @rbs *args: untyped
+      # @rbs &block: ((JSHandle) -> void)?
+      # @rbs return: JSHandle
+      def wait_for_function: (String page_function, ?Hash[Symbol, untyped] options, *untyped args) ?{ (?) -> untyped } -> JSHandle
+
+      # Wait for an element matching the selector to appear in the frame
+      # @rbs selector: String
+      # @rbs visible: bool?
+      # @rbs hidden: bool?
+      # @rbs timeout: Numeric?
+      # @rbs &block: ((ElementHandle?) -> void)?
+      # @rbs return: ElementHandle?
+      def wait_for_selector: (String selector, ?visible: bool?, ?hidden: bool?, ?timeout: Numeric?) ?{ (?) -> untyped } -> ElementHandle?
+
+      # Set files on an input element
+      # @rbs element: ElementHandle
+      # @rbs files: Array[String]
+      # @rbs return: void
+      def set_files: (ElementHandle element, Array[String] files) -> void
+
+      # Get the frame ID (browsing context ID)
+      # Following Puppeteer's _id pattern
+      # @rbs return: String
+      def _id: () -> String
+
+      private
+
+      # Initialize the frame by setting up child frame tracking
+      # Following Puppeteer's BidiFrame.#initialize pattern exactly
+      # @rbs return: void
+      def initialize_frame: () -> void
+
+      # Create a Frame for a child browsing context
+      # Following Puppeteer's BidiFrame.#createFrameTarget pattern exactly:
+      #   const frame = BidiFrame.from(this, browsingContext);
+      #   this.#frames.set(browsingContext, frame);
+      #   this.page().trustedEmitter.emit(PageEvent.FrameAttached, frame);
+      #   browsingContext.on('closed', () => {
+      #     this.#frames.delete(browsingContext);
+      #   });
+      # Note: FrameDetached is NOT emitted here - it's emitted in #initialize
+      # when the frame's own browsing context closes
+      # @rbs browsing_context: Core::BrowsingContext
+      # @rbs return: Frame
+      def create_frame_target: (Core::BrowsingContext browsing_context) -> Frame
+
+      # Check if this frame is detached and raise error if so
+      # @rbs return: void
+      def assert_not_detached: () -> void
+    end
+  end
+end

data/sig/puppeteer/bidi/js_handle.rbs

@@ -0,0 +1,90 @@
+# Generated from lib/puppeteer/bidi/js_handle.rb with RBS::Inline
+
+module Puppeteer
+  module Bidi
+    # JSHandle represents a reference to a JavaScript object
+    # Based on Puppeteer's BidiJSHandle implementation
+    class JSHandle
+      attr_reader realm: Core::Realm
+
+      # @rbs remote_value: Hash[String, untyped]
+      # @rbs realm: Core::Realm
+      # @rbs return: void
+      def initialize: (Core::Realm realm, Hash[String, untyped] remote_value) -> void
+
+      # Factory method to create JSHandle from remote value
+      # @rbs remote_value: Hash[String, untyped]
+      # @rbs realm: Core::Realm
+      # @rbs return: JSHandle | ElementHandle
+      def self.from: (Hash[String, untyped] remote_value, Core::Realm realm) -> (JSHandle | ElementHandle)
+
+      # Get the remote value (BiDi Script.RemoteValue)
+      # @rbs return: Hash[String, untyped]
+      def remote_value: () -> Hash[String, untyped]
+
+      # Get the remote object (alias for remote_value)
+      # @rbs return: Hash[String, untyped]
+      def remote_object: () -> Hash[String, untyped]
+
+      # Check if handle has been disposed
+      # @rbs return: bool
+      def disposed?: () -> bool
+
+      # Dispose this handle by releasing the remote object
+      # @rbs return: void
+      def dispose: () -> void
+
+      # Get the handle ID (handle or sharedId)
+      # @rbs return: String?
+      def id: () -> String?
+
+      # Evaluate JavaScript function with this handle as the first argument
+      # @rbs script: String
+      # @rbs *args: untyped
+      # @rbs return: untyped
+      def evaluate: (String script, *untyped args) -> untyped
+
+      # Evaluate JavaScript function and return a handle to the result
+      # @rbs script: String
+      # @rbs *args: untyped
+      # @rbs return: JSHandle
+      def evaluate_handle: (String script, *untyped args) -> JSHandle
+
+      # Get a property of the object
+      # @rbs property_name: String
+      # @rbs return: JSHandle
+      def get_property: (String property_name) -> JSHandle
+
+      # Get all properties of the object
+      # @rbs return: Hash[String, JSHandle]
+      def get_properties: () -> Hash[String, JSHandle]
+
+      # Convert this handle to a JSON-serializable value
+      # @rbs return: untyped
+      def json_value: () -> untyped
+
+      # Convert to ElementHandle if this is an element
+      # @rbs return: ElementHandle?
+      def as_element: () -> ElementHandle?
+
+      # Check if this is a primitive value
+      # @rbs return: bool
+      def primitive_value?: () -> bool
+
+      # String representation of this handle
+      # @rbs return: String
+      def to_s: () -> String
+
+      private
+
+      # Check if this handle has been disposed and raise error if so
+      # @rbs return: void
+      def assert_not_disposed: () -> void
+
+      # Handle evaluation exceptions
+      # @rbs result: Hash[String, untyped]
+      # @rbs return: void
+      def handle_evaluation_exception: (Hash[String, untyped] result) -> void
+    end
+  end
+end