@lionrapid/core 0.6.6 → 0.7.0

package/dist/browser/lionrapid.auto.dev.js

@@ -1128,6 +1128,24 @@ var __lionrapidAutoExports = (() => {
       });
       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);
@@ -1229,6 +1247,10 @@ var __lionrapidAutoExports = (() => {
             });
             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}`,
@@ -1612,6 +1634,7 @@ var __lionrapidAutoExports = (() => {
         context.locale + ":" + context.namespace,
         this.name
       );
+      const previousKeys = this.storedNamespaceKeys(context.locale, context.namespace);
       const namespaceCacheKey = createNamespaceCacheKey(
         context.locale,
         context.namespace
@@ -1623,11 +1646,38 @@ var __lionrapidAutoExports = (() => {
         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
@@ -1881,6 +1931,7 @@ var __lionrapidAutoExports = (() => {
       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
@@ -1892,6 +1943,9 @@ var __lionrapidAutoExports = (() => {
         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);
@@ -1900,6 +1954,35 @@ var __lionrapidAutoExports = (() => {
       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
@@ -4095,6 +4178,12 @@ var __lionrapidAutoExports = (() => {
             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);
@@ -5631,6 +5720,32 @@ var __lionrapidAutoExports = (() => {
 .lionrapid-btn-row button:hover { background: #f5f5f5; }
 .lionrapid-btn-row button.active { background: #3b82f6; color: #fff; }
 `;
+  var HEADER_GAP_PX = 8;
+  var CORNER_INSET_PX = 20;
+  function topCornerOffset(doc = document, win = window) {
+    const viewport = win.innerHeight || doc.documentElement.clientHeight || 0;
+    const span = (el) => {
+      const style = win.getComputedStyle(el);
+      if (style.display === "none" || style.visibility === "hidden") return null;
+      const rect = el.getBoundingClientRect();
+      if (rect.height <= 0) return null;
+      const pinned = style.position === "fixed" || style.position === "sticky";
+      const shift = pinned ? 0 : win.scrollY;
+      return [rect.top + shift, rect.bottom + shift];
+    };
+    const adminBar = doc.getElementById("wpadminbar");
+    const barBottom = adminBar && span(adminBar)?.[1] || 0;
+    let bottom = barBottom;
+    doc.querySelectorAll('header, [role="banner"]').forEach((el) => {
+      if (el.closest("article, main, aside")) return;
+      const s = span(el);
+      if (!s || s[0] > barBottom + HEADER_GAP_PX * 4) return;
+      bottom = Math.max(bottom, s[1]);
+    });
+    if (bottom === 0) return CORNER_INSET_PX;
+    const below = Math.ceil(bottom) + HEADER_GAP_PX;
+    return viewport > 0 ? Math.min(below, Math.floor(viewport / 2)) : below;
+  }
   var LanguageSwitcher = class {
     constructor() {
       __publicField(this, "core", null);
@@ -5691,6 +5806,14 @@ var __lionrapidAutoExports = (() => {
       const showNames = element.dataset.lionrapidSwitcherShowNames !== "false";
       const customCss = element.dataset.lionrapidSwitcherCustomCss || null;
       element.dataset.position = position;
+      if (position.startsWith("top")) {
+        const place = () => {
+          element.style.top = `${topCornerOffset()}px`;
+        };
+        place();
+        window.addEventListener("load", place);
+        window.addEventListener("resize", place);
+      }
       if (customCss) {
         const styleEl = document.createElement("style");
         styleEl.textContent = customCss;
@@ -6129,6 +6252,8 @@ var __lionrapidAutoExports = (() => {
       __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 = {
@@ -6142,6 +6267,8 @@ var __lionrapidAutoExports = (() => {
         }
       };
       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();
     }
@@ -6162,13 +6289,13 @@ var __lionrapidAutoExports = (() => {
       }
       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;
@@ -6192,7 +6319,7 @@ var __lionrapidAutoExports = (() => {
           timestamp: Date.now()
         };
         await cache.put(
-          CACHE_PREFIX + key,
+          this.entryPrefix + key,
           new Response(JSON.stringify(data), {
             headers: { "Content-Type": "application/json" }
           })
@@ -6207,7 +6334,7 @@ var __lionrapidAutoExports = (() => {
       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 {
       }
     }
@@ -6220,7 +6347,7 @@ var __lionrapidAutoExports = (() => {
         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 {
       }
@@ -6238,7 +6365,7 @@ var __lionrapidAutoExports = (() => {
         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))
         );
@@ -6290,9 +6417,9 @@ var __lionrapidAutoExports = (() => {
         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);
@@ -6314,7 +6441,7 @@ var __lionrapidAutoExports = (() => {
       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 };
@@ -6325,6 +6452,11 @@ var __lionrapidAutoExports = (() => {
   // src/config/api.config.ts
   var DEFAULT_API_BASE_URL = "https://app.lionrapid.com";
 
+  // src/browser/storage/scope.ts
+  function storageScope(apiKey) {
+    return apiKey ? md5(apiKey).slice(0, 8) : "none";
+  }
+
   // src/browser/auto-init.ts
   function resolveWritePolicy(apiKey) {
     const isPublishable = apiKey.startsWith("pk_");
@@ -6454,6 +6586,12 @@ var __lionrapidAutoExports = (() => {
       document.documentElement.dir = localeDir(locale);
     }
   }
+  function applyLocaleAttrs(locale) {
+    if (typeof document !== "undefined" && locale) {
+      document.documentElement.lang = locale;
+    }
+    applyLocaleDir(locale);
+  }
   function findConfigScript() {
     const current = document.currentScript;
     if (current instanceof HTMLScriptElement && current.dataset.apiKey) {
@@ -6486,7 +6624,11 @@ var __lionrapidAutoExports = (() => {
       );
     }
     const initialLocale = resolveInitialLocale(config);
-    applyLocaleDir(initialLocale);
+    if (config.mode === "dynamic-only") {
+      applyLocaleDir(initialLocale);
+    } else {
+      applyLocaleAttrs(initialLocale);
+    }
     const languageSwitcher = new LanguageSwitcher();
     languageSwitcher.setLanguages(config.languages);
     languageSwitcher.setInitialLocale(initialLocale);
@@ -6520,18 +6662,25 @@ var __lionrapidAutoExports = (() => {
       navigate: config.mode === "dynamic-only" ? (locale) => navigateToLocale(locale, config.defaultLocale, config.languages) : null
     });
     languageSwitcher.setOnLanguageChange(localeHandler.onChange);
+    const storeScope = storageScope(config.apiKey);
     try {
       const builder = LionRapidBuilder.init({
         defaultLocale: initialLocale,
         namespace: config.namespace
-      }).use(new MemoryRepository({ enabled: true })).use(new LocalStorageRepository({ enabled: true })).use(new CacheStorageRepository({ enabled: true }));
+      }).use(new MemoryRepository({ enabled: true })).use(
+        new LocalStorageRepository({
+          enabled: true,
+          options: { prefix: `lionrapid:${storeScope}:` }
+        })
+      ).use(new CacheStorageRepository({ enabled: true, options: { scope: storeScope } }));
       if (config.offline !== false) {
         builder.use(
           new CacheStorageRepository({
             enabled: true,
             options: {
               ttl: Number.MAX_SAFE_INTEGER,
-              cacheName: CORE_CACHE_NAMES.offlineFloor
+              cacheName: CORE_CACHE_NAMES.offlineFloor,
+              scope: storeScope
             }
           })
         );
@@ -6572,7 +6721,7 @@ var __lionrapidAutoExports = (() => {
         await core.changeLanguage(locale, {
           preloadNamespaces: [config.namespace]
         });
-        applyLocaleDir(locale);
+        applyLocaleAttrs(locale);
         autoTranslator.updateLocale(locale);
         autoTranslator.retranslate();
       });
@@ -6619,7 +6768,7 @@ var __lionrapidAutoExports = (() => {
           await core.changeLanguage(locale, {
             preloadNamespaces: [config.namespace]
           });
-          applyLocaleDir(locale);
+          applyLocaleAttrs(locale);
           autoTranslator.updateLocale(locale);
           autoTranslator.retranslate();
           languageSwitcher.initAll();