Support Number interpolation

Author: kateinoigakukun

src/swift/Sources/JavaScriptKit/JSValue.swift

@@ -19,6 +19,7 @@ public class JSRef: Equatable {
 public enum JSValue: Equatable {
     case boolean(Bool)
     case string(String)
+    case number(Int32)
     case object(JSRef)
 }
 
@@ -44,6 +45,8 @@ public func getJSValue(this: JSRef, name: String) -> JSValue {
         fatalError()
     case JavaScriptValueKind_Boolean:
         return .boolean(payload1 != 0)
+    case JavaScriptValueKind_Number:
+        return .number(Int32(bitPattern: payload1))
     case JavaScriptValueKind_String:
         let buffer = malloc(Int(payload2))!.assumingMemoryBound(to: UInt8.self)
         _load_string(payload1 as JavaScriptValueId, buffer)
@@ -66,6 +69,10 @@ public func setJSValue(this: JSRef, name: String, value: JSValue) {
         kind = JavaScriptValueKind_Boolean
         payload1 = boolValue ? 1 : 0
         payload2 = 0
+    case let .number(numberValue):
+        kind = JavaScriptValueKind_Number
+        payload1 = JavaScriptPayload(bitPattern: numberValue)
+        payload2 = 0
     case var .string(stringValue):
         kind = JavaScriptValueKind_String
         stringValue.withUTF8 { bufferPtr in

src/web/src/index.ts

@@ -75,10 +75,10 @@ export class SwiftRuntime {
 
         const writeUint32 = (ptr: pointer, value: number) => {
             const uint8Memory = new Uint8Array(memory().buffer);
-            uint8Memory[ptr + 0] = value & 0x000000ff
-            uint8Memory[ptr + 1] = value & 0x0000ff00
-            uint8Memory[ptr + 2] = value & 0x00ff0000
-            uint8Memory[ptr + 3] = value & 0xff000000
+            uint8Memory[ptr + 0] = (value & 0x000000ff) >> 0
+            uint8Memory[ptr + 1] = (value & 0x0000ff00) >> 8
+            uint8Memory[ptr + 2] = (value & 0x00ff0000) >> 16
+            uint8Memory[ptr + 3] = (value & 0xff000000) >> 24
         }
 
         const decodeValue = (
@@ -92,6 +92,9 @@ export class SwiftRuntime {
                         case 1: return true
                     }
                 }
+                case JavaScriptValueKind.Number: {
+                    return payload1
+                }
                 case JavaScriptValueKind.String: {
                     return readString(payload1, payload2)
                 }
@@ -105,12 +108,20 @@ export class SwiftRuntime {
 
         const encodeValue = (value: any) => {
             switch (typeof value) {
-                case "boolean":
+                case "boolean": {
                     return {
                         kind: JavaScriptValueKind.Boolean,
                         payload1: value ? 1 : 0,
                         payload2: 0,
                     }
+                }
+                case "number": {
+                    return {
+                        kind: JavaScriptValueKind.Number,
+                        payload1: value,
+                        payload2: 0,
+                    }
+                }
                 case "string": {
                     return {
                         kind: JavaScriptValueKind.String,

test/JavaScriptKitExec/Sources/JavaScriptKitExec/UnitTestUtils.swift

@@ -0,0 +1,38 @@
+import JavaScriptKit
+
+struct MessageError: Error {
+    let message: String
+    init(_ message: String) {
+        self.message = message
+    }
+}
+
+func expectEqual<T: Equatable>(_ lhs: T, _ rhs: T) throws {
+    if lhs != rhs {
+        throw MessageError("Expect to be equal \"\(lhs)\" and \"\(rhs)\"")
+    }
+}
+
+func expectObject(_ value: JSValue) throws -> JSRef {
+    switch value {
+    case .object(let ref): return ref
+    default:
+        throw MessageError("Type of \(value) should be \"object\"")
+    }
+}
+
+func expectBoolean(_ value: JSValue) throws -> Bool {
+    switch value {
+    case .boolean(let bool): return bool
+    default:
+        throw MessageError("Type of \(value) should be \"boolean\"")
+    }
+}
+
+func expectNumber(_ value: JSValue) throws -> Int32 {
+    switch value {
+    case .number(let number): return number
+    default:
+        throw MessageError("Type of \(value) should be \"boolean\"")
+    }
+}

test/JavaScriptKitExec/Sources/JavaScriptKitExec/main.swift

@@ -1,40 +1,14 @@
 import JavaScriptKit
 
-struct MessageError: Error {
-    let message: String
-    init(_ message: String) {
-        self.message = message
-    }
-}
-
-func expectEqual<T: Equatable>(_ lhs: T, _ rhs: T) throws {
-    if lhs != rhs {
-        throw MessageError("Expect to be equal \"\(lhs)\" and \"\(rhs)\"")
-    }
-}
-
-func expectObject(_ value: JSValue) throws -> JSRef {
-    switch value {
-    case .object(let ref): return ref
-    default:
-        throw MessageError("Type of \(value) should be \"object\"")
-    }
-}
-
-func expectBoolean(_ value: JSValue) throws -> Bool {
-    switch value {
-    case .boolean(let bool): return bool
-    default:
-        throw MessageError("Type of \(value) should be \"boolean\"")
-    }
-}
-
 Literal_Conversion: do {
     let global = JSRef.global()
     let inputs: [JSValue] = [
         .boolean(true),
         .boolean(false),
         .string("foobar"),
+        .number(0),
+        .number(.max),
+        .number(.min),
     ]
     for (index, input) in inputs.enumerated() {
         let prop = "prop_\(index)"
@@ -62,7 +36,12 @@ Object_Conversion: do {
 
     let globalObject1 = getJSValue(this: .global(), name: "globalObject1")
     let globalObject1Ref = try expectObject(globalObject1)
-    _ = try expectObject(getJSValue(this: globalObject1Ref, name: "prop_1"))
+    let prop_1 = getJSValue(this: globalObject1Ref, name: "prop_1")
+    let prop_1Ref = try expectObject(prop_1)
+    let nested_prop = getJSValue(this: prop_1Ref, name: "nested_prop")
+    try expectEqual(nested_prop, .number(1))
+    let prop_2 = getJSValue(this: globalObject1Ref, name: "prop_2")
+    try expectEqual(prop_2, .number(2))
     let prop_3 = getJSValue(this: globalObject1Ref, name: "prop_3")
     try expectEqual(prop_3, .boolean(true))
 } catch {