react-native-ble-mesh 2.1.0 → 2.1.3

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,11 +89,9 @@ 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);
-      }
+      // Compression failure is non-fatal — silently fall back to uncompressed
     }
 
     this._stats.bytesOut += payload.length;
@@ -132,7 +130,7 @@ class MessageCompressor {
 
   /**
      * Gets compression statistics.
-     * @returns {Object} Statistics
+     * @returns {any} Statistics
      */
   getStats() {
     const ratio = this._stats.bytesIn > 0

package/src/utils/encoding.js

@@ -21,9 +21,12 @@ for (let i = 0; i < 256; i++) {
 }
 
 // Cached TextEncoder/TextDecoder singletons (avoid per-call allocation)
-let _cachedEncoder = null;
-let _cachedDecoder = null;
+/** @type {any} */ let _cachedEncoder = null;
+/** @type {any} */ let _cachedDecoder = null;
 
+/**
+ * @returns {any}
+ */
 function _getEncoder() {
   if (!_cachedEncoder && typeof TextEncoder !== 'undefined') {
     _cachedEncoder = new TextEncoder();
@@ -31,6 +34,9 @@ function _getEncoder() {
   return _cachedEncoder;
 }
 
+/**
+ * @returns {any}
+ */
 function _getDecoder() {
   if (!_cachedDecoder && typeof TextDecoder !== 'undefined') {
     _cachedDecoder = new 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) {