When using Kotlin JS with libraries such as react, you may frequently create external interfaces for react props you want to use. They have to be external interfaces because they extend the external interface Props and Kotlin doesn’t like to extend external stuff with internal classes/interfaces.The problem is that if you want to specify required fields you have to essentially create a function wrapper to enforce which fields are required. In Typescript, using their equivalent to external interfaces, you get error messages if you don’t populate all fields not marked as nullable.
This is an error in TS:
interface ComponentProps{
name:string
description?:string
}
let test:ComponentProps={description:"test"} // error, property "name" is missing in type ...
The same in Kotlin would go through without problems/errors but obviously could lead to runtime errors. Using a class to wrap this would also not be very helpful since Kotlin classes may create an object that is not compatible with code that expects the external interface and the IDE will warn you of that also. So that leaves only functions to wrap these interfaces without any automation or IDE help in creating them.
Since external interfaces in Kotlin are really only there for its javascript support it seems it would be ok for them to behave a bit different than normal interfaces. The warnings in place when attempting to subclass already show that there are differences when using them but it seems like a conscious effort was made to keep them as close to existing interface behavior as possible leading in the end to making them more difficult to use in the JS setting they were meant to be used in.
Are there any plans to validate these external interfaces a little differently or is there another solution out there that doesn’t involve a lot of boilerplate every time an external interface is used?