@iyulab/flex-table 0.10.0 → 0.10.1

package/dist/clipboard/clipboard.d.ts

@@ -0,0 +1,12 @@
+import type { CellRange } from '../core/selection.js';
+import type { ColumnDefinition, DataRow } from '../models/types.js';
+/**
+ * Copy selected range to clipboard as TSV.
+ */
+export declare function copyToClipboard(data: DataRow[], columns: ColumnDefinition[], range: CellRange): string;
+/**
+ * Parse TSV/CSV clipboard text into a 2D array of strings.
+ * Handles RFC 4180 quoted fields: double-quote escaping, embedded tabs/newlines.
+ */
+export declare function parseClipboardText(text: string): string[][];
+export declare function parseValueForColumn(raw: string, col: ColumnDefinition): unknown;

package/dist/clipboard/clipboard.test.d.ts

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

package/dist/core/editing.d.ts

@@ -0,0 +1,15 @@
+import type { CellPosition } from './selection.js';
+export interface EditState {
+    position: CellPosition;
+    originalValue: unknown;
+}
+/**
+ * Manages cell editing state.
+ */
+export declare class EditingState {
+    current: EditState | null;
+    start(position: CellPosition, originalValue: unknown): void;
+    isEditing(row: number, col: number): boolean;
+    cancel(): EditState | null;
+    commit(): EditState | null;
+}

package/dist/core/filtering.d.ts

@@ -0,0 +1,28 @@
+import type { DataRow } from '../models/types.js';
+/**
+ * Filter predicate function.
+ * Receives the cell value and the full row.
+ */
+export type FilterPredicate = (value: unknown, row: DataRow) => boolean;
+/**
+ * A filter applied to a specific column.
+ */
+export interface ColumnFilter {
+    /** Column key this filter applies to */
+    key: string;
+    /** Filter predicate */
+    predicate: FilterPredicate;
+}
+/**
+ * Callback invoked when a filter predicate throws an error.
+ */
+export type FilterErrorCallback = (error: unknown, row: DataRow, filter: ColumnFilter) => void;
+/**
+ * Compute filtered indices.
+ * Returns data indices that pass ALL filters (AND logic).
+ * Original data is never mutated.
+ *
+ * If a filter predicate throws, the row is included (fail-open)
+ * and the optional `onError` callback is invoked.
+ */
+export declare function computeFilteredIndices(data: DataRow[], filters: ColumnFilter[], onError?: FilterErrorCallback): number[];

package/dist/core/filtering.test.d.ts

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

package/dist/core/row-selection.d.ts

@@ -0,0 +1,23 @@
+import type { SelectionMode } from '../models/types.js';
+/**
+ * Manages row-level selection state (checkbox-based).
+ * Separate from cell-level SelectionState.
+ */
+export declare class RowSelectionState {
+    private _selected;
+    private _mode;
+    private _rowCount;
+    get mode(): SelectionMode;
+    set mode(value: SelectionMode);
+    setRowCount(count: number): void;
+    get selectedIndices(): number[];
+    get selectedCount(): number;
+    get isAllSelected(): boolean;
+    get isSomeSelected(): boolean;
+    isSelected(index: number): boolean;
+    toggle(index: number): void;
+    select(index: number): void;
+    deselect(index: number): void;
+    selectAll(): void;
+    deselectAll(): void;
+}

package/dist/core/selection.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Represents the active cell position.
+ */
+export interface CellPosition {
+    row: number;
+    col: number;
+}
+/**
+ * A rectangular range of cells.
+ */
+export interface CellRange {
+    startRow: number;
+    startCol: number;
+    endRow: number;
+    endCol: number;
+}
+/**
+ * Returns normalized range (start <= end).
+ */
+export declare function normalizeRange(range: CellRange): CellRange;
+/**
+ * Manages active cell state and range selection.
+ */
+export declare class SelectionState {
+    activeCell: CellPosition | null;
+    /** Anchor cell for range selection (Shift+Arrow/Click) */
+    rangeAnchor: CellPosition | null;
+    /** Current range end (the active cell is the range end during Shift selection) */
+    range: CellRange | null;
+    private _rowCount;
+    private _colCount;
+    setDimensions(rowCount: number, colCount: number): void;
+    setActive(row: number, col: number): CellPosition | null;
+    /** Set active cell and extend range from anchor */
+    setActiveWithRange(row: number, col: number): CellPosition | null;
+    /** Check if a cell is within the current selection range */
+    isInRange(row: number, col: number): boolean;
+    /** Get the effective range: either the explicit range or just the active cell */
+    getEffectiveRange(): CellRange | null;
+    clear(): void;
+    moveUp(): CellPosition | null;
+    moveDown(): CellPosition | null;
+    moveLeft(): CellPosition | null;
+    moveRight(): CellPosition | null;
+    moveNext(): CellPosition | null;
+    movePrev(): CellPosition | null;
+    moveToStart(): CellPosition | null;
+    moveToEnd(): CellPosition | null;
+    moveToRowStart(): CellPosition | null;
+    moveToRowEnd(): CellPosition | null;
+    shiftMoveUp(): CellPosition | null;
+    shiftMoveDown(): CellPosition | null;
+    shiftMoveLeft(): CellPosition | null;
+    shiftMoveRight(): CellPosition | null;
+}

package/dist/core/selection.test.d.ts

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

package/dist/core/sorting.d.ts

@@ -0,0 +1,27 @@
+import type { ColumnDefinition, DataRow } from '../models/types.js';
+/**
+ * Sort direction.
+ */
+export type SortDirection = 'asc' | 'desc';
+/**
+ * A single sort criterion.
+ */
+export interface SortCriteria {
+    /** Column key to sort by */
+    key: string;
+    /** Sort direction */
+    direction: SortDirection;
+}
+/**
+ * Compute sorted index mapping.
+ * Returns an array where result[visualIndex] = dataIndex.
+ * Original data is never mutated.
+ */
+export declare function computeSortedIndices(data: DataRow[], criteria: SortCriteria[], columns: ColumnDefinition[]): number[];
+/**
+ * Toggle sort for a column key in the criteria array.
+ * Cycle: none → asc → desc → none.
+ * If multi is true (Shift+click), add as secondary sort.
+ * If multi is false, replace all criteria with this column.
+ */
+export declare function toggleSort(criteria: SortCriteria[], key: string, multi: boolean): SortCriteria[];

package/dist/core/sorting.test.d.ts

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

package/dist/core/undo.d.ts

@@ -0,0 +1,45 @@
+/**
+ * A single undoable action.
+ */
+export interface UndoAction {
+    /** Human-readable label for debugging */
+    label: string;
+    /** Revert the action */
+    undo: () => void;
+    /** Re-apply the action */
+    redo: () => void;
+}
+/**
+ * Manages undo/redo history.
+ */
+export declare class UndoStack {
+    private _undoStack;
+    private _redoStack;
+    private _maxSize;
+    /** Get/set the maximum number of undo actions stored. */
+    get maxSize(): number;
+    set maxSize(value: number);
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    get undoCount(): number;
+    get redoCount(): number;
+    /**
+     * Push a new action onto the undo stack.
+     * Clears the redo stack (new action invalidates redo history).
+     */
+    push(action: UndoAction): void;
+    /**
+     * Undo the most recent action.
+     * Returns the action label, or null if nothing to undo.
+     */
+    undo(): string | null;
+    /**
+     * Redo the most recently undone action.
+     * Returns the action label, or null if nothing to redo.
+     */
+    redo(): string | null;
+    /**
+     * Clear all undo/redo history.
+     */
+    clear(): void;
+}

package/dist/core/undo.test.d.ts

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

package/dist/export/export.d.ts

@@ -0,0 +1,12 @@
+import type { ColumnDefinition, DataRow } from '../models/types.js';
+export type ExportFormat = 'csv' | 'tsv' | 'json';
+/**
+ * Export data to the specified format.
+ */
+export declare function exportData(data: DataRow[], columns: ColumnDefinition[], format: ExportFormat): string;
+/**
+ * Trigger a file download in the browser.
+ */
+export declare function downloadFile(content: string, filename: string, mimeType: string): void;
+export declare function getExportMimeType(format: ExportFormat): string;
+export declare function getExportExtension(format: ExportFormat): string;

package/dist/export/export.test.d.ts

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

package/dist/flex-table.d.ts

@@ -0,0 +1,237 @@
+import { LitElement } from 'lit';
+import type { ExportFormat } from './export/export.js';
+import type { CellPosition } from './core/selection.js';
+import type { SortCriteria } from './core/sorting.js';
+import type { FilterPredicate } from './core/filtering.js';
+import type { ColumnDefinition, DataRow, SelectionMode, DataMode } from './models/types.js';
+import type { TemplateResult } from 'lit';
+export declare class FlexTable extends LitElement {
+    static styles: import("lit").CSSResult;
+    columns: ColumnDefinition[];
+    data: DataRow[];
+    rowHeight: number;
+    showRowNumbers: boolean;
+    theme: 'light' | 'dark' | undefined;
+    maxRows: number;
+    editable: boolean;
+    showFilters: boolean;
+    /** Enable row-level checkbox selection. */
+    selectable: boolean;
+    /** Row selection mode: 'single' or 'multi' (default: 'multi'). */
+    set selectionMode(value: SelectionMode);
+    get selectionMode(): SelectionMode;
+    /** Data processing mode: 'client' (default) or 'server'. */
+    dataMode: DataMode;
+    /** Footer/summary row data. Keys match column keys; values are display strings. */
+    footerData: Record<string, string | TemplateResult> | null;
+    set maxUndoSize(value: number);
+    get maxUndoSize(): number;
+    private _scrollTop;
+    private _scrollLeft;
+    private _viewportHeight;
+    private _viewportWidth;
+    private _colLeftOffsets;
+    private _totalRowWidth;
+    private _activeCell;
+    private _editingCell;
+    private _sortCriteria;
+    private _selection;
+    private _editing;
+    private _rowSelection;
+    private _undo;
+    private _filters;
+    private _filteredIndices;
+    private _sortedIndices;
+    private _openFilterKey;
+    private _rowSelectionVersion;
+    private _viewDirty;
+    private _resizing;
+    private _resizeCleanup;
+    private _columnWidths;
+    get visibleColumns(): ColumnDefinition[];
+    private get _prefixWidth();
+    /** Whether an undo operation is available. */
+    get canUndo(): boolean;
+    /** Whether a redo operation is available. */
+    get canRedo(): boolean;
+    get activeCell(): CellPosition | null;
+    get editingCell(): CellPosition | null;
+    get sortCriteria(): SortCriteria[];
+    /** Number of rows after filtering (before pagination). */
+    get filteredRowCount(): number;
+    /** Get data indices of currently selected rows. */
+    getSelectedRows(): {
+        selectedIndices: number[];
+        selectedRows: DataRow[];
+    };
+    /** Select all visible rows (multi mode only). */
+    selectAll(): void;
+    /** Deselect all rows. */
+    deselectAll(): void;
+    private _dispatchRowSelectionEvent;
+    /**
+     * Set a filter for a column. Replaces any existing filter on the same key.
+     */
+    setFilter(key: string, predicate: FilterPredicate): void;
+    /**
+     * Remove the filter for a column.
+     */
+    removeFilter(key: string): void;
+    /**
+     * Remove all filters.
+     */
+    clearFilters(): void;
+    /**
+     * Get current active filter keys.
+     */
+    get filterKeys(): string[];
+    /**
+     * Explicitly request a re-render after external data mutations.
+     * Useful when `data` array contents are mutated in-place without reassignment.
+     */
+    refreshData(): void;
+    private _dispatchUndoStateEvent;
+    private _dispatchFilterEvent;
+    /**
+     * Add a column at the specified index (default: end).
+     * Returns the added column definition.
+     */
+    addColumn(def: ColumnDefinition, index?: number): ColumnDefinition;
+    /**
+     * Delete a column by its key.
+     * Removes related filters, sort criteria, and column width overrides.
+     */
+    deleteColumn(key: string): void;
+    /**
+     * Move a column to a new position.
+     * @param key Column key to move.
+     * @param newIndex Target index in the columns array.
+     */
+    moveColumn(key: string, newIndex: number): void;
+    /**
+     * Add a row at the specified index (default: end).
+     * Returns the new row.
+     */
+    addRow(row?: DataRow, index?: number): DataRow | null;
+    /**
+     * Delete rows at the specified data indices.
+     * If no indices provided, deletes the currently selected rows.
+     */
+    deleteRows(indices?: number[]): void;
+    /**
+     * Apply multiple cell changes as a single undo-able operation.
+     * @param changes Array of { row (data index), key, value } objects.
+     */
+    updateRows(changes: Array<{
+        row: number;
+        key: string;
+        value: unknown;
+    }>): void;
+    private _createEmptyRow;
+    /**
+     * Export table data to string in the specified format.
+     * @param options.selectionOnly - Export only the currently selected range
+     */
+    exportToString(format: ExportFormat, options?: {
+        selectionOnly?: boolean;
+    }): string;
+    /**
+     * Export table data and trigger file download.
+     */
+    exportToFile(format: ExportFormat, filename?: string): void;
+    private _getSelectedDataRows;
+    /**
+     * Get the effective width for a column, checking internal overrides first.
+     */
+    getColumnWidth(key: string): number | undefined;
+    private _getColWidth;
+    private get headerHeight();
+    /** Number of rows visible after filter + sort. */
+    private get _visibleRowCount();
+    private get totalBodyHeight();
+    private get visibleRange();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected firstUpdated(): void;
+    private _updateColOffsets;
+    private get visibleColRange();
+    protected willUpdate(changedProperties: Map<string, unknown>): void;
+    protected updated(): void;
+    /** Recompute filter → sort pipeline. */
+    private _recomputeView;
+    /** Map visual row index to data row index */
+    private _toDataIndex;
+    private _focusEditor;
+    private _measureViewport;
+    private _onScroll;
+    private _onDocumentClick;
+    private _onContextMenu;
+    private _onCellClickEvent;
+    private _onRowNumberClick;
+    private _onCellDblClick;
+    /** Check if a column is editable based on global + per-column settings */
+    private _isCellEditable;
+    private _startEdit;
+    private _commitEdit;
+    private _applyEdit;
+    private _cancelEdit;
+    private _onEditorKeyDown;
+    private _syncActiveCell;
+    private _onKeyDown;
+    private _handleCtrlKey;
+    private _handleAltKey;
+    private _handleNavigation;
+    private _handleCopy;
+    private _handlePaste;
+    private _readClipboardText;
+    private _expandRowsForPaste;
+    private _applyPasteData;
+    private _handleDelete;
+    private _clearRange;
+    private _scrollToActiveCell;
+    private _dispatchSelectionEvent;
+    private _onHeaderClick;
+    private _selectColumn;
+    /** Public API: select an entire column by index. */
+    selectColumn(colIndex: number): void;
+    /** Calculate cumulative left offset for a left-pinned column */
+    private _getPinnedLeft;
+    /** Calculate cumulative right offset for a right-pinned column */
+    private _getPinnedRight;
+    private _renderHeaderCell;
+    private _adjustFilterDropdown;
+    private _onFilterBtnClick;
+    private _renderFilterDropdown;
+    private _renderTextFilter;
+    private _renderNumberFilter;
+    private _invalidCells;
+    private _cellKey;
+    private _markCellInvalid;
+    private _isCellInvalid;
+    private _textFilterState;
+    private _numberFilterState;
+    private _dateFilterState;
+    private _applyNumberFilter;
+    private _renderDateFilter;
+    private _applyDateFilter;
+    private _renderBooleanFilter;
+    private _clearColumnFilter;
+    private _onResizeAutoFit;
+    private _onResizeStart;
+    render(): TemplateResult<1>;
+    private _onSelectAllChange;
+    private _onRowCheckboxChange;
+    private _renderFooter;
+    private _renderRow;
+    private _renderCell;
+    private _renderEditor;
+    /** Convert value to YYYY-MM-DD for date input (local timezone) */
+    private _toDateInputValue;
+    /** Convert value to YYYY-MM-DDTHH:mm for datetime-local input (local timezone) */
+    private _toDateTimeInputValue;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'flex-table': FlexTable;
+    }
+}

package/dist/flex-table.test.d.ts

@@ -0,0 +1 @@
+import './flex-table.js';

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { FlexTable } from './flex-table.js';
+export type { ColumnDefinition, ColumnType, DataRow, CellRenderer, CellEditor, CellValidator, SelectionMode, DataMode } from './models/types.js';
+export type { CellPosition, CellRange } from './core/selection.js';
+export type { SortCriteria, SortDirection } from './core/sorting.js';
+export type { ColumnFilter, FilterPredicate, FilterErrorCallback } from './core/filtering.js';
+export { RowSelectionState } from './core/row-selection.js';
+export { UndoStack } from './core/undo.js';
+export type { UndoAction } from './core/undo.js';
+export type { ExportFormat } from './export/export.js';
+export { exportData } from './export/export.js';
+export { renderCell } from './renderers/cell-renderer.js';

package/dist/models/types.d.ts

@@ -0,0 +1,65 @@
+import type { TemplateResult } from 'lit';
+/**
+ * Built-in column data types for rendering and editing.
+ * Any string is accepted as a type — unknown types fall back to 'text' behavior.
+ */
+export type ColumnType = 'text' | 'number' | 'boolean' | 'date' | 'datetime' | (string & {});
+/**
+ * Custom cell renderer function.
+ * Receives the cell value, the full row data, and the column definition.
+ * Returns either a Lit TemplateResult or a plain string.
+ */
+export type CellRenderer = (value: unknown, row: DataRow, col: ColumnDefinition) => TemplateResult | string;
+/**
+ * Custom cell editor function.
+ * Receives the cell value, the full row data, and the column definition.
+ * Should return a Lit TemplateResult containing an input element with class "ft-editor".
+ */
+export type CellEditor = (value: unknown, row: DataRow, col: ColumnDefinition) => TemplateResult;
+/**
+ * Cell validator function. Returns null/undefined if valid, or an error message string.
+ */
+export type CellValidator = (value: unknown, row: DataRow, col: ColumnDefinition) => string | null | undefined;
+/**
+ * Row selection mode.
+ */
+export type SelectionMode = 'single' | 'multi';
+/**
+ * Data processing mode.
+ * - 'client': flex-table performs sorting/filtering locally (default).
+ * - 'server': flex-table only dispatches events; consumer provides pre-sorted/filtered data.
+ */
+export type DataMode = 'client' | 'server';
+/**
+ * Definition of a single column in the table.
+ */
+export interface ColumnDefinition {
+    /** Unique key matching data property names */
+    key: string;
+    /** Display header text */
+    header: string;
+    /** Data type for rendering/editing (default: 'text'). Unknown types fall back to 'text'. */
+    type?: ColumnType;
+    /** Column width in pixels (default: auto) */
+    width?: number;
+    /** Minimum column width in pixels (default: 40) */
+    minWidth?: number;
+    /** Whether the column is hidden */
+    hidden?: boolean;
+    /** Whether the column is sortable (default: true) */
+    sortable?: boolean;
+    /** Custom cell renderer — overrides built-in type rendering */
+    renderer?: CellRenderer;
+    /** Whether the column is editable (default: true — follows global editable setting) */
+    editable?: boolean;
+    /** Custom cell editor — overrides built-in type editing */
+    editor?: CellEditor;
+    /** Pin the column to one side during horizontal scroll */
+    pinned?: 'left' | 'right';
+    /** Cell validator — called before committing edits */
+    validator?: CellValidator;
+}
+/**
+ * A single data row — schema-agnostic key-value map.
+ */
+export type DataRow = Record<string, unknown>;

package/dist/odata/index.d.ts

@@ -0,0 +1,2 @@
+export { useODataSource } from './use-odata-source.js';
+export type { UseODataSourceOptions, UseODataSourceResult } from './types.js';

package/dist/odata/types.d.ts

@@ -0,0 +1,19 @@
+import type { SortCriteria } from '../core/sorting.js';
+export interface UseODataSourceOptions {
+    pageSize?: number;
+    defaultOrderBy?: string;
+    fixedFilter?: Record<string, unknown>;
+}
+export interface UseODataSourceResult<T> {
+    data: T[];
+    totalCount: number;
+    loading: boolean;
+    error: string | null;
+    page: number;
+    setPage: (page: number) => void;
+    sortCriteria: SortCriteria[];
+    onSortChange: (e: CustomEvent) => void;
+    setSearch: (term: string) => void;
+    search: string;
+    refresh: () => void;
+}

package/dist/odata/use-odata-source.d.ts

@@ -0,0 +1,6 @@
+import type { UseODataSourceOptions, UseODataSourceResult } from './types.js';
+/**
+ * OData v4 서버 사이드 데이터소스 React 훅.
+ * flex-table의 dataMode="server"와 함께 사용한다.
+ */
+export declare function useODataSource<T = Record<string, unknown>>(url: string, options?: UseODataSourceOptions): UseODataSourceResult<T>;

package/dist/react.d.ts

@@ -0,0 +1,29 @@
+import { type EventName } from '@lit/react';
+import { FlexTable } from './flex-table.js';
+export declare const FlexTableReact: import("@lit/react").ReactWebComponent<FlexTable, {
+    onCellSelect: EventName<CustomEvent>;
+    onCellEditCommit: EventName<CustomEvent>;
+    onCellEditCancel: EventName<CustomEvent>;
+    onCellEditStart: EventName<CustomEvent>;
+    onSortChange: EventName<CustomEvent>;
+    onFilterChange: EventName<CustomEvent>;
+    onRowAdd: EventName<CustomEvent>;
+    onRowDelete: EventName<CustomEvent>;
+    onColumnResize: EventName<CustomEvent>;
+    onColumnSelect: EventName<CustomEvent>;
+    onColumnAdd: EventName<CustomEvent>;
+    onColumnDelete: EventName<CustomEvent>;
+    onColumnReorder: EventName<CustomEvent>;
+    onSelectionChange: EventName<CustomEvent>;
+    onClipboardCopy: EventName<CustomEvent>;
+    onClipboardCut: EventName<CustomEvent>;
+    onClipboardPaste: EventName<CustomEvent>;
+    onClipboardError: EventName<CustomEvent>;
+    onUndoStateChange: EventName<CustomEvent>;
+    onValidationError: EventName<CustomEvent>;
+    onBatchUpdate: EventName<CustomEvent>;
+    onContextMenu: EventName<CustomEvent>;
+    onFilterError: EventName<CustomEvent>;
+}>;
+export type { FlexTable };
+export type { ColumnDefinition, DataRow, ColumnType, CellRenderer, CellEditor, CellValidator, SelectionMode, DataMode } from './models/types.js';

package/dist/renderers/cell-renderer.d.ts

@@ -0,0 +1,5 @@
+import type { ColumnDefinition, DataRow } from '../models/types.js';
+/**
+ * Render a cell value using the column's custom renderer or built-in type rendering.
+ */
+export declare function renderCell(value: unknown, row: DataRow, col: ColumnDefinition): unknown;

package/dist/styles/flex-table.styles.d.ts

@@ -0,0 +1 @@
+export declare const flexTableStyles: import("lit").CSSResult;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iyulab/flex-table",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "description": "A minimalist, input-centric data grid web component",
   "type": "module",
   "main": "./dist/flex-table.js",
@@ -25,7 +25,7 @@
   ],
   "scripts": {
     "dev": "vite serve demo",
-    "build": "tsc && vite build",
+    "build": "vite build && tsc --emitDeclarationOnly",
     "build:demo": "vite build --config vite.config.demo.ts",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",