react-native-ble-mesh 2.0.0 → 2.1.0

package/src/mesh/dedup/BloomFilter.js

@@ -13,6 +13,15 @@
 const FNV_PRIME = 0x01000193;
 const FNV_OFFSET = 0x811c9dc5;
 
+// Cached TextEncoder singleton (avoids per-call allocation)
+let _encoder = null;
+function _getEncoder() {
+  if (!_encoder && typeof TextEncoder !== 'undefined') {
+    _encoder = new TextEncoder();
+  }
+  return _encoder;
+}
+
 /**
  * Bloom filter for probabilistic set membership testing
  * @class BloomFilter
@@ -56,6 +65,13 @@ class BloomFilter {
      * @private
      */
     this._count = 0;
+
+    /**
+     * Running count of set bits (avoids O(n) scan in getFillRatio)
+     * @type {number}
+     * @private
+     */
+    this._setBitCount = 0;
   }
 
   /**
@@ -90,72 +106,50 @@ class BloomFilter {
       return item;
     }
     if (typeof item === 'string') {
-      const encoder = new TextEncoder();
-      return encoder.encode(item);
+      const encoder = _getEncoder();
+      if (encoder) {
+        return encoder.encode(item);
+      }
+      // Fallback for environments without TextEncoder
+      const bytes = new Uint8Array(item.length);
+      for (let i = 0; i < item.length; i++) {
+        bytes[i] = item.charCodeAt(i) & 0xff;
+      }
+      return bytes;
     }
     throw new Error('Item must be string or Uint8Array');
   }
 
-  /**
-   * Computes hash positions for an item
-   * @param {string|Uint8Array} item - Item to hash
-   * @returns {number[]} Array of bit positions
-   * @private
-   */
-  _getPositions(item) {
-    const data = this._toBytes(item);
-    const positions = [];
-    for (let i = 0; i < this.hashCount; i++) {
-      const hash = this._fnv1a(data, i);
-      positions.push(hash % this.size);
-    }
-    return positions;
-  }
-
-  /**
-   * Sets a bit at the given position
-   * @param {number} position - Bit position
-   * @private
-   */
-  _setBit(position) {
-    const byteIndex = Math.floor(position / 8);
-    const bitIndex = position % 8;
-    this._bits[byteIndex] |= (1 << bitIndex);
-  }
-
-  /**
-   * Gets a bit at the given position
-   * @param {number} position - Bit position
-   * @returns {boolean} True if bit is set
-   * @private
-   */
-  _getBit(position) {
-    const byteIndex = Math.floor(position / 8);
-    const bitIndex = position % 8;
-    return (this._bits[byteIndex] & (1 << bitIndex)) !== 0;
-  }
-
   /**
    * Adds an item to the filter
+   * Inlined position computation to avoid intermediate array allocation
    * @param {string|Uint8Array} item - Item to add
    */
   add(item) {
-    const positions = this._getPositions(item);
-    for (const pos of positions) {
-      this._setBit(pos);
+    const data = this._toBytes(item);
+    for (let i = 0; i < this.hashCount; i++) {
+      const pos = this._fnv1a(data, i) % this.size;
+      const byteIndex = pos >> 3;
+      const mask = 1 << (pos & 7);
+      if (!(this._bits[byteIndex] & mask)) {
+        this._bits[byteIndex] |= mask;
+        this._setBitCount++;
+      }
     }
     this._count++;
   }
 
   /**
    * Tests if an item might be in the filter
+   * Inlined position computation to avoid intermediate array allocation
    * @param {string|Uint8Array} item - Item to test
    * @returns {boolean} True if item might be present, false if definitely absent
    */
   mightContain(item) {
-    const positions = this._getPositions(item);
-    for (const pos of positions) {
-      if (!this._getBit(pos)) {
+    const data = this._toBytes(item);
+    for (let i = 0; i < this.hashCount; i++) {
+      const pos = this._fnv1a(data, i) % this.size;
+      if (!(this._bits[pos >> 3] & (1 << (pos & 7)))) {
         return false;
       }
     }
@@ -168,22 +162,15 @@ class BloomFilter {
   clear() {
     this._bits.fill(0);
     this._count = 0;
+    this._setBitCount = 0;
   }
 
   /**
-   * Gets the fill ratio of the filter
+   * Gets the fill ratio of the filter (O(1) using running count)
    * @returns {number} Ratio of set bits to total bits (0-1)
    */
   getFillRatio() {
-    let setBits = 0;
-    for (let i = 0; i < this._bits.length; i++) {
-      let byte = this._bits[i];
-      while (byte) {
-        setBits += byte & 1;
-        byte >>>= 1;
-      }
-    }
-    return setBits / this.size;
+    return this._setBitCount / this.size;
   }
 
   /**

package/src/mesh/dedup/DedupManager.js

@@ -69,6 +69,13 @@ class DedupManager {
      */
     this._autoResetThreshold = config.autoResetThreshold;
 
+    /**
+     * Grace period timer ID for bloom filter reset
+     * @type {ReturnType<typeof setTimeout>|null}
+     * @private
+     */
+    this._graceTimer = null;
+
     /**
      * Statistics for monitoring
      * @type {Object}
@@ -165,9 +172,15 @@ class DedupManager {
     // Keep old filter for a grace period by checking both
     this._oldBloomFilter = oldFilter;
 
+    // Clear any existing grace timer before starting a new one
+    if (this._graceTimer) {
+      clearTimeout(this._graceTimer);
+    }
+
     // Clear old filter after grace period
-    setTimeout(() => {
+    this._graceTimer = setTimeout(() => {
       this._oldBloomFilter = null;
+      this._graceTimer = null;
     }, 60000); // 1 minute grace
   }
 
@@ -175,6 +188,11 @@ class DedupManager {
    * Resets both the Bloom filter and cache
    */
   reset() {
+    if (this._graceTimer) {
+      clearTimeout(this._graceTimer);
+      this._graceTimer = null;
+    }
+    this._oldBloomFilter = null;
     this._bloomFilter.clear();
     this._cache.clear();
     this._stats.resets++;
@@ -233,6 +251,19 @@ class DedupManager {
   getSeenTimestamp(messageId) {
     return this._cache.getTimestamp(messageId);
   }
+
+  /**
+   * Destroys the dedup manager and cleans up resources
+   */
+  destroy() {
+    if (this._graceTimer) {
+      clearTimeout(this._graceTimer);
+      this._graceTimer = null;
+    }
+    this._oldBloomFilter = null;
+    this._bloomFilter.clear();
+    this._cache.clear();
+  }
 }
 
 module.exports = DedupManager;

package/src/mesh/fragment/Fragmenter.js

@@ -121,7 +121,7 @@ function fragment(payload, messageId, maxSize = DEFAULT_FRAGMENT_SIZE) {
   for (let i = 0; i < fragmentCount; i++) {
     const remainingLength = payload.length - offset;
     const chunkLength = Math.min(payloadCapacity, remainingLength);
-    const chunk = payload.slice(offset, offset + chunkLength);
+    const chunk = payload.subarray(offset, offset + chunkLength);
 
     // Create fragment with header
     const header = createFragmentHeader(i, fragmentCount, chunkLength);

package/src/mesh/monitor/ConnectionQuality.js

@@ -53,8 +53,16 @@ class PeerQualityTracker {
   constructor(peerId, config) {
     this.peerId = peerId;
     this._config = config;
-    this._rssiSamples = [];
-    this._latencySamples = [];
+    // Circular buffer for RSSI samples
+    this._rssiSamples = new Float64Array(config.sampleSize);
+    this._rssiIndex = 0;
+    this._rssiCount = 0;
+    this._rssiSum = 0;
+    // Circular buffer for latency samples
+    this._latencySamples = new Float64Array(config.sampleSize);
+    this._latencyIndex = 0;
+    this._latencyCount = 0;
+    this._latencySum = 0;
     this._packetsSent = 0;
     this._packetsAcked = 0;
     this._bytesTransferred = 0;
@@ -65,25 +73,37 @@ class PeerQualityTracker {
   }
 
   /**
-   * Records an RSSI sample
+   * Records an RSSI sample using circular buffer
    * @param {number} rssi - Signal strength in dBm
    */
   recordRssi(rssi) {
-    this._rssiSamples.push(rssi);
-    if (this._rssiSamples.length > this._config.sampleSize) {
-      this._rssiSamples.shift();
+    const capacity = this._rssiSamples.length;
+    if (this._rssiCount >= capacity) {
+      this._rssiSum -= this._rssiSamples[this._rssiIndex];
+    }
+    this._rssiSamples[this._rssiIndex] = rssi;
+    this._rssiSum += rssi;
+    this._rssiIndex = (this._rssiIndex + 1) % capacity;
+    if (this._rssiCount < capacity) {
+      this._rssiCount++;
     }
     this._lastActivity = Date.now();
   }
 
   /**
-   * Records a latency measurement
+   * Records a latency measurement using circular buffer
    * @param {number} latencyMs - Round-trip latency in ms
    */
   recordLatency(latencyMs) {
-    this._latencySamples.push(latencyMs);
-    if (this._latencySamples.length > this._config.sampleSize) {
-      this._latencySamples.shift();
+    const capacity = this._latencySamples.length;
+    if (this._latencyCount >= capacity) {
+      this._latencySum -= this._latencySamples[this._latencyIndex];
+    }
+    this._latencySamples[this._latencyIndex] = latencyMs;
+    this._latencySum += latencyMs;
+    this._latencyIndex = (this._latencyIndex + 1) % capacity;
+    if (this._latencyCount < capacity) {
+      this._latencyCount++;
     }
     this._lastActivity = Date.now();
   }
@@ -125,21 +145,21 @@ class PeerQualityTracker {
   }
 
   /**
-   * Gets the average RSSI
+   * Gets the average RSSI (O(1) using running sum)
    * @returns {number|null}
    */
   getAvgRssi() {
-    if (this._rssiSamples.length === 0) { return null; }
-    return this._rssiSamples.reduce((a, b) => a + b, 0) / this._rssiSamples.length;
+    if (this._rssiCount === 0) { return null; }
+    return this._rssiSum / this._rssiCount;
   }
 
   /**
-   * Gets the average latency
+   * Gets the average latency (O(1) using running sum)
    * @returns {number|null}
    */
   getAvgLatency() {
-    if (this._latencySamples.length === 0) { return null; }
-    return this._latencySamples.reduce((a, b) => a + b, 0) / this._latencySamples.length;
+    if (this._latencyCount === 0) { return null; }
+    return this._latencySum / this._latencyCount;
   }
 
   /**
@@ -388,10 +408,15 @@ class ConnectionQuality extends EventEmitter {
   }
 
   /**
-   * Periodic update — recalculates all qualities and emits changes
+   * Periodic update — recalculates all qualities and emits changes.
+   * Stops the timer automatically when no peers are connected.
    * @private
    */
   _update() {
+    if (this._peers.size === 0) {
+      this.stop();
+      return;
+    }
     for (const tracker of this._peers.values()) {
       const quality = tracker.calculate();
       if (quality.changed) {

package/src/mesh/monitor/NetworkMonitor.js

@@ -117,11 +117,32 @@ class NetworkMonitor extends EventEmitter {
     this._pendingMessages = new Map();
 
     /**
-         * Latency samples
-         * @type {number[]}
+         * Latency samples (circular buffer)
+         * @type {Float64Array}
          * @private
          */
-    this._latencies = [];
+    this._latencies = new Float64Array(this._config.latencySampleSize);
+
+    /**
+         * Circular buffer write index
+         * @type {number}
+         * @private
+         */
+    this._latencyIndex = 0;
+
+    /**
+         * Number of latency samples stored
+         * @type {number}
+         * @private
+         */
+    this._latencyCount = 0;
+
+    /**
+         * Running sum of latency samples for O(1) average
+         * @type {number}
+         * @private
+         */
+    this._latencySum = 0;
 
     /**
          * Global statistics
@@ -386,7 +407,10 @@ class NetworkMonitor extends EventEmitter {
   reset() {
     this._nodes.clear();
     this._pendingMessages.clear();
-    this._latencies = [];
+    this._latencies = new Float64Array(this._config.latencySampleSize);
+    this._latencyIndex = 0;
+    this._latencyCount = 0;
+    this._latencySum = 0;
     this._stats = {
       totalMessagesSent: 0,
       totalMessagesDelivered: 0,
@@ -430,14 +454,21 @@ class NetworkMonitor extends EventEmitter {
   }
 
   /**
-     * Adds a latency sample.
+     * Adds a latency sample using circular buffer.
      * @param {number} latency - Latency in ms
      * @private
      */
   _addLatencySample(latency) {
-    this._latencies.push(latency);
-    if (this._latencies.length > this._config.latencySampleSize) {
-      this._latencies.shift();
+    const capacity = this._latencies.length;
+    // Subtract the old value being overwritten if buffer is full
+    if (this._latencyCount >= capacity) {
+      this._latencySum -= this._latencies[this._latencyIndex];
+    }
+    this._latencies[this._latencyIndex] = latency;
+    this._latencySum += latency;
+    this._latencyIndex = (this._latencyIndex + 1) % capacity;
+    if (this._latencyCount < capacity) {
+      this._latencyCount++;
     }
   }
 
@@ -469,17 +500,30 @@ class NetworkMonitor extends EventEmitter {
   }
 
   /**
-     * Calculates average latency from samples.
+     * Calculates average latency from samples (O(1) using running sum).
      * @returns {number} Average latency
      * @private
      */
   _calculateAverageLatency() {
-    if (this._latencies.length === 0) {
+    if (this._latencyCount === 0) {
       return 0;
     }
-    return Math.round(
-      this._latencies.reduce((a, b) => a + b, 0) / this._latencies.length
-    );
+    return Math.round(this._latencySum / this._latencyCount);
+  }
+
+  /**
+     * Cleans up stale pending messages older than nodeTimeoutMs.
+     * @private
+     */
+  _cleanupPendingMessages() {
+    const now = Date.now();
+    const timeout = this._config.nodeTimeoutMs;
+    for (const [messageId, pending] of this._pendingMessages) {
+      if (now - pending.timestamp > timeout) {
+        this._pendingMessages.delete(messageId);
+        this._stats.totalMessagesFailed++;
+      }
+    }
   }
 
   /**
@@ -520,6 +564,7 @@ class NetworkMonitor extends EventEmitter {
     this._healthCheckTimer = setInterval(
       () => {
         try {
+          this._cleanupPendingMessages();
           const report = this.generateHealthReport();
           this.emit('health-report', report);
         } catch (error) {

package/src/mesh/peer/Peer.js

@@ -8,6 +8,9 @@
 const { CONNECTION_STATE } = require('../../constants');
 const { ValidationError } = require('../../errors');
 
+/** Pre-computed Set of valid connection states for O(1) lookup */
+const CONNECTION_STATE_SET = new Set(Object.values(CONNECTION_STATE));
+
 /**
  * Represents a peer in the mesh network
  * @class Peer
@@ -130,9 +133,9 @@ class Peer {
    * @param {string} state - New connection state
    */
   setConnectionState(state) {
-    if (!Object.values(CONNECTION_STATE).includes(state)) {
+    if (!CONNECTION_STATE_SET.has(state)) {
       throw ValidationError.invalidArgument('state', state, {
-        validValues: Object.values(CONNECTION_STATE)
+        validValues: Array.from(CONNECTION_STATE_SET)
       });
     }
     this.connectionState = state;

package/src/mesh/peer/PeerManager.js

@@ -109,7 +109,11 @@ class PeerManager extends EventEmitter {
    * @returns {Peer[]} Array of connected peers
    */
   getConnectedPeers() {
-    return this.getAllPeers().filter(peer => peer.isConnected());
+    const result = [];
+    for (const peer of this._peers.values()) {
+      if (peer.isConnected()) { result.push(peer); }
+    }
+    return result;
   }
 
   /**
@@ -117,7 +121,11 @@ class PeerManager extends EventEmitter {
    * @returns {Peer[]} Array of secured peers
    */
   getSecuredPeers() {
-    return this.getAllPeers().filter(peer => peer.isSecured());
+    const result = [];
+    for (const peer of this._peers.values()) {
+      if (peer.isSecured()) { result.push(peer); }
+    }
+    return result;
   }
 
   /**
@@ -125,7 +133,11 @@ class PeerManager extends EventEmitter {
    * @returns {Peer[]} Array of direct peers
    */
   getDirectPeers() {
-    return this.getAllPeers().filter(peer => peer.isDirect());
+    const result = [];
+    for (const peer of this._peers.values()) {
+      if (peer.isDirect()) { result.push(peer); }
+    }
+    return result;
   }
 
   /**

package/src/mesh/router/MessageRouter.js

@@ -12,18 +12,26 @@ const { DedupManager } = require('../dedup');
 const RouteTable = require('./RouteTable');
 const { randomBytes } = require('../../utils/bytes');
 
+/**
+ * Hex lookup table for fast byte-to-hex conversion
+ * @constant {string[]}
+ * @private
+ */
+const HEX = Array.from({ length: 256 }, (_, i) => (i < 16 ? '0' : '') + i.toString(16));
+
 /**
  * Generates a UUID v4 string
  * @returns {string} UUID string
  * @private
  */
 function generateUUID() {
-  const bytes = randomBytes(16);
-  bytes[6] = (bytes[6] & 0x0f) | 0x40;
-  bytes[8] = (bytes[8] & 0x3f) | 0x80;
-  const hex = Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('');
-  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-` +
-    `${hex.slice(16, 20)}-${hex.slice(20)}`;
+  const b = randomBytes(16);
+  b[6] = (b[6] & 0x0f) | 0x40;
+  b[8] = (b[8] & 0x3f) | 0x80;
+  return `${HEX[b[0]]}${HEX[b[1]]}${HEX[b[2]]}${HEX[b[3]]}-${
+    HEX[b[4]]}${HEX[b[5]]}-${HEX[b[6]]}${HEX[b[7]]}-${
+    HEX[b[8]]}${HEX[b[9]]}-${HEX[b[10]]}${HEX[b[11]]}${
+    HEX[b[12]]}${HEX[b[13]]}${HEX[b[14]]}${HEX[b[15]]}`;
 }
 
 /**

package/src/mesh/router/RouteTable.js

@@ -281,16 +281,26 @@ class RouteTable {
    * @returns {Object} Statistics
    */
   getStats() {
-    const routes = this.getAllRoutes();
-    const hopCounts = routes.map(r => r.hopCount);
+    const now = Date.now();
+    let totalRoutes = 0;
+    let maxHops = 0;
+    let hopSum = 0;
+
+    for (const [, route] of this._routes) {
+      if (now <= route.expiresAt) {
+        totalRoutes++;
+        if (route.hopCount > maxHops) {
+          maxHops = route.hopCount;
+        }
+        hopSum += route.hopCount;
+      }
+    }
 
     return {
-      totalRoutes: routes.length,
+      totalRoutes,
       directNeighbors: this._neighbors.size,
-      maxHops: hopCounts.length > 0 ? Math.max(...hopCounts) : 0,
-      avgHops: hopCounts.length > 0
-        ? hopCounts.reduce((a, b) => a + b, 0) / hopCounts.length
-        : 0
+      maxHops: totalRoutes > 0 ? maxHops : 0,
+      avgHops: totalRoutes > 0 ? hopSum / totalRoutes : 0
     };
   }
 }

package/src/mesh/store/StoreAndForwardManager.js

@@ -11,6 +11,14 @@
 const EventEmitter = require('../../utils/EventEmitter');
 const { EVENTS } = require('../../constants');
 const { ValidationError } = require('../../errors');
+const { randomBytes } = require('../../utils/bytes');
+
+/**
+ * Hex lookup table for fast byte-to-hex conversion
+ * @constant {string[]}
+ * @private
+ */
+const HEX = Array.from({ length: 256 }, (_, i) => (i < 16 ? '0' : '') + i.toString(16));
 
 /**
  * Default configuration for store and forward
@@ -439,9 +447,12 @@ class StoreAndForwardManager extends EventEmitter {
      * @private
      */
   _generateId() {
-    const { randomBytes } = require('../../utils/bytes');
     const bytes = randomBytes(16);
-    return Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('');
+    let id = '';
+    for (let i = 0; i < bytes.length; i++) {
+      id += HEX[bytes[i]];
+    }
+    return id;
   }
 
   /**

package/src/protocol/deserializer.js

@@ -39,15 +39,14 @@ function deserializeHeader(data) {
     });
   }
 
-  const headerData = data.slice(0, HEADER_SIZE);
-  const view = new DataView(headerData.buffer, headerData.byteOffset, HEADER_SIZE);
+  const headerData = data.subarray(0, HEADER_SIZE);
+  const view = new DataView(data.buffer, data.byteOffset, HEADER_SIZE);
 
   // Extract checksum from bytes 44-47 (big-endian)
   const storedChecksum = view.getUint32(44, false);
 
-  // Calculate checksum over bytes 0-43
-  const checksumData = headerData.slice(0, 44);
-  const calculatedChecksum = crc32(checksumData);
+  // Calculate checksum over bytes 0-43 (subarray = zero-copy view)
+  const calculatedChecksum = crc32(headerData.subarray(0, 44));
 
   // Verify checksum
   if (storedChecksum !== calculatedChecksum) {
@@ -65,7 +64,7 @@ function deserializeHeader(data) {
     hopCount: headerData[3],
     maxHops: headerData[4],
     // bytes 5-7 are reserved
-    messageId: headerData.slice(8, 24),
+    messageId: new Uint8Array(headerData.buffer, headerData.byteOffset + 8, 16),
     timestamp: readUint64BE(view, 24),
     expiresAt: readUint64BE(view, 32),
     payloadLength: view.getUint16(40, false),
@@ -120,8 +119,8 @@ function deserialize(data) {
     });
   }
 
-  // Extract payload
-  const payload = data.slice(HEADER_SIZE, HEADER_SIZE + header.payloadLength);
+  // Extract payload (subarray = zero-copy view)
+  const payload = data.subarray(HEADER_SIZE, HEADER_SIZE + header.payloadLength);
 
   return new Message(header, payload);
 }
@@ -175,7 +174,7 @@ function deserializeBatch(data) {
     }
 
     // Extract and deserialize this message
-    const messageData = data.slice(offset, offset + messageLength);
+    const messageData = data.subarray(offset, offset + messageLength);
 
     try {
       const message = deserialize(messageData);
@@ -228,7 +227,7 @@ function peekMessageId(data) {
   if (!(data instanceof Uint8Array) || data.length < 24) {
     return null;
   }
-  return data.slice(8, 24);
+  return data.subarray(8, 24);
 }
 
 module.exports = {