@lionrapid/core 0.6.6 → 0.7.0

package/dist/browser/lionrapid.umd.js

@@ -1246,6 +1246,24 @@ var HandlerChain = class {
     });
     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);
@@ -1347,6 +1365,10 @@ var HandlerChain = class {
           });
           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}`,
@@ -1730,6 +1752,7 @@ var SyncHandler = class {
       context.locale + ":" + context.namespace,
       this.name
     );
+    const previousKeys = this.storedNamespaceKeys(context.locale, context.namespace);
     const namespaceCacheKey = createNamespaceCacheKey(
       context.locale,
       context.namespace
@@ -1741,11 +1764,38 @@ var SyncHandler = class {
       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
@@ -1999,6 +2049,7 @@ var AsyncHandler = class {
     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
@@ -2010,6 +2061,9 @@ var AsyncHandler = class {
       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);
@@ -2018,6 +2072,35 @@ var AsyncHandler = class {
     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
@@ -4245,6 +4328,12 @@ var LionRapidBuilder = class _LionRapidBuilder {
           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);
@@ -5621,6 +5710,8 @@ var CacheStorageRepository = class {
     __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 = {
@@ -5634,6 +5725,8 @@ var CacheStorageRepository = class {
       }
     };
     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();
   }
@@ -5654,13 +5747,13 @@ var CacheStorageRepository = class {
     }
     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;
@@ -5684,7 +5777,7 @@ var CacheStorageRepository = class {
         timestamp: Date.now()
       };
       await cache.put(
-        CACHE_PREFIX + key,
+        this.entryPrefix + key,
         new Response(JSON.stringify(data), {
           headers: { "Content-Type": "application/json" }
         })
@@ -5699,7 +5792,7 @@ var CacheStorageRepository = class {
     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 {
     }
   }
@@ -5712,7 +5805,7 @@ var CacheStorageRepository = class {
       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 {
     }
@@ -5730,7 +5823,7 @@ var CacheStorageRepository = class {
       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))
       );
@@ -5782,9 +5875,9 @@ var CacheStorageRepository = class {
       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);
@@ -5806,7 +5899,7 @@ var CacheStorageRepository = class {
     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 };
@@ -5818,7 +5911,7 @@ var CacheStorageRepository = class {
 var DEFAULT_API_BASE_URL = "https://app.lionrapid.com";
 
 // src/index.ts
-var VERSION = "0.6.6";
+var VERSION = "0.7.0";
 //# sourceMappingURL=lionrapid.umd.js.map
 
   return exports;