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

package/lib/types/xlsx-export-worker.d.ts

@@ -0,0 +1,5 @@
+/**
+ * On-demand export worker. SheetJS is intentionally isolated from the Univer
+ * main thread so large workbook encoding does not freeze scrolling/editing.
+ */
+export {};

package/lib/types/xlsx-export-worker.js

@@ -0,0 +1,24 @@
+/**
+ * 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.js";
+const workerScope = globalThis;
+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/lib/types/xlsx-export.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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
+ */
+/** Download the first workbook sheet as UTF-8 CSV. */
+export declare function downloadWorkbookCsv(snapshot: unknown, filenameBase: string): void;
+/** Download all workbook sheets as an XLSX file. */
+export declare function downloadWorkbookXlsx(snapshot: unknown, filenameBase: string): void;
+/** Encode the first sheet as CSV without touching browser APIs. */
+export declare function workbookCsvText(snapshot: unknown): string | null;
+/** Encode all sheets as XLSX without touching browser APIs. */
+export declare function workbookXlsxBytes(snapshot: unknown): ArrayBuffer | null;
+/** Parse an uploaded XLSX file into a Univer-compatible snapshot. */
+export declare function readWorkbookXlsx(data: ArrayBuffer, filename?: string): object;
+export declare function downloadBlob(blob: Blob, filename: string): void;

package/lib/types/xlsx-export.js

@@ -0,0 +1,371 @@
+/**
+ * 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.js";
+import { SHEET_MAX_COLUMNS, SHEET_MAX_PHYSICAL_ROWS, SHEET_MAX_ROWS } from "./types.js";
+/** Download the first workbook sheet as UTF-8 CSV. */
+export function downloadWorkbookCsv(snapshot, filenameBase) {
+    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, filenameBase) {
+    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) {
+    const sheet = orderedSheets(snapshot)[0];
+    if (sheet === undefined)
+        return null;
+    const bounds = usedBounds(sheet.sheet);
+    const lines = [];
+    for (let row = 0; row <= bounds.endRow; row += 1) {
+        const values = [];
+        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) {
+    const workbook = snapshotToXlsx(snapshot);
+    if (workbook.SheetNames.length === 0)
+        return null;
+    return XLSX.write(workbook, { bookType: 'xlsx', type: 'array', cellStyles: true, compression: true });
+}
+/** Parse an uploaded XLSX file into a Univer-compatible snapshot. */
+export function readWorkbookXlsx(data, filename = 'workbook') {
+    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 = {};
+    const sheetOrder = [];
+    const styles = {};
+    const styleIds = new Map();
+    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 = {
+            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];
+                if (sourceCell === undefined)
+                    continue;
+                const cell = { 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) {
+    const root = (typeof snapshot === 'object' && snapshot !== null ? snapshot : {});
+    const workbook = XLSX.utils.book_new();
+    for (const entry of orderedSheets(root)) {
+        const 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 = { v: cell.v === null ? undefined : cell.v, 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');
+        if (entry.sheet.rowData !== undefined)
+            worksheet['!rows'] = dimensionArray(entry.sheet.rowData, 'height', 'hpt');
+        XLSX.utils.book_append_sheet(workbook, worksheet, entry.name);
+    }
+    workbook.Props = { ...(workbook.Props ?? {}), Title: root.name ?? 'Datasheet' };
+    return workbook;
+}
+function orderedSheets(snapshot) {
+    const root = (typeof snapshot === 'object' && snapshot !== null ? snapshot : {});
+    const sheets = root.sheets ?? {};
+    const ids = root.sheetOrder?.filter(id => sheets[id] !== undefined) ?? Object.keys(sheets);
+    const usedNames = new Set();
+    return ids.map((id, index) => ({ id, name: uniqueSheetName(safeSheetName(sheets[id]?.name ?? id, index), usedNames, index), sheet: sheets[id] ?? {} }));
+}
+function uniqueSheetName(name, usedNames, index) {
+    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, index) {
+    return name.replace(/[\\/:?*\[\]]/g, ' ').trim().slice(0, 31) || `Sheet${index + 1}`;
+}
+function getCell(sheet, row, column) {
+    const value = sheet.cellData?.[String(row)]?.[String(column)];
+    if (typeof value === 'object' && value !== null)
+        return value;
+    return { v: value };
+}
+function usedBounds(sheet) {
+    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) {
+    if (cell.f !== undefined && cell.v === undefined)
+        return `=${cell.f.replace(/^=/, '')}`;
+    return cell.v ?? '';
+}
+function normalizeImportedValue(value) {
+    return value instanceof Date ? value.toISOString() : value ?? null;
+}
+function xlsxStyleToUniver(value, numberFormat) {
+    const source = asRecord(value);
+    const font = asRecord(source.font);
+    const fill = asRecord(source.fill);
+    const alignment = asRecord(source.alignment);
+    const style = {};
+    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, cell) {
+    if (typeof cell.s === 'string') {
+        const style = root.styles?.[cell.s];
+        return style !== undefined ? style : undefined;
+    }
+    return cell.s !== null && typeof cell.s === 'object' ? cell.s : undefined;
+}
+function univerStyleToXlsx(style) {
+    const font = {};
+    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 = {};
+    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) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function colorValue(value) {
+    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) {
+    const normalized = value.replace(/^#/, '');
+    return normalized.length === 6 ? `FF${normalized}` : normalized;
+}
+function stableStyleSignature(style) {
+    return JSON.stringify(Object.entries(style).sort(([left], [right]) => left.localeCompare(right)));
+}
+function cellType(value) {
+    if (typeof value === 'number')
+        return 'n';
+    if (typeof value === 'boolean')
+        return 'b';
+    if (value instanceof Date)
+        return 'd';
+    return 's';
+}
+function isRange(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const range = value;
+    return ['startRow', 'startColumn', 'endRow', 'endColumn'].every(key => typeof range[key] === 'number');
+}
+function dimensionSize(value, key) {
+    if (typeof value !== 'object' || value === null)
+        return undefined;
+    const size = value[key];
+    return typeof size === 'number' && Number.isFinite(size) ? size : undefined;
+}
+function dimensionArray(data, sourceKey, targetKey) {
+    const indexes = Object.keys(data).map(Number).filter(Number.isInteger);
+    const result = [];
+    for (const index of indexes) {
+        const value = data[String(index)];
+        result[index] = { ...(typeof value === 'object' && value !== null ? value : {}), [targetKey]: dimensionSize(value, sourceKey) };
+    }
+    return result;
+}
+function escapeCsv(value) {
+    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) {
+    return value.replace(/[\\/:*?"<>|]/g, '-').trim() || 'workbook';
+}
+export function downloadBlob(blob, filename) {
+    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/lib/types/xlsx-import-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/types/xlsx-import-worker.js

@@ -0,0 +1,19 @@
+/**
+ * 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.js";
+const workerScope = globalThis;
+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) });
+    }
+};