react-native-ble-mesh 2.1.0 → 2.1.3

package/src/transport/WiFiDirectTransport.js

@@ -10,10 +10,11 @@
 
 const Transport = require('./Transport');
 const { ConnectionError } = require('../errors');
+const base64 = require('../utils/base64');
 
 /**
  * Wi-Fi Direct transport states
- * @constant {Object}
+ * @constant {any}
  */
 const WIFI_DIRECT_STATE = Object.freeze({
   AVAILABLE: 'available',
@@ -46,6 +47,7 @@ class WiFiDirectTransport extends Transport {
     this._isDiscovering = false;
     this._isGroupOwner = false;
     this._groupInfo = null;
+    /** @type {any} */
     this._subscriptions = [];
   }
 
@@ -75,16 +77,16 @@ class WiFiDirectTransport extends Transport {
 
     try {
       const p2p = this._getWifiP2p();
-      await p2p.initialize();
+      await p2p?.initialize();
 
       // Check if Wi-Fi Direct is supported
-      const isAvailable = await p2p.isSuccessfulInitialize();
+      const isAvailable = await p2p?.isSuccessfulInitialize();
       if (!isAvailable) {
         throw new ConnectionError('Wi-Fi Direct is not available on this device', 'E100');
       }
 
       this._setState(Transport.STATE.RUNNING);
-    } catch (error) {
+    } catch (/** @type {any} */ error) {
       this._setState(Transport.STATE.ERROR);
       throw error;
     }
@@ -107,13 +109,13 @@ class WiFiDirectTransport extends Transport {
 
       // Disconnect from group
       try {
-        await p2p.removeGroup();
+        await p2p?.removeGroup();
       } catch (e) {
         // Ignore — may not be in a group
       }
 
       // Cleanup subscriptions
-      this._subscriptions.forEach(sub => {
+      this._subscriptions.forEach((/** @type {any} */ sub) => {
         if (sub && typeof sub.remove === 'function') { sub.remove(); }
       });
       this._subscriptions = [];
@@ -132,7 +134,7 @@ class WiFiDirectTransport extends Transport {
     if (!this.isRunning || this._isDiscovering) { return; }
 
     const p2p = this._getWifiP2p();
-    await p2p.discoverPeers();
+    await p2p?.discoverPeers();
     this._isDiscovering = true;
     this.emit('discoveryStarted');
   }
@@ -146,7 +148,7 @@ class WiFiDirectTransport extends Transport {
 
     const p2p = this._getWifiP2p();
     try {
-      await p2p.stopDiscoveringPeers();
+      await p2p?.stopDiscoveringPeers();
     } catch (e) {
       // Ignore
     }
@@ -173,9 +175,9 @@ class WiFiDirectTransport extends Transport {
     const p2p = this._getWifiP2p();
 
     try {
-      await p2p.connect(peerId);
+      await p2p?.connect(peerId);
 
-      const connectionInfo = await p2p.getConnectionInfo();
+      const connectionInfo = await p2p?.getConnectionInfo();
       this._isGroupOwner = connectionInfo.isGroupOwner || false;
       this._groupInfo = connectionInfo;
 
@@ -187,7 +189,7 @@ class WiFiDirectTransport extends Transport {
       });
 
       this.emit('peerConnected', { peerId, transport: 'wifi-direct' });
-    } catch (error) {
+    } catch (/** @type {any} */ error) {
       throw ConnectionError.connectionFailed(peerId, { cause: error.message });
     }
   }
@@ -202,7 +204,7 @@ class WiFiDirectTransport extends Transport {
 
     const p2p = this._getWifiP2p();
     try {
-      await p2p.removeGroup();
+      await p2p?.removeGroup();
     } catch (e) {
       // Ignore
     }
@@ -227,14 +229,14 @@ class WiFiDirectTransport extends Transport {
     const peerInfo = this._peers.get(peerId);
 
     // Convert Uint8Array to base64 for transfer
-    const base64 = this._uint8ArrayToBase64(data);
+    const encoded = this._uint8ArrayToBase64(data);
 
     if (this._isGroupOwner) {
       // Group owner sends via server socket
-      await p2p.sendMessage(base64);
+      await p2p?.sendMessage(encoded);
     } else {
       // Client sends to group owner address
-      await p2p.sendMessageTo(peerInfo.groupOwnerAddress, this._port, base64);
+      await p2p?.sendMessageTo(peerInfo.groupOwnerAddress, this._port, encoded);
     }
   }
 
@@ -261,16 +263,20 @@ class WiFiDirectTransport extends Transport {
     if (!this.isRunning) { return []; }
     const p2p = this._getWifiP2p();
     try {
-      return await p2p.getAvailablePeers();
+      return await p2p?.getAvailablePeers();
     } catch (e) {
       return [];
     }
   }
 
-  /** @private */
+  /**
+   * @private
+   * @returns {any}
+   */
   _getWifiP2p() {
     if (!this._wifiP2p) {
       try {
+        // @ts-ignore
         this._wifiP2p = require('react-native-wifi-p2p');
       } catch (e) {
         throw new Error(
@@ -283,13 +289,8 @@ class WiFiDirectTransport extends Transport {
   }
 
   /** @private */
-  _uint8ArrayToBase64(bytes) {
-    const chunks = [];
-    for (let i = 0; i < bytes.length; i += 8192) {
-      chunks.push(String.fromCharCode.apply(null, bytes.subarray(i, Math.min(i + 8192, bytes.length))));
-    }
-    const binary = chunks.join('');
-    return typeof btoa !== 'undefined' ? btoa(binary) : Buffer.from(bytes).toString('base64');
+  _uint8ArrayToBase64(/** @type {any} */ bytes) {
+    return base64.encode(bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes));
   }
 }
 

package/src/transport/adapters/BLEAdapter.js

@@ -17,12 +17,12 @@ const { BLUETOOTH_STATE } = require('../../constants');
 class BLEAdapter {
   /**
    * Creates a new BLEAdapter instance
-   * @param {Object} [options={}] - Adapter options
+   * @param {any} [options={}] - Adapter options
    */
   constructor(options = {}) {
     /**
      * Adapter options
-     * @type {Object}
+     * @type {any}
      * @protected
      */
     this._options = options;
@@ -73,12 +73,12 @@ class BLEAdapter {
   /**
    * Starts scanning for BLE devices
    * @abstract
-   * @param {string[]} serviceUUIDs - Service UUIDs to filter by
-   * @param {Function} callback - Callback for discovered devices
+   * @param {string[]} _serviceUUIDs - Service UUIDs to filter by
+   * @param {Function} _callback - Callback for discovered devices
    * @returns {Promise<void>}
    * @throws {Error} If not implemented by subclass
    */
-  async startScan(_serviceUUIDs, _callback) {
+  async startScan(/** @type {any} */ _serviceUUIDs, _callback) {
     throw new Error('BLEAdapter.startScan() must be implemented by subclass');
   }
 
@@ -94,50 +94,50 @@ class BLEAdapter {
   /**
    * Connects to a BLE device
    * @abstract
-   * @param {string} deviceId - Device ID to connect to
+   * @param {string} _deviceId - Device ID to connect to
    * @returns {Promise<Object>} Connected device info
    * @throws {Error} If not implemented by subclass
    */
-  async connect(_deviceId) {
+  async connect(/** @type {any} */ _deviceId) {
     throw new Error('BLEAdapter.connect() must be implemented by subclass');
   }
 
   /**
    * Disconnects from a BLE device
    * @abstract
-   * @param {string} deviceId - Device ID to disconnect from
+   * @param {string} _deviceId - Device ID to disconnect from
    * @returns {Promise<void>}
    * @throws {Error} If not implemented by subclass
    */
-  async disconnect(_deviceId) {
+  async disconnect(/** @type {any} */ _deviceId) {
     throw new Error('BLEAdapter.disconnect() must be implemented by subclass');
   }
 
   /**
    * Writes data to a characteristic
    * @abstract
-   * @param {string} deviceId - Target device ID
-   * @param {string} serviceUUID - Service UUID
-   * @param {string} charUUID - Characteristic UUID
-   * @param {Uint8Array} data - Data to write
+   * @param {string} _deviceId - Target device ID
+   * @param {string} _serviceUUID - Service UUID
+   * @param {string} _charUUID - Characteristic UUID
+   * @param {Uint8Array} _data - Data to write
    * @returns {Promise<void>}
    * @throws {Error} If not implemented by subclass
    */
-  async write(_deviceId, _serviceUUID, _charUUID, _data) {
+  async write(/** @type {any} */ _deviceId, _serviceUUID, _charUUID, _data) {
     throw new Error('BLEAdapter.write() must be implemented by subclass');
   }
 
   /**
    * Subscribes to characteristic notifications
    * @abstract
-   * @param {string} deviceId - Target device ID
-   * @param {string} serviceUUID - Service UUID
-   * @param {string} charUUID - Characteristic UUID
-   * @param {Function} callback - Notification callback
+   * @param {string} _deviceId - Target device ID
+   * @param {string} _serviceUUID - Service UUID
+   * @param {string} _charUUID - Characteristic UUID
+   * @param {Function} _callback - Notification callback
    * @returns {Promise<void>}
    * @throws {Error} If not implemented by subclass
    */
-  async subscribe(_deviceId, _serviceUUID, _charUUID, _callback) {
+  async subscribe(/** @type {any} */ _deviceId, _serviceUUID, _charUUID, _callback) {
     throw new Error('BLEAdapter.subscribe() must be implemented by subclass');
   }
 

package/src/transport/adapters/NodeBLEAdapter.js

@@ -21,35 +21,35 @@ class NodeBLEAdapter extends BLEAdapter {
   /**
    * Creates a new NodeBLEAdapter instance
    * @param {Object} [options={}] - Adapter options
-   * @param {Object} [options.noble] - Noble instance
+   * @param {any} [options.noble] - Noble instance
    */
   constructor(options = {}) {
     super(options);
 
     /**
      * Noble instance
-     * @type {Object|null}
+     * @type {any}
      * @private
      */
     this._noble = options.noble || null;
 
     /**
      * Connected peripherals map
-     * @type {Map<string, Object>}
+     * @type {Map<string, any>}
      * @private
      */
     this._peripherals = new Map();
 
     /**
      * Discovered peripherals cache
-     * @type {Map<string, Object>}
+     * @type {Map<string, any>}
      * @private
      */
     this._discoveredPeripherals = new Map();
 
     /**
      * Subscription handlers map
-     * @type {Map<string, Object>}
+     * @type {Map<string, any>}
      * @private
      */
     this._subscriptions = new Map();
@@ -82,6 +82,7 @@ class NodeBLEAdapter extends BLEAdapter {
     // Try to load noble if not provided
     if (!this._noble) {
       try {
+        // @ts-ignore
         this._noble = require('@abandonware/noble');
       } catch (error) {
         throw new Error(
@@ -91,7 +92,7 @@ class NodeBLEAdapter extends BLEAdapter {
     }
 
     // Set up state change listener
-    this._noble.on('stateChange', (state) => {
+    this._noble.on('stateChange', (/** @type {any} */ state) => {
       this._notifyStateChange(this._mapState(state));
     });
 
@@ -141,7 +142,7 @@ class NodeBLEAdapter extends BLEAdapter {
       uuid.toLowerCase().replace(/-/g, '')
     );
 
-    this._noble.on('discover', (peripheral) => {
+    this._noble.on('discover', (/** @type {any} */ peripheral) => {
       this._discoveredPeripherals.set(peripheral.id, peripheral);
 
       if (this._scanCallback) {
@@ -284,7 +285,7 @@ class NodeBLEAdapter extends BLEAdapter {
       throw new Error(`Characteristic ${charUUID} not found`);
     }
 
-    characteristic.on('data', (data) => {
+    characteristic.on('data', (/** @type {any} */ data) => {
       callback(new Uint8Array(data));
     });
 
@@ -318,7 +319,7 @@ class NodeBLEAdapter extends BLEAdapter {
       poweredOff: BLEAdapter.STATE.POWERED_OFF,
       poweredOn: BLEAdapter.STATE.POWERED_ON
     };
-    return stateMap[state] || BLEAdapter.STATE.UNKNOWN;
+    return /** @type {any} */ (stateMap)[state] || BLEAdapter.STATE.UNKNOWN;
   }
 
   /**
@@ -336,7 +337,7 @@ class NodeBLEAdapter extends BLEAdapter {
         reject(new Error('Bluetooth initialization timeout'));
       }, 10000);
 
-      this._noble.once('stateChange', (state) => {
+      this._noble.once('stateChange', (/** @type {any} */ state) => {
         clearTimeout(timeout);
         if (state === 'poweredOn') {
           resolve();
@@ -349,13 +350,13 @@ class NodeBLEAdapter extends BLEAdapter {
 
   /**
    * Connects to a peripheral
-   * @param {Object} peripheral - Noble peripheral
+   * @param {any} peripheral - Noble peripheral
    * @returns {Promise<void>}
    * @private
    */
   _connectPeripheral(peripheral) {
     return new Promise((resolve, reject) => {
-      peripheral.connect((error) => {
+      peripheral.connect((/** @type {any} */ error) => {
         if (error) { reject(error); } else { resolve(); }
       });
     });
@@ -363,7 +364,7 @@ class NodeBLEAdapter extends BLEAdapter {
 
   /**
    * Disconnects from a peripheral
-   * @param {Object} peripheral - Noble peripheral
+   * @param {any} peripheral - Noble peripheral
    * @returns {Promise<void>}
    * @private
    */
@@ -375,13 +376,13 @@ class NodeBLEAdapter extends BLEAdapter {
 
   /**
    * Discovers services and characteristics
-   * @param {Object} peripheral - Noble peripheral
+   * @param {any} peripheral - Noble peripheral
    * @returns {Promise<void>}
    * @private
    */
   _discoverServices(peripheral) {
     return new Promise((resolve, reject) => {
-      peripheral.discoverAllServicesAndCharacteristics((error) => {
+      peripheral.discoverAllServicesAndCharacteristics((/** @type {any} */ error) => {
         if (error) { reject(error); } else { resolve(); }
       });
     });
@@ -389,10 +390,10 @@ class NodeBLEAdapter extends BLEAdapter {
 
   /**
    * Finds a characteristic on a peripheral
-   * @param {Object} peripheral - Noble peripheral
+   * @param {any} peripheral - Noble peripheral
    * @param {string} serviceUUID - Service UUID
    * @param {string} charUUID - Characteristic UUID
-   * @returns {Object|null} Characteristic or null
+   * @returns {any} Characteristic or null
    * @private
    */
   _findCharacteristic(peripheral, serviceUUID, charUUID) {
@@ -400,23 +401,23 @@ class NodeBLEAdapter extends BLEAdapter {
     const formattedCharUUID = charUUID.toLowerCase().replace(/-/g, '');
 
     const service = peripheral.services?.find(
-      s => s.uuid === formattedServiceUUID
+      (/** @type {any} */ s) => s.uuid === formattedServiceUUID
     );
     return service?.characteristics?.find(
-      c => c.uuid === formattedCharUUID
+      (/** @type {any} */ c) => c.uuid === formattedCharUUID
     ) || null;
   }
 
   /**
    * Writes to a characteristic
-   * @param {Object} characteristic - Noble characteristic
+   * @param {any} characteristic - Noble characteristic
    * @param {Buffer} data - Data to write
    * @returns {Promise<void>}
    * @private
    */
   _writeCharacteristic(characteristic, data) {
     return new Promise((resolve, reject) => {
-      characteristic.write(data, false, (error) => {
+      characteristic.write(data, false, (/** @type {any} */ error) => {
         if (error) { reject(error); } else { resolve(); }
       });
     });
@@ -424,13 +425,13 @@ class NodeBLEAdapter extends BLEAdapter {
 
   /**
    * Subscribes to a characteristic
-   * @param {Object} characteristic - Noble characteristic
+   * @param {any} characteristic - Noble characteristic
    * @returns {Promise<void>}
    * @private
    */
   _subscribeCharacteristic(characteristic) {
     return new Promise((resolve, reject) => {
-      characteristic.subscribe((error) => {
+      characteristic.subscribe((/** @type {any} */ error) => {
         if (error) { reject(error); } else { resolve(); }
       });
     });

package/src/transport/adapters/RNBLEAdapter.js

@@ -6,6 +6,7 @@
  */
 
 const BLEAdapter = require('./BLEAdapter');
+const base64 = require('../../utils/base64');
 
 /**
  * React Native BLE adapter implementation.
@@ -21,14 +22,14 @@ class RNBLEAdapter extends BLEAdapter {
   /**
    * Creates a new RNBLEAdapter instance
    * @param {Object} [options={}] - Adapter options
-   * @param {Object} [options.BleManager] - BleManager class from react-native-ble-plx
+   * @param {any} [options.BleManager] - BleManager class from react-native-ble-plx
    */
   constructor(options = {}) {
     super(options);
 
     /**
      * BleManager instance
-     * @type {Object|null}
+     * @type {any}
      * @private
      */
     this._manager = null;
@@ -45,32 +46,33 @@ class RNBLEAdapter extends BLEAdapter {
      * @type {string|null}
      * @private
      */
+    // @ts-ignore
     this._restoreIdentifier = options.restoreIdentifier || null;
 
     /**
      * Connected devices map
-     * @type {Map<string, Object>}
+     * @type {Map<string, any>}
      * @private
      */
     this._devices = new Map();
 
     /**
      * Subscription handlers map
-     * @type {Map<string, Object>}
+     * @type {Map<string, any>}
      * @private
      */
     this._subscriptions = new Map();
 
     /**
      * Scan subscription reference
-     * @type {Object|null}
+     * @type {any}
      * @private
      */
     this._scanSubscription = null;
 
     /**
      * State subscription reference
-     * @type {Object|null}
+     * @type {any}
      * @private
      */
     this._stateSubscription = null;
@@ -96,6 +98,7 @@ class RNBLEAdapter extends BLEAdapter {
     // Try to load BleManager if not provided
     if (!this._BleManager) {
       try {
+        // @ts-ignore
         const blePlx = require('react-native-ble-plx');
         this._BleManager = blePlx.BleManager;
       } catch (error) {
@@ -108,7 +111,7 @@ class RNBLEAdapter extends BLEAdapter {
     const managerOptions = {};
     if (this._restoreIdentifier) {
       managerOptions.restoreStateIdentifier = this._restoreIdentifier;
-      managerOptions.restoreStateFunction = (restoredState) => {
+      managerOptions.restoreStateFunction = (/** @type {any} */ restoredState) => {
         // Re-populate devices from restored state
         if (restoredState && restoredState.connectedPeripherals) {
           for (const peripheral of restoredState.connectedPeripherals) {
@@ -117,10 +120,11 @@ class RNBLEAdapter extends BLEAdapter {
         }
       };
     }
+    // @ts-ignore
     this._manager = new this._BleManager(managerOptions);
 
     // Subscribe to state changes
-    this._stateSubscription = this._manager.onStateChange((state) => {
+    this._stateSubscription = this._manager.onStateChange((/** @type {any} */ state) => {
       this._notifyStateChange(this._mapState(state));
     }, true);
 
@@ -174,7 +178,7 @@ class RNBLEAdapter extends BLEAdapter {
   async startScan(serviceUUIDs, callback) {
     this._ensureInitialized();
 
-    this._manager.startDeviceScan(serviceUUIDs, null, (error, device) => {
+    this._manager.startDeviceScan(serviceUUIDs, null, (/** @type {any} */ error, /** @type {any} */ device) => {
       if (error) {
         return;
       }
@@ -292,7 +296,7 @@ class RNBLEAdapter extends BLEAdapter {
       deviceId,
       serviceUUID,
       charUUID,
-      (error, characteristic) => {
+      (/** @type {any} */ error, /** @type {any} */ characteristic) => {
         if (!error && characteristic) {
           const data = this._base64ToUint8Array(characteristic.value);
           callback(data);
@@ -328,7 +332,7 @@ class RNBLEAdapter extends BLEAdapter {
       PoweredOff: BLEAdapter.STATE.POWERED_OFF,
       PoweredOn: BLEAdapter.STATE.POWERED_ON
     };
-    return stateMap[state] || BLEAdapter.STATE.UNKNOWN;
+    return /** @type {any} */ (stateMap)[state] || BLEAdapter.STATE.UNKNOWN;
   }
 
   /**
@@ -357,26 +361,17 @@ class RNBLEAdapter extends BLEAdapter {
    * @private
    */
   _uint8ArrayToBase64(bytes) {
-    let binary = '';
-    for (let i = 0; i < bytes.length; i++) {
-      binary += String.fromCharCode(bytes[i]);
-    }
-    return btoa(binary);
+    return base64.encode(bytes);
   }
 
   /**
    * Converts Base64 string to Uint8Array
-   * @param {string} base64 - Base64 string
+   * @param {string} base64Str - Base64 string
    * @returns {Uint8Array} Byte array
    * @private
    */
-  _base64ToUint8Array(base64) {
-    const binary = atob(base64);
-    const bytes = new Uint8Array(binary.length);
-    for (let i = 0; i < binary.length; i++) {
-      bytes[i] = binary.charCodeAt(i);
-    }
-    return bytes;
+  _base64ToUint8Array(base64Str) {
+    return base64.decode(base64Str);
   }
 }
 

package/src/utils/EventEmitter.js

@@ -1,4 +1,5 @@
 'use strict';
+/* global __DEV__ */
 
 /**
  * @fileoverview Enhanced EventEmitter class
@@ -12,8 +13,8 @@
 class EventEmitter {
   /**
    * Creates a new EventEmitter
-   * @param {Object} [options] - Configuration options
-   * @param {number} [options.maxListeners=10] - Maximum listeners per event
+   * @param {any} [options] - Configuration options
+   *
    */
   constructor(options = {}) {
     /**
@@ -47,14 +48,17 @@ class EventEmitter {
     }
 
     const listeners = this._events.get(event);
+    if (!listeners) { return this; }
 
     // Warn if max listeners exceeded
     if (listeners.length >= this._maxListeners) {
-      console.warn(
-        'MaxListenersExceededWarning: Possible EventEmitter memory leak detected. ' +
-        `${listeners.length + 1} ${event} listeners added. ` +
-        'Use setMaxListeners() to increase limit'
-      );
+      if (typeof __DEV__ !== 'undefined' && __DEV__) {
+        console.warn(
+          'MaxListenersExceededWarning: Possible EventEmitter memory leak detected. ' +
+          `${listeners.length + 1} ${event} listeners added. ` +
+          'Use setMaxListeners() to increase limit'
+        );
+      }
     }
 
     listeners.push({ listener, once: false });
@@ -76,7 +80,7 @@ class EventEmitter {
       this._events.set(event, []);
     }
 
-    this._events.get(event).push({ listener, once: true });
+    this._events.get(event)?.push({ listener, once: true });
     return this;
   }
 
@@ -92,13 +96,13 @@ class EventEmitter {
     }
 
     const listeners = this._events.get(event);
-    const index = listeners.findIndex(entry => entry.listener === listener);
+    const index = listeners?.findIndex(entry => entry.listener === listener) ?? -1;
 
     if (index !== -1) {
-      listeners.splice(index, 1);
+      listeners?.splice(index, 1);
     }
 
-    if (listeners.length === 0) {
+    if (listeners?.length === 0) {
       this._events.delete(event);
     }
 
@@ -117,6 +121,7 @@ class EventEmitter {
     }
 
     const listeners = this._events.get(event);
+    if (!listeners) { return false; }
     const hasOnce = listeners.some(e => e.once);
     const iterList = hasOnce ? listeners.slice() : listeners;
 
@@ -169,7 +174,7 @@ class EventEmitter {
     if (!this._events.has(event)) {
       return 0;
     }
-    return this._events.get(event).length;
+    return this._events.get(event)?.length ?? 0;
   }
 
   /**