refactor: improve the formatType method

Author: RYGRIT

server/utils/docs/format.ts

@@ -72,58 +72,66 @@ export function formatParam(param: FunctionParam): string {
 export function formatType(type?: TsType): string {
   if (!type) return ''
 
-  if (type.kind === 'keyword' && type.keyword) {
-    return type.keyword
-  }
+  const formatter = TYPE_FORMATTERS[type.kind]
+  const formatted = formatter?.(type)
+
+  if (formatted) return formatted
+  return type.repr ? stripAnsi(type.repr) : 'unknown'
+}
 
-  if (type.kind === 'typeRef' && type.typeRef) {
+const TYPE_FORMATTERS: Partial<Record<TsType['kind'], (type: TsType) => string>> = {
+  keyword: type => type.keyword || '',
+  literal: type => {
+    if (!type.literal) return ''
+    if (type.literal.kind === 'string') return `"${type.literal.string}"`
+    if (type.literal.kind === 'number') return String(type.literal.number)
+    if (type.literal.kind === 'boolean') return String(type.literal.boolean)
+    return ''
+  },
+  typeRef: type => {
+    if (!type.typeRef) return ''
     const params = type.typeRef.typeParams?.map(t => formatType(t)).join(', ')
     return params ? `${type.typeRef.typeName}<${params}>` : type.typeRef.typeName
-  }
-
-  if (type.kind === 'array' && type.array) {
-    return `${formatType(type.array)}[]`
-  }
-
-  if (type.kind === 'union' && type.union) {
-    return type.union.map(t => formatType(t)).join(' | ')
-  }
-
-  if (type.kind === 'this') {
-    return 'this'
-  }
-
-  if (type.kind === 'indexedAccess' && type.indexedAccess) {
+  },
+  array: type => {
+    if (!type.array) return ''
+    const element = formatType(type.array)
+    return type.array.kind === 'union' ? `(${element})[]` : `${element}[]`
+  },
+  union: type => (type.union ? type.union.map(t => formatType(t)).join(' | ') : ''),
+  this: () => 'this',
+  indexedAccess: type => {
+    if (!type.indexedAccess) return ''
     return `${formatType(type.indexedAccess.objType)}[${formatType(type.indexedAccess.indexType)}]`
-  }
-
-  if (type.kind === 'typeOperator' && type.typeOperator) {
+  },
+  typeOperator: type => {
+    if (!type.typeOperator) return ''
     return `${type.typeOperator.operator} ${formatType(type.typeOperator.tsType)}`
-  }
+  },
+  fnOrConstructor: type =>
+    type.fnOrConstructor ? formatFnOrConstructorType(type.fnOrConstructor) : '',
+  typeLiteral: type => (type.typeLiteral ? formatTypeLiteralType(type.typeLiteral) : ''),
+}
 
-  if (type.kind === 'fnOrConstructor' && type.fnOrConstructor) {
-    const { fnOrConstructor: fn } = type
-    const typeParams = fn.typeParams?.map(t => t.name).join(', ')
-    const typeParamsStr = typeParams ? `<${typeParams}>` : ''
-    const params = fn.params.map(p => formatParam(p)).join(', ')
-    const ret = formatType(fn.tsType) || 'void'
-    return `${typeParamsStr}(${params}) => ${ret}`
-  }
+function formatFnOrConstructorType(fn: NonNullable<TsType['fnOrConstructor']>): string {
+  const typeParams = fn.typeParams?.map(t => t.name).join(', ')
+  const typeParamsStr = typeParams ? `<${typeParams}>` : ''
+  const params = fn.params.map(p => formatParam(p)).join(', ')
+  const ret = formatType(fn.tsType) || 'void'
+  return `${typeParamsStr}(${params}) => ${ret}`
+}
 
-  if (type.kind === 'typeLiteral' && type.typeLiteral) {
-    const parts: string[] = []
-    for (const prop of type.typeLiteral.properties) {
-      const opt = prop.optional ? '?' : ''
-      const ro = prop.readonly ? 'readonly ' : ''
-      parts.push(`${ro}${prop.name}${opt}: ${formatType(prop.tsType) || 'unknown'}`)
-    }
-    for (const method of type.typeLiteral.methods) {
-      const params = method.params?.map(p => formatParam(p)).join(', ') || ''
-      const ret = formatType(method.returnType) || 'void'
-      parts.push(`${method.name}(${params}): ${ret}`)
-    }
-    return `{ ${parts.join('; ')} }`
+function formatTypeLiteralType(lit: NonNullable<TsType['typeLiteral']>): string {
+  const parts: string[] = []
+  for (const prop of lit.properties) {
+    const opt = prop.optional ? '?' : ''
+    const ro = prop.readonly ? 'readonly ' : ''
+    parts.push(`${ro}${prop.name}${opt}: ${formatType(prop.tsType) || 'unknown'}`)
   }
-
-  return type.repr ? stripAnsi(type.repr) : 'unknown'
+  for (const method of lit.methods) {
+    const params = method.params?.map(p => formatParam(p)).join(', ') || ''
+    const ret = formatType(method.returnType) || 'void'
+    parts.push(`${method.name}(${params}): ${ret}`)
+  }
+  return `{ ${parts.join('; ')} }`
 }