refactor: use a typewriter factory

src/typeWriter/factory.ts

@@ -0,0 +1,49 @@
+import { Type } from 'ts-morph'
+import arrayTypeGenerator from './array'
+import enumTypeGenerator from './enum'
+import intersecionTypeGenerator from './intersection'
+import literalTypeGenerator from './literal'
+import objectTypeGenerator from './object'
+import simpleTypeGenerator from './simple'
+import unionTypeGenerator from './union'
+
+export default function factory(type: Type) {
+  switch (true) {
+    case type.isString():
+      return simpleTypeGenerator('String')
+
+    case type.isNumber():
+      return simpleTypeGenerator('Number')
+
+    case type.isBoolean():
+      return simpleTypeGenerator('Boolean')
+
+    case type.isArray():
+      return arrayTypeGenerator(type)
+
+    case type.isEnum():
+      return enumTypeGenerator(type)
+
+    case type.isIntersection():
+      return intersecionTypeGenerator(type)
+
+    case type.isUnion():
+      return unionTypeGenerator(type)
+
+    case type.isLiteral():
+      return literalTypeGenerator(type)
+
+    case type.isAny():
+      return simpleTypeGenerator('Unknown')
+
+    case type.isUndefined():
+      return simpleTypeGenerator('Undefined')
+
+    case type.isInterface():
+    case type.isObject():
+      return objectTypeGenerator(type)
+
+    default:
+      throw new Error('!!! TYPE ' + type.getText() + ' NOT PARSED !!!')
+  }
+}

src/typeWriter/generateOrReuseType.ts

@@ -1,6 +1,6 @@
 import { tryCatch } from '@johngw/error'
 import { Type } from 'ts-morph'
-import typeGenerator from './typeGenerator'
+import factory from './factory'
 import RuntypeGenerator from './RuntypeGenerator'
 import { Declare } from './symbols'
 
@@ -14,5 +14,5 @@ export default function* generateOrReuseType(type: Type): RuntypeGenerator {
     return
   }
 
-  yield* typeGenerator(type)
+  yield* factory(type)
 }

src/typeWriter/index.ts

@@ -8,7 +8,7 @@ import {
   VariableDeclarationKind,
 } from 'ts-morph'
 import { Declare, Import, ImportFromSource, Write } from './symbols'
-import typeGenerator from './typeGenerator'
+import factory from './factory'
 
 export default function writeRuntype(
   project: Project,
@@ -21,9 +21,15 @@ export default function writeRuntype(
 ) {
   const typeDeclaration = getTypeDeclaration(sourceFile, sourceType)
   const recursive = isRecursive(typeDeclaration)
-  const generator = typeGenerator(typeDeclaration.getType(), recursive)
+  const generator = factory(typeDeclaration.getType())
 
   let writer = project.createWriter()
+
+  if (recursive) {
+    runtypeImports.add('Lazy')
+    writer = writer.write('Lazy(() => ')
+  }
+
   let item = generator.next()
 
   while (!item.done) {
@@ -63,6 +69,10 @@ export default function writeRuntype(
     item = generator.next(next)
   }
 
+  if (recursive) {
+    writer = writer.write(')')
+  }
+
   targetFile.addVariableStatement({
     isExported: true,
     declarationKind: VariableDeclarationKind.Const,