@braze/sanity-plugin-ai-translation 0.2.64 → 0.2.66

package/dist/index.js

@@ -6,6 +6,7 @@ import defaults from "lodash.defaults";
 import { Card, Stack, Flex, Text, Box, Heading, Button, Spinner, Inline, Checkbox, Grid, Radio, TextInput, Badge, Select, Label, Code, Tooltip } from "@sanity/ui";
 import { toPlainText } from "@portabletext/react";
 import { uuid } from "@sanity/uuid";
+import { XMLParser } from "fast-xml-parser";
 import cloneDeep from "lodash.clonedeep";
 import get from "lodash.get";
 import set from "lodash.set";
@@ -1539,7 +1540,7 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
     cleanedLength: cleanedText.length,
     preview: cleanedText.substring(0, 500)
   });
-  const parsed = parseReviewFormat(cleanedText, originalDoc);
+  const parsed = parseResponseToNodes(cleanedText, originalDoc);
   devLog.debug("Parsed response structure", {
     rootNodeCount: parsed.length,
     rootNodeNames: parsed.map((n) => n.type === "field" && n.name ? n.name : "unknown")
@@ -1561,7 +1562,118 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
     codeBlocksRemoved,
     preview: cleaned.trim().substring(0, 200)
   }), cleaned.trim();
-}, parseReviewFormat = (text, originalDoc) => {
+}, TAG_NAMES = ["field", "block", "span"], looksLikeXmlResponse = (text) => TAG_NAMES.some((tag) => text.includes(`<${tag}`));
+function parseCompactFormatSections(text, originalDoc) {
+  const nodes = [], lines = text.split(`
+`), compactStartRegex = /^---\s+(\w+)\s+---$/;
+  for (let i = 0; i < lines.length; i++) {
+    const match = lines[i].trim().match(compactStartRegex);
+    if (!match) continue;
+    const fieldName = match[1], contentLines = [];
+    for (i++; i < lines.length; ) {
+      const currentLine = lines[i];
+      if (currentLine.trim().match(new RegExp(`^---\\s+/${fieldName}\\s+---$`)))
+        break;
+      contentLines.push(currentLine), i++;
+    }
+    const content = contentLines.join(`
+`);
+    let contentType;
+    try {
+      const fieldValue = get(originalDoc, [fieldName]);
+      if (fieldValue && typeof fieldValue == "object" && fieldValue !== null) {
+        const fieldType = fieldValue._type;
+        typeof fieldType == "string" && fieldType.startsWith("translatable.") && (contentType = fieldType);
+      }
+    } catch {
+    }
+    contentType || (content.includes("<block") || content.includes("<span") ? contentType = "translatable.richtext" : contentType = "translatable.vtt.captions"), nodes.push({
+      type: "field",
+      name: fieldName,
+      text: content,
+      attributes: { type: contentType },
+      children: []
+    });
+  }
+  return nodes;
+}
+const parseResponseToNodes = (text, originalDoc) => {
+  if (looksLikeXmlResponse(text))
+    try {
+      const wrapped = `<root>${text}</root>`, parsed = new XMLParser({
+        ignoreAttributes: !1,
+        attributeNamePrefix: "@_",
+        textNodeName: "#text",
+        parseTagValue: !1,
+        trimValues: !1,
+        // preserve exact whitespace in text (e.g. trailing space in spans)
+        isArray: (tagName) => TAG_NAMES.includes(tagName)
+      }).parse(wrapped);
+      if (parsed && typeof parsed == "object" && parsed.root) {
+        const xmlNodes = convertXmlObjectToParsedNodes(parsed.root), compactNodes = parseCompactFormatSections(text, originalDoc);
+        if (xmlNodes.length > 0 || compactNodes.length > 0) {
+          const merged = [...xmlNodes, ...compactNodes];
+          return devLog.debug("Parsed response with XML parser + compact sections", {
+            xmlNodeCount: xmlNodes.length,
+            compactNodeCount: compactNodes.length,
+            total: merged.length
+          }), merged;
+        }
+      }
+    } catch (err) {
+      devLog.warn("XML parse failed, falling back to regex parser", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  return parseReviewFormat(text, originalDoc);
+};
+function normalizeToArray(value) {
+  return Array.isArray(value) ? value : value != null && typeof value == "object" ? [value] : [];
+}
+function convertXmlObjectToParsedNodes(root) {
+  const result = [];
+  for (const tagName of TAG_NAMES) {
+    const raw = root[tagName];
+    if (raw !== void 0) {
+      for (const item of normalizeToArray(raw))
+        if (item != null && typeof item == "object") {
+          const node = convertXmlElementToParsedNode(item, tagName);
+          node && result.push(node);
+        }
+    }
+  }
+  return result;
+}
+function convertXmlElementToParsedNode(obj, tagName) {
+  const attributes = {};
+  for (const [key, value] of Object.entries(obj))
+    if (key.startsWith("@_")) {
+      const attrName = key.slice(2);
+      attributes[attrName] = value != null ? String(value) : "";
+    }
+  let text;
+  const textVal = obj["#text"];
+  textVal != null && (text = typeof textVal == "string" ? textVal : String(textVal));
+  const children = [];
+  for (const childTag of TAG_NAMES) {
+    const raw = obj[childTag];
+    if (raw !== void 0) {
+      for (const item of normalizeToArray(raw))
+        if (item != null && typeof item == "object") {
+          const child = convertXmlElementToParsedNode(item, childTag);
+          child && children.push(child);
+        }
+    }
+  }
+  return {
+    type: tagName,
+    name: attributes.name,
+    text: text !== void 0 && text !== "" ? unescapeXml(text) : void 0,
+    attributes,
+    children
+  };
+}
+const parseReviewFormat = (text, originalDoc) => {
   const root = [], stack = [], lines = text.split(`
 `);
   devLog.debug("Parsing response text", {
@@ -1897,10 +2009,22 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
     });
     return;
   }
-  node.text !== void 0 && !node.attributes.readonly && (get(doc, path) !== void 0 ? set(doc, path, node.text) : devLog.debug("Skipping field not present in original document", {
-    path: path.join("."),
-    attemptedValue: node.text
-  }));
+  if (node.text !== void 0 && !node.attributes.readonly) {
+    const existingValue = get(doc, path);
+    if (existingValue === void 0)
+      devLog.debug("Skipping field not present in original document", {
+        path: path.join("."),
+        attemptedValue: node.text
+      });
+    else if (typeof existingValue == "string") {
+      const value = path.length === 1 ? node.text.trim() : node.text;
+      set(doc, path, value);
+    } else
+      devLog.warn("Skipping text apply at path where value is not a string (prevents structure corruption)", {
+        path: path.join("."),
+        actualType: typeof existingValue
+      });
+  }
 }, applyBlockChanges = (block, blockNode) => {
   if (blockNode.attributes._key && block._key !== blockNode.attributes._key) {
     devLog.warn("Block key mismatch, skipping", {