Function handlePropertySignature

packages/vue/src/form.ts:108–207

(
  propertySignature: S.AST.PropertySignature
)

  }

function handlePropertySignature(
  propertySignature: S.AST.PropertySignature
):
  | NestedFieldInfo<Record<PropertyKey, any>>
  | FieldInfo<any>
  | UnionFieldInfo<(NestedFieldInfo<Record<PropertyKey, any>> | FieldInfo<any>)[]>
  | DiscriminatedUnionFieldInfo<Record<PropertyKey, any>>
{
  const schema = S.make(propertySignature.type)

  if (S.AST.isDeclaration(schema.ast)) {
    const tl = getObjectsAST(schema.ast)
    return tl
      ? handlePropertySignature(
        new S.AST.PropertySignature(
          propertySignature.name,
          tl
        )
      )
      : buildFieldInfo(propertySignature)
  }

  switch (schema.ast._tag) {
    case "Objects": {
      return buildFieldInfoFromFieldsRoot(
        schema as S.Codec<Record<PropertyKey, any>>
      )
    }
    case "Union": {
      const allTypeLiterals = schema.ast.types.every(getObjectsAST)

      if (allTypeLiterals) {
        const members = schema
          .ast
          .types
          .map((elAst) =>
            // syntehtic property signature as if each union member were the only member
            new S.AST.PropertySignature(
              propertySignature.name,
              elAst
            )
          )
          .flatMap((ps) => {
            // try to retrieve the _tag literal to set _infoTag later
            const typeLiteral = getObjectsAST(ps.type)

            const tagPropertySignature = typeLiteral?.propertySignatures.find((_) => _.name === "_tag")
            // unwrap single-element Union to Literal (S.Struct({ _tag: S.Literal("x") }) wraps as Union([Literal("x")]))
            const tagType = tagPropertySignature
              ? S.AST.isUnion(tagPropertySignature.type)
                  && tagPropertySignature.type.types.length === 1
                  && S.AST.isLiteral(tagPropertySignature.type.types[0]!)
                ? tagPropertySignature.type.types[0]
                : tagPropertySignature.type
              : undefined
            const tagLiteral = tagType
                && S.AST.isLiteral(tagType)
                && typeof tagType.literal === "string"