fix(javascript): improve caching performance (generated)

algolia/api-clients-automation#6431

Co-authored-by: algolia-bot <accounts+algolia-api-client-bot@algolia.com>
Co-authored-by: Eric Zaharia <94015633+eric-zaharia@users.noreply.github.com>

Author: algolia-bot

package.json

@@ -27,7 +27,7 @@
     "files": [
       {
         "path": "packages/algoliasearch/dist/algoliasearch.umd.js",
-        "maxSize": "14.8KB"
+        "maxSize": "14.9KB"
       },
       {
         "path": "packages/algoliasearch/dist/lite/builds/browser.umd.js",

packages/client-common/src/__tests__/cache/browser-local-storage-cache.test.ts

@@ -103,7 +103,7 @@ describe('browser local storage cache', () => {
 
     expect(missMock.mock.calls.length).toBe(1);
 
-    expect(localStorage.getItem(`algolia-client-js-${version}`)).toEqual('{}');
+    expect(localStorage.getItem(`algolia-client-js-${version}`)).toBeNull();
   });
 
   test('do throws localstorage exceptions on access', async () => {

packages/client-common/src/cache/createBrowserLocalStorageCache.ts

@@ -21,32 +21,40 @@ export function createBrowserLocalStorageCache(options: BrowserLocalStorageOptio
     getStorage().setItem(namespaceKey, JSON.stringify(namespace));
   }
 
-  function removeOutdatedCacheItems(): void {
+  function yieldToMain(): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, 0));
+  }
+
+  function getFilteredNamespace(): {
+    namespace: Record<string, BrowserLocalStorageCacheItem>;
+    changed: boolean;
+  } {
     const timeToLive = options.timeToLive ? options.timeToLive * 1000 : null;
     const namespace = getNamespace<BrowserLocalStorageCacheItem>();
+    const currentTime = new Date().getTime();
+    let changed = false;
 
-    const filteredNamespaceWithoutOldFormattedCacheItems = Object.fromEntries(
+    const filtered = Object.fromEntries(
       Object.entries(namespace).filter(([, cacheItem]) => {
-        return cacheItem.timestamp !== undefined;
-      }),
-    );
-
-    setNamespace(filteredNamespaceWithoutOldFormattedCacheItems);
+        if (!cacheItem || cacheItem.timestamp === undefined) {
+          changed = true;
+          return false;
+        }
 
-    if (!timeToLive) {
-      return;
-    }
+        if (!timeToLive) {
+          return true;
+        }
 
-    const filteredNamespaceWithoutExpiredItems = Object.fromEntries(
-      Object.entries(filteredNamespaceWithoutOldFormattedCacheItems).filter(([, cacheItem]) => {
-        const currentTimestamp = new Date().getTime();
-        const isExpired = cacheItem.timestamp + timeToLive < currentTimestamp;
+        if (cacheItem.timestamp + timeToLive < currentTime) {
+          changed = true;
+          return false;
+        }
 
-        return !isExpired;
+        return true;
       }),
     );
 
-    setNamespace(filteredNamespaceWithoutExpiredItems);
+    return { namespace: filtered, changed };
   }
 
   return {
@@ -57,23 +65,24 @@ export function createBrowserLocalStorageCache(options: BrowserLocalStorageOptio
         miss: () => Promise.resolve(),
       },
     ): Promise<TValue> {
-      return Promise.resolve()
-        .then(() => {
-          removeOutdatedCacheItems();
-
-          return getNamespace<Promise<BrowserLocalStorageCacheItem>>()[JSON.stringify(key)];
-        })
-        .then((value) => {
-          return Promise.all([value ? value.value : defaultValue(), value !== undefined]);
-        })
-        .then(([value, exists]) => {
-          return Promise.all([value, exists || events.miss(value)]);
-        })
-        .then(([value]) => value);
+      return yieldToMain().then(() => {
+        const { namespace, changed } = getFilteredNamespace();
+        const cachedItem = namespace[JSON.stringify(key)];
+
+        if (changed) {
+          setNamespace(namespace);
+        }
+
+        if (cachedItem) {
+          return cachedItem.value as TValue;
+        }
+
+        return defaultValue().then((value) => events.miss(value).then(() => value));
+      });
     },
 
     set<TValue>(key: Record<string, any> | string, value: TValue): Promise<TValue> {
-      return Promise.resolve().then(() => {
+      return yieldToMain().then(() => {
         const namespace = getNamespace();
 
         namespace[JSON.stringify(key)] = {
@@ -88,7 +97,7 @@ export function createBrowserLocalStorageCache(options: BrowserLocalStorageOptio
     },
 
     delete(key: Record<string, any> | string): Promise<void> {
-      return Promise.resolve().then(() => {
+      return yieldToMain().then(() => {
         const namespace = getNamespace();
 
         delete namespace[JSON.stringify(key)];