I wish there was a way to define an external interface that conforms to a normal interface. It feels like it could be done with an annotation or something that you put on a normal interface that tells the compiler not to expect getters.

Normal - your custom interface?

Imagine:

interface FooCommon {
    val bar: String
}

I want to be able to do:

external interface FooJs : FooCommon {
    val bar: String
}

fun parseJs(): FooCommon {
    val myDynamic = js("""{bar: "baz"}""")
    return myDynamic.unsafeCast<FooJs>()
}

Instead I have to do something like;

external interface FooJs {
    val bar: String
}


class FooCommonFromJs(private val fooJs: FooJs) : FooCommon {
    override val bar: String
        get() = fooJs.bar
}

fun parseJs(): FooCommon {
    val myDynamic = js("""{bar: "baz"}""")
    return FooCommonFromJs(myDynamic.unsafeCast<FooJs>())
}

We have

jso

for such cases

Ah, interesting I did not know about

jso

. It looks like it just casts whatever you pass as the type param, which I think is the equivalent of:

fun parseJs(): FooCommon {
    val myDynamic = js("""{bar: "baz"}""")
    return myDynamic.unsafeCast<FooCommon>()
}

Originally I tried this:

fun parseJs() {
    val myDynamic = js("""{bar: "baz"}""")
    val a = myDynamic.unsafeCast<FooCommon>()
    console.log(a.bar)
}

And it didn’t work because

FooCommon

was not

@JsExported

!!! It turns out, if you

@JsExport

a “normal” class, it forces the compiler to not generate JS properties that mirror the kotlin property names, and so an

unsafeCast()

will “just work”.

jso

recommended in any case