react-native-ble-mesh 2.1.0 → 2.1.3

package/src/service/EmergencyManager.js

@@ -13,7 +13,7 @@ const EventEmitter = require('../utils/EventEmitter');
 
 /**
  * Panic trigger types
- * @constant {Object}
+ * @constant {any}
  */
 const PANIC_TRIGGER = Object.freeze({
   TRIPLE_TAP: 'triple_tap',
@@ -24,7 +24,7 @@ const PANIC_TRIGGER = Object.freeze({
 
 /**
  * Default configuration
- * @constant {Object}
+ * @constant {any}
  */
 const DEFAULT_CONFIG = Object.freeze({
   /** Trigger type for panic mode */
@@ -63,18 +63,14 @@ const DEFAULT_CONFIG = Object.freeze({
 class EmergencyManager extends EventEmitter {
   /**
      * Creates a new EmergencyManager instance.
-     * @param {Object} [options={}] - Configuration options
-     * @param {string} [options.trigger='triple_tap'] - Panic trigger type
-     * @param {number} [options.tapWindowMs=500] - Time window for taps
-     * @param {number} [options.tapCount=3] - Required tap count
-     * @param {boolean} [options.requireConfirmation=false] - Require confirmation
+     * @param {any} [options] - Configuration options
      */
   constructor(options = {}) {
     super();
 
     /**
          * Configuration
-         * @type {Object}
+         * @type {any}
          * @private
          */
     this._config = { ...DEFAULT_CONFIG, ...options };
@@ -88,7 +84,7 @@ class EmergencyManager extends EventEmitter {
 
     /**
          * Tap tracking
-         * @type {Object}
+         * @type {any}
          * @private
          */
     this._tapState = {
@@ -98,7 +94,7 @@ class EmergencyManager extends EventEmitter {
 
     /**
          * Shake tracking
-         * @type {Object}
+         * @type {any}
          * @private
          */
     this._shakeState = {
@@ -122,7 +118,7 @@ class EmergencyManager extends EventEmitter {
 
     /**
          * Statistics
-         * @type {Object}
+         * @type {any}
          * @private
          */
     this._stats = {
@@ -134,9 +130,7 @@ class EmergencyManager extends EventEmitter {
 
   /**
      * Enables panic mode.
-     * @param {Object} [options={}] - Enable options
-     * @param {Function} [options.onWipe] - Callback after wipe
-     * @param {string} [options.trigger] - Override trigger type
+     * @param {any} [options] - Enable options
      */
   enablePanicMode(options = {}) {
     this._enabled = true;
@@ -208,10 +202,7 @@ class EmergencyManager extends EventEmitter {
 
   /**
      * Registers accelerometer data for shake detection.
-     * @param {Object} data - Accelerometer data
-     * @param {number} data.x - X acceleration
-     * @param {number} data.y - Y acceleration
-     * @param {number} data.z - Z acceleration
+     * @param {any} data - Accelerometer data
      */
   registerAccelerometer(data) {
     if (!this._enabled || this._config.trigger !== PANIC_TRIGGER.SHAKE) {
@@ -236,7 +227,7 @@ class EmergencyManager extends EventEmitter {
 
   /**
      * Manually triggers panic wipe.
-     * @returns {Promise<Object>} Wipe result
+     * @returns {Promise<any>} Wipe result
      */
   async triggerManualWipe() {
     return this._executeWipe(PANIC_TRIGGER.MANUAL);
@@ -244,7 +235,7 @@ class EmergencyManager extends EventEmitter {
 
   /**
      * Wipes all registered data.
-     * @returns {Promise<Object>} Wipe result with timing
+     * @returns {Promise<any>} Wipe result with timing
      */
   async wipeAllData() {
     return this._executeWipe(PANIC_TRIGGER.MANUAL);
@@ -252,7 +243,7 @@ class EmergencyManager extends EventEmitter {
 
   /**
      * Gets emergency statistics.
-     * @returns {Object} Statistics
+     * @returns {any} Statistics
      */
   getStats() {
     return { ...this._stats };
@@ -280,7 +271,7 @@ class EmergencyManager extends EventEmitter {
 
     try {
       await this._executeWipe(trigger);
-    } catch (error) {
+    } catch (/** @type {any} */ error) {
       this.emit('error', {
         message: 'Panic wipe failed',
         error: error.message,
@@ -292,7 +283,7 @@ class EmergencyManager extends EventEmitter {
   /**
      * Executes the data wipe.
      * @param {string} trigger - Trigger type
-     * @returns {Promise<Object>} Wipe result
+     * @returns {Promise<any>} Wipe result
      * @private
      */
   async _executeWipe(trigger) {
@@ -300,6 +291,7 @@ class EmergencyManager extends EventEmitter {
 
     this.emit('panic-wipe-started', { trigger, timestamp: startTime });
 
+    /** @type {any} */
     const results = {
       trigger,
       startTime,
@@ -308,12 +300,13 @@ class EmergencyManager extends EventEmitter {
     };
 
     // Execute all clearers in parallel for speed
+    /** @type {any[]} */
     const clearerResults = new Array(this._clearers.length);
     const promises = this._clearers.map(async (clearer, index) => {
       try {
         await clearer();
         clearerResults[index] = { index, success: true };
-      } catch (error) {
+      } catch (/** @type {any} */ error) {
         results.errors.push({ index, error: error.message });
         clearerResults[index] = { index, success: false, error: error.message };
       }
@@ -344,12 +337,12 @@ class EmergencyManager extends EventEmitter {
     if (this._onWipe) {
       try {
         this._onWipe(results);
-      } catch (error) {
+      } catch (/** @type {any} */ error) {
         // Ignore callback errors
       }
     }
 
-    console.log(`Panic wipe completed in ${elapsedMs}ms`);
+    // Panic wipe completed — avoid logging sensitive operations in production
 
     return results;
   }

package/src/service/HandshakeManager.js

@@ -21,15 +21,27 @@ const STATE = Object.freeze({
  * @extends EventEmitter
  */
 class HandshakeManager extends EventEmitter {
+  /**
+   * @param {any} keyManager
+   * @param {any} sessionManager
+   */
   constructor(keyManager, sessionManager) {
     super();
     if (!keyManager || !sessionManager) { throw new Error('keyManager and sessionManager required'); }
+    /** @type {any} */
     this._keyManager = keyManager;
+    /** @type {any} */
     this._sessionManager = sessionManager;
+    /** @type {Map<string, any>} */
     this._pending = new Map();
+    /** @type {number} */
     this._timeout = MESH_CONFIG.HANDSHAKE_TIMEOUT_MS;
   }
 
+  /**
+   * @param {string} peerId
+   * @param {any} transport
+   */
   async initiateHandshake(peerId, transport) {
     if (this._pending.has(peerId)) { throw HandshakeError.alreadyInProgress(peerId); }
 
@@ -44,12 +56,18 @@ class HandshakeManager extends EventEmitter {
       hs.step = 1;
       this.emit(EVENTS.HANDSHAKE_PROGRESS, { peerId, step: 1, role: 'initiator' });
       return await this._waitForCompletion(peerId);
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       this._fail(peerId, err);
       throw err;
     }
   }
 
+  /**
+   * @param {string} peerId
+   * @param {number} type
+   * @param {Uint8Array} payload
+   * @param {any} transport
+   */
   async handleIncomingHandshake(peerId, type, payload, transport) {
     try {
       if (type === MESSAGE_TYPE.HANDSHAKE_INIT) {
@@ -62,12 +80,15 @@ class HandshakeManager extends EventEmitter {
         return await this._onFinal(peerId, payload);
       }
       throw HandshakeError.handshakeFailed(peerId, null, { reason: 'Unknown type' });
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       this._fail(peerId, err);
       throw err;
     }
   }
 
+  /**
+   * @param {string} peerId
+   */
   cancelHandshake(peerId) {
     const hs = this._pending.get(peerId);
     if (!hs) { return; }
@@ -77,9 +98,20 @@ class HandshakeManager extends EventEmitter {
     this.emit(EVENTS.HANDSHAKE_FAILED, { peerId, reason: 'cancelled' });
   }
 
+  /**
+   * @param {string} peerId
+   * @returns {boolean}
+   */
   isHandshakePending(peerId) { return this._pending.has(peerId); }
+  /** @returns {number} */
   getPendingCount() { return this._pending.size; }
 
+  /**
+   * @param {string} peerId
+   * @param {boolean} isInitiator
+   * @returns {any}
+   * @private
+   */
   _createState(peerId, isInitiator) {
     const kp = this._keyManager.getStaticKeyPair();
     return {
@@ -88,11 +120,18 @@ class HandshakeManager extends EventEmitter {
     };
   }
 
+  /**
+   * @param {any} keyPair
+   * @param {boolean} isInitiator
+   * @returns {any}
+   * @private
+   */
   _createNoise(keyPair, isInitiator) {
     // Get crypto provider from keyManager if available
     const provider = this._keyManager.provider;
 
     // Generate ephemeral key pair for this handshake
+    /** @type {any} */
     let ephemeralKeyPair;
     if (provider && typeof provider.generateKeyPair === 'function') {
       ephemeralKeyPair = provider.generateKeyPair();
@@ -101,11 +140,18 @@ class HandshakeManager extends EventEmitter {
       ephemeralKeyPair = { publicKey: randomBytes(32), secretKey: randomBytes(32) };
     }
 
+    /** @type {Uint8Array | null} */
     let remoteEphemeralPublic = null;
+    /** @type {Uint8Array | null} */
     let sharedSecret = null;
+    /** @type {any} */
     let sessionKeys = null;
     let complete = false;
 
+    /**
+     * @param {Uint8Array} secret
+     * @returns {any}
+     */
     const deriveSessionKeys = (secret) => {
       // Derive send/receive keys from shared secret
       // Use hash to derive two different keys from the secret
@@ -125,6 +171,7 @@ class HandshakeManager extends EventEmitter {
         return ephemeralKeyPair.publicKey;
       },
 
+      /** @param {Uint8Array} msg */
       readMessage1: (msg) => {
         // Responder receives initiator's ephemeral public key
         remoteEphemeralPublic = new Uint8Array(msg);
@@ -137,10 +184,12 @@ class HandshakeManager extends EventEmitter {
         } else {
           throw new Error('Crypto provider required for secure handshake. Install tweetnacl: npm install tweetnacl');
         }
+        // @ts-ignore
         sessionKeys = deriveSessionKeys(sharedSecret);
         return ephemeralKeyPair.publicKey;
       },
 
+      /** @param {Uint8Array} msg */
       readMessage2: (msg) => {
         // Initiator receives responder's ephemeral public key and derives shared secret
         remoteEphemeralPublic = new Uint8Array(msg);
@@ -149,6 +198,7 @@ class HandshakeManager extends EventEmitter {
         } else {
           throw new Error('Crypto provider required for secure handshake. Install tweetnacl: npm install tweetnacl');
         }
+        // @ts-ignore
         sessionKeys = deriveSessionKeys(sharedSecret);
       },
 
@@ -158,6 +208,7 @@ class HandshakeManager extends EventEmitter {
         return ephemeralKeyPair.publicKey;
       },
 
+      /** @param {any} _msg */
       readMessage3: (_msg) => {
         // Responder confirms handshake completion
         complete = true;
@@ -184,6 +235,7 @@ class HandshakeManager extends EventEmitter {
         const recvNonceView = new DataView(recvNonceBuf.buffer);
 
         return {
+          /** @param {Uint8Array} plaintext */
           encrypt: (plaintext) => {
             if (provider && typeof provider.encrypt === 'function') {
               // Store counter in last 8 bytes of nonce
@@ -194,6 +246,7 @@ class HandshakeManager extends EventEmitter {
             throw new Error('Crypto provider required for encryption');
           },
 
+          /** @param {Uint8Array} ciphertext */
           decrypt: (ciphertext) => {
             if (provider && typeof provider.decrypt === 'function') {
               recvNonceView.setUint32(16, 0, true);
@@ -215,6 +268,12 @@ class HandshakeManager extends EventEmitter {
     };
   }
 
+  /**
+   * @param {string} peerId
+   * @param {Uint8Array} payload
+   * @param {any} transport
+   * @private
+   */
   async _onInit(peerId, payload, transport) {
     const existing = this._pending.get(peerId);
 
@@ -245,6 +304,12 @@ class HandshakeManager extends EventEmitter {
     return null;
   }
 
+  /**
+   * @param {string} peerId
+   * @param {Uint8Array} payload
+   * @param {any} transport
+   * @private
+   */
   async _onResponse(peerId, payload, transport) {
     const hs = this._pending.get(peerId);
     if (!hs || !hs.isInitiator) {
@@ -258,6 +323,11 @@ class HandshakeManager extends EventEmitter {
     return this._complete(peerId, hs);
   }
 
+  /**
+   * @param {string} peerId
+   * @param {Uint8Array} payload
+   * @private
+   */
   async _onFinal(peerId, payload) {
     const hs = this._pending.get(peerId);
     if (!hs || hs.isInitiator) { throw HandshakeError.invalidState(peerId, 3); }
@@ -266,6 +336,11 @@ class HandshakeManager extends EventEmitter {
     return this._complete(peerId, hs);
   }
 
+  /**
+   * @param {string} peerId
+   * @param {any} hs
+   * @private
+   */
   _complete(peerId, hs) {
     if (hs.timer) { clearTimeout(hs.timer); }
     const session = hs.noise.getSession();
@@ -279,6 +354,11 @@ class HandshakeManager extends EventEmitter {
     return session;
   }
 
+  /**
+   * @param {string} peerId
+   * @param {any} error
+   * @private
+   */
   _fail(peerId, error) {
     const hs = this._pending.get(peerId);
     if (hs) {
@@ -289,6 +369,10 @@ class HandshakeManager extends EventEmitter {
     this.emit(EVENTS.HANDSHAKE_FAILED, { peerId, error: error.message, step: hs?.step });
   }
 
+  /**
+   * @param {string} peerId
+   * @private
+   */
   _setTimeout(peerId) {
     const hs = this._pending.get(peerId);
     if (!hs) { return; }
@@ -299,6 +383,10 @@ class HandshakeManager extends EventEmitter {
     }, this._timeout);
   }
 
+  /**
+   * @param {string} peerId
+   * @private
+   */
   _waitForCompletion(peerId) {
     return new Promise((resolve, reject) => {
       const hs = this._pending.get(peerId);
@@ -309,6 +397,11 @@ class HandshakeManager extends EventEmitter {
     });
   }
 
+  /**
+   * @param {any} localKey
+   * @param {any} remoteId
+   * @private
+   */
   _compareKeys(localKey, remoteId) {
     // Simple string/byte comparison for deterministic tie-breaking
     const localStr = typeof localKey === 'string' ? localKey : Array.from(localKey).join(',');
@@ -316,6 +409,11 @@ class HandshakeManager extends EventEmitter {
     return localStr < remoteStr ? -1 : localStr > remoteStr ? 1 : 0;
   }
 
+  /**
+   * @param {number} type
+   * @param {Uint8Array} payload
+   * @private
+   */
   _wrap(type, payload) {
     const w = new Uint8Array(1 + payload.length);
     w[0] = type;