react-native-ble-mesh 2.0.0 → 2.1.2

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);
     }
 
@@ -116,10 +117,12 @@ class EventEmitter {
       return false;
     }
 
-    const listeners = this._events.get(event).slice();
-    const toRemove = [];
+    const listeners = this._events.get(event);
+    if (!listeners) { return false; }
+    const hasOnce = listeners.some(e => e.once);
+    const iterList = hasOnce ? listeners.slice() : listeners;
 
-    for (const entry of listeners) {
+    for (const entry of iterList) {
       try {
         entry.listener.apply(this, args);
       } catch (error) {
@@ -130,15 +133,11 @@ class EventEmitter {
           console.error('Error in error handler:', error);
         }
       }
-
-      if (entry.once) {
-        toRemove.push(entry);
-      }
     }
 
     // Remove one-time listeners
-    if (toRemove.length > 0) {
-      const remaining = this._events.get(event).filter(e => !toRemove.includes(e));
+    if (hasOnce) {
+      const remaining = listeners.filter(e => !e.once);
       if (remaining.length === 0) {
         this._events.delete(event);
       } else {
@@ -172,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/bytes.js

@@ -11,9 +11,16 @@
  * @returns {Uint8Array} Concatenated array
  */
 function concat(...arrays) {
-  // Filter out undefined/null and calculate total length
-  const validArrays = arrays.filter(arr => arr !== null && arr !== undefined);
-  const totalLength = validArrays.reduce((sum, arr) => sum + arr.length, 0);
+  // Single-pass: filter out undefined/null and calculate total length
+  const validArrays = [];
+  let totalLength = 0;
+  for (let i = 0; i < arrays.length; i++) {
+    const arr = arrays[i];
+    if (arr !== null && arr !== undefined) {
+      validArrays.push(arr);
+      totalLength += arr.length;
+    }
+  }
 
   const result = new Uint8Array(totalLength);
   let offset = 0;
@@ -119,10 +126,7 @@ function xor(a, b) {
  * @returns {Uint8Array} The filled array (same reference)
  */
 function fill(array, value) {
-  const byte = value & 0xff;
-  for (let i = 0; i < array.length; i++) {
-    array[i] = byte;
-  }
+  array.fill(value & 0xff);
   return array;
 }
 
@@ -132,9 +136,7 @@ function fill(array, value) {
  * @returns {Uint8Array} Copy of the array
  */
 function copy(array) {
-  const result = new Uint8Array(array.length);
-  result.set(array);
-  return result;
+  return array.slice();
 }
 
 /**

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 };
@@ -57,6 +57,9 @@ class MessageCompressor {
       bytesIn: 0,
       bytesOut: 0
     };
+
+    // Pre-allocate hash table to avoid per-call allocation
+    this._hashTable = new Int32Array(this._config.hashTableSize);
   }
 
   /**
@@ -86,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);
@@ -129,7 +132,7 @@ class MessageCompressor {
 
   /**
      * Gets compression statistics.
-     * @returns {Object} Statistics
+     * @returns {any} Statistics
      */
   getStats() {
     const ratio = this._stats.bytesIn > 0
@@ -177,9 +180,8 @@ class MessageCompressor {
     output[outputPos++] = (inputLen >> 16) & 0xff;
     output[outputPos++] = (inputLen >> 24) & 0xff;
 
-    // Hash table for finding matches
-    // Using Knuth's multiplicative hash constant (2654435761) for good distribution
-    const hashTable = new Int32Array(this._config.hashTableSize);
+    // Reuse pre-allocated hash table, reset for this call
+    const hashTable = this._hashTable;
     hashTable.fill(-1);
 
     let anchor = 0;

package/src/utils/encoding.js

@@ -14,18 +14,47 @@ for (let i = 0; i < 16; i++) {
   HEX_LOOKUP[HEX_CHARS.toUpperCase().charCodeAt(i)] = i;
 }
 
+// Pre-computed byte-to-hex lookup table (avoids per-byte toString + padStart)
+const HEX_TABLE = new Array(256);
+for (let i = 0; i < 256; i++) {
+  HEX_TABLE[i] = HEX_CHARS[i >> 4] + HEX_CHARS[i & 0x0f];
+}
+
+// Cached TextEncoder/TextDecoder singletons (avoid per-call allocation)
+/** @type {any} */ let _cachedEncoder = null;
+/** @type {any} */ let _cachedDecoder = null;
+
+/**
+ * @returns {any}
+ */
+function _getEncoder() {
+  if (!_cachedEncoder && typeof TextEncoder !== 'undefined') {
+    _cachedEncoder = new TextEncoder();
+  }
+  return _cachedEncoder;
+}
+
+/**
+ * @returns {any}
+ */
+function _getDecoder() {
+  if (!_cachedDecoder && typeof TextDecoder !== 'undefined') {
+    _cachedDecoder = new TextDecoder();
+  }
+  return _cachedDecoder;
+}
+
 /**
  * Converts a byte array to a hexadecimal string
  * @param {Uint8Array} bytes - Bytes to convert
  * @returns {string} Hexadecimal string
  */
 function bytesToHex(bytes) {
-  let result = '';
+  const parts = new Array(bytes.length);
   for (let i = 0; i < bytes.length; i++) {
-    result += HEX_CHARS[bytes[i] >> 4];
-    result += HEX_CHARS[bytes[i] & 0x0f];
+    parts[i] = HEX_TABLE[bytes[i]];
   }
-  return result;
+  return parts.join('');
 }
 
 /**
@@ -62,8 +91,9 @@ function hexToBytes(hex) {
  * @returns {Uint8Array} UTF-8 encoded bytes
  */
 function stringToBytes(str) {
-  if (typeof TextEncoder !== 'undefined') {
-    return new TextEncoder().encode(str);
+  const encoder = _getEncoder();
+  if (encoder) {
+    return encoder.encode(str);
   }
 
   // Fallback for environments without TextEncoder
@@ -99,8 +129,9 @@ function stringToBytes(str) {
  * @returns {string} Decoded string
  */
 function bytesToString(bytes) {
-  if (typeof TextDecoder !== 'undefined') {
-    return new TextDecoder().decode(bytes);
+  const decoder = _getDecoder();
+  if (decoder) {
+    return decoder.decode(bytes);
   }
 
   // Fallback for environments without TextDecoder

package/src/utils/retry.js

@@ -7,7 +7,7 @@
 
 /**
  * Default retry options
- * @constant {Object}
+ * @constant {any}
  */
 const DEFAULT_OPTIONS = {
   maxRetries: 3,
@@ -21,7 +21,7 @@ const DEFAULT_OPTIONS = {
 /**
  * Calculates delay with optional jitter
  * @param {number} attempt - Current attempt number (0-based)
- * @param {Object} options - Retry options
+ * @param {any} options - Retry options
  * @returns {number} Delay in milliseconds
  * @private
  */
@@ -46,13 +46,10 @@ function calculateDelay(attempt, options) {
  * Retries an async function with exponential backoff
  * @template T
  * @param {function(): Promise<T>} fn - Async function to retry
- * @param {Object} [options] - Retry options
- * @param {number} [options.maxRetries=3] - Maximum number of retries
- * @param {number} [options.initialDelay=100] - Initial delay in milliseconds
- * @param {number} [options.maxDelay=10000] - Maximum delay in milliseconds
- * @param {number} [options.factor=2] - Exponential factor
- * @param {boolean} [options.jitter=true] - Add randomness to delays
+ * @param {any} [options] - Retry options   *
+ * @param {object} options
  * @param {function(Error, number): boolean} [options.shouldRetry] - Predicate to determine if should retry
+ * @param {object} options
  * @param {function(Error, number): void} [options.onRetry] - Callback on each retry
  * @returns {Promise<T>} Result of the function
  * @throws {Error} Last error if all retries fail
@@ -66,7 +63,7 @@ async function retry(fn, options = {}) {
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
     try {
       return await fn();
-    } catch (error) {
+    } catch (/** @type {any} */ error) {
       lastError = error;
 
       // Check if we should retry
@@ -94,11 +91,12 @@ async function retry(fn, options = {}) {
  * Creates a retryable version of an async function
  * @template T
  * @param {function(...*): Promise<T>} fn - Async function to wrap
- * @param {Object} [options] - Retry options
+ * @param {any} [options] - Retry options
  * @returns {function(...*): Promise<T>} Wrapped function with retry logic
  */
 function retryable(fn, options = {}) {
   return function retryableFn(...args) {
+    // @ts-ignore
     return retry(() => fn.apply(this, args), options);
   };
 }
@@ -109,7 +107,7 @@ function retryable(fn, options = {}) {
  * @returns {function(Error): boolean} Predicate function
  */
 function retryOn(errorTypes) {
-  return (error) => {
+  return (/** @type {any} */ error) => {
     return errorTypes.some(ErrorType => error instanceof ErrorType);
   };
 }
@@ -120,7 +118,7 @@ function retryOn(errorTypes) {
  * @returns {function(Error): boolean} Predicate function
  */
 function retryExcept(errorTypes) {
-  return (error) => {
+  return (/** @type {any} */ error) => {
     return !errorTypes.some(ErrorType => error instanceof ErrorType);
   };
 }
@@ -131,7 +129,7 @@ function retryExcept(errorTypes) {
  * @returns {function(Error): boolean} Predicate function
  */
 function retryOnCodes(codes) {
-  return (error) => {
+  return (/** @type {any} */ error) => {
     return error.code && codes.includes(error.code);
   };
 }

package/src/utils/time.js

@@ -23,8 +23,9 @@ function delay(ms) {
  * @returns {Promise<T>} Promise that rejects on timeout
  */
 function withTimeout(promise, ms, message = 'Operation timed out') {
-  let timeoutId;
+  /** @type {any} */ let timeoutId;
 
+  /** @type {Promise<T>} */
   const timeoutPromise = new Promise((_, reject) => {
     timeoutId = setTimeout(() => {
       reject(new Error(message));
@@ -32,10 +33,10 @@ function withTimeout(promise, ms, message = 'Operation timed out') {
   });
 
   return Promise.race([
-    promise.then(result => {
+    promise.then((/** @type {T} */ result) => {
       clearTimeout(timeoutId);
       return result;
-    }).catch(error => {
+    }).catch((/** @type {any} */ error) => {
       clearTimeout(timeoutId);
       throw error;
     }),
@@ -57,7 +58,9 @@ function now() {
  * @returns {number} High-resolution timestamp
  */
 function hrTime() {
+  // @ts-ignore - performance may be available in some environments
   if (typeof performance !== 'undefined' && performance.now) {
+    // @ts-ignore
     return performance.now();
   }
   return Date.now();
@@ -119,7 +122,7 @@ function formatDuration(ms) {
  * @returns {function(...*): void} Debounced function
  */
 function debounce(fn, waitMs) {
-  let timeoutId = null;
+  /** @type {any} */ let timeoutId = null;
 
   return function debounced(...args) {
     if (timeoutId !== null) {
@@ -128,6 +131,7 @@ function debounce(fn, waitMs) {
 
     timeoutId = setTimeout(() => {
       timeoutId = null;
+      // @ts-ignore
       fn.apply(this, args);
     }, waitMs);
   };
@@ -148,6 +152,7 @@ function throttle(fn, intervalMs) {
 
     if (currentTime - lastCall >= intervalMs) {
       lastCall = currentTime;
+      // @ts-ignore
       return fn.apply(this, args);
     }
   };

package/src/utils/validation.js

@@ -74,7 +74,7 @@ function validatePositiveInt(value, name) {
  * Validates that a value is one of the allowed values
  * @param {*} value - Value to validate
  * @param {string} name - Name of the parameter for error messages
- * @param {Array} allowed - Array of allowed values
+ * @param {any[]} allowed - Array of allowed values
  * @throws {ValidationError} If value is not in allowed list
  */
 function validateEnum(value, name, allowed) {