react-native-ble-mesh 1.1.1 → 2.1.0

package/src/mesh/monitor/index.js

@@ -6,9 +6,13 @@
  */
 
 const { NetworkMonitor, HEALTH_STATUS, DEFAULT_CONFIG } = require('./NetworkMonitor');
+const { ConnectionQuality, PeerQualityTracker, QUALITY_LEVEL } = require('./ConnectionQuality');
 
 module.exports = {
-    NetworkMonitor,
-    HEALTH_STATUS,
-    DEFAULT_CONFIG,
+  NetworkMonitor,
+  HEALTH_STATUS,
+  DEFAULT_CONFIG,
+  ConnectionQuality,
+  PeerQualityTracker,
+  QUALITY_LEVEL
 };

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;
   }
 
   /**
@@ -230,7 +242,12 @@ class PeerManager extends EventEmitter {
   cleanup(maxAge = this.peerTimeout) {
     const removed = [];
     for (const [id, peer] of this._peers) {
-      if (peer.isStale(maxAge) && !peer.isConnected()) {
+      // Don't remove peers that are actively connecting or connected
+      if (peer.isConnected() || peer.connectionState === CONNECTION_STATE.CONNECTING) {
+        continue;
+      }
+
+      if (peer.isStale(maxAge)) {
         this._peers.delete(id);
         removed.push(peer);
         this.emit(EVENTS.PEER_LOST, peer);

package/src/mesh/router/MessageRouter.js

@@ -12,17 +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]]}`;
 }
 
 /**
@@ -148,8 +157,8 @@ class MessageRouter extends EventEmitter {
       return null;
     }
 
-    // Check hop count
-    if (hopCount >= (maxHops || MESH_CONFIG.MAX_HOPS)) {
+    // Check hop count (allow delivery at exactly maxHops, just don't relay further)
+    if (hopCount > (maxHops || MESH_CONFIG.MAX_HOPS)) {
       this._stats.maxHopsDropped++;
       this.emit(EVENTS.MESSAGE_DROPPED, { messageId, reason: 'max_hops' });
       return null;
@@ -165,17 +174,18 @@ class MessageRouter extends EventEmitter {
     this._routeTable.addRoute(sourcePeerId, sourcePeerId, 0);
 
     // Check if message is for us
-    const isForUs = !message.recipientId ||
-                    message.recipientId === this.localPeerId ||
-                    (message.flags & MESSAGE_FLAGS.IS_BROADCAST);
+    const isForUs = !message.recipientId || message.recipientId === this.localPeerId;
+    const isBroadcast = (message.flags & MESSAGE_FLAGS.IS_BROADCAST) !== 0;
 
-    if (isForUs) {
+    // Deliver locally if for us or broadcast
+    if (isForUs || isBroadcast) {
       this.emit(EVENTS.MESSAGE_RECEIVED, message);
     }
 
-    // Relay if broadcast or not for us
-    const shouldRelay = (message.flags & MESSAGE_FLAGS.IS_BROADCAST) ||
-                        (message.recipientId && message.recipientId !== this.localPeerId);
+    // Relay decision: only relay if TTL allows AND message isn't exclusively for us
+    const shouldRelay = isBroadcast
+      ? (message.hopCount < (maxHops || MESH_CONFIG.MAX_HOPS)) // Broadcasts relay if hops remain
+      : (!isForUs); // Unicast only relays if not for us
 
     if (shouldRelay) {
       this._relayMessage(message, sourcePeerId);
@@ -237,8 +247,11 @@ class MessageRouter extends EventEmitter {
       return [nextHop];
     }
 
-    // No known route, flood to all
-    return Array.from(this._peers.keys()).filter(id => id !== excludePeerId);
+    // No known route - use limited flooding (max 3 peers, prefer recently active)
+    const allPeers = Array.from(this._peers.keys()).filter(id => id !== excludePeerId);
+    // Limit flood scope to prevent network storms
+    const maxFloodPeers = Math.min(3, allPeers.length);
+    return allPeers.slice(0, maxFloodPeers);
   }
 
   /**
@@ -270,25 +283,31 @@ class MessageRouter extends EventEmitter {
       expiresAt: now + MESH_CONFIG.MESSAGE_TTL_MS
     };
 
-    this._dedupManager.markSeen(messageId);
-    this._stats.messagesSent++;
-
     // Determine targets
     const targets = recipientId
       ? [this._routeTable.getNextHop(recipientId) || recipientId]
       : Array.from(this._peers.keys());
 
+    // Send to targets
+    let anySent = false;
     for (const peerId of targets) {
       const sendFn = this._peers.get(peerId);
       if (sendFn) {
         try {
           sendFn(message);
+          anySent = true;
         } catch (err) {
           this.emit(EVENTS.ERROR, err);
         }
       }
     }
 
+    // Only mark as seen AFTER successful send
+    if (anySent) {
+      this._dedupManager.markSeen(messageId);
+      this._stats.messagesSent++;
+    }
+
     this.emit(EVENTS.MESSAGE_SENT, message);
     return messageId;
   }

package/src/mesh/router/RouteTable.js

@@ -99,7 +99,13 @@ class RouteTable {
 
     // Enforce max routes limit
     if (!existingRoute && this._routes.size >= this.maxRoutes) {
-      this._evictOldestRoute();
+      // First try to clean up expired routes before evicting valid ones
+      this.cleanup();
+
+      // If still at capacity after cleanup, evict oldest
+      if (this._routes.size >= this.maxRoutes) {
+        this._evictOldestRoute();
+      }
     }
 
     const route = {
@@ -275,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
     };
   }
 }