Changes related to WebIDL support.

Author: mjburghard

Sources/JavaScriptKit/FundamentalObjects/JSFunction.swift

@@ -43,10 +43,7 @@ public class JSFunction: JSObject {
                 let argv = bufferPointer.baseAddress
                 let argc = bufferPointer.count
                 var resultObj = JavaScriptObjectRef()
-                _call_new(
-                    self.id, argv, Int32(argc),
-                    &resultObj
-                )
+                _call_new(self.id, argv, Int32(argc), &resultObj)
                 return JSObject(id: resultObj)
             }
         }
@@ -57,6 +54,10 @@ public class JSFunction: JSObject {
         fatalError("unavailable")
     }
 
+    public override class func construct(from value: JSValue) -> Self? {
+        return value.function as? Self
+    }
+
     override public func jsValue() -> JSValue {
         .function(self)
     }
@@ -89,6 +90,15 @@ public class JSClosure: JSFunction {
         }
     }
 
+    public required convenience init(jsValue: JSValue) {
+        switch jsValue {
+        case let .function(fun):
+            self.init { fun(arguments: $0) }
+        default:
+            fatalError()
+        }
+    }
+
     public func release() {
         Self.sharedFunctions[hostFuncRef] = nil
         isReleased = true

Sources/JavaScriptKit/FundamentalObjects/JSObject.swift

@@ -43,6 +43,10 @@ public class JSObject: Equatable {
         return lhs.id == rhs.id
     }
 
+    public class func construct(from value: JSValue) -> Self? {
+        return value.object as? Self
+    }
+
     public func jsValue() -> JSValue {
         .object(self)
     }

Sources/JavaScriptKit/JSValue.swift

@@ -37,14 +37,51 @@ public enum JSValue: Equatable {
         }
     }
 
-    public var isNull: Bool { return self == .null }
-    public var isUndefined: Bool { return self == .undefined }
     public var function: JSFunction? {
         switch self {
         case let .function(function): return function
         default: return nil
         }
     }
+
+    public var isBoolean: Bool {
+        guard case .boolean = self else { return false }
+        return true
+    }
+
+    public var isString: Bool {
+        guard case .string = self else { return false }
+        return true
+    }
+
+    public var isNumber: Bool {
+        guard case .number = self else { return false }
+        return true
+    }
+
+    public var isObject: Bool {
+        guard case .object = self else { return false }
+        return true
+    }
+
+    public var isNull: Bool {
+        return self == .null
+    }
+
+    public var isUndefined: Bool {
+        return self == .undefined
+    }
+
+    public var isFunction: Bool {
+        guard case .function = self else { return false }
+        return true
+    }
+}
+
+extension JSValue {
+    public func fromJSValue<Type>() -> Type? where Type: JSValueConstructible {
+        return Type.construct(from: self)
+    }
 }
 
 extension JSValue {
@@ -60,7 +97,13 @@ extension JSValue: ExpressibleByStringLiteral {
 }
 
 extension JSValue: ExpressibleByIntegerLiteral {
-    public init(integerLiteral value: Double) {
+    public init(integerLiteral value: Int32) {
+        self = .number(Double(value))
+    }
+}
+
+extension JSValue: ExpressibleByFloatLiteral {
+    public init(floatLiteral value: Double) {
         self = .number(value)
     }
 }
@@ -94,3 +137,18 @@ public func setJSValue(this: JSObject, index: Int32, value: JSValue) {
                        rawValue.payload1, rawValue.payload2, rawValue.payload3)
     }
 }
+
+extension JSValue {
+    public func isInstanceOf(_ constructor: JSFunction) -> Bool {
+        switch self {
+        case .boolean, .string, .number:
+            return false
+        case let .object(ref):
+            return ref.isInstanceOf(constructor)
+        case let .function(ref):
+            return ref.isInstanceOf(constructor)
+        case .null, .undefined:
+            fatalError()
+        }
+    }
+}

Sources/JavaScriptKit/JSValueConvertible.swift

@@ -1,10 +1,47 @@
 import _CJavaScriptKit
 
+public protocol JSBridgedType: JSValueCodable, CustomStringConvertible {
+    static var constructor: JSFunction? { get }
+
+    var objectRef: JSObject { get }
+    init(objectRef: JSObject)
+}
+
+extension JSBridgedType {
+    public var description: String {
+        return objectRef.toString!().fromJSValue()!
+    }
+}
+
 public protocol JSValueConvertible {
     func jsValue() -> JSValue
 }
 
-extension JSValue: JSValueConvertible {
+public typealias JSValueCodable = JSValueConvertible & JSValueConstructible
+
+extension JSBridgedType {
+    public static func canDecode(from jsValue: JSValue) -> Bool {
+        if let constructor = Self.constructor {
+            return jsValue.isInstanceOf(constructor)
+        } else {
+            return jsValue.isObject
+        }
+    }
+
+    public init(jsValue: JSValue) {
+        self.init(objectRef: jsValue.object!)
+    }
+
+    public func jsValue() -> JSValue {
+        return JSValue.object(objectRef)
+    }
+}
+
+extension JSValue: JSValueCodable {
+    public static func construct(from value: JSValue) -> Self? {
+        return value
+    }
+
     public func jsValue() -> JSValue { self }
 }
 
@@ -16,20 +53,20 @@ extension Int: JSValueConvertible {
     public func jsValue() -> JSValue { .number(Double(self)) }
 }
 
-extension Int8: JSValueConvertible {
+extension UInt: JSValueConvertible {
     public func jsValue() -> JSValue { .number(Double(self)) }
 }
 
-extension Int16: JSValueConvertible {
+extension Float: JSValueConvertible {
     public func jsValue() -> JSValue { .number(Double(self)) }
 }
 
-extension Int32: JSValueConvertible {
-    public func jsValue() -> JSValue { .number(Double(self)) }
+extension Double: JSValueConvertible {
+    public func jsValue() -> JSValue { .number(self) }
 }
 
-extension UInt: JSValueConvertible {
-    public func jsValue() -> JSValue { .number(Double(self)) }
+extension String: JSValueConvertible {
+    public func jsValue() -> JSValue { .string(self) }
 }
 
 extension UInt8: JSValueConvertible {
@@ -41,22 +78,30 @@ extension UInt16: JSValueConvertible {
 }
 
 extension UInt32: JSValueConvertible {
-  public func jsValue() -> JSValue { .number(Double(self)) }
+    public func jsValue() -> JSValue { .number(Double(self)) }
 }
 
-extension Float: JSValueConvertible {
+extension UInt64: JSValueConvertible {
     public func jsValue() -> JSValue { .number(Double(self)) }
 }
 
-extension Double: JSValueConvertible {
-    public func jsValue() -> JSValue { .number(self) }
+extension Int8: JSValueConvertible {
+    public func jsValue() -> JSValue { .number(Double(self)) }
 }
 
-extension String: JSValueConvertible {
-    public func jsValue() -> JSValue { .string(self) }
+extension Int16: JSValueConvertible {
+    public func jsValue() -> JSValue { .number(Double(self)) }
+}
+
+extension Int32: JSValueConvertible {
+    public func jsValue() -> JSValue { .number(Double(self)) }
 }
 
-extension JSObject: JSValueConvertible {
+extension Int64: JSValueConvertible {
+    public func jsValue() -> JSValue { .number(Double(self)) }
+}
+
+extension JSObject: JSValueCodable {
     // `JSObject.jsValue` is defined in JSObject.swift to be able to overridden
     // from `JSFunction`
 }
@@ -79,24 +124,80 @@ extension Dictionary: JSValueConvertible where Value == JSValueConvertible, Key
     }
 }
 
-private let Array = JSObject.global.Array.function!
+private let NativeJSArray = JSObject.global.Array.function!
+extension Dictionary: JSValueConstructible where Value: JSValueConstructible, Key == String {
+    public static func construct(from value: JSValue) -> Self? {
+        if let objectRef = value.object,
+           let keys: [String] = Object.keys!(objectRef.jsValue()).fromJSValue() {
+            var entries = [(String, Value)]()
+            entries.reserveCapacity(keys.count)
+            for key in keys {
+                guard let value: Value = objectRef[key].fromJSValue() else {
+                    return nil
+                }
+                entries.append((key, value))
+            }
+            return Dictionary(uniqueKeysWithValues: entries)
+        }
+        return nil
+    }
+}
+
+extension Optional: JSValueConstructible where Wrapped: JSValueConstructible {
+    public static func construct(from value: JSValue) -> Self? {
+        switch value {
+        case .null, .undefined:
+            return nil
+        default:
+            return Wrapped.construct(from: value)
+        }
+    }
+}
+
+extension Optional: JSValueConvertible where Wrapped: JSValueConvertible {
+    public func jsValue() -> JSValue {
+        switch self {
+        case .none: return .null
+        case let .some(wrapped): return wrapped.jsValue()
+        }
+    }
+}
 
 extension Array where Element: JSValueConvertible {
     public func jsValue() -> JSValue {
-        Swift.Array<JSValueConvertible>.jsValue(self)()
+        Array<JSValueConvertible>.jsValue(self)()
     }
 }
 
 extension Array: JSValueConvertible where Element == JSValueConvertible {
     public func jsValue() -> JSValue {
-        let array = Array.new(count)
+        let array = NativeJSArray.new(count)
         for (index, element) in enumerated() {
             array[index] = element.jsValue()
         }
         return .object(array)
     }
 }
 
+extension Array: JSValueConstructible where Element: JSValueConstructible {
+    public static func construct(from value: JSValue) -> [Element]? {
+        if let objectRef = value.object,
+           objectRef.isInstanceOf(JSObject.global.Array.function!) {
+            let count: Int = objectRef.length.fromJSValue()!
+            var array = [Element]()
+            array.reserveCapacity(count)
+
+            for i in 0 ..< count {
+                guard let value: Element = objectRef[i].fromJSValue() else { return nil }
+                array.append(value)
+            }
+
+            return array
+        }
+        return nil
+    }
+}
+
 extension RawJSValue: JSValueConvertible {
     public func jsValue() -> JSValue {
         switch kind {
@@ -192,6 +293,6 @@ extension Array where Element == JSValueConvertible {
 
 extension Array where Element: JSValueConvertible {
     func withRawJSValues<T>(_ body: ([RawJSValue]) -> T) -> T {
-        Swift.Array<JSValueConvertible>.withRawJSValues(self)(body)
+        Array<JSValueConvertible>.withRawJSValues(self)(body)
     }
 }