Class: BiDiGenerate::Schema Private

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 647

def baked_discriminator?(field)
  field['type'].key?('const') && !field['type']['nullable']
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 432

def commands_for(domain)
  @commands.select { |c| c['domain'] == domain }
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 845

def default_variant_enum_values(selector, by)
  default = selector['default']
  field = default && @types[default]['fields'].find { |f| f['wire'] == by }
  ref = field && field['type']['ref']
  ref && @types[ref] && @types[ref]['kind'] == 'enum' ? @types[ref]['values'] : []
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 712

def discriminated_variants(selector)
  variants = selector['variants'].map do |variant|
    VariantIR.new(mode: :value, value: variant['value'], ref: ruby_path(variant['ref']), requires: nil)
  end
  return variants unless selector['default']

  variants << VariantIR.new(mode: :fallback, value: nil, ref: ruby_path(selector['default']), requires: nil)
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 396

def domain_href(domain)
  @domains.dig(domain, 'specHref')
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 521

def domain_path(name)
  name.include?('.') ? ruby_path(name) : nil
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 428

def domains
  (@commands + @events).map { |entry| entry['domain'] }.uniq
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 802

def enum_const(field_type)
  ref = field_type['ref'] || field_type.dig('list', 'ref')
  return unless ref && @types[ref] && @types[ref]['kind'] == 'enum'

  BiDiGenerate.enum_const_path(ref)
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 461

def enums_for(domain)
  @types.filter_map do |name, type|
    next unless type['kind'] == 'enum'
    next unless name.start_with?("#{domain}.")

    pairs = type['values'].map { |v| [BiDiGenerate.enum_key(v), v.to_s] }
    Enum.new(constant_name: BiDiGenerate.screaming_snake(name.sub("#{domain}.", '')), pairs: pairs,
             spec_href: type['specHref'])
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 505

def envelope_synthetic?(type)
  return false unless type['synthetic']

  owner = @types[type['owner']]
  owner && owner['kind'] == 'record' && message_envelope?(owner)
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 440

def events_for(domain)
  @events.select { |e| e['domain'] == domain }
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 651

def field_ir(field)
  resolved = resolve(field['type'])
  ruby_name = BiDiGenerate.safe_field_name(BiDiGenerate.camel_to_snake(field['name']))
  FieldIR.new(ruby_name: ruby_name, wire_key: field['wire'],
              required: field['required'], nullable: resolved[:nullable],
              ref: resolved[:ref], list: resolved[:list], enum: enum_const(field['type']),
              primitive: leaf_primitive(field['type']), scalar: resolved[:scalar],
              rbs: resolved[:rbs])
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 868

def guard_union_dispatch_keys_simple!(selector, ref)
  keys = selector['by'] ? [selector['by']] : (selector['ordered'] || []).flat_map { |arm| arm['requires'] }
  camel = keys.reject { |k| BiDiGenerate.camel_to_snake(k) == k }
  return if camel.empty?

  raise "union command param #{ref} dispatches on non-snake wire key(s) #{camel.inspect}; " \
        'Union.build matches kwargs to dispatch keys by symbol, so give the outbound ' \
        'dispatch an explicit wire<->ruby mapping before shipping this.'
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 666

def leaf_primitive(node, seen = {})
  return node['primitive'] if node.key?('primitive') && CHECKABLE_PRIMITIVES.include?(node['primitive'])
  return nil unless node.key?('ref')

  name = node['ref']
  type = @types[name]
  return nil if seen[name] || type.nil? || type['kind'] != 'alias'

  seen[name] = true
  leaf_primitive(type['type'], seen)
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 854

def merged_params(variant_fields)
  all_fields = variant_fields.flatten
  all_fields.map { |f| f['wire'] }.uniq.map do |wire|
    field = all_fields.find { |f| f['wire'] == wire }
    required = variant_fields.all? { |fields| fields.any? { |f| f['wire'] == wire && f['required'] } }
    Param.new(ruby_name: BiDiGenerate.safe_field_name(BiDiGenerate.camel_to_snake(field['name'])),
              wire_name: wire, required: required, rbs: rbs_type(field['type']))
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 500

def message_envelope?(type)
  type['fields'].any? { |f| f['wire'] == 'method' && f['type'].key?('const') }
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 608

def named_type(name)
  {ref: domain_path(name), list: false, rbs: rbs_abs(ruby_path(name))}
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 624

def nilable(type, flag)
  flag ? BiDiGenerate.rbs_nilable(type) : type
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 721

def ordered_variants(selector)
  (selector['ordered'] || []).map do |arm|
    VariantIR.new(mode: :presence, value: nil, ref: ruby_path(arm['ref']), requires: arm['requires'])
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 448

def params_for(params_ref)
  return [] unless params_ref

  type = @types[params_ref['ref']]
  return nil unless type

  case type['kind']
  when 'record' then record_params(type['fields'])
  when 'union' then union_params(type, params_ref['ref'])
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 408

def promote_command_params_records!
  @commands.each do |cmd|
    ref = cmd.dig('params', 'ref')
    next unless ref

    type = @types[ref]
    promote_to_domain_type!(ref) if type && envelope_synthetic?(type)
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 420

def promote_to_domain_type!(name)
  type = @types[name]
  type&.delete('synthetic')
  type&.delete('owner')
  type&.delete('label')
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 795

def rbs_abs(path)
  "::Selenium::WebDriver::BiDi::Protocol::#{path}"
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 786

def rbs_const(value)
  case value
  when true, false then 'bool'
  when ::String then 'String'
  when ::Numeric then 'Numeric'
  else 'untyped'
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 760

def rbs_type(node)
  resolve(node)[:rbs]
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 628

def record_class(name, type)
  const = type['fields'].find { |f| baked_discriminator?(f) }
  discriminator = const && {ruby_name: BiDiGenerate.safe_field_name(BiDiGenerate.camel_to_snake(const['name'])),
                            wire: const['wire'], value: const['type']['const'],
                            rbs: rbs_const(const['type']['const'])}
  fields = type['fields'].reject { |f| baked_discriminator?(f) }.map { |f| field_ir(f) }
  # Gate the extensions store on `preserveExtras` (extensible AND re-sendable), not raw
  # `extensible`: only a type you receive and can hand back keeps unknown wire keys. A
  # received-only extensible type gets no store, so its unknown keys are silently ignored.
  TypeClass.new(ruby_name: BiDiGenerate.type_class_name(name), fields: fields,
                discriminator: discriminator, extensible: type['preserveExtras'] ? true : false,
                schema_name: name, synthetic: type['synthetic'] ? true : false,
                owner: type['owner'], label: type['label'], spec_href: type['specHref'])
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 748

def record_params(fields)
  fields.map do |field|
    Param.new(
      ruby_name: BiDiGenerate.safe_field_name(BiDiGenerate.camel_to_snake(field['name'])),
      wire_name: field['wire'],
      required: field['required'],
      enum: enum_const(field['type']),
      rbs: rbs_type(field['type'])
    )
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 541

def resolve(node)
  nullable = node['nullable'] ? true : false
  if node.key?('list')
    element = resolve(node['list'])
    return {ref: element[:ref], list: true, nullable: nullable, scalar: element[:scalar],
            rbs: nilable("Array[#{element[:rbs]}]", nullable)}
  end
  if node.key?('ref')
    named = resolve_named(node['ref'])
    return {ref: named[:ref], list: named[:list], nullable: nullable, scalar: named[:scalar],
            rbs: nilable(named[:rbs], nullable)}
  end
  return resolve_union(node, nullable) if node.key?('union')

  {ref: nil, list: false, nullable: nullable, rbs: nilable(scalar_rbs(node), nullable)}
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 589

def resolve_named(name, seen = {})
  return OPAQUE if name.nil? || seen[name]

  seen[name] = true
  type = @types[name]
  return OPAQUE unless type

  case type['kind']
  when 'record' then type['fields'].empty? ? OPAQUE : named_type(name)
  when 'union' then named_type(name)
  when 'enum' then {ref: nil, list: false, rbs: 'Symbol'}
  when 'alias' then resolve_named_alias(name, type['type'], seen)
  else OPAQUE
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 612

def resolve_named_alias(name, inner, seen)
  return named_type(name) if inner.key?('union')
  return resolve_named(inner['ref'], seen) if inner.key?('ref')

  if inner.key?('list')
    element = resolve(inner['list'])
    return {ref: element[:ref], list: true, scalar: element[:scalar], rbs: "Array[#{element[:rbs]}]"}
  end

  {ref: nil, list: false, rbs: scalar_rbs(inner)}
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 564

def resolve_union(node, nullable)
  refs = node['union'].select { |arm| arm.key?('ref') }
  opaque = {ref: nil, list: false, nullable: nullable, rbs: nilable('untyped', nullable)}
  return opaque unless refs.one? && union_ref?(refs.first['ref'])

  named = resolve_named(refs.first['ref'])
  {ref: named[:ref], list: named[:list], nullable: nullable, scalar: node['scalar'],
   rbs: nilable('untyped', nullable)}
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 527

def ruby_path(name)
  type = @types[name]
  return BiDiGenerate.type_ruby_path(name) unless type && type['synthetic']

  "#{ruby_path(type['owner'])}::#{type['label']}"
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 779

def scalar_rbs(node)
  return PRIMITIVE_RBS.fetch(node['primitive']) if node.key?('primitive')
  return rbs_const(node['const']) if node.key?('const')

  'untyped'
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 514

def structured_ref(name)
  resolved = resolve_named(name)
  resolved[:list] ? nil : resolved[:ref]
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 493

def suppressed_record?(type)
  message_envelope?(type) || envelope_synthetic?(type)
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 436

def type_kind(ref)
  @types[ref]&.fetch('kind', nil)
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 477

def types_for(domain)
  prefix = "#{domain}."
  @types.filter_map do |name, type|
    next unless name.start_with?(prefix)

    case type['kind']
    when 'record' then record_class(name, type) unless type['fields'].empty? || suppressed_record?(type)
    when 'union' then union_class(name)
    when 'alias' then union_class(name) if type['type'].key?('union')
    end
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 678

def union_class(name)
  type = @types[name]
  # A first-class union carries the schema's authoritative dispatch `selector`
  # (derived spec-faithfully, including null discriminators and the spec's choice
  # order); consume it rather than re-deriving and silently depending on emit
  # order. An alias-to-union (only input.Origin) has no selector — its const-string
  # arms aren't first-class types — so it keeps the structural re-derivation.
  type['kind'] == 'union' ? union_from_selector(name, type['selector']) : union_from_alias(name)
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 732

def union_from_alias(name)
  consts = @types[name]['type']['union'].filter_map { |arm| arm['ref'] }.to_h do |ref|
    const = @types[ref]['fields'].find { |f| f['type'].key?('const') }
    const || raise("alias-union #{name} arm #{ref} has no const discriminator to dispatch on")
    [ref, const]
  end
  variants = consts.map do |ref, const|
    VariantIR.new(mode: :value, value: const['type']['const'], ref: ruby_path(ref), requires: nil)
  end
  # An alias-union carries bare-scalar arms (input.Origin's "viewport"/"pointer"), so it
  # is never object_only — those arms must still pass a non-Hash payload through.
  UnionClass.new(ruby_name: BiDiGenerate.type_class_name(name),
                 discriminator_wire: consts.values.first['wire'], variants: variants, schema_name: name,
                 spec_href: @types[name]['specHref'], object_only: @types[name]['objectOnly'] ? true : false)
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 695

def union_from_selector(name, selector)
  # A correlated union is resolved by request id, never the payload, so it carries
  # no dispatch — it must never be emitted (every one is a top-level result
  # grouping). Fail loudly if a future schema makes one domain-scoped rather than
  # emit a Union whose every parse would raise.
  if selector['correlated']
    raise "correlated union #{name} must not be emitted (resolved by request id, not payload)"
  end

  variants = selector['by'] ? discriminated_variants(selector) : ordered_variants(selector)
  raise "union #{name} selector yielded no dispatch variants" if variants.empty?

  UnionClass.new(ruby_name: BiDiGenerate.type_class_name(name),
                 discriminator_wire: selector['by'], variants: variants, schema_name: name,
                 spec_href: @types[name]['specHref'], object_only: @types[name]['objectOnly'] ? true : false)
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 814

def union_params(type, ref = nil)
  variants = type['variants'].map { |variant_ref| @types[variant_ref] }
  return nil unless variants.all? { |v| v && v['kind'] == 'record' }

  selector = type['selector']
  guard_union_dispatch_keys_simple!(selector, ref)
  params = merged_params(variants.map { |v| v['fields'] })
  annotate_discriminator_enum!(params, selector)
  params
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 576

def union_ref?(name)
  type = @types[name]
  return false unless type
  return union_ref?(type['type']['ref']) if type['kind'] == 'alias' && type['type'].key?('ref')

  type['kind'] == 'union'
end