puppeteer-ruby 0.45.6 → 0.50.0.alpha6

data/sig/puppeteer/http_request.rbs

@@ -0,0 +1,214 @@
+# Generated from lib/puppeteer/http_request.rb with RBS::Inline
+
+class Puppeteer::HTTPRequest
+  include Puppeteer::DebugPrint
+
+  include Puppeteer::IfPresent
+
+  DEFAULT_INTERCEPT_RESOLUTION_PRIORITY: ::Integer
+
+  # defines some methods used only in NetworkManager, Response
+  class InternalAccessor
+    def initialize: (untyped request) -> untyped
+
+    def request_id: () -> untyped
+
+    def client=: (untyped client) -> untyped
+
+    def interception_id: () -> untyped
+
+    # @param response [Puppeteer::HTTPResponse]
+    def response=: (untyped response) -> untyped
+
+    def redirect_chain: () -> untyped
+
+    def failure_text=: (untyped failure_text) -> untyped
+
+    def from_memory_cache=: (untyped from_memory_cache) -> untyped
+
+    def from_memory_cache?: () -> untyped
+  end
+
+  class InterceptResolutionState
+    def self.abort: (?priority: untyped) -> untyped
+
+    def self.respond: (?priority: untyped) -> untyped
+
+    def self.continue: (?priority: untyped) -> untyped
+
+    def self.disabled: (?priority: untyped) -> untyped
+
+    def self.none: (?priority: untyped) -> untyped
+
+    def self.already_handled: (?priority: untyped) -> untyped
+
+    private def initialize: (action: untyped, priority: untyped) -> untyped
+
+    def priority_unspecified?: () -> untyped
+
+    attr_reader action: untyped
+
+    attr_reader priority: untyped
+  end
+
+  # @param client [Puppeteer::CDPSession]
+  # @param frame [Puppeteer::Frame]
+  # @param interception_id [string|nil]
+  # @param allow_interception [boolean]
+  # @param event [Hash]
+  # @param redirect_chain Array<Request>
+  def initialize: (untyped client, untyped frame, untyped interception_id, untyped allow_interception, untyped event, untyped redirect_chain) -> untyped
+
+  attr_reader internal: untyped
+
+  attr_reader client: untyped
+
+  attr_reader url: untyped
+
+  attr_reader resource_type: untyped
+
+  attr_reader method: untyped
+
+  attr_reader post_data: untyped
+
+  attr_reader response: untyped
+
+  attr_reader frame: untyped
+
+  attr_reader initiator: untyped
+
+  def update_headers: (untyped headers) -> untyped
+
+  def headers: () -> untyped
+
+  # @rbs return: bool -- Whether request has post data
+  def has_post_data?: () -> bool
+
+  # @rbs return: String? -- Post data string if available
+  def fetch_post_data: () -> String?
+
+  def inspect: () -> untyped
+
+  private def assert_interception_allowed: () -> untyped
+
+  private def assert_interception_not_handled: () -> untyped
+
+  private def can_be_intercepted?: () -> untyped
+
+  # @returns the `ContinueRequestOverrides` that will be used
+  # if the interception is allowed to continue (ie, `abort()` and
+  # `respond()` aren't called).
+  def continue_request_overrides: () -> untyped
+
+  # @returns The `ResponseForRequest` that gets used if the
+  # interception is allowed to respond (ie, `abort()` is not called).
+  def response_for_request: () -> untyped
+
+  # @returns the most recent reason for aborting the request
+  def abort_error_reason: () -> untyped
+
+  # @returns An InterceptResolutionState object describing the current resolution
+  #  action and priority.
+  #
+  #  InterceptResolutionState contains:
+  #    action: InterceptResolutionAction
+  #    priority?: number
+  #
+  #  InterceptResolutionAction is one of: `abort`, `respond`, `continue`,
+  #  `disabled`, `none`, or `alreay-handled`
+  def intercept_resolution_state: () -> untyped
+
+  def intercept_resolution_handled?: () -> untyped
+
+  # Adds an async request handler to the processing queue.
+  # Deferred handlers are not guaranteed to execute in any particular order,
+  # but they are guarnateed to resolve before the request interception
+  # is finalized.
+  #
+  # @param pending_handler [Proc]
+  def enqueue_intercept_action: (untyped pending_handler) -> untyped
+
+  # Awaits pending interception handlers and then decides how to fulfill
+  # the request interception.
+  def finalize_interceptions: () -> untyped
+
+  def navigation_request?: () -> untyped
+
+  def redirect_chain: () -> untyped
+
+  def failure: () -> untyped
+
+  private def headers_to_array: (untyped headers) -> untyped
+
+  class InterceptionNotEnabledError < Puppeteer::Error
+    def initialize: () -> untyped
+  end
+
+  class AlreadyHandledError < Puppeteer::Error
+    def initialize: () -> untyped
+  end
+
+  # proceed request on request interception.
+  #
+  # Example:
+  #
+  #   page.on 'request' do |req|
+  #     # Override headers
+  #     headers = req.headers.merge(
+  #       foo: 'bar', # set "foo" header
+  #       origin: nil, # remove "origin" header
+  #     )
+  #     req.continue(headers: headers)
+  #   end
+  #
+  # @param error_code [String|Symbol]
+  def continue: (?url: untyped, ?method: untyped, ?post_data: untyped, ?headers: untyped, ?priority: untyped) -> untyped
+
+  private def continue_impl: (untyped overrides) -> untyped
+
+  # Mocking response.
+  #
+  # Example:
+  #
+  #   page.on 'request' do |req|
+  #     req.respond(
+  #       status: 404,
+  #       content_type: 'text/plain',
+  #       body: 'Not Found!'
+  #     )
+  #   end
+  #
+  # @param status [Integer]
+  # @param headers [Hash<String, String>]
+  # @param content_type [String]
+  # @param body [String]
+  def respond: (?status: untyped, ?headers: untyped, ?content_type: untyped, ?body: untyped, ?priority: untyped) -> untyped
+
+  private def respond_impl: (?status: untyped, ?headers: untyped, ?content_type: untyped, ?body: untyped) -> untyped
+
+  # abort request on request interception.
+  #
+  # Example:
+  #
+  #   page.on 'request' do |req|
+  #     if req.url.include?("porn")
+  #       req.abort
+  #     else
+  #       req.continue
+  #     end
+  #   end
+  #
+  # @param error_code [String|Symbol]
+  def abort: (?error_code: untyped, ?priority: untyped) -> untyped
+
+  private def abort_impl: (untyped error_reason) -> untyped
+
+  private def target_closed_error?: (untyped error) -> untyped
+
+  private def handle_interception_error: (untyped error) -> untyped
+
+  ERROR_REASONS: untyped
+
+  # List taken from https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml with extra 306 and 418 codes.
+  STATUS_TEXTS: untyped
+end

data/sig/puppeteer/http_response.rbs

@@ -0,0 +1,89 @@
+# Generated from lib/puppeteer/http_response.rb with RBS::Inline
+
+class Puppeteer::HTTPResponse
+  include Puppeteer::IfPresent
+
+  class Redirected < Puppeteer::Error
+    def initialize: () -> untyped
+  end
+
+  # defines methods used only in NetworkManager
+  class InternalAccessor
+    def initialize: (untyped response) -> untyped
+
+    def body_loaded_promise: () -> untyped
+  end
+
+  class RemoteAddress
+    def initialize: (ip: untyped, port: untyped) -> untyped
+
+    attr_reader ip: untyped
+
+    attr_reader port: untyped
+  end
+
+  # @param client [Puppeteer::CDPSession]
+  # @param request [Puppeteer::HTTPRequest]
+  # @param response_payload [Hash]
+  # @param extra_info [Hash|nil]
+  def initialize: (untyped client, untyped request, untyped response_payload, untyped extra_info) -> untyped
+
+  attr_reader internal: untyped
+
+  attr_reader remote_address: untyped
+
+  attr_reader url: untyped
+
+  attr_reader status: untyped
+
+  attr_reader status_text: untyped
+
+  attr_reader headers: untyped
+
+  attr_reader security_details: untyped
+
+  attr_reader request: untyped
+
+  attr_reader timing: untyped
+
+  def inspect: () -> untyped
+
+  private def parse_status_text_from_extra_info: (untyped extra_info) -> untyped
+
+  # @return [Boolean]
+  def ok?: () -> untyped
+
+  # @rbs return: String -- Response body as binary string
+  def buffer: () -> String
+
+  # @param text [String]
+  # @rbs return: String -- Response body as text
+  def text: () -> String
+
+  # @param json [Hash]
+  # @rbs return: Hash[untyped, untyped] -- Parsed JSON
+  def json: () -> Hash[untyped, untyped]
+
+  # @rbs return: bool -- Whether response was served from cache
+  def from_cache?: () -> bool
+
+  # @rbs return: bool -- Whether response was served from service worker
+  def from_service_worker?: () -> bool
+
+  # @rbs return: Puppeteer::Frame -- Frame associated with the request
+  def frame: () -> Puppeteer::Frame
+
+  class SecurityDetails
+    def initialize: (untyped security_payload) -> untyped
+
+    attr_reader subject_name: untyped
+
+    attr_reader issuer: untyped
+
+    attr_reader valid_from: untyped
+
+    attr_reader valid_to: untyped
+
+    attr_reader protocol: untyped
+  end
+end

data/sig/puppeteer/js_handle.rbs

@@ -0,0 +1,64 @@
+# Generated from lib/puppeteer/js_handle.rb with RBS::Inline
+
+class Puppeteer::JSHandle
+  include Puppeteer::IfPresent
+
+  # @param context [Puppeteer::ExecutionContext]
+  # @param remote_object [Puppeteer::RemoteObject]
+  def self.create: (context: untyped, remote_object: untyped) -> untyped
+
+  # @param context [Puppeteer::ExecutionContext]
+  # @param client [Puppeteer::CDPSession]
+  # @param remote_object [Puppeteer::RemoteObject]
+  def initialize: (context: untyped, client: untyped, remote_object: untyped) -> untyped
+
+  attr_reader context: untyped
+
+  attr_reader remote_object: untyped
+
+  def inspect: () -> untyped
+
+  # @return [Puppeteer::ExecutionContext]
+  def execution_context: () -> untyped
+
+  # @param page_function [String]
+  # @return [Object]
+  def evaluate: (untyped page_function, *untyped args) -> untyped
+
+  # @param page_function [String]
+  # @param args {Array<*>}
+  # @return [Puppeteer::JSHandle]
+  def evaluate_handle: (untyped page_function, *untyped args) -> untyped
+
+  # getProperty(propertyName) in JavaScript
+  # @param name [String]
+  # @return [Puppeteer::JSHandle]
+  def property: (untyped name) -> untyped
+
+  # @param name [String]
+  # @return [Puppeteer::JSHandle]
+  def []: (untyped name) -> untyped
+
+  # getProperties in JavaScript.
+  # @return [Hash<String, JSHandle>]
+  def properties: () -> untyped
+
+  def json_value: () -> untyped
+
+  def as_element: () -> untyped
+
+  def dispose: () -> untyped
+
+  def disposed?: () -> untyped
+
+  # @rbs return: void
+  def dispose_symbol: () -> void
+
+  # @rbs return: self
+  def move: () -> self
+
+  def to_s: () -> untyped
+
+  # @rbs return: String
+  private def stringify_remote_value: () -> String
+end

data/sig/puppeteer/keyboard.rbs

@@ -0,0 +1,40 @@
+# Generated from lib/puppeteer/keyboard.rb with RBS::Inline
+
+class Puppeteer::Keyboard
+  # @rbs client: Puppeteer::CDPSession -- CDP session
+  # @rbs return: void -- No return value
+  def initialize: (Puppeteer::CDPSession client) -> void
+
+  attr_reader modifiers: untyped
+
+  # @rbs key: String -- Key name
+  # @rbs text: String? -- Text to input
+  # @rbs commands: Array[String]? -- Editing commands
+  # @rbs return: void -- No return value
+  def down: (String key, ?text: String?, ?commands: Array[String]?) -> void
+
+  private def modifier_bit: (untyped key) -> untyped
+
+  private def key_description_for_string: (untyped key_string) -> untyped
+
+  # @rbs key: String -- Key name
+  # @rbs return: void -- No return value
+  def up: (String key) -> void
+
+  # @rbs char: String -- Character to insert
+  # @rbs return: void -- No return value
+  def send_character: (String char) -> void
+
+  # @rbs text: String -- Text to type
+  # @rbs delay: Numeric? -- Delay between key presses (ms)
+  # @rbs return: void -- No return value
+  def type_text: (String text, ?delay: Numeric?) -> void
+
+  # @rbs key: String -- Key name
+  # @rbs delay: Numeric? -- Delay between key events (ms)
+  # @rbs text: String? -- Text to input
+  # @rbs commands: Array[String]? -- Editing commands
+  # @rbs block: Proc? -- Optional block for key combo usage
+  # @rbs return: void -- No return value
+  def press: (String key, ?delay: Numeric?, ?text: String?, ?commands: Array[String]?) ?{ (?) -> untyped } -> void
+end

data/sig/puppeteer/locators.rbs

@@ -0,0 +1,222 @@
+# Generated from lib/puppeteer/locators.rb with RBS::Inline
+
+module Puppeteer
+  module LocatorEvent
+    Action: ::String
+  end
+end
+
+class Puppeteer::Locator
+  include Puppeteer::EventCallbackable
+
+  RETRY_DELAY_SECONDS: ::Float
+
+  class TimeoutController
+    def initialize: (untyped timeout) -> untyped
+
+    attr_reader timeout: untyped
+
+    def remaining_timeout: () -> untyped
+
+    def exceeded?: () -> untyped
+
+    def check!: (?untyped cause) -> untyped
+  end
+
+  def initialize: () -> untyped
+
+  # @rbs locators: Array[Puppeteer::Locator] -- Locator candidates
+  # @rbs return: Puppeteer::Locator -- Locator that races candidates
+  def self.race: (Array[Puppeteer::Locator] locators) -> Puppeteer::Locator
+
+  # @rbs input: String -- Input string to check
+  # @rbs return: bool -- Whether string looks like a JS function
+  def self.function_string?: (String input) -> bool
+
+  # @rbs return: Numeric -- Timeout in milliseconds
+  def timeout: () -> Numeric
+
+  # @rbs timeout: Numeric -- Timeout in milliseconds
+  # @rbs return: Puppeteer::Locator -- Updated locator
+  def set_timeout: (Numeric timeout) -> Puppeteer::Locator
+
+  # @rbs visibility: String? -- 'visible', 'hidden', or nil
+  # @rbs return: Puppeteer::Locator -- Updated locator
+  def set_visibility: (String? visibility) -> Puppeteer::Locator
+
+  # @rbs value: bool -- Whether to wait for enabled state
+  # @rbs return: Puppeteer::Locator -- Updated locator
+  def set_wait_for_enabled: (bool value) -> Puppeteer::Locator
+
+  # @rbs value: bool -- Whether to ensure element is in viewport
+  # @rbs return: Puppeteer::Locator -- Updated locator
+  def set_ensure_element_is_in_the_viewport: (bool value) -> Puppeteer::Locator
+
+  # @rbs value: bool -- Whether to wait for stable bounding box
+  # @rbs return: Puppeteer::Locator -- Updated locator
+  def set_wait_for_stable_bounding_box: (bool value) -> Puppeteer::Locator
+
+  # @rbs locator: Puppeteer::Locator -- Locator to copy options from
+  # @rbs return: self -- Locator with copied options
+  def copy_options: (Puppeteer::Locator locator) -> self
+
+  # @rbs return: Puppeteer::Locator -- Cloned locator
+  def clone: (?freeze: untyped) -> Puppeteer::Locator
+
+  # @rbs return: Puppeteer::JSHandle -- Handle for located value
+  def wait_handle: () -> Puppeteer::JSHandle
+
+  # @rbs return: untyped -- JSON-serializable value
+  def wait: () -> untyped
+
+  # @rbs mapper: String -- JS mapper function
+  # @rbs return: Puppeteer::Locator -- Mapped locator
+  def map: (String mapper) -> Puppeteer::Locator
+
+  # @rbs predicate: String -- JS predicate function
+  # @rbs return: Puppeteer::Locator -- Filtered locator
+  def filter: (String predicate) -> Puppeteer::Locator
+
+  # @rbs predicate: Proc -- Handle predicate
+  # @rbs return: Puppeteer::Locator -- Filtered locator
+  def filter_handle: (Proc predicate) -> Puppeteer::Locator
+
+  # @rbs mapper: Proc -- Handle mapper
+  # @rbs return: Puppeteer::Locator -- Mapped locator
+  def map_handle: (Proc mapper) -> Puppeteer::Locator
+
+  # @rbs delay: Numeric? -- Delay between down and up (ms)
+  # @rbs button: String? -- Mouse button
+  # @rbs click_count: Integer? -- Deprecated click count
+  # @rbs count: Integer? -- Number of clicks
+  # @rbs offset: Hash[Symbol, Numeric]? -- Click offset
+  # @rbs return: void -- No return value
+  def click: (?delay: Numeric?, ?button: String?, ?click_count: Integer?, ?count: Integer?, ?offset: Hash[Symbol, Numeric]?) -> void
+
+  # @rbs value: String -- Value to fill
+  # @rbs return: void -- No return value
+  def fill: (String value) -> void
+
+  # @rbs return: void -- No return value
+  def hover: () -> void
+
+  # @rbs scroll_top: Numeric? -- Scroll top position
+  # @rbs scroll_left: Numeric? -- Scroll left position
+  # @rbs return: void -- No return value
+  def scroll: (?scroll_top: Numeric?, ?scroll_left: Numeric?) -> void
+
+  # @rbs event_name: String -- Event name
+  # @rbs block: Proc -- Event handler
+  # @rbs return: Puppeteer::Locator -- Locator for chaining
+  def on: (String event_name) ?{ (?) -> untyped } -> Puppeteer::Locator
+
+  # @rbs event_name: String -- Event name
+  # @rbs block: Proc -- Event handler
+  # @rbs return: Puppeteer::Locator -- Locator for chaining
+  def once: (String event_name) ?{ (?) -> untyped } -> Puppeteer::Locator
+
+  def _clone: () -> untyped
+
+  def _wait: (untyped _options) -> untyped
+
+  private def perform_action: (untyped name, conditions: untyped) ?{ (?) -> untyped } -> untyped
+
+  private def with_retry: (untyped _name) ?{ (?) -> untyped } -> untyped
+
+  private def build_action_options: (untyped timeout_controller) -> untyped
+
+  private def run_conditions: (untyped handle, untyped options, untyped conditions) -> untyped
+
+  private def wait_for_enabled_if_needed: (untyped handle, untyped options) -> untyped
+
+  private def wait_for_stable_bounding_box_if_needed: (untyped handle, untyped options) -> untyped
+
+  private def ensure_element_is_in_viewport_if_needed: (untyped handle, untyped options) -> untyped
+
+  private def fill_element: (untyped handle, untyped value) -> untyped
+end
+
+class Puppeteer::FunctionLocator < Puppeteer::Locator
+  # @rbs page_or_frame: Puppeteer::Page | Puppeteer::Frame -- Page or frame
+  # @rbs func: String -- JS function to evaluate
+  # @rbs return: Puppeteer::Locator -- Function locator
+  def self.create: (Puppeteer::Page | Puppeteer::Frame page_or_frame, String func) -> Puppeteer::Locator
+
+  def initialize: (untyped page_or_frame, untyped func) -> untyped
+
+  def _clone: () -> untyped
+
+  def _wait: (untyped options) -> untyped
+
+  def self.default_timeout_for: (untyped page_or_frame) -> untyped
+end
+
+class Puppeteer::DelegatedLocator < Puppeteer::Locator
+  def initialize: (untyped delegate) -> untyped
+
+  def delegate: () -> untyped
+
+  def set_timeout: (untyped timeout) -> untyped
+
+  def set_visibility: (untyped visibility) -> untyped
+
+  def set_wait_for_enabled: (untyped value) -> untyped
+
+  def set_ensure_element_is_in_the_viewport: (untyped value) -> untyped
+
+  def set_wait_for_stable_bounding_box: (untyped value) -> untyped
+
+  def _clone: () -> untyped
+
+  def _wait: (untyped _options) -> untyped
+end
+
+class Puppeteer::FilteredLocator < Puppeteer::DelegatedLocator
+  def initialize: (untyped base, untyped predicate) -> untyped
+
+  def _clone: () -> untyped
+
+  def _wait: (untyped options) -> untyped
+end
+
+class Puppeteer::MappedLocator < Puppeteer::DelegatedLocator
+  def initialize: (untyped base, untyped mapper) -> untyped
+
+  def _clone: () -> untyped
+
+  def _wait: (untyped options) -> untyped
+end
+
+class Puppeteer::NodeLocator < Puppeteer::Locator
+  # @rbs page_or_frame: Puppeteer::Page | Puppeteer::Frame -- Page or frame
+  # @rbs selector: String -- Selector
+  # @rbs return: Puppeteer::Locator -- Node locator
+  def self.create: (Puppeteer::Page | Puppeteer::Frame page_or_frame, String selector) -> Puppeteer::Locator
+
+  # @rbs page_or_frame: Puppeteer::Page | Puppeteer::Frame -- Page or frame
+  # @rbs handle: Puppeteer::ElementHandle -- Element handle
+  # @rbs return: Puppeteer::Locator -- Node locator
+  def self.create_from_handle: (Puppeteer::Page | Puppeteer::Frame page_or_frame, Puppeteer::ElementHandle handle) -> Puppeteer::Locator
+
+  def initialize: (untyped page_or_frame, untyped selector_or_handle) -> untyped
+
+  def _clone: () -> untyped
+
+  def _wait: (untyped options) -> untyped
+
+  private def wait_for_visibility_if_needed: (untyped handle, untyped options) -> untyped
+
+  def self.default_timeout_for: (untyped page_or_frame) -> untyped
+end
+
+class Puppeteer::RaceLocator < Puppeteer::Locator
+  def self.create: (untyped locators) -> untyped
+
+  def initialize: (untyped locators) -> untyped
+
+  def _clone: () -> untyped
+
+  def _wait: (untyped options) -> untyped
+
+  def self.check_locator_array: (untyped locators) -> untyped
+end