Function projectSchema

javascript/selenium-webdriver/project_bidi_schema.mjs:600–687

(ast, model, links = {})

 * @returns {{schemaVersion: number, commands: object[], events: object[], types: object, domains: object}} The schema.
 */
export function projectSchema(ast, model, links = {}) {
  const types = {}
  for (const def of normalizeAst(ast)) {
    if (!def?.Name) continue
    const node = projectType(def)
    // Types the normalizer minted for anonymous CDDL constructs (hoisted enums /
    // inline records, union arms) carry their decomposition so a binding can name
    // or nest them idiomatically without parsing the synthetic key. `owner` is the
    // type the construct was lifted out of; `label` is the member name within it.
    if (def['x-selenium-synthetic']) {
      node.synthetic = true
      node.owner = def['x-selenium-owner']
      node.label = def['x-selenium-label']
    }
    // Link to the type's definition in the live spec, when the index covers it —
    // the readable prose section where one exists, else the CDDL production.
    // Synthetic types have no spec definition and are (correctly) never in it.
    const typeHref = links.types?.[def.Name.toLowerCase()]
    if (typeHref) node.specHref = typeHref
    types[def.Name] = node
  }
  for (const [name, node] of Object.entries(types))
    if (node.kind === 'union') node.selector = unionSelector(name, types)
  // Override the result-grouping unions: they are dispatched by request id, so a
  // payload selector for them is meaningless (and would be empty/ambiguous).
  for (const name of correlatedUnions(types)) types[name].selector = { correlated: true }
  // A first-class union whose every arm is an object rejects a non-object payload
  // instead of passing it through. (An alias-union like input.Origin, which carries
  // bare-string arms, is intentionally left unflagged so those arms still pass through.)
  for (const node of Object.values(types))
    if (node.kind === 'union' && node.variants.every((v) => variantIsObject(v, types))) node.objectOnly = true

  const commands = []
  const events = []
  const envelopeParams = commandEnvelopeParams(types)
  // Commands and events link to their own prose section (`#command-*` / `#event-*`),
  // keyed by the wire method; domains to their `#module-*` section. Present-only-when-known.
  const link = (map, key) => (typeof key === 'string' ? map?.[key.toLowerCase()] : undefined)
  for (const [domain, entry] of Object.entries(model)) {
    for (const c of entry.commands ?? []) {
      const cmd = {
        domain,
        method: c.method,
        name: c.name,
        // Prefer the envelope's params (it captures inline params the model drops).
        params: typeRef(envelopeParams.get(c.method) ?? c.params),
        result: typeRef(c.result),
      }
      const href = link(links.commands, c.method)
      if (href) cmd.specHref = href
      commands.push(cmd)
    }
    for (const e of entry.events ?? []) {
      const ev = { domain, method: e.method, name: e.name, params: typeRef(envelopeParams.get(e.method) ?? e.params) }
      const href = link(links.events, e.method)
      if (href) ev.specHref = href
      events.push(ev)
    }