react-native-ble-mesh 2.0.0 → 2.1.2

package/src/service/text/TextManager.js

@@ -12,9 +12,16 @@ const TextMessage = require('./message/TextMessage');
 const { ChannelManager } = require('./channel');
 const { BroadcastManager } = require('./broadcast');
 
+/**
+ * Cached TextEncoder/TextDecoder instances to avoid per-call allocation
+ * @private
+ */
+const cachedEncoder = new TextEncoder();
+const cachedDecoder = new TextDecoder();
+
 /**
  * Text manager states
- * @constant {Object}
+ * @constant {any}
  */
 const MANAGER_STATE = Object.freeze({
   UNINITIALIZED: 'uninitialized',
@@ -33,34 +40,34 @@ const MANAGER_STATE = Object.freeze({
 class TextManager extends EventEmitter {
   /**
    * Creates a new TextManager
-   * @param {Object} [options] - Manager options
+   * @param {any} [options] - Manager options
    */
   constructor(options = {}) {
     super();
 
-    /** @private */
+    /** @type {string} @private */
     this._state = MANAGER_STATE.UNINITIALIZED;
-    /** @private */
+    /** @type {any} @private */
     this._meshService = null;
     /** @private */
     this._channelManager = new ChannelManager();
     /** @private */
     this._broadcastManager = new BroadcastManager(options.broadcast);
-    /** @private */
+    /** @type {string | null} @private */
     this._senderId = null;
-    /** @private */
+    /** @type {number} @private */
     this._messageCounter = 0;
-    /** @private */
+    /** @type {Set<string>} @private */
     this._pendingReadReceipts = new Set();
-    /** @private */
+    /** @type {ReturnType<typeof setTimeout> | null} @private */
     this._readReceiptBatchTimeout = null;
-    /** @private */
+    /** @type {number} @private */
     this._readReceiptBatchDelayMs = options.readReceiptBatchDelayMs || 1000;
   }
 
   /**
    * Initializes the text manager
-   * @param {MeshService} meshService - Mesh service instance
+   * @param {any} meshService - Mesh service instance
    * @returns {Promise<void>}
    */
   async initialize(meshService) {
@@ -82,7 +89,7 @@ class TextManager extends EventEmitter {
       // Initialize broadcast manager
       this._broadcastManager.initialize({
         senderId: this._senderId,
-        sendCallback: (message) => this._sendBroadcastMessage(message)
+        sendCallback: (/** @type {any} */ message) => this._sendBroadcastMessage(message)
       });
 
       // Setup event forwarding
@@ -90,7 +97,7 @@ class TextManager extends EventEmitter {
 
       this._setState(MANAGER_STATE.READY);
       this.emit('initialized');
-    } catch (error) {
+    } catch (/** @type {any} */ error) {
       this._setState(MANAGER_STATE.ERROR);
       throw new MeshError(`Text manager initialization failed: ${error.message}`, ERROR_CODE.E001);
     }
@@ -196,7 +203,7 @@ class TextManager extends EventEmitter {
   /**
    * Gets recent broadcasts
    * @param {number} [limit] - Maximum number to return
-   * @returns {TextMessage[]}
+   * @returns {any[]}
    */
   getRecentBroadcasts(limit) {
     return this._broadcastManager.getRecentBroadcasts(limit);
@@ -208,6 +215,7 @@ class TextManager extends EventEmitter {
    * Joins a channel
    * @param {string} channelId - Channel ID
    * @param {string} [password] - Optional password
+   * @returns {any}
    */
   joinChannel(channelId, password) {
     this._validateReady();
@@ -280,7 +288,7 @@ class TextManager extends EventEmitter {
 
   /**
    * Gets all joined channels
-   * @returns {Object[]}
+   * @returns {any[]}
    */
   getChannels() {
     return this._channelManager.getChannels();
@@ -289,7 +297,7 @@ class TextManager extends EventEmitter {
   /**
    * Gets a specific channel
    * @param {string} channelId - Channel ID
-   * @returns {Channel|undefined}
+   * @returns {any}
    */
   getChannel(channelId) {
     return this._channelManager.getChannel(channelId);
@@ -351,6 +359,7 @@ class TextManager extends EventEmitter {
         // Extract channel ID from payload
         this._handleChannelMessagePayload(peerId, payload);
         break;
+      // @ts-ignore
       case MESSAGE_TYPE.READ_RECEIPT:
         this._handleReadReceipt(peerId, payload);
         break;
@@ -372,20 +381,25 @@ class TextManager extends EventEmitter {
       EVENTS.CHANNEL_MEMBER_JOINED,
       EVENTS.CHANNEL_MEMBER_LEFT
     ];
-    channelEvents.forEach(event => {
-      this._channelManager.on(event, data => this.emit(event, data));
+    channelEvents.forEach((/** @type {any} */ event) => {
+      this._channelManager.on(event, (/** @type {any} */ data) => this.emit(event, data));
     });
 
     // Forward broadcast events
-    this._broadcastManager.on('broadcast-sent', data => {
+    this._broadcastManager.on('broadcast-sent', (/** @type {any} */ data) => {
       this.emit(EVENTS.BROADCAST_SENT, data);
     });
-    this._broadcastManager.on('broadcast-received', data => {
+    this._broadcastManager.on('broadcast-received', (/** @type {any} */ data) => {
       this.emit(EVENTS.BROADCAST_RECEIVED, data);
     });
   }
 
-  /** @private */
+  /**
+   * @param {string} peerId - Peer ID
+   * @param {number} type - Message type
+   * @param {Uint8Array} payload - Message payload
+   * @private
+   */
   async _sendMessage(peerId, type, payload) {
     const data = new Uint8Array(1 + payload.length);
     data[0] = type;
@@ -396,7 +410,10 @@ class TextManager extends EventEmitter {
     }
   }
 
-  /** @private */
+  /**
+   * @param {any} message - Message to broadcast
+   * @private
+   */
   async _sendBroadcastMessage(message) {
     const serialized = message.serialize();
     const data = new Uint8Array(1 + serialized.length);
@@ -416,26 +433,35 @@ class TextManager extends EventEmitter {
     }
   }
 
-  /** @private */
+  /**
+   * @param {string} peerId - Peer ID
+   * @param {Uint8Array} payload - Message payload
+   * @private
+   */
   _handleChannelMessagePayload(peerId, payload) {
     // First byte is channel ID length
     const channelIdLength = payload[0];
-    const channelId = new TextDecoder().decode(payload.slice(1, 1 + channelIdLength));
-    const messagePayload = payload.slice(1 + channelIdLength);
+    const channelId = cachedDecoder.decode(payload.subarray(1, 1 + channelIdLength));
+    const messagePayload = payload.subarray(1 + channelIdLength);
 
     this.handleChannelMessage(peerId, channelId, messagePayload);
   }
 
-  /** @private */
+  /**
+   * @param {string} peerId - Peer ID
+   * @param {Uint8Array} payload - Message payload
+   * @private
+   */
   _handleReadReceipt(peerId, payload) {
     // Parse read receipt payload
+    /** @type {string[]} */
     const messageIds = [];
     let offset = 0;
 
     while (offset < payload.length) {
       const length = payload[offset];
       offset += 1;
-      const messageId = new TextDecoder().decode(payload.slice(offset, offset + length));
+      const messageId = cachedDecoder.decode(payload.subarray(offset, offset + length));
       messageIds.push(messageId);
       offset += length;
     }
@@ -456,21 +482,20 @@ class TextManager extends EventEmitter {
     const messageIds = Array.from(this._pendingReadReceipts);
     this._pendingReadReceipts.clear();
 
-    // Build read receipt payload
-    const parts = messageIds.map(id => {
-      const bytes = new TextEncoder().encode(id);
-      const part = new Uint8Array(1 + bytes.length);
-      part[0] = bytes.length;
-      part.set(bytes, 1);
-      return part;
-    });
+    // Pre-calculate total size and allocate once
+    const encodedIds = messageIds.map((/** @type {string} */ id) => cachedEncoder.encode(id));
+    let totalLength = 0;
+    for (let i = 0; i < encodedIds.length; i++) {
+      totalLength += 1 + encodedIds[i].length;
+    }
 
-    const totalLength = parts.reduce((sum, p) => sum + p.length, 0);
     const payload = new Uint8Array(totalLength);
     let offset = 0;
-    for (const part of parts) {
-      payload.set(part, offset);
-      offset += part.length;
+    for (let i = 0; i < encodedIds.length; i++) {
+      payload[offset] = encodedIds[i].length;
+      offset += 1;
+      payload.set(encodedIds[i], offset);
+      offset += encodedIds[i].length;
     }
 
     this.emit('read-receipts-sent', { messageIds, count: messageIds.length });
@@ -483,16 +508,23 @@ class TextManager extends EventEmitter {
     }
   }
 
-  /** @private */
+  /**
+   * @param {string} newState - New state
+   * @private
+   */
   _setState(newState) {
     this._state = newState;
   }
 
-  /** @private */
+  /**
+   * @param {any} publicKey - Public key
+   * @returns {string}
+   * @private
+   */
   _publicKeyToId(publicKey) {
     if (publicKey instanceof Uint8Array) {
       return Array.from(publicKey.slice(0, 8))
-        .map(b => b.toString(16).padStart(2, '0'))
+        .map((/** @type {number} */ b) => b.toString(16).padStart(2, '0'))
         .join('');
     }
     return String(publicKey).slice(0, 16);
@@ -508,7 +540,7 @@ class TextManager extends EventEmitter {
 
   /**
    * Returns statistics
-   * @returns {Object}
+   * @returns {any}
    */
   getStats() {
     return {
@@ -519,6 +551,7 @@ class TextManager extends EventEmitter {
   }
 }
 
+/** @type {any} */
 TextManager.STATE = MANAGER_STATE;
 
 module.exports = TextManager;

package/src/service/text/broadcast/BroadcastManager.js

@@ -10,7 +10,7 @@ const TextMessage = require('../message/TextMessage');
 
 /**
  * Broadcast configuration
- * @constant {Object}
+ * @constant {any}
  */
 const BROADCAST_CONFIG = Object.freeze({
   MAX_MESSAGE_SIZE: 1000,
@@ -26,26 +26,24 @@ const BROADCAST_CONFIG = Object.freeze({
 class BroadcastManager extends EventEmitter {
   /**
    * Creates a new BroadcastManager
-   * @param {Object} [options] - Manager options
-   * @param {number} [options.maxRecentBroadcasts] - Max broadcasts to keep
-   * @param {number} [options.dedupWindowMs] - Deduplication window
+   * @param {any} [options] - Manager options
    */
   constructor(options = {}) {
     super();
 
-    /** @private */
+    /** @type {number} @private */
     this._maxRecentBroadcasts = options.maxRecentBroadcasts || BROADCAST_CONFIG.MAX_RECENT_BROADCASTS;
-    /** @private */
+    /** @type {number} @private */
     this._dedupWindowMs = options.dedupWindowMs || BROADCAST_CONFIG.DEDUP_WINDOW_MS;
-    /** @private */
+    /** @type {any[]} @private */
     this._recentBroadcasts = [];
-    /** @private */
+    /** @type {Map<string, number>} @private */
     this._seenMessageIds = new Map(); // messageId -> timestamp
-    /** @private */
+    /** @type {string | null} @private */
     this._senderId = null;
-    /** @private */
+    /** @type {Function | null} @private */
     this._sendCallback = null;
-    /** @private */
+    /** @type {ReturnType<typeof setInterval> | null} @private */
     this._cleanupTimer = null;
 
     // Auto-cleanup every 5 minutes
@@ -60,9 +58,7 @@ class BroadcastManager extends EventEmitter {
 
   /**
    * Initializes the broadcast manager
-   * @param {Object} options - Init options
-   * @param {string} options.senderId - Local sender ID
-   * @param {Function} options.sendCallback - Callback to send broadcast
+   * @param {any} options - Init options
    */
   initialize(options) {
     this._senderId = options.senderId;
@@ -155,7 +151,7 @@ class BroadcastManager extends EventEmitter {
   /**
    * Gets recent broadcasts
    * @param {number} [limit] - Maximum number to return
-   * @returns {TextMessage[]}
+   * @returns {any[]}
    */
   getRecentBroadcasts(limit) {
     const broadcasts = [...this._recentBroadcasts];
@@ -180,7 +176,7 @@ class BroadcastManager extends EventEmitter {
 
   /**
    * Gets broadcast statistics
-   * @returns {Object}
+   * @returns {any}
    */
   getStats() {
     return {
@@ -221,7 +217,7 @@ class BroadcastManager extends EventEmitter {
   /**
    * Adds a message to recent broadcasts
    * @private
-   * @param {TextMessage} message - Message to add
+   * @param {any} message - Message to add
    */
   _addToRecent(message) {
     this._recentBroadcasts.push(message);
@@ -233,6 +229,7 @@ class BroadcastManager extends EventEmitter {
   }
 }
 
+/** @type {any} */
 BroadcastManager.CONFIG = BROADCAST_CONFIG;
 
 module.exports = BroadcastManager;

package/src/service/text/channel/Channel.js

@@ -12,11 +12,7 @@
 class Channel {
   /**
    * Creates a new Channel
-   * @param {Object} options - Channel options
-   * @param {string} options.id - Channel ID
-   * @param {string} [options.name] - Channel display name
-   * @param {string} [options.password] - Channel password (hashed)
-   * @param {number} [options.createdAt] - Creation timestamp
+   * @param {any} options - Channel options
    */
   constructor(options) {
     const { id, name, password, createdAt } = options;
@@ -25,17 +21,17 @@ class Channel {
       throw new Error('Channel ID is required');
     }
 
-    /** @private */
+    /** @type {string} @private */
     this._id = id;
-    /** @private */
+    /** @type {string} @private */
     this._name = name || id;
-    /** @private */
+    /** @type {Uint8Array | null} @private */
     this._passwordHash = password ? this._hashPassword(password) : null;
-    /** @private */
+    /** @type {Set<string>} @private */
     this._members = new Set();
-    /** @private */
+    /** @type {number} @private */
     this._createdAt = createdAt || Date.now();
-    /** @private */
+    /** @type {number} @private */
     this._joinedAt = Date.now();
   }
 
@@ -157,7 +153,7 @@ class Channel {
 
   /**
    * Converts to JSON representation
-   * @returns {Object}
+   * @returns {any}
    */
   toJSON() {
     return {
@@ -173,7 +169,7 @@ class Channel {
 
   /**
    * Creates a Channel from JSON
-   * @param {Object} json - JSON object
+   * @param {any} json - JSON object
    * @returns {Channel}
    */
   static fromJSON(json) {
@@ -184,7 +180,7 @@ class Channel {
     });
 
     if (json.members) {
-      json.members.forEach(peerId => channel.addMember(peerId));
+      json.members.forEach((/** @type {string} */ peerId) => channel.addMember(peerId));
     }
 
     channel._joinedAt = json.joinedAt || Date.now();

package/src/service/text/channel/ChannelManager.js

@@ -18,7 +18,7 @@ const Channel = require('./Channel');
 class ChannelManager extends EventEmitter {
   constructor() {
     super();
-    /** @private */
+    /** @type {Map<string, any>} @private */
     this._channels = new Map();
   }
 
@@ -26,7 +26,7 @@ class ChannelManager extends EventEmitter {
    * Joins a channel
    * @param {string} channelId - Channel ID
    * @param {string} [password] - Optional password
-   * @returns {Channel}
+   * @returns {any}
    */
   joinChannel(channelId, password) {
     if (!channelId || typeof channelId !== 'string') {
@@ -57,21 +57,21 @@ class ChannelManager extends EventEmitter {
     }
     const channel = this._channels.get(channelId);
     this._channels.delete(channelId);
-    this.emit(EVENTS.CHANNEL_LEFT, { channelId, memberCount: channel.getMemberCount() });
+    this.emit(EVENTS.CHANNEL_LEFT, { channelId, memberCount: channel?.getMemberCount() });
   }
 
   /**
    * Gets all joined channels
-   * @returns {Object[]}
+   * @returns {any[]}
    */
   getChannels() {
-    return Array.from(this._channels.values()).map(c => c.toJSON());
+    return Array.from(this._channels.values()).map((/** @type {any} */ c) => c.toJSON());
   }
 
   /**
    * Gets a specific channel
    * @param {string} channelId - Channel ID
-   * @returns {Channel|undefined}
+   * @returns {any}
    */
   getChannel(channelId) {
     return this._channels.get(channelId);
@@ -122,14 +122,14 @@ class ChannelManager extends EventEmitter {
 
   /**
    * Handles an incoming channel message
-   * @param {Object} message - Message data
+   * @param {any} message - Message data
    */
   handleChannelMessage(message) {
     const { channelId, senderId, content, timestamp } = message;
     if (!this._channels.has(channelId)) { return; }
 
     const channel = this._channels.get(channelId);
-    if (senderId && !channel.hasMember(senderId)) {
+    if (senderId && channel && !channel.hasMember(senderId)) {
       channel.addMember(senderId);
       this.emit(EVENTS.CHANNEL_MEMBER_JOINED, { channelId, peerId: senderId });
     }
@@ -158,12 +158,12 @@ class ChannelManager extends EventEmitter {
 
   /**
    * Gets channel statistics
-   * @returns {Object}
+   * @returns {any}
    */
   getStats() {
     return {
       channelCount: this._channels.size,
-      totalMembers: Array.from(this._channels.values()).reduce((s, c) => s + c.getMemberCount(), 0)
+      totalMembers: Array.from(this._channels.values()).reduce((/** @type {number} */ s, /** @type {any} */ c) => s + c.getMemberCount(), 0)
     };
   }
 }

package/src/service/text/message/TextMessage.js

@@ -14,38 +14,31 @@ const { generateUUID } = require('../../../utils');
 class TextMessage {
   /**
    * Creates a new TextMessage
-   * @param {Object} options - Message options
-   * @param {string} [options.id] - Message ID
-   * @param {string} options.content - Message content
-   * @param {string} [options.senderId] - Sender peer ID
-   * @param {string} [options.recipientId] - Recipient peer ID (for private messages)
-   * @param {string} [options.channelId] - Channel ID (for channel messages)
-   * @param {number} [options.timestamp] - Message timestamp
-   * @param {boolean} [options.isRead] - Whether message has been read
+   * @param {any} options - Message options
    */
   constructor(options) {
     const { id, content, senderId, recipientId, channelId, timestamp, isRead } = options;
 
-    /** @private */
+    /** @type {string} @private */
     this._id = id || generateUUID();
-    /** @private */
+    /** @type {string} @private */
     this._content = content || '';
-    /** @private */
+    /** @type {string | null} @private */
     this._senderId = senderId || null;
-    /** @private */
+    /** @type {string | null} @private */
     this._recipientId = recipientId || null;
-    /** @private */
+    /** @type {string | null} @private */
     this._channelId = channelId || null;
-    /** @private */
+    /** @type {number} @private */
     this._timestamp = timestamp || Date.now();
-    /** @private */
+    /** @type {boolean} @private */
     this._isRead = isRead || false;
   }
 
   /**
    * Creates a TextMessage from a string
    * @param {string} content - Message content
-   * @param {Object} [options] - Additional options
+   * @param {any} [options] - Additional options
    * @returns {TextMessage}
    */
   static fromString(content, options = {}) {
@@ -253,7 +246,7 @@ class TextMessage {
 
   /**
    * Returns message metadata
-   * @returns {Object}
+   * @returns {any}
    */
   getMetadata() {
     return {
@@ -269,7 +262,7 @@ class TextMessage {
 
   /**
    * Converts to JSON representation
-   * @returns {Object}
+   * @returns {any}
    */
   toJSON() {
     return {
@@ -285,7 +278,7 @@ class TextMessage {
 
   /**
    * Creates a TextMessage from JSON
-   * @param {Object} json - JSON object
+   * @param {any} json - JSON object
    * @returns {TextMessage}
    */
   static fromJSON(json) {

package/src/service/text/message/TextSerializer.js

@@ -7,7 +7,7 @@
 
 /**
  * Text header flags
- * @constant {Object}
+ * @constant {any}
  */
 const TEXT_HEADER_FLAGS = Object.freeze({
   HAS_SENDER: 0x01,
@@ -94,7 +94,7 @@ function createTextHeader(options) {
 /**
  * Parses a text message header
  * @param {Uint8Array} data - Header data
- * @returns {Object}
+ * @returns {any}
  */
 function parseTextHeader(data) {
   if (data.length < TEXT_HEADER_SIZE) {