react-native-ble-mesh 2.1.0 → 2.1.2

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) {