react-native-ble-mesh 2.1.0 → 2.1.2

package/src/storage/MemoryStorage.js

@@ -18,9 +18,9 @@ const Storage = require('./Storage');
 class MemoryStorage extends Storage {
   /**
    * Creates a new MemoryStorage instance
-   * @param {Object} [options={}] - Storage options
-   * @param {string} [options.prefix=''] - Key prefix for namespacing
-   * @param {number} [options.maxSize=0] - Maximum number of items (0 = unlimited)
+   * @param {any} [options={}] - Storage options
+   *
+   *
    */
   constructor(options = {}) {
     super(options);
@@ -66,8 +66,8 @@ class MemoryStorage extends Storage {
    * Sets a value by key
    * @param {string} key - Key to set
    * @param {any} value - Value to store
-   * @param {Object} [options={}] - Set options
-   * @param {number} [options.ttl] - Time to live in milliseconds
+   * @param {any} [options={}] - Set options
+   *
    * @returns {Promise<void>}
    */
   async set(key, value, options = {}) {
@@ -79,9 +79,12 @@ class MemoryStorage extends Storage {
         this._store.size >= this._maxSize) {
       // Remove oldest entry (first entry in Map)
       const firstKey = this._store.keys().next().value;
-      this._store.delete(firstKey);
+      if (firstKey !== undefined) {
+        this._store.delete(firstKey);
+      }
     }
 
+    /** @type {any} */
     const item = {
       value,
       createdAt: Date.now()
@@ -156,7 +159,7 @@ class MemoryStorage extends Storage {
         const unprefixedKey = prefix ? key.slice(prefix.length) : key;
         // Check expiration before including
         const item = this._store.get(key);
-        if (!item.expiresAt || Date.now() <= item.expiresAt) {
+        if (item && (!item.expiresAt || Date.now() <= item.expiresAt)) {
           result.push(unprefixedKey);
         }
       }
@@ -196,7 +199,7 @@ class MemoryStorage extends Storage {
 
   /**
    * Gets all entries as an array of [key, value] pairs
-   * @returns {Promise<Array>} Array of [key, value] entries
+   * @returns {Promise<any[]>} Array of [key, value] entries
    */
   async entries() {
     const allKeys = await this.keys();

package/src/storage/MessageStore.js

@@ -14,6 +14,10 @@ const { MESH_CONFIG } = require('../constants');
  */
 const BASE64_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
 
+/**
+ * @param {Uint8Array} bytes
+ * @returns {string}
+ */
 function uint8ArrayToBase64(bytes) {
   let result = '';
   const len = bytes.length;
@@ -34,6 +38,10 @@ for (let i = 0; i < BASE64_CHARS.length; i++) {
   BASE64_LOOKUP[BASE64_CHARS.charCodeAt(i)] = i;
 }
 
+/**
+ * @param {string} str
+ * @returns {Uint8Array}
+ */
 function base64ToUint8Array(str) {
   const len = str.length;
   let padding = 0;
@@ -63,15 +71,12 @@ function base64ToUint8Array(str) {
 class MessageStore {
   /**
    * Creates a new MessageStore instance
-   * @param {Object} [options={}] - Store options
-   * @param {Object} [options.storage] - Storage backend (defaults to MemoryStorage)
-   * @param {number} [options.maxMessages=1000] - Maximum messages to store
-   * @param {number} [options.messageTtlMs] - Message TTL in milliseconds
+   * @param {any} [options={}] - Store options   *
    */
   constructor(options = {}) {
     /**
      * Storage backend
-     * @type {Object}
+     * @type {any}
      * @private
      */
     this._storage = options.storage || new MemoryStorage({
@@ -88,7 +93,7 @@ class MessageStore {
 
     /**
      * Index storage for queries
-     * @type {Object}
+     * @type {any}
      * @private
      */
     this._indexStorage = options.indexStorage || new MemoryStorage({
@@ -98,13 +103,7 @@ class MessageStore {
 
   /**
    * Saves a message to storage
-   * @param {Object} message - Message to save
-   * @param {string} message.id - Message ID
-   * @param {number} message.type - Message type
-   * @param {Uint8Array} [message.payload] - Message payload
-   * @param {string} [message.senderId] - Sender peer ID
-   * @param {string} [message.recipientId] - Recipient peer ID
-   * @param {number} [message.timestamp] - Message timestamp
+   * @param {any} message - Message to save   *
    * @returns {Promise<void>}
    */
   async saveMessage(message) {
@@ -132,7 +131,7 @@ class MessageStore {
   /**
    * Gets a message by ID
    * @param {string} id - Message ID
-   * @returns {Promise<Object|null>} Message or null if not found
+   * @returns {Promise<any>} Message or null if not found
    */
   async getMessage(id) {
     const message = await this._storage.get(id);
@@ -157,15 +156,8 @@ class MessageStore {
 
   /**
    * Gets messages matching query options
-   * @param {Object} [options={}] - Query options
-   * @param {string} [options.senderId] - Filter by sender ID
-   * @param {string} [options.recipientId] - Filter by recipient ID
-   * @param {number} [options.type] - Filter by message type
-   * @param {number} [options.since] - Filter messages since timestamp
-   * @param {number} [options.until] - Filter messages until timestamp
-   * @param {number} [options.limit=50] - Maximum messages to return
-   * @param {number} [options.offset=0] - Offset for pagination
-   * @returns {Promise<Object[]>} Array of messages
+   * @param {any} [options={}] - Query options   *
+   * @returns {Promise<any[]>} Array of messages
    */
   async getMessages(options = {}) {
     const {
@@ -270,7 +262,7 @@ class MessageStore {
    * Gets messages by sender
    * @param {string} senderId - Sender peer ID
    * @param {number} [limit=50] - Maximum messages
-   * @returns {Promise<Object[]>} Array of messages
+   * @returns {Promise<any[]>} Array of messages
    */
   async getMessagesBySender(senderId, limit = 50) {
     return this.getMessages({ senderId, limit });
@@ -280,7 +272,7 @@ class MessageStore {
    * Gets messages by recipient
    * @param {string} recipientId - Recipient peer ID
    * @param {number} [limit=50] - Maximum messages
-   * @returns {Promise<Object[]>} Array of messages
+   * @returns {Promise<any[]>} Array of messages
    */
   async getMessagesByRecipient(recipientId, limit = 50) {
     return this.getMessages({ recipientId, limit });
@@ -291,7 +283,7 @@ class MessageStore {
    * @param {string} peerId1 - First peer ID
    * @param {string} peerId2 - Second peer ID
    * @param {number} [limit=50] - Maximum messages
-   * @returns {Promise<Object[]>} Array of messages
+   * @returns {Promise<any[]>} Array of messages
    */
   async getConversation(peerId1, peerId2, limit = 50) {
     const allKeys = await this._storage.keys();
@@ -316,7 +308,7 @@ class MessageStore {
 
   /**
    * Updates indexes for a message
-   * @param {Object} message - Message to index
+   * @param {any} message - Message to index
    * @returns {Promise<void>}
    * @private
    */
@@ -344,7 +336,7 @@ class MessageStore {
 
   /**
    * Removes a message from indexes
-   * @param {Object} message - Message to remove from indexes
+   * @param {any} message - Message to remove from indexes
    * @returns {Promise<void>}
    * @private
    */
@@ -352,14 +344,14 @@ class MessageStore {
     if (message.senderId) {
       const key = `sender:${message.senderId}`;
       const ids = (await this._indexStorage.get(key)) || [];
-      const filtered = ids.filter(id => id !== message.id);
+      const filtered = ids.filter((/** @type {any} */ id) => id !== message.id);
       await this._indexStorage.set(key, filtered);
     }
 
     if (message.recipientId) {
       const key = `recipient:${message.recipientId}`;
       const ids = (await this._indexStorage.get(key)) || [];
-      const filtered = ids.filter(id => id !== message.id);
+      const filtered = ids.filter((/** @type {any} */ id) => id !== message.id);
       await this._indexStorage.set(key, filtered);
     }
   }

package/src/storage/Storage.js

@@ -15,13 +15,13 @@
 class Storage {
   /**
    * Creates a new Storage instance
-   * @param {Object} [options={}] - Storage options
-   * @param {string} [options.prefix=''] - Key prefix for namespacing
+   * @param {any} [options={}] - Storage options
+   *
    */
   constructor(options = {}) {
     /**
      * Storage options
-     * @type {Object}
+     * @type {any}
      * @protected
      */
     this._options = {
@@ -43,7 +43,7 @@ class Storage {
   /**
    * Gets a value by key
    * @abstract
-   * @param {string} key - Key to retrieve
+   * @param {string} _key - Key to retrieve
    * @returns {Promise<any>} Stored value or undefined
    * @throws {Error} If not implemented by subclass
    */
@@ -54,8 +54,8 @@ class Storage {
   /**
    * Sets a value by key
    * @abstract
-   * @param {string} key - Key to set
-   * @param {any} value - Value to store
+   * @param {string} _key - Key to set
+   * @param {any} _value - Value to store
    * @returns {Promise<void>}
    * @throws {Error} If not implemented by subclass
    */
@@ -66,7 +66,7 @@ class Storage {
   /**
    * Deletes a value by key
    * @abstract
-   * @param {string} key - Key to delete
+   * @param {string} _key - Key to delete
    * @returns {Promise<void>}
    * @throws {Error} If not implemented by subclass
    */
@@ -77,7 +77,7 @@ class Storage {
   /**
    * Checks if a key exists
    * @abstract
-   * @param {string} key - Key to check
+   * @param {string} _key - Key to check
    * @returns {Promise<boolean>} True if key exists
    * @throws {Error} If not implemented by subclass
    */
@@ -134,7 +134,7 @@ class Storage {
 
   /**
    * Sets multiple key-value pairs
-   * @param {Map<string, any>|Object} entries - Entries to set
+   * @param {Map<string, any>|any} entries - Entries to set
    * @returns {Promise<void>}
    */
   async setMany(entries) {

package/src/transport/BLETransport.js

@@ -25,7 +25,7 @@ const { ConnectionError } = require('../errors');
 class BLETransport extends Transport {
   /**
    * Creates a new BLETransport instance
-   * @param {Object} adapter - BLE adapter instance (RNBLEAdapter or NodeBLEAdapter)
+   * @param {any} adapter - BLE adapter instance (RNBLEAdapter or NodeBLEAdapter)
    * @param {Object} [options={}] - Transport options
    * @param {string} [options.powerMode='BALANCED'] - Power mode
    * @param {number} [options.maxPeers=8] - Maximum peers
@@ -41,16 +41,17 @@ class BLETransport extends Transport {
 
     /**
      * BLE adapter instance
-     * @type {Object}
+     * @type {any}
      * @private
      */
     this._adapter = adapter;
 
     /**
      * Current power mode
-     * @type {Object}
+     * @type {any}
      * @private
      */
+    // @ts-ignore
     this._powerMode = POWER_MODE[options.powerMode] || POWER_MODE.BALANCED;
 
     /**
@@ -76,7 +77,7 @@ class BLETransport extends Transport {
 
     /**
      * Per-peer write queues for serializing BLE writes
-     * @type {Map<string, Array>}
+     * @type {Map<string, any[]>}
      * @private
      */
     this._writeQueue = new Map();
@@ -90,7 +91,7 @@ class BLETransport extends Transport {
 
     /**
      * Bound event handlers for cleanup
-     * @type {Object}
+     * @type {any}
      * @private
      */
     this._handlers = {
@@ -140,7 +141,7 @@ class BLETransport extends Transport {
 
       // Register disconnect callback if adapter supports it
       if (typeof this._adapter.onDeviceDisconnected === 'function') {
-        this._adapter.onDeviceDisconnected((peerId) => {
+        this._adapter.onDeviceDisconnected((/** @type {any} */ peerId) => {
           this._handleDeviceDisconnected(peerId);
         });
       }
@@ -149,7 +150,7 @@ class BLETransport extends Transport {
 
       // Auto-start scanning for peers
       await this.startScanning();
-    } catch (error) {
+    } catch (/** @type {any} */ error) {
       this._setState(Transport.STATE.ERROR);
       throw error;
     }
@@ -232,12 +233,12 @@ class BLETransport extends Transport {
     }
 
     try {
-      let timeoutId;
+      /** @type {any} */ let timeoutId;
       const timeoutPromise = new Promise((_, reject) => {
         timeoutId = setTimeout(() => reject(new Error('Connection timeout')), this._connectTimeoutMs);
       });
       const device = await Promise.race([
-        this._adapter.connect(peerId).then(d => { clearTimeout(timeoutId); return d; }),
+        this._adapter.connect(peerId).then((/** @type {any} */ d) => { clearTimeout(timeoutId); return d; }),
         timeoutPromise
       ]);
 
@@ -259,7 +260,7 @@ class BLETransport extends Transport {
         peerId,
         BLE_SERVICE_UUID,
         BLE_CHARACTERISTIC_RX,
-        (data) => this._handleData(peerId, data)
+        (/** @type {any} */ data) => this._handleData(peerId, data)
       );
 
       const connectionInfo = {
@@ -271,7 +272,7 @@ class BLETransport extends Transport {
 
       this._peers.set(peerId, connectionInfo);
       this.emit('peerConnected', { peerId, rssi: device.rssi || -50 });
-    } catch (error) {
+    } catch (/** @type {any} */ error) {
       if (error.message === 'Connection timeout') {
         throw ConnectionError.connectionTimeout(peerId);
       }
@@ -362,7 +363,7 @@ class BLETransport extends Transport {
    * @param {string} modeName - Power mode name (PERFORMANCE, BALANCED, POWER_SAVER)
    */
   setPowerMode(modeName) {
-    const mode = POWER_MODE[modeName];
+    const mode = /** @type {any} */ (POWER_MODE)[modeName];
     if (mode) {
       this._powerMode = mode;
     }
@@ -384,7 +385,7 @@ class BLETransport extends Transport {
 
   /**
    * Handles discovered BLE devices
-   * @param {Object} device - Discovered device info
+   * @param {any} device - Discovered device info
    * @private
    */
   _handleDeviceDiscovered(device) {
@@ -452,7 +453,8 @@ class BLETransport extends Transport {
     }
 
     return new Promise((resolve, reject) => {
-      this._writeQueue.get(peerId).push({ data, resolve, reject });
+      // @ts-ignore
+      this?._writeQueue.get(peerId).push({ data, resolve, reject });
       this._processWriteQueue(peerId);
     });
   }

package/src/transport/MockTransport.js

@@ -50,6 +50,7 @@ class MockTransport extends Transport {
      * @type {string|null}
      * @private
      */
+    // @ts-ignore
     this._localPeerId = options.localPeerId || `mock-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   }
 
@@ -122,7 +123,8 @@ class MockTransport extends Transport {
 
     // Deliver to linked transport if available
     const linkedTransport = this._linkedTransports.get(peerId);
-    if (linkedTransport && linkedTransport.isRunning) {
+    if (linkedTransport && /** @type {any} */ (linkedTransport).isRunning) {
+      // @ts-ignore
       linkedTransport._receiveMessage(this._localPeerId, data);
     }
   }
@@ -157,7 +159,7 @@ class MockTransport extends Transport {
   /**
    * Simulates a peer connection
    * @param {string} peerId - Connecting peer ID
-   * @param {Object} [info={}] - Connection info (rssi, etc.)
+   * @param {any} [info={}] - Connection info (rssi, etc.)
    */
   simulatePeerConnect(peerId, info = {}) {
     if (!this.isRunning || this._peers.has(peerId)) {
@@ -203,6 +205,7 @@ class MockTransport extends Transport {
     }
 
     this._linkedTransports.set(otherPeerId, otherTransport);
+    // @ts-ignore
     otherTransport._linkedTransports.set(this._localPeerId, this);
   }
 
@@ -212,7 +215,9 @@ class MockTransport extends Transport {
    */
   unlinkFrom(otherTransport) {
     const otherPeerId = otherTransport.localPeerId;
+    // @ts-ignore
     this._linkedTransports.delete(otherPeerId);
+    // @ts-ignore
     otherTransport._linkedTransports.delete(this._localPeerId);
   }
 

package/src/transport/MultiTransport.js

@@ -16,7 +16,7 @@ const Transport = require('./Transport');
 
 /**
  * Transport selection strategies
- * @constant {Object}
+ * @constant {any}
  */
 const STRATEGY = Object.freeze({
   /** Always use BLE */
@@ -45,6 +45,7 @@ class MultiTransport extends Transport {
    * @param {number} [options.wifiThresholdBytes=1024] - Use Wi-Fi Direct for payloads above this size
    */
   constructor(options = {}) {
+    // @ts-ignore
     super(options);
 
     this._bleTransport = options.bleTransport || null;
@@ -83,6 +84,7 @@ class MultiTransport extends Transport {
     if (this._bleTransport) {
       startPromises.push(
         this._bleTransport.start()
+          // @ts-ignore
           .then(() => this._wireTransport(this._bleTransport, 'ble'))
           .catch(err => {
             this.emit('transportError', { transport: 'ble', error: err });
@@ -93,6 +95,7 @@ class MultiTransport extends Transport {
     if (this._wifiTransport) {
       startPromises.push(
         this._wifiTransport.start()
+          // @ts-ignore
           .then(() => this._wireTransport(this._wifiTransport, 'wifi-direct'))
           .catch(err => {
             this.emit('transportError', { transport: 'wifi-direct', error: err });
@@ -170,6 +173,7 @@ class MultiTransport extends Transport {
     if (!this.isRunning) { throw new Error('Transport is not running'); }
 
     const allPeerIds = new Set();
+    /** @type {string[]} */
     const successPeerIds = [];
 
     // Collect all peers from all transports
@@ -191,6 +195,7 @@ class MultiTransport extends Transport {
       if (r.status === 'fulfilled') { successPeerIds.push(r.value); }
     });
 
+    // @ts-ignore
     return successPeerIds;
   }
 
@@ -228,9 +233,11 @@ class MultiTransport extends Transport {
   _selectTransport(peerId, dataSize) {
     switch (this._strategy) {
       case STRATEGY.BLE_ONLY:
+        // @ts-ignore
         return this._bleTransport;
 
       case STRATEGY.WIFI_ONLY:
+        // @ts-ignore
         return this._wifiTransport;
 
       case STRATEGY.AUTO:
@@ -282,13 +289,13 @@ class MultiTransport extends Transport {
    * @private
    */
   _wireTransport(transport, name) {
-    const onPeerConnected = (info) => {
+    const onPeerConnected = (/** @type {any} */ info) => {
       this._peerTransportMap.set(info.peerId, name);
       this._peers.set(info.peerId, { ...info, transport: name });
       this.emit('peerConnected', { ...info, transport: name });
     };
 
-    const onPeerDisconnected = (info) => {
+    const onPeerDisconnected = (/** @type {any} */ info) => {
       // Only remove if no other transport has this peer
       const otherTransport = this._getFallbackTransport(transport);
       if (!otherTransport || !otherTransport.isConnected(info.peerId)) {
@@ -298,15 +305,15 @@ class MultiTransport extends Transport {
       }
     };
 
-    const onMessage = (msg) => {
+    const onMessage = (/** @type {any} */ msg) => {
       this.emit('message', { ...msg, transport: name });
     };
 
-    const onDeviceDiscovered = (info) => {
+    const onDeviceDiscovered = (/** @type {any} */ info) => {
       this.emit('deviceDiscovered', { ...info, transport: name });
     };
 
-    const onError = (err) => {
+    const onError = (/** @type {any} */ err) => {
       this.emit('transportError', { transport: name, error: err });
     };
 

package/src/transport/Transport.js

@@ -9,7 +9,7 @@ const EventEmitter = require('../utils/EventEmitter');
 
 /**
  * Transport states
- * @constant {Object.<string, string>}
+ * @type {Record<string, string>}
  */
 const TRANSPORT_STATE = Object.freeze({
   STOPPED: 'stopped',
@@ -44,7 +44,7 @@ class Transport extends EventEmitter {
 
     /**
      * Transport options
-     * @type {Object}
+     * @type {any}
      * @protected
      */
     this._options = {
@@ -61,7 +61,7 @@ class Transport extends EventEmitter {
 
     /**
      * Connected peers map (peerId -> connection info)
-     * @type {Map<string, Object>}
+     * @type {Map<string, any>}
      * @protected
      */
     this._peers = new Map();
@@ -119,23 +119,23 @@ class Transport extends EventEmitter {
   /**
    * Sends data to a specific peer
    * @abstract
-   * @param {string} peerId - Target peer ID
-   * @param {Uint8Array} data - Data to send
+   * @param {string} _peerId - Target peer ID
+   * @param {Uint8Array} _data - Data to send
    * @returns {Promise<void>}
    * @throws {Error} If not implemented by subclass
    */
-  async send(_peerId, _data) {
+  async send(/** @type {any} */ _peerId, _data) {
     throw new Error('Transport.send() must be implemented by subclass');
   }
 
   /**
    * Broadcasts data to all connected peers
    * @abstract
-   * @param {Uint8Array} data - Data to broadcast
+   * @param {Uint8Array} _data - Data to broadcast
    * @returns {Promise<string[]>} Array of peer IDs that received the broadcast
    * @throws {Error} If not implemented by subclass
    */
-  async broadcast(_data) {
+  async broadcast(/** @type {any} */ _data) {
     throw new Error('Transport.broadcast() must be implemented by subclass');
   }
 
@@ -159,7 +159,7 @@ class Transport extends EventEmitter {
   /**
    * Gets connection info for a peer
    * @param {string} peerId - Peer ID
-   * @returns {Object|undefined} Connection info or undefined
+   * @returns {any} Connection info or undefined
    */
   getPeerInfo(peerId) {
     return this._peers.get(peerId);