Use the new ExecutorFactory protocol to provide a default executor

Author: kateinoigakukun

Sources/JavaScriptEventLoop/JavaScriptEventLoop+ExecutorFactory.swift

@@ -0,0 +1,39 @@
+@available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, visionOS 9999, *)
+extension JavaScriptEventLoop: MainExecutor {
+    public func run() throws {}
+    public func stop() {}
+}
+
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+extension JavaScriptEventLoop: TaskExecutor {}
+
+@available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, visionOS 9999, *)
+extension JavaScriptEventLoop: SchedulableExecutor {
+    public func enqueue<C: Clock>(
+        _ job: consuming ExecutorJob,
+        after delay: C.Duration,
+        tolerance: C.Duration?,
+        clock: C
+    ) {
+        self.enqueue(
+            UnownedJob(job),
+            withDelay: Self.delayInMilliseconds(from: delay, clock: clock)
+        )
+    }
+
+    private static func delayInMilliseconds<C: Clock>(from duration: C.Duration, clock: C) -> UInt64 {
+        let swiftDuration = clock.convert(from: duration)!
+        let (seconds, attoseconds) = swiftDuration.components
+        return UInt64(seconds) * 1_000 + (UInt64(attoseconds) / 1_000_000_000)
+    }
+}
+
+@available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, visionOS 9999, *)
+extension JavaScriptEventLoop: ExecutorFactory {
+    public static var mainExecutor: any MainExecutor {
+        JavaScriptEventLoop.shared
+    }
+    public static var defaultExecutor: any TaskExecutor {
+        JavaScriptEventLoop.shared
+    }
+}

Sources/JavaScriptEventLoop/JavaScriptEventLoop+LegacyHooks.swift

@@ -32,10 +32,11 @@ extension JavaScriptEventLoop {
             UInt64, UnownedJob, swift_task_enqueueGlobalWithDelay_original
         ) -> Void
         let swift_task_enqueueGlobalWithDelay_hook_impl: swift_task_enqueueGlobalWithDelay_hook_Fn = {
-            delay,
+            nanoseconds,
             job,
             original in
-            JavaScriptEventLoop.shared.enqueue(job, withDelay: delay)
+            let milliseconds = nanoseconds / 1_000_000
+            JavaScriptEventLoop.shared.enqueue(job, withDelay: milliseconds)
         }
         swift_task_enqueueGlobalWithDelay_hook = unsafeBitCast(
             swift_task_enqueueGlobalWithDelay_hook_impl,

Sources/JavaScriptEventLoop/JavaScriptEventLoop.swift

@@ -120,12 +120,19 @@ public final class JavaScriptEventLoop: SerialExecutor, @unchecked Sendable {
 
     @MainActor private static func installGlobalExecutorIsolated() {
         guard !didInstallGlobalExecutor else { return }
+#if compiler(>=5.2)
+        if #available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, visionOS 9999, *) {
+            _createExecutors(factory: JavaScriptEventLoop.self)
+        } else {
+            installByLegacyHook()
+        }
+#else
         installByLegacyHook()
+#endif
         didInstallGlobalExecutor = true
     }
 
-    internal func enqueue(_ job: UnownedJob, withDelay nanoseconds: UInt64) {
-        let milliseconds = nanoseconds / 1_000_000
+    internal func enqueue(_ job: UnownedJob, withDelay milliseconds: UInt64) {
         setTimeout(
             Double(milliseconds),
             {