@smartcat/sanity-plugin 1.2.1 → 1.3.0

package/src/tool/ProjectView.tsx

@@ -17,6 +17,9 @@ import {
   Flex,
   Heading,
   Inline,
+  Menu,
+  MenuButton,
+  MenuItem,
   Spinner,
   Stack,
   Text,
@@ -33,6 +36,7 @@ import {
   SyncIcon,
   RemoveCircleIcon,
   JsonIcon,
+  ChevronDownIcon,
 } from '@sanity/icons'
 import styled, {css, keyframes} from 'styled-components'
 import {API_VERSION} from '../lib/constants'
@@ -158,10 +162,16 @@ const CodeArea = styled.textarea`
   tab-size: 2;
 `
 
+/** Target-locale siblings of a document-level item, via translation.metadata. */
+const VIEW_SIBLINGS_QUERY = `*[_type == "translation.metadata" && references($id)][0].translations[]{"language": _key, "doc": value->}`
+
 /**
- * Builds the LocJSON the export would produce for an item — same field selection
- * and serialize options as {@link prepareExport} — and shows it (pretty-printed)
- * in a read-only modal, for inspecting exactly what gets sent to Smartcat.
+ * Dropdown that builds the LocJSON the export would produce for an item — same
+ * field selection and serialize options as {@link prepareExport} — and shows it
+ * (pretty-printed) in a read-only modal. Offers "Source only" (what a plain
+ * export sends) plus "Source + <language>" for each target language: the
+ * bilingual file the send-existing flow would upload for that language, so you
+ * can inspect exactly what goes to Smartcat per language.
  */
 function ViewLocjsonButton(props: {
   docId: string
@@ -173,45 +183,80 @@ function ViewLocjsonButton(props: {
   sourceLanguage: string
   documentI18nLanguageField: string
   fieldI18nLanguageField: string
+  /** Project target languages (Sanity locale ids). */
+  targetLanguages: string[]
+  /** Configured languages (for titles + Smartcat codes). */
+  languages: SmartcatLanguage[]
 }) {
-  const {docId, type, sourceIsPublished, client, schema, sourceLanguage, documentI18nLanguageField, fieldI18nLanguageField} = props
+  const {docId, type, sourceIsPublished, client, schema, sourceLanguage, documentI18nLanguageField, fieldI18nLanguageField, targetLanguages, languages} = props
   const [open, setOpen] = useState(false)
   const [content, setContent] = useState<string | null>(null)
   const [filename, setFilename] = useState<string | null>(null)
+  const [title, setTitle] = useState<string>('Source only')
   const [error, setError] = useState<string | null>(null)
 
-  const build = useCallback(async () => {
-    setOpen(true)
-    setContent(null)
-    setFilename(null)
-    setError(null)
-    try {
-      // Resolve the same version the export will send: the draft (fallback to
-      // published) unless the item was added from the published perspective.
-      const raw = (await client.fetch(
-        sourceIsPublished
-          ? '*[_id == $id][0]'
-          : 'coalesce(*[_id == "drafts." + $id][0], *[_id == $id][0])',
-        {id: docId},
-      )) as (Record<string, unknown> & {_id: string}) | null
-      if (!raw) throw new Error(`Document not found: ${docId}`)
-      const isDraft = typeof raw._id === 'string' && raw._id.startsWith('drafts.')
-      // Serialize under the canonical (bare) id, matching the export.
-      const doc = isDraft ? {...raw, _id: docId} : raw
-      const fields = getTranslatableFields(schema.get(type), {exclude: [documentI18nLanguageField]})
-      const locjson = serializeToLocjson(doc as never, fields, {
-        sourceLanguage,
-        fieldLanguageKey: fieldI18nLanguageField,
-      })
-      // Same name the export sends to Smartcat; the last path segment is the
-      // file's basename (the Smartcat "folder/" prefix can't be a local filename).
-      const smartcatName = buildLocjsonFilename(type, docId, resolveDocumentTitle(schema, doc as never), {draft: isDraft})
-      setFilename(smartcatName.split('/').pop() || smartcatName)
-      setContent(JSON.stringify(locjson, null, 2))
-    } catch (err) {
-      setError(err instanceof Error ? err.message : String(err))
-    }
-  }, [client, schema, docId, type, sourceIsPublished, sourceLanguage, documentI18nLanguageField, fieldI18nLanguageField])
+  // Build the LocJSON for one variant: `targetLanguage` undefined ⇒ source-only
+  // (a plain export), otherwise the bilingual file for that Sanity locale.
+  const build = useCallback(
+    async (targetLanguage?: string) => {
+      setOpen(true)
+      setContent(null)
+      setFilename(null)
+      setError(null)
+      setTitle(targetLanguage ? `Source + ${languageTitle(languages, targetLanguage)}` : 'Source only')
+      try {
+        // Resolve the same version the export will send: the draft (fallback to
+        // published) unless the item was added from the published perspective.
+        const raw = (await client.fetch(
+          sourceIsPublished
+            ? '*[_id == $id][0]'
+            : 'coalesce(*[_id == "drafts." + $id][0], *[_id == $id][0])',
+          {id: docId},
+        )) as (Record<string, unknown> & {_id: string}) | null
+        if (!raw) throw new Error(`Document not found: ${docId}`)
+        const isDraft = typeof raw._id === 'string' && raw._id.startsWith('drafts.')
+        // Serialize under the canonical (bare) id, matching the export.
+        const doc = isDraft ? {...raw, _id: docId} : raw
+        const fields = getTranslatableFields(schema.get(type), {exclude: [documentI18nLanguageField]})
+
+        // For a bilingual variant, resolve the existing translation the same way
+        // the export does: field-level from the inline member, document-level from
+        // the target-locale sibling document.
+        let target: {language: string; doc?: Record<string, unknown> & {_id: string; _type: string}} | undefined
+        if (targetLanguage) {
+          if (localizationMode(schema.get(type)) === 'document') {
+            const variants = (await client.fetch(VIEW_SIBLINGS_QUERY, {id: docId})) as
+              | {language: string; doc: (Record<string, unknown> & {_id: string; _type: string}) | null}[]
+              | null
+            const sibling = (variants ?? []).find((v) => v.language === targetLanguage)?.doc ?? undefined
+            target = {language: targetLanguage, doc: sibling}
+          } else {
+            target = {language: targetLanguage}
+          }
+        }
+
+        const locjson = serializeToLocjson(doc as never, fields, {
+          sourceLanguage,
+          fieldLanguageKey: fieldI18nLanguageField,
+          target,
+        })
+        // Same name the export sends to Smartcat; the last path segment is the
+        // file's basename (the Smartcat "folder/" prefix can't be a local filename).
+        const smartcatCode = targetLanguage
+          ? languages.find((l) => l.id === targetLanguage)?.smartcatLanguage || targetLanguage
+          : undefined
+        const smartcatName = buildLocjsonFilename(type, docId, resolveDocumentTitle(schema, doc as never), {
+          draft: isDraft,
+          language: smartcatCode,
+        })
+        setFilename(smartcatName.split('/').pop() || smartcatName)
+        setContent(JSON.stringify(locjson, null, 2))
+      } catch (err) {
+        setError(err instanceof Error ? err.message : String(err))
+      }
+    },
+    [client, schema, docId, type, sourceIsPublished, sourceLanguage, documentI18nLanguageField, fieldI18nLanguageField, languages],
+  )
 
   const download = useCallback(() => {
     if (content == null || !filename) return
@@ -225,20 +270,25 @@ function ViewLocjsonButton(props: {
 
   return (
     <>
-      <Button
-        mode="bleed"
-        icon={JsonIcon}
-        title="View LocJSON"
-        fontSize={0}
-        padding={2}
-        onClick={build}
+      <MenuButton
+        id={`locjson-menu-${docId}`}
+        button={<Button mode="bleed" icon={JsonIcon} iconRight={ChevronDownIcon} title="View LocJSON" fontSize={0} padding={2} />}
+        menu={
+          <Menu>
+            <MenuItem text="Source only" onClick={() => build()} />
+            {targetLanguages.map((lang) => (
+              <MenuItem key={lang} text={`Source + ${languageTitle(languages, lang)}`} onClick={() => build(lang)} />
+            ))}
+          </Menu>
+        }
+        popover={{portal: true}}
       />
       {open && (
         <Dialog
           id={`locjson-${docId}`}
           header={
             <Flex align="center" gap={3}>
-              <Text weight="semibold">LocJSON · {type}</Text>
+              <Text weight="semibold">LocJSON · {type} · {title}</Text>
               <Button
                 icon={DownloadIcon}
                 text="Download"
@@ -912,6 +962,18 @@ export function ProjectView({
                             {modeByType.get(item.doc._type) === 'field' ? 'fields' : 'document'}
                           </Badge>
                         )}
+                        <Badge
+                          tone={item.sendExistingTranslations ? 'primary' : 'default'}
+                          fontSize={0}
+                          paddingX={2}
+                          title={
+                            item.sendExistingTranslations
+                              ? 'Existing translations are uploaded to Smartcat (one bilingual file per language) and marked confirmed'
+                              : 'Only source text is sent; Smartcat translates from scratch'
+                          }
+                        >
+                          {item.sendExistingTranslations ? 'source + translations' : 'source only'}
+                        </Badge>
                         {item.doc && <OpenInStudioButton id={item.doc._id} type={item.doc._type} />}
                         {item.doc && (
                           <ViewLocjsonButton
@@ -923,6 +985,8 @@ export function ProjectView({
                             sourceLanguage={sourceLanguage}
                             documentI18nLanguageField={documentI18nLanguageField}
                             fieldI18nLanguageField={fieldI18nLanguageField}
+                            targetLanguages={targets}
+                            languages={languages}
                           />
                         )}
                       </Flex>

package/src/tool/data.ts

@@ -24,6 +24,12 @@ export interface ProjectItemRef {
    * and which version the export serializes. Null on legacy items (pre-flag).
    */
   sourceIsPublished: boolean | null
+  /**
+   * Whether the export sends this item's existing translations (one bilingual
+   * file per target language) or only its source text. Null/false on legacy
+   * items (pre-flag) ⇒ source-only, today's behaviour.
+   */
+  sendExistingTranslations: boolean | null
   doc: {_id: string; _type: string} | null
   /** Locale variants linked via translation.metadata: language -> variant doc id. */
   translations: {language: string; id: string}[] | null
@@ -73,6 +79,7 @@ export const PROJECT_DETAIL_QUERY = `*[_id == $id][0]{
     _key,
     "docId": ${ITEM_ID},
     sourceIsPublished,
+    sendExistingTranslations,
     "doc": ${itemDocDeref('{_id, _type}')},
     "translations": *[_type == "translation.metadata" && references(${ITEM_ID_FROM_SUBQUERY})][0]
       .translations[]{language, "id": value._ref}

package/src/tool/processing.ts

@@ -14,7 +14,7 @@ import {serializeToLocjson} from '../lib/locjson/serialize'
 import {buildLocjsonFilename} from '../lib/locjson/filename'
 import {deserializeFromLocjson} from '../lib/locjson/deserialize'
 import {requireSourceLanguage} from '../lib/constants'
-import {buildLanguageMappings, findDuplicateSmartcatLanguages} from '../lib/languageMap'
+import {buildLanguageMappings, findDuplicateSmartcatLanguages, toSmartcatLanguage} from '../lib/languageMap'
 import type {LocalizationMode, LocJSON} from '../lib/locjson/types'
 import {summarizeCompletion, type DocProgress} from '../progress/core'
 import type {SmartcatLanguage} from '../types'
@@ -142,10 +142,22 @@ const ITEMS_QUERY = `*[_id == $id][0]{
   items[]{
     "docId": ${ITEM_ID},
     "docType": docType,
+    sendExistingTranslations,
     "doc": ${itemDocDerefRespectingDraft()}
   }
 }`
 
+/**
+ * Target-locale sibling documents for a set of source ids, via
+ * document-internationalization's `translation.metadata`. Returns, per metadata
+ * group, every locale variant's `{language, doc}` — the send-existing flow reads
+ * each target language's sibling as the translation to upload. Document-level
+ * only; field-level types keep all languages inline on the same document.
+ */
+const SIBLINGS_QUERY = `*[_type == "translation.metadata" && references($ids)]{
+  "variants": translations[]{ "language": _key, "doc": value-> }
+}`
+
 export async function prepareExport({
   client,
   schema,
@@ -165,6 +177,7 @@ export async function prepareExport({
     items?: {
       docId?: string
       docType?: string
+      sendExistingTranslations?: boolean
       doc: (Record<string, unknown> & {_id: string; _type: string}) | null
     }[]
   } | null>(ITEMS_QUERY, {id: projectId})
@@ -195,6 +208,37 @@ export async function prepareExport({
     .map((item) => item.doc)
     .filter((d): d is Record<string, unknown> & {_id: string; _type: string} => Boolean(d))
 
+  // For "send existing translations" document-level items, fetch each source's
+  // target-locale sibling documents up front (one query), keyed by
+  // bare-source-id → (Sanity locale → sibling doc). Field-level types need none —
+  // their translations live inline on the same document.
+  type TargetDoc = Record<string, unknown> & {_id: string; _type: string}
+  const siblingsByDocId = new Map<string, Map<string, TargetDoc>>()
+  const flaggedDocLevelIds = items
+    .filter(
+      (item) =>
+        item.doc && item.sendExistingTranslations === true && localizationMode(schema.get(item.doc._type)) === 'document',
+    )
+    .map((item) => publishedId((item.doc as {_id: string})._id))
+  if (flaggedDocLevelIds.length > 0) {
+    const groups = await client.fetch<{variants: {language: string; doc: TargetDoc | null}[]}[]>(
+      SIBLINGS_QUERY,
+      {ids: flaggedDocLevelIds},
+    )
+    for (const group of groups ?? []) {
+      const byLang = new Map<string, TargetDoc>()
+      const groupSourceIds: string[] = []
+      for (const variant of group.variants ?? []) {
+        if (!variant.doc) continue
+        byLang.set(variant.language, variant.doc)
+        groupSourceIds.push(publishedId(variant.doc._id))
+      }
+      // Every member of a translation group can reach the same sibling set, so key
+      // the map by each variant's id — the source doc looks up its own group.
+      for (const sid of groupSourceIds) siblingsByDocId.set(sid, byLang)
+    }
+  }
+
   // The translatable field list is per-type, so compute it once per type even
   // when a project holds many documents of the same type.
   const fieldsByType = new Map<string, ReturnType<typeof getTranslatableFields>>()
@@ -228,17 +272,79 @@ export async function prepareExport({
     })
   }
 
-  const outbox: {_key: string; sourceDocId: string; title?: string; filename: string; locjson: string}[] = []
-  for (const rawDoc of docs) {
+  const outbox: {
+    _key: string
+    sourceDocId: string
+    title?: string
+    filename: string
+    locjson: string
+    /** Present for per-language bilingual files (send-existing flow). */
+    targetLanguage?: string
+  }[] = []
+
+  /**
+   * Queue one bilingual LocJSON per target language for a "send existing
+   * translations" item. Each file carries the source plus that language's
+   * existing translation (field-level: the inline member; document-level: the
+   * locale-sibling document), is named `…_{smartcatCode}.locjson` so Smartcat
+   * groups the languages as one document, and records its single target language.
+   */
+  const queueBilingual = (
+    doc: Record<string, unknown> & {_id: string; _type: string},
+    name: string | undefined,
+    fields: TranslatableField[],
+    isDraft: boolean,
+  ): void => {
+    const mode = localizationMode(schema.get(doc._type))
+    const byLang = mode === 'document' ? siblingsByDocId.get(doc._id) : undefined
+    let queued = 0
+    for (const targetSanityId of targetLanguages) {
+      const smartcatCode = toSmartcatLanguage(smartcatLanguages, targetSanityId)
+      const target =
+        mode === 'field' ? {language: targetSanityId} : {language: targetSanityId, doc: byLang?.get(targetSanityId)}
+      const locjson = serializeToLocjson(doc as never, fields, {sourceLanguage: source, fieldLanguageKey, target})
+      if (locjson.units.length === 0) {
+        log({level: 'skip', indent: true, message: `${targetSanityId}: no translatable content — not sent`})
+        continue
+      }
+      const prefilled = locjson.units.filter((u) => u.target.length > 0).length
+      outbox.push({
+        _key: uuid(),
+        sourceDocId: doc._id,
+        title: name,
+        filename: buildLocjsonFilename(doc._type, doc._id, name, {draft: isDraft, language: smartcatCode}),
+        locjson: JSON.stringify(locjson),
+        targetLanguage: smartcatCode,
+      })
+      queued++
+      log({
+        level: 'success',
+        indent: true,
+        message: `${targetSanityId} → ${smartcatCode}: queued ${locjson.units.length} unit(s), ${prefilled} with existing translation`,
+      })
+    }
+    if (queued === 0) log({level: 'skip', indent: true, message: 'no translatable content — not sent'})
+  }
+  for (const item of items) {
+    const rawDoc = item.doc
+    if (!rawDoc) continue
     // Serialize under the canonical (bare) id so identity, metadata and progress
     // stay stable, even when the *content* came from the draft. Mark draft-sourced
     // files so they're recognizable in Smartcat.
     const isDraft = rawDoc._id.startsWith('drafts.')
     const doc = isDraft ? {...rawDoc, _id: publishedId(rawDoc._id)} : rawDoc
     const name = resolveDocumentTitle(schema, doc)
-    log({level: 'info', message: `${name || doc._id}  ·  ${doc._type}${isDraft ? ' (draft)' : ''}`})
+    const sendExisting = item.sendExistingTranslations === true
+    log({
+      level: 'info',
+      message: `${name || doc._id}  ·  ${doc._type}${isDraft ? ' (draft)' : ''}${sendExisting ? ' · sending existing translations' : ''}`,
+    })
     try {
       const fields = fieldsFor(doc._type)
+      if (sendExisting) {
+        queueBilingual(doc, name, fields, isDraft)
+        continue
+      }
       // Fields skipped because they hold a block type that can't be serialized
       // (e.g. a custom `table`): left untranslated on purpose, reported as errors
       // below so the editor knows to act rather than lose content silently.