@lionrapid/core 0.3.1 → 0.4.0

package/dist/browser/lionrapid.auto.js

@@ -23,6 +23,7 @@ var LionRapid = (() => {
   // src/browser/index.ts
   var index_exports = {};
   __export(index_exports, {
+    AttributeExtractor: () => AttributeExtractor,
     AutoTranslator: () => AutoTranslator,
     BlockExtractor: () => BlockExtractor,
     CacheStorageRepository: () => CacheStorageRepository,
@@ -2179,10 +2180,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;
@@ -2227,7 +2262,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);
@@ -4204,15 +4239,46 @@ var LionRapid = (() => {
     }
     return str;
   }
-  function str2binl(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 < str.length * 8; i += 8) {
-      bin[i >> 5] |= (str.charCodeAt(i / 8) & 255) << i % 32;
+    for (let i = 0; i < bytes.length; i++) {
+      bin[i >> 2] |= bytes[i] << i % 4 * 8;
     }
     return bin;
   }
   function md5(str) {
-    return binl2hex(binlMD5(str2binl(str), str.length * 8));
+    const bytes = utf8Bytes(str);
+    return binl2hex(binlMD5(bytes2binl(bytes), bytes.length * 8));
   }
   function generateAutoKey(text) {
     const trimmed = text.trim();
@@ -4221,6 +4287,7 @@ var LionRapid = (() => {
 
   // src/browser/block-extractor.ts
   var BLOCK_SELECTOR = "p,h1,h2,h3,h4,h5,h6,li,td,th,label,button,figcaption,dt,dd,summary,caption";
+  var INLINE_BLOCK_SELECTOR = "a";
   var SKIP_TAGS = /* @__PURE__ */ new Set([
     "SCRIPT",
     "STYLE",
@@ -4309,8 +4376,60 @@ var LionRapid = (() => {
         }
         results.push({ element: el, unit, key });
       }
+      this.extractOrphanInline(root, results, includeTranslated);
       return results;
     }
+    /**
+     * Second pass: extract inline elements (currently <a>) that have no block
+     * ancestor. These would otherwise slip through both the block pass (not in
+     * BLOCK_SELECTOR) and the inline-style capture (no parent block to host
+     * them as `<1>...</1>`). Common shape: a `<div>` action group containing
+     * only links.
+     */
+    extractOrphanInline(root, results, includeTranslated) {
+      const candidates = root.querySelectorAll(INLINE_BLOCK_SELECTOR);
+      const elements = [];
+      if (root instanceof Element && root.matches(INLINE_BLOCK_SELECTOR)) {
+        elements.push(root);
+      }
+      for (let i = 0; i < candidates.length; i++) {
+        elements.push(candidates[i]);
+      }
+      for (let i = 0; i < elements.length; i++) {
+        const el = elements[i];
+        if (this.isInsideSkipTag(el)) continue;
+        if (!includeTranslated && this.hasSkipAttribute(el)) continue;
+        if (this.matchesExcludeSelector(el)) continue;
+        if (el.getAttribute("translate") === "no") continue;
+        if (el.parentElement?.closest(BLOCK_SELECTOR)) continue;
+        if (el.parentElement?.closest(INLINE_BLOCK_SELECTOR)) continue;
+        if (el.querySelector(BLOCK_SELECTOR)) continue;
+        const lrOriginal = el.getAttribute("data-lr-original");
+        let unit;
+        if (lrOriginal) {
+          const temp = document.createElement(el.tagName);
+          temp.innerHTML = lrOriginal;
+          unit = parseBlockElement(temp);
+        } else {
+          unit = parseBlockElement(el);
+        }
+        const strippedText = unit.text.replace(/<\/?[0-9]+\/?>/g, "");
+        if (this.excludeFilter.shouldExclude(strippedText)) continue;
+        const lrBlock = el.getAttribute("data-lr-block");
+        let key;
+        if (lrBlock) {
+          key = lrBlock;
+        } else {
+          const dataI18n = el.getAttribute("data-i18n");
+          if (dataI18n) {
+            key = dataI18n.includes(":") ? dataI18n : `common:${dataI18n}`;
+          } else {
+            key = generateAutoKey(unit.text);
+          }
+        }
+        results.push({ element: el, unit, key });
+      }
+    }
     isInsideSkipTag(element) {
       let current = element.parentElement;
       while (current) {
@@ -4346,6 +4465,116 @@ var LionRapid = (() => {
     }
   };
 
+  // src/browser/attribute-extractor.ts
+  var TARGETS = [
+    { selector: 'img[alt], area[alt], input[type="image"][alt]', attr: "alt", type: "alt" },
+    { selector: "[title]", attr: "title", type: "title" },
+    { selector: "input[placeholder], textarea[placeholder]", attr: "placeholder", type: "placeholder" },
+    { selector: 'meta[name="description"][content]', attr: "content", type: "meta-description" },
+    {
+      selector: 'input[type="submit"][value], input[type="button"][value], input[type="reset"][value]',
+      attr: "value",
+      type: "input-value"
+    }
+  ];
+  var SKIP_TAGS2 = /* @__PURE__ */ new Set([
+    "SCRIPT",
+    "STYLE",
+    "CODE",
+    "PRE",
+    "NOSCRIPT",
+    "SVG"
+  ]);
+  var SKIP_ATTRIBUTES2 = [
+    "data-lionrapid-translated",
+    "data-lionrapid-client",
+    "data-no-translate"
+  ];
+  function stampAttrName(attrName) {
+    return `data-lr-attr-${attrName.toLowerCase()}`;
+  }
+  var AttributeExtractor = class {
+    constructor(excludePatterns = {}, excludeSelectors = [], minTextLength = 2) {
+      __publicField(this, "excludeFilter");
+      __publicField(this, "excludeSelectors");
+      this.excludeFilter = new ExcludeFilter(excludePatterns, minTextLength);
+      this.excludeSelectors = excludeSelectors;
+    }
+    /**
+     * Walk the DOM under `root` and return every translatable attribute.
+     *
+     * @param root           Element or Document to scan
+     * @param includeStamped When true, elements already carrying
+     *                       `data-lr-attr-{name}` are returned anyway —
+     *                       the editor uses this to surface server-handled
+     *                       attributes for inspection. The runtime keeps
+     *                       the default `false` so it doesn't re-extract
+     *                       what the server already keyed.
+     */
+    extract(root, includeStamped = false) {
+      const results = [];
+      for (const target of TARGETS) {
+        const candidates = root.querySelectorAll(target.selector);
+        const all = [];
+        if (root instanceof Element && root.matches(target.selector)) {
+          all.push(root);
+        }
+        for (let i = 0; i < candidates.length; i++) {
+          all.push(candidates[i]);
+        }
+        for (let i = 0; i < all.length; i++) {
+          const el = all[i];
+          if (this.isInsideSkipTag(el)) continue;
+          if (this.hasSkipAncestor(el)) continue;
+          if (this.matchesExcludeSelector(el)) continue;
+          if (el.getAttribute("translate") === "no") continue;
+          const rawValue = el.getAttribute(target.attr);
+          if (rawValue === null) continue;
+          const trimmed = rawValue.trim();
+          if (this.excludeFilter.shouldExclude(trimmed)) continue;
+          const stampName = stampAttrName(target.attr);
+          const stamped = el.getAttribute(stampName);
+          if (!includeStamped && stamped) {
+            continue;
+          }
+          const unit = { text: rawValue, type: target.type };
+          const key = stamped ?? generateAutoKey(rawValue);
+          results.push({ element: el, attrName: target.attr, unit, key });
+        }
+      }
+      return results;
+    }
+    isInsideSkipTag(element) {
+      let current = element.parentElement;
+      while (current) {
+        if (SKIP_TAGS2.has(current.tagName)) return true;
+        current = current.parentElement;
+      }
+      return false;
+    }
+    hasSkipAncestor(element) {
+      let current = element;
+      while (current) {
+        for (const attr of SKIP_ATTRIBUTES2) {
+          if (current.hasAttribute(attr)) return true;
+        }
+        current = current.parentElement;
+      }
+      return false;
+    }
+    matchesExcludeSelector(element) {
+      for (const selector of this.excludeSelectors) {
+        try {
+          if (element.matches(selector) || element.closest(selector)) {
+            return true;
+          }
+        } catch {
+        }
+      }
+      return false;
+    }
+  };
+
   // src/browser/dom-observer.ts
   var DOMObserver = class {
     constructor(callbacks, debounceMs = 50) {
@@ -4450,6 +4679,7 @@ var LionRapid = (() => {
     constructor(config = {}) {
       __publicField(this, "core", null);
       __publicField(this, "blockExtractor");
+      __publicField(this, "attributeExtractor");
       __publicField(this, "domObserver", null);
       __publicField(this, "locale", "");
       __publicField(this, "sourceLocale", "");
@@ -4463,6 +4693,11 @@ var LionRapid = (() => {
         config.excludeSelectors,
         config.minTextLength
       );
+      this.attributeExtractor = new AttributeExtractor(
+        config.excludePatterns,
+        config.excludeSelectors,
+        config.minTextLength
+      );
       this.debounceMs = config.debounceMs ?? 100;
     }
     /**
@@ -4511,8 +4746,9 @@ var LionRapid = (() => {
       if (!this.core) {
         return 0;
       }
-      const extracted = this.blockExtractor.extract(element);
-      return this.translateBlocks(extracted);
+      const blockCount = this.translateBlocks(this.blockExtractor.extract(element));
+      const attrCount = this.translateAttributesIn(this.attributeExtractor.extract(element));
+      return blockCount + attrCount;
     }
     /**
      * Translate the entire page
@@ -4610,12 +4846,79 @@ var LionRapid = (() => {
       }
       return count;
     }
+    /**
+     * Translate extracted attribute units against the cache.
+     *
+     * Mirrors translateBlocks but for attribute values. For each hit, the
+     * original attribute value is preserved in `data-lr-orig-{name}` so
+     * retranslate() can restore source. The element accumulates a comma-
+     * separated `data-lionrapid-client-attrs` list naming every attr the
+     * client touched — so we can find them all on retranslate without
+     * iterating a fixed selector set.
+     *
+     * Cache misses emit `translation:not-found` with empty styles, so the
+     * existing MissingTranslationQueue + NetworkRepository sync queue
+     * picks them up unchanged.
+     */
+    translateAttributesIn(extracted) {
+      if (!this.core) return 0;
+      let count = 0;
+      for (const { element, attrName, unit, key } of extracted) {
+        const fullKey = `${this.locale}:${this.namespace}:${key}`;
+        const cached = this.core.cache.get(fullKey);
+        if (cached && cached.value !== unit.text && cached.value !== key) {
+          const lower = attrName.toLowerCase();
+          const origAttr = `data-lr-orig-${lower}`;
+          if (!element.hasAttribute(origAttr)) {
+            element.setAttribute(origAttr, unit.text);
+          }
+          element.setAttribute(attrName, cached.value);
+          element.setAttribute(`data-lr-attr-${lower}`, key);
+          const existing = element.getAttribute("data-lionrapid-client-attrs") ?? "";
+          const set = new Set(existing.split(",").filter(Boolean));
+          set.add(lower);
+          element.setAttribute("data-lionrapid-client-attrs", Array.from(set).join(","));
+          count++;
+        } else {
+          this.core.bus.emit("translation:not-found", {
+            payload: {
+              key,
+              fallbackValue: unit.text,
+              locale: this.sourceLocale,
+              namespace: this.namespace,
+              status: 404,
+              styles: {}
+            }
+          });
+        }
+      }
+      return count;
+    }
     /**
      * Get translated count
      */
     getTranslatedCount() {
       return this.translatedCount;
     }
+    /**
+     * Restore every client-translated attribute on `el` from its
+     * `data-lr-orig-*` backup, then strip the stamps. Mirrors the block-side
+     * restoration in retranslate() so language switch / editor reset clears
+     * attributes too.
+     */
+    restoreClientAttributes(el) {
+      const list = el.getAttribute("data-lionrapid-client-attrs");
+      if (list === null) return;
+      for (const name of list.split(",").filter(Boolean)) {
+        const orig = el.getAttribute(`data-lr-orig-${name}`);
+        if (orig !== null) {
+          el.setAttribute(name, orig);
+          el.removeAttribute(`data-lr-orig-${name}`);
+        }
+        el.removeAttribute(`data-lr-attr-${name}`);
+      }
+      el.removeAttribute("data-lionrapid-client-attrs");
+    }
     /**
      * Re-translate a single element (for editor live preview reset)
      */
@@ -4624,14 +4927,15 @@ var LionRapid = (() => {
       if (original !== null) element.innerHTML = original;
       element.removeAttribute("data-lionrapid-client");
       element.removeAttribute("data-lr-block");
+      this.restoreClientAttributes(element);
       this.translateElement(element);
     }
     /**
      * Re-translate the page (after language change)
      */
     retranslate() {
-      const translated = document.querySelectorAll("[data-lionrapid-client]");
-      translated.forEach((el) => {
+      const translatedBlocks = document.querySelectorAll("[data-lionrapid-client]");
+      translatedBlocks.forEach((el) => {
         const original = el.getAttribute("data-lr-original");
         if (original !== null) {
           el.innerHTML = original;
@@ -4639,6 +4943,8 @@ var LionRapid = (() => {
         el.removeAttribute("data-lionrapid-client");
         el.removeAttribute("data-lr-block");
       });
+      const translatedAttrs = document.querySelectorAll("[data-lionrapid-client-attrs]");
+      translatedAttrs.forEach((el) => this.restoreClientAttributes(el));
       this.translatedCount = 0;
       if (this.locale !== this.sourceLocale) {
         this.translatePage();
@@ -5368,6 +5674,7 @@ var LionRapid = (() => {
     const switcherShowFlags = script.dataset.switcherShowFlags !== "false";
     const switcherShowNames = script.dataset.switcherShowNames === "true";
     const switcherCustomCss = script.dataset.switcherCustomCss || void 0;
+    const editorCdnUrl = script.dataset.editorCdn || void 0;
     return {
       apiKey,
       baseUrl,
@@ -5381,7 +5688,8 @@ var LionRapid = (() => {
       switcherPosition,
       switcherShowFlags,
       switcherShowNames,
-      switcherCustomCss
+      switcherCustomCss,
+      editorCdnUrl
     };
   }
   function readLocaleCookie(availableLanguages) {
@@ -5563,7 +5871,7 @@ var LionRapid = (() => {
       };
       window.LionRapid = instance;
       const editorParam = new URLSearchParams(window.location.search).get("__lr_editor");
-      if (editorParam && !document.querySelector("script[data-grant]")) {
+      if (editorParam && !document.querySelector("script[data-grant], script[data-lr-editor]")) {
         const editorScript = document.createElement("script");
         editorScript.src = config.editorCdnUrl || "https://cdn.lionrapid.com/lionrapid.editor.min.js";
         editorScript.dataset.grant = editorParam;