A modern programming language that makes developers happier.

kotlinlang

What's the best way to make an external binding for a javascript function that takes a js object as a parameter?

```
Platform.select({
  ios: 'iOS',
  android: 'android',
});
```

I think this should work:
```kotlin
external interface Config {
    val ios: String
    val android: String
}

external object Platform {
    fun select(config: Config)
}
```

How would you recommend calling the select function?

would I then have to create a kotlin implementation of the Config interface and use that?

Is there no way to easily create a dynamic js object?

I found a better way. Should I be doing this, or is there maybe a better way?:
```
fun &lt;T&gt; Platform.select(ios: T, android: T): T {
  @Suppress("UnsafeCastFromDynamic")
  return select(
      jsObject {
        this.ios = ios
        this.android = android
      }
  )
}

inline fun jsObject(init: dynamic.() -&gt; Unit): dynamic {
  val o = jsObject()
  init(o)
  return o
}

fun jsObject(): dynamic = js("{}")
```

there is also standard `json`:
```json(
    "ios" to "something", 
    "android" to "something"
)```

Could I incorporate parameters into that by name?

Not sure what do you mean. You can just keep all the params as map (so can change them, add, remove) and then convert map to json using this function just before passing to js code

<@U1ZQ36CJD> Congrats with making it work. :smiley:
Yes, you could create an anonymous instance of `Config` and use that. Yes, that would be suboptimal performace-wise

In my opinion a simpler way to remedy that would be creating a factory function, which looks like a constructor:
```
fun Config(ios: String, android: String): Config {
    val res = js("{}")
    res.ios = ios
    res.android = android
    return res.unsafeCast&lt;Config&gt;()
}
```

Calling select looks like this: `Platform.select(Config("ios", "android"))`. This way you  won't need a special extension function for every usage of `Config`.