react-native-ble-nitro 1.0.0-beta.8 → 1.0.0

package/src/compatibility/deviceWrapper.ts

@@ -1,427 +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 { 
-  NativeDevice, 
-  UUID, 
-  Base64, 
-  DeviceId,
-  TransactionId,
-  ConnectionPriority,
-  ConnectionOptions,
-  ServiceDataEntry,
-  NativeService,
-  NativeCharacteristic,
-  NativeDescriptor,
-  CharacteristicSubscriptionType,
-  Subscription
-} from '../specs/types';
-import { serviceDataArrayToMap } from './serviceData';
-import { 
-  normalizeCharacteristicSubscriptionType,
-  stateToString,
-  characteristicSubscriptionTypeToString 
-} from './enums';
-
-/**
- * Device wrapper that provides react-native-ble-plx compatibility
- * Maps Nitro device properties to the expected API surface
- */
-export class DeviceWrapper {
-  constructor(private nitroDevice: NitroDevice | any) {}
-
-  // Device identification
-  get id(): DeviceId {
-    return this.nitroDevice.id;
-  }
-
-  // Map deviceName back to name for compatibility
-  get name(): string | null {
-    return this.nitroDevice.deviceName || null;
-  }
-
-  get rssi(): number | null {
-    return this.nitroDevice.rssi || null;
-  }
-
-  get mtu(): number {
-    return this.nitroDevice.mtu;
-  }
-
-  // Advertisement data
-  get manufacturerData(): Base64 | null {
-    return this.nitroDevice.manufacturerData || null;
-  }
-
-  get rawScanRecord(): Base64 {
-    return this.nitroDevice.rawScanRecord;
-  }
-
-  // Convert ServiceDataEntry[] back to { [uuid: string]: Base64 }
-  get serviceData(): { [uuid: string]: Base64 } | null {
-    return serviceDataArrayToMap(this.nitroDevice.serviceData || null);
-  }
-
-  get serviceUUIDs(): UUID[] | null {
-    return this.nitroDevice.serviceUUIDs || null;
-  }
-
-  get localName(): string | null {
-    return this.nitroDevice.localName || null;
-  }
-
-  get txPowerLevel(): number | null {
-    return this.nitroDevice.txPowerLevel || null;
-  }
-
-  get solicitedServiceUUIDs(): UUID[] | null {
-    return this.nitroDevice.solicitedServiceUUIDs || null;
-  }
-
-  get isConnectable(): boolean | null {
-    return this.nitroDevice.isConnectable || null;
-  }
-
-  get overflowServiceUUIDs(): UUID[] | null {
-    return this.nitroDevice.overflowServiceUUIDs || null;
-  }
-
-  // Connection management methods
-  async requestConnectionPriority(
-    connectionPriority: ConnectionPriority,
-    transactionId?: TransactionId
-  ): Promise<DeviceWrapper> {
-    const result = await this.nitroDevice.requestConnectionPriority(connectionPriority, transactionId);
-    return new DeviceWrapper(result);
-  }
-
-  async readRSSI(transactionId?: TransactionId): Promise<DeviceWrapper> {
-    const result = await this.nitroDevice.readRSSI(transactionId);
-    return new DeviceWrapper(result);
-  }
-
-  async requestMTU(mtu: number, transactionId?: TransactionId): Promise<DeviceWrapper> {
-    const result = await this.nitroDevice.requestMTU(mtu, transactionId);
-    return new DeviceWrapper(result);
-  }
-
-  async connect(options?: Partial<ConnectionOptions>): Promise<DeviceWrapper> {
-    // Provide defaults for required fields in Nitro interface
-    const connectionOptions: 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(): Promise<DeviceWrapper> {
-    const result = await this.nitroDevice.cancelConnection();
-    return new DeviceWrapper(result);
-  }
-
-  async isConnected(): Promise<boolean> {
-    return await this.nitroDevice.isConnected();
-  }
-
-  onDisconnected(listener: (error: any | null, device: DeviceWrapper) => void): Subscription {
-    return this.nitroDevice.onDisconnected((error: any, device: any) => {
-      listener(error, new DeviceWrapper(device));
-    });
-  }
-
-  // Service discovery
-  async discoverAllServicesAndCharacteristics(transactionId?: TransactionId): Promise<DeviceWrapper> {
-    const result = await this.nitroDevice.discoverAllServicesAndCharacteristics(transactionId);
-    return new DeviceWrapper(result);
-  }
-
-  async services(): Promise<ServiceWrapper[]> {
-    const services = await this.nitroDevice.services();
-    return services.map((service: any) => new ServiceWrapper(service, this.nitroDevice));
-  }
-
-  // Characteristic operations
-  async characteristicsForService(serviceUUID: UUID): Promise<CharacteristicWrapper[]> {
-    const characteristics = await this.nitroDevice.characteristicsForService(serviceUUID);
-    return characteristics.map((char: any) => new CharacteristicWrapper(char, this.nitroDevice));
-  }
-
-  async readCharacteristicForService(
-    serviceUUID: UUID,
-    characteristicUUID: UUID,
-    transactionId?: TransactionId
-  ): Promise<CharacteristicWrapper> {
-    const result = await this.nitroDevice.readCharacteristicForService(
-      serviceUUID, 
-      characteristicUUID, 
-      transactionId
-    );
-    return new CharacteristicWrapper(result, this.nitroDevice);
-  }
-
-  async writeCharacteristicWithResponseForService(
-    serviceUUID: UUID,
-    characteristicUUID: UUID,
-    valueBase64: Base64,
-    transactionId?: TransactionId
-  ): Promise<CharacteristicWrapper> {
-    const result = await this.nitroDevice.writeCharacteristicWithResponseForService(
-      serviceUUID,
-      characteristicUUID,
-      valueBase64,
-      transactionId
-    );
-    return new CharacteristicWrapper(result, this.nitroDevice);
-  }
-
-  async writeCharacteristicWithoutResponseForService(
-    serviceUUID: UUID,
-    characteristicUUID: UUID,
-    valueBase64: Base64,
-    transactionId?: TransactionId
-  ): Promise<CharacteristicWrapper> {
-    const result = await this.nitroDevice.writeCharacteristicWithoutResponseForService(
-      serviceUUID,
-      characteristicUUID,
-      valueBase64,
-      transactionId
-    );
-    return new CharacteristicWrapper(result, this.nitroDevice);
-  }
-
-  monitorCharacteristicForService(
-    serviceUUID: UUID,
-    characteristicUUID: UUID,
-    listener: (error: any | null, characteristic: CharacteristicWrapper | null) => void,
-    transactionId?: TransactionId,
-    subscriptionType?: 'notification' | 'indication'
-  ): Subscription {
-    const nitroSubscriptionType = subscriptionType 
-      ? normalizeCharacteristicSubscriptionType(subscriptionType)
-      : undefined;
-
-    return this.nitroDevice.monitorCharacteristicForService(
-      serviceUUID,
-      characteristicUUID,
-      (error: any, characteristic: any) => {
-        listener(
-          error, 
-          characteristic ? new CharacteristicWrapper(characteristic, this.nitroDevice) : null
-        );
-      },
-      transactionId,
-      nitroSubscriptionType
-    );
-  }
-
-  // Descriptor operations
-  async descriptorsForService(
-    serviceUUID: UUID,
-    characteristicUUID: UUID
-  ): Promise<DescriptorWrapper[]> {
-    const descriptors = await this.nitroDevice.descriptorsForService(serviceUUID, characteristicUUID);
-    return descriptors.map((desc: any) => new DescriptorWrapper(desc, this.nitroDevice));
-  }
-
-  async readDescriptorForService(
-    serviceUUID: UUID,
-    characteristicUUID: UUID,
-    descriptorUUID: UUID,
-    transactionId?: TransactionId
-  ): Promise<DescriptorWrapper> {
-    const result = await this.nitroDevice.readDescriptorForService(
-      serviceUUID,
-      characteristicUUID,
-      descriptorUUID,
-      transactionId
-    );
-    return new DescriptorWrapper(result, this.nitroDevice);
-  }
-
-  async writeDescriptorForService(
-    serviceUUID: UUID,
-    characteristicUUID: UUID,
-    descriptorUUID: UUID,
-    valueBase64: Base64,
-    transactionId?: TransactionId
-  ): Promise<DescriptorWrapper> {
-    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(
-    private nativeService: NativeService,
-    private nitroDevice: NitroDevice
-  ) {}
-
-  get id(): number {
-    return this.nativeService.id;
-  }
-
-  get uuid(): UUID {
-    return this.nativeService.uuid;
-  }
-
-  get deviceID(): DeviceId {
-    return this.nativeService.deviceID;
-  }
-
-  get isPrimary(): boolean {
-    return this.nativeService.isPrimary;
-  }
-
-  // Delegate to device methods
-  async characteristics(): Promise<CharacteristicWrapper[]> {
-    const device = new DeviceWrapper(this.nitroDevice);
-    return await device.characteristicsForService(this.uuid);
-  }
-
-  async readCharacteristic(
-    characteristicUUID: UUID,
-    transactionId?: TransactionId
-  ): Promise<CharacteristicWrapper> {
-    const device = new DeviceWrapper(this.nitroDevice);
-    return await device.readCharacteristicForService(this.uuid, characteristicUUID, transactionId);
-  }
-
-  // ... other service methods would delegate similarly
-}
-
-/**
- * Characteristic wrapper for compatibility
- */
-export class CharacteristicWrapper {
-  constructor(
-    private nativeCharacteristic: NativeCharacteristic,
-    private nitroDevice: NitroDevice
-  ) {}
-
-  get id(): number {
-    return this.nativeCharacteristic.id;
-  }
-
-  get uuid(): UUID {
-    return this.nativeCharacteristic.uuid;
-  }
-
-  get serviceID(): number {
-    return this.nativeCharacteristic.serviceID;
-  }
-
-  get serviceUUID(): UUID {
-    return this.nativeCharacteristic.serviceUUID;
-  }
-
-  get deviceID(): DeviceId {
-    return this.nativeCharacteristic.deviceID;
-  }
-
-  get isReadable(): boolean {
-    return this.nativeCharacteristic.isReadable;
-  }
-
-  get isWritableWithResponse(): boolean {
-    return this.nativeCharacteristic.isWritableWithResponse;
-  }
-
-  get isWritableWithoutResponse(): boolean {
-    return this.nativeCharacteristic.isWritableWithoutResponse;
-  }
-
-  get isNotifiable(): boolean {
-    return this.nativeCharacteristic.isNotifiable;
-  }
-
-  get isNotifying(): boolean {
-    return this.nativeCharacteristic.isNotifying;
-  }
-
-  get isIndicatable(): boolean {
-    return this.nativeCharacteristic.isIndicatable;
-  }
-
-  get value(): Base64 | null {
-    return this.nativeCharacteristic.value;
-  }
-
-  // Delegate to device methods
-  async read(transactionId?: TransactionId): Promise<CharacteristicWrapper> {
-    const device = new DeviceWrapper(this.nitroDevice);
-    return await device.readCharacteristicForService(this.serviceUUID, this.uuid, transactionId);
-  }
-
-  // ... other characteristic methods would delegate similarly
-}
-
-/**
- * Descriptor wrapper for compatibility
- */
-export class DescriptorWrapper {
-  constructor(
-    private nativeDescriptor: NativeDescriptor,
-    private nitroDevice: NitroDevice
-  ) {}
-
-  get id(): number {
-    return this.nativeDescriptor.id;
-  }
-
-  get uuid(): UUID {
-    return this.nativeDescriptor.uuid;
-  }
-
-  get characteristicID(): number {
-    return this.nativeDescriptor.characteristicID;
-  }
-
-  get characteristicUUID(): UUID {
-    return this.nativeDescriptor.characteristicUUID;
-  }
-
-  get serviceID(): number {
-    return this.nativeDescriptor.serviceID;
-  }
-
-  get serviceUUID(): UUID {
-    return this.nativeDescriptor.serviceUUID;
-  }
-
-  get deviceID(): DeviceId {
-    return this.nativeDescriptor.deviceID;
-  }
-
-  get value(): Base64 | null {
-    return this.nativeDescriptor.value;
-  }
-
-  // Delegate to device methods
-  async read(transactionId?: TransactionId): Promise<DescriptorWrapper> {
-    const device = new DeviceWrapper(this.nitroDevice);
-    return await device.readDescriptorForService(
-      this.serviceUUID, 
-      this.characteristicUUID, 
-      this.uuid, 
-      transactionId
-    );
-  }
-
-  // ... other descriptor methods would delegate similarly
-}

package/src/compatibility/enums.ts

@@ -1,190 +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 enum State {
-  Unknown = 'Unknown',
-  Resetting = 'Resetting',
-  Unsupported = 'Unsupported',
-  Unauthorized = 'Unauthorized',
-  PoweredOff = 'PoweredOff',
-  PoweredOn = 'PoweredOn'
-}
-
-export enum LogLevel {
-  None = 'None',
-  Verbose = 'Verbose',
-  Debug = 'Debug',
-  Info = 'Info',
-  Warning = 'Warning',
-  Error = 'Error'
-}
-
-// These are type literals in react-native-ble-plx, not enums
-export type CharacteristicSubscriptionType = 'notification' | 'indication';
-export type RefreshGattMoment = 'OnConnected';
-
-// Conversion functions from Nitro numeric enums to react-native-ble-plx string enums/types
-export function stateToString(state: NitroState): 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: NitroLogLevel): 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: NitroCharacteristicSubscriptionType
-): CharacteristicSubscriptionType {
-  const mapping = {
-    [NitroCharacteristicSubscriptionType.Notification]: 'notification' as const,
-    [NitroCharacteristicSubscriptionType.Indication]: 'indication' as const,
-  };
-  return mapping[type] ?? 'notification';
-}
-
-export function refreshGattMomentToString(_moment: NitroRefreshGattMoment): RefreshGattMoment {
-  return 'OnConnected'; // Only one value exists
-}
-
-// Conversion functions from react-native-ble-plx string enums/types to Nitro numeric enums
-export function stringToState(stateString: State | string): NitroState {
-  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: LogLevel | string): NitroLogLevel {
-  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: CharacteristicSubscriptionType | string
-): NitroCharacteristicSubscriptionType {
-  switch (typeString) {
-    case 'notification':
-      return NitroCharacteristicSubscriptionType.Notification;
-    case 'indication':
-      return NitroCharacteristicSubscriptionType.Indication;
-    default:
-      return NitroCharacteristicSubscriptionType.Notification;
-  }
-}
-
-export function stringToRefreshGattMoment(_momentString: RefreshGattMoment): NitroRefreshGattMoment {
-  return NitroRefreshGattMoment.OnConnected;
-}
-
-// Generic converter that handles both string and numeric enum values
-export function normalizeState(state: NitroState | State | string): NitroState {
-  if (typeof state === 'string') {
-    return stringToState(state);
-  }
-  // If it's already a NitroState (numeric), return as-is
-  if (typeof state === 'number') {
-    return state as NitroState;
-  }
-  // If it's a string State enum value, convert it
-  return stringToState(state as string);
-}
-
-export function normalizeLogLevel(logLevel: NitroLogLevel | LogLevel | string): NitroLogLevel {
-  if (typeof logLevel === 'string') {
-    return stringToLogLevel(logLevel);
-  }
-  // If it's already a NitroLogLevel (numeric), return as-is
-  if (typeof logLevel === 'number') {
-    return logLevel as NitroLogLevel;
-  }
-  // If it's a string LogLevel enum value, convert it
-  return stringToLogLevel(logLevel as string);
-}
-
-export function normalizeCharacteristicSubscriptionType(
-  type: NitroCharacteristicSubscriptionType | CharacteristicSubscriptionType | string
-): NitroCharacteristicSubscriptionType {
-  if (typeof type === 'string') {
-    return stringToCharacteristicSubscriptionType(type);
-  }
-  // If it's already a NitroCharacteristicSubscriptionType (numeric), return as-is
-  return type as NitroCharacteristicSubscriptionType;
-}
-
-export function normalizeRefreshGattMoment(
-  _moment: NitroRefreshGattMoment | RefreshGattMoment | string
-): NitroRefreshGattMoment {
-  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: any): boolean {
-  return typeof value === 'string';
-}

package/src/compatibility/index.ts

@@ -1,32 +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';
-
-// Export type literals (not enums) for exact react-native-ble-plx compatibility
-export type {
-  CharacteristicSubscriptionType,
-  RefreshGattMoment
-} from './enums';