react-native-ble-mesh 2.1.0 → 2.1.2

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,7 +288,7 @@ class WiFiDirectTransport extends Transport {
   }
 
   /** @private */
-  _uint8ArrayToBase64(bytes) {
+  _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))));

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

@@ -21,14 +21,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 +45,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 +97,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 +110,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 +119,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 +177,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 +295,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 +331,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;
   }
 
   /**

package/src/utils/EventEmitter.js

@@ -12,8 +12,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,6 +47,7 @@ class EventEmitter {
     }
 
     const listeners = this._events.get(event);
+    if (!listeners) { return this; }
 
     // Warn if max listeners exceeded
     if (listeners.length >= this._maxListeners) {
@@ -76,7 +77,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 +93,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 +118,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 +171,7 @@ class EventEmitter {
     if (!this._events.has(event)) {
       return 0;
     }
-    return this._events.get(event).length;
+    return this._events.get(event)?.length ?? 0;
   }
 
   /**

package/src/utils/LRUCache.js

@@ -47,7 +47,7 @@ class LRUCache {
     }
 
     // Move to end (most recently used)
-    const value = this._cache.get(key);
+    const value = /** @type {V} */ (this._cache.get(key));
     this._cache.delete(key);
     this._cache.set(key, value);
 
@@ -67,7 +67,9 @@ class LRUCache {
     } else if (this._cache.size >= this._maxSize) {
       // Remove least recently used (first item)
       const firstKey = this._cache.keys().next().value;
-      this._cache.delete(firstKey);
+      if (firstKey !== undefined) {
+        this._cache.delete(firstKey);
+      }
     }
 
     this._cache.set(key, value);
@@ -134,7 +136,7 @@ class LRUCache {
 
   /**
    * Returns all entries in the cache (most recent last)
-   * @returns {Array} Array of [key, value] pairs
+   * @returns {any[]} Array of [key, value] pairs
    */
   entries() {
     return Array.from(this._cache.entries());
@@ -194,7 +196,11 @@ class LRUCache {
     // Evict oldest items if over new limit
     while (this._cache.size > this._maxSize) {
       const firstKey = this._cache.keys().next().value;
-      this._cache.delete(firstKey);
+      if (firstKey !== undefined) {
+        this._cache.delete(firstKey);
+      } else {
+        break;
+      }
     }
   }
 }

package/src/utils/RateLimiter.js

@@ -162,7 +162,7 @@ class RateLimiter {
 
   /**
    * Gets rate limiter configuration
-   * @returns {Object} Configuration object
+   * @returns {any} Configuration object
    */
   getConfig() {
     return {

package/src/utils/compression.js

@@ -15,7 +15,7 @@ const { ValidationError, MeshError } = require('../errors');
 
 /**
  * Default compression configuration
- * @constant {Object}
+ * @constant {any}
  */
 const DEFAULT_CONFIG = Object.freeze({
   /** Minimum payload size to compress (bytes) */
@@ -45,8 +45,8 @@ const DEFAULT_CONFIG = Object.freeze({
 class MessageCompressor {
   /**
      * Creates a new MessageCompressor instance.
-     * @param {Object} [options={}] - Compression options
-     * @param {number} [options.threshold=100] - Min size to compress
+     * @param {any} [options={}] - Compression options
+   *
      */
   constructor(options = {}) {
     this._config = { ...DEFAULT_CONFIG, ...options };
@@ -89,7 +89,7 @@ class MessageCompressor {
         this._stats.bytesOut += compressed.length;
         return { data: compressed, compressed: true };
       }
-    } catch (error) {
+    } catch (/** @type {any} */ error) {
       // Log compression error at debug level for troubleshooting
       if (typeof console !== 'undefined' && console.debug) {
         console.debug('Compression failed, using uncompressed:', error.message);
@@ -132,7 +132,7 @@ class MessageCompressor {
 
   /**
      * Gets compression statistics.
-     * @returns {Object} Statistics
+     * @returns {any} Statistics
      */
   getStats() {
     const ratio = this._stats.bytesIn > 0