@lionrapid/core 0.6.6 → 0.7.0

package/dist/browser/lionrapid.iife.js

@@ -1234,6 +1234,24 @@ var LionRapid = (() => {
       });
       await Promise.allSettled(savePromises);
     }
+    /** Forget `locale:namespace` in every memory and storage handler (a 404). */
+    async forgetNamespaceInHandlers(context) {
+      for (const handler of this.syncHandlers) {
+        try {
+          handler.forgetNamespace?.(context);
+        } catch (error) {
+          logger.warn(`Failed to clear namespace in ${handler.name}`, error);
+        }
+      }
+      for (const handler of this.asyncHandlers) {
+        if (handler.type !== "storage" && handler.type !== "memory") continue;
+        try {
+          await handler.forgetNamespace?.(context);
+        } catch (error) {
+          logger.warn(`Failed to clear namespace in ${handler.name}`, error);
+        }
+      }
+    }
     async saveNamespaceToHandlers(translations, context) {
       this.saveNamespaceToMemoryHandlers(translations, context);
       await this.saveNamespaceToStorageHandlers(translations, context);
@@ -1335,6 +1353,10 @@ var LionRapid = (() => {
             });
             return result.data;
           }
+          if (result && result.status === 404) {
+            await this.forgetNamespaceInHandlers({ namespace, locale });
+            return null;
+          }
         } catch (error) {
           logger.warn(
             `Failed to load namespace: ${locale}:${namespace} from ${handler.name}`,
@@ -1718,6 +1740,7 @@ var LionRapid = (() => {
         context.locale + ":" + context.namespace,
         this.name
       );
+      const previousKeys = this.storedNamespaceKeys(context.locale, context.namespace);
       const namespaceCacheKey = createNamespaceCacheKey(
         context.locale,
         context.namespace
@@ -1729,11 +1752,38 @@ var LionRapid = (() => {
         context.locale,
         context.namespace
       );
+      for (const key of previousKeys) {
+        if (!(key in flattened)) this.removeQuietly(key);
+      }
       for (const [flatKey, flatValue] of Object.entries(flattened)) {
         this.setWithTTL(flatKey, flatValue);
       }
       repoBus.setSuccess(JSON.stringify(translations));
     }
+    /** Forget a namespace the server says does not exist (404). See AsyncStorageHandler. */
+    forgetNamespace(context) {
+      if (!context.namespace) return;
+      for (const key of this.storedNamespaceKeys(context.locale, context.namespace)) {
+        this.removeQuietly(key);
+      }
+      this.clearNamespace(context.locale, context.namespace);
+    }
+    storedNamespaceKeys(locale, namespace) {
+      try {
+        const blob = this.repository.get(createNamespaceCacheKey(locale, namespace));
+        if (!blob) return [];
+        return Object.keys(flattenTranslations(JSON.parse(blob), "", locale, namespace));
+      } catch {
+        return [];
+      }
+    }
+    removeQuietly(cacheKey) {
+      this.ttlMap.delete(cacheKey);
+      try {
+        this.repository.remove(cacheKey);
+      } catch {
+      }
+    }
     /**
      * ✅ Strategy 1: Direct cache lookup using unified pattern
      * Returns parsed ContentUnit (text + styles) or null
@@ -1987,6 +2037,7 @@ var LionRapid = (() => {
       logger.debug(
         `Saving namespace: ${context.locale}:${context.namespace} (${keyCount} keys)`
       );
+      const previousKeys = await this.storedNamespaceKeys(context.locale, context.namespace);
       const namespaceCacheKey = createNamespaceCacheKey(
         context.locale,
         context.namespace
@@ -1998,6 +2049,9 @@ var LionRapid = (() => {
         context.locale,
         context.namespace
       );
+      for (const key of previousKeys) {
+        if (!(key in flattened)) await this.removeQuietly(key);
+      }
       let savedCount = 0;
       for (const [flatKey, flatValue] of Object.entries(flattened)) {
         await this.setWithTTL(flatKey, flatValue);
@@ -2006,6 +2060,35 @@ var LionRapid = (() => {
       logger.debug(`Saved: ${savedCount} keys + namespace blob`);
       repoBus.setSuccess(JSON.stringify(translations));
     }
+    /**
+     * Forget a namespace the server says does not exist (404): its blob and
+     * every per-key entry the blob listed. A network failure never gets here,
+     * so the offline floor still serves when the server is unreachable.
+     */
+    async forgetNamespace(context) {
+      if (!context.namespace) return;
+      for (const key of await this.storedNamespaceKeys(context.locale, context.namespace)) {
+        await this.removeQuietly(key);
+      }
+      await this.removeQuietly(createNamespaceCacheKey(context.locale, context.namespace));
+    }
+    /** The per-key cache keys (`locale:namespace:key`) the stored blob lists. */
+    async storedNamespaceKeys(locale, namespace) {
+      try {
+        const blob = await this.repository.get(createNamespaceCacheKey(locale, namespace));
+        if (!blob) return [];
+        return Object.keys(flattenTranslations(JSON.parse(blob), "", locale, namespace));
+      } catch {
+        return [];
+      }
+    }
+    async removeQuietly(cacheKey) {
+      this.ttlMap.delete(cacheKey);
+      try {
+        await this.repository.remove(cacheKey);
+      } catch {
+      }
+    }
     /**
      * ✅ Strategy 1: Direct cache lookup using unified pattern
      * Returns parsed ContentUnit (text + styles) or null
@@ -4233,6 +4316,12 @@ var LionRapid = (() => {
             logger.debug(`Preloaded: ${namespaceKey}`);
             return;
           }
+          if (result?.status === 404) {
+            await handlerChain.forgetNamespaceInHandlers({
+              locale: preloadConfig.locale,
+              namespace: preloadConfig.namespace
+            });
+          }
           if (result?.error) {
             warnLoudlyOnce(namespaceKey, result.error);
             logger.warn(`Preload failed: ${namespaceKey}`, result.error);
@@ -5609,6 +5698,8 @@ var LionRapid = (() => {
       __publicField(this, "type", "storage");
       __publicField(this, "config");
       __publicField(this, "cacheName");
+      /** CACHE_PREFIX, plus `<scope>/` when scoped. */
+      __publicField(this, "entryPrefix");
       __publicField(this, "defaultTTL");
       __publicField(this, "available");
       this.config = {
@@ -5622,6 +5713,8 @@ var LionRapid = (() => {
         }
       };
       this.cacheName = this.config.options?.cacheName ?? CACHE_NAME;
+      const scope = this.config.options?.scope;
+      this.entryPrefix = scope ? `${CACHE_PREFIX}${encodeURIComponent(scope)}/` : CACHE_PREFIX;
       this.defaultTTL = this.config.options?.ttl ?? 7 * 24 * 60 * 60 * 1e3;
       this.available = this.checkAvailability();
     }
@@ -5642,13 +5735,13 @@ var LionRapid = (() => {
       }
       try {
         const cache = await caches.open(this.cacheName);
-        const response = await cache.match(CACHE_PREFIX + key);
+        const response = await cache.match(this.entryPrefix + key);
         if (!response) {
           throw new TranslationNotFoundError(key);
         }
         const data = await response.json();
         if (data.expiry !== null && Date.now() > data.expiry) {
-          await cache.delete(CACHE_PREFIX + key);
+          await cache.delete(this.entryPrefix + key);
           throw new TranslationNotFoundError(key);
         }
         return data.value;
@@ -5672,7 +5765,7 @@ var LionRapid = (() => {
           timestamp: Date.now()
         };
         await cache.put(
-          CACHE_PREFIX + key,
+          this.entryPrefix + key,
           new Response(JSON.stringify(data), {
             headers: { "Content-Type": "application/json" }
           })
@@ -5687,7 +5780,7 @@ var LionRapid = (() => {
       if (!this.available) return;
       try {
         const cache = await caches.open(this.cacheName);
-        await cache.delete(CACHE_PREFIX + key);
+        await cache.delete(this.entryPrefix + key);
       } catch {
       }
     }
@@ -5700,7 +5793,7 @@ var LionRapid = (() => {
         const cache = await caches.open(this.cacheName);
         const keys = await cache.keys();
         await Promise.all(
-          keys.filter((request) => request.url.includes(CACHE_PREFIX)).map((request) => cache.delete(request))
+          keys.filter((request) => request.url.includes(this.entryPrefix)).map((request) => cache.delete(request))
         );
       } catch {
       }
@@ -5718,7 +5811,7 @@ var LionRapid = (() => {
         await Promise.all(
           keys.filter((request) => {
             const url = request.url;
-            const key = url.includes(CACHE_PREFIX) ? url.substring(url.indexOf(CACHE_PREFIX) + CACHE_PREFIX.length) : "";
+            const key = url.includes(this.entryPrefix) ? url.substring(url.indexOf(this.entryPrefix) + this.entryPrefix.length) : "";
             return key === namespaceCacheKey || key.startsWith(keyPrefix);
           }).map((request) => cache.delete(request))
         );
@@ -5770,9 +5863,9 @@ var LionRapid = (() => {
         const keys = await cache.keys();
         for (const request of keys) {
           const url = request.url;
-          if (!url.includes(CACHE_PREFIX)) continue;
+          if (!url.includes(this.entryPrefix)) continue;
           const key = url.substring(
-            url.indexOf(CACHE_PREFIX) + CACHE_PREFIX.length
+            url.indexOf(this.entryPrefix) + this.entryPrefix.length
           );
           try {
             const value = await this.get(key);
@@ -5794,7 +5887,7 @@ var LionRapid = (() => {
       try {
         const cache = await caches.open(this.cacheName);
         const keys = await cache.keys();
-        const size = keys.filter((r) => r.url.includes(CACHE_PREFIX)).length;
+        const size = keys.filter((r) => r.url.includes(this.entryPrefix)).length;
         return { size, cacheName: this.cacheName };
       } catch {
         return { size: 0, cacheName: this.cacheName };
@@ -5806,7 +5899,7 @@ var LionRapid = (() => {
   var DEFAULT_API_BASE_URL = "https://app.lionrapid.com";
 
   // src/index.ts
-  var VERSION = "0.6.6";
+  var VERSION = "0.7.0";
   return __toCommonJS(index_exports);
 })();
 //# sourceMappingURL=lionrapid.iife.js.map