omni-viewer-core 0.1.0

package/dist/viewers/excel/controller.js

@@ -0,0 +1,548 @@
+// ExcelController — the behavior-controller layer for the Excel viewer
+// (DESIGN.md §3-②, docs/viewers/excel.md §3). Pure state machine: no DOM, no
+// host services, no SheetJS. It consumes an already-parsed
+// ParseResult<ExcelWorkbook> and drives sheet switch, sort, search, pagination,
+// raw-view toggle, copy, and CELL EDITING (X-편집, promoted to v1 scope).
+//
+// Editing mirrors the CSV controller engine (src/viewers/csv/controller.ts):
+// immutable RowIds so sort/filter can't misroute an edit, an inverse-op
+// undo/redo stack, and dirty tracking against a saved point. The Excel-specific
+// part is that cells are TYPED (EditableCell {t,v,w}); an edited value's type is
+// inferred (inferEditedCell) so type-preserving export (serializeWorkbook) keeps
+// numbers/dates as numbers/dates rather than text. Edits live in a per-sheet
+// working model so switching sheets preserves them.
+//
+// Sort reuses the CSV deterministic comparators (X2). Save-as export only —
+// no writeback to the original file, no formula recalculation.
+import { applySort, detectColumnType, nextSortState, parseDateKey, serializeRowsToTsv } from '../../parsers/csv/index.js';
+import { buildGridView } from './grid.js';
+export const EXCEL_DEFAULT_PAGE_SIZE = 100;
+export const EXCEL_UNDO_STACK_LIMIT = 200;
+export function createExcelController(result, options = {}) {
+    const listeners = new Set();
+    const pageSizeDefault = options.pageSize ?? EXCEL_DEFAULT_PAGE_SIZE;
+    const editable = result.status === 'ok';
+    const workbook = result.status === 'failed'
+        ? { sheetNames: [], sheets: [], date1904: false }
+        : result.document;
+    /** Per-sheet mutable working models — created on first load/edit. */
+    const working = new Map();
+    // Current-sheet runtime view state.
+    let sheetIndex = 0;
+    let ws = null;
+    let sortedRows = [];
+    let displayRows = [];
+    let sort = { columnIndex: null, direction: null };
+    let sortedColumnType = null;
+    let search = '';
+    let matchedCellCount = 0;
+    let pageSize = pageSizeDefault;
+    let page = 0;
+    let viewMode = 'table';
+    let rawCache = null;
+    /** Grid views (X3) are derived from the original sheet, cached per sheet. */
+    const gridCache = new Map();
+    function getWorkingSheet(index) {
+        const existing = working.get(index);
+        if (existing)
+            return existing;
+        const sheet = workbook.sheets[index];
+        if (!sheet)
+            return null;
+        const built = deriveWorkingSheet(sheet);
+        working.set(index, built);
+        return built;
+    }
+    function hasActiveSearch() {
+        return viewMode === 'table' && search.length > 0;
+    }
+    function rowText(row, c) {
+        return row.cells[c]?.w ?? '';
+    }
+    function refilter() {
+        if (!hasActiveSearch()) {
+            displayRows = sortedRows.slice();
+            matchedCellCount = 0;
+            return;
+        }
+        const term = search.toLowerCase();
+        const filtered = [];
+        let cells = 0;
+        for (const row of sortedRows) {
+            let hit = false;
+            for (const cell of row.cells) {
+                if (cell.w.toLowerCase().includes(term)) {
+                    cells++;
+                    hit = true;
+                }
+            }
+            if (hit)
+                filtered.push(row);
+        }
+        displayRows = filtered;
+        matchedCellCount = cells;
+    }
+    function resort() {
+        const rows = ws?.rowOrder ?? [];
+        if (sort.columnIndex === null || !sort.direction) {
+            sortedRows = rows.slice();
+            sortedColumnType = null;
+        }
+        else {
+            const col = sort.columnIndex;
+            sortedColumnType = detectColumnType(rows.map((r) => rowText(r, col)));
+            const positions = applySort(rows.map((_, i) => i), sort, (rowIndex, columnIndex) => rowText(rows[rowIndex], columnIndex), sortedColumnType);
+            sortedRows = positions.map((p) => rows[p]);
+        }
+        refilter();
+    }
+    function loadSheet(index) {
+        sheetIndex = index;
+        ws = getWorkingSheet(index);
+        sort = { columnIndex: null, direction: null };
+        sortedColumnType = null;
+        search = '';
+        matchedCellCount = 0;
+        page = 0;
+        rawCache = null;
+        resort();
+    }
+    function pageCount() {
+        return Math.max(1, Math.ceil(displayRows.length / pageSize));
+    }
+    // --- editing ------------------------------------------------------------
+    function isDirty(sheet) {
+        return sheet.savedUnreachable || sheet.undoStack.length !== sheet.savedDepth;
+    }
+    function workbookDirty() {
+        for (const sheet of working.values()) {
+            if (isDirty(sheet))
+                return true;
+        }
+        return false;
+    }
+    function applyOp(op, direction) {
+        if (!ws)
+            return;
+        switch (op.kind) {
+            case 'cell': {
+                const row = ws.byId.get(op.rowId);
+                if (row)
+                    row.cells[op.columnIndex] = direction === 'forward' ? op.next : op.prev;
+                break;
+            }
+            case 'header': {
+                ws.headers[op.columnIndex] = direction === 'forward' ? op.next : op.prev;
+                break;
+            }
+            case 'insert': {
+                if (direction === 'forward')
+                    addRowAt(op.row, op.positions);
+                else
+                    removeRow(op.row);
+                break;
+            }
+            case 'delete': {
+                if (direction === 'forward')
+                    removeRow(op.row);
+                else
+                    addRowAt(op.row, op.positions);
+                break;
+            }
+        }
+        rawCache = null;
+    }
+    function addRowAt(row, positions) {
+        if (!ws)
+            return;
+        ws.rowOrder.splice(clamp(positions.order, 0, ws.rowOrder.length), 0, row);
+        sortedRows.splice(clamp(positions.sorted, 0, sortedRows.length), 0, row);
+        if (positions.display >= 0) {
+            displayRows.splice(clamp(positions.display, 0, displayRows.length), 0, row);
+        }
+        ws.byId.set(row.id, row);
+    }
+    function removeRow(row) {
+        if (!ws)
+            return;
+        const drop = (arr) => {
+            const i = arr.indexOf(row);
+            if (i >= 0)
+                arr.splice(i, 1);
+        };
+        drop(ws.rowOrder);
+        drop(sortedRows);
+        drop(displayRows);
+        ws.byId.delete(row.id);
+    }
+    function pushOp(op) {
+        if (!ws)
+            return;
+        applyOp(op, 'forward');
+        if (ws.redoStack.length > 0) {
+            if (ws.savedDepth > ws.undoStack.length)
+                ws.savedUnreachable = true;
+            ws.redoStack = [];
+        }
+        ws.undoStack.push(op);
+        if (ws.undoStack.length > EXCEL_UNDO_STACK_LIMIT) {
+            ws.undoStack.shift();
+            if (ws.savedDepth > 0)
+                ws.savedDepth--;
+            else
+                ws.savedUnreachable = true;
+        }
+    }
+    // --- state --------------------------------------------------------------
+    function buildState() {
+        const start = page * pageSize;
+        const pageRows = displayRows.slice(start, start + pageSize);
+        return {
+            status: result.status,
+            failure: result.status === 'failed' ? result.failure : null,
+            diagnostics: result.diagnostics,
+            sheetNames: [...workbook.sheetNames],
+            sheetIndex,
+            sheetName: ws?.name ?? '',
+            headers: ws ? ws.headers.map((c) => c.w) : [],
+            columnCount: ws?.columnCount ?? 0,
+            rowCount: ws?.rowOrder.length ?? 0,
+            sort,
+            sortedColumnType,
+            search,
+            matchedRowCount: displayRows.length,
+            matchedCellCount,
+            page,
+            pageCount: pageCount(),
+            pageSize,
+            viewMode,
+            visibleRows: pageRows.map((r) => r.cells.map((c) => c.w)),
+            visibleRowIds: pageRows.map((r) => r.id),
+            editable,
+            canUndo: (ws?.undoStack.length ?? 0) > 0,
+            canRedo: (ws?.redoStack.length ?? 0) > 0,
+            dirty: ws ? isDirty(ws) : false,
+            workbookDirty: workbookDirty()
+        };
+    }
+    let state;
+    function commit() {
+        state = buildState();
+        for (const listener of listeners)
+            listener(state);
+    }
+    loadSheet(0);
+    state = buildState();
+    function dispatch(action) {
+        switch (action.type) {
+            case 'switch-sheet': {
+                if (action.index < 0 ||
+                    action.index >= workbook.sheets.length ||
+                    action.index === sheetIndex) {
+                    return;
+                }
+                loadSheet(action.index);
+                break;
+            }
+            case 'sort-column': {
+                if (!ws || action.columnIndex < 0 || action.columnIndex >= ws.columnCount)
+                    return;
+                sort = nextSortState(sort, action.columnIndex);
+                resort();
+                page = 0;
+                break;
+            }
+            case 'set-search': {
+                if (action.search === search)
+                    return;
+                search = action.search;
+                refilter();
+                page = 0;
+                break;
+            }
+            case 'set-page-size': {
+                if (!Number.isInteger(action.pageSize) || action.pageSize <= 0)
+                    return;
+                if (action.pageSize === pageSize)
+                    return;
+                const firstVisible = page * pageSize;
+                pageSize = action.pageSize;
+                page = Math.floor(firstVisible / pageSize);
+                break;
+            }
+            case 'set-page': {
+                page = clamp(action.page, 0, pageCount() - 1);
+                break;
+            }
+            case 'next-page': {
+                page = clamp(page + 1, 0, pageCount() - 1);
+                break;
+            }
+            case 'prev-page': {
+                page = clamp(page - 1, 0, pageCount() - 1);
+                break;
+            }
+            case 'set-view-mode': {
+                if (action.mode === viewMode)
+                    return;
+                viewMode = action.mode;
+                refilter();
+                page = clamp(page, 0, pageCount() - 1);
+                break;
+            }
+            case 'edit-cell': {
+                if (!editable || !ws)
+                    return;
+                const row = ws.byId.get(action.rowId);
+                if (!row || action.columnIndex < 0 || action.columnIndex >= ws.columnCount)
+                    return;
+                const prev = row.cells[action.columnIndex] ?? emptyCell();
+                const next = inferEditedCell(action.value);
+                if (cellsEqual(prev, next))
+                    return;
+                pushOp({ kind: 'cell', rowId: action.rowId, columnIndex: action.columnIndex, prev, next });
+                break;
+            }
+            case 'edit-header': {
+                if (!editable || !ws)
+                    return;
+                if (action.columnIndex < 0 || action.columnIndex >= ws.columnCount)
+                    return;
+                const prev = ws.headers[action.columnIndex] ?? emptyCell();
+                const next = { t: 'text', v: action.value, w: action.value };
+                if (cellsEqual(prev, next))
+                    return;
+                pushOp({ kind: 'header', columnIndex: action.columnIndex, prev, next });
+                break;
+            }
+            case 'insert-row': {
+                if (!editable || !ws)
+                    return;
+                const row = {
+                    id: ws.nextRowId++,
+                    cells: Array.from({ length: ws.columnCount }, emptyCell)
+                };
+                let positions;
+                if (action.afterRowId === 'end') {
+                    positions = { order: ws.rowOrder.length, sorted: sortedRows.length, display: displayRows.length };
+                }
+                else {
+                    const after = ws.byId.get(action.afterRowId);
+                    if (!after)
+                        return;
+                    positions = {
+                        order: ws.rowOrder.indexOf(after) + 1 || ws.rowOrder.length,
+                        sorted: sortedRows.indexOf(after) + 1 || sortedRows.length,
+                        display: displayRows.indexOf(after) + 1 || displayRows.length
+                    };
+                }
+                pushOp({ kind: 'insert', row, positions });
+                break;
+            }
+            case 'delete-row': {
+                if (!editable || !ws)
+                    return;
+                const row = ws.byId.get(action.rowId);
+                if (!row)
+                    return;
+                pushOp({
+                    kind: 'delete',
+                    row,
+                    positions: {
+                        order: ws.rowOrder.indexOf(row),
+                        sorted: sortedRows.indexOf(row),
+                        display: displayRows.indexOf(row)
+                    }
+                });
+                break;
+            }
+            case 'undo': {
+                if (!ws)
+                    return;
+                const op = ws.undoStack.pop();
+                if (!op)
+                    return;
+                applyOp(op, 'backward');
+                ws.redoStack.push(op);
+                break;
+            }
+            case 'redo': {
+                if (!ws)
+                    return;
+                const op = ws.redoStack.pop();
+                if (!op)
+                    return;
+                applyOp(op, 'forward');
+                ws.undoStack.push(op);
+                break;
+            }
+        }
+        commit();
+    }
+    return {
+        get state() {
+            return state;
+        },
+        dispatch,
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+        getRowById(rowId) {
+            return ws?.byId.get(rowId)?.cells.map((c) => c.w) ?? [];
+        },
+        toTsv() {
+            return serializeRowsToTsv(displayRows.map((r) => r.cells.map((c) => c.w)), ws ? ws.headers.map((c) => c.w) : []);
+        },
+        toJson() {
+            const headers = ws ? ws.headers.map((c) => c.w) : [];
+            return JSON.stringify({
+                format: 'excel-export@1',
+                sheetName: ws?.name ?? '',
+                headers,
+                rows: displayRows.map((r) => r.cells.map((c) => c.w)),
+                metadata: {
+                    totalRows: ws?.rowOrder.length ?? 0,
+                    filteredRows: displayRows.length,
+                    columns: headers.length,
+                    searchActive: hasActiveSearch()
+                }
+            }, null, 2);
+        },
+        rawJson() {
+            if (rawCache === null) {
+                const headers = ws ? ws.headers.map((c) => c.w) : [];
+                rawCache = JSON.stringify({
+                    sheetName: ws?.name ?? '',
+                    headers,
+                    rows: (ws?.rowOrder ?? []).map((r) => r.cells.map((c) => c.w)),
+                    metadata: { totalRows: ws?.rowOrder.length ?? 0, columns: headers.length }
+                }, null, 2);
+            }
+            return rawCache;
+        },
+        getWorkbook() {
+            const sheets = workbook.sheetNames.map((name, index) => {
+                const edited = working.get(index);
+                if (edited)
+                    return workingToSheet(edited);
+                return workbook.sheets[index] ?? emptySheet(name);
+            });
+            return { sheetNames: [...workbook.sheetNames], sheets, date1904: workbook.date1904 };
+        },
+        getGrid() {
+            const sheet = workbook.sheets[sheetIndex];
+            if (!sheet)
+                return null;
+            let grid = gridCache.get(sheetIndex);
+            if (!grid) {
+                grid = buildGridView(sheet);
+                gridCache.set(sheetIndex, grid);
+            }
+            return grid;
+        },
+        markSaved() {
+            for (const sheet of working.values()) {
+                sheet.savedDepth = sheet.undoStack.length;
+                sheet.savedUnreachable = false;
+            }
+            commit();
+        }
+    };
+}
+// --- helpers ---------------------------------------------------------------
+function emptyCell() {
+    return { t: 'text', v: '', w: '' };
+}
+function cellsEqual(a, b) {
+    return a.t === b.t && a.v === b.v && a.w === b.w;
+}
+/** Infer a cell's type from an edited string (docs/viewers/excel.md §3): a
+ *  finite number is numeric, an ISO-shaped value is a date (parseDateKey —
+ *  deterministic, ADR 41), everything else is text. */
+function inferEditedCell(value) {
+    const trimmed = value.trim();
+    if (trimmed !== '' && Number.isFinite(Number(trimmed))) {
+        return { t: 'number', v: Number(trimmed), w: value };
+    }
+    if (parseDateKey(trimmed) !== null) {
+        return { t: 'date', v: trimmed, w: value };
+    }
+    return { t: 'text', v: value, w: value };
+}
+function deriveWorkingSheet(sheet) {
+    const range = sheet.usedRange;
+    const columnCount = range ? range.c1 - range.c0 + 1 : 0;
+    const headers = [];
+    const rowOrder = [];
+    const byId = new Map();
+    if (range) {
+        const grid = new Map();
+        for (const cell of sheet.cells)
+            grid.set(`${cell.r}:${cell.c}`, cell);
+        const cellAt = (r, c) => {
+            const found = grid.get(`${r}:${c}`);
+            return found ? { t: found.t, v: found.v, w: found.w } : emptyCell();
+        };
+        for (let c = range.c0; c <= range.c1; c++)
+            headers.push(cellAt(range.r0, c));
+        let nextId = 0;
+        for (let r = range.r0 + 1; r <= range.r1; r++) {
+            const cells = [];
+            for (let c = range.c0; c <= range.c1; c++)
+                cells.push(cellAt(r, c));
+            const row = { id: nextId++, cells };
+            rowOrder.push(row);
+            byId.set(row.id, row);
+        }
+        return {
+            name: sheet.name,
+            headers,
+            rowOrder,
+            byId,
+            columnCount,
+            nextRowId: nextId,
+            undoStack: [],
+            redoStack: [],
+            savedDepth: 0,
+            savedUnreachable: false
+        };
+    }
+    return {
+        name: sheet.name,
+        headers,
+        rowOrder,
+        byId,
+        columnCount,
+        nextRowId: 0,
+        undoStack: [],
+        redoStack: [],
+        savedDepth: 0,
+        savedUnreachable: false
+    };
+}
+/** Rebuild a sparse, typed ExcelSheet from an edited working model (origin
+ *  normalized to A1). Empty text cells are omitted to keep the model sparse. */
+function workingToSheet(ws) {
+    const cells = [];
+    const push = (r, c, cell) => {
+        if (cell.t === 'text' && cell.v === '' && cell.w === '')
+            return;
+        cells.push({ r, c, t: cell.t, v: cell.v, w: cell.w });
+    };
+    ws.headers.forEach((cell, c) => push(0, c, cell));
+    ws.rowOrder.forEach((row, ri) => {
+        row.cells.forEach((cell, c) => push(ri + 1, c, cell));
+    });
+    const rowCount = ws.rowOrder.length + (ws.columnCount > 0 ? 1 : 0);
+    const usedRange = ws.columnCount > 0 && rowCount > 0
+        ? { r0: 0, c0: 0, r1: rowCount - 1, c1: ws.columnCount - 1 }
+        : null;
+    return { name: ws.name, usedRange, cells, rowCount, columnCount: ws.columnCount };
+}
+function emptySheet(name) {
+    return { name, usedRange: null, cells: [], rowCount: 0, columnCount: 0 };
+}
+function clamp(v, min, max) {
+    return Math.min(Math.max(v, min), max);
+}

package/dist/viewers/excel/grid.d.ts

@@ -0,0 +1,28 @@
+import type { CellStyle, ExcelSheet } from '../../parsers/excel/index.js';
+export interface GridCell {
+    r: number;
+    c: number;
+    rowSpan: number;
+    colSpan: number;
+    text: string;
+    /** CSS property → value (camelCase keys), applied as an inline style. */
+    style: Record<string, string>;
+}
+export interface GridRow {
+    heightPx: number;
+    cells: GridCell[];
+}
+export interface GridView {
+    /** Column widths in px, in used-range order. */
+    cols: number[];
+    rows: GridRow[];
+    /** Rendered row count when the sheet was capped, else null. */
+    truncatedRows: number | null;
+}
+/** Cell budget before the grid truncates to keep the DOM bounded (web parity). */
+export declare const GRID_MAX_CELLS = 60000;
+export declare function buildGridView(sheet: ExcelSheet, options?: {
+    maxCells?: number;
+}): GridView;
+/** Convert the semantic CellStyle to CSS property→value pairs (camelCase). */
+export declare function styleToCss(style: CellStyle): Record<string, string>;

package/dist/viewers/excel/grid.js

@@ -0,0 +1,99 @@
+// Grid render model (X3) — turns a parsed ExcelSheet (cells + merges + column/
+// row sizes + styles) into a renderable, CSS-ready structure for the WYSIWYG
+// grid view. Pure and DOM-free (ported from omni-viewer-web `buildSheetView`),
+// so both the core DOM renderer and web's Vue renderer can consume it.
+//
+// This is a read-only view of the original parsed sheet — it does not reflect
+// data-mode edits (docs/viewers/excel.md §3, X3 decision).
+const DEFAULT_COL_WIDTH = 100;
+const DEFAULT_ROW_HEIGHT = 24;
+/** Cell budget before the grid truncates to keep the DOM bounded (web parity). */
+export const GRID_MAX_CELLS = 60000;
+export function buildGridView(sheet, options = {}) {
+    const range = sheet.usedRange;
+    if (!range)
+        return { cols: [], rows: [], truncatedRows: null };
+    const maxCells = options.maxCells ?? GRID_MAX_CELLS;
+    const totalRows = range.r1 - range.r0 + 1;
+    const totalCols = range.c1 - range.c0 + 1;
+    let lastRow = range.r1;
+    let truncatedRows = null;
+    if (totalRows * totalCols > maxCells) {
+        const maxRows = Math.max(1, Math.floor(maxCells / Math.max(1, totalCols)));
+        lastRow = range.r0 + maxRows - 1;
+        truncatedRows = maxRows;
+    }
+    const cellByAddr = new Map();
+    for (const cell of sheet.cells)
+        cellByAddr.set(`${cell.r}:${cell.c}`, cell);
+    // Merges: the top-left cell carries the span; the rest are covered/skipped.
+    const mergeStarts = new Map();
+    const mergeCovered = new Set();
+    for (const m of sheet.merges ?? []) {
+        for (let r = m.r0; r <= m.r1; r++) {
+            for (let c = m.c0; c <= m.c1; c++) {
+                const key = `${r}:${c}`;
+                if (r === m.r0 && c === m.c0) {
+                    mergeStarts.set(key, { rowSpan: m.r1 - m.r0 + 1, colSpan: m.c1 - m.c0 + 1 });
+                }
+                else {
+                    mergeCovered.add(key);
+                }
+            }
+        }
+    }
+    const cols = [];
+    for (let c = range.c0; c <= range.c1; c++) {
+        cols.push(sheet.columnWidthsPx?.[c] ?? DEFAULT_COL_WIDTH);
+    }
+    const rows = [];
+    for (let r = range.r0; r <= lastRow; r++) {
+        const cells = [];
+        for (let c = range.c0; c <= range.c1; c++) {
+            const key = `${r}:${c}`;
+            if (mergeCovered.has(key))
+                continue;
+            const cell = cellByAddr.get(key);
+            const span = mergeStarts.get(key);
+            cells.push({
+                r,
+                c,
+                rowSpan: span?.rowSpan ?? 1,
+                colSpan: span?.colSpan ?? 1,
+                text: cell?.w ?? '',
+                style: cell?.style ? styleToCss(cell.style) : {}
+            });
+        }
+        rows.push({ heightPx: sheet.rowHeightsPx?.[r] ?? DEFAULT_ROW_HEIGHT, cells });
+    }
+    return { cols, rows, truncatedRows };
+}
+/** Convert the semantic CellStyle to CSS property→value pairs (camelCase). */
+export function styleToCss(style) {
+    const css = {};
+    if (style.bold)
+        css.fontWeight = '700';
+    if (style.italic)
+        css.fontStyle = 'italic';
+    if (typeof style.fontSizePx === 'number')
+        css.fontSize = `${style.fontSizePx}px`;
+    if (style.color)
+        css.color = style.color;
+    if (style.background)
+        css.backgroundColor = style.background;
+    if (style.align)
+        css.textAlign = style.align;
+    if (style.valign)
+        css.verticalAlign = style.valign;
+    if (style.wrap)
+        css.whiteSpace = 'pre-wrap';
+    if (style.borders?.top)
+        css.borderTop = style.borders.top;
+    if (style.borders?.right)
+        css.borderRight = style.borders.right;
+    if (style.borders?.bottom)
+        css.borderBottom = style.borders.bottom;
+    if (style.borders?.left)
+        css.borderLeft = style.borders.left;
+    return css;
+}