[WIP] Wasm support

gradle/libs.versions.toml

@@ -5,8 +5,8 @@ buildconfig = "5.1.0"
 gradle-publish = "1.2.1"
 nexus-publish = "1.3.0"
 detekt = "1.23.4"
-nodejs = "18.14.1"
-yarn = "1.22.19"
+nodejs = "21.4.0"
+yarn = "1.22.21"
 
 [plugins]
 kotlin-multiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin" }

resources-library/build.gradle.kts

@@ -35,6 +35,11 @@ kotlin {
         nodejs()
     }
 
+    wasmJs {
+        browser()
+        nodejs()
+    }
+
     iosArm64()
     iosX64()
     iosSimulatorArm64()
@@ -60,6 +65,14 @@ kotlin {
         }
 
         val commonMain by getting
+        val jsMain by getting
+        val wasmJsMain by getting
+        val jsSharedMain by creating {
+            dependsOn(commonMain)
+            jsMain.dependsOn(this)
+            wasmJsMain.dependsOn(this)
+        }
+
         val mingwX64Main by getting
         val linuxX64Main by getting
         val linuxArm64Main by getting

resources-library/src/jsMain/kotlin/Resource.kt → resources-library/src/jsSharedMain/kotlin/Resource.kt

@@ -4,6 +4,23 @@ import org.khronos.webgl.Int8Array
 import org.khronos.webgl.Uint8Array
 import org.w3c.xhr.XMLHttpRequest
 
+private fun hasNodeApi(): Boolean = js("""{
+    (typeof process !== 'undefined' 
+        && process.versions != null 
+        && process.versions.node != null) ||
+    (typeof window !== 'undefined' 
+        && typeof window.process !== 'undefined' 
+        && window.process.versions != null 
+        && window.process.versions.node != null)
+}"""
+)
+
+private fun readFileSync(path: String, options: String): String = js("require('fs').readFileSync(path, options)")
+
+private fun readFileSync(path: String): Uint8Array = js("require('fs').readFileSync(path)")
+
+private fun existsSync(path: String): Boolean = js("require('fs').existsSync(path)")
+
 /*
  * It's impossible to separate browser/node JS runtimes, as they can't be published separately.
  * See: https://youtrack.jetbrains.com/issue/KT-47038
@@ -14,32 +31,27 @@ public actual class Resource actual constructor(path: String) {
     private val resourceBrowser: ResourceBrowser by lazy { ResourceBrowser(path) }
     private val resourceNode: ResourceNode by lazy { ResourceNode(path) }
 
-    public actual fun exists(): Boolean = when {
-        IS_BROWSER -> resourceBrowser.exists()
-        IS_NODE -> resourceNode.exists()
-        else -> throw UnsupportedOperationException("Unsupported JS runtime")
+    public actual fun exists(): Boolean = if (HAS_NODE_API) {
+        resourceNode.exists()
+    } else {
+        resourceBrowser.exists()
     }
 
-    public actual fun readText(): String = when {
-        IS_BROWSER -> resourceBrowser.readText()
-        IS_NODE -> resourceNode.readText()
-        else -> throw UnsupportedOperationException("Unsupported JS runtime")
+    public actual fun readText(): String = if (HAS_NODE_API) {
+        resourceNode.readText()
+    } else {
+        resourceBrowser.readText()
     }
 
-    public actual fun readBytes(): ByteArray = when {
-        IS_BROWSER -> resourceBrowser.readBytes()
-        IS_NODE -> resourceNode.readBytes()
-        else -> throw UnsupportedOperationException("Unsupported JS runtime")
+    public actual fun readBytes(): ByteArray = if (HAS_NODE_API) {
+        resourceNode.readBytes()
+    } else {
+        resourceBrowser.readBytes()
     }
 
     private companion object {
         @Suppress("MaxLineLength")
-        private val IS_BROWSER: Boolean = js(
-            "typeof window !== 'undefined' && typeof window.document !== 'undefined' || typeof self !== 'undefined' && typeof self.location !== 'undefined'"
-        ) as Boolean
-        private val IS_NODE: Boolean = js(
-            "typeof process !== 'undefined' && process.versions != null && process.versions.node != null"
-        ) as Boolean
+        private val HAS_NODE_API: Boolean = hasNodeApi()
     }
 
     /*
@@ -80,31 +92,17 @@ public actual class Resource actual constructor(path: String) {
      * Node-based resource implementation.
      */
     private class ResourceNode(val path: String) {
-        val fs = nodeRequire("fs")
-
-        private fun nodeRequire(name: String): dynamic {
-            // Alternative to declaring `private external fun require(name: String): dynamic` and
-            // using `require("fs")` directly, since it will cause webpack to complain when running
-            // on the browser, even though the code is unused.
-
-            return try {
-                js("module['' + 'require']")(name)
-            } catch (e: dynamic) {
-                throw IllegalArgumentException("Module not found: $name", e as? Throwable)
-            }
-        }
-
-        fun exists(): Boolean = fs.existsSync(path) as Boolean
+        fun exists(): Boolean = existsSync(path)
 
         fun readText(): String = runCatching {
-            fs.readFileSync(path, "utf8") as String
+            readFileSync(path, "utf8")
         }.getOrElse { cause ->
             throw FileReadException("$path: Read failed", cause)
         }
 
         fun readBytes(): ByteArray = runCatching {
-            val buffer = fs.readFileSync(path).unsafeCast<Uint8Array>()
-            Int8Array(buffer.buffer, buffer.byteOffset, buffer.length).unsafeCast<ByteArray>()
+            val buffer = readFileSync(path)
+            Int8Array(buffer.buffer, buffer.byteOffset, buffer.length) as ByteArray
         }.getOrElse { cause ->
             throw FileReadException("$path: Read failed", cause)
         }

resources-test/build.gradle.kts

@@ -46,6 +46,17 @@ kotlin {
         nodejs()
     }
 
+    wasmJs {
+        browser {
+            testTask {
+                useKarma {
+                    useAnyBrowser()
+                }
+            }
+        }
+        nodejs()
+    }
+
     iosArm64()
     iosX64()
     iosSimulatorArm64()