react-native-ble-mesh 1.0.1

package/src/utils/TimeoutManager.js

@@ -0,0 +1,164 @@
+'use strict';
+
+/**
+ * @fileoverview Safe timeout management with automatic cleanup
+ * @module utils/TimeoutManager
+ */
+
+/**
+ * Manages timeouts with automatic cleanup to prevent memory leaks.
+ * Essential for React Native where component unmounts don't clear timers.
+ *
+ * @class TimeoutManager
+ * @example
+ * const timeouts = new TimeoutManager();
+ * timeouts.set('retry', () => retryOperation(), 5000);
+ * // Later, or on cleanup:
+ * timeouts.clear('retry');
+ * // Or clear all:
+ * timeouts.clearAll();
+ */
+class TimeoutManager {
+  constructor() {
+    /** @private */
+    this._timeouts = new Map();
+    /** @private */
+    this._intervals = new Map();
+  }
+
+  /**
+   * Set a timeout (clears existing timeout with same key)
+   * @param {string} key - Unique identifier for this timeout
+   * @param {Function} callback - Function to call when timeout fires
+   * @param {number} delay - Delay in milliseconds
+   * @returns {TimeoutManager} This instance for chaining
+   */
+  set(key, callback, delay) {
+    this.clear(key);
+    const id = setTimeout(() => {
+      this._timeouts.delete(key);
+      callback();
+    }, delay);
+    this._timeouts.set(key, id);
+    return this;
+  }
+
+  /**
+   * Set an interval (clears existing interval with same key)
+   * @param {string} key - Unique identifier for this interval
+   * @param {Function} callback - Function to call on each interval
+   * @param {number} interval - Interval in milliseconds
+   * @returns {TimeoutManager} This instance for chaining
+   */
+  setInterval(key, callback, interval) {
+    this.clearInterval(key);
+    const id = setInterval(callback, interval);
+    this._intervals.set(key, id);
+    return this;
+  }
+
+  /**
+   * Clear a timeout by key
+   * @param {string} key - The timeout key to clear
+   * @returns {boolean} True if timeout was cleared
+   */
+  clear(key) {
+    if (this._timeouts.has(key)) {
+      clearTimeout(this._timeouts.get(key));
+      this._timeouts.delete(key);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Clear an interval by key
+   * @param {string} key - The interval key to clear
+   * @returns {boolean} True if interval was cleared
+   */
+  clearInterval(key) {
+    if (this._intervals.has(key)) {
+      clearInterval(this._intervals.get(key));
+      this._intervals.delete(key);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Check if a timeout exists
+   * @param {string} key - The timeout key
+   * @returns {boolean} True if timeout exists
+   */
+  has(key) {
+    return this._timeouts.has(key);
+  }
+
+  /**
+   * Check if an interval exists
+   * @param {string} key - The interval key
+   * @returns {boolean} True if interval exists
+   */
+  hasInterval(key) {
+    return this._intervals.has(key);
+  }
+
+  /**
+   * Clear all timeouts
+   * @returns {number} Number of timeouts cleared
+   */
+  clearAllTimeouts() {
+    const count = this._timeouts.size;
+    for (const id of this._timeouts.values()) {
+      clearTimeout(id);
+    }
+    this._timeouts.clear();
+    return count;
+  }
+
+  /**
+   * Clear all intervals
+   * @returns {number} Number of intervals cleared
+   */
+  clearAllIntervals() {
+    const count = this._intervals.size;
+    for (const id of this._intervals.values()) {
+      clearInterval(id);
+    }
+    this._intervals.clear();
+    return count;
+  }
+
+  /**
+   * Clear all timeouts and intervals
+   * @returns {number} Total number cleared
+   */
+  clearAll() {
+    return this.clearAllTimeouts() + this.clearAllIntervals();
+  }
+
+  /**
+   * Get count of active timeouts
+   * @returns {number} Number of active timeouts
+   */
+  get timeoutCount() {
+    return this._timeouts.size;
+  }
+
+  /**
+   * Get count of active intervals
+   * @returns {number} Number of active intervals
+   */
+  get intervalCount() {
+    return this._intervals.size;
+  }
+
+  /**
+   * Destroy the manager (clears all timers)
+   */
+  destroy() {
+    this.clearAll();
+  }
+}
+
+module.exports = TimeoutManager;

package/src/utils/base64.js

@@ -0,0 +1,151 @@
+'use strict';
+
+/**
+ * @fileoverview Optimized Base64 encoding/decoding for React Native
+ * @module utils/base64
+ *
+ * This implementation avoids string concatenation in loops which is O(n²).
+ * Uses array building which is O(n) - critical for React Native performance.
+ */
+
+/**
+ * Base64 character lookup table
+ * @private
+ */
+const BASE64_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+
+/**
+ * Reverse lookup table for decoding
+ * @private
+ */
+const BASE64_LOOKUP = new Uint8Array(256);
+for (let i = 0; i < BASE64_CHARS.length; i++) {
+  BASE64_LOOKUP[BASE64_CHARS.charCodeAt(i)] = i;
+}
+
+/**
+ * Encode Uint8Array to Base64 string (optimized for React Native)
+ *
+ * Uses array building instead of string concatenation to avoid O(n²) performance.
+ *
+ * @param {Uint8Array} bytes - The bytes to encode
+ * @returns {string} Base64 encoded string
+ * @throws {TypeError} If input is not a Uint8Array
+ * @example
+ * const encoded = encode(new Uint8Array([72, 101, 108, 108, 111]));
+ * console.log(encoded); // "SGVsbG8="
+ */
+function encode(bytes) {
+  if (!(bytes instanceof Uint8Array)) {
+    throw new TypeError('Input must be a Uint8Array');
+  }
+
+  const len = bytes.length;
+  const resultLen = Math.ceil(len / 3) * 4;
+  const result = new Array(resultLen);
+
+  let i = 0;
+  let j = 0;
+
+  // Process 3 bytes at a time
+  while (i < len - 2) {
+    const b1 = bytes[i++];
+    const b2 = bytes[i++];
+    const b3 = bytes[i++];
+
+    result[j++] = BASE64_CHARS[b1 >> 2];
+    result[j++] = BASE64_CHARS[((b1 & 0x03) << 4) | (b2 >> 4)];
+    result[j++] = BASE64_CHARS[((b2 & 0x0f) << 2) | (b3 >> 6)];
+    result[j++] = BASE64_CHARS[b3 & 0x3f];
+  }
+
+  // Handle remaining bytes
+  const remaining = len - i;
+  if (remaining === 1) {
+    const b1 = bytes[i];
+    result[j++] = BASE64_CHARS[b1 >> 2];
+    result[j++] = BASE64_CHARS[(b1 & 0x03) << 4];
+    result[j++] = '=';
+    result[j++] = '=';
+  } else if (remaining === 2) {
+    const b1 = bytes[i];
+    const b2 = bytes[i + 1];
+    result[j++] = BASE64_CHARS[b1 >> 2];
+    result[j++] = BASE64_CHARS[((b1 & 0x03) << 4) | (b2 >> 4)];
+    result[j++] = BASE64_CHARS[(b2 & 0x0f) << 2];
+    result[j++] = '=';
+  }
+
+  return result.join('');
+}
+
+/**
+ * Decode Base64 string to Uint8Array (optimized for React Native)
+ *
+ * @param {string} base64 - The Base64 string to decode
+ * @returns {Uint8Array} Decoded bytes
+ * @throws {TypeError} If input is not a string
+ * @throws {Error} If input contains invalid Base64 characters
+ * @example
+ * const decoded = decode("SGVsbG8=");
+ * console.log(decoded); // Uint8Array([72, 101, 108, 108, 111])
+ */
+function decode(base64) {
+  if (typeof base64 !== 'string') {
+    throw new TypeError('Input must be a string');
+  }
+
+  // Remove padding and calculate output length
+  const len = base64.length;
+  let padding = 0;
+
+  if (len > 0 && base64[len - 1] === '=') {
+    padding++;
+    if (len > 1 && base64[len - 2] === '=') {
+      padding++;
+    }
+  }
+
+  const outputLen = (len * 3 / 4) - padding;
+  const result = new Uint8Array(outputLen);
+
+  let i = 0;
+  let j = 0;
+
+  // Process 4 characters at a time
+  while (i < len) {
+    const c1 = BASE64_LOOKUP[base64.charCodeAt(i++)];
+    const c2 = BASE64_LOOKUP[base64.charCodeAt(i++)];
+    const c3 = BASE64_LOOKUP[base64.charCodeAt(i++)];
+    const c4 = BASE64_LOOKUP[base64.charCodeAt(i++)];
+
+    result[j++] = (c1 << 2) | (c2 >> 4);
+    if (j < outputLen) {
+      result[j++] = ((c2 & 0x0f) << 4) | (c3 >> 2);
+    }
+    if (j < outputLen) {
+      result[j++] = ((c3 & 0x03) << 6) | c4;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Check if a string is valid Base64
+ * @param {string} str - String to check
+ * @returns {boolean} True if valid Base64
+ */
+function isValid(str) {
+  if (typeof str !== 'string') {
+    return false;
+  }
+  // Base64 regex: only valid chars, proper length, proper padding
+  return /^[A-Za-z0-9+/]*={0,2}$/.test(str) && str.length % 4 === 0;
+}
+
+module.exports = {
+  encode,
+  decode,
+  isValid
+};

package/src/utils/bytes.js

@@ -0,0 +1,187 @@
+'use strict';
+
+/**
+ * @fileoverview Byte manipulation utilities
+ * @module utils/bytes
+ */
+
+/**
+ * Concatenates multiple Uint8Arrays into a single array
+ * @param {...Uint8Array} arrays - Arrays to concatenate
+ * @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);
+
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+
+  for (const arr of validArrays) {
+    result.set(arr, offset);
+    offset += arr.length;
+  }
+
+  return result;
+}
+
+/**
+ * Compares two byte arrays in constant time to prevent timing attacks
+ * @param {Uint8Array} a - First array
+ * @param {Uint8Array} b - Second array
+ * @returns {boolean} True if arrays are equal
+ */
+function constantTimeEqual(a, b) {
+  if (!(a instanceof Uint8Array) || !(b instanceof Uint8Array)) {
+    return false;
+  }
+
+  if (a.length !== b.length) {
+    return false;
+  }
+
+  let result = 0;
+  for (let i = 0; i < a.length; i++) {
+    result |= a[i] ^ b[i];
+  }
+
+  return result === 0;
+}
+
+/**
+ * Generates cryptographically secure random bytes
+ * @param {number} length - Number of bytes to generate
+ * @returns {Uint8Array} Random bytes
+ * @throws {Error} If crypto is not available
+ */
+function randomBytes(length) {
+  if (length < 0 || !Number.isInteger(length)) {
+    throw new Error('Length must be a non-negative integer');
+  }
+
+  if (length === 0) {
+    return new Uint8Array(0);
+  }
+
+  const bytes = new Uint8Array(length);
+
+  // Try Web Crypto API (browser and modern Node.js)
+  if (typeof crypto !== 'undefined' && crypto.getRandomValues) {
+    crypto.getRandomValues(bytes);
+    return bytes;
+  }
+
+  // Try globalThis.crypto (Node.js 19+, browsers)
+  if (typeof globalThis.crypto !== 'undefined' && globalThis.crypto.getRandomValues) {
+    globalThis.crypto.getRandomValues(bytes);
+    return bytes;
+  }
+
+  // Try Node.js crypto module
+  try {
+    const nodeCrypto = require('crypto');
+    const nodeBytes = nodeCrypto.randomBytes(length);
+    bytes.set(nodeBytes);
+    return bytes;
+  } catch (e) {
+    // Ignore and throw error below
+  }
+
+  throw new Error('No secure random number generator available');
+}
+
+/**
+ * XORs two byte arrays together
+ * @param {Uint8Array} a - First array
+ * @param {Uint8Array} b - Second array
+ * @returns {Uint8Array} XOR result (length matches shorter array)
+ */
+function xor(a, b) {
+  const length = Math.min(a.length, b.length);
+  const result = new Uint8Array(length);
+
+  for (let i = 0; i < length; i++) {
+    result[i] = a[i] ^ b[i];
+  }
+
+  return result;
+}
+
+/**
+ * Fills a byte array with a specific value
+ * @param {Uint8Array} array - Array to fill
+ * @param {number} value - Value to fill with (0-255)
+ * @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;
+  }
+  return array;
+}
+
+/**
+ * Creates a copy of a byte array
+ * @param {Uint8Array} array - Array to copy
+ * @returns {Uint8Array} Copy of the array
+ */
+function copy(array) {
+  const result = new Uint8Array(array.length);
+  result.set(array);
+  return result;
+}
+
+/**
+ * Securely wipes a byte array by overwriting with zeros
+ * @param {Uint8Array} array - Array to wipe
+ */
+function secureWipe(array) {
+  fill(array, 0);
+}
+
+/**
+ * Checks if two byte arrays are equal (non-constant-time)
+ * Use constantTimeEqual for security-sensitive comparisons
+ * @param {Uint8Array} a - First array
+ * @param {Uint8Array} b - Second array
+ * @returns {boolean} True if arrays are equal
+ */
+function equals(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Creates a view into a byte array without copying
+ * @param {Uint8Array} array - Source array
+ * @param {number} start - Start offset
+ * @param {number} [length] - Length of view (defaults to rest of array)
+ * @returns {Uint8Array} View into the array
+ */
+function slice(array, start, length) {
+  const end = length !== undefined ? start + length : array.length;
+  return array.subarray(start, end);
+}
+
+module.exports = {
+  concat,
+  constantTimeEqual,
+  randomBytes,
+  xor,
+  fill,
+  copy,
+  secureWipe,
+  equals,
+  slice
+};

package/src/utils/debug.js

@@ -0,0 +1,151 @@
+'use strict';
+
+/**
+ * Debug and logging utilities for BLE Mesh
+ *
+ * Enable debug output by setting:
+ * - Environment variable: DEBUG=ble-mesh:*
+ * - Or programmatically: debug.enable('ble-mesh:*')
+ *
+ * Namespaces:
+ * - ble-mesh:service - MeshService events
+ * - ble-mesh:transport - Transport layer
+ * - ble-mesh:crypto - Cryptographic operations
+ * - ble-mesh:handshake - Noise handshake
+ * - ble-mesh:mesh - Mesh routing
+ * - ble-mesh:* - All namespaces
+ *
+ * @module utils/debug
+ */
+
+// Check for debug environment variable
+const DEBUG_ENV = typeof process !== 'undefined' && process.env && process.env.DEBUG;
+
+// Active debug namespaces
+const activeNamespaces = new Set();
+
+// Parse debug patterns
+function parseDebugPatterns(patterns) {
+  if (!patterns) { return; }
+  const parts = patterns.split(',').map(p => p.trim());
+  for (const part of parts) {
+    if (part.startsWith('-')) {
+      activeNamespaces.delete(part.slice(1));
+    } else {
+      activeNamespaces.add(part);
+    }
+  }
+}
+
+// Initialize from environment
+if (DEBUG_ENV) {
+  parseDebugPatterns(DEBUG_ENV);
+}
+
+/**
+ * Check if a namespace is enabled
+ * @param {string} namespace - Namespace to check
+ * @returns {boolean}
+ */
+function isEnabled(namespace) {
+  if (activeNamespaces.has('*') || activeNamespaces.has('ble-mesh:*')) {
+    return true;
+  }
+  if (activeNamespaces.has(namespace)) {
+    return true;
+  }
+  // Check wildcard patterns
+  for (const pattern of activeNamespaces) {
+    if (pattern.endsWith(':*')) {
+      const prefix = pattern.slice(0, -1);
+      if (namespace.startsWith(prefix)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+/**
+ * Create a debug logger for a namespace
+ * @param {string} namespace - Debug namespace (e.g., 'ble-mesh:service')
+ * @returns {Function} Debug logger function
+ */
+function createDebugger(namespace) {
+  const logger = (...args) => {
+    if (!isEnabled(namespace)) { return; }
+
+    const timestamp = new Date().toISOString();
+    const prefix = `[${timestamp}] ${namespace}`;
+
+    // Format message
+    const message = args
+      .map(arg => {
+        if (arg instanceof Error) {
+          return `${arg.name}: ${arg.message}`;
+        }
+        if (typeof arg === 'object') {
+          try {
+            return JSON.stringify(arg, null, 2);
+          } catch {
+            return String(arg);
+          }
+        }
+        return String(arg);
+      })
+      .join(' ');
+
+    console.log(`${prefix} ${message}`);
+  };
+
+  logger.namespace = namespace;
+  logger.enabled = () => isEnabled(namespace);
+
+  return logger;
+}
+
+/**
+ * Enable debug namespaces
+ * @param {string} patterns - Comma-separated namespace patterns
+ * @example
+ * debug.enable('ble-mesh:*')
+ * debug.enable('ble-mesh:service,ble-mesh:crypto')
+ */
+function enable(patterns) {
+  parseDebugPatterns(patterns);
+}
+
+/**
+ * Disable debug output
+ */
+function disable() {
+  activeNamespaces.clear();
+}
+
+/**
+ * Get list of enabled namespaces
+ * @returns {string[]}
+ */
+function getEnabled() {
+  return Array.from(activeNamespaces);
+}
+
+// Pre-defined debuggers for common namespaces
+const debuggers = {
+  service: createDebugger('ble-mesh:service'),
+  transport: createDebugger('ble-mesh:transport'),
+  crypto: createDebugger('ble-mesh:crypto'),
+  handshake: createDebugger('ble-mesh:handshake'),
+  mesh: createDebugger('ble-mesh:mesh'),
+  protocol: createDebugger('ble-mesh:protocol'),
+  storage: createDebugger('ble-mesh:storage')
+};
+
+module.exports = {
+  createDebugger,
+  enable,
+  disable,
+  isEnabled,
+  getEnabled,
+  ...debuggers
+};