puppeteer-bidi 0.0.1.beta1 → 0.0.1.beta2

data/lib/puppeteer/bidi/target.rb

@@ -1,78 +1,105 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
 module Puppeteer
   module Bidi
+    # @rbs!
+    #   type Target = BrowserTarget | PageTarget | FrameTarget
+
     class BrowserTarget
+      # @rbs browser: Browser
+      # @rbs return: void
       def initialize(browser)
         @browser = browser
       end
 
+      # @rbs return: nil
       def page
         nil
       end
 
+      # @rbs return: String
       def url
         ''
       end
 
+      # @rbs return: String
       def type
         'browser'
       end
 
+      # @rbs return: Browser
       def browser
         @browser
       end
 
+      # @rbs return: BrowserContext
       def browser_context
         @browser.default_browser_context
       end
     end
 
     class PageTarget
+      # @rbs page: Page
+      # @rbs return: void
       def initialize(page)
         @page = page
       end
 
+      # @rbs return: Page
       def page
         @page
       end
 
+      # @rbs return: String
       def url
         @page.url
       end
 
+      # @rbs return: String
       def type
         'page'
       end
 
+      # @rbs return: Browser
       def browser
         @page.browser_context.browser
       end
 
+      # @rbs return: BrowserContext
       def browser_context
         @page.browser_context
       end
     end
 
     class FrameTarget
+      # @rbs frame: Frame
+      # @rbs return: void
       def initialize(frame)
         @frame = frame
       end
 
+      # @rbs return: Page
       def page
         @frame.page
       end
 
+      # @rbs return: String
       def url
         @frame.url
       end
 
+      # @rbs return: String
       def type
         'frame'
       end
 
+      # @rbs return: Browser
       def browser
         @frame.browser_context.browser
       end
 
+      # @rbs return: BrowserContext
       def browser_context
         @frame.browser_context
       end

data/lib/puppeteer/bidi/timeout_settings.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rbs_inline: enabled
 
 module Puppeteer
   module Bidi

data/lib/puppeteer/bidi/transport.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rbs_inline: enabled
 
 require 'async'
 require 'async/websocket/client'

data/lib/puppeteer/bidi/version.rb

@@ -2,6 +2,6 @@
 
 module Puppeteer
   module Bidi
-    VERSION = "0.0.1.beta1"
+    VERSION = "0.0.1.beta2"
   end
 end

data/lib/puppeteer/bidi/wait_task.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rbs_inline: enabled
 
 module Puppeteer
   module Bidi

data/lib/puppeteer/bidi.rb

@@ -32,16 +32,25 @@ require "puppeteer/bidi/browser"
 
 module Puppeteer
   module Bidi
+    # @rbs!
+    #   type launch_options = {
+    #     ?executable_path: String,
+    #     ?user_data_dir: String,
+    #     ?headless: bool,
+    #     ?args: Array[String],
+    #     ?timeout: Numeric
+    #   }
+
     # Launch a new browser instance
-    # @rbs **options: untyped
-    # @rbs return: Browser
+    # @rbs **options: launch_options -- Launch options
+    # @rbs return: Browser -- Browser instance
     def self.launch(**options)
       Browser.launch(**options)
     end
 
     # Connect to an existing browser instance
-    # @rbs ws_endpoint: String
-    # @rbs return: Browser
+    # @rbs ws_endpoint: String -- WebSocket endpoint URL
+    # @rbs return: Browser -- Browser instance
     def self.connect(ws_endpoint)
       Browser.connect(ws_endpoint)
     end

data/sig/_external.rbs

@@ -0,0 +1,134 @@
+# External dependencies stub definitions
+# These types are from external gems and standard library extensions
+
+# Async gem adds these methods to Kernel
+module Kernel
+  def Async: [T] () { (Async::Task[T]) -> T } -> Async::Task[T]
+  def Sync: [T] () { () -> T } -> T
+end
+
+module Async
+  def self.call: [T] () { () -> T } -> Task[T]
+
+  class Task[T]
+    def wait: () -> T
+    def sleep: (Numeric) -> void
+    def stop: () -> void
+    def with_timeout: [U] (Numeric) { () -> U } -> U
+  end
+
+  class Promise[T]
+    def initialize: () -> void
+    def wait: () -> T
+    def resolve: (T) -> void
+    def reject: (Exception) -> void
+    def resolved?: () -> bool
+  end
+
+  class TimeoutError < StandardError
+  end
+
+  class Stop < Exception
+  end
+
+  class Barrier
+    def initialize: () -> void
+    def async: () { () -> untyped } -> void
+    def wait: () -> void
+    def stop: () -> void
+  end
+
+  module HTTP
+    class Client
+    end
+
+    class Endpoint
+      def self.parse: (String) -> Endpoint
+    end
+
+    module Protocol
+      module HTTP1
+        class Client
+        end
+      end
+    end
+  end
+
+  class WebSocket
+    class Client
+    end
+
+    class Connection
+      def write: (untyped) -> void
+      def read: () -> untyped
+      def close: () -> void
+    end
+  end
+end
+
+class Thread
+  class Mutex
+    def synchronize: [T] () { () -> T } -> T
+  end
+end
+
+module Protocol
+  module WebSocket
+    class TextMessage
+      attr_reader buffer: String
+    end
+
+    class BinaryMessage
+    end
+
+    class CloseFrame
+    end
+
+    class PingFrame
+    end
+
+    class PongFrame
+    end
+  end
+end
+
+# Open3 extensions
+module Open3
+  def self.popen3: (*String) -> [IO, IO, IO, Thread]
+end
+
+# Singleton module
+module Singleton
+  def self.included: (Class) -> void
+
+  module SingletonClassMethods
+    def instance: () -> instance
+  end
+end
+
+# Dir extensions (tmpdir library)
+class Dir
+  def self.mktmpdir: (String) -> String
+                   | (String) { (String) -> untyped } -> untyped
+end
+
+# Time extensions (time library)
+class Time
+  def self.parse: (String) -> Time
+end
+
+# Date/DateTime extensions
+class Date
+  def to_time: () -> Time
+end
+
+class DateTime
+  def to_time: () -> Time
+end
+
+# Puppeteer::Bidi types that rbs-inline doesn't generate correctly
+module Puppeteer
+  module Bidi
+    type target = BrowserTarget | PageTarget | FrameTarget
+  end
+end

data/sig/_supplementary.rbs

@@ -0,0 +1,20 @@
+# Supplementary type declarations for types that rbs-inline cannot generate
+# This file is NOT auto-generated and should be manually maintained
+
+# AsyncUtils uses `extend self` to make instance methods callable as singleton methods
+module Puppeteer
+  module Bidi
+    module AsyncUtils
+      extend AsyncUtils
+    end
+  end
+end
+
+# QueryHandler uses Singleton pattern
+module Puppeteer
+  module Bidi
+    class QueryHandler
+      extend Singleton::SingletonClassMethods
+    end
+  end
+end

data/sig/puppeteer/bidi/async_utils.rbs

@@ -0,0 +1,68 @@
+# Generated from lib/puppeteer/bidi/async_utils.rb with RBS::Inline
+
+module Puppeteer
+  module Bidi
+    # Utility methods for working with Async tasks
+    # Provides Promise.all and Promise.race equivalents using Async::Barrier
+    module AsyncUtils
+      def await: (untyped task) -> untyped
+
+      # Execute a task with a timeout using Async::Task#with_timeout
+      # @param timeout_ms [Numeric] Timeout duration in milliseconds
+      # @param task [Proc, Async::Promise, nil] Task to execute; falls back to block
+      # @yield [async_task] Execute a task within the timeout, optionally receiving Async::Task
+      # @return [Async::Task] Async task that resolves/rejects once the operation completes
+      def async_timeout: (untyped timeout_ms, ?untyped task) ?{ (?) -> untyped } -> untyped
+
+      def promise_all: (*untyped tasks) -> untyped
+
+      # Wait for all async tasks to complete and return results
+      # Similar to Promise.all in JavaScript
+      # @param tasks [Array<Proc, Async::Promise>] Array of procs or promises
+      # @return [Array] Array of results in the same order as the input tasks
+      # @raise If any task raises an exception, it will be propagated
+      # @example With procs
+      #   results = AsyncUtils.await_promise_all(
+      #     -> { sleep 0.1; "first" },
+      #     -> { sleep 0.2; "second" },
+      #     -> { sleep 0.05; "third" }
+      #   )
+      #   # => ["first", "second", "third"]
+      # @example With promises
+      #   promise1 = Async::Promise.new
+      #   promise2 = Async::Promise.new
+      #   Thread.new { sleep 0.1; promise1.resolve("first") }
+      #   Thread.new { sleep 0.2; promise2.resolve("second") }
+      #   results = AsyncUtils.await_promise_all(promise1, promise2)
+      #   # => ["first", "second"]
+      def await_promise_all: (*untyped tasks) -> untyped
+
+      def promise_race: (*untyped tasks) -> untyped
+
+      # Race multiple async tasks and return the result of the first one to complete
+      # Similar to Promise.race in JavaScript
+      # @param tasks [Array<Proc, Async::Promise>] Array of procs or promises
+      # @return The result of the first task to complete
+      # @example With procs
+      #   result = AsyncUtils.await_promise_race(
+      #     -> { sleep 1; "slow" },
+      #     -> { sleep 0.1; "fast" }
+      #   )
+      #   # => "fast"
+      # @example With promises
+      #   promise1 = Async::Promise.new
+      #   promise2 = Async::Promise.new
+      #   Thread.new { sleep 0.3; promise1.resolve("slow") }
+      #   Thread.new { sleep 0.1; promise2.resolve("fast") }
+      #   result = AsyncUtils.await_promise_race(promise1, promise2)
+      #   # => "fast"
+      def await_promise_race: (*untyped tasks) -> untyped
+
+      private
+
+      def zip: (*untyped tasks) -> untyped
+
+      def first: (*untyped tasks) -> untyped
+    end
+  end
+end

data/sig/puppeteer/bidi/browser.rbs

@@ -10,38 +10,45 @@ module Puppeteer
 
       attr_reader default_browser_context: BrowserContext
 
-      # @rbs connection: Connection
-      # @rbs launcher: BrowserLauncher?
-      # @rbs return: Browser
+      # @rbs connection: Connection -- BiDi connection
+      # @rbs launcher: BrowserLauncher? -- Browser launcher instance
+      # @rbs return: Browser -- Browser instance
       def self.create: (connection: Connection, ?launcher: BrowserLauncher?) -> Browser
 
-      # @rbs connection: Connection
-      # @rbs launcher: BrowserLauncher?
-      # @rbs core_browser: Core::Browser
-      # @rbs session: Core::Session
+      # @rbs connection: Connection -- BiDi connection
+      # @rbs launcher: BrowserLauncher? -- Browser launcher instance
+      # @rbs core_browser: Core::Browser -- Core browser instance
+      # @rbs session: Core::Session -- BiDi session
       # @rbs return: void
       def initialize: (connection: Connection, launcher: BrowserLauncher?, core_browser: Core::Browser, session: Core::Session) -> void
 
+      type launch_options = { ?executable_path: String, ?user_data_dir: String, ?headless: bool, ?args: Array[String], ?timeout: Numeric }
+
       # Launch a new Firefox browser instance
-      # @rbs **options: untyped
-      # @rbs return: Browser
-      def self.launch: (**untyped options) -> Browser
+      # @rbs **options: launch_options -- Launch options
+      # @rbs return: Browser -- Browser instance
+      def self.launch: (**launch_options options) -> Browser
+
+      # Connect to an existing Firefox browser instance
+      # @rbs ws_endpoint: String -- WebSocket endpoint URL
+      # @rbs return: Browser -- Browser instance
+      def self.connect: (String ws_endpoint) -> Browser
 
       # Get BiDi session status
-      # @rbs return: untyped
+      # @rbs return: untyped -- Session status
       def status: () -> untyped
 
       # Create a new page (Puppeteer-like API)
-      # @rbs return: Page
+      # @rbs return: Page -- New page instance
       def new_page: () -> Page
 
       # Get all pages
-      # @rbs return: Array[Page]
+      # @rbs return: Array[Page] -- All pages
       def pages: () -> Array[Page]
 
       # Register event handler
-      # @rbs event: String | Symbol
-      # @rbs &block: (untyped) -> void
+      # @rbs event: String | Symbol -- Event name
+      # @rbs &block: (untyped) -> void -- Event handler
       # @rbs return: void
       def on: (String | Symbol event) { (untyped) -> void } -> void
 
@@ -53,10 +60,10 @@ module Puppeteer
       def closed?: () -> bool
 
       # Wait until a target (top-level browsing context) satisfies the predicate.
-      # @rbs timeout: Integer?
-      # @rbs &predicate: (Target) -> boolish
-      # @rbs return: Target
-      def wait_for_target: (?timeout: Integer?) { (Target) -> boolish } -> Target
+      # @rbs timeout: Integer? -- Timeout in milliseconds (default: 30000)
+      # @rbs &predicate: (target) -> boolish -- Predicate evaluated against each Target
+      # @rbs return: target -- Matching target
+      def wait_for_target: (?timeout: Integer?) { (target) -> boolish } -> target
 
       # Wait for browser process to exit
       # @rbs return: void
@@ -64,16 +71,16 @@ module Puppeteer
 
       private
 
-      # @rbs &block: (Target) -> void
-      # @rbs return: Enumerator[Target, void]
-      def each_target: () { (Target) -> void } -> Enumerator[Target, void]
+      # @rbs &block: (target) -> void -- Block to yield each target to
+      # @rbs return: Enumerator[target, void] -- Enumerator of targets
+      def each_target: () { (target) -> void } -> Enumerator[target, void]
 
-      # @rbs predicate: (Target) -> boolish
-      # @rbs return: Target?
-      def find_target: (Target predicate) -> Target?
+      # @rbs predicate: ^(target) -> boolish -- Predicate to match targets
+      # @rbs return: target? -- Matching target or nil
+      def find_target: (^(target) -> boolish predicate) -> target?
 
-      # @rbs user_context: Core::UserContext
-      # @rbs return: BrowserContext?
+      # @rbs user_context: Core::UserContext -- User context to get browser context for
+      # @rbs return: BrowserContext? -- Browser context or nil
       def browser_context_for: (Core::UserContext user_context) -> BrowserContext?
     end
   end

data/sig/puppeteer/bidi/browser_context.rbs

@@ -0,0 +1,39 @@
+# Generated from lib/puppeteer/bidi/browser_context.rb with RBS::Inline
+
+module Puppeteer
+  module Bidi
+    # BrowserContext represents an isolated browsing session
+    # This is a high-level wrapper around Core::UserContext
+    class BrowserContext
+      attr_reader user_context: Core::UserContext
+
+      attr_reader browser: Browser
+
+      # @rbs browser: Browser -- Parent browser instance
+      # @rbs user_context: Core::UserContext -- Associated user context
+      # @rbs return: void
+      def initialize: (Browser browser, Core::UserContext user_context) -> void
+
+      # Create a new page (tab/window)
+      # @rbs return: Page -- New page instance
+      def new_page: () -> Page
+
+      # Get all pages in this context
+      # @rbs return: Array[Page] -- All pages
+      def pages: () -> Array[Page]
+
+      # Get or create a Page for the given browsing context
+      # @rbs browsing_context: Core::BrowsingContext -- Browsing context
+      # @rbs return: Page -- Page instance
+      def page_for: (Core::BrowsingContext browsing_context) -> Page
+
+      # Close the browser context
+      # @rbs return: void
+      def close: () -> void
+
+      # Check if context is closed
+      # @rbs return: bool -- Whether the context is closed
+      def closed?: () -> bool
+    end
+  end
+end

data/sig/puppeteer/bidi/browser_launcher.rbs

@@ -0,0 +1,45 @@
+# Generated from lib/puppeteer/bidi/browser_launcher.rb with RBS::Inline
+
+module Puppeteer
+  module Bidi
+    # BrowserLauncher handles launching Firefox with BiDi support
+    class BrowserLauncher
+      class LaunchError < Error
+      end
+
+      attr_reader executable_path: untyped
+
+      attr_reader user_data_dir: untyped
+
+      def initialize: (?executable_path: untyped, ?user_data_dir: untyped, ?headless: untyped, ?args: untyped) -> untyped
+
+      # Launch Firefox and return BiDi WebSocket endpoint
+      # @return [String] WebSocket endpoint URL
+      def launch: () -> untyped
+
+      # Kill the Firefox process
+      def kill: () -> untyped
+
+      # Wait for process to exit
+      def wait: () -> untyped
+
+      private
+
+      def find_firefox: () -> untyped
+
+      def setup_user_data_dir: () -> untyped
+
+      def create_prefs_file: () -> untyped
+
+      def default_prefs: () -> untyped
+
+      def cleanup_temp_user_data_dir: () -> untyped
+
+      def find_available_port: () -> untyped
+
+      def build_launch_args: (untyped port) -> untyped
+
+      def wait_for_ws_endpoint: (untyped port, untyped stdout, untyped stderr, ?timeout: untyped) -> untyped
+    end
+  end
+end

data/sig/puppeteer/bidi/connection.rbs

@@ -0,0 +1,67 @@
+# Generated from lib/puppeteer/bidi/connection.rb with RBS::Inline
+
+module Puppeteer
+  module Bidi
+    # Connection manages BiDi protocol communication
+    # Handles command sending, response waiting, and event dispatching
+    class Connection
+      class TimeoutError < Error
+      end
+
+      class ProtocolError < Error
+      end
+
+      DEFAULT_TIMEOUT: Integer
+
+      # @rbs transport: Transport
+      # @rbs return: void
+      def initialize: (Transport transport) -> void
+
+      # Send a BiDi command and wait for response
+      # @rbs method: String
+      # @rbs params: Hash[String | Symbol, untyped]
+      # @rbs timeout: Integer
+      # @rbs return: Async::Task[Hash[String, untyped]]
+      def async_send_command: (String method, ?Hash[String | Symbol, untyped] params, ?timeout: Integer) -> Async::Task[Hash[String, untyped]]
+
+      # Subscribe to BiDi events
+      # @rbs event: String
+      # @rbs &block: (untyped) -> void
+      # @rbs return: void
+      def on: (String event) { (untyped) -> void } -> void
+
+      # Unsubscribe from BiDi events
+      # @rbs event: String
+      # @rbs &block: ((untyped) -> void)?
+      # @rbs return: void
+      def off: (String event) ?{ (?) -> untyped } -> void
+
+      # Close the connection
+      # @rbs return: void
+      def close: () -> void
+
+      # @rbs return: bool
+      def closed?: () -> bool
+
+      private
+
+      # @rbs return: Integer
+      def next_id: () -> Integer
+
+      # @rbs return: void
+      def setup_transport_handlers: () -> void
+
+      # @rbs message: Hash[String, untyped]
+      # @rbs return: void
+      def handle_message: (Hash[String, untyped] message) -> void
+
+      # @rbs message: Hash[String, untyped]
+      # @rbs return: void
+      def handle_response: (Hash[String, untyped] message) -> void
+
+      # @rbs message: Hash[String, untyped]
+      # @rbs return: void
+      def handle_event: (Hash[String, untyped] message) -> void
+    end
+  end
+end