@tita-agent/dsh-data-table 0.0.0-stage → 0.2.0

package/src/xlsx-export-worker.ts

@@ -0,0 +1,34 @@
+/**
+ * On-demand export worker. SheetJS is intentionally isolated from the Univer
+ * main thread so large workbook encoding does not freeze scrolling/editing.
+ */
+
+import { workbookCsvText, workbookXlsxBytes } from './xlsx-export.ts'
+
+interface ExportRequest {
+  format: 'csv' | 'xlsx'
+  snapshot: unknown
+}
+
+const workerScope = globalThis as typeof globalThis & {
+  onmessage: ((event: MessageEvent<ExportRequest>) => void) | null
+  postMessage(message: unknown, transfer?: Transferable[]): void
+}
+
+workerScope.onmessage = event => {
+  try {
+    if (event.data.format === 'csv') {
+      const csv = workbookCsvText(event.data.snapshot)
+      workerScope.postMessage({ ok: true, format: 'csv', value: csv })
+      return
+    }
+    const bytes = workbookXlsxBytes(event.data.snapshot)
+    if (bytes === null) {
+      workerScope.postMessage({ ok: true, format: 'xlsx', value: null })
+      return
+    }
+    workerScope.postMessage({ ok: true, format: 'xlsx', value: bytes }, [bytes])
+  } catch (error) {
+    workerScope.postMessage({ ok: false, error: error instanceof Error ? error.message : String(error) })
+  }
+}

package/src/xlsx-export.ts

@@ -0,0 +1,373 @@
+/**
+ * XLSX/CSV exchange adapter for Datasheet.
+ *
+ * The free Univer presets intentionally do not include Univer PRO's exchange
+ * plugin. SheetJS is used here as the file-format adapter, while the stored
+ * representation remains a normal Univer snapshot. Values, formulas, sheet
+ * names, merges, dimensions, number formats and basic cell styles round-trip
+ * without making the host process depend on a browser-only API.
+ * @module dsh-data-table/xlsx-export
+ */
+
+import * as XLSX from 'xlsx'
+import { DEFAULT_SHEET_FONT_FAMILY, DEFAULT_SHEET_ROWS, DEFAULT_SHEET_COLUMNS } from './contract/snapshots.ts'
+import { SHEET_MAX_COLUMNS, SHEET_MAX_PHYSICAL_ROWS, SHEET_MAX_ROWS } from './types.ts'
+import type { WorkbookCellStyle } from './types.ts'
+
+interface SnapshotCell {
+  v?: unknown
+  f?: string
+  s?: unknown
+  n?: string
+}
+
+interface SnapshotSheet {
+  id?: string
+  name?: string
+  rowCount?: number
+  columnCount?: number
+  cellData?: Record<string, Record<string, SnapshotCell | unknown>>
+  mergeData?: unknown
+  columnData?: Record<string, unknown>
+  rowData?: Record<string, unknown>
+  defaultStyle?: unknown
+  [key: string]: unknown
+}
+
+interface WorkbookSnapshot {
+  id?: string
+  name?: string
+  sheetOrder?: string[]
+  sheets?: Record<string, SnapshotSheet>
+  styles?: Record<string, unknown>
+}
+
+interface SheetEntry {
+  id: string
+  name: string
+  sheet: SnapshotSheet
+}
+
+/** Download the first workbook sheet as UTF-8 CSV. */
+export function downloadWorkbookCsv(snapshot: unknown, filenameBase: string): void {
+  const csv = workbookCsvText(snapshot)
+  if (csv === null) return
+  downloadBlob(new Blob([csv], { type: 'text/csv;charset=utf-8' }), `${safeFilename(filenameBase)}.csv`)
+}
+
+/** Download all workbook sheets as an XLSX file. */
+export function downloadWorkbookXlsx(snapshot: unknown, filenameBase: string): void {
+  const bytes = workbookXlsxBytes(snapshot)
+  if (bytes === null) return
+  downloadBlob(new Blob([bytes], { type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' }), `${safeFilename(filenameBase)}.xlsx`)
+}
+
+/** Encode the first sheet as CSV without touching browser APIs. */
+export function workbookCsvText(snapshot: unknown): string | null {
+  const sheet = orderedSheets(snapshot)[0]
+  if (sheet === undefined) return null
+  const bounds = usedBounds(sheet.sheet)
+  const lines: string[] = []
+  for (let row = 0; row <= bounds.endRow; row += 1) {
+    const values: string[] = []
+    for (let column = 0; column <= bounds.endColumn; column += 1) {
+      values.push(escapeCsv(displayCellValue(getCell(sheet.sheet, row, column))))
+    }
+    lines.push(values.join(','))
+  }
+  return `\uFEFF${lines.join('\n')}`
+}
+
+/** Encode all sheets as XLSX without touching browser APIs. */
+export function workbookXlsxBytes(snapshot: unknown): ArrayBuffer | null {
+  const workbook = snapshotToXlsx(snapshot)
+  if (workbook.SheetNames.length === 0) return null
+  return XLSX.write(workbook, { bookType: 'xlsx', type: 'array', cellStyles: true, compression: true }) as ArrayBuffer
+}
+
+/** Parse an uploaded XLSX file into a Univer-compatible snapshot. */
+export function readWorkbookXlsx(data: ArrayBuffer, filename = 'workbook'): object {
+  const workbook = XLSX.read(data, { type: 'array', cellFormula: true, cellStyles: true, cellDates: true, dense: false })
+  if (workbook.SheetNames.length === 0) throw new Error('Excel 文件不包含工作表')
+  if (workbook.SheetNames.length > 100) throw new Error('Excel 文件超过 Datasheet 上限（最多 100 个工作表）')
+  const sheets: Record<string, SnapshotSheet> = {}
+  const sheetOrder: string[] = []
+  const styles: Record<string, WorkbookCellStyle> = {}
+  const styleIds = new Map<string, string>()
+  for (const [index, name] of workbook.SheetNames.entries()) {
+    const source = workbook.Sheets[name]
+    const ref = source['!ref'] ?? 'A1:A1'
+    const range = XLSX.utils.decode_range(ref)
+    if (range.s.r < 0 || range.s.c < 0 || range.e.r >= SHEET_MAX_PHYSICAL_ROWS || range.e.c >= SHEET_MAX_COLUMNS) throw new Error(`Excel 文件超过 Datasheet 上限（${SHEET_MAX_ROWS} 条数据行 + 表头 × ${SHEET_MAX_COLUMNS} 列）`)
+    const id = `sheet${index + 1}`
+    const sheet: SnapshotSheet = {
+      id,
+      name: safeSheetName(name, index),
+      rowCount: Math.max(DEFAULT_SHEET_ROWS, range.e.r + 1),
+      columnCount: Math.max(DEFAULT_SHEET_COLUMNS, range.e.c + 1),
+      defaultStyle: { ff: DEFAULT_SHEET_FONT_FAMILY },
+      cellData: {},
+    }
+    for (let row = range.s.r; row <= range.e.r; row += 1) {
+      for (let column = range.s.c; column <= range.e.c; column += 1) {
+        const address = XLSX.utils.encode_cell({ r: row, c: column })
+        const sourceCell = source[address] as XLSX.CellObject | undefined
+        if (sourceCell === undefined) continue
+        const cell: SnapshotCell = { v: normalizeImportedValue(sourceCell.v) }
+        if (typeof sourceCell.f === 'string' && sourceCell.f.length > 0) cell.f = sourceCell.f
+        const style = xlsxStyleToUniver(sourceCell.s, sourceCell.z)
+        if (Object.keys(style).length > 0) {
+          const signature = stableStyleSignature(style)
+          let styleId = styleIds.get(signature)
+          if (styleId === undefined) {
+            styleId = `xlsx-style-${styleIds.size + 1}`
+            styleIds.set(signature, styleId)
+            styles[styleId] = style
+          }
+          cell.s = styleId
+        }
+        ;(sheet.cellData ??= {})[String(row)] ??= {}
+        sheet.cellData[String(row)][String(column)] = cell
+      }
+    }
+    if (Array.isArray(source['!merges'])) sheet.mergeData = source['!merges'].map(merge => ({
+      startRow: merge.s.r,
+      startColumn: merge.s.c,
+      endRow: merge.e.r,
+      endColumn: merge.e.c,
+    }))
+    if (Array.isArray(source['!cols'])) sheet.columnData = Object.fromEntries(source['!cols'].map((column, columnIndex) => [String(columnIndex), column]))
+    if (Array.isArray(source['!rows'])) sheet.rowData = Object.fromEntries(source['!rows'].map((row, rowIndex) => [String(rowIndex), row]))
+    sheets[id] = sheet
+    sheetOrder.push(id)
+  }
+  return { id: 'imported', name: filename.replace(/\.[^.]+$/, '') || 'workbook', sheetOrder, sheets, ...(Object.keys(styles).length > 0 ? { styles } : {}) }
+}
+
+function snapshotToXlsx(snapshot: unknown): XLSX.WorkBook {
+  const root = (typeof snapshot === 'object' && snapshot !== null ? snapshot : {}) as WorkbookSnapshot
+  const workbook = XLSX.utils.book_new()
+  for (const entry of orderedSheets(root)) {
+    const worksheet: XLSX.WorkSheet = {}
+    const bounds = usedBounds(entry.sheet)
+    for (let row = 0; row <= bounds.endRow; row += 1) {
+      for (let column = 0; column <= bounds.endColumn; column += 1) {
+        const cell = getCell(entry.sheet, row, column)
+        if (cell.v === undefined && cell.f === undefined) continue
+        const target = XLSX.utils.encode_cell({ r: row, c: column })
+        const output: XLSX.CellObject = { v: cell.v === null ? undefined : cell.v as string | number | boolean | Date | undefined, t: cellType(cell.v) }
+        if (typeof cell.f === 'string' && cell.f.length > 0) output.f = cell.f.replace(/^=/, '')
+        const style = resolveCellStyle(root, cell)
+        const styleNumberFormat = typeof style?.n === 'string' ? style.n : undefined
+        if (typeof cell.n === 'string') output.z = cell.n
+        else if (styleNumberFormat !== undefined) output.z = styleNumberFormat
+        if (style !== undefined) {
+          const xlsxStyle = univerStyleToXlsx(style)
+          if (Object.keys(xlsxStyle).length > 0) output.s = xlsxStyle
+        }
+        worksheet[target] = output
+      }
+    }
+    worksheet['!ref'] = `A1:${XLSX.utils.encode_cell({ r: bounds.endRow, c: bounds.endColumn })}`
+    const merges = Array.isArray(entry.sheet.mergeData) ? entry.sheet.mergeData : []
+    worksheet['!merges'] = merges.filter(isRange).map(range => ({
+      s: { r: range.startRow, c: range.startColumn },
+      e: { r: range.endRow, c: range.endColumn },
+    }))
+    if (entry.sheet.columnData !== undefined) worksheet['!cols'] = dimensionArray(entry.sheet.columnData, 'width', 'wch') as NonNullable<XLSX.WorkSheet['!cols']>
+    if (entry.sheet.rowData !== undefined) worksheet['!rows'] = dimensionArray(entry.sheet.rowData, 'height', 'hpt') as NonNullable<XLSX.WorkSheet['!rows']>
+    XLSX.utils.book_append_sheet(workbook, worksheet, entry.name)
+  }
+  workbook.Props = { ...(workbook.Props ?? {}), Title: root.name ?? 'Datasheet' }
+  return workbook
+}
+
+function orderedSheets(snapshot: unknown): SheetEntry[] {
+  const root = (typeof snapshot === 'object' && snapshot !== null ? snapshot : {}) as WorkbookSnapshot
+  const sheets = root.sheets ?? {}
+  const ids = root.sheetOrder?.filter(id => sheets[id] !== undefined) ?? Object.keys(sheets)
+  const usedNames = new Set<string>()
+  return ids.map((id, index) => ({ id, name: uniqueSheetName(safeSheetName(sheets[id]?.name ?? id, index), usedNames, index), sheet: sheets[id] ?? {} }))
+}
+
+function uniqueSheetName(name: string, usedNames: Set<string>, index: number): string {
+  let candidate = name
+  let suffix = 2
+  while (usedNames.has(candidate)) {
+    const suffixText = ` (${suffix++})`
+    candidate = `${name.slice(0, Math.max(1, 31 - suffixText.length))}${suffixText}`
+  }
+  usedNames.add(candidate)
+  return candidate || `Sheet${index + 1}`
+}
+
+function safeSheetName(name: string, index: number): string {
+  return name.replace(/[\\/:?*\[\]]/g, ' ').trim().slice(0, 31) || `Sheet${index + 1}`
+}
+
+function getCell(sheet: SnapshotSheet, row: number, column: number): SnapshotCell {
+  const value = sheet.cellData?.[String(row)]?.[String(column)]
+  if (typeof value === 'object' && value !== null) return value as SnapshotCell
+  return { v: value }
+}
+
+function usedBounds(sheet: SnapshotSheet): { endRow: number; endColumn: number } {
+  let endRow = -1
+  let endColumn = -1
+  for (const [rowKey, row] of Object.entries(sheet.cellData ?? {})) {
+    const rowNumber = Number(rowKey)
+    if (!Number.isInteger(rowNumber) || rowNumber < 0) continue
+    for (const columnKey of Object.keys(row)) {
+      const columnNumber = Number(columnKey)
+      if (!Number.isInteger(columnNumber) || columnNumber < 0) continue
+      endRow = Math.max(endRow, rowNumber)
+      endColumn = Math.max(endColumn, columnNumber)
+    }
+  }
+  return { endRow: Math.max(0, endRow), endColumn: Math.max(0, endColumn) }
+}
+
+function displayCellValue(cell: SnapshotCell): unknown {
+  if (cell.f !== undefined && cell.v === undefined) return `=${cell.f.replace(/^=/, '')}`
+  return cell.v ?? ''
+}
+
+function normalizeImportedValue(value: unknown): unknown {
+  return value instanceof Date ? value.toISOString() : value ?? null
+}
+
+function xlsxStyleToUniver(value: unknown, numberFormat: unknown): WorkbookCellStyle {
+  const source = asRecord(value)
+  const font = asRecord(source.font)
+  const fill = asRecord(source.fill)
+  const alignment = asRecord(source.alignment)
+  const style: WorkbookCellStyle = {}
+  if (typeof font.name === 'string' && font.name.length > 0) style.ff = font.name
+  if (typeof font.sz === 'number' && Number.isFinite(font.sz)) style.fs = font.sz
+  if (font.bold === true) style.bl = true
+  if (font.italic === true) style.it = true
+  if (font.underline === true || font.underline === 'single') style.ul = true
+  if (font.strike === true) style.st = true
+  const fontColor = colorValue(font.color)
+  if (fontColor !== undefined) style.cl = fontColor
+  const fillColor = colorValue(fill.fgColor ?? fill.bgColor)
+  if (fillColor !== undefined && fill.patternType !== 'none') style.bg = fillColor
+  if (alignment.horizontal === 'left') style.ht = 1
+  else if (alignment.horizontal === 'center' || alignment.horizontal === 'centerContinuous') style.ht = 2
+  else if (alignment.horizontal === 'right') style.ht = 3
+  if (alignment.vertical === 'top') style.vt = 1
+  else if (alignment.vertical === 'center') style.vt = 2
+  else if (alignment.vertical === 'bottom') style.vt = 3
+  if (typeof alignment.textRotation === 'number' && Number.isFinite(alignment.textRotation)) style.tr = alignment.textRotation
+  if (typeof numberFormat === 'string' && numberFormat.length > 0 && numberFormat !== 'General') style.n = numberFormat
+  return style
+}
+
+function resolveCellStyle(root: WorkbookSnapshot, cell: SnapshotCell): WorkbookCellStyle | undefined {
+  if (typeof cell.s === 'string') {
+    const style = root.styles?.[cell.s]
+    return style !== undefined ? style as WorkbookCellStyle : undefined
+  }
+  return cell.s !== null && typeof cell.s === 'object' ? cell.s as WorkbookCellStyle : undefined
+}
+
+function univerStyleToXlsx(style: WorkbookCellStyle): Record<string, unknown> {
+  const font: Record<string, unknown> = {}
+  if (typeof style.ff === 'string') font.name = style.ff
+  if (typeof style.fs === 'number') font.sz = style.fs
+  if (style.bl !== undefined) font.bold = style.bl
+  if (style.it !== undefined) font.italic = style.it
+  if (style.ul !== undefined) font.underline = style.ul ? 'single' : undefined
+  if (style.st !== undefined) font.strike = style.st
+  const fontColor = colorValue(style.cl)
+  if (fontColor !== undefined) font.color = { rgb: toArgb(fontColor) }
+  const fillColor = colorValue(style.bg)
+  const fill = fillColor === undefined ? undefined : { patternType: 'solid', fgColor: { rgb: toArgb(fillColor) } }
+  const alignment: Record<string, unknown> = {}
+  if (style.ht === 1) alignment.horizontal = 'left'
+  else if (style.ht === 2) alignment.horizontal = 'center'
+  else if (style.ht === 3) alignment.horizontal = 'right'
+  if (style.vt === 1) alignment.vertical = 'top'
+  else if (style.vt === 2) alignment.vertical = 'center'
+  else if (style.vt === 3) alignment.vertical = 'bottom'
+  if (style.tr !== undefined) alignment.textRotation = style.tr
+  return {
+    ...(Object.keys(font).length > 0 ? { font } : {}),
+    ...(fill === undefined ? {} : { fill }),
+    ...(Object.keys(alignment).length > 0 ? { alignment } : {}),
+  }
+}
+
+function asRecord(value: unknown): Record<string, any> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, any> : {}
+}
+
+function colorValue(value: unknown): string | undefined {
+  const record = asRecord(value)
+  const raw = typeof value === 'string' ? value : typeof record.rgb === 'string' ? record.rgb : undefined
+  if (raw === undefined || raw.length === 0) return undefined
+  const normalized = raw.replace(/^#/, '')
+  if (!/^[0-9a-fA-F]{6}([0-9a-fA-F]{2})?$/.test(normalized)) return raw
+  return `#${normalized.length === 8 ? normalized.slice(2) : normalized}`
+}
+
+function toArgb(value: string): string {
+  const normalized = value.replace(/^#/, '')
+  return normalized.length === 6 ? `FF${normalized}` : normalized
+}
+
+function stableStyleSignature(style: WorkbookCellStyle): string {
+  return JSON.stringify(Object.entries(style).sort(([left], [right]) => left.localeCompare(right)))
+}
+
+function cellType(value: unknown): XLSX.CellObject['t'] {
+  if (typeof value === 'number') return 'n'
+  if (typeof value === 'boolean') return 'b'
+  if (value instanceof Date) return 'd'
+  return 's'
+}
+
+function isRange(value: unknown): value is { startRow: number; startColumn: number; endRow: number; endColumn: number } {
+  if (typeof value !== 'object' || value === null) return false
+  const range = value as Record<string, unknown>
+  return ['startRow', 'startColumn', 'endRow', 'endColumn'].every(key => typeof range[key] === 'number')
+}
+
+function dimensionSize(value: unknown, key: 'width' | 'height'): number | undefined {
+  if (typeof value !== 'object' || value === null) return undefined
+  const size = (value as Record<string, unknown>)[key]
+  return typeof size === 'number' && Number.isFinite(size) ? size : undefined
+}
+
+function dimensionArray(data: Record<string, unknown>, sourceKey: 'width' | 'height', targetKey: 'wch' | 'hpt'): Array<Record<string, unknown> | undefined> {
+  const indexes = Object.keys(data).map(Number).filter(Number.isInteger)
+  const result: Array<Record<string, unknown> | undefined> = []
+  for (const index of indexes) {
+    const value = data[String(index)]
+    result[index] = { ...(typeof value === 'object' && value !== null ? value as object : {}), [targetKey]: dimensionSize(value, sourceKey) }
+  }
+  return result
+}
+
+function escapeCsv(value: unknown): string {
+  const raw = value === null || value === undefined ? '' : String(value)
+  // Prevent formula injection when a CSV is opened by spreadsheet software.
+  // The apostrophe is visible only as a safety marker in Excel/Sheets.
+  const text = /^[=+\-@]/.test(raw) ? `'${raw}` : raw
+  return /[",\n\r]/.test(text) ? `"${text.replace(/"/g, '""')}"` : text
+}
+
+function safeFilename(value: string): string {
+  return value.replace(/[\\/:*?"<>|]/g, '-').trim() || 'workbook'
+}
+
+export function downloadBlob(blob: Blob, filename: string): void {
+  const url = URL.createObjectURL(blob)
+  const anchor = document.createElement('a')
+  anchor.href = url
+  anchor.download = filename
+  document.body.append(anchor)
+  anchor.click()
+  anchor.remove()
+  window.setTimeout(() => URL.revokeObjectURL(url), 0)
+}

package/src/xlsx-import-worker.ts

@@ -0,0 +1,30 @@
+/**
+ * XLSX import worker. SheetJS parsing is intentionally kept off the Univer
+ * interaction thread; the node half serves this file as a static asset.
+ */
+import { readWorkbookXlsx } from './xlsx-export.ts'
+
+interface ImportRequest {
+  data: ArrayBuffer
+  filename?: string
+}
+
+interface WorkerScope {
+  onmessage: ((event: MessageEvent<ImportRequest>) => void) | null
+  postMessage(message: unknown): void
+}
+
+const workerScope = globalThis as unknown as WorkerScope
+
+workerScope.onmessage = event => {
+  try {
+    const request = event.data
+    if (request === undefined || !(request.data instanceof ArrayBuffer)) {
+      throw new Error('导入请求数据无效')
+    }
+    const snapshot = readWorkbookXlsx(request.data, request.filename ?? 'workbook')
+    workerScope.postMessage({ ok: true, snapshot })
+  } catch (error) {
+    workerScope.postMessage({ ok: false, error: error instanceof Error ? error.message : String(error) })
+  }
+}