react-native-ble-mesh 2.0.0 → 2.1.2

package/src/transport/MultiTransport.js

@@ -16,7 +16,7 @@ const Transport = require('./Transport');
 
 /**
  * Transport selection strategies
- * @constant {Object}
+ * @constant {any}
  */
 const STRATEGY = Object.freeze({
   /** Always use BLE */
@@ -45,6 +45,7 @@ class MultiTransport extends Transport {
    * @param {number} [options.wifiThresholdBytes=1024] - Use Wi-Fi Direct for payloads above this size
    */
   constructor(options = {}) {
+    // @ts-ignore
     super(options);
 
     this._bleTransport = options.bleTransport || null;
@@ -54,6 +55,9 @@ class MultiTransport extends Transport {
 
     /** @type {Map<string, string>} peerId → preferred transport name */
     this._peerTransportMap = new Map();
+
+    /** @type {Array<{transport: Transport, event: string, handler: Function}>} */
+    this._wiredHandlers = [];
   }
 
   /**
@@ -80,6 +84,7 @@ class MultiTransport extends Transport {
     if (this._bleTransport) {
       startPromises.push(
         this._bleTransport.start()
+          // @ts-ignore
           .then(() => this._wireTransport(this._bleTransport, 'ble'))
           .catch(err => {
             this.emit('transportError', { transport: 'ble', error: err });
@@ -90,6 +95,7 @@ class MultiTransport extends Transport {
     if (this._wifiTransport) {
       startPromises.push(
         this._wifiTransport.start()
+          // @ts-ignore
           .then(() => this._wireTransport(this._wifiTransport, 'wifi-direct'))
           .catch(err => {
             this.emit('transportError', { transport: 'wifi-direct', error: err });
@@ -122,6 +128,13 @@ class MultiTransport extends Transport {
     if (this._wifiTransport) { stopPromises.push(this._wifiTransport.stop().catch(() => {})); }
 
     await Promise.allSettled(stopPromises);
+
+    // Remove wired event handlers to prevent listener leaks
+    for (const { transport, event, handler } of this._wiredHandlers) {
+      transport.off(event, handler);
+    }
+    this._wiredHandlers = [];
+
     this._peers.clear();
     this._peerTransportMap.clear();
     this._setState(Transport.STATE.STOPPED);
@@ -160,6 +173,7 @@ class MultiTransport extends Transport {
     if (!this.isRunning) { throw new Error('Transport is not running'); }
 
     const allPeerIds = new Set();
+    /** @type {string[]} */
     const successPeerIds = [];
 
     // Collect all peers from all transports
@@ -181,6 +195,7 @@ class MultiTransport extends Transport {
       if (r.status === 'fulfilled') { successPeerIds.push(r.value); }
     });
 
+    // @ts-ignore
     return successPeerIds;
   }
 
@@ -218,9 +233,11 @@ class MultiTransport extends Transport {
   _selectTransport(peerId, dataSize) {
     switch (this._strategy) {
       case STRATEGY.BLE_ONLY:
+        // @ts-ignore
         return this._bleTransport;
 
       case STRATEGY.WIFI_ONLY:
+        // @ts-ignore
         return this._wifiTransport;
 
       case STRATEGY.AUTO:
@@ -272,13 +289,13 @@ class MultiTransport extends Transport {
    * @private
    */
   _wireTransport(transport, name) {
-    transport.on('peerConnected', (info) => {
+    const onPeerConnected = (/** @type {any} */ info) => {
       this._peerTransportMap.set(info.peerId, name);
       this._peers.set(info.peerId, { ...info, transport: name });
       this.emit('peerConnected', { ...info, transport: name });
-    });
+    };
 
-    transport.on('peerDisconnected', (info) => {
+    const onPeerDisconnected = (/** @type {any} */ info) => {
       // Only remove if no other transport has this peer
       const otherTransport = this._getFallbackTransport(transport);
       if (!otherTransport || !otherTransport.isConnected(info.peerId)) {
@@ -286,19 +303,34 @@ class MultiTransport extends Transport {
         this._peerTransportMap.delete(info.peerId);
         this.emit('peerDisconnected', { ...info, transport: name });
       }
-    });
+    };
 
-    transport.on('message', (msg) => {
+    const onMessage = (/** @type {any} */ msg) => {
       this.emit('message', { ...msg, transport: name });
-    });
+    };
 
-    transport.on('deviceDiscovered', (info) => {
+    const onDeviceDiscovered = (/** @type {any} */ info) => {
       this.emit('deviceDiscovered', { ...info, transport: name });
-    });
+    };
 
-    transport.on('error', (err) => {
+    const onError = (/** @type {any} */ err) => {
       this.emit('transportError', { transport: name, error: err });
-    });
+    };
+
+    transport.on('peerConnected', onPeerConnected);
+    transport.on('peerDisconnected', onPeerDisconnected);
+    transport.on('message', onMessage);
+    transport.on('deviceDiscovered', onDeviceDiscovered);
+    transport.on('error', onError);
+
+    // Store references for cleanup
+    this._wiredHandlers.push(
+      { transport, event: 'peerConnected', handler: onPeerConnected },
+      { transport, event: 'peerDisconnected', handler: onPeerDisconnected },
+      { transport, event: 'message', handler: onMessage },
+      { transport, event: 'deviceDiscovered', handler: onDeviceDiscovered },
+      { transport, event: 'error', handler: onError }
+    );
   }
 }
 

package/src/transport/Transport.js

@@ -9,7 +9,7 @@ const EventEmitter = require('../utils/EventEmitter');
 
 /**
  * Transport states
- * @constant {Object.<string, string>}
+ * @type {Record<string, string>}
  */
 const TRANSPORT_STATE = Object.freeze({
   STOPPED: 'stopped',
@@ -44,7 +44,7 @@ class Transport extends EventEmitter {
 
     /**
      * Transport options
-     * @type {Object}
+     * @type {any}
      * @protected
      */
     this._options = {
@@ -61,7 +61,7 @@ class Transport extends EventEmitter {
 
     /**
      * Connected peers map (peerId -> connection info)
-     * @type {Map<string, Object>}
+     * @type {Map<string, any>}
      * @protected
      */
     this._peers = new Map();
@@ -119,23 +119,23 @@ class Transport extends EventEmitter {
   /**
    * Sends data to a specific peer
    * @abstract
-   * @param {string} peerId - Target peer ID
-   * @param {Uint8Array} data - Data to send
+   * @param {string} _peerId - Target peer ID
+   * @param {Uint8Array} _data - Data to send
    * @returns {Promise<void>}
    * @throws {Error} If not implemented by subclass
    */
-  async send(_peerId, _data) {
+  async send(/** @type {any} */ _peerId, _data) {
     throw new Error('Transport.send() must be implemented by subclass');
   }
 
   /**
    * Broadcasts data to all connected peers
    * @abstract
-   * @param {Uint8Array} data - Data to broadcast
+   * @param {Uint8Array} _data - Data to broadcast
    * @returns {Promise<string[]>} Array of peer IDs that received the broadcast
    * @throws {Error} If not implemented by subclass
    */
-  async broadcast(_data) {
+  async broadcast(/** @type {any} */ _data) {
     throw new Error('Transport.broadcast() must be implemented by subclass');
   }
 
@@ -159,7 +159,7 @@ class Transport extends EventEmitter {
   /**
    * Gets connection info for a peer
    * @param {string} peerId - Peer ID
-   * @returns {Object|undefined} Connection info or undefined
+   * @returns {any} Connection info or undefined
    */
   getPeerInfo(peerId) {
     return this._peers.get(peerId);

package/src/transport/WiFiDirectTransport.js

@@ -13,7 +13,7 @@ const { ConnectionError } = require('../errors');
 
 /**
  * Wi-Fi Direct transport states
- * @constant {Object}
+ * @constant {any}
  */
 const WIFI_DIRECT_STATE = Object.freeze({
   AVAILABLE: 'available',
@@ -46,6 +46,7 @@ class WiFiDirectTransport extends Transport {
     this._isDiscovering = false;
     this._isGroupOwner = false;
     this._groupInfo = null;
+    /** @type {any} */
     this._subscriptions = [];
   }
 
@@ -75,16 +76,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 +108,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 +133,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 +147,7 @@ class WiFiDirectTransport extends Transport {
 
     const p2p = this._getWifiP2p();
     try {
-      await p2p.stopDiscoveringPeers();
+      await p2p?.stopDiscoveringPeers();
     } catch (e) {
       // Ignore
     }
@@ -173,9 +174,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 +188,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 +203,7 @@ class WiFiDirectTransport extends Transport {
 
     const p2p = this._getWifiP2p();
     try {
-      await p2p.removeGroup();
+      await p2p?.removeGroup();
     } catch (e) {
       // Ignore
     }
@@ -231,10 +232,10 @@ class WiFiDirectTransport extends Transport {
 
     if (this._isGroupOwner) {
       // Group owner sends via server socket
-      await p2p.sendMessage(base64);
+      await p2p?.sendMessage(base64);
     } else {
       // Client sends to group owner address
-      await p2p.sendMessageTo(peerInfo.groupOwnerAddress, this._port, base64);
+      await p2p?.sendMessageTo(peerInfo.groupOwnerAddress, this._port, base64);
     }
   }
 
@@ -261,16 +262,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,11 +288,12 @@ class WiFiDirectTransport extends Transport {
   }
 
   /** @private */
-  _uint8ArrayToBase64(bytes) {
-    let binary = '';
-    for (let i = 0; i < bytes.length; i++) {
-      binary += String.fromCharCode(bytes[i]);
+  _uint8ArrayToBase64(/** @type {any} */ 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');
   }
 }

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(); }
       });
     });