Support for sealed classes

[bernerbrau]

Would be nice to see sealed class to union type support, e.g.

sealed class Thing {
  data class ThingOne(val value: String): Thing()
  data class ThingTwo(val otherValue: Int): Thing()
}

Would compile to:

interface ThingOne {
  value: string;
} 
interface ThingTwo {
  otherValue: number;
}
type Thing = ThingOne | ThingTwo;

[ntrrgc]

The problem is that TypeScript unions and sealed class don't map as much as I'd like.

The most striking difference is that sealed class are abstract classes, whereas named unions are not, and therefore they need to be omitted in the extends clause.

Also, sealed children may be defined either as a nested classes or separate classes in the same file (since Kotlin 1.1). Unfortunately there is no way to query sealed children in the later case.

[bernerbrau]

OK, so, check my PR - turns out sealed classes are more complicated than I initially thought. It also generates code (in a separate output property) to check if a JS object has a matching type; when working with union types this seemed necessary to implement. I did have to refactor the class visitor pattern a bit to make this work.

It may be more than you're looking for, and I haven't included unit tests, but it seems to work well on our Kotlin class model. I can add in some UTs if that helps.

It's true that there's no way using vanilla Kotlin or Java reflection to scan for subclasses. So I used the Reflections library to scan for subclasses; Reflections does some basic classpath scanning to accomplish this.

I'm also working on a gradle plugin to generate this on the fly for mixed-sourceset Kotlin and Node projects and/or multimodule projects.

[bernerbrau]

I've added in UTs for two basic typedef cases. I had to refactor the factory code that builds TypeScriptDefinitions since the union type made it much more complex.

The actual generated code that does type checking still needs UTs.