@lionrapid/core 0.3.1 → 0.5.0

package/dist/browser/lionrapid.iife.js

@@ -28,6 +28,7 @@ var LionRapid = (() => {
     Colors: () => Colors,
     ContentValidator: () => ContentValidator,
     EventEmitter: () => EventEmitter,
+    ExcludeFilter: () => ExcludeFilter,
     HTMLSerializer: () => HTMLSerializer,
     HandlerChain: () => HandlerChain,
     LionRapidBuilder: () => LionRapidBuilder,
@@ -41,6 +42,7 @@ var LionRapid = (() => {
     NetworkError: () => NetworkError,
     NetworkRepository: () => NetworkRepository,
     ServerError: () => ServerError,
+    StaticRepository: () => StaticRepository,
     TranslationError: () => TranslationError,
     TranslationLockedError: () => TranslationLockedError,
     TranslationNotFoundError: () => TranslationNotFoundError,
@@ -48,10 +50,12 @@ var LionRapid = (() => {
     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,
@@ -2257,10 +2261,44 @@ var LionRapid = (() => {
   }
 
   // src/content/parser/MarkupParser.ts
+  function decodeEntities(text) {
+    const named = {
+      amp: "&",
+      lt: "<",
+      gt: ">",
+      quot: '"',
+      apos: "'",
+      nbsp: " ",
+      rsquo: "\u2019",
+      lsquo: "\u2018",
+      rdquo: "\u201D",
+      ldquo: "\u201C",
+      hellip: "\u2026",
+      mdash: "\u2014",
+      ndash: "\u2013",
+      copy: "\xA9",
+      reg: "\xAE",
+      trade: "\u2122"
+    };
+    return text.replace(/&(#x[0-9a-f]+|#[0-9]+|[a-z][a-z0-9]*);/gi, (m, body) => {
+      if (body[0] === "#") {
+        const cp = body[1] === "x" || body[1] === "X" ? parseInt(body.slice(2), 16) : parseInt(body.slice(1), 10);
+        if (Number.isFinite(cp) && cp > 0) {
+          try {
+            return String.fromCodePoint(cp);
+          } catch {
+            return m;
+          }
+        }
+        return m;
+      }
+      return named[body.toLowerCase()] ?? m;
+    });
+  }
   var MarkupParser = class {
     parse(input) {
       if (/<\/?[0-9]+>/.test(input)) {
-        return { text: input, styles: {} };
+        return { text: decodeEntities(input), styles: {} };
       }
       const styles = {};
       let tagIndex = 0;
@@ -2305,7 +2343,7 @@ var LionRapid = (() => {
         const unclosed = tagStack.pop();
         result += `</${unclosed.index}>`;
       }
-      return { text: result, styles };
+      return { text: decodeEntities(result), styles };
     }
     matchTag(input, startPos) {
       const tagStart = input.indexOf("<", startPos);
@@ -3186,6 +3224,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 {
@@ -3394,6 +3581,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();
@@ -3991,101 +4187,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/content/validator/ContentValidator.ts
   var ContentValidator = class {
     /**
@@ -4239,6 +4340,211 @@ var LionRapid = (() => {
     }
   };
 
+  // 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`;