lingo.dev 0.117.1 → 0.117.3

package/build/cli.mjs

@@ -2084,14 +2084,180 @@ function createYamlLoader() {
       return YAML.parse(input2) || {};
     },
     async push(locale, payload, originalInput) {
-      return YAML.stringify(payload, {
-        lineWidth: -1,
-        defaultKeyType: getKeyType(originalInput),
-        defaultStringType: getStringType(originalInput)
-      });
+      if (!originalInput || !originalInput.trim()) {
+        return YAML.stringify(payload, {
+          lineWidth: -1,
+          defaultKeyType: "PLAIN",
+          defaultStringType: "PLAIN"
+        });
+      }
+      try {
+        const sourceDoc = YAML.parseDocument(originalInput);
+        const outputDoc = YAML.parseDocument(
+          YAML.stringify(payload, {
+            lineWidth: -1,
+            defaultKeyType: "PLAIN"
+          })
+        );
+        const isRootKeyFormat = detectRootKeyFormat(sourceDoc, outputDoc);
+        const metadata = extractQuotingMetadata(sourceDoc, isRootKeyFormat);
+        applyQuotingMetadata(outputDoc, metadata, isRootKeyFormat);
+        return outputDoc.toString({ lineWidth: -1 });
+      } catch (error) {
+        console.warn("Failed to preserve YAML formatting:", error);
+        return YAML.stringify(payload, {
+          lineWidth: -1,
+          defaultKeyType: getKeyType(originalInput),
+          defaultStringType: getStringType(originalInput)
+        });
+      }
     }
   });
 }
+function detectRootKeyFormat(sourceDoc, outputDoc) {
+  const sourceRoot = sourceDoc.contents;
+  const outputRoot = outputDoc.contents;
+  if (!isYAMLMap(sourceRoot) || !isYAMLMap(outputRoot)) {
+    return false;
+  }
+  const sourceMap = sourceRoot;
+  const outputMap = outputRoot;
+  if (!sourceMap.items || sourceMap.items.length !== 1 || !outputMap.items || outputMap.items.length !== 1) {
+    return false;
+  }
+  const sourceRootKey = getKeyValue(sourceMap.items[0].key);
+  const outputRootKey = getKeyValue(outputMap.items[0].key);
+  if (sourceRootKey !== outputRootKey && typeof sourceRootKey === "string" && typeof outputRootKey === "string") {
+    return true;
+  }
+  return false;
+}
+function extractQuotingMetadata(doc, skipRootKey) {
+  const metadata = {
+    keys: /* @__PURE__ */ new Map(),
+    values: /* @__PURE__ */ new Map()
+  };
+  const root = doc.contents;
+  if (!root) return metadata;
+  let startNode = root;
+  if (skipRootKey && isYAMLMap(root)) {
+    const rootMap = root;
+    if (rootMap.items && rootMap.items.length === 1) {
+      startNode = rootMap.items[0].value;
+    }
+  }
+  walkAndExtract(startNode, [], metadata);
+  return metadata;
+}
+function walkAndExtract(node, path19, metadata) {
+  if (isScalar(node)) {
+    if (node.type && node.type !== "PLAIN") {
+      metadata.values.set(path19.join("."), node.type);
+    }
+  } else if (isYAMLMap(node)) {
+    if (node.items && Array.isArray(node.items)) {
+      for (const pair of node.items) {
+        if (pair && pair.key) {
+          const key = getKeyValue(pair.key);
+          if (key !== null && key !== void 0) {
+            const keyPath = [...path19, String(key)].join(".");
+            if (pair.key.type && pair.key.type !== "PLAIN") {
+              metadata.keys.set(keyPath, pair.key.type);
+            }
+            if (pair.value) {
+              walkAndExtract(pair.value, [...path19, String(key)], metadata);
+            }
+          }
+        }
+      }
+    }
+  } else if (isYAMLSeq(node)) {
+    if (node.items && Array.isArray(node.items)) {
+      for (let i = 0; i < node.items.length; i++) {
+        if (node.items[i]) {
+          walkAndExtract(node.items[i], [...path19, String(i)], metadata);
+        }
+      }
+    }
+  }
+}
+function applyQuotingMetadata(doc, metadata, skipRootKey) {
+  const root = doc.contents;
+  if (!root) return;
+  let startNode = root;
+  if (skipRootKey && isYAMLMap(root)) {
+    const rootMap = root;
+    if (rootMap.items && rootMap.items.length === 1) {
+      startNode = rootMap.items[0].value;
+    }
+  }
+  walkAndApply(startNode, [], metadata);
+}
+function walkAndApply(node, path19, metadata) {
+  if (isScalar(node)) {
+    const pathKey = path19.join(".");
+    const quoteType = metadata.values.get(pathKey);
+    if (quoteType) {
+      node.type = quoteType;
+    }
+  } else if (isYAMLMap(node)) {
+    if (node.items && Array.isArray(node.items)) {
+      for (const pair of node.items) {
+        if (pair && pair.key) {
+          const key = getKeyValue(pair.key);
+          if (key !== null && key !== void 0) {
+            const keyPath = [...path19, String(key)].join(".");
+            const keyQuoteType = metadata.keys.get(keyPath);
+            if (keyQuoteType) {
+              pair.key.type = keyQuoteType;
+            }
+            if (pair.value) {
+              walkAndApply(pair.value, [...path19, String(key)], metadata);
+            }
+          }
+        }
+      }
+    }
+  } else if (isYAMLSeq(node)) {
+    if (node.items && Array.isArray(node.items)) {
+      for (let i = 0; i < node.items.length; i++) {
+        if (node.items[i]) {
+          walkAndApply(node.items[i], [...path19, String(i)], metadata);
+        }
+      }
+    }
+  }
+}
+function isScalar(node) {
+  if (node?.constructor?.name === "Scalar") {
+    return true;
+  }
+  return node && typeof node === "object" && "value" in node && ("type" in node || "format" in node);
+}
+function isYAMLMap(node) {
+  if (node?.constructor?.name === "YAMLMap") {
+    return true;
+  }
+  return node && typeof node === "object" && "items" in node && Array.isArray(node.items) && !("value" in node);
+}
+function isYAMLSeq(node) {
+  if (node?.constructor?.name === "YAMLSeq") {
+    return true;
+  }
+  return node && typeof node === "object" && "items" in node && Array.isArray(node.items) && !("type" in node) && !("value" in node);
+}
+function getKeyValue(key) {
+  if (key === null || key === void 0) {
+    return null;
+  }
+  if (typeof key === "object" && "value" in key) {
+    return key.value;
+  }
+  if (typeof key === "string" || typeof key === "number") {
+    return key;
+  }
+  return null;
+}
 function getKeyType(yamlString) {
   if (yamlString) {
     const lines = yamlString.split("\n");
@@ -13482,7 +13648,7 @@ async function renderHero2() {
 // package.json
 var package_default = {
   name: "lingo.dev",
-  version: "0.117.1",
+  version: "0.117.3",
   description: "Lingo.dev CLI",
   private: false,
   publishConfig: {