Support JS IR target

core/build.gradle.kts

@@ -20,6 +20,16 @@ kotlin {
         }
     }
 
+    js(IR) {
+        nodejs {
+            testTask {
+                useMocha {
+                    timeout = "30s"
+                }
+            }
+        }
+    }
+
     configureNativePlatforms()
     sourceSets {
         val commonMain by getting

core/common/src/files/Paths.kt

@@ -11,6 +11,8 @@ import kotlinx.io.Source
 /**
  * A wrapper around a string representing a file path allowing to read from and write to a
  * corresponding file using [Sink] and [Source].
+ *
+ * **This API is unstable and subject to change.**
  */
 public expect class Path
 

core/common/test/files/SmokeFileTest.kt

@@ -5,10 +5,7 @@
 
 package kotlinx.io.files
 
-import kotlinx.io.createTempFile
-import kotlinx.io.deleteFile
-import kotlinx.io.readUtf8Line
-import kotlinx.io.writeUtf8
+import kotlinx.io.*
 import kotlin.test.AfterTest
 import kotlin.test.BeforeTest
 import kotlin.test.Test
@@ -31,6 +28,7 @@ class SmokeFileTest {
     @Test
     fun testBasicFile() {
         val path = Path(tempFile!!)
+
         path.sink().use {
             it.writeUtf8("example")
         }
@@ -39,4 +37,20 @@ class SmokeFileTest {
             assertEquals("example", it.readUtf8Line())
         }
     }
+
+    @OptIn(ExperimentalStdlibApi::class)
+    @Test
+    fun testReadWriteMultipleSegments() {
+        val path = Path(tempFile!!)
+
+        val data = ByteArray((Segment.SIZE * 2.5).toInt()) { it.toByte() }
+
+        path.sink().use {
+            it.write(data)
+        }
+
+        path.source().use {
+            assertArrayEquals(data, it.readByteArray())
+        }
+    }
 }

core/js/src/-PlatfromJs.kt

@@ -0,0 +1,19 @@
+/*
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE.txt file.
+ */
+
+package kotlinx.io
+
+import kotlinx.io.internal.commonAsUtf8ToByteArray
+
+internal actual fun String.asUtf8ToByteArray(): ByteArray = commonAsUtf8ToByteArray()
+
+public actual open class IOException actual constructor(
+    message: String?,
+    cause: Throwable?
+) : Exception(message, cause) {
+    public actual constructor(message: String?) : this(message, null)
+}
+
+public actual open class EOFException actual constructor(message: String?) : IOException(message)

core/js/src/RawSink.kt

@@ -0,0 +1,15 @@
+/*
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE.txt file.
+ */
+
+package kotlinx.io
+
+@OptIn(ExperimentalStdlibApi::class)
+public actual interface RawSink : AutoCloseableAlias {
+    public actual fun write(source: Buffer, byteCount: Long)
+
+    public actual fun flush()
+
+    actual override fun close()
+}

core/js/src/SegmentPool.kt

@@ -0,0 +1,17 @@
+/*
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE.txt file.
+ */
+
+package kotlinx.io
+
+internal actual object SegmentPool {
+    actual val MAX_SIZE: Int = 0
+
+    actual val byteCount: Int = 0
+
+    actual fun take(): Segment = Segment()
+
+    actual fun recycle(segment: Segment) {
+    }
+}

core/js/src/files/PathsJs.kt

@@ -0,0 +1,112 @@
+/*
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE.txt file.
+ */
+
+package kotlinx.io.files
+
+import kotlinx.io.*
+
+private val fs: dynamic
+    get(): dynamic {
+        return try {
+            js("require('fs')")
+        } catch (t: Throwable) {
+            null
+        }
+    }
+
+private val buffer: dynamic
+    get(): dynamic {
+        return try {
+            js("require('buffer')")
+        } catch (t: Throwable) {
+            null
+        }
+    }
+
+public actual class Path internal constructor(private val path: String,
+                                              @Suppress("UNUSED_PARAMETER") any: Any?) {
+    override fun toString(): String = path
+}
+
+public actual fun Path(path: String): Path {
+    return Path(path, null)
+}
+
+public actual fun Path.source(): Source {
+    check(fs !== null) { "Module 'fs' was not found" }
+    return FileSource(this).buffered()
+}
+
+public actual fun Path.sink(): Sink {
+    check(fs !== null) { "Module 'fs' was not found" }
+    check(buffer !== null) { "Module 'buffer' was not found" }
+    return FileSink(this).buffered()
+}
+
+private class FileSource(private val path: Path) : RawSource {
+    private var buffer: dynamic = null
+    private var closed = false
+    private var offset = 0
+
+    @OptIn(ExperimentalUnsignedTypes::class)
+    override fun readAtMostTo(sink: Buffer, byteCount: Long): Long {
+        check(!closed) { "Source is closed." }
+        if (byteCount == 0L) {
+            return 0
+        }
+        if (buffer === null) {
+            buffer = fs.readFileSync(path.toString(), null)
+        }
+        val len: Int = buffer.length as Int
+        if (offset >= len) {
+            return -1L
+        }
+        val bytesToRead = minOf(byteCount, (len - offset))
+        for (i in 0 until bytesToRead) {
+            sink.writeByte(buffer.readInt8(offset++) as Byte)
+        }
+
+        return bytesToRead
+    }
+
+    override fun close() {
+        closed = true
+    }
+}
+
+private class FileSink(private val path: Path) : RawSink {
+    private var closed = false
+    private var append = false
+
+    override fun write(source: Buffer, byteCount: Long) {
+        check(!closed) { "Sink is closed." }
+        if (byteCount == 0L) {
+            return
+        }
+
+        var remainingBytes = minOf(byteCount, source.size)
+        while (remainingBytes > 0) {
+            val head = source.head!!
+            val segmentBytes = head.limit - head.pos
+            val buf = buffer.Buffer.allocUnsafe(segmentBytes)
+            buf.fill(head.data, head.pos, segmentBytes)
+            if (append) {
+                fs.appendFileSync(path.toString(), buf)
+            } else {
+                fs.writeFileSync(path.toString(), buf)
+                append = true
+            }
+
+            source.skip(segmentBytes.toLong())
+            remainingBytes -= segmentBytes
+        }
+    }
+
+    override fun flush() = Unit
+
+    override fun close() {
+        closed = true
+    }
+}

core/js/test/utils.kt

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE.txt file.
+ */
+
+package kotlinx.io
+
+import kotlin.random.Random
+import kotlin.random.nextULong
+
+private val os: dynamic
+    get(): dynamic {
+        return try {
+            js("require('os')")
+        } catch (t: Throwable) {
+            null
+        }
+    }
+
+private val fs: dynamic
+    get(): dynamic {
+        return try {
+            js("require('fs')")
+        } catch (t: Throwable) {
+            null
+        }
+    }
+
+private val nodePath: dynamic
+    get(): dynamic {
+        return try {
+            js("require('path')")
+        } catch (t: Throwable) {
+            null
+        }
+    }
+
+actual fun createTempFile(): String {
+    while (true) {
+        val tmpdir = os.tmpdir()
+        val filename = Random.nextULong().toString()
+        val fullpath = "$tmpdir${nodePath.sep}$filename.txt"
+
+        if (fs.existsSync(fullpath) as Boolean) {
+            continue
+        }
+        return fullpath
+    }
+}
+
+actual fun deleteFile(path: String) {
+    if (!fs.existsSync(path) as Boolean) {
+        throw IOException("File does not exist: $path")
+    }
+    fs.rmSync(path)
+}

core/native/src/files/PathsNative.kt

@@ -19,13 +19,13 @@ public actual class Path internal constructor(internal val path: String,
 public actual fun Path(path: String): Path = Path(path, null)
 
 public actual fun Path.source(): Source {
-    val openFile: CPointer<FILE> = fopen(path, "r")
+    val openFile: CPointer<FILE> = fopen(path, "rb")
         ?: throw IOException("Failed to open $path with ${strerror(errno)?.toKString()}")
     return FileSource(openFile).buffered()
 }
 
 public actual fun Path.sink(): Sink {
-    val openFile: CPointer<FILE> = fopen(path, "w")
+    val openFile: CPointer<FILE> = fopen(path, "wb")
         ?: throw IOException("Failed to open $path with ${strerror(errno)?.toKString()}")
     return FileSink(openFile).buffered()
 }