A modern programming language that makes developers happier.

kotlinlang

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.

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&lt;FooJs&gt;()
}```

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&lt;FooJs&gt;())
}```

Expected implementation:
```fun parseJs(): FooCommon =
    jso {
       bar = "baz"
    }```

<https://github.com/karakum-team/kotlin-react-table-sample/blob/9f81caf5fc0d640e93d8a398b9e4de37a3fe99f5/src/main/kotlin/team/karakum/components/UserTable.kt#L38|Example>

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&lt;FooCommon&gt;()
}```
Originally I tried this:

```fun parseJs() {
    val myDynamic = js("""{bar: "baz"}""")
    val a = myDynamic.unsafeCast&lt;FooCommon&gt;()
    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”.

So, for posterity, I think the solution here is:

```@JsExport
interface FooCommon {
    val bar: String
}


fun parseJs(): FooCommon {
    val myDynamic = js("""{bar: "baz"}""")
    return myDynamic.unsafeCast&lt;FooCommon&gt;()
}```

in future Kotlin is see following variant:
```@JsExport
@ExternalInJsPleas
interface FooCommon {
    val bar: String
}


fun parseJs(): FooCommon {
   FooCommon(bar = "baz")
}```
