@braze/sanity-plugin-ai-translation 0.2.51 → 0.2.53

package/dist/index.d.ts

@@ -446,6 +446,21 @@ declare interface TranslatableVTTCaptions {
   _originalMetadata: VTTCaptionMetadata[];
 }
 
+/**
+ * Special type to track transformed Wistia captions.
+ * This combines metadata separation for token efficiency with compact text format for translation.
+ */
+declare interface TranslatableWistiaCaptions {
+  _type: "translatable.wistia.captions";
+  translationText: string;
+  _originalMetadata: WistiaCaptionsMetadata;
+  _srtCues: Array<{
+    index: number;
+    startTime: string;
+    endTime: string;
+  }>;
+}
+
 /**
  * Schema for translation history
  *
@@ -497,4 +512,40 @@ export declare const vttCaptionTransform: FieldTransform<
   TranslatableVTTCaptions
 >;
 
+/**
+ * Represents a Wistia captions object with SRT content and metadata.
+ */
+declare interface WistiaCaptions {
+  captionContent?: string;
+  captionFileName?: string;
+  isoLanguage?: string;
+  captionUploadStatus?: string;
+  captionUploadMessage?: string;
+  [key: string]: string | undefined;
+}
+
+/**
+ * Wistia captions metadata without captionContent, used for preservation during translation.
+ */
+declare interface WistiaCaptionsMetadata {
+  captionFileName?: string;
+  isoLanguage?: string;
+  captionUploadStatus?: string;
+  captionUploadMessage?: string;
+  _originalIndex: number;
+  [key: string]: string | number | undefined;
+}
+
+/**
+ * Transform for handling Wistia captions in documents using SRT format.
+ * This stores metadata separately for token efficiency while formatting
+ * text content in a compact indexed format for better translation results.
+ *
+ * @public
+ */
+export declare const wistiaCaptionTransform: FieldTransform<
+  WistiaCaptions,
+  TranslatableWistiaCaptions
+>;
+
 export {};

package/dist/index.js

@@ -80,7 +80,9 @@ const isLoggingEnabled = () => process.env.NEXT_PUBLIC_SANITY_STUDIO_AI_TRANSLAT
 }, updateActiveTranslationJob = (documentId, job) => {
   const entry = activeTranslations.get(documentId);
   if (entry) {
-    const jobKey = `${job._id}_${job.language}`, existingJob = entry.state.translationJobs.get(jobKey), mergedJob = existingJob ? { ...existingJob, ...job } : job;
+    const jobKey = `${job._id}_${job.language}`, existingJob = entry.state.translationJobs.get(jobKey), jobWithDefinedValues = Object.fromEntries(
+      Object.entries(job).filter(([_, value]) => value !== void 0)
+    ), mergedJob = existingJob ? { ...existingJob, ...jobWithDefinedValues } : jobWithDefinedValues;
     entry.state.translationJobs.set(jobKey, mergedJob), notifySubscribers(entry);
   }
 }, getActiveTranslation = (documentId) => activeTranslations.get(documentId)?.state ?? null, subscribeToActiveTranslation = (documentId, callback) => {
@@ -1251,7 +1253,9 @@ function restoreTransforms({
         schemaType,
         document: translatedDocument
       };
-      devLog.debug("Restoring transform for field", { fieldPath, schemaType }), restoredObj[key] = transform.fromTranslatable(value, originalValue, context);
+      devLog.debug("Restoring transform for field", { fieldPath, schemaType });
+      const restoredValue = transform.fromTranslatable(value, originalValue, context);
+      restoredObj[key] = restoredValue;
     } else
       restoredObj[key] = restoreTransforms({
         translatedDocument: value,
@@ -1489,9 +1493,9 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
   }, modelPricing = pricing[model] || pricing["gpt-5"], cachedInputRate = model === "gpt-5.1" ? 0.125 / 1e6 : modelPricing.input;
   return Math.max(0, tokens.prompt - tokens.cached) * modelPricing.input + tokens.cached * cachedInputRate + tokens.completion * modelPricing.output + tokens.reasoning * modelPricing.reasoning;
 }, deserializeDocument = (originalDoc, reviewedText) => {
-  const parsed = parseReviewFormat(reviewedText), result = cloneDeep(originalDoc);
+  const parsed = parseReviewFormat(reviewedText, originalDoc), result = cloneDeep(originalDoc);
   return applyTextChanges(result, parsed), result;
-}, parseReviewFormat = (text) => {
+}, parseReviewFormat = (text, originalDoc) => {
   const root = [], stack = [], lines = text.split(`
 `);
   for (let i = 0; i < lines.length; i++) {
@@ -1524,8 +1528,16 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
       }
       const content = contentLines.join(`
 `);
-      let contentType = "translatable.vtt.captions";
-      (content.includes("<block") || content.includes("<span")) && (contentType = "translatable.richtext");
+      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");
       const node = {
         type: "field",
         name: fieldName,
@@ -1562,7 +1574,7 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
           parent && parent.children.push(node);
         } else
           root.push(node);
-      else if (attributes.type === "translatable.vtt.captions" || attributes.type === "translatable.richtext") {
+      else if (attributes.type && typeof attributes.type == "string" && attributes.type.startsWith("translatable.")) {
         const contentLines = [];
         for (i++; i < lines.length; ) {
           const currentLine = lines[i];
@@ -1624,14 +1636,13 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
       applyFieldChanges(doc, path, node);
     }
 }, applyFieldChanges = (doc, path, node) => {
-  if (node.attributes.type === "translatable.vtt.captions") {
-    const fieldValue = get(doc, path);
-    fieldValue && typeof fieldValue == "object" && fieldValue._type === "translatable.vtt.captions" && node.text && set(doc, [...path, "translationText"], node.text);
-    return;
-  }
-  if (node.attributes.type === "translatable.richtext") {
+  const nodeType = node.attributes.type;
+  if (typeof nodeType == "string" && nodeType.startsWith("translatable.")) {
     const fieldValue = get(doc, path);
-    fieldValue && typeof fieldValue == "object" && fieldValue._type === "translatable.richtext" && node.text && set(doc, [...path, "translationText"], node.text);
+    if (fieldValue && typeof fieldValue == "object" && fieldValue !== null) {
+      const fieldType = fieldValue._type;
+      typeof fieldType == "string" && fieldType === nodeType && node.text && set(doc, [...path, "translationText"], node.text);
+    }
     return;
   }
   if (node.attributes.type === "array") {
@@ -1719,12 +1730,9 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
       return;
     }
     if (isPlainObject(value)) {
-      if (value._type === "translatable.vtt.captions" && typeof value.translationText == "string") {
-        lines.push(`${indentStr}--- ${fieldName} ---`), lines.push(value.translationText), lines.push(`${indentStr}--- /${fieldName} ---`);
-        return;
-      }
-      if (value._type === "translatable.richtext" && typeof value.translationText == "string") {
-        lines.push(`${indentStr}--- ${fieldName} ---`), lines.push(value.translationText), lines.push(`${indentStr}--- /${fieldName} ---`);
+      const valueObj = value, valueType = valueObj._type, translationText = valueObj.translationText;
+      if (typeof valueType == "string" && valueType.startsWith("translatable.") && typeof translationText == "string") {
+        lines.push(`${indentStr}--- ${fieldName} ---`), lines.push(translationText), lines.push(`${indentStr}--- /${fieldName} ---`);
         return;
       }
       lines.push(`${indentStr}<field name="${fieldName}" type="object">`);
@@ -3799,6 +3807,284 @@ function deserializeVTTCaptionText(translationText, originalMetadata) {
     resultExample: result.length > 0 ? result[0] : null
   }), result;
 }
+const LOCALE_TO_ISO = {
+  // English variants
+  "en-us": "eng",
+  "en-US": "eng",
+  "en-gb": "eng",
+  "en-GB": "eng",
+  "en-ca": "eng",
+  "en-CA": "eng",
+  "en-au": "eng",
+  "en-AU": "eng",
+  // Spanish variants
+  es: "spa",
+  "es-es": "spa",
+  "es-ES": "spa",
+  "es-mx": "spa",
+  "es-MX": "spa",
+  // French variants
+  fr: "fra",
+  "fr-fr": "fra",
+  "fr-FR": "fra",
+  "fr-ca": "fra",
+  "fr-CA": "fra",
+  // German variants
+  de: "ger",
+  "de-de": "ger",
+  "de-DE": "ger",
+  "de-at": "ger",
+  "de-AT": "ger",
+  // Italian variants
+  it: "ita",
+  "it-it": "ita",
+  "it-IT": "ita",
+  // Portuguese variants
+  pt: "por",
+  "pt-br": "por",
+  "pt-BR": "por",
+  "pt-pt": "por",
+  "pt-PT": "por",
+  // Russian variants
+  ru: "rus",
+  "ru-ru": "rus",
+  "ru-RU": "rus",
+  // Japanese variants
+  ja: "jpn",
+  "ja-jp": "jpn",
+  "ja-JP": "jpn",
+  // Korean variants
+  ko: "kor",
+  "ko-kr": "kor",
+  "ko-KR": "kor",
+  // Chinese variants
+  zh: "chi",
+  "zh-cn": "chi",
+  "zh-CN": "chi",
+  "zh-tw": "chi",
+  "zh-TW": "chi",
+  "zh-hk": "chi",
+  "zh-HK": "chi"
+}, normalizeToIsoLanguageCode = (code) => {
+  const normalizedCode = code.toLowerCase();
+  return LOCALE_TO_ISO[normalizedCode];
+}, wistiaCaptionTransform = {
+  matcher: {
+    fieldName: "wistiaCaptions"
+  },
+  toTranslatable: (wistiaCaptions, context) => {
+    if (devLog.info("Wistia captions toTranslatable - input:", {
+      fieldPath: context.fieldPath,
+      hasCaptionContent: !!wistiaCaptions?.captionContent,
+      captionContentLength: wistiaCaptions?.captionContent?.length ?? 0,
+      isoLanguage: wistiaCaptions?.isoLanguage
+    }), !wistiaCaptions || !wistiaCaptions.captionContent)
+      return devLog.debug("Wistia caption field is missing or has no content, returning empty transform", {
+        fieldPath: context.fieldPath,
+        value: wistiaCaptions
+      }), {
+        _type: "translatable.wistia.captions",
+        translationText: "",
+        _originalMetadata: {
+          captionFileName: wistiaCaptions?.captionFileName,
+          isoLanguage: wistiaCaptions?.isoLanguage,
+          captionUploadStatus: wistiaCaptions?.captionUploadStatus,
+          captionUploadMessage: wistiaCaptions?.captionUploadMessage,
+          _originalIndex: 0
+        },
+        _srtCues: []
+      };
+    devLog.info("Applying Wistia caption transform", {
+      fieldPath: context.fieldPath,
+      captionContentPreview: wistiaCaptions.captionContent.substring(0, 200)
+    });
+    const srtCues = parseSRTContent(wistiaCaptions.captionContent);
+    devLog.debug("Parsed SRT cues:", {
+      fieldPath: context.fieldPath,
+      cueCount: srtCues.length,
+      firstCue: srtCues.length > 0 ? srtCues[0] : null
+    });
+    const translationText = serializeWistiaCaptionText(srtCues), originalMetadata = {
+      captionFileName: wistiaCaptions.captionFileName,
+      isoLanguage: wistiaCaptions.isoLanguage,
+      captionUploadStatus: wistiaCaptions.captionUploadStatus,
+      captionUploadMessage: wistiaCaptions.captionUploadMessage,
+      _originalIndex: 0
+    }, srtCuesMetadata = srtCues.map((cue) => ({
+      index: cue.index,
+      startTime: cue.startTime,
+      endTime: cue.endTime
+    }));
+    return devLog.info("Wistia captions serialized:", {
+      fieldPath: context.fieldPath,
+      translationTextLength: translationText.length,
+      translationTextPreview: translationText.substring(0, 200) + (translationText.length > 200 ? "..." : ""),
+      cueCount: srtCues.length
+    }), {
+      _type: "translatable.wistia.captions",
+      translationText,
+      _originalMetadata: originalMetadata,
+      _srtCues: srtCuesMetadata
+    };
+  },
+  fromTranslatable: (translatedValue, originalValue, context) => {
+    if (devLog.info("Wistia captions fromTranslatable - input:", {
+      fieldPath: context.fieldPath,
+      valueType: typeof translatedValue,
+      isCorrectType: translatedValue._type === "translatable.wistia.captions",
+      hasText: !!translatedValue.translationText,
+      hasMetadata: !!translatedValue._originalMetadata,
+      hasCues: Array.isArray(translatedValue._srtCues)
+    }), !translatedValue || translatedValue._type !== "translatable.wistia.captions" || !translatedValue._originalMetadata || !Array.isArray(translatedValue._srtCues))
+      return devLog.debug("Value is not a translatable Wistia caption object, returning original", {
+        fieldPath: context.fieldPath,
+        valueType: typeof translatedValue,
+        translatedValue
+      }), originalValue || {};
+    devLog.info("Processing translated Wistia captions", {
+      fieldPath: context.fieldPath,
+      cueCount: translatedValue._srtCues.length
+    });
+    const { translationText, _originalMetadata, _srtCues } = translatedValue;
+    devLog.info("Wistia captions translationText:", {
+      fieldPath: context.fieldPath,
+      translationTextLength: translationText.length,
+      translationTextPreview: translationText.substring(0, 200) + (translationText.length > 200 ? "..." : "")
+    });
+    const reconstructedCaptionContent = deserializeWistiaCaptionText(translationText, _srtCues), documentLanguage = getDocumentLanguage(context.document);
+    let updatedIsoLanguage = _originalMetadata.isoLanguage;
+    if (documentLanguage) {
+      const isoCode = normalizeToIsoLanguageCode(documentLanguage);
+      isoCode ? (updatedIsoLanguage = isoCode, devLog.debug("Updated isoLanguage based on document language", {
+        fieldPath: context.fieldPath,
+        documentLanguage,
+        isoCode
+      })) : devLog.debug("Could not convert document language to ISO code, preserving original", {
+        fieldPath: context.fieldPath,
+        documentLanguage,
+        originalIsoLanguage: _originalMetadata.isoLanguage
+      });
+    } else
+      devLog.debug("Document language field not found, preserving original isoLanguage", {
+        fieldPath: context.fieldPath,
+        originalIsoLanguage: _originalMetadata.isoLanguage
+      });
+    const result = {
+      captionContent: reconstructedCaptionContent,
+      captionFileName: _originalMetadata.captionFileName,
+      isoLanguage: updatedIsoLanguage,
+      captionUploadStatus: _originalMetadata.captionUploadStatus,
+      captionUploadMessage: _originalMetadata.captionUploadMessage
+    };
+    return devLog.info("Wistia captions final result:", {
+      fieldPath: context.fieldPath,
+      hasCaptionContent: !!result.captionContent,
+      captionContentLength: result.captionContent?.length ?? 0,
+      isoLanguage: result.isoLanguage
+    }), result;
+  }
+};
+function parseSRTContent(content) {
+  if (devLog.debug("parseSRTContent - input:", {
+    contentLength: content.length,
+    contentPreview: content.substring(0, 100) + (content.length > 100 ? "..." : "")
+  }), !content || content.trim() === "")
+    return [];
+  let normalizedContent = content;
+  content.includes("\\n") && !content.includes(`
+`) && (normalizedContent = content.replace(/\\n/g, `
+`), devLog.debug("Unescaped newlines in SRT content", {
+    originalLength: content.length,
+    normalizedLength: normalizedContent.length
+  }));
+  const cues = [], cueBlocks = normalizedContent.split(/\n\s*\n/);
+  for (const block of cueBlocks) {
+    const lines = block.trim().split(`
+`);
+    if (lines.length < 3)
+      continue;
+    const cueNumber = Number.parseInt(lines[0].trim(), 10);
+    if (Number.isNaN(cueNumber)) {
+      devLog.warn("Invalid SRT cue number", { line: lines[0] });
+      continue;
+    }
+    const timestampLine = lines[1].trim(), timestampMatch = timestampLine.match(/^(\d{2}:\d{2}:\d{2}[,.]\d{3})\s*-->\s*(\d{2}:\d{2}:\d{2}[,.]\d{3})$/);
+    if (!timestampMatch) {
+      devLog.warn("Invalid SRT timestamp format", { line: timestampLine });
+      continue;
+    }
+    const startTime = timestampMatch[1].replace(".", ","), endTime = timestampMatch[2].replace(".", ","), text = lines.slice(2).join(`
+`).trim();
+    text && cues.push({
+      index: cueNumber,
+      startTime,
+      endTime,
+      text
+    });
+  }
+  return devLog.debug("parseSRTContent - output:", {
+    cueCount: cues.length,
+    firstCue: cues.length > 0 ? cues[0] : null
+  }), cues;
+}
+function serializeWistiaCaptionText(cues) {
+  if (devLog.debug("serializeWistiaCaptionText - input:", {
+    cuesCount: cues.length,
+    firstCue: cues.length > 0 ? cues[0] : null
+  }), !Array.isArray(cues) || cues.length === 0)
+    return "";
+  const result = cues.map((cue) => (devLog.debug(`Processing cue ${cue.index}:`, {
+    text: cue.text,
+    hasText: typeof cue.text == "string"
+  }), `[${cue.index}] ${cue.text}`)).join(`
+`);
+  return devLog.debug("serializeWistiaCaptionText - output:", {
+    resultLength: result.length,
+    resultPreview: result.substring(0, 100) + (result.length > 100 ? "..." : "")
+  }), result;
+}
+function deserializeWistiaCaptionText(translationText, srtCuesMetadata) {
+  if (devLog.debug("deserializeWistiaCaptionText - input:", {
+    translationTextLength: translationText.length,
+    translationTextPreview: translationText.substring(0, 100) + (translationText.length > 100 ? "..." : ""),
+    metadataCount: srtCuesMetadata.length,
+    metadataExample: srtCuesMetadata.length > 0 ? srtCuesMetadata[0] : null
+  }), !translationText || translationText.trim() === "")
+    return "";
+  const result = [], lines = translationText.split(`
+`), lineRegex = /^\[(\d+)\]\s*(.*)$/, metadataByIndex = /* @__PURE__ */ new Map();
+  for (const metadata of srtCuesMetadata)
+    metadataByIndex.set(metadata.index, { startTime: metadata.startTime, endTime: metadata.endTime });
+  for (const line of lines) {
+    const match = line.match(lineRegex);
+    if (!match) {
+      devLog.warn("Failed to parse caption line", { line });
+      continue;
+    }
+    const index = Number.parseInt(match[1], 10), text = match[2];
+    devLog.debug("Found caption:", {
+      index,
+      text
+    });
+    const metadata = metadataByIndex.get(index);
+    metadata ? (devLog.debug(`Found matching metadata for index ${index}`), result.push(`${index}`), result.push(`${metadata.startTime} --> ${metadata.endTime}`), result.push(text), result.push("")) : devLog.warn("Missing metadata for caption", { index });
+  }
+  result.length > 0 && result[result.length - 1] === "" && result.pop();
+  const reconstructed = result.join(`
+`);
+  return devLog.debug("deserializeWistiaCaptionText - output:", {
+    resultLength: reconstructed.length,
+    resultPreview: reconstructed.substring(0, 200) + (reconstructed.length > 200 ? "..." : "")
+  }), reconstructed;
+}
+function getDocumentLanguage(document) {
+  if (!document || typeof document != "object")
+    return;
+  const languageFieldNames = ["language", "lang", "locale"];
+  for (const fieldName of languageFieldNames)
+    if (fieldName in document && typeof document[fieldName] == "string")
+      return document[fieldName];
+}
 const aiTranslationPlugin = definePlugin((config) => (config.fieldTransforms?.length && (devLog.info(`Registering ${config.fieldTransforms.length} custom field transforms`), config.fieldTransforms.forEach((transform) => {
   globalTransformRegistry.register(transform);
 })), {
@@ -3818,6 +4104,7 @@ export {
   restoreExcludedFields,
   richTextTransform,
   translationHistorySchema,
-  vttCaptionTransform
+  vttCaptionTransform,
+  wistiaCaptionTransform
 };
 //# sourceMappingURL=index.js.map