@reogrid/pro 0.1.3

package/pro-react.d.cts

@@ -0,0 +1,692 @@
+import * as react from 'react';
+import { CSSProperties } from 'react';
+
+interface RangeRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+type CellHit = {
+    type: 'cell';
+    row: number;
+    column: number;
+};
+type RowHeaderHit = {
+    type: 'row-header';
+    row: number;
+};
+type ColumnHeaderHit = {
+    type: 'column-header';
+    column: number;
+};
+type CornerHit = {
+    type: 'corner';
+};
+type HitTestResult = CellHit | RowHeaderHit | ColumnHeaderHit | CornerHit;
+
+type SelectionBounds = RangeRect & {
+    topRow: number;
+    bottomRow: number;
+    leftColumn: number;
+    rightColumn: number;
+};
+declare class SelectionRange {
+    private readonly worksheet;
+    private startRow;
+    private startColumn;
+    private endRow;
+    private endColumn;
+    private anchorBounds;
+    constructor(worksheet: Worksheet);
+    reset(): void;
+    begin(row: number, column: number): void;
+    update(row: number, column: number): void;
+    isActive(): boolean;
+    clampCell(row: number, column: number): {
+        row: number;
+        column: number;
+    };
+    setRange(startRow: number, startColumn: number, endRow: number, endColumn: number): void;
+    selectRows(startRow: number, endRow?: number): void;
+    selectColumns(startColumn: number, endColumn?: number): void;
+    selectAll(): void;
+    getNormalizedBounds(): SelectionBounds | null;
+    draw(ctx: CanvasRenderingContext2D): void;
+    getActiveCell(): {
+        row: number;
+        column: number;
+    } | null;
+    moveActiveCell(rowDelta: number, columnDelta: number): {
+        row: number;
+        column: number;
+    };
+}
+
+type TextAlign = 'left' | 'center' | 'right';
+type VerticalAlign = 'top' | 'middle' | 'bottom';
+type TextWrapMode = 'none' | 'wrap' | 'break-word';
+interface CellStyle {
+    fontFamily: string;
+    fontSize: number;
+    bold: boolean;
+    italic: boolean;
+    underline: boolean;
+    backgroundColor: string;
+    color: string;
+    textAlign: TextAlign;
+    verticalAlign: VerticalAlign;
+    textWrapMode: TextWrapMode;
+}
+
+interface RichTextRun {
+    text: string;
+    fontFamily?: string;
+    fontSize?: number;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    color?: string;
+}
+
+interface CellInputValue {
+    row: number;
+    column: number;
+    value: string;
+    displayValue?: string;
+    numberFormat?: string;
+    style?: Partial<CellStyle>;
+    richText?: RichTextRun[];
+}
+interface MergedCellRange {
+    topRow: number;
+    leftColumn: number;
+    bottomRow: number;
+    rightColumn: number;
+}
+
+type BorderSide = 'top' | 'right' | 'bottom' | 'left';
+type RangeBorderSide = BorderSide | 'outside';
+type BorderLineStyle = 'solid' | 'dashed' | 'dotted';
+interface BorderLineOptions {
+    style: BorderLineStyle;
+    color?: string;
+    width?: number;
+}
+interface CellBorderDefinition {
+    top?: BorderLine;
+    right?: BorderLine;
+    bottom?: BorderLine;
+    left?: BorderLine;
+}
+interface BorderLine {
+    style: BorderLineStyle;
+    color: string;
+    width: number;
+    appliedAt?: number;
+}
+
+declare class BorderManager {
+    private readonly getRows;
+    private readonly getColumns;
+    private readonly data;
+    private sequence;
+    constructor(getRows: () => number, getColumns: () => number);
+    get size(): number;
+    entries(): Iterable<[string, CellBorderDefinition]>;
+    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;
+    pruneOutsideGrid(): void;
+    private assignBorder;
+    private removeBorderSide;
+    private removeAdjacentBorder;
+    private getAdjacentCell;
+    private oppositeSide;
+    private getOrCreate;
+    private normalizeLine;
+    private normalizeSides;
+    private normalizeBounds;
+    private isCellInBounds;
+    private nextSequence;
+}
+
+declare class MergeManager {
+    private readonly getRows;
+    private readonly getColumns;
+    /** Maps every cell key in a merged range to that range's descriptor. */
+    private readonly cells;
+    /** Maps only anchor (top-left) cell keys to their merged range descriptor. */
+    private readonly anchors;
+    constructor(getRows: () => number, getColumns: () => number);
+    get anchorCount(): number;
+    iterateAnchors(): IterableIterator<MergedCellRange>;
+    get(row: number, column: number): MergedCellRange | null;
+    isAnchor(row: number, column: number): boolean;
+    getBounds(row: number, column: number): {
+        topRow: number;
+        bottomRow: number;
+        leftColumn: number;
+        rightColumn: number;
+    };
+    setAll(ranges: Iterable<MergedCellRange>): void;
+    add(topRow: number, leftColumn: number, bottomRow: number, rightColumn: number): void;
+    remove(topRow: number, leftColumn: number, bottomRow: number, rightColumn: number): boolean;
+    clear(): boolean;
+    expandSelection(bounds: {
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+    }): {
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+    };
+    getMergedLineGaps(): {
+        horizontal: Map<number, Array<{
+            startColumnBoundary: number;
+            endColumnBoundary: number;
+        }>>;
+        vertical: Map<number, Array<{
+            startRowBoundary: number;
+            endRowBoundary: number;
+        }>>;
+    };
+    pruneOutsideGrid(): void;
+    allAnchors(): MergedCellRange[];
+    private applyRange;
+    private removeRange;
+    private removeOverlapping;
+    private rangesOverlap;
+    private normalizeRange;
+    private normalizeBounds;
+}
+
+type SelectionChangeListener = (cell: {
+    row: number;
+    column: number;
+} | null) => void;
+type CellValueChangeListener = (payload: {
+    row: number;
+    column: number;
+    value: string;
+}) => void;
+type ViewportSizeListener = (size: {
+    width: number;
+    height: number;
+}) => void;
+type ScrollChangeListener = (offset: {
+    x: number;
+    y: number;
+}) => void;
+type WorksheetExportCell = {
+    row: number;
+    column: number;
+    value?: string;
+    style?: CellStyle;
+};
+interface WorksheetExportSnapshot {
+    cells: WorksheetExportCell[];
+    merges: MergedCellRange[];
+    columnWidths: number[];
+    rowHeights: number[];
+    rows: number;
+    columns: number;
+}
+declare class Worksheet {
+    protected pixelRatio: number;
+    private readonly pointToPixelRatio;
+    protected viewportWidth: number;
+    protected viewportHeight: number;
+    rows: number;
+    columns: number;
+    readonly columnWidths: number[];
+    private readonly columnCustomWidths;
+    readonly rowHeights: number[];
+    private readonly rowCustomHeights;
+    private columnBoundaries;
+    private rowBoundaries;
+    headerColumnWidth: number;
+    headerRowHeight: number;
+    readonly selection: SelectionRange;
+    private readonly cellInputs;
+    private readonly cellRichText;
+    private readonly cellDisplayOverrides;
+    private readonly cellNumberFormats;
+    private readonly cellFormatting;
+    protected readonly borders: BorderManager;
+    protected readonly merges: MergeManager;
+    private readonly selectionChangeListeners;
+    private readonly cellValueListeners;
+    private readonly viewportSizeListeners;
+    private readonly scrollListeners;
+    private readonly structureListeners;
+    private readonly defaultStyle;
+    private _showGridLines;
+    protected resizeGuide: {
+        type: 'column' | 'row';
+        position: number;
+    } | null;
+    private readonly formulaEngine;
+    protected scrollX: number;
+    protected scrollY: number;
+    private contentWidth;
+    private contentHeight;
+    constructor();
+    render(): void;
+    getScrollContentSize(): {
+        width: number;
+        height: number;
+    };
+    getScrollOffset(): {
+        x: number;
+        y: number;
+    };
+    setScrollOffset(x: number, y: number): void;
+    onViewportSizeChange(listener: ViewportSizeListener): () => void;
+    onScrollChange(listener: ScrollChangeListener): () => void;
+    onStructureChange(listener: () => void): () => void;
+    getCellFromPoint(x: number, y: number): {
+        row: number;
+        column: number;
+    } | null;
+    hitTest(x: number, y: number): HitTestResult | null;
+    updateBoundaries(): void;
+    ensureBoundaries(): void;
+    protected getColumnBoundaries(): readonly number[];
+    protected getRowBoundaries(): readonly number[];
+    protected getColumnWidths(): readonly number[];
+    protected getRowHeights(): readonly number[];
+    protected getCellBorders(): Iterable<[string, CellBorderDefinition]>;
+    getBodyViewportWidth(): number;
+    getBodyViewportHeight(): number;
+    private clampScrollOffset;
+    protected clampScrollOffsetInPlace(): void;
+    getRangeRect(topRow: number, leftColumn: number, bottomRow: number, rightColumn: number): RangeRect;
+    getCellRect(row: number, column: number): RangeRect;
+    getVisibleRowRange(padding?: number): {
+        start: number;
+        end: number;
+    };
+    getVisibleColumnRange(padding?: number): {
+        start: number;
+        end: number;
+    };
+    getVisibleRowIndices(): number[];
+    getVisibleColumnIndices(): number[];
+    getColumnResizeHandle(x: number, y: number, tolerance?: number): number | null;
+    getRowResizeHandle(x: number, y: number, tolerance?: number): number | null;
+    getColumnStart(column: number): number;
+    getRowStart(row: number): number;
+    getCellInput(row: number, column: number): string | undefined;
+    protected getRichTextRuns(row: number, column: number): RichTextRun[] | undefined;
+    setCellInput(row: number, column: number, value: string): void;
+    loadCells(cells: Iterable<CellInputValue>): void;
+    private updateCellDisplayValue;
+    protected getCellText(row: number, column: number): string | null;
+    getComputedCellStyle(row: number, column: number): CellStyle;
+    getActiveCellStyle(): CellStyle;
+    getDefaultCellStyle(): CellStyle;
+    setCellStyle(row: number, column: number, style: Partial<CellStyle>): void;
+    private setCellFormatting;
+    setSelectionFontFamily(fontFamily: string): void;
+    setSelectionFontSize(fontSize: number): void;
+    setSelectionFontBold(enabled: boolean): void;
+    setSelectionFontItalic(enabled: boolean): void;
+    setSelectionUnderline(enabled: boolean): void;
+    setSelectionBackgroundColor(color: string): void;
+    setSelectionHorizontalAlignment(alignment: TextAlign): void;
+    setSelectionVerticalAlignment(alignment: VerticalAlign): void;
+    setSelectionTextWrapMode(mode: TextWrapMode): void;
+    setRangeBackgroundColor(topRow: number, leftColumn: number, bottomRow: number, rightColumn: number, color: string): void;
+    setSelectionRange(topRow: number, leftColumn: number, bottomRow: number, rightColumn: number): void;
+    onSelectionChange(listener: SelectionChangeListener): () => void;
+    onCellValueChange(listener: CellValueChangeListener): () => void;
+    notifySelectionChanged(): void;
+    isActiveCell(row: number, column: number): boolean;
+    private applyToSelection;
+    setMergedRanges(ranges: Iterable<MergedCellRange>): void;
+    mergeCells(topRow: number, leftColumn: number, bottomRow: number, rightColumn: number): void;
+    unmergeCells(topRow: number, leftColumn: number, bottomRow: number, rightColumn: number): void;
+    clearMergedRanges(): void;
+    getMergedRange(row: number, column: number): MergedCellRange | null;
+    isMergedCellAnchor(row: number, column: number): boolean;
+    getCellMergeBounds(row: number, column: number): {
+        topRow: number;
+        bottomRow: number;
+        leftColumn: number;
+        rightColumn: number;
+    };
+    expandSelectionWithMergedCells(bounds: {
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+    }): {
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+    };
+    protected getMergedLineGaps(): {
+        horizontal: Map<number, Array<{
+            startColumnBoundary: number;
+            endColumnBoundary: number;
+        }>>;
+        vertical: Map<number, Array<{
+            startRowBoundary: number;
+            endRowBoundary: number;
+        }>>;
+    };
+    getCellBorder(row: number, column: number): CellBorderDefinition | undefined;
+    applyCellBorders(borders: Map<string, CellBorderDefinition>): void;
+    setRangeBorder(topRow: number, leftColumn: number, bottomRow: number, rightColumn: number, border: BorderLineOptions, sides?: RangeBorderSide[]): void;
+    getColumnWidth(column: number): number;
+    setColumnWidth(column: number, width: number): void;
+    getRowHeight(row: number): number;
+    setRowHeight(row: number, height: number): void;
+    applyColumnWidths(widths: Map<number, number>, options?: {
+        customColumns?: Set<number>;
+        enforceMinColumnWidth?: boolean;
+    }): void;
+    applyRowHeights(heights: Map<number, number>, options?: {
+        customRows?: Set<number>;
+    }): void;
+    autoFitColumns(options?: {
+        columns?: number[];
+        respectCustomWidth?: boolean;
+    }): void;
+    autoFitRows(options?: {
+        rows?: number[];
+        respectCustomHeight?: boolean;
+    }): void;
+    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;
+    setGridSize(rows: number, columns: number): void;
+    setShowGridLines(visible: boolean): void;
+    getShowGridLines(): boolean;
+    protected shouldRenderGridLines(): boolean;
+    setResizeGuide(guide: {
+        type: 'column' | 'row';
+        position: number;
+    } | null, shouldRender?: boolean): void;
+    getPixelRatio(): number;
+    pointsToPixels(points: number): number;
+    getExportSnapshot(): WorksheetExportSnapshot;
+    protected parseCellKey(key: string): {
+        row: number;
+        column: number;
+    } | null;
+    private isCellInBounds;
+    private clampRow;
+    private clampColumn;
+    normalizeRangeBounds(topRow: number, leftColumn: number, bottomRow: number, rightColumn: number): {
+        top: number;
+        left: number;
+        bottom: number;
+        right: number;
+    } | null;
+    private clampSelectionToBounds;
+    private pruneCellDataOutsideGrid;
+    private ensureArrayLength;
+    private emitSelectionChange;
+    private emitCellValueChange;
+    private emitViewportSizeChange;
+    private emitScrollChange;
+    private emitStructureChange;
+}
+
+type LoadXlsxOptions = {
+    sheetName?: string;
+};
+type WorksheetImageAnchorPosition = {
+    row: number;
+    column: number;
+    offsetX: number;
+    offsetY: number;
+};
+type WorksheetImagePlacement = {
+    type: 'oneCell';
+    from: WorksheetImageAnchorPosition;
+    width: number;
+    height: number;
+} | {
+    type: 'twoCell';
+    from: WorksheetImageAnchorPosition;
+    to: WorksheetImageAnchorPosition;
+};
+type WorksheetImageInfo = {
+    id: string;
+    mimeType: string;
+    data: Uint8Array;
+    anchor: WorksheetImagePlacement;
+};
+
+type CellStyleInput = Partial<CellStyle>;
+declare class CellHandle {
+    private readonly ws;
+    private readonly r;
+    private readonly c;
+    constructor(ws: Worksheet, row: number, col: number);
+    get value(): string;
+    set value(v: string);
+    get style(): Partial<CellStyle>;
+    set style(s: CellStyleInput);
+    getValue(): string;
+    setValue(v: string): this;
+    getStyle(): CellStyle;
+    setStyle(s: CellStyleInput): this;
+}
+/** No-op handle returned when a cell address is outside the allowed constraint bounds. */
+declare class NullCellHandle {
+    get value(): string;
+    set value(_v: string);
+    get style(): Partial<CellStyle>;
+    set style(_s: CellStyleInput);
+    getValue(): string;
+    setValue(_v: string): this;
+    getStyle(): CellStyle;
+    setStyle(_s: CellStyleInput): this;
+}
+declare class RangeHandle {
+    private readonly ws;
+    private readonly topRow;
+    private readonly leftColumn;
+    private readonly bottomRow;
+    private readonly rightColumn;
+    constructor(ws: Worksheet, topRow: number, leftColumn: number, bottomRow: number, rightColumn: number);
+    setStyle(style: CellStyleInput): this;
+    setBackgroundColor(color: string): this;
+    merge(): this;
+    unmerge(): this;
+    border(options: BorderLineOptions, sides?: RangeBorderSide[]): this;
+}
+/** No-op handle returned when a range is outside the allowed constraint bounds. */
+declare class NullRangeHandle {
+    setStyle(_s: CellStyleInput): this;
+    setBackgroundColor(_c: string): this;
+    merge(): this;
+    unmerge(): this;
+    border(_o: BorderLineOptions, _s?: RangeBorderSide[]): this;
+}
+declare class ColumnHandle {
+    private readonly ws;
+    private readonly col;
+    constructor(ws: Worksheet, col: number);
+    get width(): number;
+    set width(w: number);
+}
+declare class RowHandle {
+    private readonly ws;
+    private readonly row;
+    constructor(ws: Worksheet, row: number);
+    get height(): number;
+    set height(h: number);
+}
+
+type SaveXlsxOptions = {
+    filename?: string;
+    sheetName?: string;
+};
+
+interface WorksheetConstraints {
+    maxRows?: number;
+    maxCols?: number;
+}
+declare class CanvasWorksheet extends Worksheet {
+    readonly canvas: HTMLCanvasElement;
+    private readonly ctx;
+    private readonly sheetRenderer;
+    private readonly viewportController;
+    private readonly constraints;
+    private worksheetImages;
+    private readonly imageUrlCache;
+    private readonly imageListeners;
+    constructor(canvas: HTMLCanvasElement, constraints?: WorksheetConstraints);
+    get showGridLines(): boolean;
+    set showGridLines(visible: boolean);
+    cell(a1: string): CellHandle | NullCellHandle;
+    range(a1Range: string): 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;
+    getImages(): WorksheetImageInfo[];
+    createImageUrl(imageId: string): string;
+    revokeImageUrl(imageId: string): void;
+    onImagesChange(listener: (images: WorksheetImageInfo[]) => void): () => void;
+    resize(width?: number, height?: number): void;
+    render(): void;
+    private isOutOfBounds;
+    private isRangeOutOfBounds;
+    private decodeA1Cell;
+    private decodeA1Range;
+    private findImage;
+    private resetImageCache;
+    private clearImageUrlCache;
+    private notifyImagesChanged;
+    private normalizeSheetName;
+    private downloadWorkbook;
+    private triggerDownload;
+    private clear;
+    private withBodyClip;
+    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;
+    private createSheetRendererContext;
+}
+
+interface BeginEditOptions {
+    presetValue?: string;
+    selectAll?: boolean;
+}
+declare class CellEditor {
+    private readonly worksheet;
+    private readonly input;
+    private editingCell;
+    constructor(worksheet: CanvasWorksheet);
+    beginEdit(row: number, column: number, options?: BeginEditOptions): void;
+    commit(): void;
+    cancel(): void;
+    isEditing(): boolean;
+    destroy(): void;
+    private hide;
+    private refreshPosition;
+    private createInput;
+    private updateInputPosition;
+    private handleHorizontalNavigation;
+    private commitAndMove;
+}
+
+declare class PointerController {
+    private readonly worksheet;
+    private readonly canvas;
+    private readonly eventTarget;
+    private readonly cellEditor;
+    private isDragging;
+    private dragContext;
+    private isResizing;
+    private resizeContext;
+    constructor(worksheet: CanvasWorksheet, cellEditor: CellEditor, eventTarget?: HTMLElement);
+    destroy(): void;
+    private handleMouseDown;
+    private handleMouseMove;
+    private handleMouseUp;
+    private handleDoubleClick;
+    private getCanvasPoint;
+    private resolveRowFromHit;
+    private resolveColumnFromHit;
+    private tryBeginResize;
+    private handleResizeDrag;
+    private updateHoverCursor;
+    private setCursor;
+}
+
+declare class KeyboardController {
+    private readonly worksheet;
+    private readonly cellEditor;
+    constructor(worksheet: CanvasWorksheet, cellEditor: CellEditor);
+    destroy(): void;
+    private handleKeyDown;
+    private handleNavigationKeys;
+    private ensureActiveCell;
+}
+
+type ReogridMountTarget = string | HTMLElement;
+interface ReogridOptions {
+    workspace?: ReogridMountTarget;
+    workspaceId?: string;
+    canvasId?: string;
+    injectStyles?: boolean;
+    /** Maximum number of rows. Writes beyond this limit are silently ignored. */
+    maxRows?: number;
+    /** Maximum number of columns. Writes beyond this limit are silently ignored. */
+    maxCols?: number;
+}
+interface ReogridInstance {
+    worksheet: CanvasWorksheet;
+    cellEditor: CellEditor;
+    pointerController: PointerController;
+    keyboardController: KeyboardController;
+    destroy: () => void;
+}
+
+interface ReogridProps {
+    className?: string;
+    style?: CSSProperties;
+    /**
+     * Called once after the grid is initialized, with the full ReogridInstance.
+     * Useful for setting initial cell values, styles, or loading an xlsx file.
+     */
+    onReady?: (instance: ReogridInstance) => void;
+    /**
+     * Options forwarded to createReogrid(). `workspace` is managed internally
+     * and will be ignored if supplied.
+     */
+    options?: Omit<ReogridOptions, 'workspace'>;
+}
+/**
+ * React component that mounts a ReoGrid Pro canvas spreadsheet.
+ * No row/column restrictions. Full xlsx import/export support.
+ *
+ * The ref exposes the full `ReogridInstance` (worksheet, api, etc.).
+ *
+ * @example
+ * ```tsx
+ * const gridRef = useRef<ReogridInstance>(null);
+ * <Reogrid ref={gridRef} style={{ flex: 1 }} onReady={(inst) => {
+ *   inst.api.setCellValue('A1', 'Hello from ReoGrid Pro!');
+ * }} />
+ * ```
+ */
+declare const Reogrid: react.ForwardRefExoticComponent<ReogridProps & react.RefAttributes<ReogridInstance>>;
+
+export { Reogrid, type ReogridInstance, type ReogridProps };