A modern programming language that makes developers happier.

kotlinlang

New to writing Kotlin wrappers, what is the correct way to wrap an object that consumes another object (i.e. `Foo({...})`)?

You want describe a JS class `Foo` that takes an object `{...}` of a particular shape as a constructor parameter. Did I understand you correctly?

Yeah that's the signature of the Javascript library

I just want to write the interop code (call existing Javascript from Kotlin)

That would be
```
external interface FooParameter {
    // ...
}

external class Foo(p: FooParameter) {
    // ...
}
```

<@UAZ8LS9KJ> Is there any good way to describe an object `{}` with optional parameters? Suppose `new Foo({})` accepts an object `{A: 'foo', B: 'bar'}`, where A or B may be undefined. In Kotlin we'd use default parameters on the constructor, what's the analogue for the wrapper?

You can default them to `definedExternally` <https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.js/defined-externally.html>

In case of interfaces one can do
```
external interface I {
    var A: String? get() = definedExternally; set(value) = definedExternally
    var B: String? get() = definedExternally; set(value) = definedExternally
}
```

Does this mean you need to create an implementation of `I` each time you want to pass it to `Foo`?

Yes, you would need a class or object that implements `I`. But you can also wrap the whole thing with a regular function that uses default parameters.

<@UKVL7G6MB> Could you configure `Foo` after creation?