Concurrency: Introduce JSException and remove Error conformance from JSValue

This is a breaking change. It introduces a new `JSException` type to represent
exceptions thrown from JavaScript code. This change is necessary to remove `Sendable`
conformance from `JSValue`, which is derived from `Error` conformance.

Author: kateinoigakukun

Sources/JavaScriptEventLoop/JavaScriptEventLoop.swift

@@ -218,7 +218,7 @@ public extension JSPromise {
                         return JSValue.undefined
                     },
                     failure: {
-                        continuation.resume(throwing: $0)
+                        continuation.resume(throwing: JSException($0))
                         return JSValue.undefined
                     }
                 )
@@ -227,7 +227,7 @@ public extension JSPromise {
     }
 
     /// Wait for the promise to complete, returning its result or exception as a Result.
-    var result: Result<JSValue, JSValue> {
+    var result: Swift.Result<JSValue, JSException> {
         get async {
             await withUnsafeContinuation { [self] continuation in
                 self.then(
@@ -236,7 +236,7 @@ public extension JSPromise {
                         return JSValue.undefined
                     },
                     failure: {
-                        continuation.resume(returning: .failure($0))
+                        continuation.resume(returning: .failure(JSException($0)))
                         return JSValue.undefined
                     }
                 )

Sources/JavaScriptKit/BasicObjects/JSPromise.swift

@@ -31,14 +31,22 @@ public final class JSPromise: JSBridgedClass {
         return Self(jsObject)
     }
 
+    /// The result of a promise.
+    public enum Result {
+        /// The promise resolved with a value.
+        case success(JSValue)
+        /// The promise rejected with a value.
+        case failure(JSValue)
+    }
+
     /// Creates a new `JSPromise` instance from a given `resolver` closure.
     /// The closure is passed a completion handler. Passing a successful
     /// `Result` to the completion handler will cause the promise to resolve
     /// with the corresponding value; passing a failure `Result` will cause the
     /// promise to reject with the corresponding value.
     /// Calling the completion handler more than once will have no effect
     /// (per the JavaScript specification).
-    public convenience init(resolver: @escaping (@escaping (Result<JSValue, JSValue>) -> Void) -> Void) {
+    public convenience init(resolver: @escaping (@escaping (Result) -> Void) -> Void) {
         let closure = JSOneshotClosure { arguments in
             // The arguments are always coming from the `Promise` constructor, so we should be
             // safe to assume their type here

Sources/JavaScriptKit/FundamentalObjects/JSClosure.swift

@@ -144,8 +144,8 @@ private func makeAsyncClosure(
                     let result = try await context.body(context.arguments)
                     context.resolver(.success(result))
                 } catch {
-                    if let jsError = error as? JSError {
-                        context.resolver(.failure(jsError.jsValue))
+                    if let jsError = error as? JSException {
+                        context.resolver(.failure(jsError.thrownValue))
                     } else {
                         context.resolver(.failure(JSError(message: String(describing: error)).jsValue))
                     }

Sources/JavaScriptKit/FundamentalObjects/JSThrowingFunction.swift

@@ -37,7 +37,7 @@ public class JSThrowingFunction {
     /// - Parameter arguments: Arguments to be passed to this constructor function.
     /// - Returns: A new instance of this constructor.
     public func new(arguments: [ConvertibleToJSValue]) throws -> JSObject {
-        try arguments.withRawJSValues { rawValues -> Result<JSObject, JSValue> in
+        try arguments.withRawJSValues { rawValues -> Result<JSObject, JSException> in
             rawValues.withUnsafeBufferPointer { bufferPointer in
                 let argv = bufferPointer.baseAddress
                 let argc = bufferPointer.count
@@ -52,7 +52,7 @@ public class JSThrowingFunction {
                 let exceptionKind = JavaScriptValueKindAndFlags(bitPattern: exceptionRawKind)
                 if exceptionKind.isException {
                     let exception = RawJSValue(kind: exceptionKind.kind, payload1: exceptionPayload1, payload2: exceptionPayload2)
-                    return .failure(exception.jsValue)
+                    return .failure(JSException(exception.jsValue))
                 }
                 return .success(JSObject(id: resultObj))
             }
@@ -92,7 +92,7 @@ private func invokeJSFunction(_ jsFunc: JSFunction, arguments: [ConvertibleToJSV
         }
     }
     if isException {
-        throw result
+        throw JSException(result)
     }
     return result
 }

Sources/JavaScriptKit/JSException.swift

@@ -0,0 +1,34 @@
+/// `JSException` is a wrapper that handles exceptions thrown during JavaScript execution as Swift
+/// `Error` objects.
+/// When a JavaScript function throws an exception, it's wrapped as a `JSException` and propagated
+/// through Swift's error handling mechanism.
+///
+/// Example:
+/// ```swift
+/// do {
+///     try jsFunction.throws()
+/// } catch let error as JSException {
+///     // Access the value thrown from JavaScript
+///     let jsErrorValue = error.thrownValue
+/// }
+/// ```
+public struct JSException: Error {
+    /// The value thrown from JavaScript.
+    /// This can be any JavaScript value (error object, string, number, etc.).
+    public var thrownValue: JSValue {
+      return _thrownValue
+    }
+
+    /// The actual JavaScript value that was thrown.
+    ///
+    /// Marked as `nonisolated(unsafe)` to satisfy `Sendable` requirement
+    /// from `Error` protocol.
+    private nonisolated(unsafe) let _thrownValue: JSValue
+
+    /// Initializes a new JSException instance with a value thrown from JavaScript.
+    ///
+    /// Only available within the package.
+    package init(_ thrownValue: JSValue) {
+        self._thrownValue = thrownValue
+    }
+}

Sources/JavaScriptKit/JSValue.swift

@@ -124,8 +124,6 @@ public extension JSValue {
     }
 }
 
-extension JSValue: Swift.Error {}
-
 public extension JSValue {
     func fromJSValue<Type>() -> Type? where Type: ConstructibleFromJSValue {
         return Type.construct(from: self)