lingo.dev 0.117.6 → 0.117.7

package/build/cli.cjs

@@ -3497,7 +3497,7 @@ function createPullOutputCleaner() {
 }
 
 // src/cli/loaders/html.ts
-var _htmlparser2 = require('htmlparser2'); var htmlparser2 = _interopRequireWildcard(_htmlparser2);
+var _htmlparser2 = require('htmlparser2'); var htmlparser2 = _interopRequireWildcard(_htmlparser2); var htmlparser22 = _interopRequireWildcard(_htmlparser2);
 var _domhandler = require('domhandler');
 var _domutils = require('domutils'); var domutils = _interopRequireWildcard(_domutils);
 var _domserializer = require('dom-serializer'); var DomSerializer = _interopRequireWildcard(_domserializer);
@@ -3602,7 +3602,7 @@ function createHtmlLoader() {
     // <title> should be treated as a block element for translation
   ]);
   const UNLOCALIZABLE_TAGS = /* @__PURE__ */ new Set(["script", "style"]);
-  const LOCALIZABLE_ATTRIBUTES = {
+  const LOCALIZABLE_ATTRIBUTES2 = {
     meta: ["content"],
     img: ["alt", "title"],
     input: ["placeholder", "title"],
@@ -3648,12 +3648,12 @@ function createHtmlLoader() {
         }
         return hasTranslatableContent(element);
       }
-      function getInnerHTML(element) {
+      function getInnerHTML2(element) {
         return element.children.map((child) => DomSerializer.default(child, { encodeEntities: false })).join("");
       }
       function extractAttributes(element, path19) {
         const tagName = element.name.toLowerCase();
-        const attrs = LOCALIZABLE_ATTRIBUTES[tagName];
+        const attrs = LOCALIZABLE_ATTRIBUTES2[tagName];
         if (!attrs) return;
         for (const attr of attrs) {
           const value = _optionalChain([element, 'access', _143 => _143.attribs, 'optionalAccess', _144 => _144[attr]]);
@@ -3670,14 +3670,14 @@ function createHtmlLoader() {
         extractAttributes(element, path19);
         const tagName = element.name.toLowerCase();
         if (BLOCK_ELEMENTS.has(tagName) && isLeafBlock(element)) {
-          const content = getInnerHTML(element).trim();
+          const content = getInnerHTML2(element).trim();
           if (content) {
             result[path19] = content;
           }
           return;
         }
         if (PHRASING_ELEMENTS.has(tagName) && hasTranslatableContent(element)) {
-          const content = getInnerHTML(element).trim();
+          const content = getInnerHTML2(element).trim();
           if (content) {
             result[path19] = content;
           }
@@ -4008,6 +4008,264 @@ function applyTranslations(node, path19, data, pathMap) {
   }
 }
 
+// src/cli/loaders/mjml.ts
+
+
+
+var LOCALIZABLE_COMPONENTS = [
+  "mj-text",
+  "mj-button",
+  "mj-title",
+  "mj-preview",
+  "mj-navbar-link",
+  "mj-accordion-title",
+  "mj-accordion-text",
+  "p",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "li"
+];
+var LOCALIZABLE_ATTRIBUTES = {
+  "mj-image": ["alt", "title"],
+  "mj-button": ["title", "aria-label"],
+  "mj-social-element": ["title", "alt"],
+  "img": ["alt", "title"],
+  "a": ["title", "aria-label"]
+};
+function createMjmlLoader() {
+  return createLoader({
+    async pull(locale, input2) {
+      const result = {};
+      try {
+        const parsed = await _xml2js.parseStringPromise.call(void 0, input2, {
+          explicitArray: true,
+          explicitChildren: true,
+          preserveChildrenOrder: true,
+          charsAsChildren: true,
+          includeWhiteChars: true,
+          mergeAttrs: false,
+          trim: false,
+          attrkey: "$",
+          charkey: "_",
+          childkey: "$$"
+        });
+        if (!parsed || typeof parsed !== "object") {
+          console.error("Failed to parse MJML: invalid parsed structure");
+          return result;
+        }
+        const rootKey = Object.keys(parsed).find((key) => !key.startsWith("_") && !key.startsWith("$"));
+        const rootNode = rootKey ? parsed[rootKey] : parsed;
+        const rootPath = rootNode["#name"] || rootKey || "";
+        traverse(rootNode, (node, path19, componentName) => {
+          if (typeof node !== "object") return;
+          const localizableAttrs = LOCALIZABLE_ATTRIBUTES[componentName];
+          if (localizableAttrs && node.$) {
+            localizableAttrs.forEach((attr) => {
+              const attrValue = node.$[attr];
+              if (attrValue) {
+                result[`${path19}#${attr}`] = attrValue;
+              }
+            });
+          }
+          if (LOCALIZABLE_COMPONENTS.includes(componentName)) {
+            const innerHTML = getInnerHTML(node);
+            if (innerHTML) {
+              result[path19] = innerHTML;
+              return "SKIP_CHILDREN";
+            }
+          }
+          return void 0;
+        }, rootPath);
+      } catch (error) {
+        console.error("Failed to parse MJML:", error);
+      }
+      return result;
+    },
+    async push(locale, data, originalInput) {
+      try {
+        const parsed = await _xml2js.parseStringPromise.call(void 0, originalInput || "", {
+          explicitArray: true,
+          explicitChildren: true,
+          preserveChildrenOrder: true,
+          charsAsChildren: true,
+          includeWhiteChars: true,
+          mergeAttrs: false,
+          trim: false,
+          attrkey: "$",
+          charkey: "_",
+          childkey: "$$"
+        });
+        if (!parsed || typeof parsed !== "object") {
+          console.error("Failed to parse MJML for push: invalid parsed structure");
+          return originalInput || "";
+        }
+        const rootKey = Object.keys(parsed).find((key) => !key.startsWith("_") && !key.startsWith("$"));
+        const rootNode = rootKey ? parsed[rootKey] : parsed;
+        const rootPath = rootNode["#name"] || rootKey || "";
+        traverse(rootNode, (node, path19, componentName) => {
+          if (typeof node !== "object") return;
+          const localizableAttrs = LOCALIZABLE_ATTRIBUTES[componentName];
+          if (localizableAttrs && node.$) {
+            localizableAttrs.forEach((attr) => {
+              const attrKey = `${path19}#${attr}`;
+              if (data[attrKey] !== void 0) {
+                node.$[attr] = data[attrKey];
+              }
+            });
+          }
+          if (LOCALIZABLE_COMPONENTS.includes(componentName) && data[path19]) {
+            setInnerHTML(node, data[path19]);
+            return "SKIP_CHILDREN";
+          }
+          return void 0;
+        }, rootPath);
+        return serializeMjml(parsed);
+      } catch (error) {
+        console.error("Failed to build MJML:", error);
+        return "";
+      }
+    }
+  });
+}
+function traverse(node, visitor, path19 = "") {
+  if (!node || typeof node !== "object") {
+    return;
+  }
+  const children = node.$$;
+  if (!Array.isArray(children)) {
+    return;
+  }
+  const elementCounts = /* @__PURE__ */ new Map();
+  children.forEach((child) => {
+    const elementName = child["#name"];
+    if (!elementName || elementName.startsWith("__")) {
+      return;
+    }
+    const currentIndex = elementCounts.get(elementName) || 0;
+    elementCounts.set(elementName, currentIndex + 1);
+    const currentPath = path19 ? `${path19}/${elementName}/${currentIndex}` : `${elementName}/${currentIndex}`;
+    const result = visitor(child, currentPath, elementName);
+    if (result !== "SKIP_CHILDREN") {
+      traverse(child, visitor, currentPath);
+    }
+  });
+}
+function getInnerHTML(node) {
+  if (!node.$$ || !Array.isArray(node.$$)) {
+    return null;
+  }
+  let html = "";
+  node.$$.forEach((child) => {
+    html += serializeXmlNode(child);
+  });
+  return html.trim() || null;
+}
+function setInnerHTML(node, htmlContent) {
+  const handler = new (0, _domhandler.DomHandler)();
+  const parser = new htmlparser22.Parser(handler);
+  parser.write(htmlContent);
+  parser.end();
+  const newChildren = [];
+  for (const domNode of handler.dom) {
+    const xmlNode = convertDomToXmlNode(domNode);
+    if (xmlNode) {
+      newChildren.push(xmlNode);
+    }
+  }
+  node.$$ = newChildren;
+  node._ = htmlContent;
+}
+function serializeXmlNode(node) {
+  const name = node["#name"];
+  if (name === "__text__") {
+    return node._ || "";
+  }
+  if (name === "__cdata") {
+    return `<![CDATA[${node._ || ""}]]>`;
+  }
+  if (!name || name.startsWith("__")) {
+    return "";
+  }
+  const attrs = 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}>`;
+    }
+    return `<${name}${attrString} />`;
+  }
+  const childContent = children.map(serializeXmlNode).join("");
+  return `<${name}${attrString}>${childContent}</${name}>`;
+}
+function convertDomToXmlNode(domNode) {
+  if (domNode.type === "text") {
+    return {
+      "#name": "__text__",
+      "_": domNode.data
+    };
+  }
+  if (domNode.type === "tag") {
+    const xmlNode = {
+      "#name": domNode.name,
+      "$": domNode.attribs || {},
+      "$$": []
+    };
+    if (domNode.children && domNode.children.length > 0) {
+      for (const child of domNode.children) {
+        const xmlChild = convertDomToXmlNode(child);
+        if (xmlChild) {
+          xmlNode.$$.push(xmlChild);
+        }
+      }
+    }
+    return xmlNode;
+  }
+  return null;
+}
+function serializeMjml(parsed) {
+  const xmlDec = '<?xml version="1.0" encoding="UTF-8"?>\n';
+  const rootKey = Object.keys(parsed).find((key) => !key.startsWith("_") && !key.startsWith("$"));
+  const rootNode = rootKey ? parsed[rootKey] : parsed;
+  const body = serializeElement2(rootNode);
+  return xmlDec + body;
+}
+function serializeElement2(node, indent2 = "") {
+  if (!node) {
+    return "";
+  }
+  const name = _nullishCoalesce(node["#name"], () => ( "mjml"));
+  if (name === "__text__") {
+    return _nullishCoalesce(node._, () => ( ""));
+  }
+  if (name === "__cdata") {
+    return `<![CDATA[${_nullishCoalesce(node._, () => ( ""))}]]>`;
+  }
+  if (name === "__comment__") {
+    return `<!--${_nullishCoalesce(node._, () => ( ""))}-->`;
+  }
+  const attributes = _nullishCoalesce(node.$, () => ( {}));
+  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 = _nullishCoalesce(node._, () => ( ""));
+    if (textContent2) {
+      return `${indent2}<${name}${attrString}>${textContent2}</${name}>`;
+    }
+    return `${indent2}<${name}${attrString} />`;
+  }
+  const childContent = children.map((child) => serializeElement2(child, indent2)).join("");
+  return `${indent2}<${name}${attrString}>${childContent}</${name}>`;
+}
+function escapeAttributeValue2(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/'/g, "&apos;");
+}
+
 // src/cli/loaders/properties.ts
 function createPropertiesLoader() {
   return createLoader({
@@ -4271,7 +4529,7 @@ function escapeString(str) {
 }
 
 // src/cli/loaders/xcode-strings/parser.ts
-var Parser2 = class {
+var Parser3 = class {
   
   
   constructor(tokens) {
@@ -4344,7 +4602,7 @@ function createXcodeStringsLoader() {
     async pull(locale, input2) {
       const tokenizer = new Tokenizer(input2);
       const tokens = tokenizer.tokenize();
-      const parser = new Parser2(tokens);
+      const parser = new Parser3(tokens);
       const result = parser.parse();
       return result;
     },
@@ -6731,7 +6989,7 @@ function resolveCjsExport(mod, name = "module") {
 }
 
 // src/cli/loaders/typescript/index.ts
-var traverse = resolveCjsExport(_traverse2.default, "@babel/traverse");
+var traverse2 = resolveCjsExport(_traverse2.default, "@babel/traverse");
 var generate = resolveCjsExport(_generator2.default, "@babel/generator");
 function createTypescriptLoader() {
   return createLoader({
@@ -6764,7 +7022,7 @@ function parseTypeScript(input2) {
 }
 function extractStringsFromDefaultExport(ast) {
   let extracted = {};
-  traverse(ast, {
+  traverse2(ast, {
     ExportDefaultDeclaration(path19) {
       const { declaration } = path19.node;
       const decl = unwrapTSAsExpression(declaration);
@@ -6837,7 +7095,7 @@ function arrayExpressionToArray(arrayExpression) {
 }
 function updateStringsInDefaultExport(ast, data) {
   let modified = false;
-  traverse(ast, {
+  traverse2(ast, {
     ExportDefaultDeclaration(path19) {
       const { declaration } = path19.node;
       const decl = unwrapTSAsExpression(declaration);
@@ -9254,6 +9512,17 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys,
         createSyncLoader(),
         createUnlocalizableLoader(options.returnUnlocalizedKeys)
       );
+    case "mjml":
+      return composeLoaders(
+        createTextFileLoader(bucketPathPattern),
+        createFormatterLoader(options.formatter, "html", bucketPathPattern),
+        createLockedPatternsLoader(lockedPatterns),
+        createMjmlLoader(),
+        createLockedKeysLoader(lockedKeys || []),
+        createIgnoredKeysLoader(ignoredKeys || []),
+        createSyncLoader(),
+        createUnlocalizableLoader(options.returnUnlocalizedKeys)
+      );
     case "po":
       return composeLoaders(
         createTextFileLoader(bucketPathPattern),
@@ -13836,7 +14105,7 @@ async function renderHero2() {
 // package.json
 var package_default = {
   name: "lingo.dev",
-  version: "0.117.6",
+  version: "0.117.7",
   description: "Lingo.dev CLI",
   private: false,
   publishConfig: {