react-native-ble-mesh 2.1.0 → 2.1.2

package/src/service/text/TextManager.js

@@ -21,7 +21,7 @@ const cachedDecoder = new TextDecoder();
 
 /**
  * Text manager states
- * @constant {Object}
+ * @constant {any}
  */
 const MANAGER_STATE = Object.freeze({
   UNINITIALIZED: 'uninitialized',
@@ -40,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) {
@@ -89,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
@@ -97,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);
     }
@@ -203,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);
@@ -215,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();
@@ -287,7 +288,7 @@ class TextManager extends EventEmitter {
 
   /**
    * Gets all joined channels
-   * @returns {Object[]}
+   * @returns {any[]}
    */
   getChannels() {
     return this._channelManager.getChannels();
@@ -296,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);
@@ -358,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;
@@ -379,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;
@@ -403,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);
@@ -423,7 +433,11 @@ 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];
@@ -433,9 +447,14 @@ class TextManager extends EventEmitter {
     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;
 
@@ -464,7 +483,7 @@ class TextManager extends EventEmitter {
     this._pendingReadReceipts.clear();
 
     // Pre-calculate total size and allocate once
-    const encodedIds = messageIds.map(id => cachedEncoder.encode(id));
+    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;
@@ -489,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);
@@ -514,7 +540,7 @@ class TextManager extends EventEmitter {
 
   /**
    * Returns statistics
-   * @returns {Object}
+   * @returns {any}
    */
   getStats() {
     return {
@@ -525,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) {

package/src/storage/AsyncStorageAdapter.js

@@ -20,9 +20,9 @@ const Storage = require('./Storage');
 class AsyncStorageAdapter extends Storage {
   /**
    * Creates a new AsyncStorageAdapter instance
-   * @param {Object} [options={}] - Storage options
-   * @param {string} [options.prefix='mesh'] - Key prefix for namespacing
-   * @param {Object} [options.AsyncStorage] - AsyncStorage instance (optional)
+   * @param {any} [options={}] - Storage options
+   *
+   *
    */
   constructor(options = {}) {
     super({
@@ -32,7 +32,7 @@ class AsyncStorageAdapter extends Storage {
 
     /**
      * AsyncStorage instance
-     * @type {Object|null}
+     * @type {any}
      * @private
      */
     this._storage = options.AsyncStorage || null;
@@ -58,6 +58,7 @@ class AsyncStorageAdapter extends Storage {
     // Try to load AsyncStorage if not provided
     if (!this._storage) {
       try {
+        // @ts-ignore
         const AsyncStorageModule = require('@react-native-async-storage/async-storage');
         this._storage = AsyncStorageModule.default || AsyncStorageModule;
       } catch (error) {
@@ -117,8 +118,8 @@ class AsyncStorageAdapter 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 = {}) {
@@ -126,6 +127,7 @@ class AsyncStorageAdapter extends Storage {
 
     const prefixedKey = this._getKey(key);
 
+    /** @type {any} */
     const item = {
       value,
       createdAt: Date.now()
@@ -170,7 +172,7 @@ class AsyncStorageAdapter extends Storage {
 
     const allKeys = await this._storage.getAllKeys();
     const prefix = `${this._options.prefix}:`;
-    const keysToRemove = allKeys.filter(key => key.startsWith(prefix));
+    const keysToRemove = allKeys.filter((/** @type {any} */ key) => key.startsWith(prefix));
 
     if (keysToRemove.length > 0) {
       await this._storage.multiRemove(keysToRemove);
@@ -188,8 +190,8 @@ class AsyncStorageAdapter extends Storage {
     const prefix = `${this._options.prefix}:`;
 
     return allKeys
-      .filter(key => key.startsWith(prefix))
-      .map(key => key.slice(prefix.length));
+      .filter((/** @type {any} */ key) => key.startsWith(prefix))
+      .map((/** @type {any} */ key) => key.slice(prefix.length));
   }
 
   /**
@@ -205,7 +207,7 @@ class AsyncStorageAdapter extends Storage {
     const result = new Map();
     const now = Date.now();
 
-    for (const [prefixedKey, jsonValue] of pairs) {
+    for (const [prefixedKey, jsonValue] of /** @type {any[]} */ (pairs)) {
       if (jsonValue !== null) {
         const key = prefixedKey.slice(this._options.prefix.length + 1);
         try {
@@ -224,9 +226,9 @@ class AsyncStorageAdapter extends Storage {
 
   /**
    * Sets multiple key-value pairs
-   * @param {Map<string, any>|Object} entries - Entries to set
-   * @param {Object} [options={}] - Set options
-   * @param {number} [options.ttl] - Time to live in milliseconds
+   * @param {Map<string, any>|any} entries - Entries to set
+   * @param {any} [options={}] - Set options
+   *
    * @returns {Promise<void>}
    */
   async setMany(entries, options = {}) {
@@ -237,7 +239,8 @@ class AsyncStorageAdapter extends Storage {
       : Object.entries(entries);
 
     const now = Date.now();
-    const keyValuePairs = pairs.map(([key, value]) => {
+    const keyValuePairs = pairs.map((/** @type {any} */ [key, value]) => {
+      /** @type {any} */
       const item = {
         value,
         createdAt: now