class Playwright::Waiter

def cleanup
tered_listeners.each do |emitter, event, listener|
ter.off(event, listener)
tered_listeners.clear

def force_fulfill(result)
  fulfill(result)
end

def format_log_recording(logs)
 "" if logs.empty?
 = " logs "
_length = 60
ength = ((header_length - header.length) / 2.0).to_i
length = header_length - header.length - left_length
ne = "\n"
_line}#{'=' * left_length}#{header}#{'=' * right_length}#{new_line}#{logs.join(new_line)}#{new_line}#{'=' * header_length}"

def fulfill(result)
p
 @result.resolved?
ult.fulfill(result)
or_event_info_after

def initialize(channel_owner, wait_name:)
  @result = Concurrent::Promises.resolvable_future
  @wait_id = SecureRandom.hex(16)
  @event = wait_name
  @channel = channel_owner.channel
  @registered_listeners = Set.new
  @logs = []
  wait_for_event_info_before
end

def log(message)
  @logs << message
  begin
    @channel.async_send_message_to_server(
      "waitForEventInfo",
      {
        "info": {
          "waitId": @wait_id,
          "phase": "log",
          "message": message,
        },
      },
    )
  rescue => err
    # ignore
  end
end

def reject(error)
p
= error.is_a?(TimeoutError) ? TimeoutError : Error
lass.new(message: "#{error.message}#{format_log_recording(@logs)}")
 @result.resolved?
ult.reject(ex)
or_event_info_after(error: ex)

def reject_on_event(emitter, event, error_or_proc, predicate: nil)
  listener = -> (*args) {
    if !predicate || predicate.call(*args)
      if error_or_proc.respond_to?(:call)
        reject(error_or_proc.call)
      else
        reject(error_or_proc)
      end
    end
  }
  emitter.on(event, listener)
  @registered_listeners << [emitter, event, listener]
  self
end

def reject_on_timeout(timeout_ms, message)
  return if timeout_ms <= 0
  Concurrent::Promises.schedule(timeout_ms / 1000.0) do
    reject(TimeoutError.new(message: message))
  end.rescue do |err|
    puts err, err.backtrace
  end
  self
end

def wait_for_event(emitter, event, predicate: nil)
  listener = -> (*args) {
    begin
      if !predicate || predicate.call(*args)
        fulfill(args.first)
      end
    rescue => err
      reject(err)
    end
  }
  emitter.on(event, listener)
  @registered_listeners << [emitter, event, listener]
  self
end

def wait_for_event_info_after(error: nil)
el.async_send_message_to_server(
tForEventInfo",
nfo": {
"waitId": @wait_id,
"phase": "after",
"error": error,
compact,

def wait_for_event_info_before
el.async_send_message_to_server(
tForEventInfo",
nfo": {
"waitId": @wait_id,
"phase": "before",
"event": @event,