Account for optional cache and remove timing code

f4ef9697e983a0bb0b3b0ab6388f5ecbfe37898e

Joe <joenunezb@gmail.com>

public/script.js+0 -1 Viewed

@@ -1750,7 +1750,6 @@ export async function getCharacters() {
1750	1750	}
1751	1751
1752	1752	await getGroups();
1753		- // clearFuzzySearchCaches();
1754	1753	await printCharacters(true);
1755	1754	}
1756	1755	}

public/scripts/power-user.js+22 -26 Viewed

 /**
  * Common function to perform fuzzy search with optional 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
  * @param {Object.<string, { resultMap: Map<string, any> }>} [fuzzySearchCaches=null] - FuzzyOptional fuzzy search caches
  * @returns {import('fuse.js').FuseResult<any>[]} Results as items with their score
  */
 function performFuzzySearch(type, data, keys, searchValue, fuzzySearchCaches = null) {
 -    let startTime = performance.now();
 +    // Check cache if provided
 -    const cache = fuzzySearchCaches[type];
 +    if (fuzzySearchCaches) {
+-
 +        const cache = fuzzySearchCaches[type];
 -    // Check cache for existing results
 +        if (cache?.resultMap.has(searchValue)) {
     if            return (cache.resultMap.hasget(searchValue)) {;
 -        let endTime = performance.now();
 -        if (endTime - startTime > 1.0) {
 -            console.log(`Fuzzy search for ${type} took ${endTime - startTime}ms (cached)`);
+        }
 -        return cache.resultMap.get(searchValue);
+    }
     // @ts-ignore

     });
     const results = fuse.search(searchValue);
 -    cache.resultMap.set(searchValue, results);
++
 -    let endTime = performance.now();
 +    // Store in cache if provided
     if (endTime - startTime > 1.0fuzzySearchCaches) {
 -        console.log(`Fuzzy search for ${type} took ${endTime - startTime}ms`);
 +        fuzzySearchCaches[type].resultMap.set(searchValue, results);
+    }
     return results;
+}

 /**
  * Fuzzy search characters by a search term
  * @param {string} searchValue - The search term
  * @param {Object.<string, { resultMap: Map<string, any> }>} [fuzzySearchCaches=null] - FuzzyOptional fuzzy search caches
  * @returns {import('fuse.js').FuseResult<any>[]} Results as items with their score
  */
 export function fuzzySearchCharacters(searchValue, fuzzySearchCaches = null) {
     const keys = [
         { name: 'data.name', weight: 20 },
         { name: '#tags', weight: 10, getFn: (character) => getTagsList(character.avatar).map(x => x.name).join('||') },

  * Fuzzy search world info entries by a search term
  * @param {*[]} data - WI items data array
  * @param {string} searchValue - The search term
  * @param {Object.<string, { resultMap: Map<string, any> }>} [fuzzySearchCaches=null] - FuzzyOptional fuzzy search caches
  * @returns {import('fuse.js').FuseResult<any>[]} Results as items with their score
  */
 export function fuzzySearchWorldInfo(data, searchValue, fuzzySearchCaches = null) {
     const keys = [
         { name: 'key', weight: 20 },
         { name: 'group', weight: 15 },

  * Fuzzy search persona entries by a search term
  * @param {*[]} data - persona data array
  * @param {string} searchValue - The search term
  * @param {Object.<string, { resultMap: Map<string, any> }>} [fuzzySearchCaches=null] - FuzzyOptional fuzzy search caches
  * @returns {import('fuse.js').FuseResult<any>[]} Results as items with their score
  */
 export function fuzzySearchPersonas(data, searchValue, fuzzySearchCaches = null) {
     const mappedData = data.map(x => ({
         key: x,
         name: power_user.personas[x] ?? '',

 /**
  * Fuzzy search tags by a search term
  * @param {string} searchValue - The search term
  * @param {Object.<string, { resultMap: Map<string, any> }>} [fuzzySearchCaches=null] - FuzzyOptional fuzzy search caches
  * @returns {import('fuse.js').FuseResult<any>[]} Results as items with their score
  */
 export function fuzzySearchTags(searchValue, fuzzySearchCaches = null) {
     const keys = [
         { name: 'name', weight: 1 },
     ];

 /**
  * Fuzzy search groups by a search term
  * @param {string} searchValue - The search term
  * @param {Object.<string, { resultMap: Map<string, any> }>} [fuzzySearchCaches=null] - FuzzyOptional fuzzy search caches
  * @returns {import('fuse.js').FuseResult<any>[]} Results as items with their score
  */
 export function fuzzySearchGroups(searchValue, fuzzySearchCaches = null) {
     const keys = [
         { name: 'name', weight: 20 },
         { name: 'members', weight: 15 },