lingo.dev 0.117.8 → 0.117.10

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,
@@ -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 = [
@@ -4036,8 +4146,11 @@ function createMjmlLoader() {
   return createLoader({
     async pull(locale, input2) {
       const result = {};
+      if (!input2 || input2.trim() === "") {
+        return result;
+      }
       try {
-        const parsed = await parseStringPromise2(input2, {
+        const parsed = await parseStringPromise3(input2, {
           explicitArray: true,
           explicitChildren: true,
           preserveChildrenOrder: true,
@@ -4082,8 +4195,11 @@ function createMjmlLoader() {
       return result;
     },
     async push(locale, data, originalInput) {
+      if (!originalInput || originalInput.trim() === "") {
+        return originalInput || "";
+      }
       try {
-        const parsed = await parseStringPromise2(originalInput || "", {
+        const parsed = await parseStringPromise3(originalInput, {
           explicitArray: true,
           explicitChildren: true,
           preserveChildrenOrder: true,
@@ -4225,11 +4341,10 @@ function convertDomToXmlNode(domNode) {
   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;
+  return body;
 }
 function serializeElement2(node, indent2 = "") {
   if (!node) {
@@ -5865,7 +5980,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 +5989,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 +6007,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;
@@ -9746,6 +9861,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),
@@ -14473,7 +14600,7 @@ async function renderHero2() {
 // package.json
 var package_default = {
   name: "lingo.dev",
-  version: "0.117.8",
+  version: "0.117.10",
   description: "Lingo.dev CLI",
   private: false,
   publishConfig: {