From 2ca00fe6a4150f5fed222232781809fcf667e8a4 Mon Sep 17 00:00:00 2001
From: Daniel Tschinder <231804+danez@users.noreply.github.com>
Date: Fri, 22 Dec 2023 12:10:23 +0100
Subject: [PATCH] Refactor code to prepare for future support of enums for
 example

---
 packages/react-docgen/src/utils/getTSType.ts | 37 ++++++++++++++------
 1 file changed, 26 insertions(+), 11 deletions(-)

diff --git a/packages/react-docgen/src/utils/getTSType.ts b/packages/react-docgen/src/utils/getTSType.ts
index c938bf9470b..311bbf5a8fc 100644
--- a/packages/react-docgen/src/utils/getTSType.ts
+++ b/packages/react-docgen/src/utils/getTSType.ts
@@ -36,6 +36,7 @@ import type {
   TypeScript,
   TSQualifiedName,
   TSLiteralType,
+  TSTypeAliasDeclaration,
 } from '@babel/types';
 import { getDocblock } from './docblock.js';
 
@@ -54,6 +55,8 @@ const tsTypes: Record<string, string> = {
   TSVoidKeyword: 'void',
 };
 
+const UNKNOWN_TYPE = Object.freeze({ name: 'unknown' }) as SimpleType;
+
 const namedTypes: Record<
   string,
   (
@@ -71,6 +74,7 @@ const namedTypes: Record<
   TSIntersectionType: handleTSIntersectionType,
   TSMappedType: handleTSMappedType,
   TSTupleType: handleTSTupleType,
+  TSTypeAliasDeclaration: handleTSTypeAliasDeclaration,
   TSTypeQuery: handleTSTypeQuery,
   TSTypeOperator: handleTSTypeOperator,
   TSIndexedAccessType: handleTSIndexedAccessType,
@@ -113,6 +117,15 @@ function handleTSArrayType(
   };
 }
 
+function handleTSTypeAliasDeclaration(
+  path: NodePath<TSTypeAliasDeclaration>,
+  typeParams: TypeParameters | null,
+): TypeDescriptor<TSFunctionSignatureType> {
+  const resolvedTypeAnnotation = path.get('typeAnnotation');
+
+  return getTSTypeWithResolvedTypes(resolvedTypeAnnotation, typeParams);
+}
+
 function handleTSTypeReference(
   path: NodePath<TSTypeReference>,
   typeParams: TypeParameters | null,
@@ -127,8 +140,7 @@ function handleTSTypeReference(
   }
 
   const resolvedPath =
-    (typeParams && typeParams[type.name]) ||
-    resolveToValue(path.get('typeName'));
+    (typeParams && typeParams[type.name]) || resolveToValue(typeName);
 
   const typeParameters = path.get('typeParameters');
   const resolvedTypeParameters = resolvedPath.get('typeParameters') as NodePath<
@@ -149,15 +161,18 @@ function handleTSTypeReference(
       resolvedPath as NodePath<TSType | TSTypeAnnotation>,
       null,
     );
-  }
+  } else if (resolvedPath !== typeName) {
+    const resolvedType = getTSTypeWithResolvedTypes(
+      resolvedPath as NodePath<TSType | TSTypeAnnotation>,
+      typeParams,
+    );
 
-  const resolvedTypeAnnotation = resolvedPath.get('typeAnnotation') as NodePath<
-    TSType | TSTypeAnnotation | null | undefined
-  >;
+    if (resolvedType !== UNKNOWN_TYPE) {
+      return resolvedType;
+    }
+  }
 
-  if (resolvedTypeAnnotation.hasNode()) {
-    type = getTSTypeWithResolvedTypes(resolvedTypeAnnotation, typeParams);
-  } else if (typeParameters.hasNode()) {
+  if (typeParameters.hasNode()) {
     const params = typeParameters.get('params');
 
     type = {
@@ -479,7 +494,7 @@ function handleTSIndexedAccessType(
   });
 
   if (!resolvedType) {
-    return { name: 'unknown' };
+    return UNKNOWN_TYPE;
   }
 
   return {
@@ -533,7 +548,7 @@ function getTSTypeWithResolvedTypes(
   }
 
   if (!type) {
-    type = { name: 'unknown' };
+    type = UNKNOWN_TYPE;
   }
 
   if (typeAliasName) {