react-native-ble-nitro 1.0.0-beta.9 → 1.1.0

package/lib/compatibility/constants.js

@@ -1,50 +0,0 @@
-/**
- * React-native-ble-plx compatibility constants
- *
- * Re-exports all constants and types to maintain API compatibility
- */
-// Re-export original string-based constants for backward compatibility
-export const State = {
-    Unknown: 'Unknown',
-    Resetting: 'Resetting',
-    Unsupported: 'Unsupported',
-    Unauthorized: 'Unauthorized',
-    PoweredOff: 'PoweredOff',
-    PoweredOn: 'PoweredOn',
-};
-export const LogLevel = {
-    None: 'None',
-    Verbose: 'Verbose',
-    Debug: 'Debug',
-    Info: 'Info',
-    Warning: 'Warning',
-    Error: 'Error',
-};
-// Subscription type constants
-export const CharacteristicSubscriptionType = {
-    Notification: 'notification',
-    Indication: 'indication',
-};
-// Connection options constants
-export const RefreshGattMoment = {
-    OnConnected: 'OnConnected',
-};
-// Scan mode constants (these remain numeric as in original)
-export const ScanMode = {
-    Opportunistic: -1,
-    LowPower: 0,
-    Balanced: 1,
-    LowLatency: 2,
-};
-export const ScanCallbackType = {
-    AllMatches: 1,
-    FirstMatch: 2,
-    MatchLost: 4,
-};
-export const ConnectionPriority = {
-    Balanced: 0,
-    High: 1,
-    LowPower: 2,
-};
-// Re-export all BLE error codes
-export { BleErrorCode, BleATTErrorCode, BleIOSErrorCode, BleAndroidErrorCode } from '../specs/types';

package/lib/compatibility/deviceWrapper.d.ts

@@ -1,99 +0,0 @@
-/**
- * Device wrapper for compatibility
- *
- * Wraps Nitro Device objects to provide the original react-native-ble-plx API
- */
-import type { Device as NitroDevice } from '../specs/Device.nitro';
-import type { UUID, Base64, DeviceId, TransactionId, ConnectionPriority, ConnectionOptions, NativeService, NativeCharacteristic, NativeDescriptor, Subscription } from '../specs/types';
-/**
- * Device wrapper that provides react-native-ble-plx compatibility
- * Maps Nitro device properties to the expected API surface
- */
-export declare class DeviceWrapper {
-    private nitroDevice;
-    constructor(nitroDevice: NitroDevice | any);
-    get id(): DeviceId;
-    get name(): string | null;
-    get rssi(): number | null;
-    get mtu(): number;
-    get manufacturerData(): Base64 | null;
-    get rawScanRecord(): Base64;
-    get serviceData(): {
-        [uuid: string]: Base64;
-    } | null;
-    get serviceUUIDs(): UUID[] | null;
-    get localName(): string | null;
-    get txPowerLevel(): number | null;
-    get solicitedServiceUUIDs(): UUID[] | null;
-    get isConnectable(): boolean | null;
-    get overflowServiceUUIDs(): UUID[] | null;
-    requestConnectionPriority(connectionPriority: ConnectionPriority, transactionId?: TransactionId): Promise<DeviceWrapper>;
-    readRSSI(transactionId?: TransactionId): Promise<DeviceWrapper>;
-    requestMTU(mtu: number, transactionId?: TransactionId): Promise<DeviceWrapper>;
-    connect(options?: Partial<ConnectionOptions>): Promise<DeviceWrapper>;
-    cancelConnection(): Promise<DeviceWrapper>;
-    isConnected(): Promise<boolean>;
-    onDisconnected(listener: (error: any | null, device: DeviceWrapper) => void): Subscription;
-    discoverAllServicesAndCharacteristics(transactionId?: TransactionId): Promise<DeviceWrapper>;
-    services(): Promise<ServiceWrapper[]>;
-    characteristicsForService(serviceUUID: UUID): Promise<CharacteristicWrapper[]>;
-    readCharacteristicForService(serviceUUID: UUID, characteristicUUID: UUID, transactionId?: TransactionId): Promise<CharacteristicWrapper>;
-    writeCharacteristicWithResponseForService(serviceUUID: UUID, characteristicUUID: UUID, valueBase64: Base64, transactionId?: TransactionId): Promise<CharacteristicWrapper>;
-    writeCharacteristicWithoutResponseForService(serviceUUID: UUID, characteristicUUID: UUID, valueBase64: Base64, transactionId?: TransactionId): Promise<CharacteristicWrapper>;
-    monitorCharacteristicForService(serviceUUID: UUID, characteristicUUID: UUID, listener: (error: any | null, characteristic: CharacteristicWrapper | null) => void, transactionId?: TransactionId, subscriptionType?: 'notification' | 'indication'): Subscription;
-    descriptorsForService(serviceUUID: UUID, characteristicUUID: UUID): Promise<DescriptorWrapper[]>;
-    readDescriptorForService(serviceUUID: UUID, characteristicUUID: UUID, descriptorUUID: UUID, transactionId?: TransactionId): Promise<DescriptorWrapper>;
-    writeDescriptorForService(serviceUUID: UUID, characteristicUUID: UUID, descriptorUUID: UUID, valueBase64: Base64, transactionId?: TransactionId): Promise<DescriptorWrapper>;
-}
-/**
- * Service wrapper for compatibility
- */
-export declare class ServiceWrapper {
-    private nativeService;
-    private nitroDevice;
-    constructor(nativeService: NativeService, nitroDevice: NitroDevice);
-    get id(): number;
-    get uuid(): UUID;
-    get deviceID(): DeviceId;
-    get isPrimary(): boolean;
-    characteristics(): Promise<CharacteristicWrapper[]>;
-    readCharacteristic(characteristicUUID: UUID, transactionId?: TransactionId): Promise<CharacteristicWrapper>;
-}
-/**
- * Characteristic wrapper for compatibility
- */
-export declare class CharacteristicWrapper {
-    private nativeCharacteristic;
-    private nitroDevice;
-    constructor(nativeCharacteristic: NativeCharacteristic, nitroDevice: NitroDevice);
-    get id(): number;
-    get uuid(): UUID;
-    get serviceID(): number;
-    get serviceUUID(): UUID;
-    get deviceID(): DeviceId;
-    get isReadable(): boolean;
-    get isWritableWithResponse(): boolean;
-    get isWritableWithoutResponse(): boolean;
-    get isNotifiable(): boolean;
-    get isNotifying(): boolean;
-    get isIndicatable(): boolean;
-    get value(): Base64 | null;
-    read(transactionId?: TransactionId): Promise<CharacteristicWrapper>;
-}
-/**
- * Descriptor wrapper for compatibility
- */
-export declare class DescriptorWrapper {
-    private nativeDescriptor;
-    private nitroDevice;
-    constructor(nativeDescriptor: NativeDescriptor, nitroDevice: NitroDevice);
-    get id(): number;
-    get uuid(): UUID;
-    get characteristicID(): number;
-    get characteristicUUID(): UUID;
-    get serviceID(): number;
-    get serviceUUID(): UUID;
-    get deviceID(): DeviceId;
-    get value(): Base64 | null;
-    read(transactionId?: TransactionId): Promise<DescriptorWrapper>;
-}

package/lib/compatibility/deviceWrapper.js

@@ -1,259 +0,0 @@
-/**
- * Device wrapper for compatibility
- *
- * Wraps Nitro Device objects to provide the original react-native-ble-plx API
- */
-import { serviceDataArrayToMap } from './serviceData';
-import { normalizeCharacteristicSubscriptionType } from './enums';
-/**
- * Device wrapper that provides react-native-ble-plx compatibility
- * Maps Nitro device properties to the expected API surface
- */
-export class DeviceWrapper {
-    constructor(nitroDevice) {
-        this.nitroDevice = nitroDevice;
-    }
-    // Device identification
-    get id() {
-        return this.nitroDevice.id;
-    }
-    // Map deviceName back to name for compatibility
-    get name() {
-        return this.nitroDevice.deviceName || null;
-    }
-    get rssi() {
-        return this.nitroDevice.rssi || null;
-    }
-    get mtu() {
-        return this.nitroDevice.mtu;
-    }
-    // Advertisement data
-    get manufacturerData() {
-        return this.nitroDevice.manufacturerData || null;
-    }
-    get rawScanRecord() {
-        return this.nitroDevice.rawScanRecord;
-    }
-    // Convert ServiceDataEntry[] back to { [uuid: string]: Base64 }
-    get serviceData() {
-        return serviceDataArrayToMap(this.nitroDevice.serviceData || null);
-    }
-    get serviceUUIDs() {
-        return this.nitroDevice.serviceUUIDs || null;
-    }
-    get localName() {
-        return this.nitroDevice.localName || null;
-    }
-    get txPowerLevel() {
-        return this.nitroDevice.txPowerLevel || null;
-    }
-    get solicitedServiceUUIDs() {
-        return this.nitroDevice.solicitedServiceUUIDs || null;
-    }
-    get isConnectable() {
-        return this.nitroDevice.isConnectable || null;
-    }
-    get overflowServiceUUIDs() {
-        return this.nitroDevice.overflowServiceUUIDs || null;
-    }
-    // Connection management methods
-    async requestConnectionPriority(connectionPriority, transactionId) {
-        const result = await this.nitroDevice.requestConnectionPriority(connectionPriority, transactionId);
-        return new DeviceWrapper(result);
-    }
-    async readRSSI(transactionId) {
-        const result = await this.nitroDevice.readRSSI(transactionId);
-        return new DeviceWrapper(result);
-    }
-    async requestMTU(mtu, transactionId) {
-        const result = await this.nitroDevice.requestMTU(mtu, transactionId);
-        return new DeviceWrapper(result);
-    }
-    async connect(options) {
-        // Provide defaults for required fields in Nitro interface
-        const connectionOptions = {
-            autoConnect: options?.autoConnect ?? false,
-            requestMTU: options?.requestMTU ?? 23,
-            timeout: options?.timeout ?? 0,
-        };
-        const result = await this.nitroDevice.connect(connectionOptions);
-        return new DeviceWrapper(result);
-    }
-    async cancelConnection() {
-        const result = await this.nitroDevice.cancelConnection();
-        return new DeviceWrapper(result);
-    }
-    async isConnected() {
-        return await this.nitroDevice.isConnected();
-    }
-    onDisconnected(listener) {
-        return this.nitroDevice.onDisconnected((error, device) => {
-            listener(error, new DeviceWrapper(device));
-        });
-    }
-    // Service discovery
-    async discoverAllServicesAndCharacteristics(transactionId) {
-        const result = await this.nitroDevice.discoverAllServicesAndCharacteristics(transactionId);
-        return new DeviceWrapper(result);
-    }
-    async services() {
-        const services = await this.nitroDevice.services();
-        return services.map((service) => new ServiceWrapper(service, this.nitroDevice));
-    }
-    // Characteristic operations
-    async characteristicsForService(serviceUUID) {
-        const characteristics = await this.nitroDevice.characteristicsForService(serviceUUID);
-        return characteristics.map((char) => new CharacteristicWrapper(char, this.nitroDevice));
-    }
-    async readCharacteristicForService(serviceUUID, characteristicUUID, transactionId) {
-        const result = await this.nitroDevice.readCharacteristicForService(serviceUUID, characteristicUUID, transactionId);
-        return new CharacteristicWrapper(result, this.nitroDevice);
-    }
-    async writeCharacteristicWithResponseForService(serviceUUID, characteristicUUID, valueBase64, transactionId) {
-        const result = await this.nitroDevice.writeCharacteristicWithResponseForService(serviceUUID, characteristicUUID, valueBase64, transactionId);
-        return new CharacteristicWrapper(result, this.nitroDevice);
-    }
-    async writeCharacteristicWithoutResponseForService(serviceUUID, characteristicUUID, valueBase64, transactionId) {
-        const result = await this.nitroDevice.writeCharacteristicWithoutResponseForService(serviceUUID, characteristicUUID, valueBase64, transactionId);
-        return new CharacteristicWrapper(result, this.nitroDevice);
-    }
-    monitorCharacteristicForService(serviceUUID, characteristicUUID, listener, transactionId, subscriptionType) {
-        const nitroSubscriptionType = subscriptionType
-            ? normalizeCharacteristicSubscriptionType(subscriptionType)
-            : undefined;
-        return this.nitroDevice.monitorCharacteristicForService(serviceUUID, characteristicUUID, (error, characteristic) => {
-            listener(error, characteristic ? new CharacteristicWrapper(characteristic, this.nitroDevice) : null);
-        }, transactionId, nitroSubscriptionType);
-    }
-    // Descriptor operations
-    async descriptorsForService(serviceUUID, characteristicUUID) {
-        const descriptors = await this.nitroDevice.descriptorsForService(serviceUUID, characteristicUUID);
-        return descriptors.map((desc) => new DescriptorWrapper(desc, this.nitroDevice));
-    }
-    async readDescriptorForService(serviceUUID, characteristicUUID, descriptorUUID, transactionId) {
-        const result = await this.nitroDevice.readDescriptorForService(serviceUUID, characteristicUUID, descriptorUUID, transactionId);
-        return new DescriptorWrapper(result, this.nitroDevice);
-    }
-    async writeDescriptorForService(serviceUUID, characteristicUUID, descriptorUUID, valueBase64, transactionId) {
-        const result = await this.nitroDevice.writeDescriptorForService(serviceUUID, characteristicUUID, descriptorUUID, valueBase64, transactionId);
-        return new DescriptorWrapper(result, this.nitroDevice);
-    }
-}
-/**
- * Service wrapper for compatibility
- */
-export class ServiceWrapper {
-    constructor(nativeService, nitroDevice) {
-        this.nativeService = nativeService;
-        this.nitroDevice = nitroDevice;
-    }
-    get id() {
-        return this.nativeService.id;
-    }
-    get uuid() {
-        return this.nativeService.uuid;
-    }
-    get deviceID() {
-        return this.nativeService.deviceID;
-    }
-    get isPrimary() {
-        return this.nativeService.isPrimary;
-    }
-    // Delegate to device methods
-    async characteristics() {
-        const device = new DeviceWrapper(this.nitroDevice);
-        return await device.characteristicsForService(this.uuid);
-    }
-    async readCharacteristic(characteristicUUID, transactionId) {
-        const device = new DeviceWrapper(this.nitroDevice);
-        return await device.readCharacteristicForService(this.uuid, characteristicUUID, transactionId);
-    }
-}
-/**
- * Characteristic wrapper for compatibility
- */
-export class CharacteristicWrapper {
-    constructor(nativeCharacteristic, nitroDevice) {
-        this.nativeCharacteristic = nativeCharacteristic;
-        this.nitroDevice = nitroDevice;
-    }
-    get id() {
-        return this.nativeCharacteristic.id;
-    }
-    get uuid() {
-        return this.nativeCharacteristic.uuid;
-    }
-    get serviceID() {
-        return this.nativeCharacteristic.serviceID;
-    }
-    get serviceUUID() {
-        return this.nativeCharacteristic.serviceUUID;
-    }
-    get deviceID() {
-        return this.nativeCharacteristic.deviceID;
-    }
-    get isReadable() {
-        return this.nativeCharacteristic.isReadable;
-    }
-    get isWritableWithResponse() {
-        return this.nativeCharacteristic.isWritableWithResponse;
-    }
-    get isWritableWithoutResponse() {
-        return this.nativeCharacteristic.isWritableWithoutResponse;
-    }
-    get isNotifiable() {
-        return this.nativeCharacteristic.isNotifiable;
-    }
-    get isNotifying() {
-        return this.nativeCharacteristic.isNotifying;
-    }
-    get isIndicatable() {
-        return this.nativeCharacteristic.isIndicatable;
-    }
-    get value() {
-        return this.nativeCharacteristic.value;
-    }
-    // Delegate to device methods
-    async read(transactionId) {
-        const device = new DeviceWrapper(this.nitroDevice);
-        return await device.readCharacteristicForService(this.serviceUUID, this.uuid, transactionId);
-    }
-}
-/**
- * Descriptor wrapper for compatibility
- */
-export class DescriptorWrapper {
-    constructor(nativeDescriptor, nitroDevice) {
-        this.nativeDescriptor = nativeDescriptor;
-        this.nitroDevice = nitroDevice;
-    }
-    get id() {
-        return this.nativeDescriptor.id;
-    }
-    get uuid() {
-        return this.nativeDescriptor.uuid;
-    }
-    get characteristicID() {
-        return this.nativeDescriptor.characteristicID;
-    }
-    get characteristicUUID() {
-        return this.nativeDescriptor.characteristicUUID;
-    }
-    get serviceID() {
-        return this.nativeDescriptor.serviceID;
-    }
-    get serviceUUID() {
-        return this.nativeDescriptor.serviceUUID;
-    }
-    get deviceID() {
-        return this.nativeDescriptor.deviceID;
-    }
-    get value() {
-        return this.nativeDescriptor.value;
-    }
-    // Delegate to device methods
-    async read(transactionId) {
-        const device = new DeviceWrapper(this.nitroDevice);
-        return await device.readDescriptorForService(this.serviceUUID, this.characteristicUUID, this.uuid, transactionId);
-    }
-}

package/lib/compatibility/enums.d.ts

@@ -1,38 +0,0 @@
-/**
- * React Native BLE Plx Compatible Enums and Types
- *
- * These match the exact types from react-native-ble-plx for drop-in compatibility.
- * This module provides conversion between Nitro's numeric enums and react-native-ble-plx types.
- */
-import { State as NitroState, LogLevel as NitroLogLevel, CharacteristicSubscriptionType as NitroCharacteristicSubscriptionType, RefreshGattMoment as NitroRefreshGattMoment } from '../specs/types';
-export declare enum State {
-    Unknown = "Unknown",
-    Resetting = "Resetting",
-    Unsupported = "Unsupported",
-    Unauthorized = "Unauthorized",
-    PoweredOff = "PoweredOff",
-    PoweredOn = "PoweredOn"
-}
-export declare enum LogLevel {
-    None = "None",
-    Verbose = "Verbose",
-    Debug = "Debug",
-    Info = "Info",
-    Warning = "Warning",
-    Error = "Error"
-}
-export type CharacteristicSubscriptionType = 'notification' | 'indication';
-export type RefreshGattMoment = 'OnConnected';
-export declare function stateToString(state: NitroState): State;
-export declare function logLevelToString(logLevel: NitroLogLevel): LogLevel;
-export declare function characteristicSubscriptionTypeToString(type: NitroCharacteristicSubscriptionType): CharacteristicSubscriptionType;
-export declare function refreshGattMomentToString(_moment: NitroRefreshGattMoment): RefreshGattMoment;
-export declare function stringToState(stateString: State | string): NitroState;
-export declare function stringToLogLevel(logLevelString: LogLevel | string): NitroLogLevel;
-export declare function stringToCharacteristicSubscriptionType(typeString: CharacteristicSubscriptionType | string): NitroCharacteristicSubscriptionType;
-export declare function stringToRefreshGattMoment(_momentString: RefreshGattMoment): NitroRefreshGattMoment;
-export declare function normalizeState(state: NitroState | State | string): NitroState;
-export declare function normalizeLogLevel(logLevel: NitroLogLevel | LogLevel | string): NitroLogLevel;
-export declare function normalizeCharacteristicSubscriptionType(type: NitroCharacteristicSubscriptionType | CharacteristicSubscriptionType | string): NitroCharacteristicSubscriptionType;
-export declare function normalizeRefreshGattMoment(_moment: NitroRefreshGattMoment | RefreshGattMoment | string): NitroRefreshGattMoment;
-export declare function isStringEnumValue(value: any): boolean;

package/lib/compatibility/enums.js

@@ -1,159 +0,0 @@
-/**
- * React Native BLE Plx Compatible Enums and Types
- *
- * These match the exact types from react-native-ble-plx for drop-in compatibility.
- * This module provides conversion between Nitro's numeric enums and react-native-ble-plx types.
- */
-// Import Nitro's numeric enums with aliases to avoid naming conflicts
-import { State as NitroState, LogLevel as NitroLogLevel, CharacteristicSubscriptionType as NitroCharacteristicSubscriptionType, RefreshGattMoment as NitroRefreshGattMoment, } from '../specs/types';
-// Define exact string enums and types matching react-native-ble-plx
-export var State;
-(function (State) {
-    State["Unknown"] = "Unknown";
-    State["Resetting"] = "Resetting";
-    State["Unsupported"] = "Unsupported";
-    State["Unauthorized"] = "Unauthorized";
-    State["PoweredOff"] = "PoweredOff";
-    State["PoweredOn"] = "PoweredOn";
-})(State || (State = {}));
-export var LogLevel;
-(function (LogLevel) {
-    LogLevel["None"] = "None";
-    LogLevel["Verbose"] = "Verbose";
-    LogLevel["Debug"] = "Debug";
-    LogLevel["Info"] = "Info";
-    LogLevel["Warning"] = "Warning";
-    LogLevel["Error"] = "Error";
-})(LogLevel || (LogLevel = {}));
-// Conversion functions from Nitro numeric enums to react-native-ble-plx string enums/types
-export function stateToString(state) {
-    const mapping = {
-        [NitroState.Unknown]: State.Unknown,
-        [NitroState.Resetting]: State.Resetting,
-        [NitroState.Unsupported]: State.Unsupported,
-        [NitroState.Unauthorized]: State.Unauthorized,
-        [NitroState.PoweredOff]: State.PoweredOff,
-        [NitroState.PoweredOn]: State.PoweredOn,
-    };
-    return mapping[state] ?? State.Unknown;
-}
-export function logLevelToString(logLevel) {
-    const mapping = {
-        [NitroLogLevel.None]: LogLevel.None,
-        [NitroLogLevel.Verbose]: LogLevel.Verbose,
-        [NitroLogLevel.Debug]: LogLevel.Debug,
-        [NitroLogLevel.Info]: LogLevel.Info,
-        [NitroLogLevel.Warning]: LogLevel.Warning,
-        [NitroLogLevel.Error]: LogLevel.Error,
-    };
-    return mapping[logLevel] ?? LogLevel.None;
-}
-export function characteristicSubscriptionTypeToString(type) {
-    const mapping = {
-        [NitroCharacteristicSubscriptionType.Notification]: 'notification',
-        [NitroCharacteristicSubscriptionType.Indication]: 'indication',
-    };
-    return mapping[type] ?? 'notification';
-}
-export function refreshGattMomentToString(_moment) {
-    return 'OnConnected'; // Only one value exists
-}
-// Conversion functions from react-native-ble-plx string enums/types to Nitro numeric enums
-export function stringToState(stateString) {
-    switch (stateString) {
-        case State.Unknown:
-        case 'Unknown':
-            return NitroState.Unknown;
-        case State.Resetting:
-        case 'Resetting':
-            return NitroState.Resetting;
-        case State.Unsupported:
-        case 'Unsupported':
-            return NitroState.Unsupported;
-        case State.Unauthorized:
-        case 'Unauthorized':
-            return NitroState.Unauthorized;
-        case State.PoweredOff:
-        case 'PoweredOff':
-            return NitroState.PoweredOff;
-        case State.PoweredOn:
-        case 'PoweredOn':
-            return NitroState.PoweredOn;
-        default:
-            return NitroState.Unknown;
-    }
-}
-export function stringToLogLevel(logLevelString) {
-    switch (logLevelString) {
-        case LogLevel.None:
-        case 'None':
-            return NitroLogLevel.None;
-        case LogLevel.Verbose:
-        case 'Verbose':
-            return NitroLogLevel.Verbose;
-        case LogLevel.Debug:
-        case 'Debug':
-            return NitroLogLevel.Debug;
-        case LogLevel.Info:
-        case 'Info':
-            return NitroLogLevel.Info;
-        case LogLevel.Warning:
-        case 'Warning':
-            return NitroLogLevel.Warning;
-        case LogLevel.Error:
-        case 'Error':
-            return NitroLogLevel.Error;
-        default:
-            return NitroLogLevel.None;
-    }
-}
-export function stringToCharacteristicSubscriptionType(typeString) {
-    switch (typeString) {
-        case 'notification':
-            return NitroCharacteristicSubscriptionType.Notification;
-        case 'indication':
-            return NitroCharacteristicSubscriptionType.Indication;
-        default:
-            return NitroCharacteristicSubscriptionType.Notification;
-    }
-}
-export function stringToRefreshGattMoment(_momentString) {
-    return NitroRefreshGattMoment.OnConnected;
-}
-// Generic converter that handles both string and numeric enum values
-export function normalizeState(state) {
-    if (typeof state === 'string') {
-        return stringToState(state);
-    }
-    // If it's already a NitroState (numeric), return as-is
-    if (typeof state === 'number') {
-        return state;
-    }
-    // If it's a string State enum value, convert it
-    return stringToState(state);
-}
-export function normalizeLogLevel(logLevel) {
-    if (typeof logLevel === 'string') {
-        return stringToLogLevel(logLevel);
-    }
-    // If it's already a NitroLogLevel (numeric), return as-is
-    if (typeof logLevel === 'number') {
-        return logLevel;
-    }
-    // If it's a string LogLevel enum value, convert it
-    return stringToLogLevel(logLevel);
-}
-export function normalizeCharacteristicSubscriptionType(type) {
-    if (typeof type === 'string') {
-        return stringToCharacteristicSubscriptionType(type);
-    }
-    // If it's already a NitroCharacteristicSubscriptionType (numeric), return as-is
-    return type;
-}
-export function normalizeRefreshGattMoment(_moment) {
-    return NitroRefreshGattMoment.OnConnected; // Only one value exists
-}
-// Helper function to detect if a value is a string enum vs numeric enum
-export function isStringEnumValue(value) {
-    return typeof value === 'string';
-}

package/lib/compatibility/index.d.ts

@@ -1,12 +0,0 @@
-/**
- * Compatibility layer for react-native-ble-nitro
- *
- * This module provides compatibility shims and converters to maintain
- * 100% API compatibility with react-native-ble-plx while working with
- * Nitro's type system constraints.
- */
-export * from './serviceData';
-export * from './deviceWrapper';
-export * from './constants';
-export { stateToString, stringToState, logLevelToString, stringToLogLevel, characteristicSubscriptionTypeToString, stringToCharacteristicSubscriptionType, normalizeState, normalizeLogLevel, normalizeCharacteristicSubscriptionType, State, LogLevel } from './enums';
-export type { CharacteristicSubscriptionType, RefreshGattMoment } from './enums';

package/lib/compatibility/index.js

@@ -1,12 +0,0 @@
-/**
- * Compatibility layer for react-native-ble-nitro
- *
- * This module provides compatibility shims and converters to maintain
- * 100% API compatibility with react-native-ble-plx while working with
- * Nitro's type system constraints.
- */
-export * from './serviceData';
-export * from './deviceWrapper';
-export * from './constants';
-// Explicitly export enum utilities and enums to avoid conflicts
-export { stateToString, stringToState, logLevelToString, stringToLogLevel, characteristicSubscriptionTypeToString, stringToCharacteristicSubscriptionType, normalizeState, normalizeLogLevel, normalizeCharacteristicSubscriptionType, State, LogLevel } from './enums';

package/lib/compatibility/serviceData.d.ts

@@ -1,51 +0,0 @@
-/**
- * Service Data compatibility layer
- *
- * Provides conversion between Nitro's structured ServiceDataEntry[] format
- * and the original { [uuid: string]: Base64 } format from react-native-ble-plx
- */
-import type { ServiceDataEntry, UUID, Base64 } from '../specs/types';
-/**
- * Convert ServiceDataEntry array to the original index signature format
- */
-export declare function serviceDataArrayToMap(entries: ServiceDataEntry[] | null): {
-    [uuid: string]: Base64;
-} | null;
-/**
- * Convert the original index signature format to ServiceDataEntry array
- */
-export declare function serviceDataMapToArray(map: {
-    [uuid: string]: Base64;
-} | null): ServiceDataEntry[] | null;
-/**
- * Merge two service data maps (used in device updates)
- */
-export declare function mergeServiceDataMaps(existing: {
-    [uuid: string]: Base64;
-} | null, updates: {
-    [uuid: string]: Base64;
-} | null): {
-    [uuid: string]: Base64;
-} | null;
-/**
- * Merge two service data arrays (used in native updates)
- */
-export declare function mergeServiceDataArrays(existing: ServiceDataEntry[] | null, updates: ServiceDataEntry[] | null): ServiceDataEntry[] | null;
-/**
- * Check if service data contains a specific service UUID
- */
-export declare function hasServiceUUID(serviceData: {
-    [uuid: string]: Base64;
-} | null, uuid: UUID): boolean;
-/**
- * Get service data for a specific UUID
- */
-export declare function getServiceData(serviceData: {
-    [uuid: string]: Base64;
-} | null, uuid: UUID): Base64 | null;
-/**
- * Get all service UUIDs from service data
- */
-export declare function getServiceUUIDs(serviceData: {
-    [uuid: string]: Base64;
-} | null): UUID[];