react-native-ble-mesh 2.0.0 → 2.1.2

package/src/service/audio/codec/LC3Encoder.js

@@ -16,7 +16,7 @@ const AudioError = require('../../../errors/AudioError');
 class LC3Encoder extends EventEmitter {
   /**
    * Creates a new LC3Encoder
-   * @param {LC3Codec} codec - Initialized LC3 codec instance
+   * @param {any} codec - Initialized LC3 codec instance
    */
   constructor(codec) {
     super();
@@ -25,17 +25,17 @@ class LC3Encoder extends EventEmitter {
       throw AudioError.codecInitFailed({ reason: 'Codec must be initialized' });
     }
 
-    /** @private */
+    /** @type {any} @private */
     this._codec = codec;
-    /** @private */
+    /** @type {number} @private */
     this._frameSamples = codec.getFrameSamples();
     /** @private */
     this._sampleBuffer = new Int16Array(this._frameSamples * 2);
-    /** @private */
+    /** @type {number} @private */
     this._bufferOffset = 0;
-    /** @private */
+    /** @type {number} @private */
     this._framesEncoded = 0;
-    /** @private */
+    /** @type {number} @private */
     this._errors = 0;
   }
 
@@ -45,6 +45,7 @@ class LC3Encoder extends EventEmitter {
    * @returns {Promise<Uint8Array[]>} Array of encoded LC3 frames
    */
   async pushSamples(samples) {
+    /** @type {Uint8Array[]} */
     const frames = [];
     let offset = 0;
 
@@ -68,7 +69,7 @@ class LC3Encoder extends EventEmitter {
           frames.push(encoded);
           this._framesEncoded++;
           this.emit('frame', { frame: encoded, index: this._framesEncoded });
-        } catch (error) {
+        } catch (/** @type {any} */ error) {
           this._errors++;
           this.emit('error', error);
         }
@@ -84,6 +85,7 @@ class LC3Encoder extends EventEmitter {
    * @returns {Promise<Uint8Array[]>} Array of encoded LC3 frames
    */
   async flush() {
+    /** @type {Uint8Array[]} */
     const frames = [];
 
     if (this._bufferOffset > 0) {
@@ -96,7 +98,7 @@ class LC3Encoder extends EventEmitter {
         frames.push(encoded);
         this._framesEncoded++;
         this.emit('frame', { frame: encoded, index: this._framesEncoded, padded: true });
-      } catch (error) {
+      } catch (/** @type {any} */ error) {
         this._errors++;
         this.emit('error', error);
       }
@@ -117,7 +119,7 @@ class LC3Encoder extends EventEmitter {
 
   /**
    * Returns encoder statistics
-   * @returns {Object}
+   * @returns {any}
    */
   getStats() {
     return {

package/src/service/audio/session/AudioSession.js

@@ -20,11 +20,7 @@ const LC3Decoder = require('../codec/LC3Decoder');
 class AudioSession extends EventEmitter {
   /**
    * Creates a new AudioSession
-   * @param {Object} options - Session options
-   * @param {string} options.peerId - Remote peer ID
-   * @param {LC3Codec} options.codec - Initialized codec
-   * @param {boolean} options.isInitiator - Whether local peer initiated
-   * @param {Function} [options.sendCallback] - Callback to send data
+   * @param {any} options - Session options
    */
   constructor(options) {
     super();
@@ -35,15 +31,15 @@ class AudioSession extends EventEmitter {
       throw AudioError.codecInitFailed({ reason: 'Codec must be initialized' });
     }
 
-    /** @private */
+    /** @type {string} @private */
     this._peerId = peerId;
-    /** @private */
+    /** @type {any} @private */
     this._codec = codec;
-    /** @private */
+    /** @type {boolean} @private */
     this._isInitiator = isInitiator;
-    /** @private */
+    /** @type {Function} @private */
     this._sendCallback = sendCallback || (() => {});
-    /** @private */
+    /** @type {string} @private */
     this._state = AUDIO_SESSION_STATE.IDLE;
     /** @private */
     this._encoder = new LC3Encoder(codec);
@@ -54,11 +50,11 @@ class AudioSession extends EventEmitter {
       depth: AUDIO_STREAM_CONFIG.JITTER_BUFFER_FRAMES,
       frameMs: codec.getConfig().frameMs
     });
-    /** @private */
+    /** @type {number} @private */
     this._sendSequence = 0;
-    /** @private */
+    /** @type {number | null} @private */
     this._startTime = null;
-    /** @private */
+    /** @type {any} @private */
     this._stats = {
       framesSent: 0,
       framesReceived: 0,
@@ -74,7 +70,7 @@ class AudioSession extends EventEmitter {
    * @private
    */
   _setupBufferEvents() {
-    this._jitterBuffer.on('underrun', (data) => {
+    this._jitterBuffer.on('underrun', (/** @type {any} */ data) => {
       this.emit('underrun', data);
     });
 
@@ -110,7 +106,7 @@ class AudioSession extends EventEmitter {
     const frames = await this._encoder.pushSamples(samples);
 
     for (const frame of frames) {
-      const timestampDelta = Date.now() - this._startTime;
+      const timestampDelta = Date.now() - (this._startTime || 0);
 
       await this._sendCallback({
         peerId: this._peerId,
@@ -142,7 +138,7 @@ class AudioSession extends EventEmitter {
 
   /**
    * Gets decoded audio for playback
-   * @returns {Promise<{samples: Int16Array, isPLC: boolean}|null>}
+   * @returns {Promise<any>}
    */
   async getAudio() {
     if (this._state !== AUDIO_SESSION_STATE.ACTIVE) {
@@ -215,6 +211,7 @@ class AudioSession extends EventEmitter {
 
   /**
    * Sets session state
+   * @param {string} newState
    * @private
    */
   _setState(newState) {
@@ -249,7 +246,7 @@ class AudioSession extends EventEmitter {
 
   /**
    * Returns session statistics
-   * @returns {Object}
+   * @returns {any}
    */
   getStats() {
     const bufferStats = this._jitterBuffer.getStats();

package/src/service/audio/session/VoiceMessage.js

@@ -29,17 +29,14 @@ const VOICE_MESSAGE_MAGIC = new Uint8Array([0x56, 0x4D, 0x53, 0x47]); // 'VMSG'
 class VoiceMessage {
   /**
    * Creates a VoiceMessage from recorded frames
-   * @param {Object} options - Message options
-   * @param {FrameBuffer} options.frames - Recorded frames
-   * @param {Object} options.metadata - Recording metadata
-   * @param {Uint8Array} options.senderId - Sender ID (32 bytes)
+   * @param {any} options - Message options
    */
   constructor(options) {
     const { frames, metadata, senderId } = options;
 
-    /** @private */
+    /** @type {any} @private */
     this._frames = frames;
-    /** @private */
+    /** @type {any} @private */
     this._metadata = {
       version: 1,
       codec: metadata.codec || AUDIO_CODEC_TYPE.LC3,
@@ -49,17 +46,15 @@ class VoiceMessage {
       channels: metadata.channels || 1,
       createdAt: metadata.createdAt || Date.now()
     };
-    /** @private */
+    /** @type {Uint8Array} @private */
     this._senderId = senderId || new Uint8Array(32);
-    /** @private */
+    /** @type {number} @private */
     this._playbackPosition = 0;
   }
 
   /**
    * Starts recording a new voice message
-   * @param {Object} options - Recording options
-   * @param {LC3Codec} options.codec - Initialized codec
-   * @param {Uint8Array} options.senderId - Sender ID
+   * @param {any} options - Recording options
    * @returns {VoiceMessageRecorder}
    */
   static startRecording(options) {
@@ -160,7 +155,7 @@ class VoiceMessage {
 
   /**
    * Returns metadata
-   * @returns {Object}
+   * @returns {any}
    */
   getMetadata() {
     return {
@@ -190,7 +185,7 @@ class VoiceMessage {
 
   /**
    * Gets next frame for playback
-   * @returns {{frame: Uint8Array, index: number, done: boolean}|null}
+   * @returns {any}
    */
   getNextFrame() {
     if (this._playbackPosition >= this._frames.getFrameCount()) {
@@ -237,9 +232,7 @@ class VoiceMessage {
 class VoiceMessageRecorder extends EventEmitter {
   /**
    * Creates a new recorder
-   * @param {Object} options - Recorder options
-   * @param {LC3Codec} options.codec - Initialized codec
-   * @param {Uint8Array} options.senderId - Sender ID
+   * @param {any} options - Recorder options
    */
   constructor(options) {
     super();
@@ -250,19 +243,19 @@ class VoiceMessageRecorder extends EventEmitter {
       throw AudioError.codecInitFailed({ reason: 'Codec must be initialized' });
     }
 
-    /** @private */
+    /** @type {any} @private */
     this._codec = codec;
-    /** @private */
+    /** @type {Uint8Array} @private */
     this._senderId = senderId || new Uint8Array(32);
     /** @private */
     this._frames = new FrameBuffer();
-    /** @private */
+    /** @type {any} @private */
     this._encoder = null;
-    /** @private */
+    /** @type {number} @private */
     this._startTime = Date.now();
-    /** @private */
+    /** @type {boolean} @private */
     this._cancelled = false;
-    /** @private */
+    /** @type {any} @private */
     this._config = codec.getConfig();
 
     // Lazy load encoder

package/src/service/audio/transport/AudioFragmenter.js

@@ -17,15 +17,15 @@ class AudioFragmenter {
   /**
    * Fragments voice message data
    * @param {Uint8Array} voiceData - Serialized voice message
-   * @param {Object} metadata - Voice message metadata
-   * @param {string} metadata.messageId - Unique message ID
+   * @param {any} metadata - Voice message metadata
    * @param {number} [chunkSize] - Chunk size (default from config)
    * @returns {Uint8Array[]} Array of fragments
    */
   static fragment(voiceData, metadata, chunkSize = VOICE_MESSAGE_CONFIG.CHUNK_SIZE) {
     const { messageId } = metadata;
-    const messageIdBytes = this._stringToBytes(messageId, 16);
+    const messageIdBytes = AudioFragmenter._stringToBytes(messageId, 16);
     const totalChunks = Math.ceil(voiceData.length / chunkSize);
+    /** @type {Uint8Array[]} */
     const fragments = [];
 
     for (let i = 0; i < totalChunks; i++) {
@@ -77,12 +77,15 @@ class AudioFragmenter {
 
   /**
    * Converts string to fixed-length bytes
+   * @param {string} str - String to convert
+   * @param {number} length - Target byte length
+   * @returns {Uint8Array}
    * @private
    */
   static _stringToBytes(str, length) {
     const bytes = new Uint8Array(length);
     const encoder = new TextEncoder();
-    const encoded = encoder.encode(str.slice(0, length));
+    const encoded = encoder.encode(String(str).slice(0, length));
     bytes.set(encoded.slice(0, length));
     return bytes;
   }
@@ -96,15 +99,14 @@ class AudioFragmenter {
 class AudioAssembler extends EventEmitter {
   /**
    * Creates a new AudioAssembler
-   * @param {Object} [options] - Assembler options
-   * @param {number} [options.timeout=120000] - Assembly timeout in ms
+   * @param {any} [options] - Assembler options
    */
   constructor(options = {}) {
     super();
 
-    /** @private */
+    /** @type {number} @private */
     this._timeout = options.timeout || VOICE_MESSAGE_CONFIG.TIMEOUT_MS;
-    /** @private */
+    /** @type {Map<string, any>} @private */
     this._pending = new Map(); // messageId -> { fragments, totalSize, receivedSize, timer }
   }
 
@@ -120,6 +122,7 @@ class AudioAssembler extends EventEmitter {
     const index = view.getUint16(17, false);
     const total = view.getUint16(19, false);
 
+    /** @type {Uint8Array} */
     let chunkData;
     let totalSize = 0;
 
@@ -171,6 +174,8 @@ class AudioAssembler extends EventEmitter {
 
   /**
    * Assembles complete voice message
+   * @param {string} messageId - Message ID
+   * @returns {Uint8Array|null}
    * @private
    */
   _assemble(messageId) {
@@ -199,6 +204,7 @@ class AudioAssembler extends EventEmitter {
 
   /**
    * Handles assembly timeout
+   * @param {string} messageId - Message ID
    * @private
    */
   _handleTimeout(messageId) {
@@ -209,7 +215,7 @@ class AudioAssembler extends EventEmitter {
   /**
    * Gets assembly progress
    * @param {string} messageId - Message ID
-   * @returns {Object|null}
+   * @returns {any}
    */
   getProgress(messageId) {
     const entry = this._pending.get(messageId);
@@ -245,6 +251,8 @@ class AudioAssembler extends EventEmitter {
 
   /**
    * Converts bytes to string
+   * @param {Uint8Array} bytes - Bytes to convert
+   * @returns {string}
    * @private
    */
   _bytesToString(bytes) {

package/src/service/audio/transport/AudioFramer.js

@@ -16,7 +16,7 @@ const AUDIO_FRAME_HEADER_SIZE = AUDIO_STREAM_CONFIG.FRAME_HEADER_SIZE;
 
 /**
  * Audio frame flags
- * @constant {Object}
+ * @constant {any}
  */
 const FRAME_FLAGS = Object.freeze({
   NONE: 0x00,
@@ -27,12 +27,7 @@ const FRAME_FLAGS = Object.freeze({
 
 /**
  * Packs an audio frame with header for transmission
- * @param {Object} options - Frame options
- * @param {number} options.type - Message type
- * @param {Uint8Array} options.frame - Audio frame data
- * @param {number} options.sequenceNumber - Sequence number
- * @param {number} [options.timestampDelta=0] - Timestamp delta
- * @param {number} [options.flags=0] - Frame flags
+ * @param {any} options - Frame options
  * @returns {Uint8Array} Packed frame with header
  */
 function packFrame(options) {
@@ -64,7 +59,7 @@ function packFrame(options) {
 /**
  * Unpacks an audio frame from received data
  * @param {Uint8Array} data - Received data
- * @returns {Object} Unpacked frame info
+ * @returns {any} Unpacked frame info
  */
 function unpackFrame(data) {
   if (data.length < AUDIO_FRAME_HEADER_SIZE) {
@@ -99,13 +94,13 @@ function unpackFrame(data) {
 
 /**
  * Packs multiple frames into a single packet
- * @param {Array<Object>} frames - Array of frame objects
+ * @param {any[]} frames - Array of frame objects
  * @returns {Uint8Array} Packed multi-frame data
  */
 function packMultiFrame(frames) {
   // Format: [count(1)][frame1][frame2]...
-  const packedFrames = frames.map(f => packFrame(f));
-  const totalLen = 1 + packedFrames.reduce((sum, p) => sum + p.length, 0);
+  const packedFrames = frames.map((/** @type {any} */ f) => packFrame(f));
+  const totalLen = 1 + packedFrames.reduce((/** @type {number} */ sum, /** @type {any} */ p) => sum + p.length, 0);
 
   const result = new Uint8Array(totalLen);
   result[0] = frames.length;
@@ -122,7 +117,7 @@ function packMultiFrame(frames) {
 /**
  * Unpacks multiple frames from a packet
  * @param {Uint8Array} data - Packed multi-frame data
- * @returns {Array<Object>} Array of unpacked frames
+ * @returns {any[]} Array of unpacked frames
  */
 function unpackMultiFrame(data) {
   if (data.length < 1) {
@@ -130,6 +125,7 @@ function unpackMultiFrame(data) {
   }
 
   const count = data[0];
+  /** @type {any[]} */
   const frames = [];
   let offset = 1;
 

package/src/service/file/FileAssembler.js

@@ -84,8 +84,10 @@ class FileAssembler {
 
     for (let i = 0; i < this._totalChunks; i++) {
       const chunk = this._chunks.get(i);
-      result.set(chunk, offset);
-      offset += chunk.length;
+      if (chunk) {
+        result.set(chunk, offset);
+        offset += chunk.length;
+      }
     }
 
     // Free chunk memory immediately after assembly

package/src/service/file/FileChunker.js

@@ -27,7 +27,7 @@ class FileChunker {
    * Splits data into chunks
    * @param {Uint8Array} data - File data
    * @param {string} transferId - Transfer ID
-   * @returns {Object[]} Array of chunk objects
+   * @returns {any[]} Array of chunk objects
    * @throws {Error} If data exceeds max file size
    */
   chunk(data, transferId) {

package/src/service/file/FileManager.js

@@ -12,7 +12,7 @@ const { FileMessage, FILE_TRANSFER_STATE } = require('./FileMessage');
 
 /**
  * Default file transfer configuration
- * @constant {Object}
+ * @constant {any}
  */
 const DEFAULT_CONFIG = Object.freeze({
   chunkSize: 4096,
@@ -36,21 +36,22 @@ const DEFAULT_CONFIG = Object.freeze({
  */
 class FileManager extends EventEmitter {
   /**
-   * @param {Object} [config={}]
+   * @param {any} [config]
    */
   constructor(config = {}) {
     super();
+    /** @type {any} */
     this._config = { ...DEFAULT_CONFIG, ...config };
     this._chunker = new FileChunker({
       chunkSize: this._config.chunkSize,
       maxFileSize: this._config.maxFileSize
     });
 
-    /** @type {Map<string, Object>} Active outgoing transfers */
+    /** @type {Map<string, any>} Active outgoing transfers */
     this._outgoing = new Map();
-    /** @type {Map<string, Object>} Active incoming transfers */
+    /** @type {Map<string, any>} Active incoming transfers */
     this._incoming = new Map();
-    /** @type {Map<string, NodeJS.Timeout>} Transfer timeouts */
+    /** @type {Map<string, any>} Transfer timeouts */
     this._timeouts = new Map();
   }
 
@@ -59,11 +60,8 @@ class FileManager extends EventEmitter {
    * The caller (MeshNetwork) is responsible for actually sending chunks via transport.
    *
    * @param {string} peerId - Target peer ID
-   * @param {Object} fileInfo - File information
-   * @param {Uint8Array} fileInfo.data - File data
-   * @param {string} fileInfo.name - File name
-   * @param {string} [fileInfo.mimeType='application/octet-stream'] - MIME type
-   * @returns {Object} Transfer object with id, offer, and chunks
+   * @param {any} fileInfo - File information
+   * @returns {any} Transfer object with id, offer, and chunks
    */
   prepareSend(peerId, fileInfo) {
     if (this._outgoing.size >= this._config.maxConcurrentTransfers) {
@@ -105,7 +103,7 @@ class FileManager extends EventEmitter {
   /**
    * Marks a chunk as sent and emits progress
    * @param {string} transferId - Transfer ID
-   * @param {number} chunkIndex - Chunk index that was sent
+   * @param {number} _chunkIndex - Chunk index that was sent
    */
   markChunkSent(transferId, _chunkIndex) {
     const transfer = this._outgoing.get(transferId);
@@ -141,7 +139,7 @@ class FileManager extends EventEmitter {
 
   /**
    * Handles an incoming file offer
-   * @param {Object} offer - File offer metadata
+   * @param {any} offer - File offer metadata
    * @param {string} senderId - Sender peer ID
    * @returns {string} Transfer ID
    */
@@ -234,15 +232,17 @@ class FileManager extends EventEmitter {
 
     if (this._outgoing.has(transferId)) {
       const transfer = this._outgoing.get(transferId);
-      transfer.state = FILE_TRANSFER_STATE.CANCELLED;
+      if (transfer) { transfer.state = FILE_TRANSFER_STATE.CANCELLED; }
       this._outgoing.delete(transferId);
       this.emit('transferCancelled', { transferId, direction: 'outgoing' });
     }
 
     if (this._incoming.has(transferId)) {
       const transfer = this._incoming.get(transferId);
-      transfer.meta.state = FILE_TRANSFER_STATE.CANCELLED;
-      transfer.assembler.clear();
+      if (transfer) {
+        transfer.meta.state = FILE_TRANSFER_STATE.CANCELLED;
+        transfer.assembler.clear();
+      }
       this._incoming.delete(transferId);
       this.emit('transferCancelled', { transferId, direction: 'incoming' });
     }
@@ -250,16 +250,16 @@ class FileManager extends EventEmitter {
 
   /**
    * Gets active transfers
-   * @returns {Object} { outgoing: [], incoming: [] }
+   * @returns {any}
    */
   getActiveTransfers() {
     return {
-      outgoing: Array.from(this._outgoing.values()).map(t => ({
+      outgoing: Array.from(this._outgoing.values()).map((/** @type {any} */ t) => ({
         id: t.id, peerId: t.peerId, name: t.meta.name,
         progress: Math.round((t.sentChunks / t.chunks.length) * 100),
         state: t.state
       })),
-      incoming: Array.from(this._incoming.values()).map(t => ({
+      incoming: Array.from(this._incoming.values()).map((/** @type {any} */ t) => ({
         id: t.meta.id, from: t.senderId, name: t.meta.name,
         progress: t.assembler.progress,
         state: t.meta.state
@@ -282,7 +282,10 @@ class FileManager extends EventEmitter {
     this.removeAllListeners();
   }
 
-  /** @private */
+  /**
+   * @param {string} transferId
+   * @private
+   */
   _setTransferTimeout(transferId) {
     const timer = setTimeout(() => {
       this.cancelTransfer(transferId);
@@ -294,7 +297,10 @@ class FileManager extends EventEmitter {
     this._timeouts.set(transferId, timer);
   }
 
-  /** @private */
+  /**
+   * @param {string} transferId
+   * @private
+   */
   _clearTransferTimeout(transferId) {
     const timer = this._timeouts.get(transferId);
     if (timer) {

package/src/service/file/FileMessage.js

@@ -7,7 +7,7 @@
 
 /**
  * File transfer message types
- * @constant {Object}
+ * @constant {any}
  */
 const FILE_MESSAGE_TYPE = Object.freeze({
   /** Initial file offer with metadata */
@@ -22,7 +22,7 @@ const FILE_MESSAGE_TYPE = Object.freeze({
 
 /**
  * File transfer states
- * @constant {Object}
+ * @constant {any}
  */
 const FILE_TRANSFER_STATE = Object.freeze({
   PENDING: 'pending',
@@ -38,14 +38,7 @@ const FILE_TRANSFER_STATE = Object.freeze({
  */
 class FileMessage {
   /**
-   * @param {Object} options
-   * @param {string} options.id - Transfer ID
-   * @param {string} options.name - File name
-   * @param {string} options.mimeType - MIME type
-   * @param {number} options.size - Total size in bytes
-   * @param {number} options.totalChunks - Total number of chunks
-   * @param {number} [options.chunkSize=4096] - Chunk size in bytes
-   * @param {string} [options.senderId] - Sender peer ID
+   * @param {any} options
    */
   constructor(options) {
     this.id = options.id;
@@ -57,7 +50,9 @@ class FileMessage {
     this.senderId = options.senderId || null;
     this.receivedChunks = 0;
     this.state = FILE_TRANSFER_STATE.PENDING;
+    /** @type {number | null} */
     this.startedAt = null;
+    /** @type {number | null} */
     this.completedAt = null;
   }
 
@@ -82,7 +77,7 @@ class FileMessage {
 
   /**
    * Serializes the file offer metadata
-   * @returns {Object}
+   * @returns {any}
    */
   toOffer() {
     return {
@@ -98,7 +93,7 @@ class FileMessage {
 
   /**
    * Creates a FileMessage from an offer
-   * @param {Object} offer
+   * @param {any} offer
    * @param {string} senderId
    * @returns {FileMessage}
    */