hack: nullable type in template

Author: commandblock2

src/main/kotlin/me/ntrrgc/tsGenerator/TypeScriptGenerator.kt

@@ -152,18 +152,22 @@ class TypeScriptGenerator(
         }
 
 
-        private fun formatKType(kType: KType): TypeScriptType {
+        private fun formatKType(kType: KType, isInTypeConstraint: Boolean = false): TypeScriptType {
             val classifier = kType.classifier
             if (classifier is KClass<*>) {
                 val existingMapping = predefinedMappings[classifier]
                 if (existingMapping != null) {
-                    return TypeScriptType.single(predefinedMappings[classifier]!!, kType.isMarkedNullable, voidType)
+                    // When in a type constraint, we shouldn't add the nullable union type
+                    return TypeScriptType.single(
+                        predefinedMappings[classifier]!!,
+                        kType.isMarkedNullable && !isInTypeConstraint,
+                        voidType
+                    )
                 }
                 if (!shouldIgnoreSuperclass(classifier) && !isSameClass(classifier, klass))
                     dependentTypes.add(classifier)
             }
 
-
             val classifierTsType =
                 if (classifier is KClass<*>) {
                     predefinedMappings.getOrDefault(
@@ -186,9 +190,11 @@ class TypeScriptGenerator(
                 else
                     "UNKNOWN" // giving up
 
-            return TypeScriptType.single(classifierTsType, kType.isMarkedNullable, voidType)
+            // When in a type constraint, we shouldn't add the nullable union type
+            return TypeScriptType.single(classifierTsType, kType.isMarkedNullable && !isInTypeConstraint, voidType)
         }
 
+
         private fun nonPrimitiveFromKType(kType: KType): String {
             val kClass = kType.classifier as KClass<*>
             val binaryName = kClass.binaryName()
@@ -207,15 +213,16 @@ class TypeScriptGenerator(
                 return binaryName + if (kClass.typeParameters.isNotEmpty()) "<${
                     (1..kClass.typeParameters.size).joinToString(
                         ", "
-                    ) { "Any" }
+                    ) { "Object" }
                 }>" else ""
             }
 
             // Only add generic parameters if counts match
             return binaryName + if (kType.arguments.isNotEmpty()) {
                 "<" + kType.arguments.joinToString(", ") { arg ->
                     formatKType(
-                        arg.type ?: KotlinAnyOrNull
+                        arg.type ?: KotlinNotNull,
+                        true
                     ).formatWithoutParenthesis()
                 } + ">"
             } else ""
@@ -324,7 +331,8 @@ class TypeScriptGenerator(
                     val bounds = typeParameter.upperBounds
                     typeParameter.name + if (bounds.isNotEmpty()) {
                         " extends " + bounds.joinToString(" & ") { bound ->
-                            formatKType(bound).formatWithoutParenthesis()
+                            // Pass true for isInTypeConstraint
+                            formatKType(bound, true).formatWithoutParenthesis()
                         }
                     } else {
                         ""
@@ -335,6 +343,7 @@ class TypeScriptGenerator(
             }
 
 
+
             return "$typeKeyword ${klass.binaryName()}$templateParameters$extendsString{\n" +
                     staticFieldsOf(klass) +
                     (if (klass.java.isInterface) "" else staticMethodsOf(klass, interfaceSupertypes)) +
@@ -695,6 +704,7 @@ class TypeScriptGenerator(
 
     companion object {
         private val KotlinAnyOrNull = Any::class.createType(nullable = true)
+        private val KotlinNotNull = Any::class.createType(nullable = false)
 
         fun isJavaBeanProperty(kProperty: KProperty<*>, klass: KClass<*>): Boolean {
             val beanInfo = Introspector.getBeanInfo(klass.java)