react-native-ble-mesh 2.0.0 → 2.1.2

package/src/expo/withBLEMesh.js

@@ -22,7 +22,7 @@
 
 /**
  * Default configuration
- * @constant {Object}
+ * @constant {any}
  */
 const DEFAULT_OPTIONS = {
   /** iOS NSBluetoothAlwaysUsageDescription */
@@ -40,9 +40,9 @@ const DEFAULT_OPTIONS = {
 
 /**
  * Modifies the iOS Info.plist for BLE permissions.
- * @param {Object} config - Expo config
- * @param {Object} options - Plugin options
- * @returns {Object} Modified config
+ * @param {any} config - Expo config
+ * @param {any} options - Plugin options
+ * @returns {any} Modified config
  */
 function withBLEMeshIOS(config, options) {
   const opts = { ...DEFAULT_OPTIONS, ...options };
@@ -64,9 +64,9 @@ function withBLEMeshIOS(config, options) {
 
 /**
  * Modifies the Android manifest for BLE permissions.
- * @param {Object} config - Expo config
- * @param {Object} options - Plugin options
- * @returns {Object} Modified config
+ * @param {any} config - Expo config
+ * @param {any} options - Plugin options
+ * @returns {any} Modified config
  */
 function withBLEMeshAndroid(config, options) {
   const opts = { ...DEFAULT_OPTIONS, ...options };
@@ -86,9 +86,9 @@ function withBLEMeshAndroid(config, options) {
 
 /**
  * Main Expo config plugin.
- * @param {Object} config - Expo config
- * @param {Object} [options={}] - Plugin options
- * @returns {Object} Modified config
+ * @param {any} config - Expo config
+ * @param {any} [options={}] - Plugin options
+ * @returns {any} Modified config
  */
 function withBLEMesh(config, options = {}) {
   config = withBLEMeshIOS(config, options);

package/src/hooks/AppStateManager.js

@@ -22,7 +22,7 @@
 class AppStateManager {
   /**
    * Creates a new AppStateManager
-   * @param {MeshService} mesh - MeshService instance to manage
+   * @param {any} mesh - MeshService instance to manage
    * @param {Object} [options] - Configuration options
    * @param {string} [options.backgroundMode='ULTRA_POWER_SAVER'] - Power mode for background
    * @param {string} [options.foregroundMode='BALANCED'] - Power mode for foreground
@@ -45,6 +45,8 @@ class AppStateManager {
     this._initialized = false;
     /** @private */
     this._AppState = null;
+    /** @private */
+    this._boundHandleStateChange = this._handleStateChange.bind(this);
   }
 
   /**
@@ -56,6 +58,7 @@ class AppStateManager {
 
     // Try to get AppState from React Native
     try {
+      // @ts-ignore
       const { AppState } = require('react-native');
       this._AppState = AppState;
     } catch (e) {
@@ -64,9 +67,15 @@ class AppStateManager {
       return false;
     }
 
+    // Remove old subscription before creating new one
+    if (this._subscription) {
+      this._subscription.remove();
+      this._subscription = null;
+    }
+
     this._subscription = this._AppState.addEventListener(
       'change',
-      this._handleStateChange.bind(this)
+      this._boundHandleStateChange
     );
 
     this._initialized = true;

package/src/hooks/useMesh.js

@@ -9,10 +9,8 @@
  * React hook for managing MeshService lifecycle in React Native apps.
  * Handles initialization, cleanup, and state management.
  *
- * @param {Object} [config] - MeshService configuration
- * @param {string} [config.displayName] - Display name for this node
- * @param {Object} [config.storage] - Storage adapter
- * @returns {Object} Mesh state and controls
+ * @param {any} [config] - MeshService configuration
+ * @returns {any} Mesh state and controls
  *
  * @example
  * function App() {
@@ -35,6 +33,7 @@ function useMesh(config = {}) {
   // This hook requires React - check if available
   let React;
   try {
+    // @ts-ignore
     React = require('react');
   } catch (e) {
     throw new Error('useMesh requires React. Install react as a dependency.');
@@ -47,6 +46,8 @@ function useMesh(config = {}) {
   // Create mesh instance ref (persists across renders)
   const meshRef = useRef(null);
   const mountedRef = useRef(true);
+  const stateHandlerRef = useRef(null);
+  const errorHandlerRef = useRef(null);
 
   // State
   const [state, setState] = useState('uninitialized');
@@ -63,7 +64,7 @@ function useMesh(config = {}) {
   }, [config.displayName]);
 
   // Initialize mesh
-  const initialize = useCallback(async (transport) => {
+  const initialize = useCallback(async (/** @type {any} */ transport) => {
     try {
       if (!mountedRef.current) { return; }
       setState('initializing');
@@ -71,18 +72,30 @@ function useMesh(config = {}) {
 
       const mesh = getMesh();
 
+      // Remove old listeners if they exist (prevents accumulation on re-init)
+      if (stateHandlerRef.current) {
+        mesh.off('state-changed', stateHandlerRef.current);
+      }
+      if (errorHandlerRef.current) {
+        mesh.off('error', errorHandlerRef.current);
+      }
+
       // Setup state change listener
-      mesh.on('state-changed', ({ newState }) => {
+      // @ts-ignore
+      stateHandlerRef.current = ({ newState }) => {
         if (mountedRef.current) {
           setState(newState);
         }
-      });
+      };
 
-      mesh.on('error', (err) => {
+      errorHandlerRef.current = (/** @type {any} */ err) => {
         if (mountedRef.current) {
           setError(err);
         }
-      });
+      };
+
+      mesh.on('state-changed', stateHandlerRef.current);
+      mesh.on('error', errorHandlerRef.current);
 
       // Initialize with storage
       await mesh.initialize({
@@ -105,7 +118,7 @@ function useMesh(config = {}) {
   }, [getMesh, config.storage]);
 
   // Start with transport
-  const start = useCallback(async (transport) => {
+  const start = useCallback(async (/** @type {any} */ transport) => {
     const mesh = getMesh();
     try {
       await mesh.start(transport);

package/src/hooks/useMessages.js

@@ -9,10 +9,10 @@
  * React hook for sending and receiving messages in the mesh network.
  * Manages message state and provides send functions.
  *
- * @param {MeshService} mesh - MeshService instance
- * @param {Object} [options] - Options
- * @param {number} [options.maxMessages=100] - Maximum messages to keep in state
- * @returns {Object} Messages state and send functions
+ * @param {any} mesh - MeshService instance
+ * @param {any} [options] - Options
+   *
+ * @returns {any} Messages state and send functions
  *
  * @example
  * function Chat({ mesh, peerId }) {
@@ -38,6 +38,7 @@ function useMessages(mesh, options = {}) {
   // This hook requires React
   let React;
   try {
+    // @ts-ignore
     React = require('react');
   } catch (e) {
     throw new Error('useMessages requires React. Install react as a dependency.');
@@ -52,17 +53,17 @@ function useMessages(mesh, options = {}) {
   const messageIdRef = useRef(new Set());
 
   // Add message to state (with dedup)
-  const addMessage = useCallback((msg) => {
+  const addMessage = useCallback((/** @type {any} */ msg) => {
     if (messageIdRef.current.has(msg.id)) { return; }
     messageIdRef.current.add(msg.id);
 
-    setMessages(prev => {
+    setMessages((/** @type {any} */ prev) => {
       const updated = [msg, ...prev];
-      // Trim to max messages
       if (updated.length > maxMessages) {
-        const removed = updated.slice(maxMessages);
-        removed.forEach(m => messageIdRef.current.delete(m.id));
-        return updated.slice(0, maxMessages);
+        for (let i = maxMessages; i < updated.length; i++) {
+          messageIdRef.current.delete(updated[i].id);
+        }
+        updated.length = maxMessages;
       }
       return updated;
     });
@@ -72,7 +73,7 @@ function useMessages(mesh, options = {}) {
   useEffect(() => {
     if (!mesh) { return; }
 
-    const handleBroadcast = (data) => {
+    const handleBroadcast = (/** @type {any} */ data) => {
       addMessage({
         id: data.messageId,
         type: 'broadcast',
@@ -83,7 +84,7 @@ function useMessages(mesh, options = {}) {
       });
     };
 
-    const handlePrivate = (data) => {
+    const handlePrivate = (/** @type {any} */ data) => {
       addMessage({
         id: data.messageId,
         type: 'private',
@@ -94,7 +95,7 @@ function useMessages(mesh, options = {}) {
       });
     };
 
-    const handleChannel = (data) => {
+    const handleChannel = (/** @type {any} */ data) => {
       addMessage({
         id: data.messageId,
         type: 'channel',
@@ -120,7 +121,7 @@ function useMessages(mesh, options = {}) {
   }, [mesh, addMessage]);
 
   // Send broadcast message
-  const sendBroadcast = useCallback((content) => {
+  const sendBroadcast = useCallback((/** @type {any} */ content) => {
     if (!mesh) { throw new Error('Mesh not initialized'); }
     setError(null);
 
@@ -142,7 +143,7 @@ function useMessages(mesh, options = {}) {
   }, [mesh, addMessage]);
 
   // Send private message
-  const sendPrivate = useCallback(async (peerId, content) => {
+  const sendPrivate = useCallback(async (/** @type {any} */ peerId, /** @type {any} */ content) => {
     if (!mesh) { throw new Error('Mesh not initialized'); }
     setError(null);
     setSending(true);
@@ -168,7 +169,7 @@ function useMessages(mesh, options = {}) {
   }, [mesh, addMessage]);
 
   // Send channel message
-  const sendToChannel = useCallback((channelId, content) => {
+  const sendToChannel = useCallback((/** @type {any} */ channelId, /** @type {any} */ content) => {
     if (!mesh) { throw new Error('Mesh not initialized'); }
     setError(null);
 

package/src/hooks/usePeers.js

@@ -9,8 +9,8 @@
  * React hook for managing and observing peers in the mesh network.
  * Automatically updates when peers connect, disconnect, or change state.
  *
- * @param {MeshService} mesh - MeshService instance
- * @returns {Object} Peers state and utilities
+ * @param {any} mesh - MeshService instance
+ * @returns {any} Peers state and utilities
  *
  * @example
  * function PeerList({ mesh }) {
@@ -30,23 +30,29 @@ function usePeers(mesh) {
   // This hook requires React
   let React;
   try {
+    // @ts-ignore
     React = require('react');
   } catch (e) {
     throw new Error('usePeers requires React. Install react as a dependency.');
   }
 
-  const { useState, useEffect, useCallback, useMemo } = React;
+  const { useState, useEffect, useCallback, useMemo, useRef } = React;
 
   const [peers, setPeers] = useState([]);
-  const [lastUpdate, setLastUpdate] = useState(Date.now());
+  const lastUpdateRef = useRef(Date.now());
 
   // Update peers from mesh
   const refreshPeers = useCallback(() => {
     if (mesh) {
       try {
         const allPeers = mesh.getPeers();
-        setPeers(allPeers);
-        setLastUpdate(Date.now());
+        setPeers((/** @type {any} */ prev) => {
+          if (prev.length === allPeers.length && prev.every((/** @type {any} */ p, /** @type {any} */ i) => p.id === allPeers[i]?.id && p.connectionState === allPeers[i]?.connectionState)) {
+            return prev;
+          }
+          return allPeers;
+        });
+        lastUpdateRef.current = Date.now();
       } catch (e) {
         // Mesh might not be ready
       }
@@ -77,20 +83,19 @@ function usePeers(mesh) {
 
   // Computed values
   const connectedPeers = useMemo(() => {
-    return peers.filter(p => p.connectionState === 'connected' || p.connectionState === 'secured');
+    return peers.filter((/** @type {any} */ p) => p.connectionState === 'connected' || p.connectionState === 'secured');
   }, [peers]);
 
   const securedPeers = useMemo(() => {
-    return peers.filter(p => p.connectionState === 'secured');
+    return peers.filter((/** @type {any} */ p) => p.connectionState === 'secured');
   }, [peers]);
 
-  // Get single peer by ID
-  const getPeer = useCallback((peerId) => {
-    return peers.find(p => p.id === peerId);
-  }, [peers]);
+  // Get single peer by ID (O(1) lookup via peerMap)
+  const peerMap = useMemo(() => new Map(peers.map((/** @type {any} */ p) => [p.id, p])), [peers]);
+  const getPeer = useCallback((/** @type {any} */ peerId) => peerMap.get(peerId), [peerMap]);
 
   // Check if peer is connected
-  const isConnected = useCallback((peerId) => {
+  const isConnected = useCallback((/** @type {any} */ peerId) => {
     const peer = getPeer(peerId);
     return peer && (peer.connectionState === 'connected' || peer.connectionState === 'secured');
   }, [getPeer]);
@@ -104,7 +109,7 @@ function usePeers(mesh) {
     getPeer,
     isConnected,
     refresh: refreshPeers,
-    lastUpdate
+    lastUpdate: lastUpdateRef.current
   };
 }
 

package/src/index.js

@@ -69,7 +69,7 @@ function createMeshNetwork(config) {
 
 /**
  * Create a new MeshService instance
- * @param {Object} [config] - Configuration options
+ * @param {any} [config] - Configuration options
  * @returns {MeshService}
  */
 function createMeshService(config) {
@@ -80,7 +80,7 @@ function createMeshService(config) {
  * Create and initialize a MeshService for Node.js usage
  * @param {Object} [options] - Configuration options
  * @param {string} [options.displayName='MeshNode'] - Display name for this node
- * @param {Object} [options.storage=null] - Storage adapter (null for MemoryStorage)
+ * @param {any} [options.storage=null] - Storage adapter (null for MemoryStorage)
  * @returns {Promise<MeshService>} Initialized MeshService
  * @example
  * const mesh = await createNodeMesh({ displayName: 'Alice' });

package/src/mesh/dedup/BloomFilter.js

@@ -13,6 +13,16 @@
 const FNV_PRIME = 0x01000193;
 const FNV_OFFSET = 0x811c9dc5;
 
+// Cached TextEncoder singleton (avoids per-call allocation)
+/** @type {any} */
+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 +66,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 +107,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 +163,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

@@ -29,13 +29,10 @@ const DEFAULT_CONFIG = {
 class DedupManager {
   /**
    * Creates a new DedupManager
-   * @param {Object} [options] - Configuration options
-   * @param {number} [options.bloomFilterSize] - Size of Bloom filter in bits
-   * @param {number} [options.bloomHashCount] - Number of hash functions
-   * @param {number} [options.cacheSize] - Maximum LRU cache entries
-   * @param {number} [options.autoResetThreshold] - Fill ratio for auto reset
+   * @param {any} [options] - Configuration options   *
    */
   constructor(options = {}) {
+    /** @type {any} */
     const config = { ...DEFAULT_CONFIG, ...options };
 
     /**
@@ -69,9 +66,16 @@ 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}
+     * @type {any}
      * @private
      */
     this._stats = {
@@ -165,9 +169,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 +185,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++;
@@ -182,7 +197,7 @@ class DedupManager {
 
   /**
    * Gets deduplication statistics
-   * @returns {Object} Statistics object
+   * @returns {any} Statistics object
    */
   getStats() {
     return {
@@ -233,6 +248,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/dedup/MessageCache.js

@@ -19,7 +19,9 @@ class CacheNode {
   constructor(key, timestamp) {
     this.key = key;
     this.timestamp = timestamp;
+    /** @type {CacheNode|null} */
     this.prev = null;
+    /** @type {CacheNode|null} */
     this.next = null;
   }
 }
@@ -207,6 +209,7 @@ class MessageCache {
    */
   getAll() {
     const result = [];
+    /** @type {CacheNode|null} */
     let node = this._head;
     while (node) {
       result.push(node.key);

package/src/mesh/fragment/Assembler.js

@@ -31,6 +31,7 @@ class PendingFragmentSet {
   constructor(messageId, total, timeout) {
     this.messageId = messageId;
     this.total = total;
+    /** @type {Map<number, Uint8Array>} */
     this.received = new Map();
     this.createdAt = Date.now();
     this.expiresAt = this.createdAt + timeout;
@@ -97,7 +98,7 @@ class PendingFragmentSet {
 
   /**
    * Gets progress information
-   * @returns {Object} Progress { received, total, percent }
+   * @returns {any} Progress { received, total, percent }
    */
   getProgress() {
     return {
@@ -137,7 +138,7 @@ class Assembler {
 
     /**
      * Statistics
-     * @type {Object}
+     * @type {any}
      * @private
      */
     this._stats = {
@@ -236,7 +237,7 @@ class Assembler {
   /**
    * Gets progress for a pending message
    * @param {string} messageId - Message ID
-   * @returns {Object|null} Progress or null if not found
+   * @returns {any} Progress or null if not found
    */
   getProgress(messageId) {
     const pendingSet = this._pending.get(messageId);
@@ -254,7 +255,7 @@ class Assembler {
 
   /**
    * Gets assembler statistics
-   * @returns {Object} Statistics
+   * @returns {any} Statistics
    */
   getStats() {
     return {