@synopackageland/ui 0.20.2 → 0.20.4

package/dist/grid/range/fill.d.ts

@@ -0,0 +1,27 @@
+import { GridCellRange } from './block';
+export type GridFillDirection = 'down' | 'up';
+/**
+ * A finished fill-handle drag. The grid never writes data: the caller reads
+ * `source`, builds the values (for example with `fillSeries`), writes `target`
+ * as one undoable change and saves in the background.
+ */
+export interface GridFillRequest {
+    /** The selected block the drag started from. */
+    source: GridCellRange;
+    /** The new rows only, same columns as `source`. */
+    target: GridCellRange;
+    direction: GridFillDirection;
+}
+/** The fill for a drag that ends on `targetRow`; null when the pointer is still inside the source rows. */
+export declare const planFill: (source: GridCellRange, targetRow: number, rowCount: number) => GridFillRequest | null;
+/** Source and target together: the selection after a fill. */
+export declare const filledRange: (fill: GridFillRequest) => GridCellRange;
+export type GridFillValue = string | number | null;
+/**
+ * Values for one column of a fill, in target row order (top to bottom).
+ * `source` is the column's source values, top to bottom. With two or more
+ * numbers that are not all equal, the steps between them repeat (1, 2 → 3, 4;
+ * a date passed as epoch milliseconds steps the same way). Anything else
+ * repeats the source block. An upward fill mirrors both rules.
+ */
+export declare const fillSeries: (source: readonly GridFillValue[], count: number, direction?: GridFillDirection) => GridFillValue[];

package/dist/grid/range/index.d.ts

@@ -0,0 +1,2 @@
+export * from './block';
+export * from './fill';

package/dist/grid/theme.d.ts

@@ -0,0 +1,61 @@
+import { GridCellMetrics, GridChipTone } from './cells/types';
+export interface GridChipColors {
+    fill: string;
+    color: string;
+}
+export interface GridCellTheme {
+    text: string;
+    textMuted: string;
+    link: string;
+    danger: string;
+    /** Saving dot. */
+    pending: string;
+    /** Ring drawn around the saving dot so it reads on any fill. */
+    surface: string;
+    checkboxOn: string;
+    checkboxMark: string;
+    checkboxOff: string;
+    ratingOn: string;
+    ratingOff: string;
+    progressTrack: string;
+    progressFill: string;
+    buttonFill: string;
+    buttonText: string;
+    buttonBorder: string;
+    avatarFill: string;
+    avatarText: string;
+    badgeFill: string;
+    badgeText: string;
+    chips: Record<GridChipTone, GridChipColors>;
+    /** 'light' or 'dark', for caches keyed by theme. */
+    themeKey: string;
+}
+type GridCellColorKey = Exclude<keyof GridCellTheme, 'chips' | 'themeKey'>;
+/** Which token feeds each colour. */
+export declare const GRID_CELL_TOKENS: Record<GridCellColorKey, string>;
+/**
+ * Chip tones use the badge token pairs, which have dark values. The scale
+ * names are aliases of the matching tone (blue = info, green = success,
+ * orange = warning, red = danger, gray = neutral).
+ */
+export declare const GRID_CHIP_TOKENS: Record<GridChipTone, {
+    fill: string;
+    color: string;
+}>;
+/** DSM 7 light values, used only where a token is missing (tests, a page without theme.css). */
+export declare const defaultGridCellTheme: GridCellTheme;
+/** Resolved colour of a token, or empty/undefined when the token is not set. */
+export type GridCellTokenSource = (token: string) => string | undefined;
+export declare const createGridCellTheme: (source: GridCellTokenSource, overrides?: Partial<GridCellTheme>) => GridCellTheme;
+/**
+ * Cell colours in effect on `el`, each resolved to `rgb()`/`rgba()` through a
+ * hidden probe so canvas never sees `var()` or `color-mix()`. Call again after
+ * the app switches theme (alongside the host's `refreshTheme`).
+ */
+export declare const readGridCellTheme: (el: Element, overrides?: Partial<GridCellTheme>) => GridCellTheme;
+/**
+ * Sizes for a row height: chips and avatars leave 4 px above and below (20 px
+ * in a 28 px row, 16 px in a 24 px row), icons stay 16 px down to 24 px rows.
+ */
+export declare const gridCellMetrics: (rowHeight: number, fontSize?: number, chipFontSize?: number) => GridCellMetrics;
+export {};

package/dist/grid-core/auto-scroll.d.ts

@@ -0,0 +1,67 @@
+import { DragRegionType, IPosition, IScrollDirection } from './types';
+/** Edge zone in px. */
+export declare const AUTO_SCROLL_THRESHOLD = 30;
+/** Top speed in px per ms (2000 px/s). */
+export declare const AUTO_SCROLL_MAX_PX_PER_MS = 2;
+/** Time from rest to top speed in ms. */
+export declare const AUTO_SCROLL_MS_TO_FULL_SPEED = 1200;
+export interface IAutoScrollBounds {
+    containerWidth: number;
+    containerHeight: number;
+    /** Row header plus frozen columns; pointers over frozen columns do not scroll, so they stay targets. */
+    freezeRegionWidth: number;
+    /** Row header width. */
+    columnInitSize: number;
+    /** Column header height. */
+    rowInitSize: number;
+}
+/**
+ * Scroll direction for a pointer at `position` (relative to the grid's
+ * top-left). Right/bottom: within 30 px of the edge or beyond it. Left/top:
+ * within 30 px past the frozen columns / header, over the row header or header,
+ * or beyond the grid. Teable stops when the pointer passes over the header or
+ * leaves the grid on the left or top; we keep scrolling there.
+ * `dragType` limits a row drag to y and a column drag to x.
+ */
+export declare const getAutoScrollDirection: (position: IPosition, bounds: IAutoScrollBounds, dragType?: DragRegionType, threshold?: number) => [IScrollDirection, IScrollDirection];
+/**
+ * One frame of Teable's ramp: `speed = min(1, speed + dt/1200)`, then
+ * `px = speed · dt · 2`. Teable floors `px` every frame; with `carry` the
+ * fractional part moves to the next frame instead, so the distance does not
+ * depend on the refresh rate.
+ */
+export declare const autoScrollStep: (speed: number, dt: number, carry?: number) => {
+    speed: number;
+    motion: number;
+    carry: number;
+};
+export interface IAutoScrollerOptions {
+    getBounds: () => IAutoScrollBounds;
+    scrollBy: (deltaX: number, deltaY: number) => void;
+    /** After each scroll; re-derive the selection head from the last pointer here. */
+    onTick?: (deltaX: number, deltaY: number) => void;
+    /** Default true. False floors each frame exactly as Teable does. */
+    carryFraction?: boolean;
+    requestFrame?: (callback: (time: number) => void) => number;
+    cancelFrame?: (id: number) => void;
+}
+/**
+ * Edge auto-scroll while drag-selecting, filling or dragging. Call `update`
+ * on every pointer move and `stop` on release or cancel. The speed ramps from
+ * 0 while the pointer stays in a zone and resets when it leaves all zones.
+ */
+export declare class AutoScroller {
+    direction: [IScrollDirection, IScrollDirection];
+    private speed;
+    private carry;
+    private lastTime;
+    private frameId;
+    private readonly options;
+    constructor(options: IAutoScrollerOptions);
+    get isRunning(): boolean;
+    update(position: IPosition, dragType?: DragRegionType): void;
+    stop(): void;
+    private readonly processFrame;
+    private request;
+    private cancel;
+}

package/dist/grid-core/column-resize.d.ts

@@ -0,0 +1,43 @@
+import { CoordinateManager } from './coordinate';
+import { IColumnResizeState, IMouseState, IScrollState } from './types';
+/**
+ * The column a resize zone belongs to. The zone straddles a column edge; its
+ * left half belongs to the previous column.
+ */
+export declare const resolveResizeColumnIndex: (coordInstance: CoordinateManager, scrollLeft: number, x: number, columnIndex: number) => number;
+export interface IColumnResizeControllerOptions {
+    coordInstance: () => CoordinateManager;
+    scrollState: () => Pick<IScrollState, 'scrollLeft'>;
+    /** Minimum width, per column if a function. Default 100 px (Teable). */
+    minWidth?: number | ((columnIndex: number) => number);
+    /** Every width change while dragging, and the restored width on cancel. */
+    onResize?: (width: number, columnIndex: number) => void;
+    onChange?: (state: IColumnResizeState, hoveredIndex: number) => void;
+}
+/**
+ * Column resize as a state machine: hover a resize zone → press (`start`) →
+ * live width on every move → release (`end`) or Esc (`cancel`, restores the
+ * width at the press). The width follows the pointer from the press point, so
+ * hitting the minimum and coming back does not drift.
+ */
+export declare class ColumnResizeController {
+    state: IColumnResizeState;
+    hoveredIndex: number;
+    private pressed;
+    private readonly options;
+    constructor(options: IColumnResizeControllerOptions);
+    get isResizing(): boolean;
+    private emit;
+    private minWidth;
+    /** On pointerdown; returns false unless the pointer is on a resize zone. */
+    start(mouseState: Pick<IMouseState, 'type' | 'columnIndex' | 'x'>): boolean;
+    /** On pointermove: resizes while pressed, otherwise tracks which edge is hovered. */
+    move(mouseState: Pick<IMouseState, 'type' | 'columnIndex' | 'x'>): void;
+    /** On pointerup; returns the final width and column, or null when not resizing. */
+    end(): {
+        width: number;
+        columnIndex: number;
+    } | null;
+    /** Esc while resizing: puts the width back. */
+    cancel(): void;
+}

package/dist/grid-core/config.d.ts

@@ -0,0 +1,39 @@
+import { RegionType, IColumnFreezeState, IColumnResizeState, IDragState, IMouseState, IScrollState } from './types';
+/** Geometry constants in CSS pixels. Row and header heights are defaults; the host passes its density's values to the coordinate manager. */
+export declare const GRID_DEFAULT: {
+    readonly rowHeight: 32;
+    readonly rowHeadWidth: 70;
+    readonly rowHeadIconPaddingTop: 8;
+    readonly groupHeaderHeight: 48;
+    readonly columnWidth: 150;
+    readonly columnHeadHeight: 32;
+    readonly columnHeadMenuSize: 12;
+    readonly columnHeadMenuClickableSize: 20;
+    readonly columnHeadPadding: 8;
+    readonly columnAppendBtnWidth: 100;
+    readonly columnResizeHandlerWidth: 5;
+    readonly columnResizeHandlerPaddingTop: 4;
+    readonly columnFreezeHandlerWidth: 8;
+    readonly columnFreezeHandlerHeight: 30;
+    /** Teable's hard-coded minimum while resizing. */
+    readonly columnMinWidth: 100;
+    readonly cellHorizontalPadding: 8;
+    readonly cellVerticalPaddingXS: 3;
+    readonly cellVerticalPaddingSM: 6;
+    readonly cellVerticalPaddingMD: 10;
+    readonly cellVerticalPaddingLG: 16;
+    readonly cellTextLineHeight: 22;
+    readonly fillHandlerSize: 5;
+    readonly fillHandlerPadding: 8;
+    readonly scrollBuffer: 100;
+    readonly cellScrollBuffer: 16;
+    /** Pointer travel before a header or row drag starts. */
+    readonly dragThreshold: 5;
+};
+export declare const DEFAULT_MOUSE_STATE: IMouseState;
+export declare const DEFAULT_SCROLL_STATE: IScrollState;
+export declare const DEFAULT_COLUMN_RESIZE_STATE: IColumnResizeState;
+export declare const DEFAULT_DRAG_STATE: IDragState;
+export declare const DEFAULT_FREEZE_COLUMN_STATE: IColumnFreezeState;
+/** Regions that count as hovering a row, for the row tint. */
+export declare const ROW_RELATED_REGIONS: ReadonlySet<RegionType>;

package/dist/grid-core/coordinate.d.ts

@@ -0,0 +1,64 @@
+import { ItemType, ICellMetaData, ICellMetaDataMap, ICoordinate, IIndicesMap } from './types';
+/**
+ * Row and column geometry by arithmetic. Offsets are prefix sums computed
+ * lazily up to the furthest index asked for and cached; finding the index at
+ * an offset is a binary search over the cached part, or an exponential search
+ * past it, so hit-testing never reads the DOM.
+ *
+ * Offsets include `rowInitSize` (header height) and `columnInitSize` (row
+ * header width). Change sizes through `refreshRowDimensions` /
+ * `refreshColumnDimensions` so the cache is cleared.
+ */
+export declare class CoordinateManager {
+    protected defaultRowHeight: number;
+    protected defaultColumnWidth: number;
+    pureRowCount: number;
+    rowCount: number;
+    columnCount: number;
+    private _containerWidth;
+    private _containerHeight;
+    rowHeightMap: IIndicesMap;
+    columnWidthMap: IIndicesMap;
+    rowInitSize: number;
+    columnInitSize: number;
+    lastRowIndex: number;
+    lastColumnIndex: number;
+    rowMetaDataMap: ICellMetaDataMap;
+    columnMetaDataMap: ICellMetaDataMap;
+    private _freezeColumnCount;
+    constructor({ rowHeight, columnWidth, rowCount, pureRowCount, columnCount, containerWidth, containerHeight, rowInitSize, columnInitSize, rowHeightMap, columnWidthMap, freezeColumnCount, }: ICoordinate);
+    /** Width of the row header plus the frozen columns. */
+    get freezeRegionWidth(): number;
+    get freezeColumnCount(): number;
+    set freezeColumnCount(count: number);
+    get containerWidth(): number;
+    set containerWidth(width: number);
+    get containerHeight(): number;
+    set containerHeight(height: number);
+    get columnWidth(): number;
+    set columnWidth(width: number);
+    get rowHeight(): number;
+    set rowHeight(height: number);
+    get totalWidth(): number;
+    get totalHeight(): number;
+    getRowHeight(index: number): number;
+    getColumnWidth(index: number): number;
+    /** Offset and size of one row or column, extending the prefix-sum cache up to `index` when needed. */
+    getCellMetaData(index: number, itemType: ItemType): ICellMetaData;
+    private findNearestCellIndexLinear;
+    private findNearestCellIndexBinary;
+    /** Index of the row or column that contains `offset` (in content coordinates, headers included). */
+    findNearestCellIndex(offset: number, itemType: ItemType): number;
+    getRowStartIndex(scrollTop: number): number;
+    getRowStopIndex(startIndex: number, scrollTop: number): number;
+    getColumnStartIndex(scrollLeft: number): number;
+    getColumnStopIndex(startIndex: number, scrollLeft: number): number;
+    getRowOffset(rowIndex: number): number;
+    getColumnOffset(columnIndex: number): number;
+    /** Column x on screen: frozen columns ignore horizontal scroll. */
+    getColumnRelativeOffset(columnIndex: number, scrollLeft: number): number;
+    refreshColumnDimensions({ columnCount, columnInitSize, columnWidthMap }: Pick<ICoordinate, 'columnCount' | 'columnInitSize' | 'columnWidthMap'>): void;
+    refreshRowDimensions({ rowCount, pureRowCount, rowInitSize, rowHeightMap, rowHeight }: Pick<ICoordinate, 'rowCount' | 'pureRowCount' | 'rowInitSize' | 'rowHeightMap'> & {
+        rowHeight?: number;
+    }): void;
+}

package/dist/grid-core/drag.d.ts

@@ -0,0 +1,46 @@
+import { CoordinateManager } from './coordinate';
+import { CombinedSelection } from './selection';
+import { DragRegionType, DraggableType, IDragState, IMouseState, IPosition, IRange, IScrollState } from './types';
+/**
+ * Drop index for a pointer: the hovered column (row) when the pointer is on its
+ * leading half, the next one otherwise. The index is where the dragged items
+ * land, counted before they are removed.
+ */
+export declare const getDropTargetIndex: (coordInstance: CoordinateManager, position: IPosition, scrollState: Pick<IScrollState, "scrollLeft" | "scrollTop">, dragType: DragRegionType) => number;
+export interface IDragControllerOptions {
+    coordInstance: () => CoordinateManager;
+    scrollState: () => Pick<IScrollState, 'scrollLeft' | 'scrollTop'>;
+    selection: () => CombinedSelection;
+    draggable?: DraggableType;
+    /** Pointer travel before a press becomes a drag. */
+    threshold?: number;
+    onChange?: (state: IDragState) => void;
+}
+/**
+ * Column-header and row-handle drag as a state machine:
+ * idle → pressed (`start`) → dragging (after 5 px along the drag axis) → drop
+ * (`end`) or cancel (`cancel`, for Esc). A press that never passes the
+ * threshold is a click. Dragging a header or row inside the current
+ * column/row selection drags the whole selection.
+ */
+export declare class DragController {
+    state: IDragState;
+    private startPosition;
+    private readonly options;
+    constructor(options: IDragControllerOptions);
+    private setState;
+    /** On pointerdown. Returns the drag type and ranges when the press can start a drag. */
+    start(mouseState: Pick<IMouseState, 'type' | 'rowIndex' | 'columnIndex' | 'x' | 'y'>): {
+        type: DragRegionType;
+        ranges: IRange[];
+    } | null;
+    /** On pointermove. Flips to dragging once the pointer has moved the threshold along the drag axis. */
+    move(position: IPosition): void;
+    /**
+     * On pointerup. Calls `onDrop` with the dragged ranges and the drop index
+     * unless the drop lands inside the dragged block; always resets.
+     */
+    end(position: IPosition, onDrop?: (ranges: IRange[], dropIndex: number) => void): void;
+    /** Esc while pressed or dragging: nothing moves. */
+    cancel(): void;
+}

package/dist/grid-core/freeze.d.ts

@@ -0,0 +1,11 @@
+/** Width the scrolling columns keep at least; frozen columns that would take more stop freezing. */
+export declare const MIN_FREEZE_SCROLLABLE_WIDTH = 240;
+export interface IFreezeColumnLimitOptions {
+    containerWidth: number;
+    columnInitSize: number;
+    columnCount: number;
+    getColumnWidth: (index: number) => number;
+    minScrollableWidth?: number;
+}
+/** How many leading columns can stay frozen in this width (0 on a phone with a wide first column). */
+export declare const getMaxFreezeColumnCount: ({ containerWidth, columnInitSize, columnCount, getColumnWidth, minScrollableWidth, }: IFreezeColumnLimitOptions) => number;

package/dist/grid-core/index.d.ts

@@ -0,0 +1,17 @@
+export * from './types';
+export * from './config';
+export * from './range';
+export * from './lru';
+export * from './coordinate';
+export * from './selection';
+export * from './selection-controller';
+export * from './keyboard';
+export * from './region';
+export * from './auto-scroll';
+export * from './drag';
+export * from './column-resize';
+export * from './freeze';
+export * from './keys';
+export * from './theme';
+export * from './renderer/base';
+export * from './renderer/layout';

package/dist/grid-core/keyboard.d.ts

@@ -0,0 +1,34 @@
+import { CombinedSelection } from './selection';
+import { ICellItem } from './types';
+export type IArrowDirection = 'up' | 'down' | 'left' | 'right';
+export interface IGridBounds {
+    /** Data rows. */
+    pureRowCount: number;
+    columnCount: number;
+}
+export interface ISelectionMove {
+    selection: CombinedSelection;
+    /** The new active cell, or undefined when it stays (Shift extends the range only). */
+    activeCell?: ICellItem;
+    /** The cell to scroll into view. */
+    scrollTo: ICellItem;
+}
+/**
+ * Arrow keys on a cell selection. Plain arrows move by one; `jump` (Cmd/Ctrl)
+ * goes to the edge; `expand` (Shift) keeps the anchor and moves the head.
+ */
+export declare const moveSelection: (selection: CombinedSelection, direction: IArrowDirection, modifiers: {
+    expand?: boolean;
+    jump?: boolean;
+}, bounds: IGridBounds) => ISelectionMove;
+/** Tab / Shift+Tab: one cell right or left from the anchor, collapsing any range. The host commits an open editor first. */
+export declare const tabSelection: (selection: CombinedSelection, backward: boolean, bounds: IGridBounds) => Required<ISelectionMove>;
+/** Cmd/Ctrl+A: every cell. The active cell stays. */
+export declare const selectAllCells: (selection: CombinedSelection, bounds: IGridBounds) => CombinedSelection;
+/**
+ * Enter while editing: the cell to select after commit, one row down unless
+ * `stay` is set. A column selection commits on its first row.
+ */
+export declare const enterCommitSelection: (selection: CombinedSelection, bounds: IGridBounds, stay?: boolean) => Required<ISelectionMove>;
+/** PageUp/PageDown scroll distance: one viewport below the header. */
+export declare const pageScrollDelta: (containerHeight: number, rowInitSize: number) => number;

package/dist/grid-core/keys.d.ts

@@ -0,0 +1,38 @@
+/** keyCode values (the `ts-keycode-enum` names Teable uses). */
+export declare const KeyCode: {
+    readonly Space: 32;
+    readonly Digit0: 48;
+    readonly Digit9: 57;
+    readonly A: 65;
+    readonly Z: 90;
+    readonly Numpad0: 96;
+    readonly Numpad9: 105;
+    readonly Multiply: 106;
+    readonly Divide: 111;
+    readonly Equals: 61;
+    readonly Minus: 173;
+    readonly SemiColon: 186;
+    readonly Tilde: 192;
+    readonly OpenBracket: 219;
+    readonly Quote: 222;
+    /** Sent while an input method is composing. */
+    readonly Ime: 229;
+};
+/**
+ * The first-key test and the composition guard are shared with editors outside
+ * the grid, so they live in the interaction core (also ported from Teable).
+ * Ask `guard.ownsKey(event)` before handling Enter, Esc or Tab; ask
+ * `isComposingKey(event)` before arrows.
+ */
+export { COMPOSITION_END_GRACE_MS, createCompositionGuard, isComposingKey, isPrintableKey, type CompositionGuard } from '../interaction/ime';
+export declare const isNumberKey: (keyCode: number) => boolean;
+/**
+ * Whether a paste should go to the grid's selection handler. While editing, a
+ * visible input, textarea or contenteditable keeps the native paste; the
+ * hidden focus owner forwards it.
+ */
+export declare const shouldForwardPasteToGrid: ({ isEditing, eventTarget, hiddenFocusEl }: {
+    isEditing: boolean;
+    eventTarget: EventTarget | null;
+    hiddenFocusEl: HTMLElement | null;
+}) => boolean;

package/dist/grid-core/lru.d.ts

@@ -0,0 +1,10 @@
+/** Least-recently-used map with a fixed size, on Map's insertion order. */
+export declare class LruCache<K, V> {
+    private readonly map;
+    readonly max: number;
+    constructor(max: number);
+    get size(): number;
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    clear(): void;
+}

package/dist/grid-core/range.d.ts

@@ -0,0 +1,28 @@
+import { ICellItem, IRange } from './types';
+import { CombinedSelection } from './selection';
+/** Whether `num` lies between `start` and `end`, both inclusive, in either order. */
+export declare const inRange: (num: number, start: number, end: number) => boolean;
+/** Whether a `[start, end]` run lies entirely inside one of `ranges`. */
+export declare const isRangeWithinRanges: (checkedRange: IRange, ranges: IRange[]) => boolean;
+/** Every index covered by the runs, in order. */
+export declare const flatRanges: (ranges: IRange[]) => number[];
+export declare const isPointInsideRectangle: (checkPoint: [number, number], startPoint: [number, number], endPoint: [number, number]) => boolean;
+/** Sorts runs and merges the ones that overlap or touch. */
+export declare const serializedRanges: (ranges: IRange[]) => IRange[];
+/**
+ * Toggles `newRange` in `ranges`: a run equal to it is removed, a run that
+ * contains or overlaps it loses that part, otherwise it is added.
+ */
+export declare const mixRanges: (ranges: IRange[], newRange: IRange) => IRange[];
+/** The bottom-right `[column, row]` of a cell selection, or null for other kinds. */
+export declare const calculateMaxRange: (selection: CombinedSelection) => ICellItem | null;
+export declare const checkIfRowOrCellActive: (activeCell: ICellItem | null, rowIndex: number, columnIndex: number) => {
+    isRowActive: boolean;
+    isCellActive: boolean;
+};
+export declare const checkIfRowOrCellSelected: (selection: CombinedSelection, rowIndex: number, columnIndex: number) => {
+    isRowSelected: boolean;
+    isCellSelected: boolean;
+};
+/** Element-wise equality of two lists of ranges (replaces lodash `isEqual` for this shape). */
+export declare const rangesEqual: (a: readonly IRange[], b: readonly IRange[]) => boolean;

package/dist/grid-core/region.d.ts

@@ -0,0 +1,73 @@
+import { CoordinateManager } from './coordinate';
+import { CombinedSelection } from './selection';
+import { IGridTheme } from './theme';
+import { RegionType, IActiveCellBound, ICellItem, IColumnResizeState, IDragState, IGridColumn, ILinearRow, IMouseState, IPosition, IRectangle, IRegionPosition, IRowControlItem, IScrollState } from './types';
+type IRowControlTheme = Pick<IGridTheme, 'iconSizeXS' | 'iconSizeMD'>;
+export declare const getRowControlExtraWidth: (theme: IRowControlTheme, rowControlPaddingX: number | undefined) => number;
+export declare const getRowControlLayoutWidth: (width: number, theme: IRowControlTheme, rowControlPaddingX: number | undefined) => number;
+/** Centre x of the `rowControlIndex`-th control in a row header `width` wide. */
+export declare const getRowControlOffsetX: (width: number, theme: IRowControlTheme, rowControlPaddingX: number | undefined, rowControlCount: number, rowControlIndex: number) => number;
+export declare const getRowControlCheckboxOffsetX: ({ width, theme, rowControls, rowControlPaddingX }: {
+    width: number;
+    theme: IRowControlTheme;
+    rowControls: IRowControlItem[];
+    rowControlPaddingX?: number;
+}) => number;
+/**
+ * Row and column under a point relative to the grid's top-left corner, by
+ * arithmetic only. Row -1 = column header; column -1 = row header; column -2 =
+ * the append-column button; -Infinity = above or left of the grid.
+ */
+export declare const getPosition: (coordInstance: CoordinateManager, scrollState: Pick<IScrollState, "scrollLeft" | "scrollTop">, point: IPosition) => IRegionPosition;
+/** Whether the point is past the last row or the append column (excluding a footer band between `containerHeight` and `height`). */
+export declare const isPositionOutOfBounds: (coordInstance: CoordinateManager, scrollState: Pick<IScrollState, "scrollLeft" | "scrollTop">, point: IPosition, height?: number) => boolean;
+export interface IRegionContext {
+    coordInstance: CoordinateManager;
+    scrollState: Pick<IScrollState, 'scrollLeft' | 'scrollTop'>;
+    theme: Pick<IGridTheme, 'iconSizeXS' | 'iconSizeMD'>;
+    columns: IGridColumn[];
+    selection: CombinedSelection;
+    isSelecting: boolean;
+    dragState: Pick<IDragState, 'isDragging'>;
+    columnResizeState: Pick<IColumnResizeState, 'columnIndex'>;
+    rowControls: IRowControlItem[];
+    rowControlPaddingX?: number;
+    activeCell: ICellItem | null;
+    activeCellBound: IActiveCellBound | null;
+    isFreezing?: boolean;
+    isColumnFreezable?: boolean;
+    isColumnResizable?: boolean;
+    isColumnAppendEnable?: boolean;
+    isColumnHeaderMenuVisible?: boolean;
+    isMultiSelectionEnable?: boolean;
+    /** Shows and hit-tests the fill handle. */
+    isFillEnabled?: boolean;
+    getLinearRow?: (index: number) => ILinearRow;
+    real2RowIndex?: (index: number) => number;
+}
+interface ICheckRegionProps extends IRegionContext {
+    position: IRegionPosition;
+    isOutOfBounds: boolean;
+    getLinearRow: (index: number) => ILinearRow;
+    real2RowIndex: (index: number) => number;
+}
+export interface IRegionData extends IRectangle {
+    type: RegionType;
+    rowIndex?: number;
+    columnIndex?: number;
+    isOutOfBounds?: boolean;
+}
+export declare const BLANK_REGION_DATA: IRegionData;
+/**
+ * What is under the pointer. Checks run in priority order and the first match
+ * wins: an ongoing freeze, the fill handle, the active cell, out of bounds, an
+ * ongoing selection, resize or drag, the freeze handle, the append column, the
+ * corner checkbox, the append row, the row header, a group header, a cell, a
+ * column header.
+ */
+export declare const getRegionData: (props: ICheckRegionProps) => IRegionData;
+/** Full mouse state for a point: position, region type and the region's own row/column when it reports one. */
+export declare const getMouseState: (context: IRegionContext, point: IPosition, height?: number) => IMouseState & {
+    region: IRegionData;
+};
+export {};