dsh-cait 1.1.6 → 1.1.7

package/lib/import-export.js

@@ -6,14 +6,16 @@ import { stripMarkdown } from './markdown.js'
 import { DOCX_MIME, buildBilingualDocx, buildDocx, buildDocxFromText, parseDocxDetailed } from './docx.js'
 import { EPUB_MIME, buildEpub, buildEpubFromText, parseEpub } from './epub.js'
 import { PPTX_MIME, buildPptx, parsePptxDetailed } from './pptx.js'
-import { XLSX_MIME, buildXlsx, parseXlsx } from './xlsx.js'
+import { XLSX_MIME, buildXlsx, parseXlsx, patchXlsx } from './xlsx.js'
 import { buildTmx, parseTmx } from './tmx.js'
 import { buildHtml, buildJson, buildPo, buildRtf, buildSrt, buildVtt, buildXliff, buildXliff2, buildXliffReview, parseCsv, parseHtml, parseJson, parsePo, parseRtf, parseSrt, parseVtt, parseXliff } from './formats.js'
+import { LOCALIZATION_EXPORT, LOCALIZATION_EXTENSIONS, buildLocalization, parseLocalization } from './localization.js'
 import { decodeXml } from './xml.js'
 
 const BINARY_SOURCES = {
   docx: { label: 'DOCX', fallback: 'source.docx' },
   pptx: { label: 'PPTX', fallback: 'source.pptx' },
+  xlsx: { label: 'XLSX', fallback: 'source.xlsx' },
   epub: { label: 'EPUB', fallback: 'source.epub' },
 }
 
@@ -143,6 +145,18 @@ export const importExportMethods = {
     return readSource(this, doc, 'pptx')
   },
 
+  attachXlsxSource(doc, buffer, name = 'source.xlsx') {
+    attachSource(this, doc, 'xlsx', buffer, name)
+  },
+
+  removeXlsxSource(doc) {
+    removeSource(this, doc, 'xlsx')
+  },
+
+  readXlsxSource(doc) {
+    return readSource(this, doc, 'xlsx')
+  },
+
   attachEpubSource(doc, buffer, name = 'source.epub') {
     attachSource(this, doc, 'epub', buffer, name)
   },
@@ -333,11 +347,13 @@ export const importExportMethods = {
         name: fileName,
         text: content.text,
         paragraphMap: content.paragraphs.map((paragraph) => paragraph.index),
+        paragraphMeta: Object.fromEntries(content.paragraphs.map((paragraph) => [paragraph.index, paragraph.meta])),
         docxSource: buffer,
         docxName: fileName,
         sourceLang,
         targetLang,
         format: 'docx',
+        formatMeta: content.formatMeta,
       })
     }
 
@@ -391,6 +407,7 @@ export const importExportMethods = {
         targetLang,
         format: extension,
         ...(extension === 'pptx' ? { pptxSource: buffer, pptxName: fileName } : {}),
+        ...(extension === 'xlsx' ? { xlsxSource: buffer, xlsxName: fileName } : {}),
       })
       return {
         ...created,
@@ -411,6 +428,49 @@ export const importExportMethods = {
       })
     }
 
+    let localizationKind = LOCALIZATION_EXTENSIONS[extension]
+    if (!localizationKind && extension === 'xml' && /<resources\b/i.test(String(text ?? ''))) {
+      localizationKind = 'android'
+    }
+    if (localizationKind) {
+      const sourceText = String(text ?? '')
+      if (!sourceText.trim()) throw new CatError('EMPTY_FILE', '文件内容为空。')
+      if (sourceText.length > MAX_IMPORT_CHARS) throw new CatError('FILE_TOO_LARGE', '文件过大。')
+      let parsed
+      try {
+        parsed = parseLocalization(sourceText, localizationKind)
+      } catch (error) {
+        if (error instanceof CatError) throw error
+        throw new CatError(
+          `${localizationKind.toUpperCase()}_PARSE`,
+          `${localizationKind} 解析失败: ${error?.message ?? error}`,
+        )
+      }
+      const src = cleanLang(
+        sourceLang || parsed.sourceLang || this.settings.sourceLang,
+        this.settings.sourceLang,
+      )
+      const tgt = cleanLang(
+        targetLang || parsed.targetLang || this.settings.targetLang,
+        this.settings.targetLang,
+      )
+      const created = this.createDocument({
+        name: fileName,
+        segments: parsed.segments,
+        sourceLang: src,
+        targetLang: tgt,
+        format: parsed.format || localizationKind,
+        formatMeta: parsed.formatMeta,
+      })
+      return {
+        ...created,
+        sourceLang: src,
+        targetLang: tgt,
+        units: parsed.segments.length,
+        warnings: parsed.warnings ?? [],
+      }
+    }
+
     const structured = {
       csv: { parser: parseCsv, format: 'csv' },
       srt: { parser: parseSrt, format: 'srt' },
@@ -507,13 +567,26 @@ export const importExportMethods = {
 
     if (format === 'docx') {
       const grouped = new Map()
-      for (const segment of doc.segments) {
-        const key = Number.isInteger(segment.paragraph) ? segment.paragraph : 0
+      const byPart = new Map()
+      let hasPartMeta = false
+      for (const [index, segment] of doc.segments.entries()) {
+        const meta = segment.meta && typeof segment.meta === 'object' ? segment.meta : null
+        const part = meta?.docxPart || 'word/document.xml'
+        const ordinal = Number.isInteger(meta?.docxParagraph)
+          ? meta.docxParagraph
+          : Number.isInteger(segment.paragraph)
+            ? segment.paragraph
+            : index
+        if (meta?.docxPart && Number.isInteger(meta?.docxParagraph)) hasPartMeta = true
+        const key = `${part}\u0000${ordinal}`
         if (!grouped.has(key)) grouped.set(key, [])
         grouped.get(key).push(segment)
+        if (!byPart.has(part)) byPart.set(part, new Map())
+        const partMap = byPart.get(part)
+        if (!partMap.has(ordinal)) partMap.set(ordinal, [])
+        partMap.get(ordinal).push(segment)
       }
-      const replacements = new Map()
-      for (const [key, segments] of grouped) {
+      const combine = (segments) => {
         const translated = segments
           .map((segment) => segment.target)
           .filter(Boolean)
@@ -524,22 +597,42 @@ export const importExportMethods = {
           .filter(Boolean)
           .join(' ')
           .trim()
-        if (translated || fallback) replacements.set(key, translated || fallback)
+        return translated || fallback
+      }
+      const replacements = new Map()
+      for (const [key, segments] of grouped) {
+        const ordinal = Number(key.split('\u0000')[1])
+        const text = combine(segments)
+        if (text) replacements.set(ordinal, text)
+      }
+      for (const [part, partMap] of byPart) {
+        for (const [ordinal, segments] of partMap) {
+          const text = combine(segments)
+          if (text) partMap.set(ordinal, text)
+          else partMap.delete(ordinal)
+        }
       }
 
       let content = null
       const template = this.readDocxSource(doc)
       if (template) {
         try {
-          content = buildDocx(template, replacements)
+          content = hasPartMeta
+            ? buildDocx(template, null, byPart)
+            : buildDocx(template, replacements)
         } catch (error) {
           this.logger?.warn?.(`CAIT: DOCX 模板套用失败，改用纯文本 DOCX: ${error.message}`)
         }
       }
       if (!content) {
         const paragraphs = [...grouped.keys()]
-          .sort((left, right) => left - right)
-          .map((key) => replacements.get(key))
+          .sort((left, right) => {
+            const [leftPart, leftOrdinal] = left.split('\u0000')
+            const [rightPart, rightOrdinal] = right.split('\u0000')
+            if (leftPart !== rightPart) return leftPart.localeCompare(rightPart)
+            return Number(leftOrdinal) - Number(rightOrdinal)
+          })
+          .map((key) => replacements.get(Number(key.split('\u0000')[1])))
           .filter(Boolean)
         content = buildDocxFromText(paragraphs)
       }
@@ -583,6 +676,16 @@ export const importExportMethods = {
       }
     }
 
+    const localizationExport = LOCALIZATION_EXPORT[format]
+    if (localizationExport) {
+      return {
+        filename: `${base}.${doc.targetLang}.${localizationExport.extension}`,
+        mime: localizationExport.mime,
+        content: buildLocalization(doc, format),
+        count: doc.segments.length,
+      }
+    }
+
     if (format === 'srt') {
       return {
         filename: `${base}.${doc.targetLang}.srt`,
@@ -668,10 +771,12 @@ export const importExportMethods = {
     }
 
     if (format === 'xlsx') {
+      const source = this.readXlsxSource(doc)
+      const patched = source ? patchXlsx(doc, source) : null
       return {
         filename: `${base}.${doc.targetLang}.xlsx`,
         mime: XLSX_MIME,
-        content: buildXlsx(doc),
+        content: patched ? patched.buffer : buildXlsx(doc),
         count: doc.segments.length,
       }
     }