tiny-essentials 1.9.1 → 1.10.0

package/dist/TinyRateLimiter.js

@@ -30,24 +30,109 @@ __webpack_require__.d(__webpack_exports__, {
 });
 
 ;// ./src/v1/libs/TinyRateLimiter.mjs
+/** @typedef {(groupId: string) => void} OnMemoryExceeded */
+
+/** @typedef {(groupId: string) => void} OnGroupExpired */
+
 /**
- * Class representing a flexible rate limiter per user.
- *
- * This rate limiter can be configured by maximum number of hits,
- * time interval, or a combination of both. It supports automatic
- * cleanup of inactive users to optimize memory usage.
+ * Class representing a flexible rate limiter per user or group.
  *
- * @class
+ * This rate limiter supports limiting per user or per group by mapping
+ * userIds to a common groupId. All users within the same group share
+ * rate limits.
  */
 class TinyRateLimiter {
+  /** @type {number|null} */
+  #maxMemory = null;
+
+  /** @type {NodeJS.Timeout|null} */
+  #cleanupTimer = null;
+
+  /** @type {number|null|undefined} */
+  #maxHits = null;
+
+  /** @type {number|null|undefined} */
+  #interval = null;
+
+  /** @type {number|null|undefined} */
+  #cleanupInterval = null;
+
+  /** @type {number|null|undefined} */
+  #maxIdle = null;
+
+  /** @type {Map<string, number[]>} */
+  groupData = new Map(); // groupId -> timestamps[]
+
+  /** @type {Map<string, number>} */
+  lastSeen = new Map(); // groupId -> timestamp
+
+  /** @type {Map<string, string>} */
+  userToGroup = new Map(); // userId -> groupId
+
+  /** @type {Map<string, boolean>} */
+  groupFlags = new Map(); // groupId -> boolean
+
+  /**
+   * @type {Map<string, number>}
+   * Stores TTL (in ms) for each groupId individually
+   */
+  groupTTL = new Map();
+
+  /**
+   * @type {null|OnMemoryExceeded}
+   */
+  #onMemoryExceeded = null;
+
+  /**
+   * Set the callback to be triggered when a group exceeds its limit
+   * @param {OnMemoryExceeded} callback
+   */
+  setOnMemoryExceeded(callback) {
+    if (typeof callback !== 'function') throw new Error('onMemoryExceeded must be a function');
+    this.#onMemoryExceeded = callback;
+  }
+
+  /**
+   * Clear the onMemoryExceeded callback
+   */
+  clearOnMemoryExceeded() {
+    this.#onMemoryExceeded = null;
+  }
+
+  /**
+   * @type {null|OnGroupExpired}
+   */
+  #onGroupExpired = null;
+
+  /**
+   * Set the callback to be triggered when a group expires and is removed.
+   *
+   * This callback is called automatically during cleanup when a group
+   * becomes inactive for longer than its TTL.
+   *
+   * @param {OnGroupExpired} callback - A function that receives the expired groupId.
+   */
+  setOnGroupExpired(callback) {
+    if (typeof callback !== 'function') throw new Error('onGroupExpired must be a function');
+    this.#onGroupExpired = callback;
+  }
+
+  /**
+   * Clear the onGroupExpired callback
+   */
+  clearOnGroupExpired() {
+    this.#onGroupExpired = null;
+  }
+
   /**
    * @param {Object} options
+   * @param {number|null} [options.maxMemory] - Max memory allowed
    * @param {number} [options.maxHits] - Max interactions allowed
    * @param {number} [options.interval] - Time window in milliseconds
    * @param {number} [options.cleanupInterval] - Interval for automatic cleanup (ms)
    * @param {number} [options.maxIdle=300000] - Max idle time for a user before being cleaned (ms)
    */
-  constructor({ maxHits, interval, cleanupInterval, maxIdle = 300000 }) {
+  constructor({ maxHits, interval, cleanupInterval, maxIdle = 300000, maxMemory = 100000 }) {
     /** @param {number|undefined} val */
     const isPositiveInteger = (val) =>
       typeof val === 'number' && Number.isFinite(val) && val >= 1 && Number.isInteger(val);
@@ -67,45 +152,129 @@ class TinyRateLimiter {
       throw new Error("'cleanupInterval' must be a positive integer in milliseconds if defined.");
     if (!isMaxIdleValid) throw new Error("'maxIdle' must be a positive integer in milliseconds.");
 
-    this.maxHits = isMaxHitsValid ? maxHits : null;
-    this.interval = isIntervalValid ? interval : null;
-    this.cleanupInterval = isCleanupValid ? cleanupInterval : null;
-    this.maxIdle = maxIdle;
-
-    /** @type {Map<string, number[]>} */
-    this.userData = new Map();
+    if (typeof maxMemory === 'number' && Number.isFinite(maxMemory) && maxMemory > 0) {
+      this.#maxMemory = Math.floor(maxMemory);
+    } else if (maxMemory === null || maxMemory === undefined) {
+      this.#maxMemory = null;
+    } else {
+      throw new Error('maxMemory must be a positive number or null');
+    }
 
-    /** @type {Map<string, number>} */
-    this.lastSeen = new Map();
+    this.#maxHits = isMaxHitsValid ? maxHits : null;
+    this.#interval = isIntervalValid ? interval : null;
+    this.#cleanupInterval = isCleanupValid ? cleanupInterval : null;
+    this.#maxIdle = maxIdle;
 
     // Start automatic cleanup only if cleanupInterval is valid
-    if (this.cleanupInterval !== null)
-      this._cleanupTimer = setInterval(() => this._cleanup(), this.cleanupInterval);
+    if (this.#cleanupInterval !== null)
+      this.#cleanupTimer = setInterval(() => this._cleanup(), this.#cleanupInterval);
   }
 
   /**
-   * Get the interval window in milliseconds.
-   *
-   * @returns {number} The interval value.
-   * @throws {Error} If interval is not a valid finite number.
+   * Check if a given ID is a groupId (not a userId)
+   * @param {string} id
+   * @returns {boolean}
    */
-  getInterval() {
-    if (typeof this.interval !== 'number' || !Number.isFinite(this.interval))
-      throw new Error("'interval' is not a valid finite number.");
-    return this.interval;
+  isGroupId(id) {
+    const result = this.groupFlags.get(id);
+    return typeof result === 'boolean' ? result : false;
   }
 
   /**
-   * Get the maximum number of allowed hits.
-   *
-   * @returns {number} The maxHits value.
-   * @throws {Error} If maxHits is not a valid finite number.
+   * Get all user IDs that belong to a given group.
+   * @param {string} groupId
+   * @returns {string[]}
    */
-  getMaxHits() {
-    if (typeof this.maxHits !== 'number' || !Number.isFinite(this.maxHits)) {
-      throw new Error("'maxHits' is not a valid finite number.");
+  getUsersInGroup(groupId) {
+    const users = [];
+    for (const [userId, assignedGroup] of this.userToGroup.entries()) {
+      if (assignedGroup === groupId) {
+        users.push(userId);
+      }
+    }
+
+    return users;
+  }
+
+  /**
+   * Set TTL (in milliseconds) for a specific group
+   * @param {string} groupId
+   * @param {number} ttl
+   */
+  setGroupTTL(groupId, ttl) {
+    if (typeof ttl !== 'number' || !Number.isFinite(ttl) || ttl <= 0)
+      throw new Error('TTL must be a positive number in milliseconds');
+    this.groupTTL.set(groupId, ttl);
+  }
+
+  /**
+   * Get TTL (in ms) for a specific group.
+   * @param {string} groupId
+   * @returns {number|null}
+   */
+  getGroupTTL(groupId) {
+    return this.groupTTL.get(groupId) ?? null;
+  }
+
+  /**
+   * Delete the TTL setting for a specific group
+   * @param {string} groupId
+   */
+  deleteGroupTTL(groupId) {
+    this.groupTTL.delete(groupId);
+  }
+
+  /**
+   * Assign a userId to a groupId, with merge if user has existing data.
+   * @param {string} userId
+   * @param {string} groupId
+   * @throws {Error} If userId is already assigned to a different group
+   */
+  assignToGroup(userId, groupId) {
+    const existingGroup = this.userToGroup.get(userId);
+    if (existingGroup && existingGroup !== groupId)
+      throw new Error(`User ${userId} is already assigned to group ${existingGroup}`);
+
+    // If the user is already in the group, nothing needs to be done
+    if (existingGroup === groupId) return;
+    const userData = this.groupData.get(userId);
+
+    // Associates the user to the group
+    if (this.isGroupId(userId)) {
+      for (const [uid, gId] of this.userToGroup.entries())
+        if (gId === userId) this.userToGroup.set(uid, groupId);
+      this.userToGroup.delete(userId);
+    } else this.userToGroup.set(userId, groupId);
+
+    // If the user has no data, nothing needs to be done
+    if (!userData) return;
+
+    const groupData = this.groupData.get(groupId);
+    if (groupData) {
+      for (const item of userData) groupData.push(item);
+    } else {
+      const newData = [];
+      for (const item of userData) newData.push(item);
+      this.groupData.set(groupId, newData);
     }
-    return this.maxHits;
+
+    this.lastSeen.set(groupId, Date.now());
+
+    // Removes individual data as they are now in the group
+    this.groupFlags.delete(userId);
+    this.groupData.delete(userId);
+    this.lastSeen.delete(userId);
+    this.groupTTL.delete(userId);
+    this.groupFlags.set(groupId, true);
+  }
+
+  /**
+   * Get the groupId for a given userId
+   * @param {string} userId
+   * @returns {string}
+   */
+  getGroupId(userId) {
+    return this.userToGroup.get(userId) || userId; // fallback: use userId as own group
   }
 
   /**
@@ -113,20 +282,22 @@ class TinyRateLimiter {
    * @param {string} userId
    */
   hit(userId) {
+    const groupId = this.getGroupId(userId);
     const now = Date.now();
 
-    if (!this.userData.has(userId)) {
-      this.userData.set(userId, []);
+    if (!this.groupData.has(groupId)) {
+      this.groupData.set(groupId, []);
+      this.groupFlags.set(groupId, false);
     }
 
-    const history = this.userData.get(userId);
-    if (!history) throw new Error(`No data found for userId: ${userId}`);
+    const history = this.groupData.get(groupId);
+    if (!history) throw new Error(`No data found for groupId: ${groupId}`);
 
     history.push(now);
-    this.lastSeen.set(userId, now);
+    this.lastSeen.set(groupId, now);
 
     // Clean up old entries
-    if (this.interval !== null) {
+    if (this.#interval !== null) {
       const interval = this.getInterval();
       const cutoff = now - interval;
       while (history.length && history[0] < cutoff) {
@@ -135,92 +306,295 @@ class TinyRateLimiter {
     }
 
     // Optional: keep only the last N entries for memory optimization
-    if (this.maxHits !== null) {
-      const maxHits = this.getMaxHits();
-      if (history.length > maxHits) {
-        history.splice(0, history.length - maxHits);
+    if (this.#maxMemory !== null && typeof this.#maxMemory === 'number') {
+      if (history.length > this.#maxMemory) {
+        history.splice(0, history.length - this.#maxMemory);
+        if (typeof this.#onMemoryExceeded === 'function') this.#onMemoryExceeded(groupId);
       }
     }
   }
 
   /**
-   * Check if the user is currently rate limited
+   * Check if the user (via their group) is currently rate limited
    * @param {string} userId
    * @returns {boolean}
    */
   isRateLimited(userId) {
-    const now = Date.now();
-
-    if (!this.userData.has(userId)) return false;
+    const groupId = this.getGroupId(userId);
+    if (!this.groupData.has(groupId)) return false;
 
-    const history = this.userData.get(userId);
-    if (!history) throw new Error(`No data found for userId: ${userId}`);
+    const history = this.groupData.get(groupId);
+    if (!history) throw new Error(`No data found for groupId: ${groupId}`);
 
-    if (this.interval !== null) {
+    if (this.#interval !== null) {
+      const now = Date.now();
       const interval = this.getInterval();
-      const recent = history.filter((t) => t > now - interval);
-      if (this.maxHits !== null) {
-        return recent.length >= this.getMaxHits();
+      const cutoff = now - interval;
+      let count = 0;
+      for (let i = history.length - 1; i >= 0; i--) {
+        if (history[i] > cutoff) count++;
+        else break;
       }
-      return recent.length > 0;
+      if (this.#maxHits !== null) return count > this.getMaxHits();
+      return count > 0;
     }
 
-    if (this.maxHits !== null) {
-      return history.length >= this.getMaxHits();
+    if (this.#maxHits !== null) {
+      return history.length > this.getMaxHits();
     }
 
     return false;
   }
 
   /**
-   * Manually reset user data
+   * Manually reset group data
+   * @param {string} groupId
+   */
+  resetGroup(groupId) {
+    this.groupFlags.delete(groupId);
+    this.groupData.delete(groupId);
+    this.lastSeen.delete(groupId);
+    this.groupTTL.delete(groupId);
+  }
+
+  /**
+   * Manually reset user data.
+   *
+   * @deprecated Use `resetUserGroup(userId)` instead. This method will be removed in future versions.
    * @param {string} userId
+   * @returns {void}
    */
   reset(userId) {
-    this.userData.delete(userId);
-    this.lastSeen.delete(userId);
+    if (false)
+      {}
+    return this.resetUserGroup(userId);
   }
 
   /**
-   * Set hit timestamps for a user
+   * Manually reset a user mapping
    * @param {string} userId
+   */
+  resetUserGroup(userId) {
+    this.userToGroup.delete(userId);
+  }
+
+  /**
+   * Set custom timestamps to a group
+   * @param {string} groupId
    * @param {number[]} timestamps
    */
-  setData(userId, timestamps) {
-    this.userData.set(userId, timestamps);
-    this.lastSeen.set(userId, Date.now());
+  setData(groupId, timestamps) {
+    if (!Array.isArray(timestamps)) throw new Error('timestamps must be an array of numbers.');
+    for (const t of timestamps) {
+      if (typeof t !== 'number' || !Number.isFinite(t)) {
+        throw new Error('All timestamps must be finite numbers.');
+      }
+    }
+    if (!this.groupData.has(groupId)) this.groupFlags.set(groupId, false);
+    this.groupData.set(groupId, timestamps);
+    this.lastSeen.set(groupId, Date.now());
   }
 
   /**
-   * Get timestamps from user
-   * @param {string} userId
+   * Check if a group has data
+   * @param {string} groupId
+   * @returns {boolean}
+   */
+  hasData(groupId) {
+    return this.groupData.has(groupId);
+  }
+
+  /**
+   * Get timestamps from a group
+   * @param {string} groupId
    * @returns {number[]}
    */
-  getData(userId) {
-    return this.userData.get(userId) || [];
+  getData(groupId) {
+    return this.groupData.get(groupId) || [];
   }
 
   /**
-   * Cleanup old/inactive users
+   * Get the maximum idle time (in milliseconds) before a group is considered expired.
+   * @returns {number}
+   */
+  getMaxIdle() {
+    if (typeof this.#maxIdle !== 'number' || !Number.isFinite(this.#maxIdle) || this.#maxIdle < 0) {
+      throw new Error("'maxIdle' must be a non-negative finite number.");
+    }
+    return this.#maxIdle;
+  }
+
+  /**
+   * Set the maximum idle time (in milliseconds) before a group is considered expired.
+   * @param {number} ms
+   */
+  setMaxIdle(ms) {
+    if (typeof ms !== 'number' || !Number.isFinite(ms) || ms < 0) {
+      throw new Error("'maxIdle' must be a non-negative finite number.");
+    }
+    this.#maxIdle = ms;
+  }
+
+  /**
+   * Cleanup old/inactive groups with individual TTLs
    * @private
    */
   _cleanup() {
     const now = Date.now();
-    for (const [userId, last] of this.lastSeen.entries()) {
-      if (now - last > this.maxIdle) {
-        this.userData.delete(userId);
-        this.lastSeen.delete(userId);
+    for (const [groupId, last] of this.lastSeen.entries()) {
+      const ttl = this.getGroupTTL(groupId) ?? this.getMaxIdle();
+      if (now - last > ttl) {
+        this.groupFlags.delete(groupId);
+        this.groupData.delete(groupId);
+        this.lastSeen.delete(groupId);
+        this.groupTTL.delete(groupId);
+
+        // Notify subclass or external binding
+        if (typeof this.#onGroupExpired === 'function') {
+          this.#onGroupExpired(groupId);
+        }
       }
     }
   }
 
   /**
-   * Destroy the rate limiter, stopping all intervals
+   * Get list of active group IDs
+   * @returns {string[]}
+   */
+  getActiveGroups() {
+    return Array.from(this.groupData.keys());
+  }
+
+  /**
+   * Get a shallow copy of all user-to-group mappings as a plain object
+   * @returns {Record<string, string>}
+   */
+  getAllUserMappings() {
+    return Object.fromEntries(this.userToGroup);
+  }
+
+  /**
+   * Get the interval window in milliseconds.
+   * @returns {number}
+   */
+  getInterval() {
+    if (typeof this.#interval !== 'number' || !Number.isFinite(this.#interval)) {
+      throw new Error("'interval' is not a valid finite number.");
+    }
+    return this.#interval;
+  }
+
+  /**
+   * Get the maximum number of allowed hits.
+   * @returns {number}
+   */
+  getMaxHits() {
+    if (typeof this.#maxHits !== 'number' || !Number.isFinite(this.#maxHits)) {
+      throw new Error("'maxHits' is not a valid finite number.");
+    }
+    return this.#maxHits;
+  }
+
+  /**
+   * Get the total number of hits recorded for a group.
+   * @param {string} groupId
+   * @returns {number}
+   */
+  getTotalHits(groupId) {
+    const history = this.groupData.get(groupId);
+    return Array.isArray(history) ? history.length : 0;
+  }
+
+  /**
+   * Get the timestamp of the last hit for a group.
+   * @param {string} groupId
+   * @returns {number|null}
+   */
+  getLastHit(groupId) {
+    const history = this.groupData.get(groupId);
+    return history?.length ? history[history.length - 1] : null;
+  }
+
+  /**
+   * Get milliseconds since the last hit for a group.
+   * @param {string} groupId
+   * @returns {number|null}
+   */
+  getTimeSinceLastHit(groupId) {
+    const last = this.getLastHit(groupId);
+    return last !== null ? Date.now() - last : null;
+  }
+
+  /**
+   * Internal utility to compute average spacing
+   * @private
+   * @param {number[]|undefined} history
+   * @returns {number|null}
+   */
+  _calculateAverageSpacing(history) {
+    if (!Array.isArray(history) || history.length < 2) return null;
+    let total = 0;
+    for (let i = 1; i < history.length; i++) {
+      total += history[i] - history[i - 1];
+    }
+    return total / (history.length - 1);
+  }
+
+  /**
+   * Get average time between hits for a group (ms).
+   * @param {string} groupId
+   * @returns {number|null}
+   */
+  getAverageHitSpacing(groupId) {
+    return this._calculateAverageSpacing(this.groupData.get(groupId));
+  }
+
+  /**
+   * Get metrics about a group's activity.
+   * @param {string} groupId
+   * @returns {{
+   *   totalHits: number,
+   *   lastHit: number|null,
+   *   timeSinceLastHit: number|null,
+   *   averageHitSpacing: number|null
+   * }}
+   */
+  getMetrics(groupId) {
+    const history = this.groupData.get(groupId);
+
+    if (!Array.isArray(history) || history.length === 0) {
+      return {
+        totalHits: 0,
+        lastHit: null,
+        timeSinceLastHit: null,
+        averageHitSpacing: null,
+      };
+    }
+
+    const totalHits = history.length;
+    const lastHit = history[totalHits - 1];
+    const timeSinceLastHit = Date.now() - lastHit;
+    const averageHitSpacing = this._calculateAverageSpacing(history);
+
+    return {
+      totalHits,
+      lastHit,
+      timeSinceLastHit,
+      averageHitSpacing,
+    };
+  }
+
+  /**
+   * Destroy the rate limiter, stopping cleanup and clearing data
    */
   destroy() {
-    if (this._cleanupTimer) clearInterval(this._cleanupTimer);
-    this.userData.clear();
+    if (this.#cleanupTimer) clearInterval(this.#cleanupTimer);
+    this._cleanup();
+    this.groupData.clear();
     this.lastSeen.clear();
+    this.userToGroup.clear();
+    this.groupTTL.clear();
+    this.groupFlags.clear();
   }
 }
 

package/dist/TinyRateLimiter.min.js

@@ -1 +1 @@
-(()=>{"use strict";var t={d:(e,i)=>{for(var s in i)t.o(i,s)&&!t.o(e,s)&&Object.defineProperty(e,s,{enumerable:!0,get:i[s]})},o:(t,e)=>Object.prototype.hasOwnProperty.call(t,e)},e={};t.d(e,{TinyRateLimiter:()=>i});const i=class{constructor({maxHits:t,interval:e,cleanupInterval:i,maxIdle:s=3e5}){const r=t=>"number"==typeof t&&Number.isFinite(t)&&t>=1&&Number.isInteger(t),n=r(t),a=r(e),l=r(i),o=r(s);if(!n&&!a)throw new Error("RateLimiter requires at least one valid option: 'maxHits' or 'interval'.");if(void 0!==t&&!n)throw new Error("'maxHits' must be a positive integer if defined.");if(void 0!==e&&!a)throw new Error("'interval' must be a positive integer in milliseconds if defined.");if(void 0!==i&&!l)throw new Error("'cleanupInterval' must be a positive integer in milliseconds if defined.");if(!o)throw new Error("'maxIdle' must be a positive integer in milliseconds.");this.maxHits=n?t:null,this.interval=a?e:null,this.cleanupInterval=l?i:null,this.maxIdle=s,this.userData=new Map,this.lastSeen=new Map,null!==this.cleanupInterval&&(this._cleanupTimer=setInterval((()=>this._cleanup()),this.cleanupInterval))}getInterval(){if("number"!=typeof this.interval||!Number.isFinite(this.interval))throw new Error("'interval' is not a valid finite number.");return this.interval}getMaxHits(){if("number"!=typeof this.maxHits||!Number.isFinite(this.maxHits))throw new Error("'maxHits' is not a valid finite number.");return this.maxHits}hit(t){const e=Date.now();this.userData.has(t)||this.userData.set(t,[]);const i=this.userData.get(t);if(!i)throw new Error(`No data found for userId: ${t}`);if(i.push(e),this.lastSeen.set(t,e),null!==this.interval){const t=e-this.getInterval();for(;i.length&&i[0]<t;)i.shift()}if(null!==this.maxHits){const t=this.getMaxHits();i.length>t&&i.splice(0,i.length-t)}}isRateLimited(t){const e=Date.now();if(!this.userData.has(t))return!1;const i=this.userData.get(t);if(!i)throw new Error(`No data found for userId: ${t}`);if(null!==this.interval){const t=this.getInterval(),s=i.filter((i=>i>e-t));return null!==this.maxHits?s.length>=this.getMaxHits():s.length>0}return null!==this.maxHits&&i.length>=this.getMaxHits()}reset(t){this.userData.delete(t),this.lastSeen.delete(t)}setData(t,e){this.userData.set(t,e),this.lastSeen.set(t,Date.now())}getData(t){return this.userData.get(t)||[]}_cleanup(){const t=Date.now();for(const[e,i]of this.lastSeen.entries())t-i>this.maxIdle&&(this.userData.delete(e),this.lastSeen.delete(e))}destroy(){this._cleanupTimer&&clearInterval(this._cleanupTimer),this.userData.clear(),this.lastSeen.clear()}};window.TinyRateLimiter=e.TinyRateLimiter})();
+(()=>{"use strict";var e={d:(t,r)=>{for(var i in r)e.o(r,i)&&!e.o(t,i)&&Object.defineProperty(t,i,{enumerable:!0,get:r[i]})},o:(e,t)=>Object.prototype.hasOwnProperty.call(e,t)},t={};e.d(t,{TinyRateLimiter:()=>r});const r=class{#e=null;#t=null;#r=null;#i=null;#s=null;#n=null;groupData=new Map;lastSeen=new Map;userToGroup=new Map;groupFlags=new Map;groupTTL=new Map;#o=null;setOnMemoryExceeded(e){if("function"!=typeof e)throw new Error("onMemoryExceeded must be a function");this.#o=e}clearOnMemoryExceeded(){this.#o=null}#a=null;setOnGroupExpired(e){if("function"!=typeof e)throw new Error("onGroupExpired must be a function");this.#a=e}clearOnGroupExpired(){this.#a=null}constructor({maxHits:e,interval:t,cleanupInterval:r,maxIdle:i=3e5,maxMemory:s=1e5}){const n=e=>"number"==typeof e&&Number.isFinite(e)&&e>=1&&Number.isInteger(e),o=n(e),a=n(t),u=n(r),l=n(i);if(!o&&!a)throw new Error("RateLimiter requires at least one valid option: 'maxHits' or 'interval'.");if(void 0!==e&&!o)throw new Error("'maxHits' must be a positive integer if defined.");if(void 0!==t&&!a)throw new Error("'interval' must be a positive integer in milliseconds if defined.");if(void 0!==r&&!u)throw new Error("'cleanupInterval' must be a positive integer in milliseconds if defined.");if(!l)throw new Error("'maxIdle' must be a positive integer in milliseconds.");if("number"==typeof s&&Number.isFinite(s)&&s>0)this.#e=Math.floor(s);else{if(null!=s)throw new Error("maxMemory must be a positive number or null");this.#e=null}this.#r=o?e:null,this.#i=a?t:null,this.#s=u?r:null,this.#n=i,null!==this.#s&&(this.#t=setInterval((()=>this._cleanup()),this.#s))}isGroupId(e){const t=this.groupFlags.get(e);return"boolean"==typeof t&&t}getUsersInGroup(e){const t=[];for(const[r,i]of this.userToGroup.entries())i===e&&t.push(r);return t}setGroupTTL(e,t){if("number"!=typeof t||!Number.isFinite(t)||t<=0)throw new Error("TTL must be a positive number in milliseconds");this.groupTTL.set(e,t)}getGroupTTL(e){return this.groupTTL.get(e)??null}deleteGroupTTL(e){this.groupTTL.delete(e)}assignToGroup(e,t){const r=this.userToGroup.get(e);if(r&&r!==t)throw new Error(`User ${e} is already assigned to group ${r}`);if(r===t)return;const i=this.groupData.get(e);if(this.isGroupId(e)){for(const[r,i]of this.userToGroup.entries())i===e&&this.userToGroup.set(r,t);this.userToGroup.delete(e)}else this.userToGroup.set(e,t);if(!i)return;const s=this.groupData.get(t);if(s)for(const e of i)s.push(e);else{const e=[];for(const t of i)e.push(t);this.groupData.set(t,e)}this.lastSeen.set(t,Date.now()),this.groupFlags.delete(e),this.groupData.delete(e),this.lastSeen.delete(e),this.groupTTL.delete(e),this.groupFlags.set(t,!0)}getGroupId(e){return this.userToGroup.get(e)||e}hit(e){const t=this.getGroupId(e),r=Date.now();this.groupData.has(t)||(this.groupData.set(t,[]),this.groupFlags.set(t,!1));const i=this.groupData.get(t);if(!i)throw new Error(`No data found for groupId: ${t}`);if(i.push(r),this.lastSeen.set(t,r),null!==this.#i){const e=r-this.getInterval();for(;i.length&&i[0]<e;)i.shift()}null!==this.#e&&"number"==typeof this.#e&&i.length>this.#e&&(i.splice(0,i.length-this.#e),"function"==typeof this.#o&&this.#o(t))}isRateLimited(e){const t=this.getGroupId(e);if(!this.groupData.has(t))return!1;const r=this.groupData.get(t);if(!r)throw new Error(`No data found for groupId: ${t}`);if(null!==this.#i){const e=Date.now()-this.getInterval();let t=0;for(let i=r.length-1;i>=0&&r[i]>e;i--)t++;return null!==this.#r?t>this.getMaxHits():t>0}return null!==this.#r&&r.length>this.getMaxHits()}resetGroup(e){this.groupFlags.delete(e),this.groupData.delete(e),this.lastSeen.delete(e),this.groupTTL.delete(e)}reset(e){return this.resetUserGroup(e)}resetUserGroup(e){this.userToGroup.delete(e)}setData(e,t){if(!Array.isArray(t))throw new Error("timestamps must be an array of numbers.");for(const e of t)if("number"!=typeof e||!Number.isFinite(e))throw new Error("All timestamps must be finite numbers.");this.groupData.has(e)||this.groupFlags.set(e,!1),this.groupData.set(e,t),this.lastSeen.set(e,Date.now())}hasData(e){return this.groupData.has(e)}getData(e){return this.groupData.get(e)||[]}getMaxIdle(){if("number"!=typeof this.#n||!Number.isFinite(this.#n)||this.#n<0)throw new Error("'maxIdle' must be a non-negative finite number.");return this.#n}setMaxIdle(e){if("number"!=typeof e||!Number.isFinite(e)||e<0)throw new Error("'maxIdle' must be a non-negative finite number.");this.#n=e}_cleanup(){const e=Date.now();for(const[t,r]of this.lastSeen.entries())e-r>(this.getGroupTTL(t)??this.getMaxIdle())&&(this.groupFlags.delete(t),this.groupData.delete(t),this.lastSeen.delete(t),this.groupTTL.delete(t),"function"==typeof this.#a&&this.#a(t))}getActiveGroups(){return Array.from(this.groupData.keys())}getAllUserMappings(){return Object.fromEntries(this.userToGroup)}getInterval(){if("number"!=typeof this.#i||!Number.isFinite(this.#i))throw new Error("'interval' is not a valid finite number.");return this.#i}getMaxHits(){if("number"!=typeof this.#r||!Number.isFinite(this.#r))throw new Error("'maxHits' is not a valid finite number.");return this.#r}getTotalHits(e){const t=this.groupData.get(e);return Array.isArray(t)?t.length:0}getLastHit(e){const t=this.groupData.get(e);return t?.length?t[t.length-1]:null}getTimeSinceLastHit(e){const t=this.getLastHit(e);return null!==t?Date.now()-t:null}_calculateAverageSpacing(e){if(!Array.isArray(e)||e.length<2)return null;let t=0;for(let r=1;r<e.length;r++)t+=e[r]-e[r-1];return t/(e.length-1)}getAverageHitSpacing(e){return this._calculateAverageSpacing(this.groupData.get(e))}getMetrics(e){const t=this.groupData.get(e);if(!Array.isArray(t)||0===t.length)return{totalHits:0,lastHit:null,timeSinceLastHit:null,averageHitSpacing:null};const r=t.length,i=t[r-1];return{totalHits:r,lastHit:i,timeSinceLastHit:Date.now()-i,averageHitSpacing:this._calculateAverageSpacing(t)}}destroy(){this.#t&&clearInterval(this.#t),this._cleanup(),this.groupData.clear(),this.lastSeen.clear(),this.userToGroup.clear(),this.groupTTL.clear(),this.groupFlags.clear()}};window.TinyRateLimiter=t.TinyRateLimiter})();

package/dist/legacy/firebase/mySQL.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
 require('clone');
-require('buffer');
+require('../../v1/basics/objFilter.cjs');
 
 // @ts-nocheck