react-native-ble-mesh 1.0.1

package/src/utils/encoding.js

@@ -0,0 +1,248 @@
+'use strict';
+
+/**
+ * @fileoverview Encoding conversion utilities
+ * @module utils/encoding
+ */
+
+/**
+ * Lookup tables for hex encoding
+ * @private
+ */
+const HEX_CHARS = '0123456789abcdef';
+const HEX_LOOKUP = new Uint8Array(256);
+
+// Initialize hex lookup table
+for (let i = 0; i < 16; i++) {
+  HEX_LOOKUP[HEX_CHARS.charCodeAt(i)] = i;
+  HEX_LOOKUP[HEX_CHARS.toUpperCase().charCodeAt(i)] = i;
+}
+
+/**
+ * Converts a byte array to a hexadecimal string
+ * @param {Uint8Array} bytes - Bytes to convert
+ * @returns {string} Hexadecimal string
+ */
+function bytesToHex(bytes) {
+  let result = '';
+  for (let i = 0; i < bytes.length; i++) {
+    result += HEX_CHARS[bytes[i] >> 4];
+    result += HEX_CHARS[bytes[i] & 0x0f];
+  }
+  return result;
+}
+
+/**
+ * Converts a hexadecimal string to a byte array
+ * @param {string} hex - Hexadecimal string
+ * @returns {Uint8Array} Byte array
+ * @throws {Error} If hex string has invalid length or characters
+ */
+function hexToBytes(hex) {
+  if (typeof hex !== 'string') {
+    throw new Error('Input must be a string');
+  }
+
+  // Remove optional 0x prefix
+  if (hex.startsWith('0x') || hex.startsWith('0X')) {
+    hex = hex.slice(2);
+  }
+
+  if (hex.length % 2 !== 0) {
+    throw new Error('Hex string must have even length');
+  }
+
+  const bytes = new Uint8Array(hex.length / 2);
+
+  for (let i = 0; i < bytes.length; i++) {
+    const hi = HEX_LOOKUP[hex.charCodeAt(i * 2)];
+    const lo = HEX_LOOKUP[hex.charCodeAt(i * 2 + 1)];
+
+    if (hi === undefined || lo === undefined) {
+      throw new Error(`Invalid hex character at position ${i * 2}`);
+    }
+
+    bytes[i] = (hi << 4) | lo;
+  }
+
+  return bytes;
+}
+
+/**
+ * Base64 character set
+ * @private
+ */
+const BASE64_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const BASE64_LOOKUP = new Uint8Array(256);
+
+// Initialize base64 lookup table
+for (let i = 0; i < BASE64_CHARS.length; i++) {
+  BASE64_LOOKUP[BASE64_CHARS.charCodeAt(i)] = i;
+}
+
+/**
+ * Converts a byte array to a Base64 string
+ * @param {Uint8Array} bytes - Bytes to convert
+ * @returns {string} Base64 string
+ */
+function bytesToBase64(bytes) {
+  let result = '';
+  const len = bytes.length;
+  const remainder = len % 3;
+
+  // Process 3 bytes at a time
+  for (let i = 0; i < len - remainder; i += 3) {
+    const n = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2];
+    result += BASE64_CHARS[(n >> 18) & 0x3f];
+    result += BASE64_CHARS[(n >> 12) & 0x3f];
+    result += BASE64_CHARS[(n >> 6) & 0x3f];
+    result += BASE64_CHARS[n & 0x3f];
+  }
+
+  // Handle remainder
+  if (remainder === 1) {
+    const n = bytes[len - 1];
+    result += BASE64_CHARS[(n >> 2) & 0x3f];
+    result += BASE64_CHARS[(n << 4) & 0x3f];
+    result += '==';
+  } else if (remainder === 2) {
+    const n = (bytes[len - 2] << 8) | bytes[len - 1];
+    result += BASE64_CHARS[(n >> 10) & 0x3f];
+    result += BASE64_CHARS[(n >> 4) & 0x3f];
+    result += BASE64_CHARS[(n << 2) & 0x3f];
+    result += '=';
+  }
+
+  return result;
+}
+
+/**
+ * Converts a Base64 string to a byte array
+ * @param {string} base64 - Base64 string
+ * @returns {Uint8Array} Byte array
+ * @throws {Error} If base64 string is invalid
+ */
+function base64ToBytes(base64) {
+  if (typeof base64 !== 'string') {
+    throw new Error('Input must be a string');
+  }
+
+  // Remove padding and calculate length
+  let paddingLength = 0;
+  if (base64.endsWith('==')) {
+    paddingLength = 2;
+  } else if (base64.endsWith('=')) {
+    paddingLength = 1;
+  }
+
+  const len = base64.length;
+  const outputLength = (len * 3) / 4 - paddingLength;
+  const bytes = new Uint8Array(outputLength);
+
+  let j = 0;
+  for (let i = 0; i < len; i += 4) {
+    const a = BASE64_LOOKUP[base64.charCodeAt(i)];
+    const b = BASE64_LOOKUP[base64.charCodeAt(i + 1)];
+    const c = BASE64_LOOKUP[base64.charCodeAt(i + 2)];
+    const d = BASE64_LOOKUP[base64.charCodeAt(i + 3)];
+
+    bytes[j++] = (a << 2) | (b >> 4);
+    if (j < outputLength) { bytes[j++] = ((b & 0x0f) << 4) | (c >> 2); }
+    if (j < outputLength) { bytes[j++] = ((c & 0x03) << 6) | d; }
+  }
+
+  return bytes;
+}
+
+/**
+ * Converts a UTF-8 string to a byte array
+ * @param {string} str - String to convert
+ * @returns {Uint8Array} UTF-8 encoded bytes
+ */
+function stringToBytes(str) {
+  if (typeof TextEncoder !== 'undefined') {
+    return new TextEncoder().encode(str);
+  }
+
+  // Fallback for environments without TextEncoder
+  const bytes = [];
+  for (let i = 0; i < str.length; i++) {
+    let code = str.charCodeAt(i);
+
+    if (code < 0x80) {
+      bytes.push(code);
+    } else if (code < 0x800) {
+      bytes.push(0xc0 | (code >> 6));
+      bytes.push(0x80 | (code & 0x3f));
+    } else if (code < 0xd800 || code >= 0xe000) {
+      bytes.push(0xe0 | (code >> 12));
+      bytes.push(0x80 | ((code >> 6) & 0x3f));
+      bytes.push(0x80 | (code & 0x3f));
+    } else {
+      // Surrogate pair
+      i++;
+      code = 0x10000 + (((code & 0x3ff) << 10) | (str.charCodeAt(i) & 0x3ff));
+      bytes.push(0xf0 | (code >> 18));
+      bytes.push(0x80 | ((code >> 12) & 0x3f));
+      bytes.push(0x80 | ((code >> 6) & 0x3f));
+      bytes.push(0x80 | (code & 0x3f));
+    }
+  }
+
+  return new Uint8Array(bytes);
+}
+
+/**
+ * Converts a UTF-8 byte array to a string
+ * @param {Uint8Array} bytes - UTF-8 encoded bytes
+ * @returns {string} Decoded string
+ */
+function bytesToString(bytes) {
+  if (typeof TextDecoder !== 'undefined') {
+    return new TextDecoder().decode(bytes);
+  }
+
+  // Fallback for environments without TextDecoder
+  let result = '';
+  let i = 0;
+
+  while (i < bytes.length) {
+    const byte1 = bytes[i++];
+
+    if (byte1 < 0x80) {
+      result += String.fromCharCode(byte1);
+    } else if (byte1 < 0xe0) {
+      const byte2 = bytes[i++];
+      result += String.fromCharCode(((byte1 & 0x1f) << 6) | (byte2 & 0x3f));
+    } else if (byte1 < 0xf0) {
+      const byte2 = bytes[i++];
+      const byte3 = bytes[i++];
+      result += String.fromCharCode(
+        ((byte1 & 0x0f) << 12) | ((byte2 & 0x3f) << 6) | (byte3 & 0x3f)
+      );
+    } else {
+      const byte2 = bytes[i++];
+      const byte3 = bytes[i++];
+      const byte4 = bytes[i++];
+      const codePoint =
+        ((byte1 & 0x07) << 18) |
+        ((byte2 & 0x3f) << 12) |
+        ((byte3 & 0x3f) << 6) |
+        (byte4 & 0x3f);
+      // Convert to surrogate pair
+      const adjusted = codePoint - 0x10000;
+      result += String.fromCharCode(0xd800 + (adjusted >> 10), 0xdc00 + (adjusted & 0x3ff));
+    }
+  }
+
+  return result;
+}
+
+module.exports = {
+  bytesToHex,
+  hexToBytes,
+  bytesToBase64,
+  base64ToBytes,
+  stringToBytes,
+  bytesToString
+};

package/src/utils/index.js

@@ -0,0 +1,106 @@
+'use strict';
+
+/**
+ * @fileoverview Utility module exports
+ * @module utils
+ */
+
+const bytes = require('./bytes');
+const encoding = require('./encoding');
+const uuid = require('./uuid');
+const time = require('./time');
+const validation = require('./validation');
+const EventEmitter = require('./EventEmitter');
+const LRUCache = require('./LRUCache');
+const RateLimiter = require('./RateLimiter');
+const retry = require('./retry');
+const debug = require('./debug');
+const BoundedMap = require('./BoundedMap');
+const TimeoutManager = require('./TimeoutManager');
+const base64 = require('./base64');
+
+module.exports = {
+  // Byte manipulation
+  concat: bytes.concat,
+  constantTimeEqual: bytes.constantTimeEqual,
+  randomBytes: bytes.randomBytes,
+  xor: bytes.xor,
+  fill: bytes.fill,
+  copy: bytes.copy,
+  secureWipe: bytes.secureWipe,
+  equals: bytes.equals,
+  slice: bytes.slice,
+
+  // Encoding
+  bytesToHex: encoding.bytesToHex,
+  hexToBytes: encoding.hexToBytes,
+  bytesToBase64: encoding.bytesToBase64,
+  base64ToBytes: encoding.base64ToBytes,
+  stringToBytes: encoding.stringToBytes,
+  bytesToString: encoding.bytesToString,
+
+  // UUID
+  generateUUID: uuid.generateUUID,
+  uuidToBytes: uuid.uuidToBytes,
+  bytesToUuid: uuid.bytesToUuid,
+  isValidUUID: uuid.isValidUUID,
+  generateShortId: uuid.generateShortId,
+  shortenUUID: uuid.shortenUUID,
+  compareUUID: uuid.compareUUID,
+
+  // Time
+  delay: time.delay,
+  withTimeout: time.withTimeout,
+  now: time.now,
+  hrTime: time.hrTime,
+  elapsed: time.elapsed,
+  isExpired: time.isExpired,
+  formatDuration: time.formatDuration,
+  debounce: time.debounce,
+  throttle: time.throttle,
+
+  // Validation
+  validateString: validation.validateString,
+  validateBytes: validation.validateBytes,
+  validatePositiveInt: validation.validatePositiveInt,
+  validateEnum: validation.validateEnum,
+  validateNonNegativeInt: validation.validateNonNegativeInt,
+  validateRange: validation.validateRange,
+  validateBoolean: validation.validateBoolean,
+  validateFunction: validation.validateFunction,
+  validateObject: validation.validateObject,
+  validateOptional: validation.validateOptional,
+
+  // Classes
+  EventEmitter,
+  LRUCache,
+  RateLimiter,
+  BoundedMap,
+  TimeoutManager,
+
+  // Optimized Base64 (for React Native)
+  base64Encode: base64.encode,
+  base64Decode: base64.decode,
+  isValidBase64: base64.isValid,
+
+  // Retry
+  retry: retry.retry,
+  retryable: retry.retryable,
+  retryOn: retry.retryOn,
+  retryExcept: retry.retryExcept,
+  retryOnCodes: retry.retryOnCodes,
+
+  // Debug
+  debug,
+  createDebugger: debug.createDebugger,
+  enableDebug: debug.enable,
+  disableDebug: debug.disable,
+
+  // Sub-modules (for specific imports)
+  bytes,
+  encoding,
+  uuid,
+  time,
+  validation,
+  base64
+};

package/src/utils/retry.js

@@ -0,0 +1,146 @@
+'use strict';
+
+/**
+ * @fileoverview Retry utilities with exponential backoff
+ * @module utils/retry
+ */
+
+/**
+ * Default retry options
+ * @constant {Object}
+ */
+const DEFAULT_OPTIONS = {
+  maxRetries: 3,
+  initialDelay: 100,
+  maxDelay: 10000,
+  factor: 2,
+  jitter: true,
+  shouldRetry: () => true
+};
+
+/**
+ * Calculates delay with optional jitter
+ * @param {number} attempt - Current attempt number (0-based)
+ * @param {Object} options - Retry options
+ * @returns {number} Delay in milliseconds
+ * @private
+ */
+function calculateDelay(attempt, options) {
+  const { initialDelay, maxDelay, factor, jitter } = options;
+
+  // Exponential backoff
+  let delay = initialDelay * Math.pow(factor, attempt);
+
+  // Cap at max delay
+  delay = Math.min(delay, maxDelay);
+
+  // Add jitter (0 to 100% of delay)
+  if (jitter) {
+    delay = delay * (0.5 + Math.random());
+  }
+
+  return Math.floor(delay);
+}
+
+/**
+ * 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 {function(Error, number): boolean} [options.shouldRetry] - Predicate to determine if should retry
+ * @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
+ */
+async function retry(fn, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const { maxRetries, shouldRetry, onRetry } = opts;
+
+  let lastError;
+
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+
+      // Check if we should retry
+      if (attempt >= maxRetries || !shouldRetry(error, attempt)) {
+        throw error;
+      }
+
+      // Calculate delay
+      const delay = calculateDelay(attempt, opts);
+
+      // Call onRetry callback if provided
+      if (onRetry) {
+        onRetry(error, attempt);
+      }
+
+      // Wait before retrying
+      await new Promise(resolve => setTimeout(resolve, delay));
+    }
+  }
+
+  throw lastError;
+}
+
+/**
+ * Creates a retryable version of an async function
+ * @template T
+ * @param {function(...*): Promise<T>} fn - Async function to wrap
+ * @param {Object} [options] - Retry options
+ * @returns {function(...*): Promise<T>} Wrapped function with retry logic
+ */
+function retryable(fn, options = {}) {
+  return function retryableFn(...args) {
+    return retry(() => fn.apply(this, args), options);
+  };
+}
+
+/**
+ * Retry predicate that retries on specific error types
+ * @param {Array<Function>} errorTypes - Error constructors to retry on
+ * @returns {function(Error): boolean} Predicate function
+ */
+function retryOn(errorTypes) {
+  return (error) => {
+    return errorTypes.some(ErrorType => error instanceof ErrorType);
+  };
+}
+
+/**
+ * Retry predicate that does not retry on specific error types
+ * @param {Array<Function>} errorTypes - Error constructors to not retry on
+ * @returns {function(Error): boolean} Predicate function
+ */
+function retryExcept(errorTypes) {
+  return (error) => {
+    return !errorTypes.some(ErrorType => error instanceof ErrorType);
+  };
+}
+
+/**
+ * Retry predicate that retries on specific error codes
+ * @param {Array<string>} codes - Error codes to retry on
+ * @returns {function(Error): boolean} Predicate function
+ */
+function retryOnCodes(codes) {
+  return (error) => {
+    return error.code && codes.includes(error.code);
+  };
+}
+
+module.exports = {
+  retry,
+  retryable,
+  retryOn,
+  retryExcept,
+  retryOnCodes,
+  DEFAULT_OPTIONS
+};

package/src/utils/time.js

@@ -0,0 +1,166 @@
+'use strict';
+
+/**
+ * @fileoverview Time-related utilities
+ * @module utils/time
+ */
+
+/**
+ * Returns a promise that resolves after the specified delay
+ * @param {number} ms - Delay in milliseconds
+ * @returns {Promise<void>} Promise that resolves after delay
+ */
+function delay(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Wraps a promise with a timeout
+ * @template T
+ * @param {Promise<T>} promise - Promise to wrap
+ * @param {number} ms - Timeout in milliseconds
+ * @param {string} [message='Operation timed out'] - Error message on timeout
+ * @returns {Promise<T>} Promise that rejects on timeout
+ */
+function withTimeout(promise, ms, message = 'Operation timed out') {
+  let timeoutId;
+
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => {
+      reject(new Error(message));
+    }, ms);
+  });
+
+  return Promise.race([
+    promise.then(result => {
+      clearTimeout(timeoutId);
+      return result;
+    }).catch(error => {
+      clearTimeout(timeoutId);
+      throw error;
+    }),
+    timeoutPromise
+  ]);
+}
+
+/**
+ * Returns the current timestamp in milliseconds
+ * @returns {number} Current timestamp in milliseconds since epoch
+ */
+function now() {
+  return Date.now();
+}
+
+/**
+ * Returns a high-resolution timestamp for performance measurements
+ * Falls back to Date.now() if performance API is not available
+ * @returns {number} High-resolution timestamp
+ */
+function hrTime() {
+  if (typeof performance !== 'undefined' && performance.now) {
+    return performance.now();
+  }
+  return Date.now();
+}
+
+/**
+ * Calculates time elapsed since a given timestamp
+ * @param {number} startTime - Start timestamp
+ * @returns {number} Elapsed time in milliseconds
+ */
+function elapsed(startTime) {
+  return now() - startTime;
+}
+
+/**
+ * Checks if a timestamp has expired based on a TTL
+ * @param {number} timestamp - Timestamp to check
+ * @param {number} ttlMs - Time-to-live in milliseconds
+ * @returns {boolean} True if timestamp has expired
+ */
+function isExpired(timestamp, ttlMs) {
+  return now() > timestamp + ttlMs;
+}
+
+/**
+ * Formats a duration in milliseconds to a human-readable string
+ * @param {number} ms - Duration in milliseconds
+ * @returns {string} Formatted duration (e.g., "5m 30s")
+ */
+function formatDuration(ms) {
+  if (ms < 1000) {
+    return `${ms}ms`;
+  }
+
+  const seconds = Math.floor(ms / 1000) % 60;
+  const minutes = Math.floor(ms / 60000) % 60;
+  const hours = Math.floor(ms / 3600000);
+
+  const parts = [];
+
+  if (hours > 0) {
+    parts.push(`${hours}h`);
+  }
+  if (minutes > 0) {
+    parts.push(`${minutes}m`);
+  }
+  if (seconds > 0) {
+    parts.push(`${seconds}s`);
+  }
+
+  return parts.join(' ') || '0s';
+}
+
+/**
+ * Creates a debounced function that delays invocation
+ * @template T
+ * @param {function(...*): T} fn - Function to debounce
+ * @param {number} waitMs - Delay in milliseconds
+ * @returns {function(...*): void} Debounced function
+ */
+function debounce(fn, waitMs) {
+  let timeoutId = null;
+
+  return function debounced(...args) {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+    }
+
+    timeoutId = setTimeout(() => {
+      timeoutId = null;
+      fn.apply(this, args);
+    }, waitMs);
+  };
+}
+
+/**
+ * Creates a throttled function that only invokes at most once per interval
+ * @template T
+ * @param {function(...*): T} fn - Function to throttle
+ * @param {number} intervalMs - Minimum interval in milliseconds
+ * @returns {function(...*): T|undefined} Throttled function
+ */
+function throttle(fn, intervalMs) {
+  let lastCall = 0;
+
+  return function throttled(...args) {
+    const currentTime = now();
+
+    if (currentTime - lastCall >= intervalMs) {
+      lastCall = currentTime;
+      return fn.apply(this, args);
+    }
+  };
+}
+
+module.exports = {
+  delay,
+  withTimeout,
+  now,
+  hrTime,
+  elapsed,
+  isExpired,
+  formatDuration,
+  debounce,
+  throttle
+};