react-native-ble-nitro 1.0.0-beta.16 → 1.0.0-beta.17

package/ios/BleNitroBleManager.swift

@@ -12,7 +12,7 @@ import NitroModules
  * Minimal BLE Manager implementation stub for iOS
  * TODO: Implement full CoreBluetooth integration
  */
-public class BleNitroBleManager: NSObject, HybridBleManagerSpec {
+public class BleNitroBleManager: HybridBleManagerSpec {
     
     public var memorySize: Int {
         return MemorySize.MemorySize_estimate(self)
@@ -20,156 +20,129 @@ public class BleNitroBleManager: NSObject, HybridBleManagerSpec {
     
     // MARK: - HybridBleManagerSpec Implementation (Stubs)
     
-    public func destroy() async throws {
-        // TODO: Implement destroy
+    public func destroy() throws -> Promise<Void> {
+        return Promise.resolve(withResult: ())
     }
     
-    public func initialize(options: BleManagerNitroOptions) async throws {
-        // TODO: Implement initialize
+    public func initialize(options: BleManagerNitroOptions) throws -> Promise<Void> {
         print("BleNitro: iOS implementation not yet complete")
+        return Promise.resolve(withResult: ())
     }
     
-    public func getRestoredState() async throws -> BleRestoredState? {
-        // TODO: Implement getRestoredState
-        return nil
+    public func getRestoredState() throws -> Promise<BleRestoredState?> {
+        return Promise.resolve(withResult: nil)
     }
     
-    public func setLogLevel(logLevel: BleLogLevel) async throws -> BleLogLevel {
-        // TODO: Implement setLogLevel
-        return logLevel
+    public func setLogLevel(logLevel: BleLogLevel) throws -> Promise<BleLogLevel> {
+        return Promise.resolve(withResult: logLevel)
     }
     
-    public func logLevel() async throws -> BleLogLevel {
-        // TODO: Implement logLevel
-        return .none
+    public func logLevel() throws -> Promise<BleLogLevel> {
+        return Promise.resolve(withResult: .none)
     }
     
-    public func cancelTransaction(transactionId: String) async throws {
-        // TODO: Implement cancelTransaction
+    public func cancelTransaction(transactionId: String) throws -> Promise<Void> {
+        return Promise.resolve(withResult: ())
     }
     
-    public func enable(transactionId: String?) async throws {
-        // TODO: Implement enable
-        throw BleError.notImplemented("enable not implemented on iOS yet")
+    public func enable(transactionId: String?) throws -> Promise<Void> {
+        return Promise.reject(error: BleError.notImplemented("enable not implemented on iOS yet"))
     }
     
-    public func disable(transactionId: String?) async throws {
-        // TODO: Implement disable
-        throw BleError.notImplemented("disable not implemented on iOS yet")
+    public func disable(transactionId: String?) throws -> Promise<Void> {
+        return Promise.reject(error: BleError.notImplemented("disable not implemented on iOS yet"))
     }
     
-    public func state() async throws -> State {
-        // TODO: Implement state
-        return .unknown
+    public func state() throws -> Promise<State> {
+        return Promise.resolve(withResult: .unknown)
     }
     
     public func onStateChange(listener: @escaping (State) -> Void, emitCurrentState: Bool?) throws -> Subscription {
-        // TODO: Implement onStateChange
         return Subscription(remove: {})
     }
     
-    public func startDeviceScan(uuids: [String]?, options: ScanOptions?, listener: @escaping (NativeBleError?, NativeDevice?) -> Void) async throws {
-        // TODO: Implement startDeviceScan
-        throw BleError.notImplemented("startDeviceScan not implemented on iOS yet")
+    public func startDeviceScan(uuids: [String]?, options: ScanOptions?, listener: @escaping (NativeBleError?, NativeDevice?) -> Void) throws -> Promise<Void> {
+        return Promise.reject(error: BleError.notImplemented("startDeviceScan not implemented on iOS yet"))
     }
     
-    public func stopDeviceScan() async throws {
-        // TODO: Implement stopDeviceScan
+    public func stopDeviceScan() throws -> Promise<Void> {
+        return Promise.resolve(withResult: ())
     }
     
-    public func requestConnectionPriorityForDevice(deviceIdentifier: String, connectionPriority: ConnectionPriority, transactionId: String?) async throws -> NativeDevice {
-        // TODO: Implement requestConnectionPriorityForDevice
-        throw BleError.notImplemented("requestConnectionPriorityForDevice not implemented on iOS yet")
+    public func requestConnectionPriorityForDevice(deviceIdentifier: String, connectionPriority: ConnectionPriority, transactionId: String?) throws -> Promise<NativeDevice> {
+        return Promise.reject(error: BleError.notImplemented("requestConnectionPriorityForDevice not implemented on iOS yet"))
     }
     
-    public func readRSSIForDevice(deviceIdentifier: String, transactionId: String?) async throws -> NativeDevice {
-        // TODO: Implement readRSSIForDevice
-        throw BleError.notImplemented("readRSSIForDevice not implemented on iOS yet")
+    public func readRSSIForDevice(deviceIdentifier: String, transactionId: String?) throws -> Promise<NativeDevice> {
+        return Promise.reject(error: BleError.notImplemented("readRSSIForDevice not implemented on iOS yet"))
     }
     
-    public func requestMTUForDevice(deviceIdentifier: String, mtu: Double, transactionId: String?) async throws -> NativeDevice {
-        // TODO: Implement requestMTUForDevice
-        throw BleError.notImplemented("requestMTUForDevice not implemented on iOS yet")
+    public func requestMTUForDevice(deviceIdentifier: String, mtu: Double, transactionId: String?) throws -> Promise<NativeDevice> {
+        return Promise.reject(error: BleError.notImplemented("requestMTUForDevice not implemented on iOS yet"))
     }
     
-    public func devices(deviceIdentifiers: [String]) async throws -> [NativeDevice] {
-        // TODO: Implement devices
-        return []
+    public func devices(deviceIdentifiers: [String]) throws -> Promise<[NativeDevice]> {
+        return Promise.resolve(withResult: [])
     }
     
-    public func connectedDevices(serviceUUIDs: [String]) async throws -> [NativeDevice] {
-        // TODO: Implement connectedDevices
-        return []
+    public func connectedDevices(serviceUUIDs: [String]) throws -> Promise<[NativeDevice]> {
+        return Promise.resolve(withResult: [])
     }
     
-    public func connectToDevice(deviceIdentifier: String, options: ConnectionOptions?) async throws -> NativeDevice {
-        // TODO: Implement connectToDevice
-        throw BleError.notImplemented("connectToDevice not implemented on iOS yet")
+    public func connectToDevice(deviceIdentifier: String, options: ConnectionOptions?) throws -> Promise<NativeDevice> {
+        return Promise.reject(error: BleError.notImplemented("connectToDevice not implemented on iOS yet"))
     }
     
-    public func cancelDeviceConnection(deviceIdentifier: String) async throws -> NativeDevice {
-        // TODO: Implement cancelDeviceConnection
-        throw BleError.notImplemented("cancelDeviceConnection not implemented on iOS yet")
+    public func cancelDeviceConnection(deviceIdentifier: String) throws -> Promise<NativeDevice> {
+        return Promise.reject(error: BleError.notImplemented("cancelDeviceConnection not implemented on iOS yet"))
     }
     
     public func onDeviceDisconnected(deviceIdentifier: String, listener: @escaping (NativeBleError?, NativeDevice?) -> Void) throws -> Subscription {
-        // TODO: Implement onDeviceDisconnected
         return Subscription(remove: {})
     }
     
-    public func isDeviceConnected(deviceIdentifier: String) async throws -> Bool {
-        // TODO: Implement isDeviceConnected
-        return false
+    public func isDeviceConnected(deviceIdentifier: String) throws -> Promise<Bool> {
+        return Promise.resolve(withResult: false)
     }
     
-    public func discoverAllServicesAndCharacteristicsForDevice(deviceIdentifier: String, transactionId: String?) async throws -> NativeDevice {
-        // TODO: Implement discoverAllServicesAndCharacteristicsForDevice
-        throw BleError.notImplemented("discoverAllServicesAndCharacteristicsForDevice not implemented on iOS yet")
+    public func discoverAllServicesAndCharacteristicsForDevice(deviceIdentifier: String, transactionId: String?) throws -> Promise<NativeDevice> {
+        return Promise.reject(error: BleError.notImplemented("discoverAllServicesAndCharacteristicsForDevice not implemented on iOS yet"))
     }
     
-    public func servicesForDevice(deviceIdentifier: String) async throws -> [NativeService] {
-        // TODO: Implement servicesForDevice
-        return []
+    public func servicesForDevice(deviceIdentifier: String) throws -> Promise<[NativeService]> {
+        return Promise.resolve(withResult: [])
     }
     
-    public func characteristicsForDevice(deviceIdentifier: String, serviceUUID: String) async throws -> [NativeCharacteristic] {
-        // TODO: Implement characteristicsForDevice
-        return []
+    public func characteristicsForDevice(deviceIdentifier: String, serviceUUID: String) throws -> Promise<[NativeCharacteristic]> {
+        return Promise.resolve(withResult: [])
     }
     
-    public func readCharacteristicForDevice(deviceIdentifier: String, serviceUUID: String, characteristicUUID: String, transactionId: String?) async throws -> NativeCharacteristic {
-        // TODO: Implement readCharacteristicForDevice
-        throw BleError.notImplemented("readCharacteristicForDevice not implemented on iOS yet")
+    public func readCharacteristicForDevice(deviceIdentifier: String, serviceUUID: String, characteristicUUID: String, transactionId: String?) throws -> Promise<NativeCharacteristic> {
+        return Promise.reject(error: BleError.notImplemented("readCharacteristicForDevice not implemented on iOS yet"))
     }
     
-    public func writeCharacteristicWithResponseForDevice(deviceIdentifier: String, serviceUUID: String, characteristicUUID: String, base64Value: String, transactionId: String?) async throws -> NativeCharacteristic {
-        // TODO: Implement writeCharacteristicWithResponseForDevice
-        throw BleError.notImplemented("writeCharacteristicWithResponseForDevice not implemented on iOS yet")
+    public func writeCharacteristicWithResponseForDevice(deviceIdentifier: String, serviceUUID: String, characteristicUUID: String, base64Value: String, transactionId: String?) throws -> Promise<NativeCharacteristic> {
+        return Promise.reject(error: BleError.notImplemented("writeCharacteristicWithResponseForDevice not implemented on iOS yet"))
     }
     
-    public func writeCharacteristicWithoutResponseForDevice(deviceIdentifier: String, serviceUUID: String, characteristicUUID: String, base64Value: String, transactionId: String?) async throws -> NativeCharacteristic {
-        // TODO: Implement writeCharacteristicWithoutResponseForDevice
-        throw BleError.notImplemented("writeCharacteristicWithoutResponseForDevice not implemented on iOS yet")
+    public func writeCharacteristicWithoutResponseForDevice(deviceIdentifier: String, serviceUUID: String, characteristicUUID: String, base64Value: String, transactionId: String?) throws -> Promise<NativeCharacteristic> {
+        return Promise.reject(error: BleError.notImplemented("writeCharacteristicWithoutResponseForDevice not implemented on iOS yet"))
     }
     
     public func monitorCharacteristicForDevice(deviceIdentifier: String, serviceUUID: String, characteristicUUID: String, listener: @escaping (NativeBleError?, NativeCharacteristic?) -> Void, transactionId: String?, subscriptionType: CharacteristicSubscriptionType?) throws -> Subscription {
-        // TODO: Implement monitorCharacteristicForDevice
         return Subscription(remove: {})
     }
     
-    public func descriptorsForDevice(deviceIdentifier: String, serviceUUID: String, characteristicUUID: String) async throws -> [NativeDescriptor] {
-        // TODO: Implement descriptorsForDevice
-        return []
+    public func descriptorsForDevice(deviceIdentifier: String, serviceUUID: String, characteristicUUID: String) throws -> Promise<[NativeDescriptor]> {
+        return Promise.resolve(withResult: [])
     }
     
-    public func readDescriptorForDevice(deviceIdentifier: String, serviceUUID: String, characteristicUUID: String, descriptorUUID: String, transactionId: String?) async throws -> NativeDescriptor {
-        // TODO: Implement readDescriptorForDevice
-        throw BleError.notImplemented("readDescriptorForDevice not implemented on iOS yet")
+    public func readDescriptorForDevice(deviceIdentifier: String, serviceUUID: String, characteristicUUID: String, descriptorUUID: String, transactionId: String?) throws -> Promise<NativeDescriptor> {
+        return Promise.reject(error: BleError.notImplemented("readDescriptorForDevice not implemented on iOS yet"))
     }
     
-    public func writeDescriptorForDevice(deviceIdentifier: String, serviceUUID: String, characteristicUUID: String, descriptorUUID: String, valueBase64: String, transactionId: String?) async throws -> NativeDescriptor {
-        // TODO: Implement writeDescriptorForDevice
-        throw BleError.notImplemented("writeDescriptorForDevice not implemented on iOS yet")
+    public func writeDescriptorForDevice(deviceIdentifier: String, serviceUUID: String, characteristicUUID: String, descriptorUUID: String, valueBase64: String, transactionId: String?) throws -> Promise<NativeDescriptor> {
+        return Promise.reject(error: BleError.notImplemented("writeDescriptorForDevice not implemented on iOS yet"))
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-ble-nitro",
-  "version": "1.0.0-beta.16",
+  "version": "1.0.0-beta.17",
   "description": "High-performance React Native BLE library built on Nitro Modules - drop-in replacement for react-native-ble-plx",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",