@lionrapid/core 0.4.0 → 0.5.0

package/dist/browser/lionrapid.umd.js

@@ -39,6 +39,7 @@ __export(index_exports, {
   Colors: () => Colors,
   ContentValidator: () => ContentValidator,
   EventEmitter: () => EventEmitter,
+  ExcludeFilter: () => ExcludeFilter,
   HTMLSerializer: () => HTMLSerializer,
   HandlerChain: () => HandlerChain,
   LionRapidBuilder: () => LionRapidBuilder,
@@ -52,6 +53,7 @@ __export(index_exports, {
   NetworkError: () => NetworkError,
   NetworkRepository: () => NetworkRepository,
   ServerError: () => ServerError,
+  StaticRepository: () => StaticRepository,
   TranslationError: () => TranslationError,
   TranslationLockedError: () => TranslationLockedError,
   TranslationNotFoundError: () => TranslationNotFoundError,
@@ -59,10 +61,12 @@ __export(index_exports, {
   VOID_TAGS: () => VOID_TAGS,
   createPackageLogger: () => createPackageLogger,
   extractTagName: () => extractTagName,
+  generateAutoKey: () => generateAutoKey,
   isClientError: () => isClientError,
   isRetryableError: () => isRetryableError,
   isTranslationError: () => isTranslationError,
   logger: () => logger,
+  md5: () => md5,
   measure: () => measure,
   parseKeyPath: () => parseKeyPath,
   prepareTranslationRequest: () => prepareTranslationRequest,
@@ -3232,6 +3236,155 @@ var LionRapidCore = class {
   }
 };
 
+// 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 {
@@ -3440,6 +3593,15 @@ var LionRapidBuilder = class _LionRapidBuilder {
     }
     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();
@@ -4037,101 +4199,6 @@ var _NetworkRepository = class _NetworkRepository {
 __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/content/validator/ContentValidator.ts
 var ContentValidator = class {
   /**
@@ -4285,6 +4352,211 @@ var ContentValidator = class {
   }
 };
 
+// src/browser/md5.ts
+function safeAdd(x, y) {
+  const lsw = (x & 65535) + (y & 65535);
+  const msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+  return msw << 16 | lsw & 65535;
+}
+function bitRotateLeft(num, cnt) {
+  return num << cnt | num >>> 32 - cnt;
+}
+function md5cmn(q, a, b, x, s, t) {
+  return safeAdd(bitRotateLeft(safeAdd(safeAdd(a, q), safeAdd(x, t)), s), b);
+}
+function md5ff(a, b, c, d, x, s, t) {
+  return md5cmn(b & c | ~b & d, a, b, x, s, t);
+}
+function md5gg(a, b, c, d, x, s, t) {
+  return md5cmn(b & d | c & ~d, a, b, x, s, t);
+}
+function md5hh(a, b, c, d, x, s, t) {
+  return md5cmn(b ^ c ^ d, a, b, x, s, t);
+}
+function md5ii(a, b, c, d, x, s, t) {
+  return md5cmn(c ^ (b | ~d), a, b, x, s, t);
+}
+function binlMD5(x, len) {
+  x[len >> 5] |= 128 << len % 32;
+  x[(len + 64 >>> 9 << 4) + 14] = len;
+  let a = 1732584193;
+  let b = -271733879;
+  let c = -1732584194;
+  let d = 271733878;
+  for (let i = 0; i < x.length; i += 16) {
+    const olda = a;
+    const oldb = b;
+    const oldc = c;
+    const oldd = d;
+    a = md5ff(a, b, c, d, x[i], 7, -680876936);
+    d = md5ff(d, a, b, c, x[i + 1], 12, -389564586);
+    c = md5ff(c, d, a, b, x[i + 2], 17, 606105819);
+    b = md5ff(b, c, d, a, x[i + 3], 22, -1044525330);
+    a = md5ff(a, b, c, d, x[i + 4], 7, -176418897);
+    d = md5ff(d, a, b, c, x[i + 5], 12, 1200080426);
+    c = md5ff(c, d, a, b, x[i + 6], 17, -1473231341);
+    b = md5ff(b, c, d, a, x[i + 7], 22, -45705983);
+    a = md5ff(a, b, c, d, x[i + 8], 7, 1770035416);
+    d = md5ff(d, a, b, c, x[i + 9], 12, -1958414417);
+    c = md5ff(c, d, a, b, x[i + 10], 17, -42063);
+    b = md5ff(b, c, d, a, x[i + 11], 22, -1990404162);
+    a = md5ff(a, b, c, d, x[i + 12], 7, 1804603682);
+    d = md5ff(d, a, b, c, x[i + 13], 12, -40341101);
+    c = md5ff(c, d, a, b, x[i + 14], 17, -1502002290);
+    b = md5ff(b, c, d, a, x[i + 15], 22, 1236535329);
+    a = md5gg(a, b, c, d, x[i + 1], 5, -165796510);
+    d = md5gg(d, a, b, c, x[i + 6], 9, -1069501632);
+    c = md5gg(c, d, a, b, x[i + 11], 14, 643717713);
+    b = md5gg(b, c, d, a, x[i], 20, -373897302);
+    a = md5gg(a, b, c, d, x[i + 5], 5, -701558691);
+    d = md5gg(d, a, b, c, x[i + 10], 9, 38016083);
+    c = md5gg(c, d, a, b, x[i + 15], 14, -660478335);
+    b = md5gg(b, c, d, a, x[i + 4], 20, -405537848);
+    a = md5gg(a, b, c, d, x[i + 9], 5, 568446438);
+    d = md5gg(d, a, b, c, x[i + 14], 9, -1019803690);
+    c = md5gg(c, d, a, b, x[i + 3], 14, -187363961);
+    b = md5gg(b, c, d, a, x[i + 8], 20, 1163531501);
+    a = md5gg(a, b, c, d, x[i + 13], 5, -1444681467);
+    d = md5gg(d, a, b, c, x[i + 2], 9, -51403784);
+    c = md5gg(c, d, a, b, x[i + 7], 14, 1735328473);
+    b = md5gg(b, c, d, a, x[i + 12], 20, -1926607734);
+    a = md5hh(a, b, c, d, x[i + 5], 4, -378558);
+    d = md5hh(d, a, b, c, x[i + 8], 11, -2022574463);
+    c = md5hh(c, d, a, b, x[i + 11], 16, 1839030562);
+    b = md5hh(b, c, d, a, x[i + 14], 23, -35309556);
+    a = md5hh(a, b, c, d, x[i + 1], 4, -1530992060);
+    d = md5hh(d, a, b, c, x[i + 4], 11, 1272893353);
+    c = md5hh(c, d, a, b, x[i + 7], 16, -155497632);
+    b = md5hh(b, c, d, a, x[i + 10], 23, -1094730640);
+    a = md5hh(a, b, c, d, x[i + 13], 4, 681279174);
+    d = md5hh(d, a, b, c, x[i + 0], 11, -358537222);
+    c = md5hh(c, d, a, b, x[i + 3], 16, -722521979);
+    b = md5hh(b, c, d, a, x[i + 6], 23, 76029189);
+    a = md5hh(a, b, c, d, x[i + 9], 4, -640364487);
+    d = md5hh(d, a, b, c, x[i + 12], 11, -421815835);
+    c = md5hh(c, d, a, b, x[i + 15], 16, 530742520);
+    b = md5hh(b, c, d, a, x[i + 2], 23, -995338651);
+    a = md5ii(a, b, c, d, x[i], 6, -198630844);
+    d = md5ii(d, a, b, c, x[i + 7], 10, 1126891415);
+    c = md5ii(c, d, a, b, x[i + 14], 15, -1416354905);
+    b = md5ii(b, c, d, a, x[i + 5], 21, -57434055);
+    a = md5ii(a, b, c, d, x[i + 12], 6, 1700485571);
+    d = md5ii(d, a, b, c, x[i + 3], 10, -1894986606);
+    c = md5ii(c, d, a, b, x[i + 10], 15, -1051523);
+    b = md5ii(b, c, d, a, x[i + 1], 21, -2054922799);
+    a = md5ii(a, b, c, d, x[i + 8], 6, 1873313359);
+    d = md5ii(d, a, b, c, x[i + 15], 10, -30611744);
+    c = md5ii(c, d, a, b, x[i + 6], 15, -1560198380);
+    b = md5ii(b, c, d, a, x[i + 13], 21, 1309151649);
+    a = md5ii(a, b, c, d, x[i + 4], 6, -145523070);
+    d = md5ii(d, a, b, c, x[i + 11], 10, -1120210379);
+    c = md5ii(c, d, a, b, x[i + 2], 15, 718787259);
+    b = md5ii(b, c, d, a, x[i + 9], 21, -343485551);
+    a = safeAdd(a, olda);
+    b = safeAdd(b, oldb);
+    c = safeAdd(c, oldc);
+    d = safeAdd(d, oldd);
+  }
+  return [a, b, c, d];
+}
+function binl2hex(binarray) {
+  const hexTab = "0123456789abcdef";
+  let str = "";
+  for (let i = 0; i < binarray.length * 4; i++) {
+    str += hexTab.charAt(binarray[i >> 2] >> i % 4 * 8 + 4 & 15) + hexTab.charAt(binarray[i >> 2] >> i % 4 * 8 & 15);
+  }
+  return str;
+}
+function utf8Bytes(str) {
+  if (typeof TextEncoder !== "undefined") {
+    return new TextEncoder().encode(str);
+  }
+  const out = [];
+  for (let i = 0; i < str.length; i++) {
+    const c = str.charCodeAt(i);
+    if (c < 128) {
+      out.push(c);
+    } else if (c < 2048) {
+      out.push(192 | c >> 6, 128 | c & 63);
+    } else if (c >= 55296 && c < 56320 && i + 1 < str.length) {
+      const c2 = str.charCodeAt(++i);
+      const cp = 65536 + (c - 55296 << 10) + (c2 - 56320);
+      out.push(
+        240 | cp >> 18,
+        128 | cp >> 12 & 63,
+        128 | cp >> 6 & 63,
+        128 | cp & 63
+      );
+    } else {
+      out.push(
+        224 | c >> 12,
+        128 | c >> 6 & 63,
+        128 | c & 63
+      );
+    }
+  }
+  return new Uint8Array(out);
+}
+function bytes2binl(bytes) {
+  const bin = [];
+  for (let i = 0; i < bytes.length; i++) {
+    bin[i >> 2] |= bytes[i] << i % 4 * 8;
+  }
+  return bin;
+}
+function md5(str) {
+  const bytes = utf8Bytes(str);
+  return binl2hex(binlMD5(bytes2binl(bytes), bytes.length * 8));
+}
+function generateAutoKey(text) {
+  const trimmed = text.trim();
+  return "auto_" + md5(trimmed).substring(0, 12);
+}
+
+// src/browser/exclude-filter.ts
+var DEFAULT_PATTERNS = {
+  emails: true,
+  urls: true,
+  numbers: true,
+  phones: true
+};
+var PATTERNS = {
+  email: /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/,
+  url: /^(https?:\/\/|www\.)[^\s]+$/i,
+  number: /^[\d\s.,+-]+$/,
+  phone: /^[+\d][\d\s().-]{6,}$/
+};
+var ExcludeFilter = class {
+  constructor(patterns = {}, minTextLength = 2) {
+    __publicField(this, "patterns");
+    __publicField(this, "minTextLength");
+    this.patterns = { ...DEFAULT_PATTERNS, ...patterns };
+    this.minTextLength = minTextLength;
+  }
+  /**
+   * Check if text should be excluded from translation
+   */
+  shouldExclude(text) {
+    const trimmed = text.trim();
+    if (trimmed.length < this.minTextLength) {
+      return true;
+    }
+    if (this.patterns.emails && PATTERNS.email.test(trimmed)) {
+      return true;
+    }
+    if (this.patterns.urls && PATTERNS.url.test(trimmed)) {
+      return true;
+    }
+    if (this.patterns.numbers && PATTERNS.number.test(trimmed)) {
+      return true;
+    }
+    if (this.patterns.phones && PATTERNS.phone.test(trimmed)) {
+      return true;
+    }
+    return false;
+  }
+};
+
 // src/browser/storage/localstorage-repository.ts
 var STORAGE_PREFIX = "lionrapid:";
 var VERSION_KEY = `${STORAGE_PREFIX}version`;