react-native-ble-mesh 1.1.1 → 2.0.0

package/src/utils/compression.js

@@ -18,14 +18,14 @@ const { ValidationError, MeshError } = require('../errors');
  * @constant {Object}
  */
 const DEFAULT_CONFIG = Object.freeze({
-    /** Minimum payload size to compress (bytes) */
-    threshold: 100,
-    /** Hash table size for compression (power of 2) */
-    hashTableSize: 4096,
-    /** Minimum match length */
-    minMatch: 4,
-    /** Maximum match search distance */
-    maxSearchDistance: 65535,
+  /** Minimum payload size to compress (bytes) */
+  threshold: 100,
+  /** Hash table size for compression (power of 2) */
+  hashTableSize: 4096,
+  /** Minimum match length */
+  minMatch: 4,
+  /** Maximum match search distance */
+  maxSearchDistance: 65535
 });
 
 /**
@@ -43,275 +43,275 @@ const DEFAULT_CONFIG = Object.freeze({
  * const original = compressor.decompress(data, compressed);
  */
 class MessageCompressor {
-    /**
+  /**
      * Creates a new MessageCompressor instance.
      * @param {Object} [options={}] - Compression options
      * @param {number} [options.threshold=100] - Min size to compress
      */
-    constructor(options = {}) {
-        this._config = { ...DEFAULT_CONFIG, ...options };
-        this._stats = {
-            compressionAttempts: 0,
-            successfulCompressions: 0,
-            decompressions: 0,
-            bytesIn: 0,
-            bytesOut: 0,
-        };
-    }
-
-    /**
+  constructor(options = {}) {
+    this._config = { ...DEFAULT_CONFIG, ...options };
+    this._stats = {
+      compressionAttempts: 0,
+      successfulCompressions: 0,
+      decompressions: 0,
+      bytesIn: 0,
+      bytesOut: 0
+    };
+  }
+
+  /**
      * Compresses a payload if it exceeds the threshold.
      * @param {Uint8Array} payload - Payload to compress
      * @returns {{ data: Uint8Array, compressed: boolean }} Result
      */
-    compress(payload) {
-        if (!(payload instanceof Uint8Array)) {
-            throw ValidationError.invalidType('payload', payload, 'Uint8Array');
-        }
-
-        // Don't compress if below threshold
-        if (payload.length < this._config.threshold) {
-            return { data: payload, compressed: false };
-        }
+  compress(payload) {
+    if (!(payload instanceof Uint8Array)) {
+      throw ValidationError.invalidType('payload', payload, 'Uint8Array');
+    }
 
-        this._stats.compressionAttempts++;
-        this._stats.bytesIn += payload.length;
-
-        try {
-            const compressed = this._lz4Compress(payload);
-
-            // Only use compressed if it's actually smaller
-            if (compressed.length < payload.length) {
-                this._stats.successfulCompressions++;
-                this._stats.bytesOut += compressed.length;
-                return { data: compressed, compressed: true };
-            }
-        } catch (error) {
-            // Log compression error at debug level for troubleshooting
-            if (typeof console !== 'undefined' && console.debug) {
-                console.debug('Compression failed, using uncompressed:', error.message);
-            }
-        }
+    // Don't compress if below threshold
+    if (payload.length < this._config.threshold) {
+      return { data: payload, compressed: false };
+    }
 
-        this._stats.bytesOut += payload.length;
-        return { data: payload, compressed: false };
+    this._stats.compressionAttempts++;
+    this._stats.bytesIn += payload.length;
+
+    try {
+      const compressed = this._lz4Compress(payload);
+
+      // Only use compressed if it's actually smaller
+      if (compressed.length < payload.length) {
+        this._stats.successfulCompressions++;
+        this._stats.bytesOut += compressed.length;
+        return { data: compressed, compressed: true };
+      }
+    } catch (error) {
+      // Log compression error at debug level for troubleshooting
+      if (typeof console !== 'undefined' && console.debug) {
+        console.debug('Compression failed, using uncompressed:', error.message);
+      }
     }
 
-    /**
+    this._stats.bytesOut += payload.length;
+    return { data: payload, compressed: false };
+  }
+
+  /**
      * Decompresses a payload.
      * @param {Uint8Array} payload - Payload to decompress
      * @param {boolean} wasCompressed - Whether payload was compressed
      * @returns {Uint8Array} Decompressed data
      */
-    decompress(payload, wasCompressed) {
-        if (!wasCompressed) {
-            return payload;
-        }
-
-        if (!(payload instanceof Uint8Array)) {
-            throw ValidationError.invalidType('payload', payload, 'Uint8Array');
-        }
+  decompress(payload, wasCompressed) {
+    if (!wasCompressed) {
+      return payload;
+    }
 
-        this._stats.decompressions++;
-        return this._lz4Decompress(payload);
+    if (!(payload instanceof Uint8Array)) {
+      throw ValidationError.invalidType('payload', payload, 'Uint8Array');
     }
 
-    /**
+    this._stats.decompressions++;
+    return this._lz4Decompress(payload);
+  }
+
+  /**
      * Gets compression ratio for a payload.
      * @param {Uint8Array} original - Original payload
      * @param {Uint8Array} compressed - Compressed payload
      * @returns {number} Compression ratio (0-100%)
      */
-    getCompressionRatio(original, compressed) {
-        if (original.length === 0) return 0;
-        return (1 - compressed.length / original.length) * 100;
-    }
+  getCompressionRatio(original, compressed) {
+    if (original.length === 0) { return 0; }
+    return (1 - compressed.length / original.length) * 100;
+  }
 
-    /**
+  /**
      * Gets compression statistics.
      * @returns {Object} Statistics
      */
-    getStats() {
-        const ratio = this._stats.bytesIn > 0
-            ? (1 - this._stats.bytesOut / this._stats.bytesIn) * 100
-            : 0;
-
-        return {
-            ...this._stats,
-            averageCompressionRatio: ratio,
-            compressionRate: this._stats.compressionAttempts > 0
-                ? this._stats.successfulCompressions / this._stats.compressionAttempts
-                : 0,
-        };
-    }
-
-    /**
+  getStats() {
+    const ratio = this._stats.bytesIn > 0
+      ? (1 - this._stats.bytesOut / this._stats.bytesIn) * 100
+      : 0;
+
+    return {
+      ...this._stats,
+      averageCompressionRatio: ratio,
+      compressionRate: this._stats.compressionAttempts > 0
+        ? this._stats.successfulCompressions / this._stats.compressionAttempts
+        : 0
+    };
+  }
+
+  /**
      * Resets statistics.
      */
-    resetStats() {
-        this._stats = {
-            compressionAttempts: 0,
-            successfulCompressions: 0,
-            decompressions: 0,
-            bytesIn: 0,
-            bytesOut: 0,
-        };
-    }
-
-    /**
+  resetStats() {
+    this._stats = {
+      compressionAttempts: 0,
+      successfulCompressions: 0,
+      decompressions: 0,
+      bytesIn: 0,
+      bytesOut: 0
+    };
+  }
+
+  /**
      * LZ4 compression implementation.
      * @param {Uint8Array} input - Input data
      * @returns {Uint8Array} Compressed data
      * @private
      */
-    _lz4Compress(input) {
-        const inputLen = input.length;
-
-        // Worst case: no compression + header + margin
-        const output = new Uint8Array(inputLen + Math.ceil(inputLen / 255) + 16);
-        let outputPos = 0;
-
-        // Write original size (4 bytes, little-endian)
-        output[outputPos++] = inputLen & 0xff;
-        output[outputPos++] = (inputLen >> 8) & 0xff;
-        output[outputPos++] = (inputLen >> 16) & 0xff;
-        output[outputPos++] = (inputLen >> 24) & 0xff;
-
-        // Hash table for finding matches
-        // Using Knuth's multiplicative hash constant (2654435761) for good distribution
-        const hashTable = new Int32Array(this._config.hashTableSize);
-        hashTable.fill(-1);
-
-        let anchor = 0;
-        let inputPos = 0;
-
-        while (inputPos < inputLen - 4) {
-            // Calculate hash
-            const hash = this._hash4(input, inputPos);
-            const matchPos = hashTable[hash];
-            hashTable[hash] = inputPos;
-
-            // Check if we have a match
-            if (matchPos >= 0 && inputPos - matchPos <= this._config.maxSearchDistance) {
-                // Verify match at least starts correctly
-                if (input[matchPos] === input[inputPos] &&
+  _lz4Compress(input) {
+    const inputLen = input.length;
+
+    // Worst case: no compression + header + margin
+    const output = new Uint8Array(inputLen + Math.ceil(inputLen / 255) + 16);
+    let outputPos = 0;
+
+    // Write original size (4 bytes, little-endian)
+    output[outputPos++] = inputLen & 0xff;
+    output[outputPos++] = (inputLen >> 8) & 0xff;
+    output[outputPos++] = (inputLen >> 16) & 0xff;
+    output[outputPos++] = (inputLen >> 24) & 0xff;
+
+    // Hash table for finding matches
+    // Using Knuth's multiplicative hash constant (2654435761) for good distribution
+    const hashTable = new Int32Array(this._config.hashTableSize);
+    hashTable.fill(-1);
+
+    let anchor = 0;
+    let inputPos = 0;
+
+    while (inputPos < inputLen - 4) {
+      // Calculate hash
+      const hash = this._hash4(input, inputPos);
+      const matchPos = hashTable[hash];
+      hashTable[hash] = inputPos;
+
+      // Check if we have a match
+      if (matchPos >= 0 && inputPos - matchPos <= this._config.maxSearchDistance) {
+        // Verify match at least starts correctly
+        if (input[matchPos] === input[inputPos] &&
                     input[matchPos + 1] === input[inputPos + 1] &&
                     input[matchPos + 2] === input[inputPos + 2] &&
                     input[matchPos + 3] === input[inputPos + 3]) {
 
-                    // Extend the match
-                    let matchLen = 4;
-                    while (inputPos + matchLen < inputLen &&
+          // Extend the match
+          let matchLen = 4;
+          while (inputPos + matchLen < inputLen &&
                         input[matchPos + matchLen] === input[inputPos + matchLen]) {
-                        matchLen++;
-                    }
+            matchLen++;
+          }
 
-                    if (matchLen >= this._config.minMatch) {
-                        // Write literals before match
-                        const literalLen = inputPos - anchor;
-                        const offset = inputPos - matchPos;
+          if (matchLen >= this._config.minMatch) {
+            // Write literals before match
+            const literalLen = inputPos - anchor;
+            const offset = inputPos - matchPos;
 
-                        outputPos = this._writeSequence(output, outputPos, input, anchor, literalLen, matchLen, offset);
+            outputPos = this._writeSequence(output, outputPos, input, anchor, literalLen, matchLen, offset);
 
-                        inputPos += matchLen;
-                        anchor = inputPos;
-                        continue;
-                    }
-                }
-            }
-
-            inputPos++;
+            inputPos += matchLen;
+            anchor = inputPos;
+            continue;
+          }
         }
+      }
 
-        // Write remaining literals (final block with no match)
-        const literalLen = inputLen - anchor;
-        if (literalLen > 0) {
-            outputPos = this._writeFinalLiterals(output, outputPos, input, anchor, literalLen);
-        }
+      inputPos++;
+    }
 
-        return output.subarray(0, outputPos);
+    // Write remaining literals (final block with no match)
+    const literalLen = inputLen - anchor;
+    if (literalLen > 0) {
+      outputPos = this._writeFinalLiterals(output, outputPos, input, anchor, literalLen);
     }
 
-    /**
+    return output.subarray(0, outputPos);
+  }
+
+  /**
      * LZ4 decompression implementation.
      * @param {Uint8Array} input - Compressed data
      * @returns {Uint8Array} Decompressed data
      * @private
      */
-    _lz4Decompress(input) {
-        // Read original size
-        const originalSize = input[0] | (input[1] << 8) | (input[2] << 16) | (input[3] << 24);
-
-        if (originalSize <= 0 || originalSize > 100 * 1024 * 1024) {
-            throw new MeshError(
-                'Invalid compressed data: size header out of range',
-                'E900',
-                { originalSize, maxAllowed: 100 * 1024 * 1024 }
-            );
-        }
-
-        const output = new Uint8Array(originalSize);
-        let inputPos = 4;
-        let outputPos = 0;
-
-        while (inputPos < input.length && outputPos < originalSize) {
-            // Read token
-            const token = input[inputPos++];
-            let literalLen = token >> 4;
-            let matchLen = token & 0x0f;
-
-            // Read extended literal length
-            if (literalLen === 15) {
-                let byte;
-                do {
-                    byte = input[inputPos++];
-                    literalLen += byte;
-                } while (byte === 255);
-            }
-
-            // Copy literals
-            for (let i = 0; i < literalLen && outputPos < originalSize; i++) {
-                output[outputPos++] = input[inputPos++];
-            }
-
-            // Check if we're at the end (last sequence has no match)
-            if (outputPos >= originalSize || inputPos >= input.length) {
-                break;
-            }
-
-            // Read offset (2 bytes, little-endian)
-            const offset = input[inputPos] | (input[inputPos + 1] << 8);
-            inputPos += 2;
-
-            if (offset === 0) {
-                throw new MeshError(
-                    'Invalid offset in compressed data: zero offset not allowed',
-                    'E900',
-                    { inputPos, outputPos }
-                );
-            }
-
-            // Read extended match length
-            matchLen += 4; // Minimum match is 4
-            if ((token & 0x0f) === 15) {
-                let byte;
-                do {
-                    byte = input[inputPos++];
-                    matchLen += byte;
-                } while (byte === 255);
-            }
-
-            // Copy match
-            const matchStart = outputPos - offset;
-            for (let i = 0; i < matchLen && outputPos < originalSize; i++) {
-                output[outputPos++] = output[matchStart + i];
-            }
-        }
+  _lz4Decompress(input) {
+    // Read original size
+    const originalSize = input[0] | (input[1] << 8) | (input[2] << 16) | (input[3] << 24);
+
+    if (originalSize <= 0 || originalSize > 100 * 1024 * 1024) {
+      throw new MeshError(
+        'Invalid compressed data: size header out of range',
+        'E900',
+        { originalSize, maxAllowed: 100 * 1024 * 1024 }
+      );
+    }
 
-        return output.subarray(0, outputPos);
+    const output = new Uint8Array(originalSize);
+    let inputPos = 4;
+    let outputPos = 0;
+
+    while (inputPos < input.length && outputPos < originalSize) {
+      // Read token
+      const token = input[inputPos++];
+      let literalLen = token >> 4;
+      let matchLen = token & 0x0f;
+
+      // Read extended literal length
+      if (literalLen === 15) {
+        let byte;
+        do {
+          byte = input[inputPos++];
+          literalLen += byte;
+        } while (byte === 255);
+      }
+
+      // Copy literals
+      for (let i = 0; i < literalLen && outputPos < originalSize; i++) {
+        output[outputPos++] = input[inputPos++];
+      }
+
+      // Check if we're at the end (last sequence has no match)
+      if (outputPos >= originalSize || inputPos >= input.length) {
+        break;
+      }
+
+      // Read offset (2 bytes, little-endian)
+      const offset = input[inputPos] | (input[inputPos + 1] << 8);
+      inputPos += 2;
+
+      if (offset === 0) {
+        throw new MeshError(
+          'Invalid offset in compressed data: zero offset not allowed',
+          'E900',
+          { inputPos, outputPos }
+        );
+      }
+
+      // Read extended match length
+      matchLen += 4; // Minimum match is 4
+      if ((token & 0x0f) === 15) {
+        let byte;
+        do {
+          byte = input[inputPos++];
+          matchLen += byte;
+        } while (byte === 255);
+      }
+
+      // Copy match
+      const matchStart = outputPos - offset;
+      for (let i = 0; i < matchLen && outputPos < originalSize; i++) {
+        output[outputPos++] = output[matchStart + i];
+      }
     }
 
-    /**
+    return output.subarray(0, outputPos);
+  }
+
+  /**
      * Calculates hash for 4 bytes using Knuth's multiplicative hash.
      *
      * Uses the constant 2654435761 (0x9E3779B1), which is derived from the
@@ -327,15 +327,15 @@ class MessageCompressor {
      * @returns {number} Hash value in range [0, hashTableSize)
      * @private
      */
-    _hash4(data, pos) {
-        const val = data[pos] | (data[pos + 1] << 8) |
+  _hash4(data, pos) {
+    const val = data[pos] | (data[pos + 1] << 8) |
             (data[pos + 2] << 16) | (data[pos + 3] << 24);
-        // Knuth's multiplicative hash: multiply by golden ratio constant
-        // The >>> 0 ensures unsigned 32-bit arithmetic
-        return ((val * 2654435761) >>> 0) % this._config.hashTableSize;
-    }
+    // Knuth's multiplicative hash: multiply by golden ratio constant
+    // The >>> 0 ensures unsigned 32-bit arithmetic
+    return ((val * 2654435761) >>> 0) % this._config.hashTableSize;
+  }
 
-    /**
+  /**
      * Writes a complete LZ4 sequence (literals + match).
      * @param {Uint8Array} output - Output buffer
      * @param {number} pos - Current position
@@ -347,48 +347,48 @@ class MessageCompressor {
      * @returns {number} New position
      * @private
      */
-    _writeSequence(output, pos, input, literalStart, literalLen, matchLen, offset) {
-        // Adjust match length (minimum is 4, stored as matchLen - 4)
-        const adjustedMatchLen = matchLen - 4;
-
-        // Build token
-        const literalToken = Math.min(literalLen, 15);
-        const matchToken = Math.min(adjustedMatchLen, 15);
-        output[pos++] = (literalToken << 4) | matchToken;
-
-        // Write extended literal length
-        if (literalLen >= 15) {
-            let remaining = literalLen - 15;
-            while (remaining >= 255) {
-                output[pos++] = 255;
-                remaining -= 255;
-            }
-            output[pos++] = remaining;
-        }
-
-        // Copy literals
-        for (let i = 0; i < literalLen; i++) {
-            output[pos++] = input[literalStart + i];
-        }
+  _writeSequence(output, pos, input, literalStart, literalLen, matchLen, offset) {
+    // Adjust match length (minimum is 4, stored as matchLen - 4)
+    const adjustedMatchLen = matchLen - 4;
+
+    // Build token
+    const literalToken = Math.min(literalLen, 15);
+    const matchToken = Math.min(adjustedMatchLen, 15);
+    output[pos++] = (literalToken << 4) | matchToken;
+
+    // Write extended literal length
+    if (literalLen >= 15) {
+      let remaining = literalLen - 15;
+      while (remaining >= 255) {
+        output[pos++] = 255;
+        remaining -= 255;
+      }
+      output[pos++] = remaining;
+    }
 
-        // Write offset (little-endian)
-        output[pos++] = offset & 0xff;
-        output[pos++] = (offset >> 8) & 0xff;
-
-        // Write extended match length
-        if (adjustedMatchLen >= 15) {
-            let remaining = adjustedMatchLen - 15;
-            while (remaining >= 255) {
-                output[pos++] = 255;
-                remaining -= 255;
-            }
-            output[pos++] = remaining;
-        }
+    // Copy literals
+    for (let i = 0; i < literalLen; i++) {
+      output[pos++] = input[literalStart + i];
+    }
 
-        return pos;
+    // Write offset (little-endian)
+    output[pos++] = offset & 0xff;
+    output[pos++] = (offset >> 8) & 0xff;
+
+    // Write extended match length
+    if (adjustedMatchLen >= 15) {
+      let remaining = adjustedMatchLen - 15;
+      while (remaining >= 255) {
+        output[pos++] = 255;
+        remaining -= 255;
+      }
+      output[pos++] = remaining;
     }
 
-    /**
+    return pos;
+  }
+
+  /**
      * Writes final literals block (no match following).
      * This is the last sequence in the compressed data.
      * @param {Uint8Array} output - Output buffer
@@ -399,28 +399,28 @@ class MessageCompressor {
      * @returns {number} New position
      * @private
      */
-    _writeFinalLiterals(output, pos, input, start, len) {
-        // Token with literal length only (match length = 0)
-        const literalToken = Math.min(len, 15);
-        output[pos++] = literalToken << 4;
-
-        // Write extended literal length
-        if (len >= 15) {
-            let remaining = len - 15;
-            while (remaining >= 255) {
-                output[pos++] = 255;
-                remaining -= 255;
-            }
-            output[pos++] = remaining;
-        }
-
-        // Copy literals
-        for (let i = 0; i < len; i++) {
-            output[pos++] = input[start + i];
-        }
+  _writeFinalLiterals(output, pos, input, start, len) {
+    // Token with literal length only (match length = 0)
+    const literalToken = Math.min(len, 15);
+    output[pos++] = literalToken << 4;
+
+    // Write extended literal length
+    if (len >= 15) {
+      let remaining = len - 15;
+      while (remaining >= 255) {
+        output[pos++] = 255;
+        remaining -= 255;
+      }
+      output[pos++] = remaining;
+    }
 
-        return pos;
+    // Copy literals
+    for (let i = 0; i < len; i++) {
+      output[pos++] = input[start + i];
     }
+
+    return pos;
+  }
 }
 
 /**
@@ -435,7 +435,7 @@ const defaultCompressor = new MessageCompressor();
  * @returns {{ data: Uint8Array, compressed: boolean }} Result
  */
 function compress(payload) {
-    return defaultCompressor.compress(payload);
+  return defaultCompressor.compress(payload);
 }
 
 /**
@@ -445,12 +445,12 @@ function compress(payload) {
  * @returns {Uint8Array} Decompressed data
  */
 function decompress(payload, wasCompressed) {
-    return defaultCompressor.decompress(payload, wasCompressed);
+  return defaultCompressor.decompress(payload, wasCompressed);
 }
 
 module.exports = {
-    MessageCompressor,
-    compress,
-    decompress,
-    DEFAULT_CONFIG,
+  MessageCompressor,
+  compress,
+  decompress,
+  DEFAULT_CONFIG
 };