react-native-ble-mesh 2.0.0 → 2.1.2

package/src/mesh/peer/PeerManager.js

@@ -18,9 +18,9 @@ const { ValidationError, ConnectionError } = require('../../errors');
 class PeerManager extends EventEmitter {
   /**
    * Creates a new PeerManager
-   * @param {Object} [options] - Configuration options
-   * @param {number} [options.maxPeers] - Maximum number of peers
-   * @param {number} [options.peerTimeout] - Timeout for stale peers
+   * @param {any} [options] - Configuration options
+   *
+   *
    */
   constructor(options = {}) {
     super();
@@ -39,7 +39,7 @@ class PeerManager extends EventEmitter {
 
     /**
      * Peers by ID
-     * @type {Map<string, Peer>}
+     * @type {Map<string, any>}
      * @private
      */
     this._peers = new Map();
@@ -54,8 +54,8 @@ class PeerManager extends EventEmitter {
 
   /**
    * Adds or updates a peer
-   * @param {Object} info - Peer information
-   * @returns {Peer} The added or updated peer
+   * @param {any} info - Peer information
+   * @returns {any} The added or updated peer
    */
   addPeer(info) {
     if (!info || typeof info.id !== 'string') {
@@ -90,7 +90,7 @@ class PeerManager extends EventEmitter {
   /**
    * Gets a peer by ID
    * @param {string} id - Peer ID
-   * @returns {Peer|undefined} The peer or undefined
+   * @returns {any} The peer or undefined
    */
   getPeer(id) {
     return this._peers.get(id);
@@ -98,7 +98,7 @@ class PeerManager extends EventEmitter {
 
   /**
    * Gets all peers
-   * @returns {Peer[]} Array of all peers
+   * @returns {any[]} Array of all peers
    */
   getAllPeers() {
     return Array.from(this._peers.values());
@@ -106,33 +106,45 @@ class PeerManager extends EventEmitter {
 
   /**
    * Gets connected peers
-   * @returns {Peer[]} Array of connected peers
+   * @returns {any[]} 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;
   }
 
   /**
    * Gets peers with secure sessions
-   * @returns {Peer[]} Array of secured peers
+   * @returns {any[]} 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;
   }
 
   /**
    * Gets directly connected peers
-   * @returns {Peer[]} Array of direct peers
+   * @returns {any[]} 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;
   }
 
   /**
    * Updates a peer's connection state
    * @param {string} id - Peer ID
    * @param {string} state - New connection state
-   * @returns {Peer|undefined} Updated peer or undefined
+   * @returns {any} Updated peer or undefined
    */
   updateConnectionState(id, state) {
     const peer = this._peers.get(id);
@@ -154,7 +166,7 @@ class PeerManager extends EventEmitter {
   /**
    * Marks a peer as secured
    * @param {string} id - Peer ID
-   * @returns {Peer|undefined} Updated peer or undefined
+   * @returns {any} Updated peer or undefined
    */
   markSecured(id) {
     const peer = this._peers.get(id);
@@ -225,7 +237,7 @@ class PeerManager extends EventEmitter {
   /**
    * Cleans up stale peers
    * @param {number} [maxAge] - Maximum age in ms, defaults to peerTimeout
-   * @returns {Peer[]} Array of removed peers
+   * @returns {any[]} Array of removed peers
    */
   cleanup(maxAge = this.peerTimeout) {
     const removed = [];

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 }, (/** @type {any} */ _, /** @type {number} */ 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]]}`;
 }
 
 /**
@@ -34,8 +42,8 @@ function generateUUID() {
 class MessageRouter extends EventEmitter {
   /**
    * Creates a new MessageRouter
-   * @param {Object} options - Configuration options
-   * @param {string} options.localPeerId - Local peer ID
+   * @param {any} options - Configuration options
+   *
    */
   constructor(options = {}) {
     super();
@@ -69,7 +77,7 @@ class MessageRouter extends EventEmitter {
 
     /**
      * Statistics
-     * @type {Object}
+     * @type {any}
      * @private
      */
     this._stats = {
@@ -126,9 +134,9 @@ class MessageRouter extends EventEmitter {
 
   /**
    * Processes an incoming message
-   * @param {Object} message - Message object
+   * @param {any} message - Message object
    * @param {string} sourcePeerId - Peer ID that sent the message
-   * @returns {Object|null} Processed message or null if dropped
+   * @returns {any} Processed message or null if dropped
    */
   processIncoming(message, sourcePeerId) {
     this._stats.messagesReceived++;
@@ -188,7 +196,7 @@ class MessageRouter extends EventEmitter {
 
   /**
    * Relays a message to other peers
-   * @param {Object} message - Message to relay
+   * @param {any} message - Message to relay
    * @param {string} excludePeerId - Peer to exclude from relay
    * @private
    */
@@ -206,7 +214,7 @@ class MessageRouter extends EventEmitter {
         try {
           sendFn(relayedMessage);
           this._stats.messagesRelayed++;
-        } catch (err) {
+        } catch (/** @type {any} */ err) {
           this.emit(EVENTS.ERROR, err);
         }
       }
@@ -222,7 +230,7 @@ class MessageRouter extends EventEmitter {
 
   /**
    * Gets relay targets for a message
-   * @param {Object} message - Message
+   * @param {any} message - Message
    * @param {string} excludePeerId - Peer to exclude
    * @returns {string[]} Array of peer IDs
    * @private
@@ -230,7 +238,7 @@ class MessageRouter extends EventEmitter {
   _getRelayTargets(message, excludePeerId) {
     if (message.flags & MESSAGE_FLAGS.IS_BROADCAST) {
       // Broadcast: send to all except source
-      return Array.from(this._peers.keys()).filter(id => id !== excludePeerId);
+      return Array.from(this._peers.keys()).filter((/** @type {string} */ id) => id !== excludePeerId);
     }
 
     // Unicast: find route to recipient
@@ -240,7 +248,7 @@ class MessageRouter extends EventEmitter {
     }
 
     // No known route - use limited flooding (max 3 peers, prefer recently active)
-    const allPeers = Array.from(this._peers.keys()).filter(id => id !== excludePeerId);
+    const allPeers = Array.from(this._peers.keys()).filter((/** @type {string} */ id) => id !== excludePeerId);
     // Limit flood scope to prevent network storms
     const maxFloodPeers = Math.min(3, allPeers.length);
     return allPeers.slice(0, maxFloodPeers);
@@ -248,7 +256,7 @@ class MessageRouter extends EventEmitter {
 
   /**
    * Sends a message
-   * @param {Object} options - Send options
+   * @param {any} options - Send options
    * @returns {string} Message ID
    */
   send(options) {
@@ -288,7 +296,7 @@ class MessageRouter extends EventEmitter {
         try {
           sendFn(message);
           anySent = true;
-        } catch (err) {
+        } catch (/** @type {any} */ err) {
           this.emit(EVENTS.ERROR, err);
         }
       }
@@ -306,7 +314,7 @@ class MessageRouter extends EventEmitter {
 
   /**
    * Broadcasts a message to all peers
-   * @param {Object} options - Broadcast options
+   * @param {any} options - Broadcast options
    * @returns {string} Message ID
    */
   broadcast(options) {
@@ -319,7 +327,7 @@ class MessageRouter extends EventEmitter {
 
   /**
    * Gets router statistics
-   * @returns {Object} Statistics
+   * @returns {any} Statistics
    */
   getStats() {
     return {

package/src/mesh/router/PathFinder.js

@@ -28,10 +28,7 @@ const { ValidationError } = require('../../errors');
 class PathFinder extends EventEmitter {
   /**
    * Creates a new PathFinder
-   * @param {Object} options - Configuration options
-   * @param {string} options.localPeerId - Local peer ID
-   * @param {Object} options.routeTable - RouteTable instance
-   * @param {number} [options.discoveryTimeout] - Route discovery timeout
+   * @param {any} options - Configuration options   *
    */
   constructor(options = {}) {
     super();
@@ -51,7 +48,7 @@ class PathFinder extends EventEmitter {
 
     /**
      * Route table reference
-     * @type {Object}
+     * @type {any}
      */
     this.routeTable = options.routeTable;
 
@@ -63,7 +60,7 @@ class PathFinder extends EventEmitter {
 
     /**
      * Pending route requests
-     * @type {Map<string, RouteRequest>}
+     * @type {Map<string, any>}
      * @private
      */
     this._pendingRequests = new Map();
@@ -77,7 +74,7 @@ class PathFinder extends EventEmitter {
 
     /**
      * Statistics
-     * @type {Object}
+     * @type {any}
      * @private
      */
     this._stats = {
@@ -93,7 +90,7 @@ class PathFinder extends EventEmitter {
   /**
    * Finds a route to a destination
    * @param {string} destination - Target peer ID
-   * @returns {Promise<Object|null>} Route or null if not found
+   * @returns {Promise<any>} Route or null if not found
    */
   async findRoute(destination) {
     if (!destination || typeof destination !== 'string') {
@@ -113,7 +110,7 @@ class PathFinder extends EventEmitter {
   /**
    * Initiates route discovery for a destination
    * @param {string} destination - Target peer ID
-   * @returns {Promise<Object|null>} Discovered route or null
+   * @returns {Promise<any>} Discovered route or null
    * @private
    */
   _initiateDiscovery(destination) {
@@ -164,9 +161,9 @@ class PathFinder extends EventEmitter {
 
   /**
    * Processes an incoming route request
-   * @param {Object} request - Route request data
+   * @param {any} request - Route request data
    * @param {string} sourcePeerId - Source peer ID
-   * @returns {Object|null} Reply to send or null
+   * @returns {any} Reply to send or null
    */
   processRouteRequest(request, sourcePeerId) {
     this._stats.requestsReceived++;
@@ -219,7 +216,7 @@ class PathFinder extends EventEmitter {
 
   /**
    * Processes an incoming route reply
-   * @param {Object} reply - Route reply data
+   * @param {any} reply - Route reply data
    * @param {string} sourcePeerId - Source peer ID
    */
   processRouteReply(reply, sourcePeerId) {
@@ -295,7 +292,7 @@ class PathFinder extends EventEmitter {
 
   /**
    * Gets path finder statistics
-   * @returns {Object} Statistics
+   * @returns {any} Statistics
    */
   getStats() {
     return {

package/src/mesh/router/RouteTable.js

@@ -26,9 +26,9 @@ const { ValidationError } = require('../../errors');
 class RouteTable {
   /**
    * Creates a new RouteTable
-   * @param {Object} [options] - Configuration options
-   * @param {number} [options.routeTimeout] - Route expiration timeout
-   * @param {number} [options.maxRoutes] - Maximum routes to store
+   * @param {any} [options] - Configuration options
+   *
+   *
    */
   constructor(options = {}) {
     /**
@@ -45,7 +45,7 @@ class RouteTable {
 
     /**
      * Routes by destination peer ID
-     * @type {Map<string, RouteEntry>}
+     * @type {Map<string, any>}
      * @private
      */
     this._routes = new Map();
@@ -130,7 +130,7 @@ class RouteTable {
   /**
    * Gets a route to a destination
    * @param {string} destination - Destination peer ID
-   * @returns {RouteEntry|undefined} Route or undefined
+   * @returns {any} Route or undefined
    */
   getRoute(destination) {
     const route = this._routes.get(destination);
@@ -197,7 +197,7 @@ class RouteTable {
 
   /**
    * Gets all valid routes
-   * @returns {RouteEntry[]} Array of routes
+   * @returns {any[]} Array of routes
    */
   getAllRoutes() {
     const now = Date.now();
@@ -244,6 +244,7 @@ class RouteTable {
    * @private
    */
   _evictOldestRoute() {
+    /** @type {string|null} */
     let oldest = null;
     let oldestTime = Infinity;
 
@@ -278,19 +279,29 @@ class RouteTable {
 
   /**
    * Gets routing table statistics
-   * @returns {Object} Statistics
+   * @returns {any} 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,10 +11,18 @@
 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 }, (/** @type {any} */ _, /** @type {number} */ i) => (i < 16 ? '0' : '') + i.toString(16));
 
 /**
  * Default configuration for store and forward
- * @constant {Object}
+ * @constant {any}
  */
 const DEFAULT_CONFIG = Object.freeze({
   /** Maximum number of cached messages per recipient */
@@ -60,26 +68,21 @@ const DEFAULT_CONFIG = Object.freeze({
 class StoreAndForwardManager extends EventEmitter {
   /**
      * Creates a new StoreAndForwardManager instance.
-     * @param {Object} [options={}] - Configuration options
-     * @param {number} [options.maxMessagesPerRecipient=100] - Max messages per recipient
-     * @param {number} [options.maxTotalMessages=1000] - Max total cached messages
-     * @param {number} [options.maxCacheSizeBytes=10485760] - Max cache size (10MB)
-     * @param {number} [options.retentionMs=86400000] - Message retention (24h)
-     * @param {number} [options.cleanupIntervalMs=300000] - Cleanup interval (5min)
+     * @param {any} [options={}] - Configuration options   *
      */
   constructor(options = {}) {
     super();
 
     /**
          * Configuration
-         * @type {Object}
+         * @type {any}
          * @private
          */
     this._config = { ...DEFAULT_CONFIG, ...options };
 
     /**
          * Message cache by recipient ID
-         * @type {Map<string, CachedMessage[]>}
+         * @type {Map<string, any[]>}
          * @private
          */
     this._cache = new Map();
@@ -100,14 +103,14 @@ class StoreAndForwardManager extends EventEmitter {
 
     /**
          * Cleanup timer
-         * @type {number|null}
+         * @type {any}
          * @private
          */
     this._cleanupTimer = null;
 
     /**
          * Statistics
-         * @type {Object}
+         * @type {any}
          * @private
          */
     this._stats = {
@@ -127,9 +130,9 @@ class StoreAndForwardManager extends EventEmitter {
      * Caches a message for an offline peer.
      * @param {string} recipientId - Recipient peer ID
      * @param {Uint8Array} encryptedPayload - Encrypted message payload
-     * @param {Object} [options={}] - Cache options
-     * @param {string} [options.messageId] - Message ID
-     * @param {number} [options.ttlMs] - Custom TTL in ms
+     * @param {any} [options={}] - Cache options
+   *
+   *
      * @returns {Promise<string>} Cached message ID
      */
   async cacheForOfflinePeer(recipientId, encryptedPayload, options = {}) {
@@ -165,7 +168,7 @@ class StoreAndForwardManager extends EventEmitter {
       this._cache.set(recipientId, []);
     }
 
-    const recipientCache = this._cache.get(recipientId);
+    const recipientCache = /** @type {any[]} */ (this._cache.get(recipientId));
 
     // Check per-recipient limit
     if (recipientCache.length >= this._config.maxMessagesPerRecipient) {
@@ -197,14 +200,15 @@ class StoreAndForwardManager extends EventEmitter {
      * Delivers all cached messages to a peer that came online.
      * @param {string} recipientId - Recipient peer ID
      * @param {Function} sendFn - Async function to send message: (payload) => Promise<void>
-     * @returns {Promise<Object>} Delivery result with counts
+     * @returns {Promise<any>} Delivery result with counts
      */
   async deliverCachedMessages(recipientId, sendFn) {
     if (!this._cache.has(recipientId)) {
       return { delivered: 0, failed: 0 };
     }
 
-    const messages = this._cache.get(recipientId);
+    const messages = /** @type {any[]} */ (this._cache.get(recipientId));
+    /** @type {any} */
     const results = { delivered: 0, failed: 0, remaining: [] };
 
     for (const msg of messages) {
@@ -230,7 +234,7 @@ class StoreAndForwardManager extends EventEmitter {
           messageId: msg.id,
           recipientId
         });
-      } catch (error) {
+      } catch (/** @type {any} */ error) {
         results.failed++;
         this._stats.deliveryFailures++;
         results.remaining.push(msg);
@@ -297,7 +301,7 @@ class StoreAndForwardManager extends EventEmitter {
     }
 
     const count = cache.length;
-    const size = cache.reduce((sum, m) => sum + m.size, 0);
+    const size = cache.reduce((/** @type {number} */ sum, /** @type {any} */ m) => sum + m.size, 0);
 
     this._cache.delete(recipientId);
     this._totalSize -= size;
@@ -315,7 +319,7 @@ class StoreAndForwardManager extends EventEmitter {
     let pruned = 0;
 
     for (const [recipientId, messages] of this._cache) {
-      const validMessages = messages.filter(msg => {
+      const validMessages = messages.filter((/** @type {any} */ msg) => {
         if (msg.expiresAt <= now) {
           this._totalSize -= msg.size;
           this._totalCount--;
@@ -342,7 +346,7 @@ class StoreAndForwardManager extends EventEmitter {
 
   /**
      * Gets store and forward statistics.
-     * @returns {Object} Statistics
+     * @returns {any} Statistics
      */
   getStats() {
     return {
@@ -410,6 +414,7 @@ class StoreAndForwardManager extends EventEmitter {
      */
   _removeOldestMessage() {
     let oldestTime = Infinity;
+    /** @type {string|null} */
     let oldestRecipient = null;
 
     for (const [recipientId, messages] of this._cache) {
@@ -420,7 +425,7 @@ class StoreAndForwardManager extends EventEmitter {
     }
 
     if (oldestRecipient) {
-      const messages = this._cache.get(oldestRecipient);
+      const messages = /** @type {any[]} */ (this._cache.get(oldestRecipient));
       const oldest = messages.shift();
       if (oldest) {
         this._totalSize -= oldest.size;
@@ -439,9 +444,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 = {