@lionrapid/core 0.4.0 → 0.5.0

package/dist/browser/lionrapid.auto.js

@@ -3143,6 +3143,155 @@ var LionRapid = (() => {
     }
   };
 
+  // src/repositories/memory-repository.ts
+  var MemoryRepository = class {
+    constructor(config) {
+      __publicField(this, "name", "MemoryRepository");
+      __publicField(this, "type", "memory");
+      __publicField(this, "config", {});
+      __publicField(this, "cache", /* @__PURE__ */ new Map());
+      __publicField(this, "accessOrder", /* @__PURE__ */ new Map());
+      __publicField(this, "maxSize", 1e3);
+      this.config = config;
+      this.maxSize = this.config.options?.maxSize || 1e3;
+    }
+    get(key) {
+      const value = this.cache.get(key);
+      if (value !== void 0) {
+        this.accessOrder.set(key, Date.now());
+        return value;
+      }
+      return null;
+    }
+    set(key, value) {
+      if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
+        this.evictOldest();
+      }
+      this.cache.set(key, value);
+      this.accessOrder.set(key, Date.now());
+    }
+    remove(key) {
+      this.cache.delete(key);
+      this.accessOrder.delete(key);
+    }
+    clear() {
+      this.cache.clear();
+      this.accessOrder.clear();
+    }
+    /**
+     * Clear all entries for a specific namespace
+     * Removes both the namespace cache entry and all individual translation keys
+     */
+    clearNamespace(locale, namespace) {
+      const namespaceCacheKey = createNamespaceCacheKey(locale, namespace);
+      const keyPrefix = `${locale}:${namespace}:`;
+      this.cache.delete(namespaceCacheKey);
+      this.accessOrder.delete(namespaceCacheKey);
+      for (const key of this.cache.keys()) {
+        if (key.startsWith(keyPrefix)) {
+          this.cache.delete(key);
+          this.accessOrder.delete(key);
+        }
+      }
+    }
+    getNamespace(locale, namespace) {
+      const namespaceCacheKey = createNamespaceCacheKey(locale, namespace);
+      const namespaceData = this.cache.get(namespaceCacheKey);
+      if (!namespaceData) return null;
+      try {
+        return JSON.parse(namespaceData);
+      } catch (error) {
+        this.cache.delete(namespaceCacheKey);
+        return null;
+      }
+    }
+    setNamespace(locale, namespace, translations) {
+      const namespaceCacheKey = createNamespaceCacheKey(locale, namespace);
+      this.cache.set(namespaceCacheKey, JSON.stringify(translations));
+    }
+    evictOldest() {
+      let oldestKey = "";
+      let oldestTime = Date.now();
+      for (const [key, time] of this.accessOrder.entries()) {
+        if (time < oldestTime) {
+          oldestTime = time;
+          oldestKey = key;
+        }
+      }
+      if (oldestKey) {
+        this.cache.delete(oldestKey);
+        this.accessOrder.delete(oldestKey);
+      }
+    }
+    /**
+     * Get all cache entries for debugging
+     */
+    getEntries() {
+      const entries = {};
+      for (const [key, value] of this.cache.entries()) {
+        entries[key] = value;
+      }
+      return entries;
+    }
+    getConfig() {
+      return this.config;
+    }
+  };
+
+  // src/repositories/static-repository.ts
+  var StaticRepository = class {
+    constructor(bundle, config = {}) {
+      __publicField(this, "name", "StaticRepository");
+      __publicField(this, "type", "memory");
+      __publicField(this, "config");
+      __publicField(this, "mem");
+      this.config = {
+        enabled: config.enabled ?? true,
+        priority: config.priority ?? 0.5,
+        // after the live memory (0), before storage
+        options: {
+          ttl: Number.MAX_SAFE_INTEGER,
+          maxSize: Number.MAX_SAFE_INTEGER,
+          ...config.options
+        }
+      };
+      this.mem = new MemoryRepository({ options: { maxSize: Number.MAX_SAFE_INTEGER } });
+      for (const [locale, namespaces] of Object.entries(bundle)) {
+        for (const [namespace, translations] of Object.entries(namespaces)) {
+          this.mem.setNamespace(locale, namespace, translations);
+          const flat = flattenTranslations(
+            translations,
+            "",
+            locale,
+            namespace
+          );
+          for (const [key, value] of Object.entries(flat)) this.mem.set(key, value);
+        }
+      }
+    }
+    get(key) {
+      return this.mem.get(key);
+    }
+    getNamespace(locale, namespace) {
+      return this.mem.getNamespace(locale, namespace);
+    }
+    getEntries() {
+      return this.mem.getEntries();
+    }
+    getConfig() {
+      return this.config;
+    }
+    // Read-only: the live memory layer owns fresh network data; this stays pristine.
+    set() {
+    }
+    remove() {
+    }
+    clear() {
+    }
+    setNamespace() {
+    }
+  };
+
   // src/sync/missing-translation-queue.ts
   var COOLDOWN_MS = 6e4;
   var MissingTranslationQueue = class {
@@ -3351,6 +3500,15 @@ var LionRapid = (() => {
       }
       return this;
     }
+    /**
+     * Offline resilience: seed a translation bundle (or the CLI's snapshot files)
+     * as a read-only sync layer that resolves synchronously even with the server
+     * down and nothing cached. Sits after the live memory layer (priority 0) at
+     * `priority` (default 0.5), so fresh network data always shadows it.
+     */
+    useStaticBundle(bundle, priority = 0.5) {
+      return this.use(new StaticRepository(bundle, { priority }));
+    }
     async build() {
       const eventEmitter = new EventEmitter();
       const buildBus = eventEmitter.builder();
@@ -3948,101 +4106,6 @@ var LionRapid = (() => {
   __publicField(_NetworkRepository, "VERSION_PREFIX", "lionrapid:v:");
   var NetworkRepository = _NetworkRepository;
 
-  // src/repositories/memory-repository.ts
-  var MemoryRepository = class {
-    constructor(config) {
-      __publicField(this, "name", "MemoryRepository");
-      __publicField(this, "type", "memory");
-      __publicField(this, "config", {});
-      __publicField(this, "cache", /* @__PURE__ */ new Map());
-      __publicField(this, "accessOrder", /* @__PURE__ */ new Map());
-      __publicField(this, "maxSize", 1e3);
-      this.config = config;
-      this.maxSize = this.config.options?.maxSize || 1e3;
-    }
-    get(key) {
-      const value = this.cache.get(key);
-      if (value !== void 0) {
-        this.accessOrder.set(key, Date.now());
-        return value;
-      }
-      return null;
-    }
-    set(key, value) {
-      if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
-        this.evictOldest();
-      }
-      this.cache.set(key, value);
-      this.accessOrder.set(key, Date.now());
-    }
-    remove(key) {
-      this.cache.delete(key);
-      this.accessOrder.delete(key);
-    }
-    clear() {
-      this.cache.clear();
-      this.accessOrder.clear();
-    }
-    /**
-     * Clear all entries for a specific namespace
-     * Removes both the namespace cache entry and all individual translation keys
-     */
-    clearNamespace(locale, namespace) {
-      const namespaceCacheKey = createNamespaceCacheKey(locale, namespace);
-      const keyPrefix = `${locale}:${namespace}:`;
-      this.cache.delete(namespaceCacheKey);
-      this.accessOrder.delete(namespaceCacheKey);
-      for (const key of this.cache.keys()) {
-        if (key.startsWith(keyPrefix)) {
-          this.cache.delete(key);
-          this.accessOrder.delete(key);
-        }
-      }
-    }
-    getNamespace(locale, namespace) {
-      const namespaceCacheKey = createNamespaceCacheKey(locale, namespace);
-      const namespaceData = this.cache.get(namespaceCacheKey);
-      if (!namespaceData) return null;
-      try {
-        return JSON.parse(namespaceData);
-      } catch (error) {
-        this.cache.delete(namespaceCacheKey);
-        return null;
-      }
-    }
-    setNamespace(locale, namespace, translations) {
-      const namespaceCacheKey = createNamespaceCacheKey(locale, namespace);
-      this.cache.set(namespaceCacheKey, JSON.stringify(translations));
-    }
-    evictOldest() {
-      let oldestKey = "";
-      let oldestTime = Date.now();
-      for (const [key, time] of this.accessOrder.entries()) {
-        if (time < oldestTime) {
-          oldestTime = time;
-          oldestKey = key;
-        }
-      }
-      if (oldestKey) {
-        this.cache.delete(oldestKey);
-        this.accessOrder.delete(oldestKey);
-      }
-    }
-    /**
-     * Get all cache entries for debugging
-     */
-    getEntries() {
-      const entries = {};
-      for (const [key, value] of this.cache.entries()) {
-        entries[key] = value;
-      }
-      return entries;
-    }
-    getConfig() {
-      return this.config;
-    }
-  };
-
   // src/browser/exclude-filter.ts
   var DEFAULT_PATTERNS = {
     emails: true,
@@ -5675,6 +5738,7 @@ var LionRapid = (() => {
     const switcherShowNames = script.dataset.switcherShowNames === "true";
     const switcherCustomCss = script.dataset.switcherCustomCss || void 0;
     const editorCdnUrl = script.dataset.editorCdn || void 0;
+    const offline = script.dataset.offline !== "false";
     return {
       apiKey,
       baseUrl,
@@ -5689,7 +5753,8 @@ var LionRapid = (() => {
       switcherShowFlags,
       switcherShowNames,
       switcherCustomCss,
-      editorCdnUrl
+      editorCdnUrl,
+      offline
     };
   }
   function readLocaleCookie(availableLanguages) {
@@ -5769,10 +5834,22 @@ var LionRapid = (() => {
       renderSwitcher();
     }
     try {
-      const core = await LionRapidBuilder.init({
+      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(
+      }).use(new MemoryRepository({ enabled: true })).use(new LocalStorageRepository({ enabled: true })).use(new CacheStorageRepository({ enabled: true }));
+      if (config.offline !== false) {
+        builder.use(
+          new CacheStorageRepository({
+            enabled: true,
+            options: {
+              ttl: Number.MAX_SAFE_INTEGER,
+              cacheName: "lionrapid-offline-v1"
+            }
+          })
+        );
+      }
+      const core = await builder.use(
         new NetworkRepository({
           enabled: true,
           options: {