puppeteer-bidi 0.0.1.beta1 → 0.0.1.beta3

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

@@ -0,0 +1,79 @@
+# Generated from lib/puppeteer/bidi/core/browser.rb with RBS::Inline
+
+module Puppeteer
+  module Bidi
+    module Core
+      # Browser represents the browser instance in the core layer
+      # It manages user contexts and provides browser-level operations
+      class Browser < EventEmitter
+        include Disposable::DisposableMixin
+
+        # Create a browser instance from a session
+        # @rbs session: Session -- BiDi session
+        # @rbs return: Async::Task[Browser] -- Browser instance
+        def self.from: (Session session) -> Async::Task[Browser]
+
+        attr_reader session: untyped
+
+        def initialize: (untyped session) -> untyped
+
+        # Check if the browser is closed
+        def closed?: () -> untyped
+
+        # Check if the browser is disconnected
+        def disconnected?: () -> untyped
+
+        alias disposed? disconnected?
+
+        # Get the default user context
+        # @rbs return: UserContext? -- Default user context
+        def default_user_context: () -> UserContext?
+
+        # Get all user contexts
+        # @rbs return: Array[UserContext] -- All user contexts
+        def user_contexts: () -> Array[UserContext]
+
+        # Close the browser
+        # @rbs return: Async::Task[void]
+        def close: () -> Async::Task[void]
+
+        # Add a preload script to the browser
+        # @rbs function_declaration: String -- JavaScript function to preload
+        # @rbs **options: untyped -- Preload script options
+        # @rbs return: Async::Task[String] -- Script ID
+        def add_preload_script: (String function_declaration, **untyped options) -> Async::Task[String]
+
+        # Remove a preload script
+        # @rbs script: String -- Script ID
+        # @rbs return: Async::Task[untyped]
+        def remove_preload_script: (String script) -> Async::Task[untyped]
+
+        # Create a new user context
+        # @rbs **options: untyped -- User context options
+        # @rbs return: Async::Task[UserContext] -- New user context
+        def create_user_context: (**untyped options) -> Async::Task[UserContext]
+
+        # Remove a network intercept
+        # @rbs intercept: String -- Intercept ID
+        # @rbs return: Async::Task[untyped]
+        def remove_intercept: (String intercept) -> Async::Task[untyped]
+
+        def perform_dispose: () -> untyped
+
+        private
+
+        def initialize_browser: () -> untyped
+
+        def sync_user_contexts: () -> untyped
+
+        def sync_browsing_contexts: () -> untyped
+
+        def process_contexts: (untyped contexts, untyped context_ids) -> untyped
+
+        def create_user_context_object: (untyped id) -> untyped
+
+        def dispose_browser: (untyped reason, ?closed: untyped) -> untyped
+      end
+    end
+  end
+end

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

@@ -0,0 +1,210 @@
+# Generated from lib/puppeteer/bidi/core/browsing_context.rb with RBS::Inline
+
+module Puppeteer
+  module Bidi
+    module Core
+      # BrowsingContext represents a browsing context (tab, window, or iframe)
+      class BrowsingContext < EventEmitter
+        include Disposable::DisposableMixin
+
+        # Create a browsing context
+        # @rbs user_context: UserContext -- Parent user context
+        # @rbs parent: BrowsingContext? -- Parent browsing context
+        # @rbs id: String -- Context ID
+        # @rbs url: String -- Initial URL
+        # @rbs original_opener: String? -- Original opener context ID
+        # @rbs return: BrowsingContext -- New browsing context
+        def self.from: (UserContext user_context, BrowsingContext? parent, String id, String url, String? original_opener) -> BrowsingContext
+
+        attr_reader id: untyped
+
+        attr_reader user_context: untyped
+
+        attr_reader parent: untyped
+
+        attr_reader original_opener: untyped
+
+        attr_reader default_realm: untyped
+
+        attr_reader navigation: untyped
+
+        attr_reader inflight_requests: untyped
+
+        def initialize: (untyped user_context, untyped parent, untyped id, untyped url, untyped original_opener) -> untyped
+
+        # Check if the context is closed
+        def closed?: () -> untyped
+
+        alias disposed? closed?
+
+        # Get the current URL
+        # @rbs return: String -- Current URL
+        def url: () -> String
+
+        # Get child browsing contexts
+        # @rbs return: Array[BrowsingContext] -- Child contexts
+        def children: () -> Array[BrowsingContext]
+
+        # Get all realms in this context
+        # @rbs return: Array[WindowRealm] -- All realms
+        def realms: () -> Array[WindowRealm]
+
+        # Get the top-level browsing context
+        # @rbs return: BrowsingContext -- Top-level context
+        def top: () -> BrowsingContext
+
+        # Activate this browsing context
+        def activate: () -> untyped
+
+        # Navigate to a URL
+        # @rbs url: String -- URL to navigate to
+        # @rbs wait: String? -- Wait condition ('none', 'interactive', 'complete')
+        # @rbs return: Async::Task[untyped]
+        def navigate: (String url, ?wait: String?) -> Async::Task[untyped]
+
+        # Reload the page
+        # @rbs **options: untyped -- Reload options
+        # @rbs return: Async::Task[untyped]
+        def reload: (**untyped options) -> Async::Task[untyped]
+
+        # Capture a screenshot
+        # @rbs **options: untyped -- Screenshot options
+        # @rbs return: Async::Task[String] -- Base64-encoded image data
+        def capture_screenshot: (**untyped options) -> Async::Task[String]
+
+        # Print to PDF
+        # @rbs **options: untyped -- Print options
+        # @rbs return: Async::Task[String] -- Base64-encoded PDF data
+        def print: (**untyped options) -> Async::Task[String]
+
+        # Close this browsing context
+        # @rbs prompt_unload: bool -- Whether to prompt before unload
+        # @rbs return: Async::Task[void]
+        def close: (?prompt_unload: bool) -> Async::Task[void]
+
+        # Traverse history
+        # @rbs delta: Integer -- Number of steps to go back (negative) or forward (positive)
+        # @rbs return: Async::Task[untyped]
+        def traverse_history: (Integer delta) -> Async::Task[untyped]
+
+        # Handle a user prompt
+        # @rbs **options: untyped -- Prompt handling options
+        # @rbs return: Async::Task[untyped]
+        def handle_user_prompt: (**untyped options) -> Async::Task[untyped]
+
+        # Set viewport
+        # @rbs **options: untyped -- Viewport options
+        # @rbs return: Async::Task[untyped]
+        def set_viewport: (**untyped options) -> Async::Task[untyped]
+
+        # Perform input actions
+        # @rbs actions: Array[Hash[String, untyped]] -- Input actions
+        # @rbs return: Async::Task[untyped]
+        def perform_actions: (Array[Hash[String, untyped]] actions) -> Async::Task[untyped]
+
+        # Release input actions
+        def release_actions: () -> untyped
+
+        # Set cache behavior
+        # @rbs cache_behavior: String -- 'default' or 'bypass'
+        # @rbs return: Async::Task[untyped]
+        def set_cache_behavior: (String cache_behavior) -> Async::Task[untyped]
+
+        # Create a sandboxed window realm
+        # @rbs sandbox: String -- Sandbox name
+        # @rbs return: WindowRealm -- New realm
+        def create_window_realm: (String sandbox) -> WindowRealm
+
+        # Add a preload script to this context
+        # @rbs function_declaration: String -- JavaScript function
+        # @rbs **options: untyped -- Script options
+        # @rbs return: Async::Task[String] -- Script ID
+        def add_preload_script: (String function_declaration, **untyped options) -> Async::Task[String]
+
+        # Remove a preload script
+        # @rbs script: String -- Script ID
+        # @rbs return: Async::Task[untyped]
+        def remove_preload_script: (String script) -> Async::Task[untyped]
+
+        # Add network intercept
+        # @rbs **options: untyped -- Intercept options
+        # @rbs return: String -- Intercept ID
+        def add_intercept: (**untyped options) -> String
+
+        # Get cookies
+        # @rbs **options: untyped -- Cookie filter options
+        # @rbs return: Array[Hash[String, untyped]] -- Cookies
+        def get_cookies: (**untyped options) -> Array[Hash[String, untyped]]
+
+        # Set a cookie
+        # @rbs cookie: Hash[String, untyped] -- Cookie data
+        # @rbs return: Async::Task[untyped]
+        def set_cookie: (Hash[String, untyped] cookie) -> Async::Task[untyped]
+
+        # Delete cookies
+        # @rbs *cookie_filters: Hash[String, untyped] -- Cookie filters
+        # @rbs return: void
+        def delete_cookie: (*Hash[String, untyped] cookie_filters) -> void
+
+        # Set geolocation override
+        # @rbs **options: untyped -- Geolocation options
+        # @rbs return: Async::Task[untyped]
+        def set_geolocation_override: (**untyped options) -> Async::Task[untyped]
+
+        # Set timezone override
+        # @rbs timezone_id: String? -- Timezone ID
+        # @rbs return: Async::Task[untyped]
+        def set_timezone_override: (?String? timezone_id) -> Async::Task[untyped]
+
+        # Set files on an input element
+        # @rbs element: Hash[String, untyped] -- Element reference
+        # @rbs files: Array[String] -- File paths
+        # @rbs return: Async::Task[untyped]
+        def set_files: (Hash[String, untyped] element, Array[String] files) -> Async::Task[untyped]
+
+        # Locate nodes in the context
+        # @rbs locator: Hash[String, untyped] -- Node locator
+        # @rbs start_nodes: Array[Hash[String, untyped]] -- Starting nodes
+        # @rbs return: Array[Hash[String, untyped]] -- Located nodes
+        def locate_nodes: (Hash[String, untyped] locator, ?Array[Hash[String, untyped]] start_nodes) -> Array[Hash[String, untyped]]
+
+        # Set JavaScript enabled state
+        # @rbs enabled: bool -- Whether JavaScript is enabled
+        # @rbs return: Async::Task[void]
+        def set_javascript_enabled: (bool enabled) -> Async::Task[void]
+
+        # Check if JavaScript is enabled
+        # @rbs return: bool -- Whether JavaScript is enabled
+        def javascript_enabled?: () -> bool
+
+        # Subscribe to events for this context
+        # @rbs events: Array[String] -- Event names
+        # @rbs return: void
+        def subscribe: (Array[String] events) -> void
+
+        # Add interception for this context
+        # @rbs events: Array[String] -- Event names
+        # @rbs return: void
+        def add_interception: (Array[String] events) -> void
+
+        # Override dispose to emit :closed event before setting @disposed = true
+        # This is needed because EventEmitter#emit returns early if @disposed is true
+        def dispose: () -> untyped
+
+        def perform_dispose: () -> untyped
+
+        private
+
+        def session: () -> untyped
+
+        def initialize_context: () -> untyped
+
+        def setup_event_listeners: () -> untyped
+
+        def dispose_children: (untyped reason) -> untyped
+
+        def dispose_context: (untyped reason) -> untyped
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# Generated from lib/puppeteer/bidi/core/disposable.rb with RBS::Inline
+
+module Puppeteer
+  module Bidi
+    module Core
+      # Disposable provides resource management and cleanup capabilities
+      # Similar to TypeScript's DisposableStack
+      module Disposable
+        # DisposableStack manages multiple disposable resources
+        class DisposableStack
+          # @rbs return: void
+          def initialize: () -> void
+
+          # Add a disposable resource to the stack
+          # @rbs resource: untyped -- Resource that responds to #dispose
+          # @rbs return: untyped -- The resource itself for convenience
+          def use: (untyped resource) -> untyped
+
+          # Dispose all resources in reverse order (LIFO)
+          # @rbs return: void
+          def dispose: () -> void
+
+          # @rbs return: bool
+          def disposed?: () -> bool
+        end
+
+        # Module to be included in classes that need disposal
+        module DisposableMixin
+          # @rbs return: void
+          def dispose: () -> void
+
+          # @rbs return: bool
+          def disposed?: () -> bool
+
+          # Override this method to perform cleanup
+          # @rbs return: void
+          def perform_dispose: () -> void
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# Generated from lib/puppeteer/bidi/core/errors.rb with RBS::Inline
+
+module Puppeteer
+  module Bidi
+    module Core
+      # Base error class for Core module
+      class Error < Puppeteer::Bidi::Error
+      end
+
+      # Raised when attempting to use a disposed resource
+      class DisposedError < Error
+        attr_reader resource_type: String
+
+        attr_reader reason: String
+
+        # @rbs resource_type: String
+        # @rbs reason: String
+        # @rbs return: void
+        def initialize: (String resource_type, String reason) -> void
+      end
+
+      # Raised when a realm has been destroyed
+      class RealmDestroyedError < DisposedError
+        # @rbs reason: String
+        # @rbs return: void
+        def initialize: (String reason) -> void
+      end
+
+      # Raised when a browsing context has been closed
+      class BrowsingContextClosedError < DisposedError
+        # @rbs reason: String
+        # @rbs return: void
+        def initialize: (String reason) -> void
+      end
+
+      # Raised when a user context has been closed
+      class UserContextClosedError < DisposedError
+        # @rbs reason: String
+        # @rbs return: void
+        def initialize: (String reason) -> void
+      end
+
+      # Raised when a user prompt has been closed
+      class UserPromptClosedError < DisposedError
+        # @rbs reason: String
+        # @rbs return: void
+        def initialize: (String reason) -> void
+      end
+
+      # Raised when a session has ended
+      class SessionEndedError < DisposedError
+        # @rbs reason: String
+        # @rbs return: void
+        def initialize: (String reason) -> void
+      end
+
+      # Raised when a browser has been disconnected
+      class BrowserDisconnectedError < DisposedError
+        # @rbs reason: String
+        # @rbs return: void
+        def initialize: (String reason) -> void
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# Generated from lib/puppeteer/bidi/core/event_emitter.rb with RBS::Inline
+
+module Puppeteer
+  module Bidi
+    module Core
+      # EventEmitter provides event subscription and emission capabilities
+      # Similar to Node.js EventEmitter but simpler
+      class EventEmitter
+        # @rbs return: void
+        def initialize: () -> void
+
+        # Register an event listener
+        # @rbs event: Symbol | String -- Event name
+        # @rbs &block: (untyped) -> void -- Event handler
+        # @rbs return: void
+        def on: (Symbol | String event) { (untyped) -> void } -> void
+
+        # Register a one-time event listener
+        # @rbs event: Symbol | String -- Event name
+        # @rbs &block: (untyped) -> void -- Event handler
+        # @rbs return: void
+        def once: (Symbol | String event) { (untyped) -> void } -> void
+
+        # Remove an event listener
+        # @rbs event: Symbol | String -- Event name
+        # @rbs &block: ((untyped) -> void)? -- Event handler to remove
+        # @rbs return: void
+        def off: (Symbol | String event) ?{ (?) -> untyped } -> void
+
+        # Remove all listeners for an event or all events
+        # @rbs event: (Symbol | String)? -- Event name
+        # @rbs return: void
+        def remove_all_listeners: (?(Symbol | String)? event) -> void
+
+        # Emit an event to all registered listeners
+        # @rbs event: Symbol | String -- Event name
+        # @rbs data: untyped -- Event data
+        # @rbs return: void
+        def emit: (Symbol | String event, ?untyped data) -> void
+
+        # Dispose the event emitter
+        # @rbs return: void
+        def dispose: () -> void
+
+        # @rbs return: bool
+        def disposed?: () -> bool
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# Generated from lib/puppeteer/bidi/core/navigation.rb with RBS::Inline
+
+module Puppeteer
+  module Bidi
+    module Core
+      # Navigation represents a single navigation operation
+      class Navigation < EventEmitter
+        include Disposable::DisposableMixin
+
+        # Create a navigation instance
+        # @rbs browsing_context: BrowsingContext -- The browsing context
+        # @rbs return: Navigation -- New navigation instance
+        def self.from: (BrowsingContext browsing_context) -> Navigation
+
+        attr_reader browsing_context: untyped
+
+        attr_reader request: untyped
+
+        def initialize: (untyped browsing_context) -> untyped
+
+        # Get the nested navigation if any
+        # @rbs return: Navigation? -- Nested navigation
+        def navigation: () -> Navigation?
+
+        def perform_dispose: () -> untyped
+
+        private
+
+        def session: () -> untyped
+
+        def initialize_navigation: () -> untyped
+
+        def matches?: (untyped navigation_id) -> untyped
+      end
+    end
+  end
+end

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

@@ -0,0 +1,132 @@
+# Generated from lib/puppeteer/bidi/core/realm.rb with RBS::Inline
+
+module Puppeteer
+  module Bidi
+    module Core
+      # Realm is the base class for script execution realms
+      class Realm < EventEmitter
+        include Disposable::DisposableMixin
+
+        attr_reader id: untyped
+
+        attr_reader origin: untyped
+
+        def initialize: (untyped id, untyped origin) -> untyped
+
+        # Get the target for script execution
+        # @rbs return: Hash[Symbol, untyped] -- BiDi target descriptor
+        def target: () -> Hash[Symbol, untyped]
+
+        # Disown handles (remove references)
+        # @rbs handles: Array[String] -- Handle IDs to disown
+        # @rbs return: Async::Task[untyped]
+        def disown: (Array[String] handles) -> Async::Task[untyped]
+
+        # Call a function in the realm
+        # @rbs function_declaration: String -- Function source code
+        # @rbs await_promise: bool -- Whether to await promise results
+        # @rbs **options: untyped -- Additional options (arguments, serializationOptions, resultOwnership, etc.)
+        # @rbs return: Async::Task[Hash[String, untyped]] -- Evaluation result
+        def call_function: (String function_declaration, bool await_promise, **untyped options) -> Async::Task[Hash[String, untyped]]
+
+        # Evaluate an expression in the realm
+        # @rbs expression: String -- JavaScript expression
+        # @rbs await_promise: bool -- Whether to await promise results
+        # @rbs **options: untyped -- Additional options (serializationOptions, resultOwnership, etc.)
+        # @rbs return: Async::Task[Hash[String, untyped]] -- Evaluation result
+        def evaluate: (String expression, bool await_promise, **untyped options) -> Async::Task[Hash[String, untyped]]
+
+        # Resolve the CDP execution context ID for this realm
+        # @rbs return: Integer -- Execution context ID
+        def resolve_execution_context_id: () -> Integer
+
+        # Abstract method - must be implemented by subclasses
+        # @rbs return: Session -- The session for this realm
+        def session: () -> Session
+
+        def perform_dispose: () -> untyped
+      end
+
+      # WindowRealm represents a JavaScript realm in a window or iframe
+      class WindowRealm < Realm
+        # Create a window realm
+        # @rbs browsing_context: BrowsingContext -- The browsing context
+        # @rbs sandbox: String? -- Sandbox name
+        # @rbs return: WindowRealm -- New window realm
+        def self.from: (BrowsingContext browsing_context, ?String? sandbox) -> WindowRealm
+
+        attr_reader browsing_context: untyped
+
+        attr_reader sandbox: untyped
+
+        def initialize: (untyped browsing_context, ?untyped sandbox) -> untyped
+
+        # Set the environment (Frame) for this realm
+        # This is set by Frame when it's created
+        # @rbs frame: untyped -- The frame environment
+        # @rbs return: void
+        def environment=: (untyped frame) -> void
+
+        # Get the environment (Frame) for this realm
+        # @rbs return: untyped -- The frame environment
+        def environment: () -> untyped
+
+        # Override target to use context-based target
+        # @rbs return: Hash[Symbol, untyped] -- BiDi target descriptor
+        def target: () -> Hash[Symbol, untyped]
+
+        def session: () -> untyped
+
+        private
+
+        def initialize_realm: () -> untyped
+
+        def dispose_realm: (untyped reason) -> untyped
+      end
+
+      # DedicatedWorkerRealm represents a JavaScript realm in a dedicated worker
+      class DedicatedWorkerRealm < Realm
+        # Create a dedicated worker realm
+        # @rbs owner: WindowRealm | DedicatedWorkerRealm | SharedWorkerRealm -- Owner realm
+        # @rbs id: String -- Realm ID
+        # @rbs origin: String -- Realm origin
+        # @rbs return: DedicatedWorkerRealm -- New dedicated worker realm
+        def self.from: (WindowRealm | DedicatedWorkerRealm | SharedWorkerRealm owner, String id, String origin) -> DedicatedWorkerRealm
+
+        attr_reader owners: untyped
+
+        def initialize: (untyped owner, untyped id, untyped origin) -> untyped
+
+        def session: () -> untyped
+
+        private
+
+        def initialize_realm: () -> untyped
+
+        def dispose_realm: (untyped reason) -> untyped
+      end
+
+      # SharedWorkerRealm represents a JavaScript realm in a shared worker
+      class SharedWorkerRealm < Realm
+        # Create a shared worker realm
+        # @rbs browser: Browser -- Browser instance
+        # @rbs id: String -- Realm ID
+        # @rbs origin: String -- Realm origin
+        # @rbs return: SharedWorkerRealm -- New shared worker realm
+        def self.from: (Browser browser, String id, String origin) -> SharedWorkerRealm
+
+        attr_reader browser: untyped
+
+        def initialize: (untyped browser, untyped id, untyped origin) -> untyped
+
+        def session: () -> untyped
+
+        private
+
+        def initialize_realm: () -> untyped
+
+        def dispose_realm: (untyped reason) -> untyped
+      end
+    end
+  end
+end