Add helper method to copy an array of FixedWidthIntegers to a JS TypedArray

Author: j-f1

IntegrationTests/TestSuites/Sources/PrimaryTests/main.swift

@@ -334,3 +334,10 @@ ObjectRef_Lifetime: do {
 } catch {
     print(error)
 }
+
+TypedArray: do {
+    let numbers = [UInt8](0 ... 255)
+    let typedArray = JSObjectRef.createTypedArray(numbers)
+    try expectEqual(typedArray[12], .number(12))
+    try expectEqual(typedArray.toString!(), .string(numbers.map(String.init).joined(separator: ",")))
+}

Runtime/src/index.ts

@@ -31,6 +31,32 @@ enum JavaScriptValueKind {
     Function = 6,
 }
 
+enum JavaScriptTypedArrayKind {
+    Int8 = 0,
+    Uint8 = 1,
+    Int16 = 2,
+    Uint16 = 3,
+    Int32 = 4,
+    Uint32 = 5,
+    BigInt64 = 6,
+    BigUint64 = 7,
+    Float32 = 8,
+    Float64 = 9,
+}
+
+type TypedArray =
+    | Int8ArrayConstructor
+    | Uint8ArrayConstructor
+    | Int16ArrayConstructor
+    | Uint16ArrayConstructor
+    | Int32ArrayConstructor
+    | Uint32ArrayConstructor
+    // | BigInt64ArrayConstructor
+    // | BigUint64ArrayConstructor
+    | Float32ArrayConstructor
+    | Float64ArrayConstructor
+
+
 type SwiftRuntimeHeapEntry = {
     id: number,
     rc: number,
@@ -370,6 +396,16 @@ export class SwiftRuntime {
               const constructor = this.heap.referenceHeap(constructor_ref)
               return obj instanceof constructor
             },
+            swjs_copy_typed_array_content: (
+                kind: JavaScriptTypedArrayKind,
+                elementsPtr: pointer, length: number,
+                result_obj: pointer
+            ) => {
+                const ArrayType: TypedArray = this.heap.referenceHeap(0)[JavaScriptTypedArrayKind[kind] + 'Array']
+                const array = new ArrayType(memory().buffer, elementsPtr, length);
+                // Call `.slice()` to copy the memory
+                writeUint32(result_obj, this.heap.allocHeap(array.slice()));
+            },
             swjs_destroy_ref: (ref: ref) => {
                 this.heap.freeHeap(ref)
             }

Sources/JavaScriptKit/JSObject.swift

@@ -67,4 +67,67 @@ public class JSObjectRef: Equatable {
     public class func canDecode(from jsValue: JSValue) -> Bool {
         return jsValue.isObject
     }
+
+    public class func createTypedArray<Type>(_ array: [Type]) -> JSObjectRef where Type: TypedArrayElement {
+        let type: JavaScriptTypedArrayKind
+        switch Type.self {
+        case is Int8.Type:
+            type = .int8
+        case is UInt8.Type:
+            type = .uint8
+        case is Int16.Type:
+            type = .int16
+        case is UInt16.Type:
+            type = .uint16
+        case is Int32.Type:
+            type = .int32
+        case is UInt32.Type:
+            type = .uint32
+        case is Int64.Type:
+            type = .bigInt64
+        case is UInt64.Type:
+            type = .bigUint64
+        case is Float32.Type:
+            type = .float32
+        case is Float64.Type:
+            type = .float64
+        default:
+            if Type.self is UInt.Type || Type.self is Int.Type {
+                if UInt.bitWidth == 32 {
+                    if Type.self is UInt.Type {
+                        type = .uint32
+                    } else {
+                        type = .int32
+                    }
+                } else if UInt.bitWidth == 64 {
+                    if Type.self is UInt.Type {
+                        type = .bigUint64
+                    } else {
+                        type = .bigInt64
+                    }
+                } else {
+                    fatalError("Unsupported bit width type for UInt: \(UInt.bitWidth) (hint: stick to fixed-size ints to avoid this issue)")
+                }
+            } else {
+                fatalError("Unsupported Swift type for TypedArray: \(Type.self)")
+            }
+        }
+        var resultObj = JavaScriptObjectRef()
+        array.withUnsafeBufferPointer { ptr in
+            _copy_typed_array_content(type, ptr.baseAddress!, Int32(array.count), &resultObj)
+        }
+        return JSObjectRef(id: resultObj)
+    }
 }
+
+public protocol TypedArrayElement {}
+extension Int8: TypedArrayElement {}
+extension UInt8: TypedArrayElement {}
+extension Int16: TypedArrayElement {}
+extension UInt16: TypedArrayElement {}
+extension Int32: TypedArrayElement {}
+extension UInt32: TypedArrayElement {}
+extension Int64: TypedArrayElement {}
+extension UInt64: TypedArrayElement {}
+extension Float32: TypedArrayElement {}
+extension Float64: TypedArrayElement {}

Sources/JavaScriptKit/XcodeSupport.swift

@@ -73,4 +73,11 @@ import _CJavaScriptKit
         _: UnsafePointer<JavaScriptObjectRef>!
     ) { fatalError() }
     func _destroy_ref(_: JavaScriptObjectRef) { fatalError() }
+    func _copy_typed_array_content<T: TypedArrayElement>(
+        _: JavaScriptTypedArrayKind,
+        _: UnsafePointer<T>,
+        _: Int32,
+        _: UnsafeMutablePointer<JavaScriptObjectRef>!
+    ) { fatalError() }
+
 #endif

Sources/_CJavaScriptKit/include/_CJavaScriptKit.h

@@ -18,6 +18,20 @@ typedef enum __attribute__((enum_extensibility(closed))) {
   JavaScriptValueKindFunction = 6,
 } JavaScriptValueKind;
 
+typedef enum __attribute__((enum_extensibility(closed))) {
+    JavaScriptTypedArrayKindInt8 = 0,
+    JavaScriptTypedArrayKindUint8 = 1,
+    JavaScriptTypedArrayKindInt16 = 2,
+    JavaScriptTypedArrayKindUint16 = 3,
+    JavaScriptTypedArrayKindInt32 = 4,
+    JavaScriptTypedArrayKindUint32 = 5,
+    JavaScriptTypedArrayKindBigInt64 = 6,
+    JavaScriptTypedArrayKindBigUint64 = 7,
+    JavaScriptTypedArrayKindFloat32 = 8,
+    JavaScriptTypedArrayKindFloat64 = 9,
+} JavaScriptTypedArrayKind;
+
+
 typedef unsigned JavaScriptPayload1;
 typedef unsigned JavaScriptPayload2;
 typedef double JavaScriptPayload3;
@@ -97,6 +111,14 @@ __attribute__((__import_module__("javascript_kit"),
                __import_name__("swjs_destroy_ref"))) extern void
 _destroy_ref(const JavaScriptObjectRef ref);
 
+__attribute__((
+               __import_module__("javascript_kit"),
+               __import_name__("swjs_copy_typed_array_content")
+               ))
+extern void _copy_typed_array_content(const JavaScriptTypedArrayKind kind,
+                                      const void *elementsPtr, const int length,
+                                      JavaScriptObjectRef *result_obj);
+
 #endif
 
 #endif /* _CJavaScriptKit_h */