Changes related to WebIDL support.

Author: mjburghard

Sources/JavaScriptKit/JSFunction.swift

@@ -2,8 +2,13 @@ import _CJavaScriptKit
 
 @dynamicCallable
 public class JSFunctionRef: JSObjectRef {
+
+    public override class func canDecode(from jsValue: JSValue) -> Bool {
+        return jsValue.isFunction
+    }
+
     @discardableResult
-    public func dynamicallyCall(withArguments arguments: [JSValueConvertible]) -> JSValue {
+    public func dynamicallyCall(withArguments arguments: [JSValueEncodable]) -> JSValue {
         let result = arguments.withRawJSValues { rawValues -> RawJSValue in
             rawValues.withUnsafeBufferPointer { bufferPointer -> RawJSValue in
                 let argv = bufferPointer.baseAddress
@@ -19,11 +24,11 @@ public class JSFunctionRef: JSObjectRef {
         return result.jsValue()
     }
 
-    public func apply(this: JSObjectRef, arguments: JSValueConvertible...) -> JSValue {
+    public func apply(this: JSObjectRef, arguments: JSValueEncodable...) -> JSValue {
         apply(this: this, argumentList: arguments)
     }
 
-    public func apply(this: JSObjectRef, argumentList: [JSValueConvertible]) -> JSValue {
+    public func apply(this: JSObjectRef, argumentList: [JSValueEncodable]) -> JSValue {
         let result = argumentList.withRawJSValues { rawValues in
             rawValues.withUnsafeBufferPointer { bufferPointer -> RawJSValue in
                 let argv = bufferPointer.baseAddress
@@ -38,7 +43,7 @@ public class JSFunctionRef: JSObjectRef {
         return result.jsValue()
     }
 
-    public func new(_ arguments: JSValueConvertible...) -> JSObjectRef {
+    public func new(_ arguments: JSValueEncodable...) -> JSObjectRef {
         return arguments.withRawJSValues { rawValues in
             rawValues.withUnsafeBufferPointer { bufferPointer in
                 let argv = bufferPointer.baseAddress
@@ -58,6 +63,15 @@ public class JSFunctionRef: JSObjectRef {
         fatalError("unavailable")
     }
 
+    public convenience required init(jsValue: JSValue) {
+        switch jsValue {
+        case .function(let value):
+            self.init(id: value.id)
+        default:
+            fatalError()
+        }
+    }
+
     override public func jsValue() -> JSValue {
         .function(self)
     }
@@ -81,6 +95,10 @@ public class JSClosure: JSFunctionRef {
         id = objectRef
     }
 
+    public convenience required init(jsValue: JSValue) {
+        self.init(JSFunctionRef(jsValue: jsValue).dynamicallyCall)
+    }
+
     public func release() {
         Self.sharedFunctions[hostFuncRef] = nil
     }

Sources/JavaScriptKit/JSObject.swift

@@ -2,15 +2,19 @@ import _CJavaScriptKit
 
 @dynamicMemberLookup
 public class JSObjectRef: Equatable {
+    public class func canDecode(from jsValue: JSValue) -> Bool {
+        return jsValue.isObject
+    }
+
     internal var id: UInt32
     init(id: UInt32) {
         self.id = id
     }
 
     @_disfavoredOverload
-    public subscript(dynamicMember name: String) -> ((JSValueConvertible...) -> JSValue)? {
+    public subscript(dynamicMember name: String) -> ((JSValueEncodable...) -> JSValue)? {
         guard let function = self[dynamicMember: name].function else { return nil }
-        return { (arguments: JSValueConvertible...) in
+        return { (arguments: JSValueEncodable...) in
             function.apply(this: self, argumentList: arguments)
         }
     }
@@ -54,6 +58,15 @@ public class JSObjectRef: Equatable {
         return lhs.id == rhs.id
     }
 
+    public convenience required init(jsValue: JSValue) {
+        switch jsValue {
+        case .object(let value):
+            self.init(id: value.id)
+        default:
+            fatalError()
+        }
+    }
+
     public func jsValue() -> JSValue {
         .object(self)
     }

Sources/JavaScriptKit/JSValue.swift

@@ -41,14 +41,51 @@ public enum JSValue: Equatable {
         object.flatMap { JSArrayRef($0) }
     }
 
-    public var isNull: Bool { return self == .null }
-    public var isUndefined: Bool { return self == .undefined }
     public var function: JSFunctionRef? {
         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: JSValueDecodable {
+        return Type(jsValue: self)
+    }
 }
 
 extension JSValue {
@@ -64,7 +101,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)
     }
 }
@@ -98,3 +141,20 @@ public func setJSValue(this: JSObjectRef, index: Int32, value: JSValue) {
                        rawValue.payload1, rawValue.payload2, rawValue.payload3)
     }
 }
+
+extension JSValue {
+
+    public func instanceof(_ constructor: String) -> Bool {
+        
+        switch self {
+        case .boolean, .string, .number:
+            return false
+        case .object(let ref):
+            return ref.instanceof(constructor)
+        case .function(let ref):
+            return ref.instanceof(constructor)
+        case .null, .undefined:
+            fatalError()
+        }
+    }
+}