react-native-ble-mesh 1.0.1

package/src/utils/EventEmitter.js

@@ -0,0 +1,205 @@
+'use strict';
+
+/**
+ * @fileoverview Enhanced EventEmitter class
+ * @module utils/EventEmitter
+ */
+
+/**
+ * Enhanced EventEmitter with typed events and memory leak prevention
+ * @class EventEmitter
+ */
+class EventEmitter {
+  /**
+   * Creates a new EventEmitter
+   * @param {Object} [options] - Configuration options
+   * @param {number} [options.maxListeners=10] - Maximum listeners per event
+   */
+  constructor(options = {}) {
+    /**
+     * Event listeners map
+     * @type {Map<string, Array<{listener: Function, once: boolean}>>}
+     * @private
+     */
+    this._events = new Map();
+
+    /**
+     * Maximum listeners per event
+     * @type {number}
+     * @private
+     */
+    this._maxListeners = options.maxListeners || 10;
+  }
+
+  /**
+   * Adds an event listener
+   * @param {string} event - Event name
+   * @param {Function} listener - Event handler
+   * @returns {EventEmitter} This instance for chaining
+   */
+  on(event, listener) {
+    if (typeof listener !== 'function') {
+      throw new TypeError('Listener must be a function');
+    }
+
+    if (!this._events.has(event)) {
+      this._events.set(event, []);
+    }
+
+    const listeners = this._events.get(event);
+
+    // Warn if max listeners exceeded
+    if (listeners.length >= this._maxListeners) {
+      console.warn(
+        'MaxListenersExceededWarning: Possible EventEmitter memory leak detected. ' +
+        `${listeners.length + 1} ${event} listeners added. ` +
+        'Use setMaxListeners() to increase limit'
+      );
+    }
+
+    listeners.push({ listener, once: false });
+    return this;
+  }
+
+  /**
+   * Adds a one-time event listener
+   * @param {string} event - Event name
+   * @param {Function} listener - Event handler
+   * @returns {EventEmitter} This instance for chaining
+   */
+  once(event, listener) {
+    if (typeof listener !== 'function') {
+      throw new TypeError('Listener must be a function');
+    }
+
+    if (!this._events.has(event)) {
+      this._events.set(event, []);
+    }
+
+    this._events.get(event).push({ listener, once: true });
+    return this;
+  }
+
+  /**
+   * Removes an event listener
+   * @param {string} event - Event name
+   * @param {Function} listener - Event handler to remove
+   * @returns {EventEmitter} This instance for chaining
+   */
+  off(event, listener) {
+    if (!this._events.has(event)) {
+      return this;
+    }
+
+    const listeners = this._events.get(event);
+    const index = listeners.findIndex(entry => entry.listener === listener);
+
+    if (index !== -1) {
+      listeners.splice(index, 1);
+    }
+
+    if (listeners.length === 0) {
+      this._events.delete(event);
+    }
+
+    return this;
+  }
+
+  /**
+   * Emits an event to all registered listeners
+   * @param {string} event - Event name
+   * @param {...*} args - Arguments to pass to listeners
+   * @returns {boolean} True if event had listeners
+   */
+  emit(event, ...args) {
+    if (!this._events.has(event)) {
+      return false;
+    }
+
+    const listeners = this._events.get(event).slice();
+    const toRemove = [];
+
+    for (const entry of listeners) {
+      try {
+        entry.listener.apply(this, args);
+      } catch (error) {
+        // Emit error event or log if error event fails
+        if (event !== 'error') {
+          this.emit('error', error);
+        } else {
+          console.error('Error in error handler:', error);
+        }
+      }
+
+      if (entry.once) {
+        toRemove.push(entry);
+      }
+    }
+
+    // Remove one-time listeners
+    if (toRemove.length > 0) {
+      const remaining = this._events.get(event).filter(e => !toRemove.includes(e));
+      if (remaining.length === 0) {
+        this._events.delete(event);
+      } else {
+        this._events.set(event, remaining);
+      }
+    }
+
+    return true;
+  }
+
+  /**
+   * Removes all listeners for an event or all events
+   * @param {string} [event] - Event name (optional, removes all if not provided)
+   * @returns {EventEmitter} This instance for chaining
+   */
+  removeAllListeners(event) {
+    if (event === undefined) {
+      this._events.clear();
+    } else {
+      this._events.delete(event);
+    }
+    return this;
+  }
+
+  /**
+   * Returns the number of listeners for an event
+   * @param {string} event - Event name
+   * @returns {number} Number of listeners
+   */
+  listenerCount(event) {
+    if (!this._events.has(event)) {
+      return 0;
+    }
+    return this._events.get(event).length;
+  }
+
+  /**
+   * Returns all event names with listeners
+   * @returns {string[]} Array of event names
+   */
+  eventNames() {
+    return Array.from(this._events.keys());
+  }
+
+  /**
+   * Sets the maximum number of listeners per event
+   * @param {number} n - Maximum listeners
+   * @returns {EventEmitter} This instance for chaining
+   */
+  setMaxListeners(n) {
+    this._maxListeners = n;
+    return this;
+  }
+
+  /**
+   * Gets the maximum number of listeners per event
+   * @returns {number} Maximum listeners
+   */
+  getMaxListeners() {
+    return this._maxListeners;
+  }
+}
+
+module.exports = EventEmitter;

package/src/utils/LRUCache.js

@@ -0,0 +1,202 @@
+'use strict';
+
+/**
+ * @fileoverview LRU (Least Recently Used) cache implementation
+ * @module utils/LRUCache
+ */
+
+/**
+ * Generic LRU cache with O(1) get/set operations
+ * @template K, V
+ * @class LRUCache
+ */
+class LRUCache {
+  /**
+   * Creates a new LRU cache
+   * @param {number} maxSize - Maximum number of items to store
+   * @throws {Error} If maxSize is not a positive integer
+   */
+  constructor(maxSize) {
+    if (!Number.isInteger(maxSize) || maxSize <= 0) {
+      throw new Error('maxSize must be a positive integer');
+    }
+
+    /**
+     * Maximum cache size
+     * @type {number}
+     * @private
+     */
+    this._maxSize = maxSize;
+
+    /**
+     * Internal Map for storage (maintains insertion order)
+     * @type {Map<K, V>}
+     * @private
+     */
+    this._cache = new Map();
+  }
+
+  /**
+   * Gets a value from the cache
+   * @param {K} key - Key to look up
+   * @returns {V|undefined} Value or undefined if not found
+   */
+  get(key) {
+    if (!this._cache.has(key)) {
+      return undefined;
+    }
+
+    // Move to end (most recently used)
+    const value = this._cache.get(key);
+    this._cache.delete(key);
+    this._cache.set(key, value);
+
+    return value;
+  }
+
+  /**
+   * Sets a value in the cache
+   * @param {K} key - Key to set
+   * @param {V} value - Value to store
+   * @returns {LRUCache<K, V>} This instance for chaining
+   */
+  set(key, value) {
+    // If key exists, delete it first to update order
+    if (this._cache.has(key)) {
+      this._cache.delete(key);
+    } else if (this._cache.size >= this._maxSize) {
+      // Remove least recently used (first item)
+      const firstKey = this._cache.keys().next().value;
+      this._cache.delete(firstKey);
+    }
+
+    this._cache.set(key, value);
+    return this;
+  }
+
+  /**
+   * Checks if a key exists in the cache
+   * Does not update access order
+   * @param {K} key - Key to check
+   * @returns {boolean} True if key exists
+   */
+  has(key) {
+    return this._cache.has(key);
+  }
+
+  /**
+   * Removes a key from the cache
+   * @param {K} key - Key to remove
+   * @returns {boolean} True if key was removed
+   */
+  delete(key) {
+    return this._cache.delete(key);
+  }
+
+  /**
+   * Clears all items from the cache
+   */
+  clear() {
+    this._cache.clear();
+  }
+
+  /**
+   * Gets the current number of items in the cache
+   * @returns {number} Number of items
+   */
+  get size() {
+    return this._cache.size;
+  }
+
+  /**
+   * Gets the maximum size of the cache
+   * @returns {number} Maximum size
+   */
+  get maxSize() {
+    return this._maxSize;
+  }
+
+  /**
+   * Returns all keys in the cache (most recent last)
+   * @returns {K[]} Array of keys
+   */
+  keys() {
+    return Array.from(this._cache.keys());
+  }
+
+  /**
+   * Returns all values in the cache (most recent last)
+   * @returns {V[]} Array of values
+   */
+  values() {
+    return Array.from(this._cache.values());
+  }
+
+  /**
+   * Returns all entries in the cache (most recent last)
+   * @returns {Array} Array of [key, value] pairs
+   */
+  entries() {
+    return Array.from(this._cache.entries());
+  }
+
+  /**
+   * Iterates over cache entries
+   * @param {function(V, K, Map<K, V>): void} callback - Callback function
+   */
+  forEach(callback) {
+    this._cache.forEach(callback);
+  }
+
+  /**
+   * Peeks at a value without updating access order
+   * @param {K} key - Key to peek
+   * @returns {V|undefined} Value or undefined if not found
+   */
+  peek(key) {
+    return this._cache.get(key);
+  }
+
+  /**
+   * Gets the oldest key (least recently used)
+   * @returns {K|undefined} Oldest key or undefined if empty
+   */
+  getOldest() {
+    if (this._cache.size === 0) {
+      return undefined;
+    }
+    return this._cache.keys().next().value;
+  }
+
+  /**
+   * Gets the newest key (most recently used)
+   * @returns {K|undefined} Newest key or undefined if empty
+   */
+  getNewest() {
+    if (this._cache.size === 0) {
+      return undefined;
+    }
+    const keys = Array.from(this._cache.keys());
+    return keys[keys.length - 1];
+  }
+
+  /**
+   * Updates max size and evicts items if necessary
+   * @param {number} newMaxSize - New maximum size
+   */
+  resize(newMaxSize) {
+    if (!Number.isInteger(newMaxSize) || newMaxSize <= 0) {
+      throw new Error('maxSize must be a positive integer');
+    }
+
+    this._maxSize = newMaxSize;
+
+    // Evict oldest items if over new limit
+    while (this._cache.size > this._maxSize) {
+      const firstKey = this._cache.keys().next().value;
+      this._cache.delete(firstKey);
+    }
+  }
+}
+
+module.exports = LRUCache;

package/src/utils/RateLimiter.js

@@ -0,0 +1,202 @@
+'use strict';
+
+/**
+ * @fileoverview Token bucket rate limiter implementation
+ * @module utils/RateLimiter
+ */
+
+/**
+ * Token bucket rate limiter for controlling operation frequency
+ * @class RateLimiter
+ */
+class RateLimiter {
+  /**
+   * Creates a new RateLimiter
+   * @param {Object} options - Configuration options
+   * @param {number} options.tokensPerInterval - Number of tokens added per interval
+   * @param {number} options.interval - Interval in milliseconds
+   * @param {number} [options.maxTokens] - Maximum token bucket size (defaults to tokensPerInterval)
+   */
+  constructor(options) {
+    const { tokensPerInterval, interval, maxTokens } = options;
+
+    if (!Number.isInteger(tokensPerInterval) || tokensPerInterval <= 0) {
+      throw new Error('tokensPerInterval must be a positive integer');
+    }
+
+    if (!Number.isInteger(interval) || interval <= 0) {
+      throw new Error('interval must be a positive integer');
+    }
+
+    /**
+     * Tokens added per interval
+     * @type {number}
+     * @private
+     */
+    this._tokensPerInterval = tokensPerInterval;
+
+    /**
+     * Interval in milliseconds
+     * @type {number}
+     * @private
+     */
+    this._interval = interval;
+
+    /**
+     * Maximum tokens in bucket
+     * @type {number}
+     * @private
+     */
+    this._maxTokens = maxTokens || tokensPerInterval;
+
+    /**
+     * Current token count
+     * @type {number}
+     * @private
+     */
+    this._tokens = this._maxTokens;
+
+    /**
+     * Last refill timestamp
+     * @type {number}
+     * @private
+     */
+    this._lastRefill = Date.now();
+  }
+
+  /**
+   * Refills tokens based on elapsed time
+   * @private
+   */
+  _refill() {
+    const now = Date.now();
+    const elapsed = now - this._lastRefill;
+    const tokensToAdd = Math.floor(elapsed / this._interval) * this._tokensPerInterval;
+
+    if (tokensToAdd > 0) {
+      this._tokens = Math.min(this._maxTokens, this._tokens + tokensToAdd);
+      this._lastRefill = now - (elapsed % this._interval);
+    }
+  }
+
+  /**
+   * Attempts to consume tokens
+   * @param {number} [count=1] - Number of tokens to consume
+   * @returns {boolean} True if tokens were consumed, false if insufficient
+   */
+  tryConsume(count = 1) {
+    if (!Number.isInteger(count) || count <= 0) {
+      throw new Error('count must be a positive integer');
+    }
+
+    this._refill();
+
+    if (this._tokens >= count) {
+      this._tokens -= count;
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Gets time until tokens are available
+   * @param {number} [count=1] - Number of tokens needed
+   * @returns {number} Time in milliseconds until tokens are available (0 if available now)
+   */
+  getTimeUntilNext(count = 1) {
+    if (!Number.isInteger(count) || count <= 0) {
+      throw new Error('count must be a positive integer');
+    }
+
+    this._refill();
+
+    if (this._tokens >= count) {
+      return 0;
+    }
+
+    const tokensNeeded = count - this._tokens;
+    const intervalsNeeded = Math.ceil(tokensNeeded / this._tokensPerInterval);
+
+    const elapsed = Date.now() - this._lastRefill;
+    const timeInCurrentInterval = this._interval - elapsed;
+
+    return timeInCurrentInterval + (intervalsNeeded - 1) * this._interval;
+  }
+
+  /**
+   * Waits until tokens are available, then consumes them
+   * @param {number} [count=1] - Number of tokens to consume
+   * @returns {Promise<void>} Resolves when tokens are consumed
+   */
+  async consume(count = 1) {
+    const waitTime = this.getTimeUntilNext(count);
+
+    if (waitTime > 0) {
+      await new Promise(resolve => setTimeout(resolve, waitTime));
+    }
+
+    // Re-check and consume (another consumer may have taken tokens)
+    while (!this.tryConsume(count)) {
+      const retryWait = this.getTimeUntilNext(count);
+      await new Promise(resolve => setTimeout(resolve, retryWait || 1));
+    }
+  }
+
+  /**
+   * Gets the current number of available tokens
+   * @returns {number} Available tokens
+   */
+  getAvailableTokens() {
+    this._refill();
+    return this._tokens;
+  }
+
+  /**
+   * Resets the rate limiter to full capacity
+   */
+  reset() {
+    this._tokens = this._maxTokens;
+    this._lastRefill = Date.now();
+  }
+
+  /**
+   * Gets rate limiter configuration
+   * @returns {Object} Configuration object
+   */
+  getConfig() {
+    return {
+      tokensPerInterval: this._tokensPerInterval,
+      interval: this._interval,
+      maxTokens: this._maxTokens
+    };
+  }
+}
+
+/**
+ * Creates a rate limiter with per-second rate
+ * @param {number} requestsPerSecond - Maximum requests per second
+ * @returns {RateLimiter} New rate limiter
+ */
+function perSecond(requestsPerSecond) {
+  return new RateLimiter({
+    tokensPerInterval: requestsPerSecond,
+    interval: 1000
+  });
+}
+
+/**
+ * Creates a rate limiter with per-minute rate
+ * @param {number} requestsPerMinute - Maximum requests per minute
+ * @returns {RateLimiter} New rate limiter
+ */
+function perMinute(requestsPerMinute) {
+  return new RateLimiter({
+    tokensPerInterval: requestsPerMinute,
+    interval: 60000
+  });
+}
+
+module.exports = RateLimiter;
+module.exports.perSecond = perSecond;
+module.exports.perMinute = perMinute;