puppeteer-bidi 0.0.1.beta1

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+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
+        # @param browsing_context [BrowsingContext] The browsing context
+        # @param info [Hash] The userPromptOpened event data
+        # @return [UserPrompt] New user prompt instance
+        def self.from(browsing_context, info)
+          prompt = new(browsing_context, info)
+          prompt.send(:initialize_prompt)
+          prompt
+        end
+
+        attr_reader :browsing_context, :info, :result
+
+        def initialize(browsing_context, info)
+          super()
+          @browsing_context = browsing_context
+          @info = info
+          @reason = nil
+          @result = nil
+          @disposables = Disposable::DisposableStack.new
+        end
+
+        # Check if the prompt is closed
+        def closed?
+          !@reason.nil?
+        end
+
+        alias disposed? closed?
+
+        # Check if the prompt has been handled
+        # Auto-handled prompts return true immediately
+        # @return [Boolean] Whether the prompt is handled
+        def handled?
+          handler = @info['handler']
+          return true if handler == 'accept' || handler == 'dismiss'
+          !@result.nil?
+        end
+
+        # Handle the user prompt
+        # @param accept [Boolean, nil] Whether to accept the prompt
+        # @param user_text [String, nil] Text to enter (for prompt dialogs)
+        # @return [Hash] Result of handling the prompt
+        def handle(accept: nil, user_text: nil)
+          raise UserPromptClosedError, @reason if closed?
+
+          params = { context: @info['context'] }
+          params[:accept] = accept unless accept.nil?
+          params[:userText] = user_text if user_text
+
+          session.send_command('browsingContext.handleUserPrompt', params)
+
+          # The result is set by the userPromptClosed event before this returns
+          @result
+        end
+
+        protected
+
+        def perform_dispose
+          @reason ||= 'User prompt closed, probably because the browsing context was destroyed'
+          emit(:closed, { reason: @reason })
+          @disposables.dispose
+          super
+        end
+
+        private
+
+        def session
+          @browsing_context.user_context.browser.session
+        end
+
+        def initialize_prompt
+          # Listen for browsing context closure
+          @browsing_context.once(:closed) do |data|
+            dispose_prompt("User prompt closed: #{data[:reason]}")
+          end
+
+          # Listen for prompt closed event
+          session.on('browsingContext.userPromptClosed') do |params|
+            next unless params['context'] == @browsing_context.id
+
+            @result = params
+            emit(:handled, params)
+            dispose_prompt('User prompt handled')
+          end
+        end
+
+        def dispose_prompt(reason)
+          @reason = reason
+          dispose
+        end
+      end
+    end
+  end
+end

data/lib/puppeteer/bidi/core.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+# Core module provides low-level BiDi protocol abstractions
+# This layer sits above the WebSocket transport and provides
+# object-oriented semantics around WebDriver BiDi's flat API.
+#
+# Design principles:
+# - Required arguments are method parameters, optional ones are keyword arguments
+# - Session is never exposed on public methods except on Browser
+# - Follows WebDriver BiDi spec strictly, not Puppeteer's needs
+# - Implements BiDi comprehensively but minimally
+
+require 'puppeteer/bidi/core/errors'
+require 'puppeteer/bidi/core/event_emitter'
+require 'puppeteer/bidi/core/disposable'
+require 'puppeteer/bidi/core/request'
+require 'puppeteer/bidi/core/navigation'
+require 'puppeteer/bidi/core/realm'
+require 'puppeteer/bidi/core/session'
+require 'puppeteer/bidi/core/browser'
+require 'puppeteer/bidi/core/user_context'
+require 'puppeteer/bidi/core/browsing_context'
+require 'puppeteer/bidi/core/user_prompt'
+
+module Puppeteer
+  module Bidi
+    # Core module containing low-level BiDi protocol classes
+    module Core
+      # This module provides:
+      # - EventEmitter: Event subscription and emission
+      # - Disposable: Resource management and cleanup
+      # - Session: BiDi session management
+      # - Browser: Browser instance management
+      # - UserContext: Isolated browsing contexts (incognito-like)
+      # - BrowsingContext: Individual tabs/windows/frames
+      # - Navigation: Navigation tracking
+      # - Realm: JavaScript execution contexts
+      #   - WindowRealm: Window/iframe realms
+      #   - DedicatedWorkerRealm: Dedicated worker realms
+      #   - SharedWorkerRealm: Shared worker realms
+      # - Request: Network request management
+      # - UserPrompt: User prompt (alert/confirm/prompt) handling
+    end
+  end
+end

data/lib/puppeteer/bidi/deserializer.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'set'
+
+module Puppeteer
+  module Bidi
+    # Deserializer converts BiDi Script.RemoteValue to Ruby values
+    # Based on Puppeteer's Deserializer.ts
+    class Deserializer
+      class << self
+        # 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 deserialize(remote_value, realm = nil)
+          return remote_value unless remote_value.is_a?(Hash)
+
+          type = remote_value['type']
+
+          case type
+          when 'string'
+            remote_value['value']
+          when 'number'
+            deserialize_number(remote_value['value'])
+          when 'boolean'
+            remote_value['value']
+          when 'null'
+            nil
+          when 'undefined'
+            nil
+          when 'bigint'
+            # BiDi sends bigint as string, convert to Integer
+            remote_value['value'].to_i
+          when 'array'
+            # Deserialize array elements
+            return [] unless remote_value['value']
+            remote_value['value'].map { |item| deserialize(item, realm) }
+          when 'set'
+            # Deserialize set elements and return Ruby Set
+            return Set.new unless remote_value['value']
+            Set.new(remote_value['value'].map { |item| deserialize(item, realm) })
+          when 'object'
+            # Object is an array of [key, value] tuples
+            deserialize_object(remote_value['value'], realm)
+          when 'map'
+            # Map is an array of [key, value] tuples with non-string keys
+            deserialize_map(remote_value['value'], realm)
+          when 'regexp'
+            # Reconstruct Ruby Regexp
+            deserialize_regexp(remote_value['value'])
+          when 'date'
+            # Parse ISO 8601 datetime string
+            Time.parse(remote_value['value'])
+          when 'promise'
+            # Promise placeholder - return empty hash
+            {}
+          when 'node'
+            # DOM node - create ElementHandle if realm provided
+            if realm
+              ElementHandle.new(realm, remote_value)
+            else
+              # Without realm, return the remote value as-is
+              remote_value
+            end
+          else
+            # Unknown type - create JSHandle if realm provided
+            if realm
+              JSHandle.new(realm, remote_value)
+            else
+              # Without realm, return value as-is or nil
+              remote_value['value']
+            end
+          end
+        end
+
+        private
+
+        # Deserialize a BiDi number value (handles special strings)
+        def deserialize_number(value)
+          case value
+          when 'NaN'
+            Float::NAN
+          when 'Infinity'
+            Float::INFINITY
+          when '-Infinity'
+            -Float::INFINITY
+          when '-0'
+            -0.0
+          else
+            value
+          end
+        end
+
+        # Deserialize BiDi object (array of [key, value] tuples) to Ruby Hash
+        def deserialize_object(tuples, realm)
+          return {} unless tuples
+
+          tuples.each_with_object({}) do |(key, value), hash|
+            # Keys in objects are always strings in BiDi
+            hash[key] = deserialize(value, realm)
+          end
+        end
+
+        # Deserialize BiDi map (array of [key, value] tuples) to Ruby Hash
+        # Maps can have non-string keys, so we deserialize keys too
+        def deserialize_map(tuples, realm)
+          return {} unless tuples
+
+          tuples.each_with_object({}) do |pair, hash|
+            key = deserialize(pair[0], realm)
+            value = deserialize(pair[1], realm)
+            hash[key] = value
+          end
+        end
+
+        # Deserialize BiDi regexp to Ruby Regexp
+        def deserialize_regexp(value)
+          pattern = value['pattern']
+          flags_str = value['flags'] || ''
+
+          flags = 0
+          flags |= Regexp::IGNORECASE if flags_str.include?('i')
+          flags |= Regexp::MULTILINE if flags_str.include?('m')
+          flags |= Regexp::EXTENDED if flags_str.include?('x')
+
+          Regexp.new(pattern, flags)
+        end
+      end
+    end
+  end
+end