@kermodes/grid 0.0.0-stage → 0.3.13-dev.68.g32b767a

package/dist/ColumnHeaderGroup.d.ts

@@ -0,0 +1,8 @@
+import { type MoveOperation } from './GridMetrics';
+import { type BoundedAxisRange } from './GridAxisRange';
+export interface IColumnHeaderGroup {
+    name: string;
+    depth: number;
+    color?: string;
+    getVisibleRange: (movedColumns: readonly MoveOperation[]) => BoundedAxisRange;
+}

package/dist/ContextMenu.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { type MenuAction, type MenuItem } from './menuItems';
+export type ContextMenuProps = {
+    x: number;
+    y: number;
+    sections: MenuItem[][];
+    onPick: (action: MenuAction) => void;
+    onClose: () => void;
+};
+/**
+ * A right-click menu over the grid. Escape, a click elsewhere, or scrolling
+ * closes it; arrow keys move between items.
+ */
+export declare function ContextMenu({ x, y, sections, onPick, onClose, }: ContextMenuProps): React.ReactElement;
+export default ContextMenu;

package/dist/EventHandlerResult.d.ts

@@ -0,0 +1,16 @@
+/**
+ * An options object can be returned as the result to control
+ * if event.stopPropagation() and event.preventDefault() should be called
+ */
+export type EventHandlerResultOptions = {
+    stopPropagation?: boolean;
+    preventDefault?: boolean;
+};
+/**
+ * Result from the event handler for an event.
+ * Return one of the following:
+ * - `false` if the event was not consumed and should be passed to other registered grid event handlers
+ * - `true` to stop the event from being passed along to other registered grid event handlers, as well as call event.stopPropagation() and event.preventDefault()
+ * - An `EventHandlerResultOptions` object to stop the event from being passed along to other registered grid event handlers, and decide whether to call event.stopPropagation() and/or event.preventDefault()
+ */
+export type EventHandlerResult = boolean | EventHandlerResultOptions;

package/dist/FilterBar.d.ts

@@ -0,0 +1,32 @@
+import React from 'react';
+import type GridMetrics from './GridMetrics';
+import { type DraggingColumn } from './mouse-handlers/GridColumnMoveMouseHandler';
+import { type ViewportColumn } from '@kermodes/client';
+/** Height of the quick filter bar under the column headers */
+export declare const FILTER_BAR_HEIGHT = 26;
+export declare const FILTER_SYNTAX: string;
+export declare function filterPlaceholder(type: string): string;
+/** Where one column's filter input sits, from the grid's metrics */
+export type FilterCell = {
+    column: ViewportColumn;
+    left: number;
+    width: number;
+};
+/**
+ * The filter inputs' positions for the columns on screen, in display order. Columns being
+ * dragged sit where the drag draws them, under the pointer, not at the slot they hold.
+ */
+export declare function filterCells(metrics: Pick<GridMetrics, 'columnsForRender' | 'allColumnXs' | 'allColumnWidths' | 'modelColumns' | 'gridX'>, columns: readonly ViewportColumn[], dragging?: DraggingColumn | null): FilterCell[];
+type FilterBarProps = {
+    cells: readonly FilterCell[];
+    top: number;
+    filters: Readonly<Record<string, string>>;
+    errors: Readonly<Record<string, string>>;
+    onChange: (column: string, text: string) => void;
+};
+/**
+ * One text input per column under the headers, like Deephaven's quick filter bar. Each fills
+ * its column's cell of the band the renderer draws (`drawFilterBar`), short of the divider.
+ */
+export declare function FilterBar({ cells, top, filters, errors, onChange, }: FilterBarProps): React.ReactElement;
+export {};

package/dist/Grid.d.ts

@@ -0,0 +1,458 @@
+import React, { PureComponent, type ReactNode, type RefObject } from 'react';
+import GridMetricCalculator, { type GridMetricState } from './GridMetricCalculator';
+import type GridModel from './GridModel';
+import { type GridMouseEvent, type GridMouseHandlerFunctionName } from './GridMouseHandler';
+import type GridMouseHandler from './GridMouseHandler';
+import { type GridTheme as GridThemeType } from './GridTheme';
+import GridRange, { type GridRangeIndex, SELECTION_DIRECTION } from './GridRange';
+import GridRenderer from './GridRenderer';
+import { type GridPoint } from './GridUtils';
+import { type GridSeparator } from './mouse-handlers';
+import { type DraggingColumn } from './mouse-handlers/GridColumnMoveMouseHandler';
+import { type GridKeyHandlerFunctionName, type GridKeyboardEvent } from './KeyHandler';
+import type KeyHandler from './KeyHandler';
+import { type Coordinate, type ModelIndex, type MoveOperation, type VisibleIndex } from './GridMetrics';
+import type GridMetrics from './GridMetrics';
+import ThemeContext from './ThemeContext';
+import { type GestureMode, type GetModel, type Selection } from './Selection';
+import { type GridRenderState } from './GridRendererTypes';
+export type GridProps = typeof Grid.defaultProps & {
+    children?: ReactNode;
+    canvasOptions?: CanvasRenderingContext2DSettings;
+    isStickyBottom?: boolean;
+    isStickyRight?: boolean;
+    isStuckToBottom?: boolean;
+    isStuckToRight?: boolean;
+    metricCalculator?: GridMetricCalculator;
+    model: GridModel;
+    keyHandlers?: readonly KeyHandler[];
+    mouseHandlers?: readonly GridMouseHandler[];
+    createEmptySelection?: (getModel: GetModel) => Selection;
+    movedColumns?: readonly MoveOperation[];
+    movedRows?: readonly MoveOperation[];
+    onError?: (e: Error) => void;
+    onSelectionChange?: (selection: Selection) => void;
+    onViewChanged?: (metrics: GridMetrics) => void;
+    renderer?: GridRenderer;
+    filterBarHeight?: number;
+    stateOverride?: Record<string, unknown>;
+    theme?: Partial<GridThemeType>;
+};
+export type GridState = {
+    top: VisibleIndex;
+    left: VisibleIndex;
+    topOffset: number;
+    leftOffset: number;
+    draggingColumn: DraggingColumn | null;
+    draggingColumnSeparator: GridSeparator | null;
+    isDraggingHorizontalScrollBar: boolean;
+    isDraggingVerticalScrollBar: boolean;
+    isDragging: boolean;
+    mouseX: number | null;
+    mouseY: number | null;
+    movedColumns: readonly MoveOperation[];
+    movedRows: readonly MoveOperation[];
+    selection: Selection;
+    lastSelection: Selection;
+    gestureMode: GestureMode | null;
+    cursor: string | null;
+    isStuckToBottom: boolean;
+    isStuckToRight: boolean;
+    /**
+     * Errors thrown during a render animation frame.
+     * These are not caught by the grid panel,
+     * so we need to throw them in componentDidUpdate
+     */
+    renderError?: unknown;
+    /** What revision the grid is drawing. Automatically increments when a forceUpdate is called. */
+    updateRevision: number;
+};
+/** Selection-related slice of `GridState`. Returned by gesture entry points. */
+export type GridSelectionState = Pick<GridState, 'selection' | 'lastSelection'>;
+/**
+ * High performance, extendible, themeable grid component.
+ * Architectured to be fast and handle billions of rows/columns by default.
+ * The base model does not provide support for sorting, filtering, etc.
+ * To get that functionality, extend GridModel/GridRenderer, and add onClick/onContextMenu handlers to implement your own sort.
+ *
+ * Extend GridModel with your own data model to provide the data for the grid.
+ * Extend GridTheme to change the appearance if the grid. See GridTheme for all the settable values.
+ * Extend GridMetricCalculator to provide different metrics for the grid, such as column sizing, header sizing, etc.
+ * Extend GridRenderer to have complete control over the rendering process. Can override just one method such as drawColumnHeader, or override the whole drawCanvas process.
+ *
+ * Add an onViewChanged callback to page in/out data as user moves around the grid
+ * Can also add onClick and onContextMenu handlers to add custom functionality and menus.
+ */
+declare class Grid extends PureComponent<GridProps, GridState> {
+    static contextType: React.Context<Partial<GridThemeType>>;
+    context: React.ContextType<typeof ThemeContext>;
+    static defaultProps: {
+        canvasOptions: CanvasRenderingContext2DSettings;
+        isStickyBottom: boolean;
+        isStickyRight: boolean;
+        isStuckToBottom: boolean;
+        isStuckToRight: boolean;
+        keyHandlers: readonly KeyHandler[];
+        mouseHandlers: readonly GridMouseHandler[];
+        movedColumns: readonly MoveOperation[];
+        movedRows: readonly MoveOperation[];
+        filterBarHeight: number;
+        onError: () => void;
+        onSelectionChange: (_selection: Selection) => void;
+        onViewChanged: (metrics: GridMetrics) => void;
+        stateOverride: Record<string, unknown>;
+        theme: Partial<GridThemeType>;
+        createEmptySelection: (getModel: GetModel) => Selection;
+    };
+    static pixelsPerLine: number;
+    static dragTimeout: number;
+    static getTheme: import("memoize-one").MemoizedFn<(contextTheme: Partial<GridThemeType>, userTheme: Partial<GridThemeType>) => {
+        allowColumnResize: boolean;
+        allowRowResize: boolean;
+        autoSelectRow: boolean;
+        autoSelectColumn: boolean;
+        autoSizeColumns: boolean;
+        autoSizeRows: boolean;
+        backgroundColor: import("./GridTheme").GridColor;
+        textColor: import("./GridTheme").GridColor;
+        positiveNumberColor: import("./GridTheme").GridColor;
+        negativeNumberColor: import("./GridTheme").GridColor;
+        zeroNumberColor: import("./GridTheme").GridColor;
+        dateColor: import("./GridTheme").GridColor;
+        nullBackgroundColor: import("./GridTheme").NullableGridColor;
+        cellHorizontalPadding: number;
+        headerHorizontalPadding: number;
+        font: import("./GridTheme").GridFont;
+        gridColumnColor: import("./GridTheme").NullableGridColor;
+        gridRowColor: import("./GridTheme").NullableGridColor;
+        headerBackgroundColor: import("./GridTheme").GridColor;
+        headerSeparatorColor: import("./GridTheme").GridColor;
+        headerSeparatorHoverColor: import("./GridTheme").GridColor;
+        headerSeparatorHandleSize: number;
+        headerHiddenSeparatorSize: number;
+        headerHiddenSeparatorHoverColor: import("./GridTheme").GridColor;
+        headerColor: import("./GridTheme").GridColor;
+        headerFont: import("./GridTheme").GridFont;
+        columnHoverBackgroundColor: import("./GridTheme").NullableGridColor;
+        rowHoverBackgroundColor: import("./GridTheme").NullableGridColor;
+        selectedRowHoverBackgroundColor: import("./GridTheme").NullableGridColor;
+        cursorRowBackgroundColor: import("./GridTheme").NullableGridColor;
+        rowBackgroundColors: import("./GridTheme").GridColorWay;
+        minScrollHandleSize: number;
+        scrollBarBackgroundColor: import("./GridTheme").GridColor;
+        scrollBarHoverBackgroundColor: import("./GridTheme").GridColor;
+        scrollBarCasingColor: import("./GridTheme").GridColor;
+        scrollBarCornerColor: import("./GridTheme").GridColor;
+        scrollBarColor: import("./GridTheme").GridColor;
+        scrollBarHoverColor: import("./GridTheme").GridColor;
+        scrollBarActiveColor: import("./GridTheme").GridColor;
+        scrollBarSize: number;
+        scrollBarHoverSize: number;
+        scrollBarCasingWidth: number;
+        scrollSnapToColumn: boolean;
+        scrollSnapToRow: boolean;
+        scrollBarSelectionTick: boolean;
+        scrollBarSelectionTickColor: import("./GridTheme").NullableGridColor;
+        scrollBarActiveSelectionTickColor: import("./GridTheme").NullableGridColor;
+        activeCellSelectionBorderWidth: number;
+        selectionColor: import("./GridTheme").GridColor;
+        selectionOutlineColor: import("./GridTheme").GridColor;
+        selectionOutlineCasingColor: import("./GridTheme").GridColor;
+        reorderOffset: number;
+        shadowBlur: number;
+        shadowColor: import("./GridTheme").GridColor;
+        flashColor: import("./GridTheme").GridColor;
+        errorColor: import("./GridTheme").GridColor;
+        rowHeight: number;
+        columnWidth: number;
+        minColumnWidth: number;
+        maxColumnWidth: number;
+        columnHeaderHeight: number;
+        rowHeaderWidth: number;
+        rowFooterWidth: number;
+        headerResizeSnapThreshold: number;
+        headerResizeHiddenSnapThreshold: number;
+        floatingGridColumnColor: import("./GridTheme").NullableGridColor;
+        floatingGridRowColor: import("./GridTheme").NullableGridColor;
+        floatingRowBackgroundColors: import("./GridTheme").GridColorWay;
+        floatingDividerOuterColor: import("./GridTheme").GridColor;
+        floatingDividerInnerColor: import("./GridTheme").GridColor;
+    }>;
+    /**
+     * On some devices there may be different scaling required for high DPI. Get the scale required for the canvas.
+     * @param context The canvas context
+     * @returns The scale to use
+     */
+    static getScale(context: CanvasRenderingContext2D): number;
+    /**
+     * Get the floored layout size of an element, unaffected by CSS transforms.
+     * clientWidth/clientHeight round fractional sizes, which can make the canvas
+     * overflow its wrapper by a pixel, so read the fractional size from the
+     * computed style when available.
+     * @param element The element to get the size of
+     * @returns The floored layout width and height of the element
+     */
+    static getFlooredLayoutSize(element: HTMLElement): {
+        width: number;
+        height: number;
+    };
+    /**
+     * Get the class name from the cursor provided
+     * @param cursor The grid cursor to use
+     * @returns Class name with the grid-cursor prefix or null if no cursor provided
+     */
+    static getCursorClassName(cursor: string | null): string | null;
+    renderer: GridRenderer;
+    metricCalculator: GridMetricCalculator;
+    canvas: HTMLCanvasElement | null;
+    canvasContext: CanvasRenderingContext2D | null;
+    canvasWrapper: RefObject<HTMLDivElement | null>;
+    resizeObserver: ResizeObserver;
+    animationFrame: number | null;
+    prevMetrics: GridMetrics | null;
+    metrics: GridMetrics | null;
+    private renderState;
+    documentCursor: string | null;
+    hasAddedBlockEvents: boolean;
+    dragTimer: ReturnType<typeof setTimeout> | null;
+    keyHandlers: readonly KeyHandler[];
+    mouseHandlers: readonly GridMouseHandler[];
+    constructor(props: GridProps);
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: GridProps, prevState: GridState): void;
+    componentWillUnmount(): void;
+    getTheme(): GridThemeType;
+    getGridPointFromEvent(event: GridMouseEvent): GridPoint;
+    getGridPointFromXY(x: Coordinate, y: Coordinate): GridPoint;
+    getMetricState(state?: Readonly<GridState>): GridMetricState;
+    getCachedKeyHandlers: import("memoize-one").MemoizedFn<(keyHandlers: readonly KeyHandler[]) => KeyHandler[]>;
+    getKeyHandlers(): readonly KeyHandler[];
+    getCachedMouseHandlers: import("memoize-one").MemoizedFn<(mouseHandlers: readonly GridMouseHandler[]) => readonly GridMouseHandler[]>;
+    getMouseHandlers(): readonly GridMouseHandler[];
+    /**
+     * Translate from the provided visible index to the model index
+     * @param columnIndex The column index to get the model for
+     * @returns The model index
+     */
+    getModelColumn(columnIndex: VisibleIndex): ModelIndex;
+    /**
+     * Translate from the provided visible index to the model index
+     * @param rowIndex The row index to get the model for
+     * @returns The model index
+     */
+    getModelRow(rowIndex: VisibleIndex): ModelIndex;
+    getStickyScrollPosition(isStickyBottom: boolean, isStickyRight: boolean): {
+        top: VisibleIndex;
+        left: VisibleIndex;
+    };
+    /**
+     * Allows the selected ranges to be set programatically
+     * Will update the cursor and selection start/end based on the new ranges
+     * @param gridRanges The new selected ranges to set
+     */
+    setSelectedRanges(gridRanges: readonly GridRange[]): void;
+    initContext(): void;
+    requestUpdateCanvas(): void;
+    /**
+     * Updates the canvas, metrics, and render state, then draws the canvas.
+     */
+    updateCanvas(): void;
+    private updateCanvasScale;
+    updateScrollBounds(): void;
+    /**
+     * Compares the current metrics with the previous metrics to see if we need to scroll when it is stuck to the bottom or the right
+     */
+    needToUpdateScroll(): boolean;
+    updateMetrics(state?: Readonly<GridState>): GridMetrics;
+    /**
+     * Check if the selection state has changed, and call the onSelectionChange callback if it has
+     * @param prevState The previous grid state
+     */
+    checkSelectionChange(prevState: GridState): void;
+    /**
+     * Validate the current selection, and reset if it is invalid
+     * @returns True if the selection is valid, false if the selection was invalid and has been reset
+     */
+    validateSelection(): boolean;
+    /**
+     * Clears all selected ranges
+     */
+    clearSelectedRanges(): void;
+    /** Clears all but the last selected range */
+    trimSelectedRanges(): void;
+    /** Sets the selection directly, bypassing mouse/keyboard gesture state. */
+    setSelection(selection: Selection): void;
+    /** Gets the current selection */
+    getSelection(): Selection;
+    /**
+     * Queries the current grid model.
+     * @returns The current GridModel instance.
+     */
+    getModel(): GridModel;
+    /**
+     * Extend + commit a gesture at `cursor` and return the resulting partial
+     * state. Shared by mouse click-and-release and keyboard commits.
+     *
+     * @param selection Pre-gesture selection to fold against. Cursor landing
+     * reads its extended (pre-commit) form so `KeyedSelection`'s overlay is
+     * still available.
+     * @param cursor Gesture target cell.
+     * @param mode Modifier-derived gesture mode.
+     * @param opts.moveCursor Snap the cursor to `cursor` (default true).
+     * Pass false for keyboard extend / maximize / add so the cursor stays put.
+     * @param opts.allowDeselect Whether committing on top of the same
+     * single-row / single-cell selection should deselect (mouse affordance,
+     * default true). Keyboard callers pass false so arrowing onto an
+     * already-selected cell just moves the cursor.
+     * @param opts.settle Whether the commit should finalize (deselect check,
+     * hole-punch, consolidation). Mouse-down passes false so a drag can grow
+     * the last range before mouse-up finalizes.
+     */
+    private applyGestureAt;
+    /**
+     * Start a mouse-driven selection gesture at `cursor` with the given
+     * modifier-derived `mode`. Extends the selection per `mode` semantics
+     * and commits immediately so a click without drag settles the state.
+     */
+    handleMouseSelectStart(cursor: {
+        row: GridRangeIndex;
+        column: GridRangeIndex;
+    }, mode: GestureMode): void;
+    /**
+     * Extend the current mouse selection gesture to `cursor`. Transient
+     * overlay only; the settled commit runs on `handleMouseSelectEnd`.
+     */
+    handleMouseSelectDrag(cursor: {
+        row: GridRangeIndex;
+        column: GridRangeIndex;
+    }): void;
+    /** Settle the current mouse selection gesture. Called on mouse-up. */
+    handleMouseSelectEnd(): void;
+    /**
+     * Apply a keyboard-driven selection gesture at `cursor` with `mode`, then
+     * optionally scroll the viewport to bring the cursor into view. Shared
+     * entry point for arrow keys, Home/End, and page-key movements.
+     *
+     * Only `replace` moves the cursor to `cursor`; extend/maximize/add
+     * preserve the existing cursor and update `selectionEnd` only. This
+     * matches long-standing Shift+Arrow semantics where the cursor stays put
+     * as the selection grows.
+     */
+    handleKeySelectAt(cursor: {
+        row: GridRangeIndex;
+        column: GridRangeIndex;
+    }, mode: GestureMode, opts?: {
+        keepCursorInView?: boolean;
+    }): void;
+    /**
+     * Advance the cursor in `direction` through the current selection. Used
+     * by Tab/Enter — cycles within the selected ranges when there are
+     * multiple, wraps at grid edges when there is only a single cell.
+     * When the resulting cursor falls outside the current selection (e.g.
+     * from an initial empty state), installs a fresh single-cell selection.
+     */
+    handleKeyAdvanceCursor(direction: SELECTION_DIRECTION): void;
+    /**
+     * Page-move gesture. `direction` is +1 (page-down) or -1 (page-up). Reads
+     * viewport metrics to compute the target cell, applies the gesture without
+     * auto-scrolling, then pins the viewport top so the cursor lands where it
+     * was on screen before.
+     */
+    private handleKeyPage;
+    handleKeyPageUp(mode: GestureMode): void;
+    handleKeyPageDown(mode: GestureMode): void;
+    /**
+     * Move the cursor to a cell without touching the selection.
+     */
+    handleKeyMoveCursor(column: VisibleIndex, row: VisibleIndex): void;
+    setFocusRow(focusedRow: number): void;
+    /**
+     * Set the selection to the entire grid
+     */
+    selectAll(): void;
+    /**
+     * Moves the view to make the specified cell visible
+     *
+     * @param column The column index to bring into view
+     * @param row The row index to bring into view
+     */
+    moveViewToCell(column: GridRangeIndex, row: GridRangeIndex): void;
+    /**
+     * Checks the `top` and `left` properties that are set and updates the isStuckToBottom/Right properties
+     * Should be called when user interaction occurs
+     * @param viewState New state properties to set.
+     * @param forceUpdate Whether to force an update.
+     */
+    setViewState(viewState: Partial<GridState>, forceUpdate?: boolean): void;
+    /**
+     * Check if a given cell is within the current selection
+     * @param row Row to check
+     * @param column Column to check
+     * @returns True if the cell is in the current selection, false otherwise
+     */
+    isSelected(row: VisibleIndex, column: VisibleIndex): boolean;
+    addDocumentCursor(cursor?: string | null): void;
+    removeDocumentCursor(): void;
+    startDragTimer(event: React.MouseEvent): void;
+    stopDragTimer(): void;
+    /**
+     * Draw the grid with the metrics provided
+     * When scrolling you've have to re-draw the whole canvas. As a consequence, all these drawing methods
+     * must be very quick.
+     */
+    private drawCanvas;
+    /**
+     * Set focus to this grid element
+     */
+    focus(): void;
+    /**
+     * Check if this grid is currently focused
+     * @returns True if the active element is this grid
+     */
+    isFocused(): boolean;
+    /**
+     * Handle a mouse click event. Pass the event to the registered mouse handlers until one handles it.
+     * Focuses the grid after the click.
+     * @param event The mouse event
+     */
+    handleClick(event: React.MouseEvent): void;
+    /**
+     * Handle a mouse context menu event. Pass the event to the registered mouse handlers until one handles it.
+     * @param event The mouse event triggering the context menu
+     */
+    handleContextMenu(event: React.MouseEvent): void;
+    /**
+     * Notify all of the keyboard handlers for this grid of a keyboard event.
+     * @param functionName The name of the function in the keyboard handler to call
+     * @param event The keyboard event to notify
+     */
+    notifyKeyboardHandlers(functionName: GridKeyHandlerFunctionName, event: GridKeyboardEvent): void;
+    handleKeyDown(event: GridKeyboardEvent): void;
+    handleKeyUp(event: GridKeyboardEvent): void;
+    /** Shows `cursor` over the canvas, eg. when a modifier key changes under a still pointer */
+    setCursor(cursor: string | null): void;
+    /**
+     * Notify all of the mouse handlers for this grid of a mouse event.
+     * @param functionName The name of the function in the mouse handler to call
+     * @param event The mouse event to notify
+     * @param updateCoordinates Whether to update the mouse coordinates
+     * @param addCursorToDocument Whether to add a cursor overlay or not (for dragging)
+     */
+    notifyMouseHandlers(functionName: GridMouseHandlerFunctionName, event: GridMouseEvent, updateCoordinates?: boolean, addCursorToDocument?: boolean): void;
+    handleMouseDown(event: React.MouseEvent): void;
+    handleDoubleClick(event: React.MouseEvent): void;
+    handleMouseMove(event: React.MouseEvent): void;
+    handleMouseLeave(event: React.MouseEvent): void;
+    handleMouseDrag(event: MouseEvent): void;
+    handleMouseUp(event: MouseEvent): void;
+    handleResize(): void;
+    forceUpdate(callback?: (() => void) | undefined): void;
+    handleWheel(event: WheelEvent): void;
+    /**
+     * Gets the render state
+     * @returns The render state
+     */
+    updateRenderState(): GridRenderState;
+    render(): ReactNode;
+}
+export default Grid;

package/dist/GridAxisRange.d.ts

@@ -0,0 +1,9 @@
+import type { GridRangeIndex } from './GridRange';
+import type { VisibleIndex } from './GridMetrics';
+export type Range<T> = [start: T, end: T];
+export type AxisRange = Range<GridRangeIndex>;
+export type BoundedAxisRange = Range<VisibleIndex>;
+export declare function isAxisRange(range: unknown): range is AxisRange;
+export declare function assertAxisRange(range: unknown): asserts range is AxisRange;
+export declare function isBoundedAxisRange(range: unknown): range is BoundedAxisRange;
+export declare function assertBoundedAxisRange(range: unknown): asserts range is BoundedAxisRange;