simplify the API

Author: aSemy

docs/code/example/example-polymorphic-static-types-02.kt

@@ -22,6 +22,9 @@ val module = SerializersModule {
 }
 
 fun main() {
-  val tsGenerator = KxsTsGenerator(serializersModule = module)
+  val config = KxsTsConfig(serializersModule = module)
+
+  val tsGenerator = KxsTsGenerator(config)
+
   println(tsGenerator.generate(Project.serializer()))
 }

docs/polymorphism.md

@@ -105,7 +105,10 @@ val module = SerializersModule {
 }
 
 fun main() {
-  val tsGenerator = KxsTsGenerator(serializersModule = module)
+  val config = KxsTsConfig(serializersModule = module)
+
+  val tsGenerator = KxsTsGenerator(config)
+
   println(tsGenerator.generate(Project.serializer()))
 }
 ```

modules/kxs-ts-gen-core/src/commonMain/kotlin/dev.adamko.kxstsgen/KxsTsConvertorContext.kt

@@ -1,24 +1,47 @@
 package dev.adamko.kxstsgen
 
 import kotlinx.serialization.KSerializer
-import kotlinx.serialization.modules.SerializersModule
 
 
-class KxsTsGenerator(
-  private val config: KxsTsConfig = KxsTsConfig(),
-) {
+open class KxsTsGenerator(
+  val config: KxsTsConfig = KxsTsConfig(),
 
-  constructor(
-    serializersModule: SerializersModule,
-  ) : this(KxsTsConfig(serializersModule = serializersModule))
+  val descriptorsExtractor: SerializerDescriptorsExtractor = SerializerDescriptorsExtractor.Default,
 
+  val elementIdConverter: TsElementIdConverter = TsElementIdConverter.Default,
 
-  fun generate(vararg serializers: KSerializer<*>): String {
+  val mapTypeConverter: TsMapTypeConverter = TsMapTypeConverter.Default,
 
-    val processor = KxsTsProcessor(config)
+  val typeRefConverter: TsTypeRefConverter =
+    TsTypeRefConverter.Default(elementIdConverter, mapTypeConverter),
 
-    serializers.forEach { processor.addSerializer(it) }
+  val elementConverter: TsElementConverter =
+    TsElementConverter.Default(
+      elementIdConverter,
+      mapTypeConverter,
+      typeRefConverter,
+    ),
+
+  val sourceCodeGenerator: KxsTsSourceCodeGenerator = KxsTsSourceCodeGenerator.Default(config)
+) {
 
-    return processor.process()
+  fun generate(vararg serializers: KSerializer<*>): String {
+
+    val descriptors = serializers.flatMap { descriptorsExtractor(it) }.toSet()
+
+    val elements = descriptors.map { elementConverter(it) }
+
+    return elements
+      .groupBy { element -> sourceCodeGenerator.groupElementsBy(element) }
+      .mapValues { (_, elements) ->
+        elements
+          .filterIsInstance<TsDeclaration>()
+          .map { element -> sourceCodeGenerator.generateDeclaration(element) }
+          .filter { it.isNotBlank() }
+          .joinToString(config.declarationSeparator)
+      }
+      .values// TODO  create namespaces
+      .joinToString(config.declarationSeparator)
   }
+
 }

modules/kxs-ts-gen-core/src/commonMain/kotlin/dev.adamko.kxstsgen/KxsTsGenerator.kt

@@ -5,8 +5,7 @@ package dev.adamko.kxstsgen
  * Writes [TsElement]s as TypeScript source code.
  */
 abstract class KxsTsSourceCodeGenerator(
-  val config: KxsTsConfig,
-  val context: KxsTsConvertorContext,
+  val config: KxsTsConfig = KxsTsConfig(),
 ) {
 
   abstract fun groupElementsBy(element: TsElement): String?
@@ -32,8 +31,7 @@ abstract class KxsTsSourceCodeGenerator(
 
   open class Default(
     config: KxsTsConfig,
-    context: KxsTsConvertorContext,
-  ) : KxsTsSourceCodeGenerator(config, context) {
+  ) : KxsTsSourceCodeGenerator(config) {
 
 
     override fun groupElementsBy(element: TsElement): String {

modules/kxs-ts-gen-core/src/commonMain/kotlin/dev.adamko.kxstsgen/KxsTsProcessor.kt

@@ -12,38 +12,20 @@ import kotlinx.serialization.descriptors.elementNames
 fun interface TsElementConverter {
 
   operator fun invoke(
-    context: KxsTsConvertorContext,
     descriptor: SerialDescriptor,
-    descriptorData: DescriptorData?,
   ): TsElement
 
-  object Default : TsElementConverter {
+  open class Default(
+    val elementIdConverter: TsElementIdConverter,
+    val mapTypeConverter: TsMapTypeConverter,
+    val typeRefConverter: TsTypeRefConverter,
+  ) : TsElementConverter {
 
     override operator fun invoke(
-      context: KxsTsConvertorContext,
-      descriptor: SerialDescriptor,
-      descriptorData: DescriptorData?,
-    ): TsElement {
-      return convertMonomorphicDescriptor(context, descriptor)
-
-//      return when (descriptorData) {
-//        is DescriptorData.Polymorphic -> convertPolymorphicDescriptor(
-//          context,
-//          descriptorData,
-//        )
-//        null,
-//        is DescriptorData.Monomorphic -> setOf(convertMonomorphicDescriptor(context, descriptor))
-//      }
-
-    }
-
-
-    private fun convertMonomorphicDescriptor(
-      context: KxsTsConvertorContext,
       descriptor: SerialDescriptor,
     ): TsElement {
       return when (descriptor.kind) {
-        SerialKind.ENUM        -> convertEnum(context, descriptor)
+        SerialKind.ENUM        -> convertEnum(descriptor)
 
         PrimitiveKind.BOOLEAN  -> TsLiteral.Primitive.TsBoolean
 
@@ -57,31 +39,30 @@ fun interface TsElementConverter {
         PrimitiveKind.FLOAT,
         PrimitiveKind.DOUBLE   -> TsLiteral.Primitive.TsNumber
 
-        StructureKind.LIST     -> convertList(context, descriptor)
-        StructureKind.MAP      -> convertMap(context, descriptor)
+        StructureKind.LIST     -> convertList(descriptor)
+        StructureKind.MAP      -> convertMap(descriptor)
 
         StructureKind.CLASS,
         StructureKind.OBJECT   -> when {
-          descriptor.isInline -> convertTypeAlias(context, descriptor)
-          else                -> convertInterface(context, descriptor, null)
+          descriptor.isInline -> convertTypeAlias(descriptor)
+          else                -> convertInterface(descriptor, null)
         }
 
 
-        PolymorphicKind.SEALED -> convertPolymorphic(context, descriptor)
+        PolymorphicKind.SEALED -> convertPolymorphic(descriptor)
 
         // TODO handle contextual
         // TODO handle polymorphic open
         SerialKind.CONTEXTUAL,
         PolymorphicKind.OPEN   -> {
-          val resultId = context.elementId(descriptor)
+          val resultId = elementIdConverter(descriptor)
           val fieldTypeRef = TsTypeRef.Literal(TsLiteral.Primitive.TsAny, false)
           TsDeclaration.TsTypeAlias(resultId, fieldTypeRef)
         }
       }
     }
 
-    private fun convertPolymorphic(
-      context: KxsTsConvertorContext,
+    fun convertPolymorphic(
       descriptor: SerialDescriptor,
     ): TsDeclaration {
 
@@ -95,7 +76,7 @@ fun interface TsElementConverter {
         .elementDescriptors
 
       val subclassInterfaces = subclasses
-        .map { convertMonomorphicDescriptor(context, it) }
+        .map { this(it) }
         .filterIsInstance<TsDeclaration.TsInterface>()
         .map { it.copy(id = TsElementId("${descriptor.serialName}.${it.id.name}")) }
         .toSet()
@@ -106,31 +87,29 @@ fun interface TsElementConverter {
         else                   -> error("Can't convert non-polymorphic SerialKind ${descriptor.kind} to polymorphic interface")
       }
 
-      return convertInterface(context, descriptor, polymorphism)
+      return convertInterface(descriptor, polymorphism)
     }
 
 
-    private fun convertTypeAlias(
-      context: KxsTsConvertorContext,
+    fun convertTypeAlias(
       structDescriptor: SerialDescriptor,
     ): TsDeclaration {
-      val resultId = context.elementId(structDescriptor)
+      val resultId = elementIdConverter(structDescriptor)
       val fieldDescriptor = structDescriptor.elementDescriptors.first()
-      val fieldTypeRef = context.typeRef(fieldDescriptor)
+      val fieldTypeRef = typeRefConverter(fieldDescriptor)
       return TsDeclaration.TsTypeAlias(resultId, fieldTypeRef)
     }
 
 
-    private fun convertInterface(
-      context: KxsTsConvertorContext,
+    fun convertInterface(
       descriptor: SerialDescriptor,
       polymorphism: TsPolymorphism?,
     ): TsDeclaration {
-      val resultId = context.elementId(descriptor)
+      val resultId = elementIdConverter(descriptor)
 
       val properties = descriptor.elementDescriptors.mapIndexed { index, fieldDescriptor ->
         val name = descriptor.getElementName(index)
-        val fieldTypeRef = context.typeRef(fieldDescriptor)
+        val fieldTypeRef = typeRefConverter(fieldDescriptor)
         when {
           descriptor.isElementOptional(index) -> TsProperty.Optional(name, fieldTypeRef)
           else                                -> TsProperty.Required(name, fieldTypeRef)
@@ -140,36 +119,33 @@ fun interface TsElementConverter {
     }
 
 
-    private fun convertEnum(
-      context: KxsTsConvertorContext,
+    fun convertEnum(
       enumDescriptor: SerialDescriptor,
     ): TsDeclaration.TsEnum {
-      val resultId = context.elementId(enumDescriptor)
+      val resultId = elementIdConverter(enumDescriptor)
       return TsDeclaration.TsEnum(resultId, enumDescriptor.elementNames.toSet())
     }
 
 
-    private fun convertList(
-      context: KxsTsConvertorContext,
+    fun convertList(
       listDescriptor: SerialDescriptor,
     ): TsLiteral.TsList {
       val elementDescriptor = listDescriptor.elementDescriptors.first()
-      val elementTypeRef = context.typeRef(elementDescriptor)
+      val elementTypeRef = typeRefConverter(elementDescriptor)
       return TsLiteral.TsList(elementTypeRef)
     }
 
 
-    private fun convertMap(
-      context: KxsTsConvertorContext,
+    fun convertMap(
       mapDescriptor: SerialDescriptor,
     ): TsLiteral.TsMap {
 
       val (keyDescriptor, valueDescriptor) = mapDescriptor.elementDescriptors.toList()
 
-      val keyTypeRef = context.typeRef(keyDescriptor)
-      val valueTypeRef = context.typeRef(valueDescriptor)
+      val keyTypeRef = typeRefConverter(keyDescriptor)
+      val valueTypeRef = typeRefConverter(valueDescriptor)
 
-      val type = context.mapType(keyDescriptor)
+      val type = mapTypeConverter(keyDescriptor)
 
       return TsLiteral.TsMap(keyTypeRef, valueTypeRef, type)
     }