Migrate random module to use shared web declarations

Author: whyoleg

cryptography-random/build.gradle.kts

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023-2024 Oleg Yukhnevich. Use of this source code is governed by the Apache 2.0 license.
+ * Copyright (c) 2023-2025 Oleg Yukhnevich. Use of this source code is governed by the Apache 2.0 license.
  */
 
 import ckbuild.*
@@ -15,6 +15,10 @@ description = "cryptography-kotlin random API"
 kotlin {
     allTargets()
 
+    compilerOptions {
+        freeCompilerArgs.add("-Xexpect-actual-classes")
+    }
+
     applyDefaultHierarchyTemplate {
         common {
             group("linuxAndAndroidNative") {

cryptography-random/src/jsMain/kotlin/CryptographyRandom.js.kt

@@ -4,35 +4,6 @@
 
 package dev.whyoleg.cryptography.random
 
-import org.khronos.webgl.*
-
-internal actual fun defaultCryptographyRandom(): CryptographyRandom = WebCryptoCryptographyRandom
-
-private object WebCryptoCryptographyRandom : AbstractRandom() {
-    private const val MAX_ARRAY_SIZE = 65536
-    private val crypto: Crypto = getCrypto()
-    override fun fillBytes(array: ByteArray) {
-        fillBytes(array.unsafeCast<Int8Array>())
-    }
-
-    private fun fillBytes(jsArray: Int8Array) {
-        val size = jsArray.length
-        if (size <= MAX_ARRAY_SIZE) {
-            crypto.getRandomValues(jsArray)
-        } else {
-            var filled = 0
-            do {
-                val chunkSize = minOf(MAX_ARRAY_SIZE, size - filled)
-                crypto.getRandomValues(jsArray.subarray(filled, filled + chunkSize))
-                filled += chunkSize
-            } while (filled < size)
-        }
-    }
+internal actual inline fun ByteArray.useAsInt8Array(block: (array: Int8Array) -> Unit) {
+    block(this.unsafeCast<Int8Array>())
 }
-
-private external interface Crypto {
-    fun getRandomValues(array: Int8Array)
-}
-
-//language=JavaScript
-private fun getCrypto(): Crypto = js("(globalThis ? globalThis.crypto : (window.crypto || window.msCrypto))")

cryptography-random/src/wasmJsMain/kotlin/CryptographyRandom.wasmJs.kt

@@ -4,47 +4,10 @@
 
 package dev.whyoleg.cryptography.random
 
-internal actual fun defaultCryptographyRandom(): CryptographyRandom = WebCryptoCryptographyRandom
-
-private object WebCryptoCryptographyRandom : AbstractRandom() {
-    private const val MAX_ARRAY_SIZE = 65536
-    private val crypto: Crypto = getCrypto()
-    override fun fillBytes(array: ByteArray) {
-        val size = array.size
-        val jsArray = Int8Array(size)
-        fillBytes(jsArray)
-        repeat(size) { array[it] = jsArray[it] }
-    }
-
-    private fun fillBytes(jsArray: Int8Array) {
-        val size = jsArray.length
-        if (size <= MAX_ARRAY_SIZE) {
-            crypto.getRandomValues(jsArray)
-        } else {
-            var filled = 0
-            do {
-                val chunkSize = minOf(MAX_ARRAY_SIZE, size - filled)
-                crypto.getRandomValues(jsArray.subarray(filled, filled + chunkSize))
-                filled += chunkSize
-            } while (filled < size)
-        }
-    }
+internal actual inline fun ByteArray.useAsInt8Array(block: (array: Int8Array) -> Unit) {
+    val jsArray = Int8Array(size).apply(block)
+    repeat(size) { this[it] = getByte(jsArray, it) }
 }
 
-private external interface Crypto {
-    fun getRandomValues(array: Int8Array)
-}
-
-//language=JavaScript
-private fun getCrypto(): Crypto = js("(globalThis ? globalThis.crypto : (window.crypto || window.msCrypto))")
-
-private external class Int8Array {
-    constructor(length: Int)
-
-    val length: Int
-    fun subarray(start: Int, end: Int): Int8Array
-}
-
-private fun getImpl(obj: Int8Array, index: Int): Byte = js("obj[index]")
-
-private operator fun Int8Array.get(index: Int): Byte = getImpl(this, index)
+@OptIn(ExperimentalWasmJsInterop::class)
+private fun getByte(obj: Int8Array, index: Int): Byte = js("obj[index]")

cryptography-random/src/wasmWasiMain/kotlin/CryptographyRandom.wasmWasi.kt

@@ -1,10 +1,9 @@
 /*
- * Copyright (c) 2023-2024 Oleg Yukhnevich. Use of this source code is governed by the Apache 2.0 license.
+ * Copyright (c) 2023-2025 Oleg Yukhnevich. Use of this source code is governed by the Apache 2.0 license.
  */
 
 package dev.whyoleg.cryptography.random
 
-import kotlin.wasm.*
 import kotlin.wasm.unsafe.*
 
 internal actual fun defaultCryptographyRandom(): CryptographyRandom = WasiPreview1CryptographyRandom
@@ -25,5 +24,6 @@ private object WasiPreview1CryptographyRandom : AbstractRandom() {
     }
 }
 
+@OptIn(kotlin.wasm.ExperimentalWasmInterop::class)
 @WasmImport("wasi_snapshot_preview1", "random_get")
 private external fun wasiRandomGet(address: Int, size: Int): Int

cryptography-random/src/webMain/kotlin/CryptographyRandom.web.kt

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2023-2025 Oleg Yukhnevich. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+@file:OptIn(ExperimentalWasmJsInterop::class)
+
+package dev.whyoleg.cryptography.random
+
+import kotlin.js.*
+
+internal actual fun defaultCryptographyRandom(): CryptographyRandom = WebCryptoCryptographyRandom
+
+private object WebCryptoCryptographyRandom : AbstractRandom() {
+    private const val MAX_ARRAY_SIZE = 65536
+    private val crypto: Crypto = getCrypto()
+    override fun fillBytes(array: ByteArray): Unit = array.useAsInt8Array(::fillBytes)
+
+    private fun fillBytes(jsArray: Int8Array) {
+        val size = jsArray.length
+        if (size <= MAX_ARRAY_SIZE) {
+            crypto.getRandomValues(jsArray)
+        } else {
+            var filled = 0
+            do {
+                val chunkSize = minOf(MAX_ARRAY_SIZE, size - filled)
+                crypto.getRandomValues(jsArray.subarray(filled, filled + chunkSize))
+                filled += chunkSize
+            } while (filled < size)
+        }
+    }
+}
+
+private external interface Crypto {
+    fun getRandomValues(array: Int8Array)
+}
+
+//language=JavaScript
+private fun getCrypto(): Crypto = js("(globalThis ? globalThis.crypto : (window.crypto || window.msCrypto))")
+
+internal expect inline fun ByteArray.useAsInt8Array(block: (array: Int8Array) -> Unit)
+
+internal external class Int8Array(length: Int) {
+    val length: Int
+    fun subarray(start: Int, end: Int): Int8Array
+}