simplejsble 0.0.47 → 0.0.48

package/cpp/HybridCharacteristic.cpp

@@ -0,0 +1,50 @@
+#include "HybridCharacteristic.hpp"
+#include "HybridDescriptor.hpp"
+
+namespace margelo::nitro::simplejsble {
+
+bool HybridCharacteristic::initialized() {
+    return _characteristic.initialized();
+}
+
+std::string HybridCharacteristic::uuid() {
+    return _characteristic.uuid();
+}
+
+std::vector<std::shared_ptr<HybridDescriptor>> HybridCharacteristic::descriptors() {
+    std::vector<SimpleBLE::Descriptor> characteristic_descriptors = _characteristic.descriptors();
+    std::vector<std::shared_ptr<HybridDescriptor>> hybrid_descriptors;
+    hybrid_descriptors.reserve(characteristic_descriptors.size());
+    
+    for (auto& descriptor : characteristic_descriptors) {
+        hybrid_descriptors.push_back(std::make_shared<HybridDescriptor>(std::move(descriptor)));
+    }
+    
+    return hybrid_descriptors;
+}
+
+std::vector<std::string> HybridCharacteristic::capabilities() {
+    return _characteristic.capabilities();
+}
+
+bool HybridCharacteristic::can_read() {
+    return _characteristic.can_read();
+}
+
+bool HybridCharacteristic::can_write_request() {
+    return _characteristic.can_write_request();
+}
+
+bool HybridCharacteristic::can_write_command() {
+    return _characteristic.can_write_command();
+}
+
+bool HybridCharacteristic::can_notify() {
+    return _characteristic.can_notify();
+}
+
+bool HybridCharacteristic::can_indicate() {
+    return _characteristic.can_indicate();
+}
+
+}  // namespace margelo::nitro::simplejsble

package/cpp/HybridCharacteristic.hpp

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "HybridCharacteristicSpec.hpp"
+#include <simpleble/SimpleBLE.h>
+#include <memory>
+#include <vector>
+#include <string>
+
+namespace margelo::nitro::simplejsble {
+
+// Forward declaration
+class HybridDescriptor;
+
+class HybridCharacteristic : public HybridCharacteristicSpec {
+  public:
+    HybridCharacteristic() : HybridObject(TAG) {}
+    explicit HybridCharacteristic(SimpleBLE::Characteristic characteristic)
+        : HybridObject(TAG), _characteristic(std::move(characteristic)) {}
+
+    bool initialized() override;
+    std::string uuid() override;
+    std::vector<std::shared_ptr<HybridDescriptor>> descriptors() override;
+    std::vector<std::string> capabilities() override;
+    bool can_read() override;
+    bool can_write_request() override;
+    bool can_write_command() override;
+    bool can_notify() override;
+    bool can_indicate() override;
+
+    SimpleBLE::Characteristic& getInternal() { return _characteristic; }
+    const SimpleBLE::Characteristic& getInternal() const { return _characteristic; }
+
+  private:
+    SimpleBLE::Characteristic _characteristic;
+};
+
+}  // namespace margelo::nitro::simplejsble

package/cpp/HybridDescriptor.cpp

@@ -0,0 +1,13 @@
+#include "HybridDescriptor.hpp"
+
+namespace margelo::nitro::simplejsble {
+
+bool HybridDescriptor::initialized() {
+    return _descriptor.initialized();
+}
+
+std::string HybridDescriptor::uuid() {
+    return _descriptor.uuid();
+}
+
+}  // namespace margelo::nitro::simplejsble

package/cpp/HybridDescriptor.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "HybridDescriptorSpec.hpp"
+#include <simpleble/SimpleBLE.h>
+#include <string>
+
+namespace margelo::nitro::simplejsble {
+
+class HybridDescriptor : public HybridDescriptorSpec {
+  public:
+    HybridDescriptor() : HybridObject(TAG) {}
+    explicit HybridDescriptor(SimpleBLE::Descriptor descriptor)
+        : HybridObject(TAG), _descriptor(std::move(descriptor)) {}
+
+    bool initialized() override;
+    std::string uuid() override;
+
+    SimpleBLE::Descriptor& getInternal() { return _descriptor; }
+    const SimpleBLE::Descriptor& getInternal() const { return _descriptor; }
+
+  private:
+    SimpleBLE::Descriptor _descriptor;
+};
+
+}  // namespace margelo::nitro::simplejsble

package/cpp/HybridPeripheral.cpp

@@ -1,4 +1,5 @@
 #include "HybridPeripheral.hpp"
+#include "HybridService.hpp"
 
 namespace margelo::nitro::simplejsble {
 
@@ -80,4 +81,98 @@ void HybridPeripheral::set_callback_on_disconnected(const std::function<void()>&
     });
 }
 
+std::vector<std::shared_ptr<HybridService>> HybridPeripheral::services() {
+    std::vector<SimpleBLE::Service> peripheral_services = _peripheral.services();
+    std::vector<std::shared_ptr<HybridService>> hybrid_services;
+    hybrid_services.reserve(peripheral_services.size());
+    
+    for (auto& service : peripheral_services) {
+        hybrid_services.push_back(std::make_shared<HybridService>(std::move(service)));
+    }
+    
+    return hybrid_services;
+}
+
+std::unordered_map<double, ArrayBuffer> HybridPeripheral::manufacturer_data() {
+    std::map<uint16_t, SimpleBLE::ByteArray> peripheral_manufacturer_data = _peripheral.manufacturer_data();
+    std::unordered_map<double, ArrayBuffer> manufacturer_array_buffer_map;
+    
+    for (const auto& pair : peripheral_manufacturer_data) {
+        manufacturer_array_buffer_map[static_cast<double>(pair.first)] = toArrayBuffer(pair.second);
+    }
+    
+    return manufacturer_array_buffer_map;
+}
+
+ArrayBuffer HybridPeripheral::read(const std::string& service, const std::string& characteristic) {
+    SimpleBLE::ByteArray peripheral_read_data = _peripheral.read(service, characteristic);
+    return toArrayBuffer(peripheral_read_data);
+}
+
+void HybridPeripheral::write_request(const std::string& service, const std::string& characteristic, ArrayBuffer data) {
+    SimpleBLE::ByteArray bytes = fromArrayBuffer(data);
+    _peripheral.write_request(service, characteristic, bytes);
+}
+
+void HybridPeripheral::write_command(const std::string& service, const std::string& characteristic, ArrayBuffer data) {
+    SimpleBLE::ByteArray bytes = fromArrayBuffer(data);
+    _peripheral.write_command(service, characteristic, bytes);
+}
+
+void HybridPeripheral::notify(const std::string& service, const std::string& characteristic, 
+                              const std::function<void(ArrayBuffer)>& callback) {
+    auto key = std::make_pair(service, characteristic);
+    _notifyCallbacks[key] = callback;
+    
+    _peripheral.notify(service, characteristic, [this, key](SimpleBLE::ByteArray payload) {
+        auto it = _notifyCallbacks.find(key);
+        if (it != _notifyCallbacks.end() && it->second) {
+            it->second(toArrayBuffer(payload));
+        }
+    });
+}
+
+void HybridPeripheral::indicate(const std::string& service, const std::string& characteristic, 
+                                const std::function<void(ArrayBuffer)>& callback) {
+    auto key = std::make_pair(service, characteristic);
+    _notifyCallbacks[key] = callback; //@alejo: verify if its necessary to store our own reference to the callback
+    
+    _peripheral.indicate(service, characteristic, [this, key](SimpleBLE::ByteArray payload) {
+        auto it = _notifyCallbacks.find(key);
+        if (it != _notifyCallbacks.end() && it->second) {
+            it->second(toArrayBuffer(payload));
+        }
+    });
+}
+
+void HybridPeripheral::unsubscribe(const std::string& service, const std::string& characteristic) {
+    auto key = std::make_pair(service, characteristic);
+    _notifyCallbacks.erase(key);
+    _peripheral.unsubscribe(service, characteristic);
+}
+
+ArrayBuffer HybridPeripheral::read_descriptor(const std::string& service, const std::string& characteristic, 
+                                              const std::string& descriptor) {
+    SimpleBLE::ByteArray peripheral_descriptor_data = _peripheral.read(service, characteristic, descriptor);
+    return toArrayBuffer(peripheral_descriptor_data);
+}
+
+void HybridPeripheral::write_descriptor(const std::string& service, const std::string& characteristic, 
+                                       const std::string& descriptor, ArrayBuffer data) {
+    SimpleBLE::ByteArray bytes = fromArrayBuffer(data);
+    _peripheral.write(service, characteristic, descriptor, bytes);
+}
+
+// Helper methods to cast between SimpleBLE::ByteArray and ArrayBuffer (NitroModules native type)
+ArrayBuffer HybridPeripheral::toArrayBuffer(const SimpleBLE::ByteArray& data) {
+    return ArrayBuffer(reinterpret_cast<const uint8_t*>(data.data()), data.size());
+}
+
+SimpleBLE::ByteArray HybridPeripheral::fromArrayBuffer(const ArrayBuffer& buffer) {
+    return SimpleBLE::ByteArray(
+        static_cast<const uint8_t*>(buffer.data()), 
+        buffer.size()
+    );
+}
+
 }  // namespace margelo::nitro::simplejsble

package/cpp/HybridPeripheral.hpp

@@ -5,9 +5,13 @@
 #include <simpleble/SimpleBLE.h>
 #include <functional>
 #include <string>
+#include <map>
+#include <utility>
 
 namespace margelo::nitro::simplejsble {
 
+class HybridService;
+
 class HybridPeripheral : public HybridPeripheralSpec {
   public:
     HybridPeripheral() : HybridObject(TAG) {}
@@ -32,6 +36,23 @@ class HybridPeripheral : public HybridPeripheralSpec {
     void set_callback_on_connected(const std::function<void()>& callback) override;
     void set_callback_on_disconnected(const std::function<void()>& callback) override;
 
+    std::vector<std::shared_ptr<HybridService>> services() override;
+    std::unordered_map<double, ArrayBuffer> manufacturer_data() override;
+
+    ArrayBuffer read(const std::string& service, const std::string& characteristic) override;
+    void write_request(const std::string& service, const std::string& characteristic, ArrayBuffer data) override;
+    void write_command(const std::string& service, const std::string& characteristic, ArrayBuffer data) override;
+    void notify(const std::string& service, const std::string& characteristic, 
+                const std::function<void(ArrayBuffer)>& callback) override;
+    void indicate(const std::string& service, const std::string& characteristic, 
+                  const std::function<void(ArrayBuffer)>& callback) override;
+    void unsubscribe(const std::string& service, const std::string& characteristic) override;
+
+    ArrayBuffer read_descriptor(const std::string& service, const std::string& characteristic, 
+                                const std::string& descriptor) override;
+    void write_descriptor(const std::string& service, const std::string& characteristic, 
+                         const std::string& descriptor, ArrayBuffer data) override;
+
     SimpleBLE::Peripheral& getInternal() { return _peripheral; }
     const SimpleBLE::Peripheral& getInternal() const { return _peripheral; }
 
@@ -40,6 +61,12 @@ class HybridPeripheral : public HybridPeripheralSpec {
 
     std::function<void()> _onConnected;
     std::function<void()> _onDisconnected;
+
+    std::map<std::pair<std::string, std::string>, std::function<void(ArrayBuffer)>> _notifyCallbacks;
+
+    // Helper methods to cast between SimpleBLE::ByteArray and ArrayBuffer (NitroModules native type)
+    static ArrayBuffer toArrayBuffer(const SimpleBLE::ByteArray& data);
+    static SimpleBLE::ByteArray fromArrayBuffer(const ArrayBuffer& buffer);
 };
 
 }  // namespace margelo::nitro::simplejsble

package/cpp/HybridService.cpp

@@ -0,0 +1,31 @@
+#include "HybridService.hpp"
+#include "HybridCharacteristic.hpp"
+
+namespace margelo::nitro::simplejsble {
+
+bool HybridService::initialized() {
+    return _service.initialized();
+}
+
+std::string HybridService::uuid() {
+    return _service.uuid();
+}
+
+ArrayBuffer HybridService::data() {
+    SimpleBLE::ByteArray bytes = _service.data();
+    return ArrayBuffer(reinterpret_cast<const uint8_t*>(bytes.data()), bytes.size());
+}
+
+std::vector<std::shared_ptr<HybridCharacteristic>> HybridService::characteristics() {
+    std::vector<SimpleBLE::Characteristic> service_characteristics = _service.characteristics();
+    std::vector<std::shared_ptr<HybridCharacteristic>> hybrid_characteristics;
+    hybrid_characteristics.reserve(service_characteristics.size());
+    
+    for (auto& characteristic : service_characteristics) {
+        hybrid_characteristics.push_back(std::make_shared<HybridCharacteristic>(std::move(characteristic)));
+    }
+    
+    return hybrid_characteristics;
+}
+
+}  // namespace margelo::nitro::simplejsble

package/cpp/HybridService.hpp

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "HybridServiceSpec.hpp"
+#include <simpleble/SimpleBLE.h>
+#include <memory>
+#include <vector>
+
+namespace margelo::nitro::simplejsble {
+
+class HybridCharacteristic;
+
+class HybridService : public HybridServiceSpec {
+  public:
+    HybridService() : HybridObject(TAG) {}
+    explicit HybridService(SimpleBLE::Service service)
+        : HybridObject(TAG), _service(std::move(service)) {}
+
+    bool initialized() override;
+    std::string uuid() override;
+    ArrayBuffer data() override;
+    std::vector<std::shared_ptr<HybridCharacteristic>> characteristics() override;
+
+    SimpleBLE::Service& getInternal() { return _service; }
+    const SimpleBLE::Service& getInternal() const { return _service; }
+
+  private:
+    SimpleBLE::Service _service;
+};
+
+}  // namespace margelo::nitro::simplejsble

package/lib/index.d.ts

@@ -1,5 +1,9 @@
 import type { Adapter } from "./specs/Adapter.nitro";
 import type { Peripheral, BluetoothAddressType } from "./specs/Peripheral.nitro";
-export type { Adapter, Peripheral, BluetoothAddressType };
+import type { Service } from "./specs/Service.nitro";
+import type { Characteristic } from "./specs/Characteristic.nitro";
+import type { Descriptor } from "./specs/Descriptor.nitro";
+export type { Adapter, Peripheral, BluetoothAddressType, Service, Characteristic, Descriptor };
+export { fromHex, toHex, toString, fromString } from "./utils/bytearray";
 export declare const HybridAdapter: Adapter;
 //# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,KAAK,EAAE,UAAU,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAEjF,YAAY,EAAE,OAAO,EAAE,UAAU,EAAE,oBAAoB,EAAE,CAAC;AAE1D,eAAO,MAAM,aAAa,SAAsD,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,KAAK,EAAE,UAAU,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AACjF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAE3D,YAAY,EAAE,OAAO,EAAE,UAAU,EAAE,oBAAoB,EAAE,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,CAAC;AAE/F,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEzE,eAAO,MAAM,aAAa,SAAsD,CAAC"}

package/lib/index.js

@@ -1,2 +1,3 @@
 import { NitroModules } from "react-native-nitro-modules";
+export { fromHex, toHex, toString, fromString } from "./utils/bytearray";
 export const HybridAdapter = NitroModules.createHybridObject("Adapter");

package/lib/specs/Characteristic.nitro.d.ts

@@ -0,0 +1,45 @@
+import { type HybridObject } from 'react-native-nitro-modules';
+import { type Descriptor } from './Descriptor.nitro';
+export interface Characteristic extends HybridObject<{
+    ios: 'c++';
+    android: 'c++';
+}> {
+    /**
+     * Check if the characteristic is initialized (has a valid internal handle).
+     */
+    initialized(): boolean;
+    /**
+     * Get the characteristic UUID.
+     */
+    uuid(): string;
+    /**
+     * Get all descriptors belonging to this characteristic.
+     */
+    descriptors(): Descriptor[];
+    /**
+     * Get a list of capability strings for this characteristic.
+     * Example: ["read", "write", "notify"]
+     */
+    capabilities(): string[];
+    /**
+     * Check if the characteristic supports read operations.
+     */
+    can_read(): boolean;
+    /**
+     * Check if the characteristic supports write-request operations.
+     */
+    can_write_request(): boolean;
+    /**
+     * Check if the characteristic supports write-command operations.
+     */
+    can_write_command(): boolean;
+    /**
+     * Check if the characteristic supports notify operations.
+     */
+    can_notify(): boolean;
+    /**
+     * Check if the characteristic supports indicate operations.
+     */
+    can_indicate(): boolean;
+}
+//# sourceMappingURL=Characteristic.nitro.d.ts.map

package/lib/specs/Characteristic.nitro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Characteristic.nitro.d.ts","sourceRoot":"","sources":["../../src/specs/Characteristic.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAC9D,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAEpD,MAAM,WAAW,cACf,SAAQ,YAAY,CAAC;IACnB,GAAG,EAAE,KAAK,CAAA;IACV,OAAO,EAAE,KAAK,CAAA;CACf,CAAC;IACF;;OAEG;IACH,WAAW,IAAI,OAAO,CAAA;IAEtB;;OAEG;IACH,IAAI,IAAI,MAAM,CAAA;IAEd;;OAEG;IACH,WAAW,IAAI,UAAU,EAAE,CAAA;IAE3B;;;OAGG;IACH,YAAY,IAAI,MAAM,EAAE,CAAA;IAExB;;OAEG;IACH,QAAQ,IAAI,OAAO,CAAA;IAEnB;;OAEG;IACH,iBAAiB,IAAI,OAAO,CAAA;IAE5B;;OAEG;IACH,iBAAiB,IAAI,OAAO,CAAA;IAE5B;;OAEG;IACH,UAAU,IAAI,OAAO,CAAA;IAErB;;OAEG;IACH,YAAY,IAAI,OAAO,CAAA;CACxB"}

package/lib/specs/Characteristic.nitro.js

@@ -0,0 +1,2 @@
+import {} from 'react-native-nitro-modules';
+import {} from './Descriptor.nitro';

package/lib/specs/Descriptor.nitro.d.ts

@@ -0,0 +1,15 @@
+import { type HybridObject } from 'react-native-nitro-modules';
+export interface Descriptor extends HybridObject<{
+    ios: 'c++';
+    android: 'c++';
+}> {
+    /**
+     * Check if the descriptor is initialized (has a valid internal handle).
+     */
+    initialized(): boolean;
+    /**
+     * Get the descriptor UUID.
+     */
+    uuid(): string;
+}
+//# sourceMappingURL=Descriptor.nitro.d.ts.map

package/lib/specs/Descriptor.nitro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Descriptor.nitro.d.ts","sourceRoot":"","sources":["../../src/specs/Descriptor.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAE9D,MAAM,WAAW,UACf,SAAQ,YAAY,CAAC;IACnB,GAAG,EAAE,KAAK,CAAA;IACV,OAAO,EAAE,KAAK,CAAA;CACf,CAAC;IACF;;OAEG;IACH,WAAW,IAAI,OAAO,CAAA;IAEtB;;OAEG;IACH,IAAI,IAAI,MAAM,CAAA;CACf"}

package/lib/specs/Descriptor.nitro.js

@@ -0,0 +1 @@
+import {} from 'react-native-nitro-modules';

package/lib/specs/Peripheral.nitro.d.ts

@@ -1,4 +1,5 @@
 import { type HybridObject } from 'react-native-nitro-modules';
+import { type Service } from './Service.nitro';
 /**
  * Bluetooth address type enumeration.
  * Maps to SimpleBLE::BluetoothAddressType
@@ -74,5 +75,80 @@ export interface Peripheral extends HybridObject<{
      * Set callback to be invoked when the peripheral disconnects.
      */
     set_callback_on_disconnected(callback: () => void): void;
+    /**
+     * Get all services available on the peripheral.
+     * Requires an active connection.
+     */
+    services(): Service[];
+    /**
+     * Get manufacturer data from the peripheral's advertisement.
+     * Returns a map of manufacturer ID (number) to data (ArrayBuffer).
+     */
+    manufacturer_data(): Record<number, ArrayBuffer>;
+    /**
+     * Read a characteristic value.
+     * Requires an active connection.
+     * @param service Service UUID
+     * @param characteristic Characteristic UUID
+     * @returns ArrayBuffer containing the characteristic data
+     */
+    read(service: string, characteristic: string): ArrayBuffer;
+    /**
+     * Write to a characteristic using write-request (with response).
+     * Requires an active connection.
+     * @param service Service UUID
+     * @param characteristic Characteristic UUID
+     * @param data Data to write as ArrayBuffer
+     */
+    write_request(service: string, characteristic: string, data: ArrayBuffer): void;
+    /**
+     * Write to a characteristic using write-command (without response).
+     * Requires an active connection.
+     * @param service Service UUID
+     * @param characteristic Characteristic UUID
+     * @param data Data to write as ArrayBuffer
+     */
+    write_command(service: string, characteristic: string, data: ArrayBuffer): void;
+    /**
+     * Subscribe to notifications from a characteristic.
+     * Requires an active connection.
+     * @param service Service UUID
+     * @param characteristic Characteristic UUID
+     * @param callback Callback to receive notification data as ArrayBuffer
+     */
+    notify(service: string, characteristic: string, callback: (data: ArrayBuffer) => void): void;
+    /**
+     * Subscribe to indications from a characteristic.
+     * Requires an active connection.
+     * @param service Service UUID
+     * @param characteristic Characteristic UUID
+     * @param callback Callback to receive indication data as ArrayBuffer
+     */
+    indicate(service: string, characteristic: string, callback: (data: ArrayBuffer) => void): void;
+    /**
+     * Unsubscribe from notifications or indications on a characteristic.
+     * Requires an active connection.
+     * @param service Service UUID
+     * @param characteristic Characteristic UUID
+     */
+    unsubscribe(service: string, characteristic: string): void;
+    /**
+     * Read a descriptor value.
+     * Requires an active connection.
+     * @param service Service UUID
+     * @param characteristic Characteristic UUID
+     * @param descriptor Descriptor UUID
+     * @returns ArrayBuffer containing the descriptor data
+     */
+    read_descriptor(service: string, characteristic: string, descriptor: string): ArrayBuffer;
+    /**
+     * Write to a descriptor.
+     * Requires an active connection.
+     * @param service Service UUID
+     * @param characteristic Characteristic UUID
+     * @param descriptor Descriptor UUID
+     * @param data Data to write as ArrayBuffer
+     */
+    write_descriptor(service: string, characteristic: string, descriptor: string, data: ArrayBuffer): void;
 }
 //# sourceMappingURL=Peripheral.nitro.d.ts.map

package/lib/specs/Peripheral.nitro.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Peripheral.nitro.d.ts","sourceRoot":"","sources":["../../src/specs/Peripheral.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAE9D;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAAG,QAAQ,GAAG,QAAQ,GAAG,aAAa,CAAA;AAEtE;;;;GAIG;AACH,MAAM,WAAW,UACf,SAAQ,YAAY,CAAC;IACnB,GAAG,EAAE,KAAK,CAAA;IACV,OAAO,EAAE,KAAK,CAAA;CACf,CAAC;IACF;;OAEG;IACH,WAAW,IAAI,OAAO,CAAA;IAEtB;;OAEG;IACH,UAAU,IAAI,MAAM,CAAA;IAEpB;;OAEG;IACH,OAAO,IAAI,MAAM,CAAA;IAEjB;;OAEG;IACH,YAAY,IAAI,oBAAoB,CAAA;IAEpC;;OAEG;IACH,IAAI,IAAI,MAAM,CAAA;IAEd;;;OAGG;IACH,QAAQ,IAAI,MAAM,CAAA;IAElB;;OAEG;IACH,GAAG,IAAI,MAAM,CAAA;IAEb;;OAEG;IACH,OAAO,IAAI,IAAI,CAAA;IAEf;;OAEG;IACH,UAAU,IAAI,IAAI,CAAA;IAElB;;OAEG;IACH,YAAY,IAAI,OAAO,CAAA;IAEvB;;OAEG;IACH,cAAc,IAAI,OAAO,CAAA;IAEzB;;OAEG;IACH,SAAS,IAAI,OAAO,CAAA;IAEpB;;OAEG;IACH,MAAM,IAAI,IAAI,CAAA;IAEd;;OAEG;IACH,yBAAyB,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI,CAAA;IAErD;;OAEG;IACH,4BAA4B,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI,CAAA;CACzD"}
+{"version":3,"file":"Peripheral.nitro.d.ts","sourceRoot":"","sources":["../../src/specs/Peripheral.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAC9D,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,iBAAiB,CAAA;AAE9C;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAAG,QAAQ,GAAG,QAAQ,GAAG,aAAa,CAAA;AAEtE;;;;GAIG;AACH,MAAM,WAAW,UACf,SAAQ,YAAY,CAAC;IACnB,GAAG,EAAE,KAAK,CAAA;IACV,OAAO,EAAE,KAAK,CAAA;CACf,CAAC;IACF;;OAEG;IACH,WAAW,IAAI,OAAO,CAAA;IAEtB;;OAEG;IACH,UAAU,IAAI,MAAM,CAAA;IAEpB;;OAEG;IACH,OAAO,IAAI,MAAM,CAAA;IAEjB;;OAEG;IACH,YAAY,IAAI,oBAAoB,CAAA;IAEpC;;OAEG;IACH,IAAI,IAAI,MAAM,CAAA;IAEd;;;OAGG;IACH,QAAQ,IAAI,MAAM,CAAA;IAElB;;OAEG;IACH,GAAG,IAAI,MAAM,CAAA;IAEb;;OAEG;IACH,OAAO,IAAI,IAAI,CAAA;IAEf;;OAEG;IACH,UAAU,IAAI,IAAI,CAAA;IAElB;;OAEG;IACH,YAAY,IAAI,OAAO,CAAA;IAEvB;;OAEG;IACH,cAAc,IAAI,OAAO,CAAA;IAEzB;;OAEG;IACH,SAAS,IAAI,OAAO,CAAA;IAEpB;;OAEG;IACH,MAAM,IAAI,IAAI,CAAA;IAEd;;OAEG;IACH,yBAAyB,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI,CAAA;IAErD;;OAEG;IACH,4BAA4B,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI,CAAA;IAExD;;;OAGG;IACH,QAAQ,IAAI,OAAO,EAAE,CAAA;IAErB;;;OAGG;IACH,iBAAiB,IAAI,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAA;IAEhD;;;;;;OAMG;IACH,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,WAAW,CAAA;IAE1D;;;;;;OAMG;IACH,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CAAA;IAE/E;;;;;;OAMG;IACH,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CAAA;IAE/E;;;;;;OAMG;IACH,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,IAAI,GAAG,IAAI,CAAA;IAE5F;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,IAAI,GAAG,IAAI,CAAA;IAE9F;;;;;OAKG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;IAE1D;;;;;;;OAOG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,WAAW,CAAA;IAEzF;;;;;;;OAOG;IACH,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CAAA;CACvG"}

package/lib/specs/Peripheral.nitro.js

@@ -1 +1,2 @@
 import {} from 'react-native-nitro-modules';
+import {} from './Service.nitro';

package/lib/specs/Service.nitro.d.ts

@@ -0,0 +1,25 @@
+import { type HybridObject } from 'react-native-nitro-modules';
+import { type Characteristic } from './Characteristic.nitro';
+export interface Service extends HybridObject<{
+    ios: 'c++';
+    android: 'c++';
+}> {
+    /**
+     * Check if the service is initialized (has a valid internal handle).
+     */
+    initialized(): boolean;
+    /**
+     * Get the service UUID.
+     */
+    uuid(): string;
+    /**
+     * Get the service data (if advertised).
+     * Returns raw ArrayBuffer containing the service data bytes.
+     */
+    data(): ArrayBuffer;
+    /**
+     * Get all characteristics belonging to this service.
+     */
+    characteristics(): Characteristic[];
+}
+//# sourceMappingURL=Service.nitro.d.ts.map

package/lib/specs/Service.nitro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Service.nitro.d.ts","sourceRoot":"","sources":["../../src/specs/Service.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAC9D,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAE5D,MAAM,WAAW,OACf,SAAQ,YAAY,CAAC;IACnB,GAAG,EAAE,KAAK,CAAA;IACV,OAAO,EAAE,KAAK,CAAA;CACf,CAAC;IACF;;OAEG;IACH,WAAW,IAAI,OAAO,CAAA;IAEtB;;OAEG;IACH,IAAI,IAAI,MAAM,CAAA;IAEd;;;OAGG;IACH,IAAI,IAAI,WAAW,CAAA;IAEnB;;OAEG;IACH,eAAe,IAAI,cAAc,EAAE,CAAA;CACpC"}

package/lib/specs/Service.nitro.js

@@ -0,0 +1,2 @@
+import {} from 'react-native-nitro-modules';
+import {} from './Characteristic.nitro';

package/lib/utils/bytearray.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Convert a hex string to a Uint8Array.
+ * Spaces and common separators (-, :) are automatically removed.
+ *
+ * @param hex Hex string (e.g., "48656c6c6f" or "48 65 6c 6c 6f")
+ * @returns Uint8Array containing the decoded bytes
+ *
+ * @example
+ * const data = fromHex("48656c6c6f");
+ * const data2 = fromHex("48 65 6c 6c 6f");
+ * const data3 = fromHex("48:65:6c:6c:6f");
+ */
+export declare function fromHex(hex: string): Uint8Array;
+/**
+ * Convert a Uint8Array to a hex string.
+ *
+ * @param data Uint8Array to convert
+ * @param withSpaces If true, separates bytes with spaces (default: false)
+ * @returns Hex string representation
+ *
+ * @example
+ * const data = new Uint8Array([72, 101, 108, 108, 111]);
+ * toHex(data);           // "48656c6c6f"
+ * toHex(data, true);     // "48 65 6c 6c 6f"
+ */
+export declare function toHex(data: Uint8Array, withSpaces?: boolean): string;
+/**
+ * Convert a Uint8Array to a UTF-8 string.
+ *
+ * @param data Uint8Array containing UTF-8 encoded text
+ * @returns Decoded string
+ *
+ * @example
+ * const data = new Uint8Array([72, 101, 108, 108, 111]);
+ * toString(data); // "Hello"
+ */
+export declare function toString(data: Uint8Array): string;
+/**
+ * Convert a UTF-8 string to a Uint8Array.
+ *
+ * @param str String to encode
+ * @returns Uint8Array containing UTF-8 encoded bytes
+ *
+ * @example
+ * const data = fromString("Hello");
+ * // Uint8Array([72, 101, 108, 108, 111])
+ */
+export declare function fromString(str: string): Uint8Array;
+//# sourceMappingURL=bytearray.d.ts.map

package/lib/utils/bytearray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytearray.d.ts","sourceRoot":"","sources":["../../src/utils/bytearray.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAiB/C;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,UAAU,EAAE,UAAU,GAAE,OAAe,GAAG,MAAM,CAK3E;AAED;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAGjD;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAGlD"}