Rename LimitedMap => MemoryLimitedMap

095d19cda73742ee23daedb3af8c7b55615b4789

Cohee <18619528+Cohee1207@users.noreply.github.com>

src/endpoints/characters.js+2 -2 Viewed

 import { AVATAR_WIDTH, AVATAR_HEIGHT } from '../constants.js';
 import { jsonParser, urlencodedParser } from '../express-common.js';
-import { deepMerge, humanizedISO8601DateTime, tryParse, extractFileFromZipBuffer, LimitedMap } from '../util.js';
+import { deepMerge, humanizedISO8601DateTime, tryParse, extractFileFromZipBuffer, MemoryLimitedMap } from '../util.js';
 import { TavernCardValidator } from '../validator/TavernCardValidator.js';
 import { parse, write } from '../character-card-parser.js';
 import { readWorldInfoFile } from './worldinfo.js';

 // KV-store for parsed character data
 // 100 MB limit. Would take roughly 3000 characters to reach this limit
-const characterDataCache = new LimitedMap(1024 * 1024 * 100);
+const characterDataCache = new MemoryLimitedMap(1024 * 1024 * 100);
 // Some Android devices require tighter memory management
 const isAndroid = process.platform === 'android';

src/util.js+8 -8 Viewed

+}
 /**
- * LimitedMap class that limits the memory usage of string values.
+ * MemoryLimitedMap class that limits the memory usage of string values.
  */
-export class LimitedMap {
+export class MemoryLimitedMap {
     /**
-     * Creates an instance of LimitedMap.
+     * Creates an instance of MemoryLimitedMap.
      * @param {number} maxMemoryInBytes - The maximum allowed memory in bytes for string values.
      */
     constructor(maxMemoryInBytes) {

             return;
+        }
-        const newValueSize = LimitedMap.estimateStringSize(value);
+        const newValueSize = MemoryLimitedMap.estimateStringSize(value);
         // If the new value itself exceeds the max memory, reject it
         if (newValueSize > this.maxMemory) {

         // Check if the key already exists to adjust memory accordingly
         if (this.map.has(key)) {
             const oldValue = this.map.get(key);
-            const oldValueSize = LimitedMap.estimateStringSize(oldValue);
+            const oldValueSize = MemoryLimitedMap.estimateStringSize(oldValue);
             this.currentMemory -= oldValueSize;
             // Remove the key from its current position in the queue
             const index = this.queue.indexOf(key);

         while (this.currentMemory + newValueSize > this.maxMemory && this.queue.length > 0) {
             const oldestKey = this.queue.shift();
             const oldestValue = this.map.get(oldestKey);
-            const oldestValueSize = LimitedMap.estimateStringSize(oldestValue);
+            const oldestValueSize = MemoryLimitedMap.estimateStringSize(oldestValue);
             this.map.delete(oldestKey);
             this.currentMemory -= oldestValueSize;
+        }

             return false;
+        }
         const value = this.map.get(key);
-        const valueSize = LimitedMap.estimateStringSize(value);
+        const valueSize = MemoryLimitedMap.estimateStringSize(value);
         this.map.delete(key);
         this.currentMemory -= valueSize;

+    }
     /**
-     * Makes the LimitedMap iterable.
+     * Makes the MemoryLimitedMap iterable.
      * @returns {Iterator} - Iterator over [key, value] pairs.
      */
     [Symbol.iterator]() {