e2c083ba · permissionBRICK/SillyTavern

 let browser_has_focus = true;
 const debug_functions = [];
+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() },
+};
+const fuzzySearchCategories = {
+    characters: 'characters',
+    worldInfo: 'worldInfo',
+    personas: 'personas',
+    tags: 'tags',
+    groups: 'groups',
+};
 const setHotswapsDebounced = debounce(favsToHotswap);
 function playMessageSound() {

     });
+}
-// 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() },
-};
 /**
  * Generates a hash of the Fuse configuration keys
  * @param {Array<{name: string, weight: number, getFn?: Function}>} keys

+}
 /**
- * Fuzzy search characters by a search term with caching
+ * Common function to perform fuzzy search with caching
+ * @param {string} type - Type of search from fuzzySearchCategories
+ * @param {any[]} data - Data array to search in
+ * @param {Array<{name: string, weight: number, getFn?: Function}>} keys - Fuse.js keys configuration
  * @param {string} searchValue - The search term
  * @returns {import('fuse.js').FuseResult<any>[]} Results as items with their score
  */
-export function fuzzySearchCharacters(searchValue) {
+function performFuzzySearch(type, data, keys, searchValue) {
-    const fuseKeys = [
+    const currentKeyHash = hashFuseKeys(keys);
-        { name: 'data.name', weight: 20 },
+    const cache = fuzzySearchCaches[type];
-        { name: '#tags', weight: 10, getFn: (character) => getTagsList(character.avatar).map(x => x.name).join('||') },
-        { name: 'data.description', weight: 3 },
-        { name: 'data.mes_example', weight: 3 },
-        { name: 'data.scenario', weight: 2 },
-        { name: 'data.personality', weight: 2 },
-        { name: 'data.first_mes', weight: 2 },
-        { name: 'data.creator_notes', weight: 2 },
-        { 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
+    // Check cache for existing results
     if (cache.keyHash === currentKeyHash && cache.resultMap.has(searchValue)) {
-        console.debug('Using cached fuzzy search results for ' + searchValue);
+        console.log(`Using cached ${type} fuzzy search results for ${searchValue}`);
         return cache.resultMap.get(searchValue);
+    }
-    // If key configuration changed, clear the cache
+    // Clear cache if keys changed
     if (cache.keyHash !== currentKeyHash) {
-        console.debug('Fuse keys changed, clearing cache');
+        console.log(`${type} Fuse keys changed, clearing cache`);
         cache.keyHash = currentKeyHash;
         cache.resultMap.clear();
+    }
-    // Create new Fuse instance and perform search
+    const fuse = new Fuse(data, {
-    const fuse = new Fuse(characters, {
+        keys: keys,
-        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);
+    console.log(`${type} fuzzy search results for ${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();
+    }
+}
+/**
+ * Fuzzy search characters by a search term
+ * @param {string} searchValue - The search term
+ * @returns {import('fuse.js').FuseResult<any>[]} Results as items with their score
+ */
+export function fuzzySearchCharacters(searchValue) {
+    const keys = [
+        { 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.mes_example', weight: 3 },
+        { name: 'data.scenario', weight: 2 },
+        { name: 'data.personality', weight: 2 },
+        { name: 'data.first_mes', weight: 2 },
+        { name: 'data.creator_notes', weight: 2 },
+        { name: 'data.creator', weight: 1 },
+        { name: 'data.tags', weight: 1 },
+        { name: 'data.alternate_greetings', weight: 1 },
+    ];
+    return performFuzzySearch(fuzzySearchCategories.characters, characters, keys, searchValue);
+}
+/**
  * Fuzzy search world info entries by a search term
  * @param {*[]} data - WI items data array
  * @param {string} searchValue - The search term
  * @returns {import('fuse.js').FuseResult<any>[]} Results as items with their score
  */
 export function fuzzySearchWorldInfo(data, searchValue) {
-    const fuseKeys = [
+    const keys = [
         { name: 'key', weight: 20 },
         { name: 'group', weight: 15 },
         { name: 'comment', weight: 10 },

         { name: 'automationId', weight: 1 },
     ];
-    const currentKeyHash = hashFuseKeys(fuseKeys);
+    return performFuzzySearch(fuzzySearchCategories.worldInfo, data, keys, searchValue);
-    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,
-        threshold: 0.2,
-    });
-    const results = fuse.search(searchValue);
-    cache.resultMap.set(searchValue, results);
-    console.debug('World Info fuzzy search results for ' + searchValue, results);
-    return results;
+}
 /**

  * @returns {import('fuse.js').FuseResult<any>[]} Results as items with their score
  */
 export function fuzzySearchPersonas(data, searchValue) {
-    data = data.map(x => ({ key: x, name: power_user.personas[x] ?? '', description: power_user.persona_descriptions[x]?.description ?? '' }));
+    const mappedData = data.map(x => ({
+        key: x,
+        name: power_user.personas[x] ?? '',
+        description: power_user.persona_descriptions[x]?.description ?? ''
+    }));
-    const fuseKeys = [
+    const keys = [
         { name: 'name', weight: 20 },
         { name: 'description', weight: 3 },
     ];
-    const currentKeyHash = hashFuseKeys(fuseKeys);
+    return performFuzzySearch(fuzzySearchCategories.personas, mappedData, keys, searchValue);
-    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,
-        threshold: 0.2,
-    });
-    const results = fuse.search(searchValue);
-    cache.resultMap.set(searchValue, results);
-    console.debug('Personas fuzzy search results for ' + searchValue, results);
-    return results;
+}
 /**

  * @returns {import('fuse.js').FuseResult<any>[]} Results as items with their score
  */
 export function fuzzySearchTags(searchValue) {
-    const fuseKeys = [
+    const keys = [
         { name: 'name', weight: 1 },
     ];
-    const currentKeyHash = hashFuseKeys(fuseKeys);
+    return performFuzzySearch(fuzzySearchCategories.tags, tags, keys, searchValue);
-    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();
-    }
-    const fuse = new Fuse(tags, {
-        keys: fuseKeys,
-        includeScore: true,
-        ignoreLocation: true,
-        useExtendedSearch: true,
-        threshold: 0.2,
-    });
-    const results = fuse.search(searchValue);
-    cache.resultMap.set(searchValue, results);
-    console.debug('Tags fuzzy search results for ' + searchValue, results);
-    return results;
+}
 /**

  * @returns {import('fuse.js').FuseResult<any>[]} Results as items with their score
  */
 export function fuzzySearchGroups(searchValue) {
-    const fuseKeys = [
+    const 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);
+    return performFuzzySearch(fuzzySearchCategories.groups, groups, keys, searchValue);
-    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,
-        threshold: 0.2,
-    });
-    const results = fuse.search(searchValue);
-    cache.resultMap.set(searchValue, results);
-    console.debug('Groups fuzzy search results for ' + 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();
-    }
+}
 /**

Remove duplicated code