puppeteer-bidi 0.0.1.beta1 → 0.0.1.beta3

data/sig/puppeteer/bidi/core/request.rbs

@@ -0,0 +1,120 @@
+# Generated from lib/puppeteer/bidi/core/request.rb with RBS::Inline
+
+module Puppeteer
+  module Bidi
+    module Core
+      # Request represents a network request
+      class Request < EventEmitter
+        include Disposable::DisposableMixin
+
+        # Create a request instance from a beforeRequestSent event
+        # @rbs browsing_context: BrowsingContext -- The browsing context
+        # @rbs event: Hash[String, untyped] -- The beforeRequestSent event data
+        # @rbs return: Request -- New request instance
+        def self.from: (BrowsingContext browsing_context, Hash[String, untyped] event) -> Request
+
+        attr_reader browsing_context: untyped
+
+        attr_reader error: untyped
+
+        attr_reader response: untyped
+
+        def initialize: (untyped browsing_context, untyped event) -> untyped
+
+        # Get request ID
+        # @rbs return: String -- Request ID
+        def id: () -> String
+
+        # Get request URL
+        # @rbs return: String -- Request URL
+        def url: () -> String
+
+        # Get request method
+        # @rbs return: String -- Request method (GET, POST, etc.)
+        def method: () -> String
+
+        # Get request headers
+        # @rbs return: Array[Hash[String, untyped]] -- Request headers
+        def headers: () -> Array[Hash[String, untyped]]
+
+        # Get navigation ID if this is a navigation request
+        # @rbs return: String? -- Navigation ID
+        def navigation: () -> String?
+
+        # Get redirect request if this request was redirected
+        # @rbs return: Request? -- Redirect request
+        def redirect: () -> Request?
+
+        # Get the last redirect in the chain
+        # @rbs return: Request? -- Last redirect request
+        def last_redirect: () -> Request?
+
+        # Get request initiator information
+        # @rbs return: untyped -- Initiator info (mixed String/Symbol keys)
+        def initiator: () -> untyped
+
+        # Check if the request is blocked
+        # @rbs return: bool -- Whether the request is blocked
+        def blocked?: () -> bool
+
+        # Get resource type (non-standard)
+        # @rbs return: String? -- Resource type
+        def resource_type: () -> String?
+
+        # Get POST data (non-standard)
+        # @rbs return: String? -- POST data
+        def post_data: () -> String?
+
+        # Check if request has POST data
+        # @rbs return: bool -- Whether request has POST data
+        def has_post_data?: () -> bool
+
+        # Get timing information
+        # @rbs return: Hash[String, untyped] -- Timing info
+        def timing: () -> Hash[String, untyped]
+
+        # Continue the request with optional modifications
+        # @rbs url: String? -- Modified URL
+        # @rbs method: String? -- Modified method
+        # @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
+        def continue_request: (?url: String?, ?method: String?, ?headers: Array[Hash[String, untyped]]?, ?cookies: Array[Hash[String, untyped]]?, ?body: Hash[String, untyped]?) -> untyped
+
+        # Fail the request
+        def fail_request: () -> untyped
+
+        # Provide a response for the request
+        # @rbs status_code: Integer? -- Response status code
+        # @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
+        def provide_response: (?status_code: Integer?, ?reason_phrase: String?, ?headers: Array[Hash[String, untyped]]?, ?body: Hash[String, untyped]?) -> untyped
+
+        # Fetch POST data for the request
+        # @rbs return: String? -- POST data
+        def fetch_post_data: () -> String?
+
+        # Get response content
+        # @rbs return: String -- Response content as binary string
+        def response_content: () -> String
+
+        # Continue with authentication
+        # @rbs action: String -- 'provideCredentials', 'default', or 'cancel'
+        # @rbs credentials: Hash[String, untyped]? -- Credentials hash with username and password
+        # @rbs return: untyped
+        def continue_with_auth: (action: String, ?credentials: Hash[String, untyped]?) -> untyped
+
+        def perform_dispose: () -> untyped
+
+        private
+
+        def session: () -> untyped
+
+        def initialize_request: () -> untyped
+      end
+    end
+  end
+end

data/sig/puppeteer/bidi/core/session.rbs

@@ -0,0 +1,65 @@
+# Generated from lib/puppeteer/bidi/core/session.rb with RBS::Inline
+
+module Puppeteer
+  module Bidi
+    module Core
+      # Session represents a BiDi session with the browser
+      # It wraps a Connection and provides session-specific functionality
+      class Session < EventEmitter
+        include Disposable::DisposableMixin
+
+        # Create a new session from an existing connection
+        # @rbs connection: Puppeteer::Bidi::Connection -- The BiDi connection
+        # @rbs capabilities: Hash[String, untyped] -- Session capabilities
+        # @rbs return: Async::Task[Session]
+        def self.from: (connection: Puppeteer::Bidi::Connection, capabilities: Hash[String, untyped]) -> Async::Task[Session]
+
+        attr_reader connection: untyped
+
+        attr_reader id: untyped
+
+        attr_reader capabilities: untyped
+
+        attr_accessor browser: untyped
+
+        def initialize: (untyped connection, untyped info) -> untyped
+
+        # Check if the session has ended
+        def ended?: () -> untyped
+
+        alias disposed? ended?
+
+        # Send a BiDi command through this session
+        # @rbs method: String -- BiDi method name
+        # @rbs params: Hash[String | Symbol, untyped] -- Command parameters
+        # @rbs return: Async::Task[Hash[String, untyped]]
+        def async_send_command: (String method, ?Hash[String | Symbol, untyped] params) -> Async::Task[Hash[String, untyped]]
+
+        # Subscribe to BiDi events
+        # @rbs events: Array[String] -- Event names to subscribe to
+        # @rbs contexts: Array[String]? -- Context IDs (optional)
+        # @rbs return: Async::Task[untyped]
+        def subscribe: (Array[String] events, ?Array[String]? contexts) -> Async::Task[untyped]
+
+        # Add intercepts (same as subscribe but for interception events)
+        # @rbs events: Array[String] -- Event names to intercept
+        # @rbs contexts: Array[String]? -- Context IDs (optional)
+        # @rbs return: Async::Task[untyped]
+        def add_intercepts: (Array[String] events, ?Array[String]? contexts) -> Async::Task[untyped]
+
+        # End the session
+        def end_session: () -> untyped
+
+        def perform_dispose: () -> untyped
+
+        private
+
+        def initialize_session: () -> untyped
+
+        def dispose_session: (untyped reason) -> untyped
+
+        def setup_event_forwarding: () -> untyped
+      end
+    end
+  end
+end

data/sig/puppeteer/bidi/core/user_context.rbs

@@ -0,0 +1,72 @@
+# Generated from lib/puppeteer/bidi/core/user_context.rb with RBS::Inline
+
+module Puppeteer
+  module Bidi
+    module Core
+      # UserContext represents an isolated browsing context (like an incognito session)
+      class UserContext < EventEmitter
+        include Disposable::DisposableMixin
+
+        DEFAULT: ::String
+
+        # Create a user context
+        # @rbs browser: Browser -- Parent browser
+        # @rbs id: String -- Context ID
+        # @rbs return: UserContext
+        def self.create: (Browser browser, String id) -> UserContext
+
+        attr_reader browser: untyped
+
+        attr_reader id: untyped
+
+        def initialize: (untyped browser, untyped id) -> untyped
+
+        # Check if the context is closed
+        def closed?: () -> untyped
+
+        alias disposed? closed?
+
+        # Get all browsing contexts in this user context
+        # @rbs return: Array[BrowsingContext] -- Top-level browsing contexts
+        def browsing_contexts: () -> Array[BrowsingContext]
+
+        # Create a new browsing context (tab or window)
+        # @rbs type: String -- 'tab' or 'window'
+        # @rbs reference_context: BrowsingContext? -- Reference context
+        # @rbs return: BrowsingContext -- New browsing context
+        def create_browsing_context: (String type, **untyped options) -> BrowsingContext
+
+        # Remove this user context
+        def remove: () -> untyped
+
+        # Get cookies for this user context
+        # @rbs source_origin: String? -- Source origin
+        # @rbs return: Array[Hash[String, untyped]] -- Cookies
+        def get_cookies: (**untyped options) -> Array[Hash[String, untyped]]
+
+        # Set a cookie in this user context
+        # @rbs cookie: Hash[String, untyped] -- Cookie data
+        # @rbs source_origin: String? -- Source origin
+        # @rbs return: void
+        def set_cookie: (Hash[String, untyped] cookie, **untyped options) -> void
+
+        # Set permissions for an origin
+        # @rbs origin: String -- Origin URL
+        # @rbs descriptor: Hash[String, untyped] -- Permission descriptor
+        # @rbs state: String -- Permission state
+        # @rbs return: void
+        def set_permissions: (String origin, Hash[String, untyped] descriptor, String state) -> void
+
+        def perform_dispose: () -> untyped
+
+        private
+
+        def session: () -> untyped
+
+        def initialize_context: () -> untyped
+
+        def dispose_context: (untyped reason) -> untyped
+      end
+    end
+  end
+end

data/sig/puppeteer/bidi/core/user_prompt.rbs

@@ -0,0 +1,52 @@
+# Generated from lib/puppeteer/bidi/core/user_prompt.rb with RBS::Inline
+
+module Puppeteer
+  module Bidi
+    module Core
+      # UserPrompt represents a user prompt (alert, confirm, prompt)
+      class UserPrompt < EventEmitter
+        include Disposable::DisposableMixin
+
+        # Create a user prompt instance
+        # @rbs browsing_context: BrowsingContext -- The browsing context
+        # @rbs info: Hash[String, untyped] -- The userPromptOpened event data
+        # @rbs return: UserPrompt -- New user prompt instance
+        def self.from: (BrowsingContext browsing_context, Hash[String, untyped] info) -> UserPrompt
+
+        attr_reader browsing_context: untyped
+
+        attr_reader info: untyped
+
+        attr_reader result: untyped
+
+        def initialize: (untyped browsing_context, untyped info) -> untyped
+
+        # Check if the prompt is closed
+        def closed?: () -> untyped
+
+        alias disposed? closed?
+
+        # Check if the prompt has been handled
+        # Auto-handled prompts return true immediately
+        # @rbs return: bool -- Whether the prompt is handled
+        def handled?: () -> bool
+
+        # Handle the user prompt
+        # @rbs accept: bool? -- Whether to accept the prompt
+        # @rbs user_text: String? -- Text to enter (for prompt dialogs)
+        # @rbs return: Hash[String, untyped] -- Result of handling the prompt
+        def handle: (?accept: bool?, ?user_text: String?) -> Hash[String, untyped]
+
+        def perform_dispose: () -> untyped
+
+        private
+
+        def session: () -> untyped
+
+        def initialize_prompt: () -> untyped
+
+        def dispose_prompt: (untyped reason) -> untyped
+      end
+    end
+  end
+end

data/sig/puppeteer/bidi/core.rbs

@@ -0,0 +1,9 @@
+# Generated from lib/puppeteer/bidi/core.rb with RBS::Inline
+
+module Puppeteer
+  module Bidi
+    # Core module containing low-level BiDi protocol classes
+    module Core
+    end
+  end
+end

data/sig/puppeteer/bidi/deserializer.rbs

@@ -0,0 +1,28 @@
+# Generated from lib/puppeteer/bidi/deserializer.rb with RBS::Inline
+
+module Puppeteer
+  module Bidi
+    # Deserializer converts BiDi Script.RemoteValue to Ruby values
+    # Based on Puppeteer's Deserializer.ts
+    class Deserializer
+      # Deserialize a BiDi RemoteValue to Ruby value
+      # @param remote_value [Hash] BiDi RemoteValue
+      # @param realm [Core::Realm, nil] Realm for creating handles (optional)
+      # @return [Object] Ruby value or JSHandle/ElementHandle if realm provided
+      def self.deserialize: (untyped remote_value, ?untyped realm) -> untyped
+
+      # Deserialize a BiDi number value (handles special strings)
+      private def self.deserialize_number: (untyped value) -> untyped
+
+      # Deserialize BiDi object (array of [key, value] tuples) to Ruby Hash
+      private def self.deserialize_object: (untyped tuples, untyped realm) -> untyped
+
+      # Deserialize BiDi map (array of [key, value] tuples) to Ruby Hash
+      # Maps can have non-string keys, so we deserialize keys too
+      private def self.deserialize_map: (untyped tuples, untyped realm) -> untyped
+
+      # Deserialize BiDi regexp to Ruby Regexp
+      private def self.deserialize_regexp: (untyped value) -> untyped
+    end
+  end
+end

data/sig/puppeteer/bidi/element_handle.rbs

@@ -63,75 +63,75 @@ module Puppeteer
       end
 
       # Factory method to create ElementHandle from remote value
-      # @rbs remote_value: Hash[String, untyped]
-      # @rbs realm: Core::Realm
-      # @rbs return: ElementHandle
+      # @rbs remote_value: Hash[String, untyped] -- BiDi RemoteValue
+      # @rbs realm: Core::Realm -- Associated realm
+      # @rbs return: ElementHandle -- ElementHandle instance
       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?
+      # @rbs selector: String -- Selector to query
+      # @rbs return: ElementHandle? -- Matching element or nil
       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]
+      # @rbs selector: String -- Selector to query
+      # @rbs return: Array[ElementHandle] -- All matching elements
       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
+      # @rbs selector: String -- Selector to query
+      # @rbs page_function: String -- JavaScript function to evaluate
+      # @rbs *args: untyped -- Arguments to pass to the function
+      # @rbs return: untyped -- Evaluation result
       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
+      # @rbs selector: String -- Selector to query
+      # @rbs page_function: String -- JavaScript function to evaluate
+      # @rbs *args: untyped -- Arguments to pass to the function
+      # @rbs return: untyped -- Evaluation result
       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?
+      # @rbs selector: String -- Selector to wait for
+      # @rbs visible: bool? -- Wait for element to be visible
+      # @rbs hidden: bool? -- Wait for element to be hidden
+      # @rbs timeout: Numeric? -- Wait timeout in ms
+      # @rbs &block: ((ElementHandle?) -> void)? -- Optional block called with element
+      # @rbs return: ElementHandle? -- Element or nil if hidden
       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 button: String -- Mouse button ('left', 'right', 'middle')
+      # @rbs count: Integer -- Number of clicks
+      # @rbs delay: Numeric? -- Delay between clicks in ms
+      # @rbs offset: Hash[Symbol, Numeric]? -- Click offset from element center
       # @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 text: String -- Text to type
+      # @rbs delay: Numeric -- Delay between key presses in ms
       # @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 key: String -- Key to press
+      # @rbs delay: Numeric? -- Delay between keydown and keyup in ms
+      # @rbs text: String? -- Text to send with key press
       # @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
+      # @rbs return: Frame -- Owning 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?
+      # @rbs return: Frame? -- Content frame or nil
       def content_frame: () -> Frame?
 
       # Check if the element is visible
@@ -139,7 +139,7 @@ module Puppeteer
       # - 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
+      # @rbs return: bool -- Whether element is visible
       def visible?: () -> bool
 
       # Check if the element is hidden
@@ -147,13 +147,13 @@ module Puppeteer
       # - It has no computed styles
       # - Its visibility is 'hidden' or 'collapse'
       # - Its bounding box is empty (width == 0 OR height == 0)
-      # @rbs return: bool
+      # @rbs return: bool -- Whether element is hidden
       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
+      # @rbs tag_name: String -- Expected tag name
+      # @rbs return: ElementHandle -- This element if matching
       def to_element: (String tag_name) -> ElementHandle
 
       # Focus the element
@@ -167,12 +167,12 @@ module Puppeteer
 
       # Upload files to this element (for <input type="file">)
       # Following Puppeteer's implementation: ElementHandle.uploadFile -> Frame.setFiles
-      # @rbs *files: String
+      # @rbs *files: String -- File paths to upload
       # @rbs return: void
       def upload_file: (*String files) -> void
 
       # Get the remote value as a SharedReference for BiDi commands
-      # @rbs return: Hash[Symbol, String]
+      # @rbs return: Hash[Symbol, String] -- SharedReference for BiDi
       def remote_value_as_shared_reference: () -> Hash[Symbol, String]
 
       # Scroll element into view if needed
@@ -184,54 +184,54 @@ module Puppeteer
       def scroll_into_view: () -> void
 
       # Check if element is intersecting the viewport
-      # @rbs threshold: Numeric
-      # @rbs return: bool
+      # @rbs threshold: Numeric -- Intersection ratio threshold
+      # @rbs return: bool -- Whether element intersects viewport
       def intersecting_viewport?: (?threshold: Numeric) -> bool
 
       # Get clickable point for the element
-      # @rbs offset: Hash[Symbol, Numeric]?
-      # @rbs return: Point
+      # @rbs offset: Hash[Symbol, Numeric]? -- Offset from element center
+      # @rbs return: Point -- Clickable point coordinates
       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?
+      # @rbs return: BoundingBox? -- Bounding box or nil if not visible
       def bounding_box: () -> BoundingBox?
 
       # Get the box model of the element (content, padding, border, margin)
-      # @rbs return: BoxModel?
+      # @rbs return: BoxModel? -- Box model or nil if not visible
       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]?
+      # @rbs return: Hash[Symbol, Numeric]? -- Clickable box or nil
       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 boxes: Array[Hash[String, Numeric]] -- Bounding boxes to clip
       # @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 box: Hash[String, Numeric] -- Box to clip
+      # @rbs width: Numeric -- Viewport width
+      # @rbs height: Numeric -- Viewport height
       # @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
+      # @rbs visible: bool -- Expected visibility state
+      # @rbs return: bool -- Whether element matches visibility state
       def check_visibility: (bool visible) -> bool
 
       # String representation includes element type
-      # @rbs return: String
+      # @rbs return: String -- String representation
       def to_s: () -> String
     end
   end

data/sig/puppeteer/bidi/errors.rbs

@@ -0,0 +1,34 @@
+# Generated from lib/puppeteer/bidi/errors.rb with RBS::Inline
+
+module Puppeteer
+  module Bidi
+    class Error < StandardError
+    end
+
+    # Raised when attempting to use a disposed JSHandle or ElementHandle
+    class JSHandleDisposedError < Error
+      def initialize: () -> untyped
+    end
+
+    # Raised when attempting to use a closed Page
+    class PageClosedError < Error
+      def initialize: () -> untyped
+    end
+
+    # Raised when attempting to use a detached Frame
+    class FrameDetachedError < Error
+      def initialize: (?untyped message) -> untyped
+    end
+
+    # Raised when a selector does not match any elements
+    class SelectorNotFoundError < Error
+      attr_reader selector: untyped
+
+      def initialize: (untyped selector) -> untyped
+    end
+
+    # Raised when a timeout occurs (e.g., navigation timeout)
+    class TimeoutError < Error
+    end
+  end
+end

data/sig/puppeteer/bidi/file_chooser.rbs

@@ -0,0 +1,27 @@
+# Generated from lib/puppeteer/bidi/file_chooser.rb with RBS::Inline
+
+module Puppeteer
+  module Bidi
+    # FileChooser represents a file chooser dialog opened by an input element
+    # Based on Puppeteer's FileChooser implementation
+    class FileChooser
+      # @param element [ElementHandle] The input element that opened the file chooser
+      # @param multiple [Boolean] Whether multiple files can be selected
+      def initialize: (untyped element, untyped multiple) -> untyped
+
+      # Check if multiple files can be selected
+      # @return [Boolean] True if multiple files can be selected
+      def multiple?: () -> untyped
+
+      # Accept the file chooser with the given file paths
+      # @param paths [Array<String>] File paths to accept
+      # @raise [RuntimeError] If the file chooser has already been handled
+      # @raise [RuntimeError] If multiple files passed to single-file input
+      def accept: (untyped paths) -> untyped
+
+      # Cancel the file chooser
+      # @raise [RuntimeError] If the file chooser has already been handled
+      def cancel: () -> untyped
+    end
+  end
+end