lingo.dev 0.117.7 → 0.117.9

package/build/cli.mjs

@@ -2321,9 +2321,119 @@ function _isMetadataKey(key) {
   return key.startsWith("@");
 }
 
+// src/cli/loaders/ail.ts
+import { parseStringPromise, Builder } from "xml2js";
+function createAilLoader() {
+  return createLoader({
+    async pull(locale, input2) {
+      const result = {};
+      if (!input2 || !input2.trim()) {
+        return result;
+      }
+      try {
+        const parsed = await parseStringPromise(input2, {
+          explicitArray: true,
+          // Always use arrays for consistency
+          mergeAttrs: false,
+          // Keep attributes separate in $
+          trim: true,
+          explicitRoot: true
+        });
+        const dictionary = parsed.DICTIONARY;
+        if (!dictionary) {
+          return result;
+        }
+        const entries = dictionary.ENTRY || [];
+        for (const entry of entries) {
+          const id = entry.$?.id;
+          if (!id) {
+            continue;
+          }
+          const strings = entry.STRING || [];
+          const sourceString = strings.find(
+            (s) => s.$?.lang === locale
+          );
+          if (sourceString?.$.value) {
+            result[id] = sourceString.$.value;
+          }
+        }
+        return result;
+      } catch (error) {
+        console.error("Failed to parse AIL file:", error);
+        return result;
+      }
+    },
+    async push(locale, data, originalInput) {
+      if (!originalInput || !originalInput.trim()) {
+        const dictionary = {
+          $: { type: "multilanguage" },
+          ENTRY: Object.entries(data).map(([id, value]) => ({
+            $: { id },
+            STRING: [
+              {
+                $: { lang: locale, value }
+              }
+            ]
+          }))
+        };
+        const builder = new Builder({
+          xmldec: { version: "1.0", encoding: "UTF-8" },
+          headless: false
+        });
+        return builder.buildObject({ DICTIONARY: dictionary });
+      }
+      try {
+        const parsed = await parseStringPromise(originalInput, {
+          explicitArray: true,
+          mergeAttrs: false,
+          trim: true,
+          explicitRoot: true
+        });
+        const dictionary = parsed.DICTIONARY;
+        if (!dictionary) {
+          throw new Error("No DICTIONARY root element found");
+        }
+        const entries = dictionary.ENTRY || [];
+        for (const [id, value] of Object.entries(data)) {
+          let entry = entries.find((e) => e.$?.id === id);
+          if (!entry) {
+            entry = {
+              $: { id },
+              STRING: []
+            };
+            entries.push(entry);
+          }
+          if (!entry.STRING) {
+            entry.STRING = [];
+          }
+          let targetString = entry.STRING.find(
+            (s) => s.$?.lang === locale
+          );
+          if (targetString) {
+            targetString.$.value = value;
+          } else {
+            entry.STRING.push({
+              $: { lang: locale, value }
+            });
+          }
+        }
+        dictionary.ENTRY = entries;
+        const builder = new Builder({
+          xmldec: { version: "1.0", encoding: "UTF-8" },
+          headless: false
+        });
+        return builder.buildObject({ DICTIONARY: dictionary });
+      } catch (error) {
+        console.error("Failed to build AIL file:", error);
+        throw error;
+      }
+    }
+  });
+}
+
 // src/cli/loaders/android.ts
 import { createRequire } from "module";
-import { parseStringPromise } from "xml2js";
+import { parseStringPromise as parseStringPromise2 } from "xml2js";
 var require2 = createRequire(import.meta.url);
 var sax = require2("sax");
 var defaultAndroidResourcesXml = `<?xml version="1.0" encoding="utf-8"?>
@@ -2401,7 +2511,7 @@ function resolveXmlDeclaration(xml) {
 }
 async function parseAndroidDocument(input2) {
   const xmlToParse = input2 && input2.trim().length > 0 ? input2 : defaultAndroidResourcesXml;
-  const parsed = await parseStringPromise(xmlToParse, {
+  const parsed = await parseStringPromise2(xmlToParse, {
     explicitArray: true,
     explicitChildren: true,
     preserveChildrenOrder: true,
@@ -3403,8 +3513,8 @@ function serializeElement(node) {
   const attrString = Object.entries(attributes).map(([key, value]) => ` ${key}="${escapeAttributeValue(String(value))}"`).join("");
   const children = Array.isArray(node.$$) ? node.$$ : [];
   if (children.length === 0) {
-    const textContent2 = node._ ?? "";
-    return `<${name}${attrString}>${textContent2}</${name}>`;
+    const textContent3 = node._ ?? "";
+    return `<${name}${attrString}>${textContent3}</${name}>`;
   }
   const childContent = children.map(serializeElement).join("");
   return `<${name}${attrString}>${childContent}</${name}>`;
@@ -4005,7 +4115,7 @@ function applyTranslations(node, path19, data, pathMap) {
 }
 
 // src/cli/loaders/mjml.ts
-import { parseStringPromise as parseStringPromise2 } from "xml2js";
+import { parseStringPromise as parseStringPromise3 } from "xml2js";
 import * as htmlparser22 from "htmlparser2";
 import { DomHandler as DomHandler2 } from "domhandler";
 var LOCALIZABLE_COMPONENTS = [
@@ -4037,7 +4147,7 @@ function createMjmlLoader() {
     async pull(locale, input2) {
       const result = {};
       try {
-        const parsed = await parseStringPromise2(input2, {
+        const parsed = await parseStringPromise3(input2, {
           explicitArray: true,
           explicitChildren: true,
           preserveChildrenOrder: true,
@@ -4083,7 +4193,7 @@ function createMjmlLoader() {
     },
     async push(locale, data, originalInput) {
       try {
-        const parsed = await parseStringPromise2(originalInput || "", {
+        const parsed = await parseStringPromise3(originalInput || "", {
           explicitArray: true,
           explicitChildren: true,
           preserveChildrenOrder: true,
@@ -4190,9 +4300,9 @@ function serializeXmlNode(node) {
   const attrString = Object.entries(attrs).map(([key, value]) => ` ${key}="${escapeAttributeValue2(String(value))}"`).join("");
   const children = node.$$ || [];
   if (children.length === 0) {
-    const textContent2 = node._ || "";
-    if (textContent2) {
-      return `<${name}${attrString}>${textContent2}</${name}>`;
+    const textContent3 = node._ || "";
+    if (textContent3) {
+      return `<${name}${attrString}>${textContent3}</${name}>`;
     }
     return `<${name}${attrString} />`;
   }
@@ -4249,9 +4359,9 @@ function serializeElement2(node, indent2 = "") {
   const attrString = Object.entries(attributes).map(([key, value]) => ` ${key}="${escapeAttributeValue2(String(value))}"`).join("");
   const children = Array.isArray(node.$$) ? node.$$ : [];
   if (children.length === 0) {
-    const textContent2 = node._ ?? "";
-    if (textContent2) {
-      return `${indent2}<${name}${attrString}>${textContent2}</${name}>`;
+    const textContent3 = node._ ?? "";
+    if (textContent3) {
+      return `${indent2}<${name}${attrString}>${textContent3}</${name}>`;
     }
     return `${indent2}<${name}${attrString} />`;
   }
@@ -5810,10 +5920,10 @@ function formatXml(xml) {
     if (cdataNode) {
       return `${indent2}${openTag}<![CDATA[${cdataNode.nodeValue}]]></${tagName}>`;
     }
-    const textContent2 = element.textContent?.trim() || "";
+    const textContent3 = element.textContent?.trim() || "";
     const hasOnlyText = element.childNodes.length === 1 && element.childNodes[0].nodeType === 3;
-    if (hasOnlyText && textContent2) {
-      return `${indent2}${openTag}${textContent2}</${tagName}>`;
+    if (hasOnlyText && textContent3) {
+      return `${indent2}${openTag}${textContent3}</${tagName}>`;
     }
     const children = Array.from(element.children);
     if (children.length === 0) {
@@ -5865,7 +5975,7 @@ function pushNewFile(locale, translations, originalLocale) {
 }
 
 // src/cli/loaders/xml.ts
-import { parseStringPromise as parseStringPromise3, Builder as Builder2 } from "xml2js";
+import { parseStringPromise as parseStringPromise4, Builder as Builder3 } from "xml2js";
 function normalizeXMLString(xmlString) {
   return xmlString.replace(/\s+/g, " ").replace(/>\s+</g, "><").replace("\n", "").trim();
 }
@@ -5874,7 +5984,7 @@ function createXmlLoader() {
     async pull(locale, input2) {
       let result = {};
       try {
-        const parsed = await parseStringPromise3(input2, {
+        const parsed = await parseStringPromise4(input2, {
           explicitArray: false,
           mergeAttrs: false,
           normalize: true,
@@ -5892,7 +6002,7 @@ function createXmlLoader() {
     },
     async push(locale, data) {
       try {
-        const builder = new Builder2({ headless: true });
+        const builder = new Builder3({ headless: true });
         const xmlOutput = builder.buildObject(data);
         const expectedOutput = normalizeXMLString(xmlOutput);
         return expectedOutput;
@@ -9133,14 +9243,14 @@ function parseEjsForTranslation(input2) {
     if (part.type === "ejs") {
       template += part.content;
     } else {
-      const textContent2 = part.content;
+      const textContent3 = part.content;
       const htmlTagRegex = /<[^>]+>/g;
       const textParts = [];
       let lastTextIndex = 0;
       let htmlMatch;
-      while ((htmlMatch = htmlTagRegex.exec(textContent2)) !== null) {
+      while ((htmlMatch = htmlTagRegex.exec(textContent3)) !== null) {
         if (htmlMatch.index > lastTextIndex) {
-          const textBefore = textContent2.slice(lastTextIndex, htmlMatch.index);
+          const textBefore = textContent3.slice(lastTextIndex, htmlMatch.index);
           if (textBefore.trim()) {
             textParts.push({ type: "text", content: textBefore });
           } else {
@@ -9150,8 +9260,8 @@ function parseEjsForTranslation(input2) {
         textParts.push({ type: "html", content: htmlMatch[0] });
         lastTextIndex = htmlMatch.index + htmlMatch[0].length;
       }
-      if (lastTextIndex < textContent2.length) {
-        const remainingText = textContent2.slice(lastTextIndex);
+      if (lastTextIndex < textContent3.length) {
+        const remainingText = textContent3.slice(lastTextIndex);
         if (remainingText.trim()) {
           textParts.push({ type: "text", content: remainingText });
         } else {
@@ -9159,11 +9269,11 @@ function parseEjsForTranslation(input2) {
         }
       }
       if (textParts.length === 0) {
-        const trimmedContent = textContent2.trim();
+        const trimmedContent = textContent3.trim();
         if (trimmedContent) {
-          textParts.push({ type: "text", content: textContent2 });
+          textParts.push({ type: "text", content: textContent3 });
         } else {
-          textParts.push({ type: "html", content: textContent2 });
+          textParts.push({ type: "html", content: textContent3 });
         }
       }
       for (const textPart of textParts) {
@@ -9232,6 +9342,368 @@ function createEjsLoader() {
   });
 }
 
+// src/cli/loaders/twig.ts
+import * as htmlparser23 from "htmlparser2";
+import { DomHandler as DomHandler3 } from "domhandler";
+import * as domutils2 from "domutils";
+import * as DomSerializer2 from "dom-serializer";
+function createTwigLoader() {
+  const PHRASING_ELEMENTS = /* @__PURE__ */ new Set([
+    // Text-level semantics
+    "a",
+    "abbr",
+    "b",
+    "bdi",
+    "bdo",
+    "br",
+    "cite",
+    "code",
+    "data",
+    "dfn",
+    "em",
+    "i",
+    "kbd",
+    "mark",
+    "q",
+    "ruby",
+    "s",
+    "samp",
+    "small",
+    "span",
+    "strong",
+    "sub",
+    "sup",
+    "time",
+    "u",
+    "var",
+    "wbr",
+    // Media
+    "audio",
+    "img",
+    "video",
+    "picture",
+    // Interactive
+    "button",
+    "input",
+    "label",
+    "select",
+    "textarea",
+    // Embedded
+    "canvas",
+    "iframe",
+    "object",
+    "svg",
+    "math",
+    // Other
+    "del",
+    "ins",
+    "map",
+    "area"
+  ]);
+  const BLOCK_ELEMENTS = /* @__PURE__ */ new Set([
+    "div",
+    "p",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "ul",
+    "ol",
+    "li",
+    "dl",
+    "dt",
+    "dd",
+    "blockquote",
+    "pre",
+    "article",
+    "aside",
+    "nav",
+    "section",
+    "header",
+    "footer",
+    "main",
+    "figure",
+    "figcaption",
+    "table",
+    "thead",
+    "tbody",
+    "tfoot",
+    "tr",
+    "td",
+    "th",
+    "caption",
+    "form",
+    "fieldset",
+    "legend",
+    "details",
+    "summary",
+    "address",
+    "hr",
+    "search",
+    "dialog",
+    "noscript",
+    "title"
+  ]);
+  const UNLOCALIZABLE_TAGS = /* @__PURE__ */ new Set(["script", "style"]);
+  const LOCALIZABLE_ATTRIBUTES2 = {
+    meta: ["content"],
+    img: ["alt", "title"],
+    input: ["placeholder", "title", "aria-label"],
+    textarea: ["placeholder", "title", "aria-label"],
+    button: ["title", "aria-label"],
+    a: ["title", "aria-label"],
+    abbr: ["title"],
+    link: ["title"]
+  };
+  function preprocessTwig(input2) {
+    const twigBlocks = [];
+    let counter = 0;
+    const processed = input2.replace(/\{%[\s\S]*?%\}/g, (match2) => {
+      twigBlocks.push(match2);
+      return `__TWIG_BLOCK_${counter++}__`;
+    });
+    return {
+      processed: processed.replace(/\{#[\s\S]*?#\}/g, (match2) => {
+        twigBlocks.push(match2);
+        return `__TWIG_BLOCK_${counter++}__`;
+      }),
+      twigBlocks
+    };
+  }
+  function postprocessTwig(text, twigBlocks) {
+    return text.replace(/__TWIG_BLOCK_(\d+)__/g, (_37, index) => {
+      return twigBlocks[parseInt(index, 10)] || "";
+    });
+  }
+  return createLoader({
+    async pull(locale, input2) {
+      const result = {};
+      const { processed, twigBlocks } = preprocessTwig(input2);
+      const handler = new DomHandler3();
+      const parser = new htmlparser23.Parser(handler, {
+        lowerCaseTags: false,
+        lowerCaseAttributeNames: false
+      });
+      parser.write(processed);
+      parser.end();
+      const dom = handler.dom;
+      function isInsideUnlocalizableTag(element) {
+        let current = element.parent;
+        while (current && current.type === "tag") {
+          if (UNLOCALIZABLE_TAGS.has(current.name.toLowerCase())) {
+            return true;
+          }
+          current = current.parent;
+        }
+        return false;
+      }
+      function hasTranslatableContent(element) {
+        const text = domutils2.textContent(element);
+        return text.trim().length > 0;
+      }
+      function isLeafBlock(element) {
+        const childElements = element.children.filter(
+          (child) => child.type === "tag"
+        );
+        for (const child of childElements) {
+          if (BLOCK_ELEMENTS.has(child.name.toLowerCase())) {
+            return false;
+          }
+        }
+        return hasTranslatableContent(element);
+      }
+      function getInnerHTML2(element) {
+        const html2 = element.children.map((child) => DomSerializer2.default(child, { encodeEntities: false })).join("");
+        return postprocessTwig(html2, twigBlocks);
+      }
+      function extractAttributes(element, path19) {
+        const tagName = element.name.toLowerCase();
+        const attrs = LOCALIZABLE_ATTRIBUTES2[tagName];
+        if (!attrs) return;
+        for (const attr of attrs) {
+          const value = element.attribs?.[attr];
+          if (value && value.trim()) {
+            const restoredValue = postprocessTwig(value.trim(), twigBlocks);
+            result[`${path19}#${attr}`] = restoredValue;
+          }
+        }
+      }
+      function extractFromElement(element, pathParts) {
+        const path19 = pathParts.join("/");
+        if (isInsideUnlocalizableTag(element)) {
+          return;
+        }
+        extractAttributes(element, path19);
+        const tagName = element.name.toLowerCase();
+        if (BLOCK_ELEMENTS.has(tagName) && isLeafBlock(element)) {
+          const content = getInnerHTML2(element).trim();
+          if (content) {
+            result[path19] = content;
+          }
+          return;
+        }
+        if (PHRASING_ELEMENTS.has(tagName) && hasTranslatableContent(element)) {
+          const content = getInnerHTML2(element).trim();
+          if (content) {
+            result[path19] = content;
+          }
+          return;
+        }
+        let childIndex = 0;
+        const childElements = element.children.filter(
+          (child) => child.type === "tag"
+        );
+        for (const child of childElements) {
+          extractFromElement(child, [...pathParts, childIndex++]);
+        }
+      }
+      const html = domutils2.findOne(
+        (elem) => elem.type === "tag" && elem.name.toLowerCase() === "html",
+        dom,
+        true
+      );
+      if (html) {
+        const head = domutils2.findOne(
+          (elem) => elem.type === "tag" && elem.name.toLowerCase() === "head",
+          html.children,
+          true
+        );
+        const body = domutils2.findOne(
+          (elem) => elem.type === "tag" && elem.name.toLowerCase() === "body",
+          html.children,
+          true
+        );
+        if (head) {
+          let headIndex = 0;
+          const headChildren = head.children.filter(
+            (child) => child.type === "tag"
+          );
+          for (const child of headChildren) {
+            extractFromElement(child, ["head", headIndex++]);
+          }
+        }
+        if (body) {
+          let bodyIndex = 0;
+          const bodyChildren = body.children.filter(
+            (child) => child.type === "tag"
+          );
+          for (const child of bodyChildren) {
+            extractFromElement(child, ["body", bodyIndex++]);
+          }
+        }
+      } else {
+        let rootIndex = 0;
+        const rootElements = dom.filter(
+          (child) => child.type === "tag"
+        );
+        for (const child of rootElements) {
+          extractFromElement(child, [rootIndex++]);
+        }
+      }
+      return result;
+    },
+    async push(locale, data, originalInput) {
+      const { processed, twigBlocks } = preprocessTwig(originalInput || "");
+      const handler = new DomHandler3();
+      const parser = new htmlparser23.Parser(handler, {
+        lowerCaseTags: false,
+        lowerCaseAttributeNames: false
+      });
+      parser.write(processed || "<!DOCTYPE html><html><head></head><body></body></html>");
+      parser.end();
+      const dom = handler.dom;
+      const html = domutils2.findOne(
+        (elem) => elem.type === "tag" && elem.name.toLowerCase() === "html",
+        dom,
+        true
+      );
+      if (html) {
+        html.attribs = html.attribs || {};
+        html.attribs.lang = locale;
+      }
+      function traverseByIndices(element, indices) {
+        let current = element;
+        for (const indexStr of indices) {
+          if (!current) return null;
+          const index = parseInt(indexStr, 10);
+          const children = current.children.filter(
+            (child) => child.type === "tag"
+          );
+          if (index >= children.length) {
+            return null;
+          }
+          current = children[index];
+        }
+        return current;
+      }
+      function resolvePathToElement(path19) {
+        const parts = path19.split("/");
+        const [rootTag, ...indices] = parts;
+        let current = null;
+        if (html) {
+          if (rootTag === "head") {
+            current = domutils2.findOne(
+              (elem) => elem.type === "tag" && elem.name.toLowerCase() === "head",
+              html.children,
+              true
+            );
+          } else if (rootTag === "body") {
+            current = domutils2.findOne(
+              (elem) => elem.type === "tag" && elem.name.toLowerCase() === "body",
+              html.children,
+              true
+            );
+          }
+          if (!current) return null;
+          return traverseByIndices(current, indices);
+        } else {
+          const rootElements = dom.filter(
+            (child) => child.type === "tag"
+          );
+          const rootIndex = parseInt(rootTag, 10);
+          if (rootIndex >= rootElements.length) {
+            return null;
+          }
+          current = rootElements[rootIndex];
+          return traverseByIndices(current, indices);
+        }
+      }
+      for (const [path19, value] of Object.entries(data)) {
+        const [nodePath, attribute] = path19.split("#");
+        const element = resolvePathToElement(nodePath);
+        if (!element) {
+          console.warn(`Path not found in original template: ${nodePath}`);
+          continue;
+        }
+        if (attribute) {
+          element.attribs = element.attribs || {};
+          element.attribs[attribute] = value;
+        } else {
+          if (value) {
+            const { processed: processedValue, twigBlocks: valueTwigBlocks } = preprocessTwig(value);
+            const valueHandler = new DomHandler3();
+            const valueParser = new htmlparser23.Parser(valueHandler);
+            valueParser.write(processedValue);
+            valueParser.end();
+            element.children = valueHandler.dom;
+            element.children.forEach((child) => {
+              if (child.type === "text" && child.data) {
+                child.data = postprocessTwig(child.data, valueTwigBlocks);
+              }
+            });
+          } else {
+            element.children = [];
+          }
+        }
+      }
+      const serialized = DomSerializer2.default(dom, { encodeEntities: false });
+      return postprocessTwig(serialized, twigBlocks);
+    }
+  });
+}
+
 // src/cli/loaders/ensure-key-order.ts
 import _25 from "lodash";
 function createEnsureKeyOrderLoader() {
@@ -9384,6 +9856,18 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys,
   switch (bucketType) {
     default:
       throw new Error(`Unsupported bucket type: ${bucketType}`);
+    case "ail":
+      return composeLoaders(
+        createTextFileLoader(bucketPathPattern),
+        createLockedPatternsLoader(lockedPatterns),
+        createAilLoader(),
+        createEnsureKeyOrderLoader(),
+        createFlatLoader(),
+        createLockedKeysLoader(lockedKeys || []),
+        createIgnoredKeysLoader(ignoredKeys || []),
+        createSyncLoader(),
+        createUnlocalizableLoader(options.returnUnlocalizedKeys)
+      );
     case "android":
       return composeLoaders(
         createTextFileLoader(bucketPathPattern),
@@ -9730,6 +10214,16 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys,
         createIgnoredKeysLoader(ignoredKeys || []),
         createUnlocalizableLoader(options.returnUnlocalizedKeys)
       );
+    case "twig":
+      return composeLoaders(
+        createTextFileLoader(bucketPathPattern),
+        createLockedPatternsLoader(lockedPatterns),
+        createTwigLoader(),
+        createLockedKeysLoader(lockedKeys || []),
+        createIgnoredKeysLoader(ignoredKeys || []),
+        createSyncLoader(),
+        createUnlocalizableLoader(options.returnUnlocalizedKeys)
+      );
     case "txt":
       return composeLoaders(
         createTextFileLoader(bucketPathPattern),
@@ -14101,7 +14595,7 @@ async function renderHero2() {
 // package.json
 var package_default = {
   name: "lingo.dev",
-  version: "0.117.7",
+  version: "0.117.9",
   description: "Lingo.dev CLI",
   private: false,
   publishConfig: {