@macify/xpc 0.0.3 → 0.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@macify/xpc",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "XPC service support for Mac Catalyst Expo apps",
   "main": "build/index.cjs",
   "types": "build/index.d.cts",
@@ -20,7 +20,8 @@
   "devDependencies": {
     "@expo/config-plugins": "*",
     "@macify/xcode-types": "workspace:*",
-    "tsdown": "*"
+    "tsdown": "*",
+    "typescript": "*"
   },
   "peerDependencies": {
     "expo-modules-core": "*",

package/plugin/build/index.cjs

@@ -50,9 +50,9 @@ function resolveSwiftPackagePath() {
 	if (!node_fs.default.existsSync(swiftDir)) throw new Error(`[xpc] Could not find Swift package at ${swiftDir}. Is @macify/xpc installed?`);
 	return swiftDir;
 }
-/** Find the user's xpc-sources directory */
+/** Find the user's XPC sources directory */
 function findXPCSourcesDir(projectRoot) {
-	const xpcSourcesDir = node_path.default.join(projectRoot, "modules", "xpc-service", "xpc-sources");
+	const xpcSourcesDir = node_path.default.join(projectRoot, "macify", "xpc");
 	if (!node_fs.default.existsSync(xpcSourcesDir)) throw new Error(`[xpc] Could not find XPC sources at ${xpcSourcesDir}. Run 'npx macx init' first.`);
 	return xpcSourcesDir;
 }
@@ -95,7 +95,7 @@ const withXPCService = (config, props = {}) => {
 		const spmRefSection = objects["XCLocalSwiftPackageReference"] || (objects["XCLocalSwiftPackageReference"] = {});
 		spmRefSection[spmRefUuid] = {
 			isa: "XCLocalSwiftPackageReference",
-			relativePath: relativeSwiftPath
+			relativePath: `"${relativeSwiftPath}"`
 		};
 		spmRefSection[`${spmRefUuid}_comment`] = "XCLocalSwiftPackageReference \"MacifyXPCService\"";
 		const projectSection = project.pbxProjectSection();

package/swift/Sources/MacifyXPCService/FunctionDefinition.swift

@@ -0,0 +1,54 @@
+import Foundation
+
+/// Represents a registered XPC function with a name and handler closure.
+public struct FunctionDefinition {
+    let name: String
+    let handler: ([String: Any], XPCEventEmitter) async throws -> [String: Any]
+
+    init(
+        name: String,
+        handler: @escaping ([String: Any], XPCEventEmitter) async throws -> [String: Any]
+    ) {
+        self.name = name
+        self.handler = handler
+    }
+}
+
+/// Register an XPC function with no arguments.
+/// The handler receives no payload or emitter.
+/// - Parameters:
+///   - name: The function name exposed to the app
+///   - handler: An async closure that returns a response dictionary
+/// - Returns: A `FunctionDefinition` to be collected by the result builder
+public func Function(
+    _ name: String,
+    handler: @escaping () async throws -> [String: Any]
+) -> FunctionDefinition {
+    FunctionDefinition(name: name) { _, _ in try await handler() }
+}
+
+/// Register an XPC function with a payload argument.
+/// The handler receives the decoded JSON payload.
+/// - Parameters:
+///   - name: The function name exposed to the app
+///   - handler: An async closure that takes the payload and returns a response dictionary
+/// - Returns: A `FunctionDefinition` to be collected by the result builder
+public func Function(
+    _ name: String,
+    handler: @escaping ([String: Any]) async throws -> [String: Any]
+) -> FunctionDefinition {
+    FunctionDefinition(name: name) { payload, _ in try await handler(payload) }
+}
+
+/// Register an XPC function with payload and emitter arguments.
+/// The handler receives the decoded JSON payload and an event emitter for pushing events.
+/// - Parameters:
+///   - name: The function name exposed to the app
+///   - handler: An async closure that takes the payload and emitter, and returns a response dictionary
+/// - Returns: A `FunctionDefinition` to be collected by the result builder
+public func Function(
+    _ name: String,
+    handler: @escaping ([String: Any], XPCEventEmitter) async throws -> [String: Any]
+) -> FunctionDefinition {
+    FunctionDefinition(name: name, handler: handler)
+}

package/swift/Sources/MacifyXPCService/MacifyServiceImpl.swift

@@ -1,13 +1,13 @@
 import Foundation
 
 /// The XPC service implementation that receives generic JSON RPC calls
-/// and dispatches them to the user's `XPCMessageHandler`.
+/// and dispatches them to the registered functions in the service definition.
 public class MacifyServiceImpl: NSObject, MacifyXPCProtocol {
-    private let handler: XPCMessageHandler
+    private let definition: XPCServiceDefinition
     private let emitter: XPCEventEmitter
 
-    public init(handler: XPCMessageHandler, connection: NSXPCConnection) {
-        self.handler = handler
+    public init(definition: XPCServiceDefinition, connection: NSXPCConnection) {
+        self.definition = definition
         self.emitter = XPCEventEmitter(connection: connection)
         super.init()
     }
@@ -32,8 +32,8 @@ public class MacifyServiceImpl: NSObject, MacifyXPCProtocol {
                     decoded = json
                 }
 
-                // Dispatch to user's handler
-                let result = try await handler.handle(
+                // Dispatch to the appropriate function in the definition
+                let result = try await definition.call(
                     type: type, payload: decoded, emitter: emitter
                 )
 

package/swift/Sources/MacifyXPCService/XPCServiceDefinitionBuilder.swift

@@ -0,0 +1,67 @@
+import Foundation
+
+/// Holds a collection of registered XPC functions and dispatches calls to them.
+public struct XPCServiceDefinition {
+    private let functionsByName: [String: ([String: Any], XPCEventEmitter) async throws -> [String: Any]]
+
+    init(functions: [FunctionDefinition]) {
+        var dict: [String: ([String: Any], XPCEventEmitter) async throws -> [String: Any]] = [:]
+        for function in functions {
+            dict[function.name] = function.handler
+        }
+        self.functionsByName = dict
+    }
+
+    /// Look up and call a function by name.
+    /// - Parameters:
+    ///   - type: The function name
+    ///   - payload: The decoded JSON payload
+    ///   - emitter: The event emitter for pushing events back to the app
+    /// - Returns: The response dictionary
+    /// - Throws: `MacifyXPCError.unknownMethod` if the function name is not registered
+    func call(
+        type: String,
+        payload: [String: Any],
+        emitter: XPCEventEmitter
+    ) async throws -> [String: Any] {
+        guard let handler = functionsByName[type] else {
+            throw MacifyXPCError.unknownMethod(type)
+        }
+        return try await handler(payload, emitter)
+    }
+}
+
+/// Result builder for composing XPC function definitions.
+@resultBuilder
+public struct XPCServiceDefinitionBuilder {
+    /// Build a single function definition.
+    public static func buildExpression(_ expression: FunctionDefinition) -> [FunctionDefinition] {
+        [expression]
+    }
+
+    /// Build a block of function definitions.
+    public static func buildBlock(_ components: [FunctionDefinition]...) -> [FunctionDefinition] {
+        components.flatMap { $0 }
+    }
+
+    /// Handle optional components (e.g., `if` without `else`).
+    public static func buildOptional(_ component: [FunctionDefinition]?) -> [FunctionDefinition] {
+        component ?? []
+    }
+
+    /// Handle the first branch of a conditional.
+    public static func buildEither(first component: [FunctionDefinition]) -> [FunctionDefinition] {
+        component
+    }
+
+    /// Handle the second branch of a conditional.
+    public static func buildEither(second component: [FunctionDefinition]) -> [FunctionDefinition] {
+        component
+    }
+
+    /// Handle `if #available(...)` checks.
+    @available(macOS 13.0, *)
+    public static func buildLimitedAvailability(_ component: [FunctionDefinition]) -> [FunctionDefinition] {
+        component
+    }
+}

package/swift/Sources/MacifyXPCService/XPCServiceHost.swift

@@ -6,24 +6,23 @@ import Foundation
 /// ```swift
 /// import MacifyXPCService
 ///
-/// struct MyHandler: XPCMessageHandler {
-///     func handle(type: String, payload: [String: Any], emitter: XPCEventEmitter) async throws -> [String: Any] {
-///         switch type {
-///         case "ping":
-///             return ["message": "pong"]
-///         default:
-///             throw MacifyXPCError.unknownMethod(type)
-///         }
+/// XPCService {
+///     Function("ping") {
+///         return ["message": "pong"]
 ///     }
-/// }
 ///
-/// XPCServiceHost.start(handler: MyHandler())
+///     Function("processImage") { (payload, emitter) in
+///         let path = payload["path"] as! String
+///         emitter.emit("progress", payload: ["percent": 0.5])
+///         return ["result": "processed \(path)"]
+///     }
+/// }
 /// ```
 public enum XPCServiceHost {
-    /// Start the XPC service listener with the given message handler.
+    /// Start the XPC service with the given definition.
     /// This function never returns — it runs the main run loop.
-    public static func start(handler: XPCMessageHandler) {
-        let delegate = ServiceDelegate(handler: handler)
+    public static func start(definition: XPCServiceDefinition) {
+        let delegate = ServiceDelegate(definition: definition)
         let listener = NSXPCListener.service()
         listener.delegate = delegate
 
@@ -37,12 +36,38 @@ public enum XPCServiceHost {
     private static var _delegate: ServiceDelegate?
 }
 
+/// Entry point DSL for defining and starting an XPC service.
+///
+/// Usage:
+/// ```swift
+/// XPCService {
+///     Function("ping") {
+///         return ["message": "pong"]
+///     }
+///
+///     Function("echo") { (payload) in
+///         return payload
+///     }
+/// }
+/// ```
+/// - Parameter content: A builder closure that defines the service functions
+public func XPCService(
+    @XPCServiceDefinitionBuilder _ content: () -> [FunctionDefinition]
+) {
+    let functions = content()
+    let definition = XPCServiceDefinition(functions: functions)
+    XPCServiceHost.start(definition: definition)
+    // Keep the process alive indefinitely
+    dispatchMain()
+}
+
+
 /// Internal delegate that vends `MacifyServiceImpl` instances to incoming connections.
 class ServiceDelegate: NSObject, NSXPCListenerDelegate {
-    let handler: XPCMessageHandler
+    let definition: XPCServiceDefinition
 
-    init(handler: XPCMessageHandler) {
-        self.handler = handler
+    init(definition: XPCServiceDefinition) {
+        self.definition = definition
         super.init()
     }
 
@@ -62,7 +87,7 @@ class ServiceDelegate: NSObject, NSXPCListenerDelegate {
 
         // Vend the service implementation
         connection.exportedObject = MacifyServiceImpl(
-            handler: handler, connection: connection
+            definition: definition, connection: connection
         )
 
         connection.invalidationHandler = {
@@ -73,3 +98,5 @@ class ServiceDelegate: NSObject, NSXPCListenerDelegate {
         return true
     }
 }
+
+

package/swift/Sources/MacifyXPCService/XPCMessageHandler.swift

@@ -1,18 +0,0 @@
-import Foundation
-
-/// Protocol that users implement to handle XPC messages.
-/// The user's `main.swift` creates a struct conforming to this and passes
-/// it to `XPCServiceHost.start(handler:)`.
-public protocol XPCMessageHandler {
-    /// Handle an incoming RPC call.
-    /// - Parameters:
-    ///   - type: The message type string (e.g. "ping", "processImage")
-    ///   - payload: Decoded JSON payload as a dictionary
-    ///   - emitter: Used to push events back to the app
-    /// - Returns: A dictionary that will be JSON-encoded and sent back as the reply
-    func handle(
-        type: String,
-        payload: [String: Any],
-        emitter: XPCEventEmitter
-    ) async throws -> [String: Any]
-}