@candypoets/nipworker 0.96.3 → 0.96.5

package/swift/Sources/NipworkerSwift/Hooks.swift

@@ -0,0 +1,300 @@
+import Foundation
+
+public final class NipworkerHookHandle {
+    private let onCancel: () -> Void
+    private var isCancelled = false
+
+    public init(_ onCancel: @escaping () -> Void) {
+        self.onCancel = onCancel
+    }
+
+    public func cancel() {
+        guard !isCancelled else { return }
+        isCancelled = true
+        onCancel()
+    }
+
+    deinit {
+        cancel()
+    }
+}
+
+// MARK: - Callback-based subscription helpers
+
+/// Subscribe through the React Native shared runtime. Returns an unsubscribe function.
+public func useSubscription(
+    subscriptionId: String,
+    requests: [RequestObject],
+    callback: @escaping ([WorkerMessageView]) -> Void,
+    options: SubscriptionConfig = SubscriptionConfig()
+) -> () -> Void {
+    useSubscription(
+        manager: NostrManager.reactNativeShared(),
+        subscriptionId: subscriptionId,
+        requests: requests,
+        callback: callback,
+        options: options
+    )
+}
+
+/// Subscribe with a callback closure. Returns an unsubscribe function.
+/// Mirrors the JS `useSubscription` hook pattern.
+public func useSubscription(
+    manager: NostrManager,
+    subscriptionId: String,
+    requests: [RequestObject],
+    callback: @escaping ([WorkerMessageView]) -> Void,
+    options: SubscriptionConfig = SubscriptionConfig()
+) -> () -> Void {
+    var notificationToken: NSObjectProtocol?
+    var lastReadPosition = 4
+    var isActive = true
+    let canonicalSubscriptionId = subscriptionId
+
+    func readAvailableMessages() {
+        Task {
+            var position = lastReadPosition
+            var allMessages: [WorkerMessageView] = []
+
+            while true {
+                let result = await manager.readWorkerMessages(for: canonicalSubscriptionId, from: position)
+                if result.messages.isEmpty {
+                    break
+                }
+                allMessages.append(contentsOf: result.messages)
+                position = result.newPosition
+            }
+
+            lastReadPosition = position
+            if isActive, !allMessages.isEmpty {
+                callback(allMessages)
+            }
+        }
+    }
+
+    Task {
+        notificationToken = NotificationCenter.default.addObserver(
+            forName: .nipworkerSubscriptionUpdated(subId: canonicalSubscriptionId),
+            object: nil,
+            queue: .main
+        ) { _ in
+            guard isActive else { return }
+            readAvailableMessages()
+        }
+
+        _ = await manager.subscribe(subscriptionId: subscriptionId, requests: requests, options: options)
+        readAvailableMessages()
+    }
+
+    return {
+        isActive = false
+        if let token = notificationToken {
+            NotificationCenter.default.removeObserver(token)
+        }
+        Task {
+            await manager.unsubscribe(subscriptionId: canonicalSubscriptionId)
+        }
+    }
+}
+
+/// Subscribe through the React Native shared runtime. Returns a cancellable handle.
+public func useSubscriptionHandle(
+    subscriptionId: String,
+    requests: [RequestObject],
+    callback: @escaping ([WorkerMessageView]) -> Void,
+    options: SubscriptionConfig = SubscriptionConfig()
+) -> NipworkerHookHandle {
+    NipworkerHookHandle(
+        useSubscription(
+            subscriptionId: subscriptionId,
+            requests: requests,
+            callback: callback,
+            options: options
+        )
+    )
+}
+
+/// Subscribe with a callback closure. Returns a cancellable handle.
+/// This is the native component-friendly form of the JS `useSubscription` API.
+public func useSubscriptionHandle(
+    manager: NostrManager,
+    subscriptionId: String,
+    requests: [RequestObject],
+    callback: @escaping ([WorkerMessageView]) -> Void,
+    options: SubscriptionConfig = SubscriptionConfig()
+) -> NipworkerHookHandle {
+    NipworkerHookHandle(
+        useSubscription(
+            manager: manager,
+            subscriptionId: subscriptionId,
+            requests: requests,
+            callback: callback,
+            options: options
+        )
+    )
+}
+
+/// Publish through the React Native shared runtime. Returns an unsubscribe function.
+public func usePublish(
+    publishId: String,
+    event: NostrEvent,
+    callback: @escaping ([String: PublishStatus]) -> Void,
+    defaultRelays: [String] = [],
+    optimisticSubIds: [String] = []
+) -> () -> Void {
+    usePublish(
+        manager: NostrManager.reactNativeShared(),
+        publishId: publishId,
+        event: event,
+        callback: callback,
+        defaultRelays: defaultRelays,
+        optimisticSubIds: optimisticSubIds
+    )
+}
+
+/// Publish with a callback for status updates. Returns an unsubscribe function.
+/// Mirrors the JS `usePublish` hook pattern.
+public func usePublish(
+    manager: NostrManager,
+    publishId: String,
+    event: NostrEvent,
+    callback: @escaping ([String: PublishStatus]) -> Void,
+    defaultRelays: [String] = [],
+    optimisticSubIds: [String] = []
+) -> () -> Void {
+    var notificationToken: NSObjectProtocol?
+    var lastReadPosition = 4
+    var isActive = true
+
+    Task {
+        _ = await manager.publish(
+            publishId: publishId,
+            event: event,
+            defaultRelays: defaultRelays,
+            optimisticSubIds: optimisticSubIds
+        )
+
+        notificationToken = NotificationCenter.default.addObserver(
+            forName: .nipworkerSubscriptionUpdated(subId: publishId),
+            object: nil,
+            queue: .main
+        ) { [weak manager] _ in
+            guard isActive,
+                  let manager = manager else { return }
+
+            Task {
+                var position = lastReadPosition
+                var merged: [String: PublishStatus] = [:]
+
+                while true {
+                    let result = await manager.readPublishStatuses(for: publishId, from: position)
+                    if result.statuses.isEmpty {
+                        break
+                    }
+                    for (url, status) in result.statuses {
+                        merged[url] = status
+                    }
+                    position = result.newPosition
+                }
+
+                lastReadPosition = position
+                if !merged.isEmpty {
+                    callback(merged)
+                }
+            }
+        }
+    }
+
+    return {
+        isActive = false
+        if let token = notificationToken {
+            NotificationCenter.default.removeObserver(token)
+        }
+        Task {
+            await manager.releasePublish(publishId: publishId)
+        }
+    }
+}
+
+/// Publish through the React Native shared runtime. Returns a cancellable handle.
+public func usePublishHandle(
+    publishId: String,
+    event: NostrEvent,
+    callback: @escaping ([String: PublishStatus]) -> Void,
+    defaultRelays: [String] = [],
+    optimisticSubIds: [String] = []
+) -> NipworkerHookHandle {
+    NipworkerHookHandle(
+        usePublish(
+            publishId: publishId,
+            event: event,
+            callback: callback,
+            defaultRelays: defaultRelays,
+            optimisticSubIds: optimisticSubIds
+        )
+    )
+}
+
+/// Publish with a callback for status updates. Returns a cancellable handle.
+/// This is the native component-friendly form of the JS `usePublish` API.
+public func usePublishHandle(
+    manager: NostrManager,
+    publishId: String,
+    event: NostrEvent,
+    callback: @escaping ([String: PublishStatus]) -> Void,
+    defaultRelays: [String] = [],
+    optimisticSubIds: [String] = []
+) -> NipworkerHookHandle {
+    NipworkerHookHandle(
+        usePublish(
+            manager: manager,
+            publishId: publishId,
+            event: event,
+            callback: callback,
+            defaultRelays: defaultRelays,
+            optimisticSubIds: optimisticSubIds
+        )
+    )
+}
+
+/// Relay status helper using the React Native shared runtime.
+public func useRelayStatus(
+    onStatus: @escaping (String, RelayStatus) -> Void
+) -> () -> Void {
+    useRelayStatus(manager: NostrManager.reactNativeShared(), onStatus: onStatus)
+}
+
+/// Relay status helper. Immediately calls handler with current statuses,
+/// then subscribes to updates. Returns a stop function.
+public func useRelayStatus(
+    manager: NostrManager,
+    onStatus: @escaping (String, RelayStatus) -> Void
+) -> () -> Void {
+    var notificationToken: NSObjectProtocol?
+    var isActive = true
+
+    Task {
+        let statuses = await manager.getRelayStatuses()
+        for (url, status) in statuses {
+            onStatus(url, status)
+        }
+
+        notificationToken = NotificationCenter.default.addObserver(
+            forName: .nipworkerRelayStatusUpdated,
+            object: nil,
+            queue: .main
+        ) { notification in
+            guard isActive,
+                  let url = notification.userInfo?["url"] as? String,
+                  let status = notification.userInfo?["status"] as? RelayStatus else { return }
+            onStatus(url, status)
+        }
+    }
+
+    return {
+        isActive = false
+        if let token = notificationToken {
+            NotificationCenter.default.removeObserver(token)
+        }
+    }
+}

package/swift/Sources/NipworkerSwift/Models.swift

@@ -0,0 +1,156 @@
+import Foundation
+
+public struct RequestObject {
+    public var ids: [String]?
+    public var authors: [String]?
+    public var kinds: [UInt16]?
+    public var tags: [String: [String]]?
+    public var since: Int?
+    public var until: Int?
+    public var limit: Int?
+    public var search: String?
+    public var relays: [String]
+    public var closeOnEOSE: Bool?
+    public var cacheFirst: Bool?
+    public var noCache: Bool?
+    public var maxRelays: UInt16?
+
+    public init(
+        ids: [String]? = nil,
+        authors: [String]? = nil,
+        kinds: [UInt16]? = nil,
+        tags: [String: [String]]? = nil,
+        since: Int? = nil,
+        until: Int? = nil,
+        limit: Int? = nil,
+        search: String? = nil,
+        relays: [String] = [],
+        closeOnEOSE: Bool? = nil,
+        cacheFirst: Bool? = nil,
+        noCache: Bool? = nil,
+        maxRelays: UInt16? = nil
+    ) {
+        self.ids = ids
+        self.authors = authors
+        self.kinds = kinds
+        self.tags = tags
+        self.since = since
+        self.until = until
+        self.limit = limit
+        self.search = search
+        self.relays = relays
+        self.closeOnEOSE = closeOnEOSE
+        self.cacheFirst = cacheFirst
+        self.noCache = noCache
+        self.maxRelays = maxRelays
+    }
+}
+
+public struct PipeConfig {
+    public enum Kind {
+        case muteFilter
+        case parse
+        case saveToDb
+        case serializeEvents(subId: String)
+        case kindFilter(kinds: [UInt16])
+        case counter(kinds: [UInt16], pubkey: String)
+        case npubLimiter(kind: UInt16, limitPerNpub: UInt32, maxTotalNpubs: UInt32)
+        case proofVerification(maxProofs: UInt32)
+    }
+    public var kind: Kind
+    public init(_ kind: Kind) { self.kind = kind }
+}
+
+public struct SubscriptionConfig {
+    public var pipeline: [PipeConfig]?
+    public var closeOnEose: Bool
+    public var cacheFirst: Bool
+    public var timeoutMs: UInt64?
+    public var maxEvents: UInt32?
+    public var skipCache: Bool
+    public var force: Bool
+    public var bytesPerEvent: UInt32
+    public var isSlow: Bool
+    public var pagination: String?
+    public var cacheOnly: Bool
+
+    public init(
+        pipeline: [PipeConfig]? = nil,
+        closeOnEose: Bool = false,
+        cacheFirst: Bool = true,
+        timeoutMs: UInt64? = nil,
+        maxEvents: UInt32? = nil,
+        skipCache: Bool = false,
+        force: Bool = false,
+        bytesPerEvent: UInt32 = 3072,
+        isSlow: Bool = false,
+        pagination: String? = nil,
+        cacheOnly: Bool = false
+    ) {
+        self.pipeline = pipeline
+        self.closeOnEose = closeOnEose
+        self.cacheFirst = cacheFirst
+        self.timeoutMs = timeoutMs
+        self.maxEvents = maxEvents
+        self.skipCache = skipCache
+        self.force = force
+        self.bytesPerEvent = bytesPerEvent
+        self.isSlow = isSlow
+        self.pagination = pagination
+        self.cacheOnly = cacheOnly
+    }
+}
+
+public struct EventTemplate {
+    public var kind: UInt16
+    public var content: String
+    public var tags: [[String]]
+
+    public init(kind: UInt16, content: String, tags: [[String]] = []) {
+        self.kind = kind
+        self.content = content
+        self.tags = tags
+    }
+}
+
+public struct NostrEvent: Identifiable, Equatable, Sendable {
+    public var id: String
+    public var pubkey: String
+    public var kind: UInt16
+    public var content: String
+    public var tags: [[String]]
+    public var createdAt: Int
+    public var sig: String
+
+    public init(id: String, pubkey: String, kind: UInt16, content: String, tags: [[String]], createdAt: Int, sig: String) {
+        self.id = id
+        self.pubkey = pubkey
+        self.kind = kind
+        self.content = content
+        self.tags = tags
+        self.createdAt = createdAt
+        self.sig = sig
+    }
+}
+
+public struct NostrManagerConfig {
+    public var logLevel: String?
+    public init(logLevel: String? = nil) { self.logLevel = logLevel }
+}
+
+public enum SignerTypeName: Sendable {
+    case pubkey(String)
+    case privkey(String)
+}
+
+public enum RelayStatus: Equatable, Sendable {
+    case connected
+    case failed
+    case closed(String?)
+}
+
+public enum PublishStatus: Equatable, Sendable {
+    case pending
+    case success(String)
+    case failed(String)
+}