getting rid of existentials, patched headers in C parts

Author: sliemeobn

Package.swift

@@ -14,7 +14,8 @@ let package = Package(
         .target(
             name: "JavaScriptKit",
             dependencies: ["_CJavaScriptKit"],
-            resources: [.copy("Runtime")]
+            //LES: TODO - make this conditional
+            // resources: [.copy("Runtime")]
         ),
         .target(name: "_CJavaScriptKit"),
         .target(

Sources/JavaScriptKit/BasicObjects/JSPromise.swift

@@ -58,14 +58,25 @@ public final class JSPromise: JSBridgedClass {
         self.init(unsafelyWrapping: Self.constructor!.new(closure))
     }
 
+#if !hasFeature(Embedded)
     public static func resolve(_ value: ConvertibleToJSValue) -> JSPromise {
         self.init(unsafelyWrapping: Self.constructor!.resolve!(value).object!)
     }
 
     public static func reject(_ reason: ConvertibleToJSValue) -> JSPromise {
         self.init(unsafelyWrapping: Self.constructor!.reject!(reason).object!)
     }
+#else
+    public static func resolve(_ value: some ConvertibleToJSValue) -> JSPromise {
+        self.init(unsafelyWrapping: constructor!.resolve!(value).object!)
+    }
+
+    public static func reject(_ reason: some ConvertibleToJSValue) -> JSPromise {
+        self.init(unsafelyWrapping: constructor!.reject!(reason).object!)
+    }
+#endif
 
+#if !hasFeature(Embedded)
     /// Schedules the `success` closure to be invoked on successful completion of `self`.
     @discardableResult
     public func then(success: @escaping (JSValue) -> ConvertibleToJSValue) -> JSPromise {
@@ -150,4 +161,5 @@ public final class JSPromise: JSBridgedClass {
         }
         return .init(unsafelyWrapping: jsObject.finally!(closure).object!)
     }
+#endif
 }

Sources/JavaScriptKit/BasicObjects/JSTimer.swift

@@ -11,10 +11,33 @@ For invalidation you should either store the timer in an optional property and a
 or deallocate the object that owns the timer.
 */
 public final class JSTimer {
+    enum ClosureStorage {
+        case oneshot(JSOneshotClosure)
+        case repeating(JSClosure)
+
+        var jsValue: JSValue {
+            switch self {
+            case .oneshot(let closure):
+                closure.jsValue
+            case .repeating(let closure):
+                closure.jsValue
+            }
+        }
+
+        func release() {
+            switch self {
+            case .oneshot(let closure):
+                closure.release()
+            case .repeating(let closure):
+                closure.release()
+            }
+        }
+    }
+
     /// Indicates whether this timer instance calls its callback repeatedly at a given delay.
     public let isRepeating: Bool
 
-    private let closure: JSClosureProtocol
+    private let closure: ClosureStorage
 
     /** Node.js and browser APIs are slightly different. `setTimeout`/`setInterval` return an object
      in Node.js, while browsers return a number. Fortunately, clearTimeout and clearInterval take
@@ -35,21 +58,21 @@ public final class JSTimer {
      */
     public init(millisecondsDelay: Double, isRepeating: Bool = false, callback: @escaping () -> ()) {
         if isRepeating {
-            closure = JSClosure { _ in
+            closure = .repeating(JSClosure { _ in
                 callback()
                 return .undefined
-            }
+            })
         } else {
-            closure = JSOneshotClosure { _ in
+            closure = .oneshot(JSOneshotClosure { _ in
                 callback()
                 return .undefined
-            }
+            })
         }
         self.isRepeating = isRepeating
         if isRepeating {
-            value = global.setInterval.function!(closure, millisecondsDelay)
+            value = global.setInterval.function!(arguments: [closure.jsValue, millisecondsDelay.jsValue])
         } else {
-            value = global.setTimeout.function!(closure, millisecondsDelay)
+            value = global.setTimeout.function!(arguments: [closure.jsValue, millisecondsDelay.jsValue])
         }
     }
 

Sources/JavaScriptKit/BasicObjects/JSTypedArray.swift

@@ -1,7 +1,7 @@
 //
 //  Created by Manuel Burghard. Licensed unter MIT.
 //
-
+#if !hasFeature(Embedded)
 import _CJavaScriptKit
 
 /// A protocol that allows a Swift numeric type to be mapped to the JavaScript TypedArray that holds integers of its type
@@ -187,3 +187,4 @@ extension Float32: TypedArrayElement {
 extension Float64: TypedArrayElement {
     public static var typedArrayClass = JSObject.global.Float64Array.function!
 }
+#endif

Sources/JavaScriptKit/ConvertibleToJSValue.swift

@@ -88,6 +88,7 @@ extension JSObject: JSValueCompatible {
 private let objectConstructor = JSObject.global.Object.function!
 private let arrayConstructor = JSObject.global.Array.function!
 
+#if !hasFeature(Embedded)
 extension Dictionary where Value == ConvertibleToJSValue, Key == String {
     public var jsValue: JSValue {
         let object = objectConstructor.new()
@@ -97,6 +98,7 @@ extension Dictionary where Value == ConvertibleToJSValue, Key == String {
         return .object(object)
     }
 }
+#endif
 
 extension Dictionary: ConvertibleToJSValue where Value: ConvertibleToJSValue, Key == String {
     public var jsValue: JSValue {
@@ -158,6 +160,7 @@ extension Array: ConvertibleToJSValue where Element: ConvertibleToJSValue {
     }
 }
 
+#if !hasFeature(Embedded)
 extension Array where Element == ConvertibleToJSValue {
     public var jsValue: JSValue {
         let array = arrayConstructor.new(count)
@@ -167,6 +170,7 @@ extension Array where Element == ConvertibleToJSValue {
         return .object(array)
     }
 }
+#endif
 
 extension Array: ConstructibleFromJSValue where Element: ConstructibleFromJSValue {
     public static func construct(from value: JSValue) -> [Element]? {
@@ -252,13 +256,13 @@ extension JSValue {
     }
 }
 
-extension Array where Element == ConvertibleToJSValue {
+extension Array where Element: ConvertibleToJSValue {
     func withRawJSValues<T>(_ body: ([RawJSValue]) -> T) -> T {
         // fast path for empty array
         guard self.count != 0 else { return body([]) }
 
         func _withRawJSValues(
-            _ values: [ConvertibleToJSValue], _ index: Int,
+            _ values: Self, _ index: Int,
             _ results: inout [RawJSValue], _ body: ([RawJSValue]) -> T
         ) -> T {
             if index == values.count { return body(results) }
@@ -272,8 +276,24 @@ extension Array where Element == ConvertibleToJSValue {
     }
 }
 
-extension Array where Element: ConvertibleToJSValue {
+#if !hasFeature(Embedded)
+extension Array where Element == ConvertibleToJSValue {
     func withRawJSValues<T>(_ body: ([RawJSValue]) -> T) -> T {
-        [ConvertibleToJSValue].withRawJSValues(self)(body)
+        // fast path for empty array
+        guard self.count != 0 else { return body([]) }
+
+        func _withRawJSValues(
+            _ values: [ConvertibleToJSValue], _ index: Int,
+            _ results: inout [RawJSValue], _ body: ([RawJSValue]) -> T
+        ) -> T {
+            if index == values.count { return body(results) }
+            return values[index].jsValue.withRawJSValue { (rawValue) -> T in
+                results.append(rawValue)
+                return _withRawJSValues(values, index + 1, &results, body)
+            }
+        }
+        var _results = [RawJSValue]()
+        return _withRawJSValues(self, 0, &_results, body)
     }
 }
+#endif

Sources/JavaScriptKit/FundamentalObjects/JSClosure.swift

@@ -32,7 +32,7 @@ public class JSOneshotClosure: JSObject, JSClosureProtocol {
         })
     }
 
-    #if compiler(>=5.5)
+    #if compiler(>=5.5) && !hasFeature(Embedded)
     @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)
     public static func async(_ body: @escaping ([JSValue]) async throws -> JSValue) -> JSOneshotClosure {
         JSOneshotClosure(makeAsyncClosure(body))
@@ -113,7 +113,7 @@ public class JSClosure: JSFunction, JSClosureProtocol {
         Self.sharedClosures[hostFuncRef] = (self, body)
     }
 
-    #if compiler(>=5.5)
+    #if compiler(>=5.5) && !hasFeature(Embedded)
     @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)
     public static func async(_ body: @escaping ([JSValue]) async throws -> JSValue) -> JSClosure {
         JSClosure(makeAsyncClosure(body))
@@ -129,7 +129,7 @@ public class JSClosure: JSFunction, JSClosureProtocol {
     #endif
 }
 
-#if compiler(>=5.5)
+#if compiler(>=5.5) && !hasFeature(Embedded)
 @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)
 private func makeAsyncClosure(_ body: @escaping ([JSValue]) async throws -> JSValue) -> (([JSValue]) -> JSValue) {
     { arguments in
@@ -195,7 +195,7 @@ func _call_host_function_impl(
     guard let (_, hostFunc) = JSClosure.sharedClosures[hostFuncRef] else {
         return true
     }
-    let arguments = UnsafeBufferPointer(start: argv, count: Int(argc)).map(\.jsValue)
+    let arguments = UnsafeBufferPointer(start: argv, count: Int(argc)).map { $0.jsValue}
     let result = hostFunc(arguments)
     let callbackFuncRef = JSFunction(id: callbackFuncRef)
     _ = callbackFuncRef(result)