omni-viewer-core 0.1.0

package/dist/viewers/csv/controller.js

@@ -0,0 +1,598 @@
+// CsvController — the behavior-controller layer for the CSV viewer
+// (DESIGN.md §3-②). Pure state machine: no DOM, no host services. The DOM
+// renderer is one consumer; web (Vue) can consume it directly to share
+// interaction semantics. Conformance kit item 3 (action sequence → normalized
+// state) runs against this.
+//
+// Rows are identified by immutable RowIds (not array indexes) so edit-mode
+// insert/delete cannot corrupt sort, search, or row numbering
+// (docs/viewers/csv.md §6 편집과 저장).
+import { parseCsv, applySort, detectColumnType, nextSortState, computeStatistics, serializeRowsToTsv, serializeRowsToJson, serializeRowsToCsv } from '../../parsers/csv/index.js';
+export const DEFAULT_PAGE_SIZE = 500;
+export const UNDO_STACK_LIMIT = 200;
+/** Avoid a full-table scan for each very broad single-character query. */
+export const CSV_MIN_SEARCH_LENGTH = 2;
+export function createCsvController(source, options = {}) {
+    const listeners = new Set();
+    const text = typeof source === 'string'
+        ? source
+        : new TextDecoder('utf-8', { fatal: false }).decode(source);
+    let document = emptyDocument();
+    let parse;
+    let headers = [];
+    /** Live column count — column insert/delete moves it off the parsed value. */
+    let columnCount = 0;
+    let rowOrder = [];
+    let byId = new Map();
+    let orderPos = new Map();
+    let nextRowId = 0;
+    let sort = { columnIndex: null, direction: null };
+    let sortedColumnType = null;
+    /** Document rows in sorted display order (row references). */
+    let sortedRows = [];
+    /** sortedRows filtered by the active search — always a distinct array. */
+    let displayRows = [];
+    let search = '';
+    let showRowNumbers = false;
+    let pageSize = options.pageSize ?? DEFAULT_PAGE_SIZE;
+    let page = 0;
+    let viewMode = 'table';
+    let statsVisible = false;
+    let statsCache = null;
+    const undoStack = [];
+    let redoStack = [];
+    let savedDepth = 0;
+    let savedUnreachable = false;
+    /** True once the stack overflowed — an empty undo stack then no longer
+     *  proves the document equals the original source text. */
+    let opsDropped = false;
+    function isDirty() {
+        return savedUnreachable || undoStack.length !== savedDepth;
+    }
+    function rebuildOrderPos() {
+        orderPos = new Map();
+        rowOrder.forEach((row, i) => orderPos.set(row.id, i));
+    }
+    function rowMatches(row, term) {
+        for (const cell of row.cells) {
+            if (cell.toLowerCase().includes(term))
+                return true;
+        }
+        return false;
+    }
+    function hasActiveSearch() {
+        return search.length >= CSV_MIN_SEARCH_LENGTH;
+    }
+    /** Search filters over the sorted display order (docs §6). */
+    function refilter() {
+        if (!hasActiveSearch()) {
+            displayRows = sortedRows.slice();
+            return;
+        }
+        const term = search.toLowerCase();
+        displayRows = sortedRows.filter((r) => rowMatches(r, term));
+    }
+    function resort() {
+        if (sort.columnIndex === null || !sort.direction) {
+            sortedRows = rowOrder.slice();
+            sortedColumnType = null;
+        }
+        else {
+            const col = sort.columnIndex;
+            sortedColumnType = detectColumnType(rowOrder.map((r) => r.cells[col] ?? ''));
+            const positions = applySort(identity(rowOrder.length), sort, (rowIndex, columnIndex) => rowOrder[rowIndex]?.cells[columnIndex] ?? '', sortedColumnType);
+            sortedRows = positions.map((p) => rowOrder[p]);
+        }
+        refilter();
+    }
+    function reparse(delimiter) {
+        const parseOptions = {};
+        if (delimiter !== undefined)
+            parseOptions.delimiter = delimiter;
+        if (options.fileName !== undefined)
+            parseOptions.fileName = options.fileName;
+        if (options.limits !== undefined)
+            parseOptions.limits = options.limits;
+        parse = parseCsv(text, parseOptions).result;
+        document = parse.status === 'failed' ? emptyDocument() : parse.document;
+        headers = [...document.headers];
+        columnCount = document.columnCount;
+        nextRowId = 0;
+        rowOrder = document.rows.map((cells) => ({ id: nextRowId++, cells: [...cells] }));
+        byId = new Map(rowOrder.map((r) => [r.id, r]));
+        rebuildOrderPos();
+        sort = { columnIndex: null, direction: null };
+        sortedColumnType = null;
+        // The search term survives a reparse and reapplies to the new document.
+        resort();
+        page = 0;
+        statsCache = null;
+        undoStack.length = 0;
+        redoStack = [];
+        savedDepth = 0;
+        savedUnreachable = false;
+        opsDropped = false;
+    }
+    // ------------------------------------------------------------- edit ops
+    function addRowAt(row, positions) {
+        rowOrder.splice(clamp(positions.order, 0, rowOrder.length), 0, row);
+        sortedRows.splice(clamp(positions.sorted, 0, sortedRows.length), 0, row);
+        // display === -1 records "was filtered out" — don't resurface it.
+        if (positions.display >= 0) {
+            displayRows.splice(clamp(positions.display, 0, displayRows.length), 0, row);
+        }
+        byId.set(row.id, row);
+        rebuildOrderPos();
+    }
+    function removeRow(row) {
+        const removeFrom = (arr) => {
+            const i = arr.indexOf(row);
+            if (i >= 0)
+                arr.splice(i, 1);
+        };
+        removeFrom(rowOrder);
+        removeFrom(sortedRows);
+        removeFrom(displayRows);
+        byId.delete(row.id);
+        rebuildOrderPos();
+    }
+    // Column ops mutate the shared row objects, so rowOrder / sortedRows /
+    // displayRows all see the change without re-deriving. Display order is
+    // deliberately untouched (docs §6: edits never reshuffle the view) — the
+    // sort column index just shifts with the columns, and deleting the sorted
+    // column clears the sort marker while keeping the current order on screen.
+    function insertColumnAt(columnIndex, header, cells) {
+        headers.splice(columnIndex, 0, header);
+        for (const row of rowOrder) {
+            row.cells.splice(columnIndex, 0, cells?.get(row.id) ?? '');
+        }
+        columnCount++;
+        if (sort.columnIndex !== null && sort.columnIndex >= columnIndex) {
+            sort = { ...sort, columnIndex: sort.columnIndex + 1 };
+        }
+    }
+    function removeColumnAt(columnIndex) {
+        headers.splice(columnIndex, 1);
+        for (const row of rowOrder) {
+            row.cells.splice(columnIndex, 1);
+        }
+        columnCount--;
+        if (sort.columnIndex !== null) {
+            if (sort.columnIndex === columnIndex) {
+                sort = { columnIndex: null, direction: null };
+                sortedColumnType = null;
+            }
+            else if (sort.columnIndex > columnIndex) {
+                sort = { ...sort, columnIndex: sort.columnIndex - 1 };
+            }
+        }
+    }
+    function applyOp(op, direction) {
+        switch (op.kind) {
+            case 'cell': {
+                const row = byId.get(op.rowId);
+                if (row) {
+                    row.cells[op.columnIndex] =
+                        direction === 'forward' ? op.next : op.prev;
+                }
+                break;
+            }
+            case 'header': {
+                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;
+            }
+            case 'insert-col': {
+                if (direction === 'forward')
+                    insertColumnAt(op.columnIndex, op.header);
+                else
+                    removeColumnAt(op.columnIndex);
+                break;
+            }
+            case 'delete-col': {
+                if (direction === 'forward')
+                    removeColumnAt(op.columnIndex);
+                else
+                    insertColumnAt(op.columnIndex, op.header, op.cells);
+                break;
+            }
+            case 'document': {
+                const target = direction === 'forward' ? op.next : op.prev;
+                headers = target.headers;
+                rowOrder = target.rows.slice();
+                byId = new Map(rowOrder.map((r) => [r.id, r]));
+                rebuildOrderPos();
+                columnCount = target.columnCount;
+                parse = target.parse;
+                document = target.document;
+                // The sorted column may not exist in the swapped-in document.
+                if (sort.columnIndex !== null && sort.columnIndex >= columnCount) {
+                    sort = { columnIndex: null, direction: null };
+                    sortedColumnType = null;
+                }
+                resort();
+                break;
+            }
+        }
+        statsCache = null;
+    }
+    function pushOp(op) {
+        applyOp(op, 'forward');
+        if (redoStack.length > 0) {
+            // The saved point may live in the discarded redo branch.
+            if (savedDepth > undoStack.length)
+                savedUnreachable = true;
+            redoStack = [];
+        }
+        undoStack.push(op);
+        if (undoStack.length > UNDO_STACK_LIMIT) {
+            undoStack.shift();
+            opsDropped = true;
+            if (savedDepth > 0)
+                savedDepth--;
+            else
+                savedUnreachable = true;
+        }
+    }
+    function documentCsv() {
+        return serializeRowsToCsv(rowOrder.map((r) => r.cells), headers, document.delimiter);
+    }
+    /** Verbatim source while provably unedited (original quoting and line
+     *  endings preserved); normalized serialization once edits exist. */
+    function toRawText() {
+        return undoStack.length === 0 && !opsDropped ? text : documentCsv();
+    }
+    // -------------------------------------------------------------- state
+    function pageCount() {
+        return Math.max(1, Math.ceil(displayRows.length / pageSize));
+    }
+    function buildState() {
+        const start = page * pageSize;
+        return {
+            status: parse.status,
+            failure: parse.status === 'failed' ? parse.failure : null,
+            diagnostics: parse.diagnostics,
+            headers: [...headers],
+            columnCount,
+            rowCount: rowOrder.length,
+            delimiter: document.delimiter,
+            detectionSource: document.detection.source,
+            sort,
+            sortedColumnType,
+            search,
+            matchedRowCount: displayRows.length,
+            showRowNumbers,
+            dirty: isDirty(),
+            canUndo: undoStack.length > 0,
+            canRedo: redoStack.length > 0,
+            page,
+            pageCount: pageCount(),
+            pageSize,
+            viewMode,
+            statsVisible,
+            visibleRowIds: displayRows.slice(start, start + pageSize).map((r) => r.id)
+        };
+    }
+    let state;
+    function commit() {
+        state = buildState();
+        for (const listener of listeners)
+            listener(state);
+    }
+    reparse(undefined);
+    state = buildState();
+    function dispatch(action) {
+        switch (action.type) {
+            case 'sort-column': {
+                if (action.columnIndex < 0 || action.columnIndex >= columnCount) {
+                    return;
+                }
+                sort = nextSortState(sort, action.columnIndex);
+                resort();
+                page = 0;
+                break;
+            }
+            case 'set-delimiter': {
+                // Reparsing would discard edits (docs §6 dirty guard).
+                if (isDirty())
+                    return;
+                reparse(action.delimiter === 'auto' ? undefined : action.delimiter);
+                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 firstVisiblePosition = page * pageSize;
+                pageSize = action.pageSize;
+                page = Math.floor(firstVisiblePosition / pageSize);
+                break;
+            }
+            case 'toggle-row-numbers': {
+                showRowNumbers = !showRowNumbers;
+                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': {
+                viewMode = action.mode;
+                break;
+            }
+            case 'toggle-stats': {
+                statsVisible = !statsVisible;
+                break;
+            }
+            case 'edit-cell': {
+                if (parse.status !== 'ok')
+                    return; // docs §6 결정 2
+                const row = byId.get(action.rowId);
+                if (!row)
+                    return;
+                if (action.columnIndex < 0 || action.columnIndex >= columnCount) {
+                    return;
+                }
+                const prev = row.cells[action.columnIndex] ?? '';
+                if (prev === action.value)
+                    return;
+                pushOp({
+                    kind: 'cell',
+                    rowId: action.rowId,
+                    columnIndex: action.columnIndex,
+                    prev,
+                    next: action.value
+                });
+                break;
+            }
+            case 'edit-header': {
+                if (parse.status !== 'ok')
+                    return;
+                if (action.columnIndex < 0 || action.columnIndex >= headers.length) {
+                    return;
+                }
+                const prev = headers[action.columnIndex] ?? '';
+                if (prev === action.value)
+                    return;
+                pushOp({
+                    kind: 'header',
+                    columnIndex: action.columnIndex,
+                    prev,
+                    next: action.value
+                });
+                break;
+            }
+            case 'insert-row': {
+                if (parse.status !== 'ok')
+                    return;
+                const row = {
+                    id: nextRowId++,
+                    cells: Array.from({ length: columnCount }, () => '')
+                };
+                let positions;
+                if (action.afterRowId === 'end') {
+                    positions = {
+                        order: rowOrder.length,
+                        sorted: sortedRows.length,
+                        display: displayRows.length
+                    };
+                }
+                else {
+                    const after = byId.get(action.afterRowId);
+                    if (!after)
+                        return;
+                    // The new row shows right below the clicked one regardless
+                    // of sort/filter — an invisible new row cannot be edited.
+                    positions = {
+                        order: (orderPos.get(after.id) ?? rowOrder.length - 1) + 1,
+                        sorted: sortedRows.indexOf(after) + 1 || sortedRows.length,
+                        display: displayRows.indexOf(after) + 1 || displayRows.length
+                    };
+                }
+                pushOp({ kind: 'insert', row, positions });
+                break;
+            }
+            case 'delete-row': {
+                if (parse.status !== 'ok')
+                    return;
+                const row = byId.get(action.rowId);
+                if (!row)
+                    return;
+                pushOp({
+                    kind: 'delete',
+                    row,
+                    positions: {
+                        order: orderPos.get(row.id) ?? 0,
+                        sorted: sortedRows.indexOf(row),
+                        display: displayRows.indexOf(row)
+                    }
+                });
+                break;
+            }
+            case 'insert-column': {
+                if (parse.status !== 'ok')
+                    return;
+                if (action.columnIndex < 0 || action.columnIndex > columnCount) {
+                    return;
+                }
+                pushOp({
+                    kind: 'insert-col',
+                    columnIndex: action.columnIndex,
+                    header: `Column${columnCount + 1}`
+                });
+                break;
+            }
+            case 'delete-column': {
+                if (parse.status !== 'ok')
+                    return;
+                // Deleting the last column would leave an unrepresentable
+                // zero-column document.
+                if (columnCount <= 1)
+                    return;
+                if (action.columnIndex < 0 || action.columnIndex >= columnCount) {
+                    return;
+                }
+                pushOp({
+                    kind: 'delete-col',
+                    columnIndex: action.columnIndex,
+                    header: headers[action.columnIndex] ?? '',
+                    cells: new Map(rowOrder.map((r) => [r.id, r.cells[action.columnIndex] ?? '']))
+                });
+                break;
+            }
+            case 'replace-document': {
+                if (parse.status !== 'ok')
+                    return;
+                if (action.text === toRawText())
+                    return;
+                // The active delimiter is forced so mid-edit text never flips
+                // the document to a surprise delimiter; switching stays with
+                // the delimiter select (and its dirty guard).
+                const parseOptions = { delimiter: document.delimiter };
+                if (options.fileName !== undefined)
+                    parseOptions.fileName = options.fileName;
+                if (options.limits !== undefined)
+                    parseOptions.limits = options.limits;
+                const next = parseCsv(action.text, parseOptions).result;
+                // A swap that cannot represent the full text (partial/failed,
+                // e.g. over the row limit) is refused; the good document stays.
+                // Emptied text parses 'ok' and legitimately empties the document.
+                if (next.status !== 'ok')
+                    return;
+                const nextRows = next.document.rows.map((cells) => ({
+                    id: nextRowId++,
+                    cells: [...cells]
+                }));
+                pushOp({
+                    kind: 'document',
+                    prev: {
+                        headers,
+                        rows: rowOrder.slice(),
+                        columnCount,
+                        parse,
+                        document
+                    },
+                    next: {
+                        headers: [...next.document.headers],
+                        rows: nextRows,
+                        columnCount: next.document.columnCount,
+                        parse: next,
+                        document: next.document
+                    }
+                });
+                page = 0;
+                break;
+            }
+            case 'undo': {
+                const op = undoStack.pop();
+                if (!op)
+                    return;
+                applyOp(op, 'backward');
+                redoStack.push(op);
+                break;
+            }
+            case 'redo': {
+                const op = redoStack.pop();
+                if (!op)
+                    return;
+                applyOp(op, 'forward');
+                undoStack.push(op);
+                break;
+            }
+        }
+        commit();
+    }
+    return {
+        get state() {
+            return state;
+        },
+        dispatch,
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+        getRowById(rowId) {
+            return byId.get(rowId)?.cells ?? [];
+        },
+        getRowNumber(rowId) {
+            return (orderPos.get(rowId) ?? -1) + 1;
+        },
+        getStatistics() {
+            if (!statsCache) {
+                statsCache = computeStatistics(rowOrder.map((r) => r.cells), headers);
+            }
+            return statsCache;
+        },
+        toTsv() {
+            // Copy targets the current display result: sorted + search-filtered
+            // (docs §6). sourceRowsLoaded below stays the unfiltered total.
+            return serializeRowsToTsv(displayRows.map((r) => r.cells), headers);
+        },
+        toJson() {
+            return serializeRowsToJson(displayRows.map((r) => r.cells), headers, {
+                scope: 'loaded-results',
+                sourceRowsLoaded: rowOrder.length,
+                sourceFullyScanned: parse.status === 'ok'
+            });
+        },
+        toCsv() {
+            return serializeRowsToCsv(displayRows.map((r) => r.cells), headers, document.delimiter);
+        },
+        toDocumentCsv() {
+            return documentCsv();
+        },
+        markSaved() {
+            savedDepth = undoStack.length;
+            savedUnreachable = false;
+            commit();
+        },
+        rawText: text,
+        toRawText
+    };
+}
+function emptyDocument() {
+    return {
+        headers: [],
+        rows: [],
+        columnCount: 0,
+        delimiter: ',',
+        detection: { delimiter: ',', confidence: 0, source: 'auto' }
+    };
+}
+function identity(n) {
+    return Array.from({ length: n }, (_, i) => i);
+}
+function clamp(v, min, max) {
+    return Math.min(Math.max(v, min), max);
+}

package/dist/viewers/csv/index.d.ts

@@ -0,0 +1,48 @@
+import type { ClipboardService, FileSaveService, FileWritebackService, HostContext } from '../../host/index.js';
+import { type MountOptions, type ViewerHandle, type ViewerInput } from '../types.js';
+import { type ResourceLimits } from '../../parsers/types.js';
+export { createCsvController, DEFAULT_PAGE_SIZE } from './controller.js';
+export type { CsvController, CsvViewState, CsvAction, CsvControllerOptions } from './controller.js';
+export { csvViewerCss } from './styles.js';
+/** Viewer metadata — single source for the registry codegen (DESIGN.md §7). */
+export declare const CSV_VIEWER_META: {
+    id: string;
+    displayNameKey: string;
+    extensions: string[];
+    priority: number;
+    requiredServices: readonly [];
+    optionalServices: readonly ["clipboard", "save", "writeback"];
+    inputOwnership: "borrows";
+};
+export type CsvViewerContext = HostContext & {
+    clipboard?: ClipboardService;
+    save?: FileSaveService;
+    writeback?: FileWritebackService;
+};
+/** CSV mount handle: dirty inspection lets hosts guard against re-renders
+ *  that would discard unsaved edits (docs §6). */
+export interface CsvViewerHandle extends ViewerHandle {
+    isDirty(): boolean;
+}
+/** Export file name: strip the extension, append -export, pick the extension
+ *  by the active delimiter (docs/viewers/csv.md §6). */
+export declare function exportFileName(sourceName: string, delimiter: string): string;
+/** Suggested filename for Save As. The host's FileSaveService presents the
+ * destination picker; this only supplies its initial filename. */
+export declare function saveAsFileName(sourceName: string, delimiter: string): string;
+export interface CsvMountOptions extends MountOptions {
+    /** Parser resource limits (docs/parsers/csv.md); adapters may tighten them. */
+    limits?: ResourceLimits;
+    pageSize?: number;
+}
+/** Clipboard copy guard (docs/viewers/csv.md §6): larger payloads are refused. */
+export declare const COPY_PAYLOAD_LIMIT_BYTES: number;
+/** Cells at least this long (or containing a newline) get a full-content tooltip. */
+export declare const CELL_TOOLTIP_MIN_CHARS = 50;
+/** Header single-click sort is deferred briefly so a double-click can win and
+ *  open the rename editor instead (docs §6). */
+export declare const SORT_CLICK_DELAY_MS = 250;
+/** Raw-view typing settles this long before the text is reparsed into the
+ *  document (docs §6 — the edit only marks dirty; saving stays explicit). */
+export declare const RAW_EDIT_DEBOUNCE_MS = 400;
+export declare function mountCsvViewer(input: ViewerInput, container: HTMLElement, ctx: CsvViewerContext, options?: CsvMountOptions): Promise<CsvViewerHandle>;