@reogrid/pro 0.1.3 → 0.1.5

package/pro-react.d.ts

@@ -23,7 +23,46 @@ type ColumnHeaderHit = {
 type CornerHit = {
     type: 'corner';
 };
-type HitTestResult = CellHit | RowHeaderHit | ColumnHeaderHit | CornerHit;
+type ColumnHeaderDropdownHit = {
+    type: 'column-header-dropdown';
+    column: number;
+};
+type OutlineToggleHit = {
+    type: 'outline-toggle';
+    direction: 'row' | 'column';
+    level: number;
+    start: number;
+};
+type OutlineLevelButtonHit = {
+    type: 'outline-level-button';
+    direction: 'row' | 'column';
+    level: number;
+};
+type HitTestResult = CellHit | RowHeaderHit | ColumnHeaderHit | ColumnHeaderDropdownHit | CornerHit | OutlineToggleHit | OutlineLevelButtonHit;
+type ContextMenuEventBase = {
+    clientX: number;
+    clientY: number;
+    originalEvent: MouseEvent;
+};
+type RowHeaderContextMenu = ContextMenuEventBase & {
+    area: 'row-header';
+    row: number;
+    selectedRows: [number, number];
+};
+type ColumnHeaderContextMenu = ContextMenuEventBase & {
+    area: 'column-header';
+    column: number;
+    selectedColumns: [number, number];
+};
+type CellContextMenu = ContextMenuEventBase & {
+    area: 'cell';
+    row: number;
+    column: number;
+};
+type CornerContextMenu = ContextMenuEventBase & {
+    area: 'corner';
+};
+type ContextMenuEvent = RowHeaderContextMenu | ColumnHeaderContextMenu | CellContextMenu | CornerContextMenu;
 
 type SelectionBounds = RangeRect & {
     topRow: number;
@@ -52,7 +91,18 @@ declare class SelectionRange {
     selectColumns(startColumn: number, endColumn?: number): void;
     selectAll(): void;
     getNormalizedBounds(): SelectionBounds | null;
+    /** Returns the normalized selection row/column bounds, or null if inactive. */
+    getSelectionBounds(): {
+        topRow: number;
+        bottomRow: number;
+        leftColumn: number;
+        rightColumn: number;
+    } | null;
     draw(ctx: CanvasRenderingContext2D): void;
+    /** Draw the selection fill and border at the given screen-space rect. */
+    drawRect(ctx: CanvasRenderingContext2D, x: number, y: number, width: number, height: number): void;
+    containsRow(row: number): boolean;
+    containsColumn(column: number): boolean;
     getActiveCell(): {
         row: number;
         column: number;
@@ -63,6 +113,15 @@ declare class SelectionRange {
     };
 }
 
+interface FormulaEngineOptions {
+    /**
+     * When true (the default), all built-in functions (SUM, IF, …) are
+     * registered.  Set to false for Lite builds where only basic arithmetic
+     * and cell references are supported.
+     */
+    registerBuiltins?: boolean;
+}
+
 type TextAlign = 'left' | 'center' | 'right';
 type VerticalAlign = 'top' | 'middle' | 'bottom';
 type TextWrapMode = 'none' | 'wrap' | 'break-word';
@@ -137,6 +196,20 @@ declare class BorderManager {
     getCell(row: number, column: number): CellBorderDefinition | undefined;
     applyAll(borders: Map<string, CellBorderDefinition>): void;
     setRange(topRow: number, leftColumn: number, bottomRow: number, rightColumn: number, border: BorderLineOptions, sides?: RangeBorderSide[]): void;
+    /**
+     * Shift all border entries when rows or columns are inserted or deleted.
+     *
+     * @param axis  — 'row' or 'column'
+     * @param index — insertion/deletion point (0-based)
+     * @param count — positive = insert, negative = delete
+     */
+    shiftBorders(axis: 'row' | 'column', index: number, count: number): void;
+    /** Low-level access for permuteRows. */
+    getData(key: string): CellBorderDefinition | undefined;
+    setData(key: string, value: CellBorderDefinition): void;
+    deleteData(key: string): void;
+    /** Swap border entries between two rows within a column range. */
+    swapRowCells(rowA: number, rowB: number, startColumn: number, endColumn: number): void;
     pruneOutsideGrid(): void;
     private assignBorder;
     private removeBorderSide;
@@ -194,6 +267,14 @@ declare class MergeManager {
             endRowBoundary: number;
         }>>;
     };
+    /**
+     * Shift all merged ranges when rows or columns are inserted or deleted.
+     *
+     * @param axis  — 'row' or 'column'
+     * @param index — insertion/deletion point (0-based)
+     * @param count — positive = insert, negative = delete
+     */
+    shiftRanges(axis: 'row' | 'column', index: number, count: number): void;
     pruneOutsideGrid(): void;
     allAnchors(): MergedCellRange[];
     private applyRange;
@@ -204,6 +285,115 @@ declare class MergeManager {
     private normalizeBounds;
 }
 
+/** Base config accepted by any cell type. */
+interface CellTypeConfigBase {
+    type: string;
+    [key: string]: unknown;
+}
+interface DropdownClickContext {
+    row?: number;
+    column: number;
+    isHeader: boolean;
+}
+interface DropdownConfig {
+    type: 'dropdown';
+    options?: string[];
+    onclick?: (context: DropdownClickContext) => void;
+}
+/** Open union — any `{ type: string }` config is accepted. */
+type CellTypeConfig = CellTypeConfigBase;
+declare class CellTypeRegistry {
+    private readonly configs;
+    set(row: number, col: number, config: CellTypeConfig): void;
+    get(row: number, col: number): CellTypeConfig | undefined;
+    clear(row: number, col: number): void;
+    clearAll(): void;
+}
+
+type RowOrColumn = 'row' | 'column';
+interface OutlineGroup {
+    /** Starting row/column index */
+    start: number;
+    /** Number of rows/columns in this group */
+    count: number;
+    /** Whether this group is collapsed (children hidden) */
+    collapsed: boolean;
+}
+
+declare class OutlineManager {
+    readonly direction: RowOrColumn;
+    /** levels[0] = outermost groups, levels[n] = most nested */
+    private levels;
+    constructor(direction: RowOrColumn);
+    /** Returns the deepest level index, or -1 if no outlines exist */
+    getMaxLevel(): number;
+    /** Total number of levels (0 if no outlines) */
+    getLevelCount(): number;
+    hasOutlines(): boolean;
+    getGroupsAtLevel(level: number): readonly OutlineGroup[];
+    getAllGroups(): readonly (readonly OutlineGroup[])[];
+    /**
+     * Add a group spanning [start, start+count).
+     * Automatically assigns the correct level based on containment:
+     * larger (enclosing) groups are placed at lower levels (outermost).
+     * Returns the assigned level index.
+     */
+    addGroup(start: number, count: number): number;
+    /**
+     * Remove a group matching [start, start+count).
+     * Returns true if a group was found and removed.
+     */
+    removeGroup(start: number, count: number): boolean;
+    /**
+     * Find the group at a specific level and start index.
+     */
+    findGroup(level: number, start: number): OutlineGroup | null;
+    /**
+     * Collapse a group. Returns the set of indices that should be hidden.
+     */
+    collapseGroup(level: number, start: number): Set<number>;
+    /**
+     * Expand a group. Returns the set of indices that should be shown.
+     */
+    expandGroup(level: number, start: number): Set<number>;
+    /**
+     * Collapse all groups at the given level and deeper.
+     * Expand all groups at levels shallower than the given level.
+     * Returns the complete set of hidden indices after the operation.
+     */
+    collapseToLevel(level: number): void;
+    /**
+     * Get all indices hidden by collapsed outline groups.
+     */
+    getHiddenIndices(): Set<number>;
+    /**
+     * Get hidden indices for a specific group (excluding indices hidden by inner collapsed groups).
+     */
+    private getGroupHiddenIndices;
+    /**
+     * Shift all groups when rows/columns are inserted or deleted.
+     * @param index - The insert/delete position
+     * @param delta - Positive for insert, negative for delete
+     */
+    shiftGroups(index: number, delta: number): void;
+    /** Remove trailing empty levels */
+    private trimEmptyLevels;
+    /** Clear all outline groups */
+    clear(): void;
+    /**
+     * Get a snapshot for serialization/undo.
+     */
+    getSnapshot(): OutlineGroup[][];
+    /**
+     * Restore from a snapshot.
+     */
+    restoreSnapshot(snapshot: OutlineGroup[][]): void;
+}
+
+type AlternateRowColors = {
+    evenColor: string;
+    oddColor: string;
+};
 type SelectionChangeListener = (cell: {
     row: number;
     column: number;
@@ -221,19 +411,33 @@ type ScrollChangeListener = (offset: {
     x: number;
     y: number;
 }) => void;
+type ContextMenuListener = (event: ContextMenuEvent) => void;
+type ProtectedCellEditListener = (payload: {
+    row: number;
+    column: number;
+}) => void;
 type WorksheetExportCell = {
     row: number;
     column: number;
     value?: string;
     style?: CellStyle;
+    /** For formula cells: the cached computed value for the xlsx <v> tag */
+    cachedValue?: string | number | boolean;
 };
 interface WorksheetExportSnapshot {
     cells: WorksheetExportCell[];
     merges: MergedCellRange[];
+    borders: Map<string, CellBorderDefinition>;
     columnWidths: number[];
     rowHeights: number[];
     rows: number;
     columns: number;
+    frozenRows: number;
+    frozenColumns: number;
+}
+interface WorksheetOptions {
+    /** Options forwarded to the FormulaEngine (e.g. disable built-in functions for Lite). */
+    formula?: FormulaEngineOptions;
 }
 declare class Worksheet {
     protected pixelRatio: number;
@@ -246,6 +450,8 @@ declare class Worksheet {
     private readonly columnCustomWidths;
     readonly rowHeights: number[];
     private readonly rowCustomHeights;
+    private readonly rowHidden;
+    private readonly columnHidden;
     private columnBoundaries;
     private rowBoundaries;
     headerColumnWidth: number;
@@ -263,19 +469,45 @@ declare class Worksheet {
     private readonly viewportSizeListeners;
     private readonly scrollListeners;
     private readonly structureListeners;
+    private readonly contextMenuListeners;
     private readonly defaultStyle;
     private _showGridLines;
+    private _alternateRowColors;
     protected resizeGuide: {
         type: 'column' | 'row';
         position: number;
     } | null;
     private readonly formulaEngine;
+    protected readonly cellTypeRegistry: CellTypeRegistry;
+    protected readonly rowOutlines: OutlineManager;
+    protected readonly columnOutlines: OutlineManager;
+    private readonly headerDropdowns;
+    private _protected;
+    private readonly cellLockStates;
+    private readonly protectedCellEditListeners;
     protected scrollX: number;
     protected scrollY: number;
+    protected frozenRows: number;
+    protected frozenColumns: number;
     private contentWidth;
     private contentHeight;
-    constructor();
+    private _renderSuspended;
+    private _renderPending;
+    constructor(options?: WorksheetOptions);
     render(): void;
+    /** Override in rendering subclasses to perform actual drawing. */
+    protected renderImpl(): void;
+    /**
+     * Suspend rendering. All render() calls become no-ops until resumeRender().
+     * Use for batch operations that would otherwise trigger thousands of redraws.
+     */
+    suspendRender(): void;
+    /**
+     * Resume rendering and flush a single render if any were requested while suspended.
+     */
+    resumeRender(): void;
+    /** Rebuild formula dependency graph and re-evaluate all formulas. */
+    rebuildFormulas(): void;
     getScrollContentSize(): {
         width: number;
         height: number;
@@ -288,15 +520,25 @@ declare class Worksheet {
     onViewportSizeChange(listener: ViewportSizeListener): () => void;
     onScrollChange(listener: ScrollChangeListener): () => void;
     onStructureChange(listener: () => void): () => void;
+    getFrozenRows(): number;
+    getFrozenColumns(): number;
+    setFrozenRows(count: number): void;
+    setFrozenColumns(count: number): void;
+    getFrozenWidth(): number;
+    getFrozenHeight(): number;
     getCellFromPoint(x: number, y: number): {
         row: number;
         column: number;
     } | null;
     hitTest(x: number, y: number): HitTestResult | null;
+    /** Converts a screen X coordinate to grid content X, accounting for frozen columns. */
+    protected screenToGridX(screenX: number): number;
+    /** Converts a screen Y coordinate to grid content Y, accounting for frozen rows. */
+    protected screenToGridY(screenY: number): number;
     updateBoundaries(): void;
     ensureBoundaries(): void;
-    protected getColumnBoundaries(): readonly number[];
-    protected getRowBoundaries(): readonly number[];
+    getColumnBoundaries(): readonly number[];
+    getRowBoundaries(): readonly number[];
     protected getColumnWidths(): readonly number[];
     protected getRowHeights(): readonly number[];
     protected getCellBorders(): Iterable<[string, CellBorderDefinition]>;
@@ -323,9 +565,23 @@ declare class Worksheet {
     getCellInput(row: number, column: number): string | undefined;
     protected getRichTextRuns(row: number, column: number): RichTextRun[] | undefined;
     setCellInput(row: number, column: number, value: string): void;
+    setCellNumberFormat(row: number, column: number, formatCode: string): void;
+    getCellNumberFormat(row: number, column: number): string | undefined;
+    clearCellNumberFormat(row: number, column: number): void;
+    setCellType(row: number, col: number, config: CellTypeConfig): void;
+    getCellType(row: number, col: number): CellTypeConfig | undefined;
+    clearCellType(row: number, col: number): void;
+    setHeaderDropdown(column: number, config: DropdownConfig | null): void;
+    getHeaderDropdown(column: number): DropdownConfig | undefined;
+    hasHeaderDropdown(column: number): boolean;
+    /** Check if a screen X coordinate hits the dropdown button area of a cell. */
+    isDropdownButtonHit(row: number, column: number, screenX: number): boolean;
     loadCells(cells: Iterable<CellInputValue>): void;
     private updateCellDisplayValue;
     protected getCellText(row: number, column: number): string | null;
+    getCellRawStyle(row: number, column: number): Partial<CellStyle> | undefined;
+    replaceCellStyle(row: number, column: number, style: Partial<CellStyle> | undefined): void;
+    clearCellStyle(row: number, column: number): void;
     getComputedCellStyle(row: number, column: number): CellStyle;
     getActiveCellStyle(): CellStyle;
     getDefaultCellStyle(): CellStyle;
@@ -344,6 +600,30 @@ declare class Worksheet {
     setSelectionRange(topRow: number, leftColumn: number, bottomRow: number, rightColumn: number): void;
     onSelectionChange(listener: SelectionChangeListener): () => void;
     onCellValueChange(listener: CellValueChangeListener): () => void;
+    onContextMenu(listener: ContextMenuListener): () => void;
+    emitContextMenu(event: ContextMenuEvent): void;
+    /** Whether the worksheet is in protected mode (all cells locked by default). */
+    get protected(): boolean;
+    set protected(value: boolean);
+    /** Set an explicit lock state on a cell, overriding the worksheet default. */
+    setCellLock(row: number, column: number, state: 'locked' | 'unlocked'): void;
+    /** Remove the explicit lock state from a cell, reverting to worksheet default. */
+    clearCellLock(row: number, column: number): void;
+    /** Get the explicit lock state of a cell, or `undefined` if inheriting from worksheet. */
+    getCellLock(row: number, column: number): 'locked' | 'unlocked' | undefined;
+    /** Set an explicit lock state on all cells in a range. */
+    setRangeLock(topRow: number, leftColumn: number, bottomRow: number, rightColumn: number, state: 'locked' | 'unlocked'): void;
+    /** Remove explicit lock states from all cells in a range. */
+    clearRangeLock(topRow: number, leftColumn: number, bottomRow: number, rightColumn: number): void;
+    /**
+     * Resolve the effective protection state of a cell.
+     * Explicit lock state takes precedence; otherwise inherits from `worksheet.protected`.
+     */
+    isCellProtected(row: number, column: number): boolean;
+    /** Returns `true` if any cell in the range is protected. */
+    isRangeProtected(topRow: number, leftColumn: number, bottomRow: number, rightColumn: number): boolean;
+    onProtectedCellEdit(listener: ProtectedCellEditListener): () => void;
+    emitProtectedCellEdit(row: number, column: number): void;
     notifySelectionChanged(): void;
     isActiveCell(row: number, column: number): boolean;
     private applyToSelection;
@@ -406,10 +686,86 @@ declare class Worksheet {
     protected measureRowHeight(_row: number): number;
     protected measureCellContentHeight(_row: number, _column: number, _style: CellStyle): number;
     protected measureCellContentWidth(_row: number, _column: number, _style: CellStyle): number;
+    isRowHidden(row: number): boolean;
+    setRowHidden(row: number, hidden: boolean): void;
+    setRowsHidden(rows: number[], hidden: boolean): void;
+    isColumnHidden(column: number): boolean;
+    setColumnHidden(column: number, hidden: boolean): void;
+    setColumnsHidden(columns: number[], hidden: boolean): void;
+    private static readonly OUTLINE_LEVEL_SIZE;
+    private static readonly OUTLINE_PANEL_PADDING;
+    getRowOutlines(): OutlineManager;
+    getColumnOutlines(): OutlineManager;
+    /** Width of the row outline panel (left of row headers). 0 if no row outlines. */
+    getOutlinePanelWidth(): number;
+    /** Height of the column outline panel (above column headers). 0 if no column outlines. */
+    getOutlinePanelHeight(): number;
+    /** Recalculate header sizes based on outline levels */
+    private updateHeaderSizes;
+    /** Apply outline hidden state to row/column hidden arrays */
+    private syncOutlineHidden;
+    groupRows(startRow: number, endRow: number): void;
+    ungroupRows(startRow: number, endRow: number): void;
+    groupColumns(startColumn: number, endColumn: number): void;
+    ungroupColumns(startColumn: number, endColumn: number): void;
+    collapseRowOutline(level: number, start: number): void;
+    expandRowOutline(level: number, start: number): void;
+    collapseColumnOutline(level: number, start: number): void;
+    expandColumnOutline(level: number, start: number): void;
+    collapseRowsToLevel(level: number): void;
+    collapseColumnsToLevel(level: number): void;
+    insertRows(index: number, count: number): void;
+    insertColumns(index: number, count: number): void;
+    deleteRows(index: number, count: number): void;
+    deleteColumns(index: number, count: number): void;
+    /**
+     * Write to cellInputs without triggering the formula engine.
+     * Used by FormulaEngine.onStructureChange() to update formula strings
+     * after reference shifting — avoids infinite recursion.
+     */
+    setCellInputDirect(row: number, column: number, value: string): void;
+    /**
+     * Swap cell data between two rows within [startColumn, endColumn].
+     * Swaps: cellInputs, cellRichText, cellDisplayOverrides, cellNumberFormats,
+     * cellFormatting, borders. Does NOT swap rowHeight or rowHidden.
+     * Does NOT trigger render — caller is responsible.
+     */
+    swapRows(rowA: number, rowB: number, startColumn: number, endColumn: number): void;
+    /**
+     * Apply a row permutation within [startColumn, endColumn].
+     * `targetRows[i]` receives the data currently at `sourceRows[i]`.
+     * Both arrays must have the same length and targetRows must equal the
+     * set of participating row positions (a permutation of sourceRows is NOT
+     * required — sourceRows may list the same rows in a different order).
+     *
+     * Operates directly on internal Maps for performance — no per-cell
+     * render(), formulaEngine, or event callbacks are triggered.
+     * Caller must call formulaEngine.rebuildAll() and render() afterwards.
+     */
+    permuteRows(sourceRows: number[], targetRows: number[], startColumn: number, endColumn: number): void;
+    private swapMapEntries;
+    /** Get all cell data in a range (for backup before deletion). */
+    getRangeData(topRow: number, leftColumn: number, bottomRow: number, rightColumn: number): Map<string, {
+        input?: string;
+        richText?: RichTextRun[];
+        displayOverride?: string;
+        numberFormat?: string;
+        formatting?: Partial<CellStyle>;
+    }>;
+    /** Restore cell data from a backup (used by undo of delete operations). */
+    restoreRangeData(data: Map<string, {
+        input?: string;
+        richText?: RichTextRun[];
+        displayOverride?: string;
+        numberFormat?: string;
+        formatting?: Partial<CellStyle>;
+    }>): void;
     setGridSize(rows: number, columns: number): void;
     setShowGridLines(visible: boolean): void;
     getShowGridLines(): boolean;
     protected shouldRenderGridLines(): boolean;
+    setAlternateRowColors(colors: AlternateRowColors | null): void;
+    getAlternateRowColors(): AlternateRowColors | null;
     setResizeGuide(guide: {
         type: 'column' | 'row';
         position: number;
@@ -431,6 +787,11 @@ declare class Worksheet {
         right: number;
     } | null;
     private clampSelectionToBounds;
+    /**
+     * Shift keys in all cell data Maps when rows/columns are inserted or deleted.
+     * count > 0 = insert, count < 0 = delete.
+     */
+    private shiftCellDataMaps;
     private pruneCellDataOutsideGrid;
     private ensureArrayLength;
     private emitSelectionChange;
@@ -466,6 +827,73 @@ type WorksheetImageInfo = {
     anchor: WorksheetImagePlacement;
 };
 
+interface ColumnFilterState {
+    column: number;
+    /** The set of cell text values currently selected (shown). null = no filter (all shown). */
+    selectedValues: Set<string> | null;
+}
+interface AutoFilterConfig {
+    /** The row containing column labels. Data rows start from headerRow + 1. */
+    headerRow: number;
+    /** First column in the filter range (inclusive). */
+    startColumn: number;
+    /** Last column in the filter range (inclusive). */
+    endColumn: number;
+}
+interface FilterChangeEvent {
+    column: number;
+    selectedValues: Set<string> | null;
+    hiddenRowCount: number;
+}
+
+type SortOrder = 'asc' | 'desc';
+interface SortResult {
+    /**
+     * Snapshot of row positions before sorting.
+     * `originalOrder[i]` is the row index that was at position `startRow + i` before sorting.
+     */
+    originalOrder: number[];
+}
+
+declare class AutoColumnFilter {
+    private readonly worksheet;
+    private readonly config;
+    private readonly columnFilters;
+    private readonly filterChangeListeners;
+    private currentSort;
+    constructor(worksheet: Worksheet, config: AutoFilterConfig);
+    getConfig(): Readonly<AutoFilterConfig>;
+    /** Get unique cell input values in a column (below header row). Sorted alphabetically. */
+    getColumnValues(column: number): string[];
+    /** Set the filter for a column. Pass null to clear (show all). */
+    setColumnFilter(column: number, selectedValues: Set<string> | null): void;
+    /** Get current filter state for a column (null if no filter). */
+    getColumnFilter(column: number): ColumnFilterState | null;
+    /** Returns true if any column has an active filter. */
+    hasActiveFilters(): boolean;
+    /** Apply all active filters. Iterates rows once and batch-updates hidden state. */
+    apply(): void;
+    /** Clear all column filters and unhide all data rows. */
+    clearAll(): void;
+    /** Listen for filter changes. Returns unsubscribe function. */
+    onFilterChange(listener: (event: FilterChangeEvent) => void): () => void;
+    /** Sort data rows by the given column. Returns the result for undo support. */
+    sortColumn(column: number, order: SortOrder): SortResult;
+    /** Get the current sort state (null if not sorted). */
+    getSortState(): {
+        column: number;
+        order: SortOrder;
+    } | null;
+    /** Set the sort state indicator (does not sort — use sortColumn for that). */
+    setSortState(column: number, order: SortOrder): void;
+    /** Clear the sort state (does not revert data — use undo for that). */
+    clearSortState(): void;
+    /** Destroy: clear filters, remove listeners. */
+    destroy(): void;
+    private getHiddenRowCount;
+    private emitFilterChange;
+}
+
 type CellStyleInput = Partial<CellStyle>;
 declare class CellHandle {
     private readonly ws;
@@ -480,6 +908,20 @@ declare class CellHandle {
     setValue(v: string): this;
     getStyle(): CellStyle;
     setStyle(s: CellStyleInput): this;
+    get format(): string | undefined;
+    set format(code: string | undefined);
+    setFormat(code: string): this;
+    setType(config: CellTypeConfig): this;
+    clearType(): this;
+    /** Returns `true` if this cell is part of a merged range. */
+    get isMerged(): boolean;
+    /** Returns the merged range this cell belongs to, or `null` if not merged. */
+    get mergeRange(): MergedCellRange | null;
+    /** Explicit lock state, or `undefined` if inheriting from worksheet. */
+    get locked(): 'locked' | 'unlocked' | undefined;
+    set locked(state: 'locked' | 'unlocked' | undefined);
+    /** Resolved protection state (considers worksheet.protected + explicit lock). */
+    get isProtected(): boolean;
 }
 /** No-op handle returned when a cell address is outside the allowed constraint bounds. */
 declare class NullCellHandle {
@@ -491,6 +933,16 @@ declare class NullCellHandle {
     setValue(_v: string): this;
     getStyle(): CellStyle;
     setStyle(_s: CellStyleInput): this;
+    get format(): string | undefined;
+    set format(_code: string | undefined);
+    setFormat(_code: string): this;
+    setType(_config: CellTypeConfig): this;
+    clearType(): this;
+    get isMerged(): boolean;
+    get mergeRange(): MergedCellRange | null;
+    get locked(): 'locked' | 'unlocked' | undefined;
+    set locked(_state: 'locked' | 'unlocked' | undefined);
+    get isProtected(): boolean;
 }
 declare class RangeHandle {
     private readonly ws;
@@ -503,7 +955,10 @@ declare class RangeHandle {
     setBackgroundColor(color: string): this;
     merge(): this;
     unmerge(): this;
+    setFormat(code: string): this;
     border(options: BorderLineOptions, sides?: RangeBorderSide[]): this;
+    setLock(state: 'locked' | 'unlocked'): this;
+    clearLock(): this;
 }
 /** No-op handle returned when a range is outside the allowed constraint bounds. */
 declare class NullRangeHandle {
@@ -511,7 +966,10 @@ declare class NullRangeHandle {
     setBackgroundColor(_c: string): this;
     merge(): this;
     unmerge(): this;
+    setFormat(_code: string): this;
     border(_o: BorderLineOptions, _s?: RangeBorderSide[]): this;
+    setLock(_state: 'locked' | 'unlocked'): this;
+    clearLock(): this;
 }
 declare class ColumnHandle {
     private readonly ws;
@@ -546,23 +1004,30 @@ declare class CanvasWorksheet extends Worksheet {
     private worksheetImages;
     private readonly imageUrlCache;
     private readonly imageListeners;
-    constructor(canvas: HTMLCanvasElement, constraints?: WorksheetConstraints);
+    private autoFilter;
+    constructor(canvas: HTMLCanvasElement, constraints?: WorksheetConstraints, worksheetOptions?: WorksheetOptions);
     get showGridLines(): boolean;
     set showGridLines(visible: boolean);
+    get alternateRowColors(): AlternateRowColors | null;
+    set alternateRowColors(colors: AlternateRowColors | null);
     cell(a1: string): CellHandle | NullCellHandle;
+    cell(row: number, column: number): CellHandle | NullCellHandle;
     range(a1Range: string): RangeHandle | NullRangeHandle;
+    range(topRow: number, leftColumn: number, bottomRow: number, rightColumn: number): RangeHandle | NullRangeHandle;
     column(index: number): ColumnHandle;
     row(index: number): RowHandle;
     loadFromUrl(url: string | URL, options?: LoadXlsxOptions): Promise<void>;
     loadFromFile(file: File, options?: LoadXlsxOptions): Promise<void>;
     loadFromXlsx(data: ArrayBuffer | Uint8Array | string, options?: LoadXlsxOptions): Promise<void>;
     saveAsXlsx(options?: SaveXlsxOptions): void;
+    /** Returns the display text for a cell (formatted/computed value). */
+    getDisplayText(row: number, column: number): string | null;
     getImages(): WorksheetImageInfo[];
     createImageUrl(imageId: string): string;
     revokeImageUrl(imageId: string): void;
     onImagesChange(listener: (images: WorksheetImageInfo[]) => void): () => void;
     resize(width?: number, height?: number): void;
-    render(): void;
+    protected renderImpl(): void;
     private isOutOfBounds;
     private isRangeOutOfBounds;
     private decodeA1Cell;
@@ -576,23 +1041,77 @@ declare class CanvasWorksheet extends Worksheet {
     private triggerDownload;
     private clear;
     private withBodyClip;
+    private drawSelectionPerViewport;
     private drawResizeGuide;
     protected measureColumnWidth(column: number): number;
     protected measureRowHeight(row: number): number;
     protected measureCellContentHeight(row: number, column: number, style: CellStyle): number;
     protected measureCellContentWidth(row: number, column: number, style: CellStyle): number;
+    createAutoFilter(config: AutoFilterConfig): AutoColumnFilter;
+    removeAutoFilter(): void;
+    getAutoFilter(): AutoColumnFilter | null;
+    private onFilterHeaderDropdownClick;
+    private readonly filterDropdownListeners;
+    onFilterDropdownClick(listener: (column: number) => void): () => void;
+    /**
+     * Sort rows by the given column. If an AutoFilter is active, sorts within
+     * its data range and updates its sort state. Otherwise sorts all rows.
+     * Does NOT go through ActionManager — caller should wrap in SortColumnAction
+     * if undo support is desired.
+     */
+    sortColumn(column: number, order: SortOrder): SortResult;
+    /** Get the current sort state (from the active AutoFilter, if any). */
+    getSortState(): {
+        column: number;
+        order: SortOrder;
+    } | null;
     private createSheetRendererContext;
 }
 
+interface ActionTargetRange {
+    topRow: number;
+    leftColumn: number;
+    bottomRow: number;
+    rightColumn: number;
+}
+interface WorksheetAction {
+    readonly name: string;
+    /** When `true`, ActionManager checks cell protection before executing. */
+    readonly modifiesCellData?: boolean;
+    do(worksheet: Worksheet): void;
+    undo(worksheet: Worksheet): void;
+    /** Range to select after do/undo. If undefined, selection is not changed. */
+    getTargetRange?(): ActionTargetRange;
+}
+
+declare class ActionManager {
+    private readonly undoStack;
+    private readonly redoStack;
+    private readonly capacity;
+    private readonly worksheet;
+    private readonly listeners;
+    constructor(worksheet: Worksheet, capacity?: number);
+    execute(action: WorksheetAction): boolean;
+    undo(): boolean;
+    redo(): boolean;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    clear(): void;
+    onUndoRedoChange(listener: () => void): () => void;
+    private selectActionTarget;
+    private notifyListeners;
+}
+
 interface BeginEditOptions {
     presetValue?: string;
     selectAll?: boolean;
 }
 declare class CellEditor {
     private readonly worksheet;
+    private readonly actionManager;
     private readonly input;
     private editingCell;
-    constructor(worksheet: CanvasWorksheet);
+    constructor(worksheet: CanvasWorksheet, actionManager?: ActionManager);
     beginEdit(row: number, column: number, options?: BeginEditOptions): void;
     commit(): void;
     cancel(): void;
@@ -606,21 +1125,38 @@ declare class CellEditor {
     private commitAndMove;
 }
 
+declare class DropdownOverlay {
+    private readonly worksheet;
+    private readonly listElement;
+    private currentCallback;
+    private outsideClickHandler;
+    constructor(worksheet: CanvasWorksheet);
+    open(row: number, column: number, options: string[], onSelect: (value: string) => void): void;
+    close(): void;
+    isOpen(): boolean;
+    destroy(): void;
+    private selectItem;
+    private createListElement;
+}
+
 declare class PointerController {
     private readonly worksheet;
     private readonly canvas;
     private readonly eventTarget;
     private readonly cellEditor;
+    private readonly dropdownOverlay;
     private isDragging;
     private dragContext;
     private isResizing;
     private resizeContext;
-    constructor(worksheet: CanvasWorksheet, cellEditor: CellEditor, eventTarget?: HTMLElement);
+    private readonly actionManager;
+    constructor(worksheet: CanvasWorksheet, cellEditor: CellEditor, dropdownOverlay: DropdownOverlay, eventTarget?: HTMLElement, actionManager?: ActionManager);
     destroy(): void;
     private handleMouseDown;
     private handleMouseMove;
     private handleMouseUp;
     private handleDoubleClick;
+    private handleContextMenu;
     private getCanvasPoint;
     private resolveRowFromHit;
     private resolveColumnFromHit;
@@ -630,13 +1166,34 @@ declare class PointerController {
     private setCursor;
 }
 
+declare class ClipboardService {
+    private readonly worksheet;
+    private readonly actionManager;
+    /** Internal buffer for same-instance paste and cut tracking. */
+    private internalBuffer;
+    private cutOrigin;
+    constructor(worksheet: Worksheet, actionManager: ActionManager);
+    copy(): Promise<void>;
+    cut(): Promise<void>;
+    pasteFromEvent(event: ClipboardEvent): void;
+    pasteFromClipboardApi(): Promise<void>;
+    delete(): void;
+    private pasteText;
+    private buildRangeData;
+    private writeToClipboard;
+    private fallbackCopy;
+}
+
 declare class KeyboardController {
     private readonly worksheet;
     private readonly cellEditor;
-    constructor(worksheet: CanvasWorksheet, cellEditor: CellEditor);
+    private readonly actionManager;
+    private readonly clipboardService;
+    constructor(worksheet: CanvasWorksheet, cellEditor: CellEditor, actionManager: ActionManager, clipboardService: ClipboardService);
     destroy(): void;
     private handleKeyDown;
     private handleNavigationKeys;
+    private handlePaste;
     private ensureActiveCell;
 }
 
@@ -650,9 +1207,14 @@ interface ReogridOptions {
     maxRows?: number;
     /** Maximum number of columns. Writes beyond this limit are silently ignored. */
     maxCols?: number;
+    /** Maximum number of undo/redo steps (default: 30). */
+    undoCapacity?: number;
+    /** Options forwarded to the FormulaEngine (e.g. disable built-in functions for Lite). */
+    formula?: WorksheetOptions['formula'];
 }
 interface ReogridInstance {
     worksheet: CanvasWorksheet;
+    actionManager: ActionManager;
     cellEditor: CellEditor;
     pointerController: PointerController;
     keyboardController: KeyboardController;