lingo.dev 0.105.1 → 0.105.2

package/build/cli.mjs

@@ -2749,18 +2749,406 @@ function preserveCommentOrder(section, originalSection) {
 }
 
 // src/cli/loaders/xliff.ts
-import xliff from "xliff";
+import { JSDOM as JSDOM2 } from "jsdom";
 function createXliffLoader() {
   return createLoader({
-    async pull(locale, input2) {
-      const js = await xliff.xliff2js(input2);
-      return js || {};
+    async pull(locale, input2, _ctx, originalLocale) {
+      const trimmedInput = (input2 ?? "").trim();
+      if (!trimmedInput) {
+        return createEmptyResult(originalLocale, locale);
+      }
+      try {
+        const dom = new JSDOM2(trimmedInput, { contentType: "text/xml" });
+        const document = dom.window.document;
+        const parserError = document.querySelector("parsererror");
+        if (parserError) {
+          throw new Error(`XML parsing failed: ${parserError.textContent}`);
+        }
+        const xliffElement = document.documentElement;
+        if (!xliffElement || xliffElement.tagName !== "xliff") {
+          throw new Error("Invalid XLIFF: missing root <xliff> element");
+        }
+        const version = xliffElement.getAttribute("version") || "1.2";
+        const isV2 = version === "2.0";
+        if (isV2) {
+          return pullV2(xliffElement, locale, originalLocale);
+        } else {
+          return pullV1(xliffElement, locale, originalLocale);
+        }
+      } catch (error) {
+        throw new Error(`Failed to parse XLIFF file: ${error.message}`);
+      }
     },
-    async push(locale, payload) {
-      const res = await xliff.js2xliff(payload);
-      return res.trim();
+    async push(locale, translations, originalInput, originalLocale, pullInput) {
+      if (!originalInput) {
+        return pushNewFile(locale, translations, originalLocale);
+      }
+      try {
+        const dom = new JSDOM2(originalInput, { contentType: "text/xml" });
+        const document = dom.window.document;
+        const xliffElement = document.documentElement;
+        const version = xliffElement.getAttribute("version") || "1.2";
+        const isV2 = version === "2.0";
+        if (isV2) {
+          return pushV2(
+            dom,
+            xliffElement,
+            locale,
+            translations,
+            originalLocale,
+            originalInput
+          );
+        } else {
+          return pushV1(
+            dom,
+            xliffElement,
+            locale,
+            translations,
+            originalLocale,
+            originalInput
+          );
+        }
+      } catch (error) {
+        throw new Error(`Failed to update XLIFF file: ${error.message}`);
+      }
+    }
+  });
+}
+function pullV1(xliffElement, locale, originalLocale) {
+  const result = {};
+  const fileElement = xliffElement.querySelector("file");
+  if (!fileElement) {
+    return result;
+  }
+  const sourceLanguage = fileElement.getAttribute("source-language") || originalLocale;
+  const isSourceLocale = sourceLanguage === locale;
+  const bodyElement = fileElement.querySelector("body");
+  if (!bodyElement) {
+    return result;
+  }
+  const transUnits = bodyElement.querySelectorAll("trans-unit");
+  const seenKeys = /* @__PURE__ */ new Set();
+  transUnits.forEach((unit) => {
+    let key = getTransUnitKey(unit);
+    if (!key) return;
+    if (seenKeys.has(key)) {
+      const id = unit.getAttribute("id")?.trim();
+      if (id) {
+        key = `${key}#${id}`;
+      } else {
+        let counter = 1;
+        let newKey = `${key}__${counter}`;
+        while (seenKeys.has(newKey)) {
+          counter++;
+          newKey = `${key}__${counter}`;
+        }
+        key = newKey;
+      }
+    }
+    seenKeys.add(key);
+    const elementName = isSourceLocale ? "source" : "target";
+    const textElement = unit.querySelector(elementName);
+    if (textElement) {
+      result[key] = extractTextContent(textElement);
+    } else if (isSourceLocale) {
+      result[key] = key;
+    } else {
+      result[key] = "";
+    }
+  });
+  return result;
+}
+function pushV1(dom, xliffElement, locale, translations, originalLocale, originalInput) {
+  const document = dom.window.document;
+  const fileElement = xliffElement.querySelector("file");
+  if (!fileElement) {
+    throw new Error("Invalid XLIFF 1.2: missing <file> element");
+  }
+  const sourceLanguage = fileElement.getAttribute("source-language") || originalLocale;
+  const isSourceLocale = sourceLanguage === locale;
+  if (!isSourceLocale) {
+    fileElement.setAttribute("target-language", locale);
+  }
+  let bodyElement = fileElement.querySelector("body");
+  if (!bodyElement) {
+    bodyElement = document.createElement("body");
+    fileElement.appendChild(bodyElement);
+  }
+  const existingUnits = /* @__PURE__ */ new Map();
+  const seenKeys = /* @__PURE__ */ new Set();
+  bodyElement.querySelectorAll("trans-unit").forEach((unit) => {
+    let key = getTransUnitKey(unit);
+    if (!key) return;
+    if (seenKeys.has(key)) {
+      const id = unit.getAttribute("id")?.trim();
+      if (id) {
+        key = `${key}#${id}`;
+      } else {
+        let counter = 1;
+        let newKey = `${key}__${counter}`;
+        while (seenKeys.has(newKey)) {
+          counter++;
+          newKey = `${key}__${counter}`;
+        }
+        key = newKey;
+      }
+    }
+    seenKeys.add(key);
+    existingUnits.set(key, unit);
+  });
+  Object.entries(translations).forEach(([key, value]) => {
+    let unit = existingUnits.get(key);
+    if (!unit) {
+      unit = document.createElement("trans-unit");
+      unit.setAttribute("id", key);
+      unit.setAttribute("resname", key);
+      unit.setAttribute("restype", "string");
+      unit.setAttribute("datatype", "plaintext");
+      const sourceElement = document.createElement("source");
+      setTextContent(sourceElement, isSourceLocale ? value : key);
+      unit.appendChild(sourceElement);
+      if (!isSourceLocale) {
+        const targetElement = document.createElement("target");
+        targetElement.setAttribute("state", value ? "translated" : "new");
+        setTextContent(targetElement, value);
+        unit.appendChild(targetElement);
+      }
+      bodyElement.appendChild(unit);
+      existingUnits.set(key, unit);
+    } else {
+      updateTransUnitV1(unit, key, value, isSourceLocale);
+    }
+  });
+  const translationKeys = new Set(Object.keys(translations));
+  existingUnits.forEach((unit, key) => {
+    if (!translationKeys.has(key)) {
+      unit.parentNode?.removeChild(unit);
+    }
+  });
+  return serializeWithDeclaration(
+    dom,
+    extractXmlDeclaration(originalInput || "")
+  );
+}
+function updateTransUnitV1(unit, key, value, isSourceLocale) {
+  const document = unit.ownerDocument;
+  if (isSourceLocale) {
+    let sourceElement = unit.querySelector("source");
+    if (!sourceElement) {
+      sourceElement = document.createElement("source");
+      unit.appendChild(sourceElement);
+    }
+    setTextContent(sourceElement, value);
+  } else {
+    let targetElement = unit.querySelector("target");
+    if (!targetElement) {
+      targetElement = document.createElement("target");
+      unit.appendChild(targetElement);
     }
+    setTextContent(targetElement, value);
+    targetElement.setAttribute("state", value.trim() ? "translated" : "new");
+  }
+}
+function pullV2(xliffElement, locale, originalLocale) {
+  const result = {};
+  const srcLang = xliffElement.getAttribute("srcLang") || originalLocale;
+  result.sourceLanguage = srcLang;
+  const fileElements = xliffElement.querySelectorAll("file");
+  fileElements.forEach((fileElement) => {
+    const fileId = fileElement.getAttribute("id");
+    if (!fileId) return;
+    traverseUnitsV2(fileElement, fileId, "", result);
   });
+  return result;
+}
+function traverseUnitsV2(container, fileId, currentPath, result) {
+  Array.from(container.children).forEach((child) => {
+    const tagName = child.tagName;
+    if (tagName === "unit") {
+      const unitId = child.getAttribute("id")?.trim();
+      if (!unitId) return;
+      const key = `resources/${fileId}/${currentPath}${unitId}/source`;
+      const segment = child.querySelector("segment");
+      const source = segment?.querySelector("source");
+      if (source) {
+        result[key] = extractTextContent(source);
+      } else {
+        result[key] = unitId;
+      }
+    } else if (tagName === "group") {
+      const groupId = child.getAttribute("id")?.trim();
+      const newPath = groupId ? `${currentPath}${groupId}/groupUnits/` : currentPath;
+      traverseUnitsV2(child, fileId, newPath, result);
+    }
+  });
+}
+function pushV2(dom, xliffElement, locale, translations, originalLocale, originalInput) {
+  const document = dom.window.document;
+  if (translations.sourceLanguage) {
+    xliffElement.setAttribute("srcLang", translations.sourceLanguage);
+    delete translations.sourceLanguage;
+  }
+  const existingUnits = /* @__PURE__ */ new Map();
+  const fileElements = xliffElement.querySelectorAll("file");
+  fileElements.forEach((fileElement) => {
+    const fileId = fileElement.getAttribute("id");
+    if (!fileId) return;
+    indexUnitsV2(fileElement, fileId, "", existingUnits);
+  });
+  Object.entries(translations).forEach(([key, value]) => {
+    const unit = existingUnits.get(key);
+    if (unit) {
+      updateUnitV2(unit, value);
+    } else {
+      console.warn(`Cannot create new unit for key: ${key} in XLIFF 2.0`);
+    }
+  });
+  return serializeWithDeclaration(
+    dom,
+    extractXmlDeclaration(originalInput || "")
+  );
+}
+function indexUnitsV2(container, fileId, currentPath, index) {
+  Array.from(container.children).forEach((child) => {
+    const tagName = child.tagName;
+    if (tagName === "unit") {
+      const unitId = child.getAttribute("id")?.trim();
+      if (!unitId) return;
+      const key = `resources/${fileId}/${currentPath}${unitId}/source`;
+      index.set(key, child);
+    } else if (tagName === "group") {
+      const groupId = child.getAttribute("id")?.trim();
+      const newPath = groupId ? `${currentPath}${groupId}/groupUnits/` : currentPath;
+      indexUnitsV2(child, fileId, newPath, index);
+    }
+  });
+}
+function updateUnitV2(unit, value) {
+  const document = unit.ownerDocument;
+  let segment = unit.querySelector("segment");
+  if (!segment) {
+    segment = document.createElement("segment");
+    unit.appendChild(segment);
+  }
+  let source = segment.querySelector("source");
+  if (!source) {
+    source = document.createElement("source");
+    segment.appendChild(source);
+  }
+  setTextContent(source, value);
+}
+function getTransUnitKey(transUnit) {
+  const resname = transUnit.getAttribute("resname")?.trim();
+  if (resname) return resname;
+  const id = transUnit.getAttribute("id")?.trim();
+  if (id) return id;
+  const sourceElement = transUnit.querySelector("source");
+  if (sourceElement) {
+    const sourceText = extractTextContent(sourceElement).trim();
+    if (sourceText) return sourceText;
+  }
+  return "";
+}
+function extractTextContent(element) {
+  const cdataNode = Array.from(element.childNodes).find(
+    (node) => node.nodeType === element.CDATA_SECTION_NODE
+  );
+  if (cdataNode) {
+    return cdataNode.nodeValue || "";
+  }
+  return element.textContent || "";
+}
+function setTextContent(element, content) {
+  const document = element.ownerDocument;
+  while (element.firstChild) {
+    element.removeChild(element.firstChild);
+  }
+  if (/[<>&"']/.test(content)) {
+    const cdataSection = document.createCDATASection(content);
+    element.appendChild(cdataSection);
+  } else {
+    element.textContent = content;
+  }
+}
+function extractXmlDeclaration(xmlContent) {
+  const match2 = xmlContent.match(/^<\?xml[^>]*\?>/);
+  return match2 ? match2[0] : "";
+}
+function serializeWithDeclaration(dom, declaration) {
+  let serialized = dom.serialize();
+  serialized = formatXml(serialized);
+  if (declaration) {
+    serialized = `${declaration}
+${serialized}`;
+  }
+  return serialized;
+}
+function formatXml(xml) {
+  const dom = new JSDOM2(xml, { contentType: "text/xml" });
+  const doc = dom.window.document;
+  function formatElement(element, depth = 0) {
+    const indent2 = "  ".repeat(depth);
+    const tagName = element.tagName;
+    const attributes = Array.from(element.attributes).map((attr) => `${attr.name}="${attr.value}"`).join(" ");
+    const openTag = attributes ? `<${tagName} ${attributes}>` : `<${tagName}>`;
+    const cdataNode = Array.from(element.childNodes).find(
+      (node) => node.nodeType === element.CDATA_SECTION_NODE
+    );
+    if (cdataNode) {
+      return `${indent2}${openTag}<![CDATA[${cdataNode.nodeValue}]]></${tagName}>`;
+    }
+    const textContent = element.textContent?.trim() || "";
+    const hasOnlyText = element.childNodes.length === 1 && element.childNodes[0].nodeType === 3;
+    if (hasOnlyText && textContent) {
+      return `${indent2}${openTag}${textContent}</${tagName}>`;
+    }
+    const children = Array.from(element.children);
+    if (children.length === 0) {
+      return `${indent2}${openTag}</${tagName}>`;
+    }
+    let result = `${indent2}${openTag}
+`;
+    for (const child of children) {
+      result += formatElement(child, depth + 1) + "\n";
+    }
+    result += `${indent2}</${tagName}>`;
+    return result;
+  }
+  return formatElement(doc.documentElement);
+}
+function createEmptyResult(originalLocale, locale) {
+  return {};
+}
+function pushNewFile(locale, translations, originalLocale) {
+  const skeleton = `<?xml version="1.0" encoding="utf-8"?>
+<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" version="1.2">
+  <file original="" source-language="${originalLocale}" target-language="${locale}" datatype="plaintext">
+    <header></header>
+    <body></body>
+  </file>
+</xliff>`;
+  const dom = new JSDOM2(skeleton, { contentType: "text/xml" });
+  const document = dom.window.document;
+  const bodyElement = document.querySelector("body");
+  Object.entries(translations).forEach(([key, value]) => {
+    const unit = document.createElement("trans-unit");
+    unit.setAttribute("id", key);
+    unit.setAttribute("resname", key);
+    unit.setAttribute("restype", "string");
+    unit.setAttribute("datatype", "plaintext");
+    const sourceElement = document.createElement("source");
+    setTextContent(sourceElement, key);
+    unit.appendChild(sourceElement);
+    const targetElement = document.createElement("target");
+    targetElement.setAttribute("state", value ? "translated" : "new");
+    setTextContent(targetElement, value);
+    unit.appendChild(targetElement);
+    bodyElement.appendChild(unit);
+  });
+  return serializeWithDeclaration(
+    dom,
+    '<?xml version="1.0" encoding="utf-8"?>'
+  );
 }
 
 // src/cli/loaders/xml.ts
@@ -9954,7 +10342,7 @@ async function renderHero2() {
 // package.json
 var package_default = {
   name: "lingo.dev",
-  version: "0.105.1",
+  version: "0.105.2",
   description: "Lingo.dev CLI",
   private: false,
   publishConfig: {