react-native-ble-nitro 1.6.0 → 1.7.0

package/nitrogen/generated/ios/c++/HybridNativeBleNitroFactorySpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridNativeBleNitroFactorySpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridNativeBleNitroFactorySpecSwift.hpp"
+
+namespace margelo::nitro::co::zyke::ble {
+} // namespace margelo::nitro::co::zyke::ble

package/nitrogen/generated/ios/c++/HybridNativeBleNitroFactorySpecSwift.hpp

@@ -0,0 +1,94 @@
+///
+/// HybridNativeBleNitroFactorySpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridNativeBleNitroFactorySpec.hpp"
+
+// Forward declaration of `HybridNativeBleNitroFactorySpec_cxx` to properly resolve imports.
+namespace BleNitro { class HybridNativeBleNitroFactorySpec_cxx; }
+
+// Forward declaration of `HybridNativeBleNitroSpec` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { class HybridNativeBleNitroSpec; }
+// Forward declaration of `BLEDevice` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { struct BLEDevice; }
+// Forward declaration of `ManufacturerData` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { struct ManufacturerData; }
+// Forward declaration of `ManufacturerDataEntry` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { struct ManufacturerDataEntry; }
+// Forward declaration of `ArrayBuffer` to properly resolve imports.
+namespace NitroModules { class ArrayBuffer; }
+// Forward declaration of `ArrayBufferHolder` to properly resolve imports.
+namespace NitroModules { class ArrayBufferHolder; }
+
+#include <memory>
+#include "HybridNativeBleNitroSpec.hpp"
+#include <string>
+#include <optional>
+#include "BLEDevice.hpp"
+#include <vector>
+#include <functional>
+#include "ManufacturerData.hpp"
+#include "ManufacturerDataEntry.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/ArrayBufferHolder.hpp>
+
+#include "BleNitro-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::co::zyke::ble {
+
+  /**
+   * The C++ part of HybridNativeBleNitroFactorySpec_cxx.swift.
+   *
+   * HybridNativeBleNitroFactorySpecSwift (C++) accesses HybridNativeBleNitroFactorySpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridNativeBleNitroFactorySpec_cxx can directly inherit from the C++ class HybridNativeBleNitroFactorySpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridNativeBleNitroFactorySpecSwift: public virtual HybridNativeBleNitroFactorySpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridNativeBleNitroFactorySpecSwift(const BleNitro::HybridNativeBleNitroFactorySpec_cxx& swiftPart):
+      HybridObject(HybridNativeBleNitroFactorySpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline BleNitro::HybridNativeBleNitroFactorySpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    inline std::shared_ptr<HybridNativeBleNitroSpec> create(const std::optional<std::string>& nativeRestoreStateIdentifier, const std::optional<std::function<void(const std::vector<BLEDevice>& /* peripherals */)>>& restoreStateCallback) override {
+      auto __result = _swiftPart.create(nativeRestoreStateIdentifier, restoreStateCallback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    BleNitro::HybridNativeBleNitroFactorySpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::co::zyke::ble

package/nitrogen/generated/ios/c++/HybridNativeBleNitroSpecSwift.hpp

@@ -31,17 +31,17 @@ namespace margelo::nitro::co::zyke::ble { enum class BLEState; }
 // Forward declaration of `OperationResult` to properly resolve imports.
 namespace margelo::nitro::co::zyke::ble { struct OperationResult; }
 
+#include <string>
+#include <optional>
 #include "BLEDevice.hpp"
 #include <vector>
 #include <functional>
-#include <string>
 #include "ManufacturerData.hpp"
 #include "ManufacturerDataEntry.hpp"
 #include <NitroModules/ArrayBuffer.hpp>
 #include <NitroModules/ArrayBufferHolder.hpp>
 #include "ScanFilter.hpp"
 #include "AndroidScanMode.hpp"
-#include <optional>
 #include "BLEState.hpp"
 #include "OperationResult.hpp"
 #include <NitroModules/Promise.hpp>
@@ -83,7 +83,13 @@ namespace margelo::nitro::co::zyke::ble {
 
   public:
     // Properties
-    
+    inline std::optional<std::string> getRestoreStateIdentifier() noexcept override {
+      auto __result = _swiftPart.getRestoreStateIdentifier();
+      return __result;
+    }
+    inline void setRestoreStateIdentifier(const std::optional<std::string>& restoreStateIdentifier) noexcept override {
+      _swiftPart.setRestoreStateIdentifier(restoreStateIdentifier);
+    }
 
   public:
     // Methods

package/nitrogen/generated/ios/swift/BLEDevice.swift

@@ -18,14 +18,14 @@ public extension BLEDevice {
   /**
    * Create a new instance of `BLEDevice`.
    */
-  init(id: String, name: String, rssi: Double, manufacturerData: ManufacturerData, serviceUUIDs: [String], isConnectable: Bool) {
+  init(id: String, name: String, rssi: Double, manufacturerData: ManufacturerData, serviceUUIDs: [String], isConnectable: Bool, isConnected: Bool) {
     self.init(std.string(id), std.string(name), rssi, manufacturerData, { () -> bridge.std__vector_std__string_ in
       var __vector = bridge.create_std__vector_std__string_(serviceUUIDs.count)
       for __item in serviceUUIDs {
         __vector.push_back(std.string(__item))
       }
       return __vector
-    }(), isConnectable)
+    }(), isConnectable, isConnected)
   }
 
   var id: String {
@@ -99,4 +99,15 @@ public extension BLEDevice {
       self.__isConnectable = newValue
     }
   }
+  
+  var isConnected: Bool {
+    @inline(__always)
+    get {
+      return self.__isConnected
+    }
+    @inline(__always)
+    set {
+      self.__isConnected = newValue
+    }
+  }
 }

package/nitrogen/generated/ios/swift/Func_void_std__vector_BLEDevice_.swift

@@ -9,21 +9,21 @@ import NitroModules
 
 
 /**
- * Wraps a Swift `(_ restoredPeripherals: [BLEDevice]) -> Void` as a class.
+ * Wraps a Swift `(_ peripherals: [BLEDevice]) -> Void` as a class.
  * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
  */
 public final class Func_void_std__vector_BLEDevice_ {
   public typealias bridge = margelo.nitro.co.zyke.ble.bridge.swift
 
-  private let closure: (_ restoredPeripherals: [BLEDevice]) -> Void
+  private let closure: (_ peripherals: [BLEDevice]) -> Void
 
-  public init(_ closure: @escaping (_ restoredPeripherals: [BLEDevice]) -> Void) {
+  public init(_ closure: @escaping (_ peripherals: [BLEDevice]) -> Void) {
     self.closure = closure
   }
 
   @inline(__always)
-  public func call(restoredPeripherals: bridge.std__vector_BLEDevice_) -> Void {
-    self.closure(restoredPeripherals.map({ __item in __item }))
+  public func call(peripherals: bridge.std__vector_BLEDevice_) -> Void {
+    self.closure(peripherals.map({ __item in __item }))
   }
 
   /**

package/nitrogen/generated/ios/swift/HybridNativeBleNitroFactorySpec.swift

@@ -0,0 +1,49 @@
+///
+/// HybridNativeBleNitroFactorySpec.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/// See ``HybridNativeBleNitroFactorySpec``
+public protocol HybridNativeBleNitroFactorySpec_protocol: HybridObject {
+  // Properties
+  
+
+  // Methods
+  func create(nativeRestoreStateIdentifier: String?, restoreStateCallback: ((_ peripherals: [BLEDevice]) -> Void)?) throws -> (any HybridNativeBleNitroSpec)
+}
+
+/// See ``HybridNativeBleNitroFactorySpec``
+open class HybridNativeBleNitroFactorySpec_base {
+  private weak var cxxWrapper: HybridNativeBleNitroFactorySpec_cxx? = nil
+  public init() { }
+  public func getCxxWrapper() -> HybridNativeBleNitroFactorySpec_cxx {
+  #if DEBUG
+    guard self is HybridNativeBleNitroFactorySpec else {
+      fatalError("`self` is not a `HybridNativeBleNitroFactorySpec`! Did you accidentally inherit from `HybridNativeBleNitroFactorySpec_base` instead of `HybridNativeBleNitroFactorySpec`?")
+    }
+  #endif
+    if let cxxWrapper = self.cxxWrapper {
+      return cxxWrapper
+    } else {
+      let cxxWrapper = HybridNativeBleNitroFactorySpec_cxx(self as! HybridNativeBleNitroFactorySpec)
+      self.cxxWrapper = cxxWrapper
+      return cxxWrapper
+    }
+  }
+}
+
+/**
+ * A Swift base-protocol representing the NativeBleNitroFactory HybridObject.
+ * Implement this protocol to create Swift-based instances of NativeBleNitroFactory.
+ * ```swift
+ * class HybridNativeBleNitroFactory : HybridNativeBleNitroFactorySpec {
+ *   // ...
+ * }
+ * ```
+ */
+public typealias HybridNativeBleNitroFactorySpec = HybridNativeBleNitroFactorySpec_protocol & HybridNativeBleNitroFactorySpec_base

package/nitrogen/generated/ios/swift/HybridNativeBleNitroFactorySpec_cxx.swift

@@ -0,0 +1,149 @@
+///
+/// HybridNativeBleNitroFactorySpec_cxx.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * A class implementation that bridges HybridNativeBleNitroFactorySpec over to C++.
+ * In C++, we cannot use Swift protocols - so we need to wrap it in a class to make it strongly defined.
+ *
+ * Also, some Swift types need to be bridged with special handling:
+ * - Enums need to be wrapped in Structs, otherwise they cannot be accessed bi-directionally (Swift bug: https://github.com/swiftlang/swift/issues/75330)
+ * - Other HybridObjects need to be wrapped/unwrapped from the Swift TCxx wrapper
+ * - Throwing methods need to be wrapped with a Result<T, Error> type, as exceptions cannot be propagated to C++
+ */
+open class HybridNativeBleNitroFactorySpec_cxx {
+  /**
+   * The Swift <> C++ bridge's namespace (`margelo::nitro::co::zyke::ble::bridge::swift`)
+   * from `BleNitro-Swift-Cxx-Bridge.hpp`.
+   * This contains specialized C++ templates, and C++ helper functions that can be accessed from Swift.
+   */
+  public typealias bridge = margelo.nitro.co.zyke.ble.bridge.swift
+
+  /**
+   * Holds an instance of the `HybridNativeBleNitroFactorySpec` Swift protocol.
+   */
+  private var __implementation: any HybridNativeBleNitroFactorySpec
+
+  /**
+   * Holds a weak pointer to the C++ class that wraps the Swift class.
+   */
+  private var __cxxPart: bridge.std__weak_ptr_HybridNativeBleNitroFactorySpec_
+
+  /**
+   * Create a new `HybridNativeBleNitroFactorySpec_cxx` that wraps the given `HybridNativeBleNitroFactorySpec`.
+   * All properties and methods bridge to C++ types.
+   */
+  public init(_ implementation: any HybridNativeBleNitroFactorySpec) {
+    self.__implementation = implementation
+    self.__cxxPart = .init()
+    /* no base class */
+  }
+
+  /**
+   * Get the actual `HybridNativeBleNitroFactorySpec` instance this class wraps.
+   */
+  @inline(__always)
+  public func getHybridNativeBleNitroFactorySpec() -> any HybridNativeBleNitroFactorySpec {
+    return __implementation
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `HybridNativeBleNitroFactorySpec_cxx`.
+   * The pointer has to be a retained opaque `Unmanaged<HybridNativeBleNitroFactorySpec_cxx>`.
+   * This removes one strong reference from the object!
+   */
+  public class func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> HybridNativeBleNitroFactorySpec_cxx {
+    return Unmanaged<HybridNativeBleNitroFactorySpec_cxx>.fromOpaque(pointer).takeRetainedValue()
+  }
+
+  /**
+   * Gets (or creates) the C++ part of this Hybrid Object.
+   * The C++ part is a `std::shared_ptr<HybridNativeBleNitroFactorySpec>`.
+   */
+  public func getCxxPart() -> bridge.std__shared_ptr_HybridNativeBleNitroFactorySpec_ {
+    let cachedCxxPart = self.__cxxPart.lock()
+    if cachedCxxPart.__convertToBool() {
+      return cachedCxxPart
+    } else {
+      let newCxxPart = bridge.create_std__shared_ptr_HybridNativeBleNitroFactorySpec_(self.toUnsafe())
+      __cxxPart = bridge.weakify_std__shared_ptr_HybridNativeBleNitroFactorySpec_(newCxxPart)
+      return newCxxPart
+    }
+  }
+
+  
+
+  /**
+   * Get the memory size of the Swift class (plus size of any other allocations)
+   * so the JS VM can properly track it and garbage-collect the JS object if needed.
+   */
+  @inline(__always)
+  public var memorySize: Int {
+    return MemoryHelper.getSizeOf(self.__implementation) + self.__implementation.memorySize
+  }
+
+  /**
+   * Call dispose() on the Swift class.
+   * This _may_ be called manually from JS.
+   */
+  @inline(__always)
+  public func dispose() {
+    self.__implementation.dispose()
+  }
+
+  // Properties
+  
+
+  // Methods
+  @inline(__always)
+  public final func create(nativeRestoreStateIdentifier: bridge.std__optional_std__string_, restoreStateCallback: bridge.std__optional_std__function_void_const_std__vector_BLEDevice______peripherals______) -> bridge.Result_std__shared_ptr_HybridNativeBleNitroSpec__ {
+    do {
+      let __result = try self.__implementation.create(nativeRestoreStateIdentifier: { () -> String? in
+        if let __unwrapped = nativeRestoreStateIdentifier.value {
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }(), restoreStateCallback: { () -> ((_ peripherals: [BLEDevice]) -> Void)? in
+        if let __unwrapped = restoreStateCallback.value {
+          return { () -> ([BLEDevice]) -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void_std__vector_BLEDevice_(__unwrapped)
+            return { (__peripherals: [BLEDevice]) -> Void in
+              __wrappedFunction.call({ () -> bridge.std__vector_BLEDevice_ in
+                var __vector = bridge.create_std__vector_BLEDevice_(__peripherals.count)
+                for __item in __peripherals {
+                  __vector.push_back(__item)
+                }
+                return __vector
+              }())
+            }
+          }()
+        } else {
+          return nil
+        }
+      }())
+      let __resultCpp = { () -> bridge.std__shared_ptr_HybridNativeBleNitroSpec_ in
+        let __cxxWrapped = __result.getCxxWrapper()
+        return __cxxWrapped.getCxxPart()
+      }()
+      return bridge.create_Result_std__shared_ptr_HybridNativeBleNitroSpec__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_HybridNativeBleNitroSpec__(__exceptionPtr)
+    }
+  }
+}

package/nitrogen/generated/ios/swift/HybridNativeBleNitroSpec.swift

@@ -11,7 +11,7 @@ import NitroModules
 /// See ``HybridNativeBleNitroSpec``
 public protocol HybridNativeBleNitroSpec_protocol: HybridObject {
   // Properties
-  
+  var restoreStateIdentifier: String? { get set }
 
   // Methods
   func setRestoreStateCallback(callback: @escaping (_ restoredPeripherals: [BLEDevice]) -> Void) throws -> Void

package/nitrogen/generated/ios/swift/HybridNativeBleNitroSpec_cxx.swift

@@ -106,7 +106,28 @@ open class HybridNativeBleNitroSpec_cxx {
   }
 
   // Properties
-  
+  public final var restoreStateIdentifier: bridge.std__optional_std__string_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = self.__implementation.restoreStateIdentifier {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.restoreStateIdentifier = { () -> String? in
+        if let __unwrapped = newValue.value {
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
 
   // Methods
   @inline(__always)

package/nitrogen/generated/shared/c++/BLEDevice.hpp

@@ -38,10 +38,11 @@ namespace margelo::nitro::co::zyke::ble {
     ManufacturerData manufacturerData     SWIFT_PRIVATE;
     std::vector<std::string> serviceUUIDs     SWIFT_PRIVATE;
     bool isConnectable     SWIFT_PRIVATE;
+    bool isConnected     SWIFT_PRIVATE;
 
   public:
     BLEDevice() = default;
-    explicit BLEDevice(std::string id, std::string name, double rssi, ManufacturerData manufacturerData, std::vector<std::string> serviceUUIDs, bool isConnectable): id(id), name(name), rssi(rssi), manufacturerData(manufacturerData), serviceUUIDs(serviceUUIDs), isConnectable(isConnectable) {}
+    explicit BLEDevice(std::string id, std::string name, double rssi, ManufacturerData manufacturerData, std::vector<std::string> serviceUUIDs, bool isConnectable, bool isConnected): id(id), name(name), rssi(rssi), manufacturerData(manufacturerData), serviceUUIDs(serviceUUIDs), isConnectable(isConnectable), isConnected(isConnected) {}
   };
 
 } // namespace margelo::nitro::co::zyke::ble
@@ -59,7 +60,8 @@ namespace margelo::nitro {
         JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, "rssi")),
         JSIConverter<margelo::nitro::co::zyke::ble::ManufacturerData>::fromJSI(runtime, obj.getProperty(runtime, "manufacturerData")),
         JSIConverter<std::vector<std::string>>::fromJSI(runtime, obj.getProperty(runtime, "serviceUUIDs")),
-        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, "isConnectable"))
+        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, "isConnectable")),
+        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, "isConnected"))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::co::zyke::ble::BLEDevice& arg) {
@@ -70,6 +72,7 @@ namespace margelo::nitro {
       obj.setProperty(runtime, "manufacturerData", JSIConverter<margelo::nitro::co::zyke::ble::ManufacturerData>::toJSI(runtime, arg.manufacturerData));
       obj.setProperty(runtime, "serviceUUIDs", JSIConverter<std::vector<std::string>>::toJSI(runtime, arg.serviceUUIDs));
       obj.setProperty(runtime, "isConnectable", JSIConverter<bool>::toJSI(runtime, arg.isConnectable));
+      obj.setProperty(runtime, "isConnected", JSIConverter<bool>::toJSI(runtime, arg.isConnected));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -83,6 +86,7 @@ namespace margelo::nitro {
       if (!JSIConverter<margelo::nitro::co::zyke::ble::ManufacturerData>::canConvert(runtime, obj.getProperty(runtime, "manufacturerData"))) return false;
       if (!JSIConverter<std::vector<std::string>>::canConvert(runtime, obj.getProperty(runtime, "serviceUUIDs"))) return false;
       if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, "isConnectable"))) return false;
+      if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, "isConnected"))) return false;
       return true;
     }
   };

package/nitrogen/generated/shared/c++/HybridNativeBleNitroFactorySpec.cpp

@@ -0,0 +1,21 @@
+///
+/// HybridNativeBleNitroFactorySpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridNativeBleNitroFactorySpec.hpp"
+
+namespace margelo::nitro::co::zyke::ble {
+
+  void HybridNativeBleNitroFactorySpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("create", &HybridNativeBleNitroFactorySpec::create);
+    });
+  }
+
+} // namespace margelo::nitro::co::zyke::ble

package/nitrogen/generated/shared/c++/HybridNativeBleNitroFactorySpec.hpp

@@ -0,0 +1,71 @@
+///
+/// HybridNativeBleNitroFactorySpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridNativeBleNitroSpec` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { class HybridNativeBleNitroSpec; }
+// Forward declaration of `BLEDevice` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { struct BLEDevice; }
+
+#include <memory>
+#include "HybridNativeBleNitroSpec.hpp"
+#include <string>
+#include <optional>
+#include "BLEDevice.hpp"
+#include <vector>
+#include <functional>
+
+namespace margelo::nitro::co::zyke::ble {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `NativeBleNitroFactory`
+   * Inherit this class to create instances of `HybridNativeBleNitroFactorySpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridNativeBleNitroFactory: public HybridNativeBleNitroFactorySpec {
+   * public:
+   *   HybridNativeBleNitroFactory(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridNativeBleNitroFactorySpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridNativeBleNitroFactorySpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridNativeBleNitroFactorySpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<HybridNativeBleNitroSpec> create(const std::optional<std::string>& nativeRestoreStateIdentifier, const std::optional<std::function<void(const std::vector<BLEDevice>& /* peripherals */)>>& restoreStateCallback) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "NativeBleNitroFactory";
+  };
+
+} // namespace margelo::nitro::co::zyke::ble

package/nitrogen/generated/shared/c++/HybridNativeBleNitroSpec.cpp

@@ -14,6 +14,8 @@ namespace margelo::nitro::co::zyke::ble {
     HybridObject::loadHybridMethods();
     // load custom methods/properties
     registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("restoreStateIdentifier", &HybridNativeBleNitroSpec::getRestoreStateIdentifier);
+      prototype.registerHybridSetter("restoreStateIdentifier", &HybridNativeBleNitroSpec::setRestoreStateIdentifier);
       prototype.registerHybridMethod("setRestoreStateCallback", &HybridNativeBleNitroSpec::setRestoreStateCallback);
       prototype.registerHybridMethod("startScan", &HybridNativeBleNitroSpec::startScan);
       prototype.registerHybridMethod("stopScan", &HybridNativeBleNitroSpec::stopScan);

package/nitrogen/generated/shared/c++/HybridNativeBleNitroSpec.hpp

@@ -24,12 +24,12 @@ namespace margelo::nitro::co::zyke::ble { enum class BLEState; }
 // Forward declaration of `OperationResult` to properly resolve imports.
 namespace margelo::nitro::co::zyke::ble { struct OperationResult; }
 
+#include <string>
+#include <optional>
 #include "BLEDevice.hpp"
 #include <vector>
 #include <functional>
 #include "ScanFilter.hpp"
-#include <optional>
-#include <string>
 #include <NitroModules/ArrayBuffer.hpp>
 #include "BLEState.hpp"
 #include "OperationResult.hpp"
@@ -62,7 +62,8 @@ namespace margelo::nitro::co::zyke::ble {
 
     public:
       // Properties
-      
+      virtual std::optional<std::string> getRestoreStateIdentifier() = 0;
+      virtual void setRestoreStateIdentifier(const std::optional<std::string>& restoreStateIdentifier) = 0;
 
     public:
       // Methods

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-ble-nitro",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "High-performance React Native BLE library built on Nitro Modules",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -23,6 +23,14 @@
       "types": "./lib/manager.d.ts",
       "default": "./src/manager.ts"
     },
+    "./singleton": {
+      "react-native": "./src/singleton.ts",
+      "typescript": "./src/singleton.ts",
+      "import": "./lib/singleton.js",
+      "require": "./lib/commonjs/singleton.js",
+      "types": "./lib/singleton.d.ts",
+      "default": "./src/singleton.ts"
+    },
     "./plugin": {
       "import": "./plugin/build/index.js",
       "require": "./plugin/build/index.js",