Function serializeTypeExpression

scripts/generateLibs.ts:157–214

(typeNode: ts.TypeNode)

  }

  function serializeTypeExpression(typeNode: ts.TypeNode): TypeExpression {
    if (ts.isUnionTypeNode(typeNode)) {
      return {
        type: 'union',
        unionOrIntersectionList: typeNode.types.map((childTypeNode) => {
          return serializeTypeExpression(childTypeNode)
        }),
      }
    } else if (ts.isIntersectionTypeNode(typeNode)) {
      return {
        type: 'intersection',
        unionOrIntersectionList: typeNode.types.map((childTypeNode) => {
          return serializeTypeExpression(childTypeNode)
        }),
      }
    } else if (ts.isTypeReferenceNode(typeNode)) {
      const type = checker.getTypeFromTypeNode(typeNode)
      serializeType(type)

      // Note: I am ignoring type arguments e.g. HTMLCollectionOf<HTMLScriptElement>
      // This will come through as a plain HTMLCollectionOf.
      // TODO: Parse typeNode.typeArguments into something useful.
      return { type: 'reference', reference: typeNode.typeName.getText() }
    } else if (ts.isParenthesizedTypeNode(typeNode)) {
      const parType = typeNode as ts.ParenthesizedTypeNode
      return serializeTypeExpression(parType.type)
    } else if (ts.isFunctionTypeNode(typeNode)) {
      const funcType = typeNode as ts.FunctionTypeNode
      return { type: 'function', function: serializeFunctionTypeExpression(funcType) }
    } else if (ts.isTypeLiteralNode(typeNode)) {
      return { type: 'literal', literal: typeNode.getText() }
    } else if (ts.isArrayTypeNode(typeNode)) {
      return { type: 'array' }
    } else if (ts.isThisTypeNode(typeNode)) {
      return { type: 'this' }
    } else if (typeNode.kind === ts.SyntaxKind.NumberKeyword) {
      return { type: 'reference', reference: 'Number' }
    } else if (typeNode.kind === ts.SyntaxKind.StringKeyword) {
      return { type: 'reference', reference: 'String' }
    } else if (typeNode.kind === ts.SyntaxKind.BooleanKeyword) {
      return { type: 'reference', reference: 'Boolean' }
    } else if (typeNode.kind === ts.SyntaxKind.UnknownKeyword) {
      return { type: 'unknown' }
    } else if (typeNode.kind === ts.SyntaxKind.UndefinedKeyword) {
      return { type: 'undefined' }
    } else if (typeNode.kind === ts.SyntaxKind.NullKeyword) {
      return { type: 'null' }
    } else if (typeNode.kind === ts.SyntaxKind.AnyKeyword) {
      return { type: 'any' }
    } else if (typeNode.kind === ts.SyntaxKind.VoidKeyword) {
      return { type: 'void' }
    } else {
      console.log('???', ts.SyntaxKind[typeNode.kind])
      console.log(typeNode.getText())
    }

    return { type: 'any' }
  }