A modern programming language that makes developers happier.

kotlinlang

In Kotlin/JS, how can I initialize a _JavaScript_ Integer?

I'm creating typings for a library (Discord Embedded App SDK) and to set an activity they have a `Timestamps` object that expects two integers: A `start` and `end` timestamps. These timestamps are Epoch millis. The library expects integers for these timestamps: <https://discord.com/developers/docs/events/gateway-events#activity-object-activity-timestamps>

But that's where the issue lies: I can't figure out a way to initialize a JavaScript Integer!

• A Kotlin Int doesn't work because converting a epoch millis to a Kotlin Int causes it to overflow and go into the negatives
• A Kotlin Long doesn't work due to the way Kotlin Long works in Kotlin/JS
• A Kotlin BigInt doesn't work because the backend (in this case, Discord's RPC protocol) complains that it isn't a number
• A Kotlin String doesn't work because the backend complains that it isn't a number
The *only* way I found to make it work is by initializing the number via `js`, but I wonder if there's a better way to do this?

```                    discordSDK.commands.setActivity(
                        SetActivityRequest(
                            activity = Activity(
                                0, // Changes the top of the activity title in the profile
                                "PixelBloom",
                                "Placing pixels at ${cursor.value?.x}, ${cursor.value?.y}",
                                timestamps = Timestamps(
                                    start = js("new Date().getTime()")
                                )
                            ).also {
                                console.log("Generated Activity: ", it)
                            }
                        )
                    )```

Will Double do? Sure, it’s not an integer, but it’s the closest type to JS `number` that Kotlin has.

JS "integer" is just a double that happens to be integral

JS APIs that that want larger numbers but don't accept strings are pretty bad though, JS is unable to represent many exact integers above 2^53 (because that's the limit of using double-precision floating point numbers to represent integers)

Define the external using `Double`s.
```external class Timestamps(
  start: Double? = definedExternally,
  end: Double? = definedExternally,
)```
Which will then accept a `Date.now()` without conversion.

Or, if you prefer using Kotlin's built-in clock
```val start = Clock.System.now().toEpochMilliseconds()
timestamps = Timestamps(start = start.toDouble())```

`EpochTimeStamp` <https://github.com/JetBrains/kotlin-wrappers/blob/e5838e1a4a4234c066e661101be4a5d56d25a492/kotlin-web/src/webMain/generated/web/time/EpochTimeStamp.kt#L10|is here> :wink:

Potentially it can be opaque interface :wink:

Thanks everyone! I don't know why I didn't try using `Double` before but sure enough it worked :slightly_smiling_face:

```@JsPlainObject
external interface Timestamps {
    var start: Double?
    var end: Double?
}```
About the EpochTimeStamp, that would require something like this, right? <@U33H6SB2B>

```fun Long.toEpochTimeStamp() = this.toDouble().unsafeCast&lt;EpochTimeStamp&gt;()```
and then

```@JsPlainObject
external interface Timestamps {
    var start: EpochTimeStamp?
    var end: EpochTimeStamp?
}```
(this does work because EpochTimeStamp is a typealias of Int53 and Int53 is a typealias of Double, but I don't know if it is correct)

You can use `EpochTimeStamp` right now instead of `Double` .
No additional `unsafeCast` required.

In similar case we add interfaces (<https://github.com/JetBrains/kotlin-wrappers/blob/90d08f3085d727bdabb4ed36c099efe550893083/kotlin-cssom-core/src/webMain/generated/web/cssom/ClassName.kt#L7|like this>).
For numbers it's not so easy :(