Add JavaScriptFoundationCompat module to provide utilities to interact Foundation types

kateinoigakukun · kateinoigakukun · commit 304116e04eaa · 2025-06-26T12:30:21.000+09:00
diff --git a/Package.swift b/Package.swift
@@ -106,6 +106,18 @@ let package = Package(
                 "JavaScriptEventLoopTestSupport",
             ]
         ),
+        .target(
+            name: "JavaScriptFoundationCompat",
+            dependencies: [
+                "JavaScriptKit"
+            ]
+        ),
+        .testTarget(
+            name: "JavaScriptFoundationCompatTests",
+            dependencies: [
+                "JavaScriptFoundationCompat"
+            ]
+        ),
         .plugin(
             name: "PackageToJS",
             capability: .command(
diff --git a/Sources/JavaScriptFoundationCompat/Data+JSValue.swift b/Sources/JavaScriptFoundationCompat/Data+JSValue.swift
@@ -0,0 +1,32 @@
+import Foundation
+import JavaScriptKit
+
+/// Data <-> Uint8Array conversion. The conversion is lossless and copies the bytes at most once per conversion
+extension Data: ConvertibleToJSValue, ConstructibleFromJSValue {
+    /// Convert a Data to a JSValue.
+    ///
+    /// - Returns: A Uint8Array that contains the bytes of the Data.
+    public var jsValue: JSValue {
+        self.withUnsafeBytes { buffer in
+            return JSTypedArray<UInt8>(buffer: buffer.bindMemory(to: UInt8.self)).jsValue
+        }
+    }
+
+    /// Construct a Data from a JSValue.
+    ///
+    /// - Parameter jsValue: The JSValue to construct a Data from.
+    /// - Returns: A Data, if the JSValue is a Uint8Array.
+    public static func construct(from jsValue: JSValue) -> Data? {
+        guard let uint8Array = JSTypedArray<UInt8>(from: jsValue) else {
+            // If the JSValue is not a Uint8Array, fail.
+            return nil
+        }
+        // First, allocate the data storage
+        var data = Data(count: uint8Array.lengthInBytes)
+        // Then, copy the byte contents into the Data buffer
+        data.withUnsafeMutableBytes { destinationBuffer in
+            uint8Array.copyMemory(to: destinationBuffer.bindMemory(to: UInt8.self))
+        }
+        return data
+    }
+}
diff --git a/Tests/JavaScriptFoundationCompatTests/Data+JSValueTests.swift b/Tests/JavaScriptFoundationCompatTests/Data+JSValueTests.swift
@@ -0,0 +1,55 @@
+import XCTest
+import Foundation
+import JavaScriptFoundationCompat
+import JavaScriptKit
+
+final class DataJSValueTests: XCTestCase {
+    func testDataToJSValue() {
+        let data = Data([0x00, 0x01, 0x02, 0x03])
+        let jsValue = data.jsValue
+
+        let uint8Array = JSTypedArray<UInt8>(from: jsValue)
+        XCTAssertEqual(uint8Array?.lengthInBytes, 4)
+        XCTAssertEqual(uint8Array?[0], 0x00)
+        XCTAssertEqual(uint8Array?[1], 0x01)
+        XCTAssertEqual(uint8Array?[2], 0x02)
+        XCTAssertEqual(uint8Array?[3], 0x03)
+    }
+
+    func testJSValueToData() {
+        let jsValue = JSTypedArray<UInt8>([0x00, 0x01, 0x02, 0x03]).jsValue
+        let data = Data.construct(from: jsValue)
+        XCTAssertEqual(data, Data([0x00, 0x01, 0x02, 0x03]))
+    }
+
+    func testDataToJSValue_withLargeData() {
+        let data = Data(repeating: 0x00, count: 1024 * 1024)
+        let jsValue = data.jsValue
+        let uint8Array = JSTypedArray<UInt8>(from: jsValue)
+        XCTAssertEqual(uint8Array?.lengthInBytes, 1024 * 1024)
+    }
+
+    func testJSValueToData_withLargeData() {
+        let jsValue = JSTypedArray<UInt8>(Array(repeating: 0x00, count: 1024 * 1024)).jsValue
+        let data = Data.construct(from: jsValue)
+        XCTAssertEqual(data?.count, 1024 * 1024)
+    }
+
+    func testDataToJSValue_withEmptyData() {
+        let data = Data()
+        let jsValue = data.jsValue
+        let uint8Array = JSTypedArray<UInt8>(from: jsValue)
+        XCTAssertEqual(uint8Array?.lengthInBytes, 0)
+    }
+
+    func testJSValueToData_withEmptyData() {
+        let jsValue = JSTypedArray<UInt8>([]).jsValue
+        let data = Data.construct(from: jsValue)
+        XCTAssertEqual(data, Data())
+    }
+
+    func testJSValueToData_withInvalidJSValue() {
+        let data = Data.construct(from: JSObject().jsValue)
+        XCTAssertNil(data)
+    }
+}
