2661881b · permissionBRICK/SillyTavern

 const setHotswapsDebounced = debounce(favsToHotswap);
-const fuzzySearchCharactersCache = new Map();
-const fuzzySearchWorldInfoCache = new Map();
-const fuzzySearchPersonasCache = new Map();
-const fuzzySearchTagsCache = new Map();
-const fuzzySearchGroupsCache = new Map();
 function playMessageSound() {
     if (!power_user.play_message_sound) {
         return;

     });
+}
+// Create separate caches for each type of fuzzy search
+const fuzzySearchCaches = {
+    characters: { keyHash: null, resultMap: new Map() },
+    worldInfo: { keyHash: null, resultMap: new Map() },
+    personas: { keyHash: null, resultMap: new Map() },
+    tags: { keyHash: null, resultMap: new Map() },
+    groups: { keyHash: null, resultMap: new Map() },
+};
 /**
- * Fuzzy search characters by a search term
+ * Generates a hash of the Fuse configuration keys
- * @param {string} searchValue - The search term
+ * @param {Array<{name: string, weight: number, getFn?: Function}>} keys
- * @returns {import('fuse.js').FuseResult<any>[]} Results as items with their score
+ * @returns {number} Hash of the keys configuration
  */
-export function fuzzySearchCharacters(searchValue) {
+function hashFuseKeys(keys) {
+    // Convert keys to a stable string representation
+    const keyString = keys.map(k => {
+        const getFnString = k.getFn ? k.getFn.toString() : '';
+        return `${k.name}:${k.weight}:${getFnString}`;
+    }).join('|');
-    if (fuzzySearchCharactersCache.has(searchValue)) {
+    return getStringHash(keyString);
-        return fuzzySearchCharactersCache.get(searchValue);
+}
-    // @ts-ignore
+/**
-    const fuse = new Fuse(characters, {
+ * Fuzzy search characters by a search term with caching
-        keys: [
+ * @param {string} searchValue - The search term
+ * @returns {import('fuse.js').FuseResult<any>[]} Results as items with their score
+ */
+export function fuzzySearchCharacters(searchValue) {
+    const fuseKeys = [
         { name: 'data.name', weight: 20 },
         { name: '#tags', weight: 10, getFn: (character) => getTagsList(character.avatar).map(x => x.name).join('||') },
         { name: 'data.description', weight: 3 },

         { name: 'data.creator', weight: 1 },
         { name: 'data.tags', weight: 1 },
         { name: 'data.alternate_greetings', weight: 1 },
-        ],
+    ];
+    // Generate hash of current keys configuration
+    const currentKeyHash = hashFuseKeys(fuseKeys);
+    const cache = fuzzySearchCaches.characters;
+    // Check if we have a cached result for this search value
+    if (cache.keyHash === currentKeyHash && cache.resultMap.has(searchValue)) {
+        console.debug('Using cached fuzzy search results for ' + searchValue);
+        return cache.resultMap.get(searchValue);
+    }
+    // If key configuration changed, clear the cache
+    if (cache.keyHash !== currentKeyHash) {
+        console.debug('Fuse keys changed, clearing cache');
+        cache.keyHash = currentKeyHash;
+        cache.resultMap.clear();
+    }
+    // Create new Fuse instance and perform search
+    const fuse = new Fuse(characters, {
+        keys: fuseKeys,
         includeScore: true,
         ignoreLocation: true,
         useExtendedSearch: true,

     });
     const results = fuse.search(searchValue);
+    // Cache the results
+    cache.resultMap.set(searchValue, results);
     console.debug('Characters fuzzy search results for ' + searchValue, results);
-    fuzzySearchCharactersCache.set(searchValue, results);
     return results;
+}

  * @returns {import('fuse.js').FuseResult<any>[]} Results as items with their score
  */
 export function fuzzySearchWorldInfo(data, searchValue) {
-    if (fuzzySearchWorldInfoCache.has(searchValue)) {
+    const fuseKeys = [
-        return fuzzySearchWorldInfoCache.get(searchValue);
-    }
-    // @ts-ignore
-    const fuse = new Fuse(data, {
-        keys: [
         { name: 'key', weight: 20 },
         { name: 'group', weight: 15 },
         { name: 'comment', weight: 10 },

         { name: 'content', weight: 3 },
         { name: 'uid', weight: 1 },
         { name: 'automationId', weight: 1 },
-        ],
+    ];
+    const currentKeyHash = hashFuseKeys(fuseKeys);
+    const cache = fuzzySearchCaches.worldInfo;
+    // Check cache for existing results
+    if (cache.keyHash === currentKeyHash && cache.resultMap.has(searchValue)) {
+        console.debug('Using cached WI fuzzy search results for ' + searchValue);
+        return cache.resultMap.get(searchValue);
+    }
+    // Clear cache if keys changed
+    if (cache.keyHash !== currentKeyHash) {
+        console.debug('WI Fuse keys changed, clearing cache');
+        cache.keyHash = currentKeyHash;
+        cache.resultMap.clear();
+    }
+    const fuse = new Fuse(data, {
+        keys: fuseKeys,
         includeScore: true,
         ignoreLocation: true,
         useExtendedSearch: true,

     });
     const results = fuse.search(searchValue);
+    cache.resultMap.set(searchValue, results);
     console.debug('World Info fuzzy search results for ' + searchValue, results);
-    fuzzySearchWorldInfoCache.set(searchValue, results);
     return results;
+}

  * @returns {import('fuse.js').FuseResult<any>[]} Results as items with their score
  */
 export function fuzzySearchPersonas(data, searchValue) {
-    if (fuzzySearchPersonasCache.has(searchValue)) {
-        return fuzzySearchPersonasCache.get(searchValue);
-    }
     data = data.map(x => ({ key: x, name: power_user.personas[x] ?? '', description: power_user.persona_descriptions[x]?.description ?? '' }));
-    // @ts-ignore
-    const fuse = new Fuse(data, {
+    const fuseKeys = [
-        keys: [
         { name: 'name', weight: 20 },
         { name: 'description', weight: 3 },
-        ],
+    ];
+    const currentKeyHash = hashFuseKeys(fuseKeys);
+    const cache = fuzzySearchCaches.personas;
+    // Check cache for existing results
+    if (cache.keyHash === currentKeyHash && cache.resultMap.has(searchValue)) {
+        console.debug('Using cached personas fuzzy search results for ' + searchValue);
+        return cache.resultMap.get(searchValue);
+    }
+    // Clear cache if keys changed
+    if (cache.keyHash !== currentKeyHash) {
+        console.debug('Personas Fuse keys changed, clearing cache');
+        cache.keyHash = currentKeyHash;
+        cache.resultMap.clear();
+    }
+    const fuse = new Fuse(data, {
+        keys: fuseKeys,
         includeScore: true,
         ignoreLocation: true,
         useExtendedSearch: true,

     });
     const results = fuse.search(searchValue);
+    cache.resultMap.set(searchValue, results);
     console.debug('Personas fuzzy search results for ' + searchValue, results);
-    fuzzySearchPersonasCache.set(searchValue, results);
     return results;
+}

  * @returns {import('fuse.js').FuseResult<any>[]} Results as items with their score
  */
 export function fuzzySearchTags(searchValue) {
-    if (fuzzySearchTagsCache.has(searchValue)) {
+    const fuseKeys = [
-        return fuzzySearchTagsCache.get(searchValue);
+        { name: 'name', weight: 1 },
+    ];
+    const currentKeyHash = hashFuseKeys(fuseKeys);
+    const cache = fuzzySearchCaches.tags;
+    // Check cache for existing results
+    if (cache.keyHash === currentKeyHash && cache.resultMap.has(searchValue)) {
+        console.debug('Using cached tags fuzzy search results for ' + searchValue);
+        return cache.resultMap.get(searchValue);
+    }
+    // Clear cache if keys changed
+    if (cache.keyHash !== currentKeyHash) {
+        console.debug('Tags Fuse keys changed, clearing cache');
+        cache.keyHash = currentKeyHash;
+        cache.resultMap.clear();
+    }
-    // @ts-ignore
     const fuse = new Fuse(tags, {
-        keys: [
+        keys: fuseKeys,
-            { name: 'name', weight: 1 },
-        ],
         includeScore: true,
         ignoreLocation: true,
         useExtendedSearch: true,

     });
     const results = fuse.search(searchValue);
+    cache.resultMap.set(searchValue, results);
     console.debug('Tags fuzzy search results for ' + searchValue, results);
-    fuzzySearchTagsCache.set(searchValue, results);
     return results;
+}

  * @returns {import('fuse.js').FuseResult<any>[]} Results as items with their score
  */
 export function fuzzySearchGroups(searchValue) {
-    if (fuzzySearchGroupsCache.has(searchValue)) {
+    const fuseKeys = [
-        return fuzzySearchGroupsCache.get(searchValue);
-    }
-    // @ts-ignore
-    const fuse = new Fuse(groups, {
-        keys: [
         { name: 'name', weight: 20 },
         { name: 'members', weight: 15 },
         { name: '#tags', weight: 10, getFn: (group) => getTagsList(group.id).map(x => x.name).join('||') },
         { name: 'id', weight: 1 },
-        ],
+    ];
+    const currentKeyHash = hashFuseKeys(fuseKeys);
+    const cache = fuzzySearchCaches.groups;
+    // Check cache for existing results
+    if (cache.keyHash === currentKeyHash && cache.resultMap.has(searchValue)) {
+        console.debug('Using cached groups fuzzy search results for ' + searchValue);
+        return cache.resultMap.get(searchValue);
+    }
+    // Clear cache if keys changed
+    if (cache.keyHash !== currentKeyHash) {
+        console.debug('Groups Fuse keys changed, clearing cache');
+        cache.keyHash = currentKeyHash;
+        cache.resultMap.clear();
+    }
+    const fuse = new Fuse(groups, {
+        keys: fuseKeys,
         includeScore: true,
         ignoreLocation: true,
         useExtendedSearch: true,

     });
     const results = fuse.search(searchValue);
+    cache.resultMap.set(searchValue, results);
     console.debug('Groups fuzzy search results for ' + searchValue, results);
-    fuzzySearchGroupsCache.set(searchValue, results);
     return results;
+}
 /**
+ * Clears all fuzzy search caches
+ */
+export function clearFuzzySearchCaches() {
+    for (const cache of Object.values(fuzzySearchCaches)) {
+        cache.keyHash = null;
+        cache.resultMap.clear();
+    }
+}
+/**
  * Renders a story string template with the given parameters.
  * @param {object} params Template parameters.
  * @returns {string} The rendered story string.

Handle stale cache