Fix some Embedded Swift issues in JavaScriptEventLoop

This change fixes some of the issues that appear when building this library with Embedded Swift. It adds missing concurrency imports and avoids use of throwing tasks that are not supported in Embedded Swift. Standard Swift's `Result` type is used instead to express error throwing.

Author: MaxDesiatov

Sources/JavaScriptEventLoop/JSSending.swift

@@ -1,3 +1,4 @@
+import _Concurrency
 @_spi(JSObject_id) import JavaScriptKit
 import _CJavaScriptKit
 

Sources/JavaScriptEventLoop/JavaScriptEventLoop.swift

@@ -1,4 +1,5 @@
 import JavaScriptKit
+import _Concurrency
 import _CJavaScriptEventLoop
 import _CJavaScriptKit
 
@@ -259,38 +260,38 @@ extension JavaScriptEventLoop {
 extension JSPromise {
     /// Wait for the promise to complete, returning (or throwing) its result.
     public var value: JSValue {
-        get async throws {
-            try await withUnsafeThrowingContinuation { [self] continuation in
+        get async throws(JSException) {
+            try await withUnsafeContinuation { [self] continuation in
                 self.then(
                     success: {
-                        continuation.resume(returning: $0)
+                        continuation.resume(returning: Swift.Result<JSValue, JSException>.success($0))
                         return JSValue.undefined
                     },
                     failure: {
-                        continuation.resume(throwing: JSException($0))
+                        continuation.resume(returning: Swift.Result<JSValue, JSException>.failure(.init($0)))
                         return JSValue.undefined
                     }
                 )
-            }
+            }.get()
         }
     }
 
     /// Wait for the promise to complete, returning its result or exception as a Result.
     ///
     /// - Note: Calling this function does not switch from the caller's isolation domain.
-    public func value(isolation: isolated (any Actor)? = #isolation) async throws -> JSValue {
-        try await withUnsafeThrowingContinuation(isolation: isolation) { [self] continuation in
+    public func value(isolation: isolated (any Actor)? = #isolation) async throws(JSException) -> JSValue {
+        try await withUnsafeContinuation(isolation: isolation) { [self] continuation in
             self.then(
                 success: {
-                    continuation.resume(returning: $0)
+                    continuation.resume(returning: Swift.Result<JSValue, JSException>.success($0))
                     return JSValue.undefined
                 },
                 failure: {
-                    continuation.resume(throwing: JSException($0))
+                    continuation.resume(returning: Swift.Result<JSValue, JSException>.failure(.init($0)))
                     return JSValue.undefined
                 }
             )
-        }
+        }.get()
     }
 
     /// Wait for the promise to complete, returning its result or exception as a Result.

Sources/JavaScriptEventLoop/JobQueue.swift

@@ -2,6 +2,7 @@
 // The current implementation is much simple to be easily debugged, but should be re-implemented
 // using priority queue ideally.
 
+import _Concurrency
 import _CJavaScriptEventLoop
 
 #if compiler(>=5.5)

Sources/JavaScriptEventLoop/WebWorkerDedicatedExecutor.swift

@@ -1,5 +1,7 @@
+#if !hasFeature(Embedded)
 import JavaScriptKit
 import _CJavaScriptEventLoop
+import _Concurrency
 
 #if canImport(Synchronization)
 import Synchronization
@@ -60,3 +62,4 @@ public final class WebWorkerDedicatedExecutor: SerialExecutor {
         self.underlying.enqueue(job)
     }
 }
+#endif

Sources/JavaScriptEventLoop/WebWorkerTaskExecutor.swift

@@ -1,4 +1,4 @@
-#if compiler(>=6.0)  // `TaskExecutor` is available since Swift 6.0
+#if compiler(>=6.0) && !hasFeature(Embedded) // `TaskExecutor` is available since Swift 6.0, no multi-threading for embedded Wasm yet.
 
 import JavaScriptKit
 import _CJavaScriptKit