open-grid 0.2.0

package/dist/types/core/CellEditManager.d.ts

@@ -0,0 +1,46 @@
+import { DataLayer } from './DataLayer.js';
+import { ColumnLayout } from './ColumnLayout.js';
+import { GridRenderer } from './GridRenderer.js';
+import { CellEditor } from './editors/CellEditor.js';
+import { ColumnDef } from './types.js';
+
+export interface CellEditDeps<T extends Record<string, any>> {
+    data: DataLayer<T>;
+    colLayout: ColumnLayout<T>;
+    getRenderer: () => GridRenderer | null;
+    getContainer: () => HTMLElement;
+    getOptions: () => any;
+    emit: (event: string, ...args: any[]) => void;
+    doRender: () => void;
+    announce: (msg: string) => void;
+    writeCell: (ri: number, field: string, value: any) => void;
+    scrollToRow: (ri: number) => void;
+    getVisibleLeaves: () => ColumnDef<T>[];
+}
+export declare class CellEditManager<T extends Record<string, any> = any> {
+    private _activeEditor;
+    private _editCell;
+    private _focusCell;
+    private _dragColIdx;
+    private _d;
+    constructor(deps: CellEditDeps<T>);
+    get activeEditor(): CellEditor | null;
+    get editCell(): {
+        ri: number;
+        ci: number;
+    } | null;
+    get focusCell(): {
+        ri: number;
+        ci: number;
+    } | null;
+    get dragColIdx(): number | null;
+    set dragColIdx(v: number | null);
+    setFocusCell(ri: number, ci: number): void;
+    clearFocusCell(): void;
+    startEditByKey(rowIndex: number, colIndex: number): void;
+    startEdit(rowIndex: number, colIndex: number, _e: MouseEvent): void;
+    commitEdit(): void;
+    commitEditWithValue(ri: number, ci: number, value: any): void;
+    cancelEdit(): void;
+    private _finishEdit;
+}

package/dist/types/core/CellEventHandler.d.ts

@@ -0,0 +1,28 @@
+import { DataLayer } from './DataLayer.js';
+import { ColumnLayout } from './ColumnLayout.js';
+import { CellEditManager } from './CellEditManager.js';
+import { RowManager } from './RowManager.js';
+
+export interface CellEventDeps<T extends Record<string, any>> {
+    getData: () => DataLayer<T>;
+    getColLayout: () => ColumnLayout<T>;
+    getOptions: () => any;
+    getEditMgr: () => CellEditManager<T>;
+    getRowMgr: () => RowManager<T>;
+    emit: (event: string, ...args: any[]) => void;
+    writeCell: (ri: number, field: string, value: any) => void;
+    doRender: () => void;
+    getContainer: () => HTMLElement;
+}
+export declare class CellEventHandler<T extends Record<string, any> = any> {
+    private _d;
+    constructor(deps: CellEventDeps<T>);
+    handleCellClick(rowIndex: number, colIndex: number, e: MouseEvent): void;
+    handleCellDblClick(rowIndex: number, colIndex: number, e: MouseEvent): void;
+    handleCellMouseOver(ri: number, ci: number, e: MouseEvent): void;
+    handleCellMouseOut(ri: number, ci: number, e: MouseEvent): void;
+    handleCellMouseDown(ri: number, ci: number, e: MouseEvent): void;
+    handleCellMouseUp(ri: number, ci: number, e: MouseEvent): void;
+    handleCellMouseMove(ri: number, ci: number, e: MouseEvent): void;
+    handleCellKeyEvt(eventName: 'cellKeyDown' | 'cellKeyUp' | 'cellKeyPress', e: KeyboardEvent): void;
+}

package/dist/types/core/CellTypeRegistry.d.ts

@@ -0,0 +1,5 @@
+import { ColumnDef } from './types.js';
+
+export declare function isToggleCol<T>(col: ColumnDef<T>): boolean;
+export declare function isSelectCol<T>(col: ColumnDef<T>): boolean;
+export declare function isRadioCol<T>(col: ColumnDef<T>): boolean;

package/dist/types/core/ColumnLayout.d.ts

@@ -0,0 +1,41 @@
+import { ColumnDef } from './types.js';
+
+export interface FlatColumn<T = any> extends ColumnDef<T> {
+    _colIndex: number;
+    _depth: number;
+    _leaf: boolean;
+    _colSpanCount?: number;
+    _rowSpanCount?: number;
+}
+export interface HeaderCell {
+    column: FlatColumn;
+    colIndex: number;
+    depth: number;
+    colSpan: number;
+    rowSpan: number;
+}
+export declare class ColumnLayout<T = any> {
+    private _columns;
+    private _flatLeaves;
+    private _maxDepth;
+    private _frozenCount;
+    constructor(columns: ColumnDef<T>[], frozenCount?: number);
+    private _process;
+    get leaves(): FlatColumn<T>[];
+    get visibleLeaves(): FlatColumn<T>[];
+    get headerDepth(): number;
+    get frozenCount(): number;
+    setFrozen(count: number): void;
+    setColumns(columns: ColumnDef<T>[]): void;
+    hideColumn(field: string | string[]): void;
+    showColumn(field: string | string[]): void;
+    addColumn(colDef: ColumnDef<T>, position?: 'first' | 'last' | number): void;
+    removeColumn(field: string): void;
+    getColumnByField(field: string): FlatColumn<T> | undefined;
+    getColumnByIndex(index: number): FlatColumn<T> | undefined;
+    getColumnIndex(field: string): number;
+    /** 헤더 렌더링용 셀 계산 */
+    buildHeaderCells(): HeaderCell[][];
+    /** 각 리프 컬럼의 계산된 너비 배열 반환 */
+    computeWidths(totalWidth: number, defaultWidth?: number): number[];
+}

package/dist/types/core/ContextMenu.d.ts

@@ -0,0 +1,33 @@
+import { ContextMenuItem } from './types.js';
+
+export type { ContextMenuItem };
+export interface ContextMenuActions {
+    onSortAsc: () => void;
+    onSortDesc: () => void;
+    onFind: () => void;
+    onExcel: () => void;
+    onCsv: () => void;
+    onPrint: () => void;
+}
+export declare const DEFAULT_CONTEXT_ITEMS: ContextMenuItem[];
+export declare class ContextMenuManager {
+    private readonly _anchor;
+    private readonly _actions;
+    private _el;
+    private _docClick;
+    private _docKey;
+    private _docScroll;
+    private _docMouseMove;
+    private _focusIdx;
+    /**
+     * @param _anchor  그리드 컨테이너 엘리먼트 — CSS 변수 상속 기준점
+     * @param _actions 기본 액션 핸들러 (OpenGrid에서 주입)
+     */
+    constructor(_anchor: HTMLElement, _actions: ContextMenuActions);
+    open(e: MouseEvent, customItems?: ContextMenuItem[]): void;
+    close(): void;
+    destroy(): void;
+    private _position;
+    private _moveFocus;
+    private _runAction;
+}

package/dist/types/core/DataLayer.d.ts

@@ -0,0 +1,65 @@
+import { SortItem, FilterItem } from './types.js';
+
+type RowState = 'added' | 'edited' | 'removed' | 'none';
+export declare class DataLayer<T extends Record<string, any> = any> {
+    private _data;
+    private _original;
+    private _meta;
+    private _idField;
+    private _displayIndexes;
+    private _idMap;
+    private _findQuery;
+    private _findFields;
+    constructor(idField?: string);
+    setData(data: T[]): void;
+    getData(): T[];
+    getOriginalData(): T[];
+    getAllData(): T[];
+    clearData(): void;
+    get rowCount(): number;
+    get totalRowCount(): number;
+    addRow(item: Partial<T>, position?: 'first' | 'last' | number): void;
+    removeRow(rowIndex: number): T | undefined;
+    moveRow(fromDisplayIdx: number, toDisplayIdx: number): void;
+    updateCell(rowIndex: number, field: string, value: any): boolean;
+    getRowByIndex(rowIndex: number): T | undefined;
+    getCellValue(rowIndex: number, field: string): any;
+    /** 수정된 행만 반환 (추가/삭제 제외) */
+    getEditedRows(): T[];
+    /** 수정된 행만 반환 (하위 호환용 — 신규 코드는 getEditedRows() 사용) */
+    getChangedRows(): T[];
+    getAddedRows(): T[];
+    getRemovedRows(): T[];
+    /**
+     * 추가/수정/삭제 모든 변경사항을 한 번에 반환.
+     * edited 행에는 _changedFields 배열도 포함.
+     */
+    getChanges(): {
+        added: T[];
+        edited: T[];
+        removed: T[];
+    };
+    /**
+     * 수정된 컬럼 정보 반환 — 각 edited 행에 대해 { row, fields, diff } 반환.
+     * diff: { field, oldValue, newValue }[]
+     */
+    getChangedColumns(): Array<{
+        row: T;
+        fields: string[];
+        diff: Array<{
+            field: string;
+            oldValue: any;
+            newValue: any;
+        }>;
+    }>;
+    /** rowIndex 행의 원본(수정 전) 데이터 반환. 추가된 행은 undefined. */
+    getOriginalRow(rowIndex: number): T | undefined;
+    getRowsWithState(stateField: string): T[];
+    getRowState(rowIndex: number): RowState;
+    applySort(sortList: SortItem[]): void;
+    applyFilter(filters: Record<string, FilterItem[]>): void;
+    /** F3: 찾기 바 전체 컬럼 OR 검색 설정 */
+    setFindFilter(query: string, fields: string[]): void;
+    private _rebuildIdMap;
+}
+export {};

package/dist/types/core/EventEmitter.d.ts

@@ -0,0 +1,11 @@
+type Handler = (...args: any[]) => any;
+export declare class EventEmitter {
+    private listeners;
+    on(event: string, handler: Handler): this;
+    once(event: string, handler: Handler): this;
+    off(event: string, handler?: Handler): this;
+    emit(event: string, ...args: any[]): boolean;
+    removeAllListeners(event?: string): this;
+    listenerCount(event: string): number;
+}
+export {};

package/dist/types/core/ExportManager.d.ts

@@ -0,0 +1,28 @@
+import { ColumnLayout } from './ColumnLayout.js';
+import { WorksheetManager } from './WorksheetManager.js';
+import { ExportOptions } from './types.js';
+
+export interface ExportDeps<T extends Record<string, any>> {
+    getData: () => T[];
+    getColLayout: () => ColumnLayout<T>;
+    getColWidths: () => number[];
+    getOptions: () => any;
+    getContainer: () => HTMLElement;
+    getMaskEnabled: (field: string) => boolean;
+    getWsManager: () => WorksheetManager<T> | null;
+}
+export declare class ExportManager<T extends Record<string, any> = any> {
+    private _d;
+    constructor(deps: ExportDeps<T>);
+    private _readCssVar;
+    private _hexToXlsxRgb;
+    exportExcel(options?: ExportOptions | string): void;
+    exportCsv(options?: ExportOptions | string): void;
+    exportJson(options?: ExportOptions | string): void;
+    print(options?: {
+        title?: string;
+        excludeFields?: string[];
+        footerText?: string;
+    }): void;
+    exportSheetsExcel(filename?: string): void;
+}

package/dist/types/core/FilterPanel.d.ts

@@ -0,0 +1,20 @@
+import { FilterItem } from './types.js';
+
+export type FilterApplyFn = (field: string, items: FilterItem[]) => void;
+export type FilterClearFn = (field: string) => void;
+/**
+ * 컬럼 헤더 필터 드롭다운 패널.
+ * 단일 인스턴스를 재사용(열릴 때 위치 재계산).
+ */
+export declare class FilterPanel {
+    private _el;
+    private _field;
+    private _onApply;
+    private _onClear;
+    private _outsideHandler;
+    constructor(container: HTMLElement, onApply: FilterApplyFn, onClear: FilterClearFn);
+    open(field: string, anchorEl: HTMLElement, currentFilters: FilterItem[]): void;
+    close(): void;
+    get isOpen(): boolean;
+    destroy(): void;
+}

package/dist/types/core/FilterSelect.d.ts

@@ -0,0 +1,96 @@
+import { FilterItem } from './types.js';
+
+export interface FilterSelectOption {
+    value: string;
+    text: string;
+}
+/**
+ * 캐스케이딩 필터 셀렉트 컬럼 정의.
+ *
+ * ### 데이터 공급 방식 (택 1)
+ *
+ * **A. JSON 배열 바인딩** (권장)
+ * ```ts
+ * {
+ *   field: 'brand',
+ *   label: '브랜드',
+ *   data: brandList,          // any[]  ← JSON 배열
+ *   valueKey: 'brandCode',    // 필터·선택값으로 사용할 키
+ *   textKey:  'brandName',    // 화면에 표시할 텍스트 키
+ *   filterKey: 'brand',       // 그리드 행 데이터의 필터 기준 키 (기본: field)
+ *   dependsOn:    'category', // 부모 컬럼 field
+ *   dependsOnKey: 'catCode',  // 자식 data[]에서 부모값과 매칭할 키
+ * }
+ * ```
+ *
+ * **B. 정적 옵션 배열**
+ * ```ts
+ * { field: 'status', options: [{ value: 'Y', text: '활성' }] }
+ * ```
+ */
+export interface FilterSelectColumn {
+    /** 캐스케이딩 식별자 / 기본 필터 키 */
+    field: string;
+    /** 화면 표시 라벨 */
+    label: string;
+    /** 바인딩할 JSON 배열 */
+    data?: any[];
+    /** data[]에서 option value로 사용할 키 */
+    valueKey?: string;
+    /** data[]에서 화면 표시 text로 사용할 키 (미지정 시 valueKey 사용) */
+    textKey?: string;
+    /**
+     * 그리드 행 데이터에서 실제 필터링할 키.
+     * 미지정 시 `field` 값 그대로 사용.
+     *
+     * @example
+     * // 그리드 row.category === selectedValue 로 필터링
+     * filterKey: 'category'
+     */
+    filterKey?: string;
+    options?: FilterSelectOption[];
+    /** 부모 컬럼의 field 명 */
+    dependsOn?: string;
+    /**
+     * 자식 data[]에서 부모 선택값과 비교할 키.
+     *
+     * @example
+     * // brandList.filter(b => b.catCode === parentSelectedValue)
+     * dependsOnKey: 'catCode'
+     */
+    dependsOnKey?: string;
+}
+export interface FilterSelectConfig {
+    columns: FilterSelectColumn[];
+    /** fieldset 제목 (기본: '필터') */
+    legend?: string;
+}
+type FilterFn = (field: string, items: FilterItem[]) => void;
+type ResetFn = (field?: string) => void;
+export declare class FilterSelectPanel {
+    private _el;
+    private _selects;
+    /** 현재 선택 상태 { field → selectedValue } */
+    private _selected;
+    private _config;
+    private _onFilter;
+    private _onReset;
+    constructor(container: HTMLElement, config: FilterSelectConfig, onFilter: FilterFn, onReset: ResetFn, gridId?: string);
+    /**
+     * 컬럼의 옵션 목록을 계산한다.
+     *
+     * @param col         대상 컬럼 정의
+     * @param parentValue 부모 선택값 (캐스케이딩 필터에 사용)
+     */
+    private _resolve;
+    private _fill;
+    private _onChange;
+    /**
+     * 부모 컬럼 변경 후 자식 컬럼 옵션을 재계산한다 (재귀).
+     */
+    private _cascade;
+    private _reset;
+    reset(): void;
+    destroy(): void;
+}
+export {};

package/dist/types/core/FindBarManager.d.ts

@@ -0,0 +1,26 @@
+import { ColumnLayout } from './ColumnLayout.js';
+import { DataLayer } from './DataLayer.js';
+import { Pagination } from './Pagination.js';
+import { VirtualScroll } from './VirtualScroll.js';
+
+export interface FindBarDeps<T extends Record<string, any>> {
+    getColLayout: () => ColumnLayout<T>;
+    getData: () => DataLayer<T>;
+    getFilters: () => Record<string, any[]>;
+    getVs: () => VirtualScroll | null;
+    getPagination: () => Pagination | null;
+    doRender: () => void;
+}
+export declare class FindBarManager<T extends Record<string, any> = any> {
+    private _bar;
+    private _input;
+    private _count;
+    private _filter;
+    private _d;
+    constructor(deps: FindBarDeps<T>);
+    get findFilter(): string;
+    init(container: HTMLElement): void;
+    open(): void;
+    close(): void;
+    private _apply;
+}

package/dist/types/core/FooterManager.d.ts

@@ -0,0 +1,16 @@
+import { ColumnLayout } from './ColumnLayout.js';
+
+export interface FooterDeps<T extends Record<string, any>> {
+    getData: () => T[];
+    getColLayout: () => ColumnLayout<T>;
+    getColWidths: () => number[];
+    getOptions: () => any;
+    getContainer: () => HTMLElement;
+}
+export declare class FooterManager<T extends Record<string, any> = any> {
+    private _d;
+    constructor(deps: FooterDeps<T>);
+    fmtNum(value: number, fmt?: string): string;
+    computeValues(): any[];
+    render(): void;
+}

package/dist/types/core/FormulaEngine.d.ts

@@ -0,0 +1,10 @@
+import { OGDecimal, OGDecimalLike } from './OGDecimal.js';
+
+export type FormulaContext = Record<string, OGDecimalLike>;
+/**
+ * 문자열 수식을 평가해 OGDecimal 결과를 반환한다.
+ * @param expr - 수식 문자열 (예: "[price] * [qty] * 0.035")
+ * @param ctx  - 필드값 컨텍스트 (행 데이터)
+ * @param divisionPrecision - 나눗셈 소수점 자리수 (기본 30)
+ */
+export declare function evaluateFormula(expr: string, ctx: FormulaContext, divisionPrecision?: number): OGDecimal;

package/dist/types/core/GridRenderer.d.ts

@@ -0,0 +1,42 @@
+import { DataLayer } from './DataLayer.js';
+import { RowDragDrop } from './RowDragDrop.js';
+import { MergeEngine } from './MergeEngine.js';
+import { ColumnDef, SortItem } from './types.js';
+
+export interface RendererCallbacks {
+    onHeaderClick: (field: string, shiftKey: boolean) => void;
+    onCellClick: (ri: number, ci: number, e: MouseEvent) => void;
+    onCellDblClick: (ri: number, ci: number, e: MouseEvent) => void;
+    onCellMouseOver: (ri: number, ci: number, e: MouseEvent) => void;
+    onCellMouseOut: (ri: number, ci: number, e: MouseEvent) => void;
+    onCellMouseDown: (ri: number, ci: number, e: MouseEvent) => void;
+    onCellMouseUp: (ri: number, ci: number, e: MouseEvent) => void;
+    onCellMouseMove: (ri: number, ci: number, e: MouseEvent) => void;
+    onRowCheck: (ri: number, checked: boolean) => void;
+    onAllCheck: (checked: boolean) => void;
+    onColResize: (colIndex: number, newWidth: number) => void;
+    onFilterIconClick: (field: string, anchorEl: HTMLElement) => void;
+    getDndManager: () => RowDragDrop | null;
+    onColDragStart: (colIndex: number) => void;
+    onColDrop: (toIndex: number) => void;
+    getColDragIdx: () => number | null;
+}
+export declare class GridRenderer {
+    private _root;
+    private _header;
+    private _bodyWrap;
+    private _body;
+    private _opts;
+    private _cbs;
+    private _cellMap;
+    get bodyWrapper(): HTMLElement;
+    constructor(root: HTMLElement, opts: any, cbs: RendererCallbacks);
+    updateSize(totalHeight: number, headerHeight: number): void;
+    renderHeader(headerRows: any[][], leaves: ColumnDef[], widths: number[], sortList: SortItem[], opts: any): void;
+    renderBody(startIndex: number, endIndex: number, data: DataLayer<any>, leaves: ColumnDef[], widths: number[], opts: any, offsetY: number, totalHeight: number, selectedRows: Set<number>, checkedRows: Set<number>, groupFlatRows?: Array<any> | null, onGroupToggle?: (key: string) => void, onTreeToggle?: (nodeId: any) => void, extraOpts?: Record<string, any>, mergeEngine?: MergeEngine): void;
+    getCellEl(rowIndex: number, colIndex: number): HTMLElement | undefined;
+    destroy(): void;
+}
+export declare function _el(tag: string, className?: string): HTMLElement;
+export declare function _style(el: HTMLElement, styles: Partial<CSSStyleDeclaration>): void;
+export declare function _downloadText(content: string, filename: string, mime?: string): void;

package/dist/types/core/GroupEngine.d.ts

@@ -0,0 +1,47 @@
+import { SummaryOp } from './types.js';
+
+export interface GroupRow<T = any> {
+    _isGroup: true;
+    _groupField: string;
+    _groupValue: any;
+    _groupLabel: string;
+    _depth: number;
+    _expanded: boolean;
+    _childCount: number;
+    _summary: Record<string, any>;
+    _summaryFmt: Record<string, string>;
+    _states: {
+        added: number;
+        edited: number;
+        removed: number;
+    };
+    children: Array<GroupRow<T> | T>;
+}
+export type GroupItem<T> = GroupRow<T> | T;
+export interface SummaryDef {
+    field: string;
+    op: SummaryOp;
+    label?: string;
+    format?: string;
+}
+declare function _isGroup<T>(item: any): item is GroupRow<T>;
+/** flat 데이터를 fields 기준으로 계층 그룹핑 */
+export declare function buildGroups<T extends Record<string, any>>(data: T[], fields: string[], summaryDefs?: SummaryDef[], expandedKeys?: Set<string>, getRowState?: (row: T) => string): GroupRow<T>[];
+/**
+ * 숫자 포맷팅 (GroupEngine 내부 + 외부 공용)
+ * '#,##0'    → 천단위 콤마, 정수
+ * '#,##0.00' → 천단위 콤마, 소수 2자리
+ * '0.00'     → 소수 2자리 (콤마 없음)
+ * '2'        → 소수 2자리 (하위 호환)
+ */
+export declare function _fmtNum(value: number, fmt?: string): string;
+/**
+ * 그룹 트리를 화면에 표시할 flat 행 배열로 변환.
+ * 접힌 그룹(expanded=false)의 자식은 포함하지 않음.
+ */
+export declare function flattenGroups<T>(groups: GroupRow<T>[]): Array<GroupRow<T> | T>;
+/** 특정 그룹 키의 펼침 상태를 토글 */
+export declare function toggleGroup<T>(groups: GroupRow<T>[], groupKey: string, expandedKeys: Set<string>): void;
+/** 모든 그룹 키 수집 */
+export declare function collectAllKeys<T>(groups: GroupRow<T>[], parentKey?: string): string[];
+export { _isGroup };

package/dist/types/core/GroupTreeManager.d.ts

@@ -0,0 +1,43 @@
+import { DataLayer } from './DataLayer.js';
+import { VirtualScroll } from './VirtualScroll.js';
+import { GroupRow } from './GroupEngine.js';
+import { TreeNode } from './TreeEngine.js';
+
+export interface GroupTreeDeps<T extends Record<string, any>> {
+    getData: () => T[];
+    getDataLayer: () => DataLayer<T>;
+    getOptions: () => any;
+    getVs: () => VirtualScroll | null;
+    doRenderFull: (totalRows: number) => void;
+    doRender: () => void;
+}
+export declare class GroupTreeManager<T extends Record<string, any> = any> {
+    private _groupFields;
+    private _groupExpandedKeys;
+    private _groupFlatRows;
+    private _isGroupMode;
+    private _treeRoots;
+    private _treeFlatRows;
+    private _treeExpandedKeys;
+    private _isTreeMode;
+    private _d;
+    constructor(deps: GroupTreeDeps<T>);
+    get isGroupMode(): boolean;
+    get isTreeMode(): boolean;
+    get groupFlatRows(): Array<GroupRow<T> | T>;
+    get treeFlatRows(): TreeNode<T>[];
+    groupBy(fields: string[]): void;
+    clearGroup(): void;
+    expandAll(): void;
+    collapseAll(): void;
+    handleGroupToggle(groupKey: string): void;
+    rebuildGroups(): void;
+    enableTree(): void;
+    disableTree(): void;
+    expandNodes(ids: any | any[], open?: boolean): void;
+    expandAllNodes(): void;
+    collapseAllNodes(): void;
+    handleTreeToggle(nodeId: any): void;
+    rebuildTree(): void;
+    private _getSummaryDefs;
+}

package/dist/types/core/KeyboardManager.d.ts

@@ -0,0 +1,26 @@
+import { DataLayer } from './DataLayer.js';
+import { ColumnLayout } from './ColumnLayout.js';
+import { CellEditManager } from './CellEditManager.js';
+import { RowManager } from './RowManager.js';
+
+export interface KeyboardDeps<T extends Record<string, any>> {
+    getEditMgr: () => CellEditManager<T>;
+    getRowMgr: () => RowManager<T>;
+    getData: () => DataLayer<T>;
+    getColLayout: () => ColumnLayout<T>;
+    getOptions: () => any;
+    setFocusCell: (ri: number, ci: number) => void;
+    handleRowDrop: (from: number, to: number) => void;
+    doRender: () => void;
+    announce: (msg: string) => void;
+    emit: (event: string, ...args: any[]) => void;
+    visRange: () => [number, number];
+    handleCellKeyEvt: (eventName: 'cellKeyDown' | 'cellKeyUp' | 'cellKeyPress', e: KeyboardEvent) => void;
+}
+export declare class KeyboardManager<T extends Record<string, any> = any> {
+    private _d;
+    constructor(deps: KeyboardDeps<T>);
+    handleKeyDown(e: KeyboardEvent): void;
+    private _copyToClipboard;
+    private _pasteFromClipboard;
+}

package/dist/types/core/MaskingEngine.d.ts

@@ -0,0 +1,25 @@
+/** 지원 마스킹 타입 */
+export type MaskType = 'ssn' | 'phone' | 'mobile' | 'email' | 'credit' | 'account' | 'password' | 'name' | 'ip' | 'partial';
+/** 마스킹 상세 옵션 */
+export interface MaskDef {
+    type: MaskType;
+    /** 마스킹 치환 문자 (기본: '*') */
+    char?: string;
+    /** partial/account: 앞 N자리 표시 */
+    visiblePrefix?: number;
+    /** partial/account: 뒤 N자리 표시 */
+    visibleSuffix?: number;
+}
+/**
+ * 원본 값에 마스킹을 적용해 표시용 문자열을 반환.
+ *
+ * @param value   원본 값 (null/undefined → 빈 문자열 그대로 반환)
+ * @param maskDef 마스킹 타입 또는 상세 옵션
+ * @returns       마스킹된 문자열
+ *
+ * @example
+ * applyMask('930101-1234567', 'ssn')   // '930101-1******'
+ * applyMask('01012345678',    'phone') // '010-****-5678'
+ * applyMask('hong@test.com',  'email') // 'ho***@test.com'
+ */
+export declare function applyMask(value: string, maskDef: MaskType | MaskDef): string;

package/dist/types/core/MathUtils.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 소수점 precision 자리로 반올림 (epsilon round).
+ * 0.1+0.2+... 누적 오차를 최종 표시 단계에서 제거한다.
+ */
+export declare function round(val: number, precision?: number): number;
+/**
+ * Kahan compensated summation — 대량 합산 시 부동소수점 오차 최소화.
+ * 시간복잡도 O(n), 공간 O(1). 빈 배열 → 0 반환.
+ */
+export declare function kahanSum(arr: number[]): number;
+/**
+ * 안전 사칙연산 — 두 수의 곱셈 스케일링으로 소수점 오차 방지.
+ */
+export declare function safeAdd(a: number, b: number, precision?: number): number;
+export declare function safeSub(a: number, b: number, precision?: number): number;
+export declare function safeMul(a: number, b: number, precision?: number): number;
+export declare function safeDiv(a: number, b: number, precision?: number): number;
+/**
+ * Kahan 합산 후 precision 반올림.
+ * SUM/AVG footer 계산에 사용.
+ */
+export declare function kahanSumRounded(arr: number[], precision?: number): number;
+/**
+ * Kahan AVG — 합산 후 count로 나누기.
+ */
+export declare function kahanAvg(arr: number[], precision?: number): number;