react-native-ble-nitro 1.0.0-beta.18 → 1.0.0-beta.19

package/ios/BleNitroBleManager.swift

@@ -21,58 +21,40 @@ public class BleNitroBleManager: HybridBleManagerSpec {
     // MARK: - HybridBleManagerSpec Implementation (Stubs)
     
     public func destroy() throws -> Promise<Void> {
-        return Promise { resolve, reject in
-            resolve(())
-        }
+        return Promise.resolved(withResult: ())
     }
     
     public func initialize(options: BleManagerNitroOptions) throws -> Promise<Void> {
-        return Promise { resolve, reject in
-            print("BleNitro: iOS implementation not yet complete")
-            resolve(())
-        }
+        print("BleNitro: iOS implementation not yet complete")
+        return Promise.resolved(withResult: ())
     }
     
     public func getRestoredState() throws -> Promise<BleRestoredState?> {
-        return Promise { resolve, reject in
-            resolve(nil)
-        }
+        return Promise.resolved(withResult: nil as BleRestoredState?)
     }
     
     public func setLogLevel(logLevel: BleLogLevel) throws -> Promise<BleLogLevel> {
-        return Promise { resolve, reject in
-            resolve(logLevel)
-        }
+        return Promise.resolved(withResult: logLevel)
     }
     
     public func logLevel() throws -> Promise<BleLogLevel> {
-        return Promise { resolve, reject in
-            resolve(.none)
-        }
+        return Promise.resolved(withResult: BleLogLevel.none)
     }
     
     public func cancelTransaction(transactionId: String) throws -> Promise<Void> {
-        return Promise { resolve, reject in
-            resolve(())
-        }
+        return Promise.resolved(withResult: ())
     }
     
     public func enable(transactionId: String?) throws -> Promise<Void> {
-        return Promise { resolve, reject in
-            reject(BleError.notImplemented("enable not implemented on iOS yet"))
-        }
+        return Promise.rejected(withError: BleError.notImplemented("enable not implemented on iOS yet"))
     }
     
     public func disable(transactionId: String?) throws -> Promise<Void> {
-        return Promise { resolve, reject in
-            reject(BleError.notImplemented("disable not implemented on iOS yet"))
-        }
+        return Promise.rejected(withError: BleError.notImplemented("disable not implemented on iOS yet"))
     }
     
     public func state() throws -> Promise<State> {
-        return Promise { resolve, reject in
-            resolve(.unknown)
-        }
+        return Promise.resolved(withResult: State.unknown)
     }
     
     public func onStateChange(listener: @escaping (State) -> Void, emitCurrentState: Bool?) throws -> Subscription {
@@ -80,57 +62,39 @@ public class BleNitroBleManager: HybridBleManagerSpec {
     }
     
     public func startDeviceScan(uuids: [String]?, options: ScanOptions?, listener: @escaping (NativeBleError?, NativeDevice?) -> Void) throws -> Promise<Void> {
-        return Promise { resolve, reject in
-            reject(BleError.notImplemented("startDeviceScan not implemented on iOS yet"))
-        }
+        return Promise.rejected(withError: BleError.notImplemented("startDeviceScan not implemented on iOS yet"))
     }
     
     public func stopDeviceScan() throws -> Promise<Void> {
-        return Promise { resolve, reject in
-            resolve(())
-        }
+        return Promise.resolved(withResult: ())
     }
     
     public func requestConnectionPriorityForDevice(deviceIdentifier: String, connectionPriority: ConnectionPriority, transactionId: String?) throws -> Promise<NativeDevice> {
-        return Promise { resolve, reject in
-            reject(BleError.notImplemented("requestConnectionPriorityForDevice not implemented on iOS yet"))
-        }
+        return Promise.rejected(withError: BleError.notImplemented("requestConnectionPriorityForDevice not implemented on iOS yet"))
     }
     
     public func readRSSIForDevice(deviceIdentifier: String, transactionId: String?) throws -> Promise<NativeDevice> {
-        return Promise { resolve, reject in
-            reject(BleError.notImplemented("readRSSIForDevice not implemented on iOS yet"))
-        }
+        return Promise.rejected(withError: BleError.notImplemented("readRSSIForDevice not implemented on iOS yet"))
     }
     
     public func requestMTUForDevice(deviceIdentifier: String, mtu: Double, transactionId: String?) throws -> Promise<NativeDevice> {
-        return Promise { resolve, reject in
-            reject(BleError.notImplemented("requestMTUForDevice not implemented on iOS yet"))
-        }
+        return Promise.rejected(withError: BleError.notImplemented("requestMTUForDevice not implemented on iOS yet"))
     }
     
     public func devices(deviceIdentifiers: [String]) throws -> Promise<[NativeDevice]> {
-        return Promise { resolve, reject in
-            resolve([])
-        }
+        return Promise.resolved(withResult: [])
     }
     
     public func connectedDevices(serviceUUIDs: [String]) throws -> Promise<[NativeDevice]> {
-        return Promise { resolve, reject in
-            resolve([])
-        }
+        return Promise.resolved(withResult: [])
     }
     
     public func connectToDevice(deviceIdentifier: String, options: ConnectionOptions?) throws -> Promise<NativeDevice> {
-        return Promise { resolve, reject in
-            reject(BleError.notImplemented("connectToDevice not implemented on iOS yet"))
-        }
+        return Promise.rejected(withError: BleError.notImplemented("connectToDevice not implemented on iOS yet"))
     }
     
     public func cancelDeviceConnection(deviceIdentifier: String) throws -> Promise<NativeDevice> {
-        return Promise { resolve, reject in
-            reject(BleError.notImplemented("cancelDeviceConnection not implemented on iOS yet"))
-        }
+        return Promise.rejected(withError: BleError.notImplemented("cancelDeviceConnection not implemented on iOS yet"))
     }
     
     public func onDeviceDisconnected(deviceIdentifier: String, listener: @escaping (NativeBleError?, NativeDevice?) -> Void) throws -> Subscription {
@@ -138,45 +102,31 @@ public class BleNitroBleManager: HybridBleManagerSpec {
     }
     
     public func isDeviceConnected(deviceIdentifier: String) throws -> Promise<Bool> {
-        return Promise { resolve, reject in
-            resolve(false)
-        }
+        return Promise.resolved(withResult: false)
     }
     
     public func discoverAllServicesAndCharacteristicsForDevice(deviceIdentifier: String, transactionId: String?) throws -> Promise<NativeDevice> {
-        return Promise { resolve, reject in
-            reject(BleError.notImplemented("discoverAllServicesAndCharacteristicsForDevice not implemented on iOS yet"))
-        }
+        return Promise.rejected(withError: BleError.notImplemented("discoverAllServicesAndCharacteristicsForDevice not implemented on iOS yet"))
     }
     
     public func servicesForDevice(deviceIdentifier: String) throws -> Promise<[NativeService]> {
-        return Promise { resolve, reject in
-            resolve([])
-        }
+        return Promise.resolved(withResult: [])
     }
     
     public func characteristicsForDevice(deviceIdentifier: String, serviceUUID: String) throws -> Promise<[NativeCharacteristic]> {
-        return Promise { resolve, reject in
-            resolve([])
-        }
+        return Promise.resolved(withResult: [])
     }
     
     public func readCharacteristicForDevice(deviceIdentifier: String, serviceUUID: String, characteristicUUID: String, transactionId: String?) throws -> Promise<NativeCharacteristic> {
-        return Promise { resolve, reject in
-            reject(BleError.notImplemented("readCharacteristicForDevice not implemented on iOS yet"))
-        }
+        return Promise.rejected(withError: BleError.notImplemented("readCharacteristicForDevice not implemented on iOS yet"))
     }
     
     public func writeCharacteristicWithResponseForDevice(deviceIdentifier: String, serviceUUID: String, characteristicUUID: String, base64Value: String, transactionId: String?) throws -> Promise<NativeCharacteristic> {
-        return Promise { resolve, reject in
-            reject(BleError.notImplemented("writeCharacteristicWithResponseForDevice not implemented on iOS yet"))
-        }
+        return Promise.rejected(withError: BleError.notImplemented("writeCharacteristicWithResponseForDevice not implemented on iOS yet"))
     }
     
     public func writeCharacteristicWithoutResponseForDevice(deviceIdentifier: String, serviceUUID: String, characteristicUUID: String, base64Value: String, transactionId: String?) throws -> Promise<NativeCharacteristic> {
-        return Promise { resolve, reject in
-            reject(BleError.notImplemented("writeCharacteristicWithoutResponseForDevice not implemented on iOS yet"))
-        }
+        return Promise.rejected(withError: 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 {
@@ -184,21 +134,15 @@ public class BleNitroBleManager: HybridBleManagerSpec {
     }
     
     public func descriptorsForDevice(deviceIdentifier: String, serviceUUID: String, characteristicUUID: String) throws -> Promise<[NativeDescriptor]> {
-        return Promise { resolve, reject in
-            resolve([])
-        }
+        return Promise.resolved(withResult: [])
     }
     
     public func readDescriptorForDevice(deviceIdentifier: String, serviceUUID: String, characteristicUUID: String, descriptorUUID: String, transactionId: String?) throws -> Promise<NativeDescriptor> {
-        return Promise { resolve, reject in
-            reject(BleError.notImplemented("readDescriptorForDevice not implemented on iOS yet"))
-        }
+        return Promise.rejected(withError: BleError.notImplemented("readDescriptorForDevice 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 { resolve, reject in
-            reject(BleError.notImplemented("writeDescriptorForDevice not implemented on iOS yet"))
-        }
+        return Promise.rejected(withError: 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.18",
+  "version": "1.0.0-beta.19",
   "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",