@kermodes/grid 0.0.0-stage → 0.3.13-dev.71.ge96feae

package/dist/GridStyles.d.ts

@@ -0,0 +1,2 @@
+export declare function injectGridStyles(doc?: Document): void;
+export default injectGridStyles;

package/dist/GridTheme.d.ts

@@ -0,0 +1,96 @@
+/** A color parsed as CSS color value, eg. '#FF0000' */
+export type GridColor = string;
+/** A nullable color, eg. pass `null` to skip drawing this item */
+export type NullableGridColor = GridColor | null;
+/** One or more colors parsed as CSS color value separated by space, eg. '#FF0000 #00FF00' */
+export type GridColorWay = string;
+/** A font parsed as CSS font value */
+export type GridFont = string;
+export type GridTheme = {
+    allowColumnResize: boolean;
+    allowRowResize: boolean;
+    autoSelectRow: boolean;
+    autoSelectColumn: boolean;
+    autoSizeColumns: boolean;
+    autoSizeRows: boolean;
+    backgroundColor: GridColor;
+    textColor: GridColor;
+    positiveNumberColor: GridColor;
+    negativeNumberColor: GridColor;
+    zeroNumberColor: GridColor;
+    dateColor: GridColor;
+    nullBackgroundColor: NullableGridColor;
+    cellHorizontalPadding: number;
+    headerHorizontalPadding: number;
+    font: GridFont;
+    gridColumnColor: NullableGridColor;
+    gridRowColor: NullableGridColor;
+    headerBackgroundColor: GridColor;
+    headerSeparatorColor: GridColor;
+    headerSeparatorHoverColor: GridColor;
+    headerSeparatorHandleSize: number;
+    headerHiddenSeparatorSize: number;
+    headerHiddenSeparatorHoverColor: GridColor;
+    headerColor: GridColor;
+    headerFont: GridFont;
+    columnHoverBackgroundColor: NullableGridColor;
+    rowHoverBackgroundColor: NullableGridColor;
+    selectedRowHoverBackgroundColor: NullableGridColor;
+    cursorRowBackgroundColor: NullableGridColor;
+    rowBackgroundColors: GridColorWay;
+    minScrollHandleSize: number;
+    scrollBarBackgroundColor: GridColor;
+    scrollBarHoverBackgroundColor: GridColor;
+    scrollBarCasingColor: GridColor;
+    scrollBarCornerColor: GridColor;
+    scrollBarColor: GridColor;
+    scrollBarHoverColor: GridColor;
+    scrollBarActiveColor: GridColor;
+    scrollBarSize: number;
+    scrollBarHoverSize: number;
+    scrollBarCasingWidth: number;
+    scrollSnapToColumn: boolean;
+    scrollSnapToRow: boolean;
+    scrollBarSelectionTick: boolean;
+    scrollBarSelectionTickColor: NullableGridColor;
+    scrollBarActiveSelectionTickColor: NullableGridColor;
+    activeCellSelectionBorderWidth: number;
+    selectionColor: GridColor;
+    selectionOutlineColor: GridColor;
+    selectionOutlineCasingColor: GridColor;
+    reorderOffset: number;
+    shadowBlur: number;
+    shadowColor: GridColor;
+    flashColor: GridColor;
+    errorColor: GridColor;
+    rowHeight: number;
+    columnWidth: number;
+    minColumnWidth: number;
+    maxColumnWidth: number;
+    columnHeaderHeight: number;
+    rowHeaderWidth: number;
+    rowFooterWidth: number;
+    headerResizeSnapThreshold: number;
+    headerResizeHiddenSnapThreshold: number;
+    floatingGridColumnColor: NullableGridColor;
+    floatingGridRowColor: NullableGridColor;
+    floatingRowBackgroundColors: GridColorWay;
+    floatingDividerOuterColor: GridColor;
+    floatingDividerInnerColor: GridColor;
+};
+/** A design token's value by name, without the leading `--` (web/theme/tokens.css) */
+export type TokenReader = (name: string) => string;
+/**
+ * The grid's look from the design tokens (docs/theme.md), so the canvas draws with the same
+ * colours and fonts as the page around it: cells in the mono for aligned figures, headers in
+ * the sans.
+ */
+export declare function gridTheme(token: TokenReader): GridTheme;
+/** The grid's theme from the tokens in effect at `element`, which must be in the document */
+export declare function gridThemeOf(element: Element): GridTheme;
+/**
+ * Geometry and behaviour for a grid given no theme; its colours are the token names, so a host
+ * that forgets to pass `gridThemeOf(...)` draws nothing rather than a second palette.
+ */
+declare const baseTheme: GridTheme;
+export default baseTheme;

package/dist/GridUtils.d.ts

@@ -0,0 +1,457 @@
+import type React from 'react';
+import GridRange, { type GridRangeIndex } from './GridRange';
+import { type BoxCoordinates, type Coordinate, type CoordinateMap, type VisibleIndex, type VisibleToModelMap, type ModelIndex, type ModelSizeMap, type MoveOperation, type SizeMap, type GridMetrics } from './GridMetrics';
+import { type GridTheme } from './GridTheme';
+import { type GridWheelEvent } from './GridMouseHandler';
+import { type AxisRange, type BoundedAxisRange, type Range } from './GridAxisRange';
+import { type GridRenderState } from './GridRendererTypes';
+import type GridModel from './GridModel';
+export type GridPoint = {
+    x: Coordinate;
+    y: Coordinate;
+    column: GridRangeIndex;
+    row: GridRangeIndex;
+    columnHeaderDepth?: number;
+};
+export interface CellInfo {
+    row: VisibleIndex | null;
+    column: VisibleIndex | null;
+    modelRow: ModelIndex | null;
+    modelColumn: ModelIndex | null;
+    left: Coordinate | null;
+    top: Coordinate | null;
+    columnWidth: number | null;
+    rowHeight: number | null;
+}
+export type IndexCallback<T> = (itemIndex: VisibleIndex) => T | undefined;
+export declare class GridUtils {
+    static PIXELS_PER_LINE: number;
+    /**
+     * Get the GridPoint for the coordinates provided
+     * @param x The grid x coordinate
+     * @param y The grid y coordinate
+     * @param metrics The grid metrics
+     * @returns The GridPoint including the column/row information
+     */
+    static getGridPointFromXY(x: Coordinate, y: Coordinate, metrics: GridMetrics): GridPoint;
+    static getCellInfoFromXY(x: Coordinate, y: Coordinate, metrics: GridMetrics): CellInfo;
+    static getColumnHeaderDepthAtY(y: Coordinate, metrics: GridMetrics): number | undefined;
+    /**
+     * Iterate through each floating item at the start and call a callback, returning the first result
+     * @param start The count of floating items at the start
+     * @param total The total number of items
+     * @param callback Function to call for each item
+     * @returns The result from the callback
+     */
+    static iterateFloatingStart<T>(start: number, total: number, callback: IndexCallback<T>): T | undefined;
+    /**
+     * Iterate through floating items at the end. Iterates in increasing order.
+     * @param end The count of floating items at the end
+     * @param total The total number of items
+     * @param callback Function to call for each item
+     * @returns The result from the callback
+     */
+    static iterateFloatingEnd<T>(end: number, total: number, callback: IndexCallback<T>): T | undefined;
+    /**
+     * Iterate through all floating items in increasing order, starting with the top items.
+     * @param start Count of start floating rows, e.g. floatingTopRowCount
+     * @param end Count of end floating rows, e.g. floatingBottomRowCount
+     * @param total Total number of items
+     * @param callback Callback called for each value, stopping the iterating and returning the value if one is returned
+     */
+    static iterateFloating<T>(start: number, end: number, total: number, callback: IndexCallback<T>): T | undefined;
+    /**
+     * Iterate through all items in one dimension on the grid - first floating, then visible.
+     * Call the callback for each item, break if a result is returned and return that result.
+     * @param visibleStart Index of the start of the visible viewport
+     * @param visibleEnd Index of the end of the visible viewport
+     * @param floatingStartCount Number of items floating at the start
+     * @param floatingEndCount Number of items floating at the end
+     * @param totalCount Total number of items
+     * @param callback Callback to call for each item
+     * @returns The first result from the callback called, or undefined
+     */
+    static iterateAllItems<T>(visibleStart: VisibleIndex, visibleEnd: VisibleIndex, floatingStartCount: number, floatingEndCount: number, totalCount: number, callback: IndexCallback<T>): T | undefined;
+    /**
+     * Check if the coordinate is within the item specified in this dimension
+     * @param itemIndex Index of the item to check
+     * @param itemCoordinatess Coordinate of all items in this dimension
+     * @param itemSizes Size of all items in this dimension
+     * @param coordinate The coordinate to check
+     * @returns True if the coordinate is within the item specified, false otherwise
+     */
+    static isInItem(itemIndex: VisibleIndex, itemCoordinates: CoordinateMap, itemSizes: SizeMap, coordinate: Coordinate): boolean;
+    /**
+     * Get the Index of the item at the provided offset
+     * @param offset Coordinate of the offset to get the item of
+     * @param itemCount The total count of items
+     * @param floatingStart Count of floating items at the start
+     * @param floatingEnd Count of floating items at the end
+     * @param items Index of all items
+     * @param itemCoordinates The coordinate of each item
+     * @param itemSizes The size of each item
+     * @returns The item index, or null if no item matches
+     */
+    static getItemAtOffset(offset: Coordinate, itemCount: number, floatingStart: number, floatingEnd: number, items: readonly VisibleIndex[], itemCoordinates: CoordinateMap, itemSizes: SizeMap, ignoreFloating?: boolean): VisibleIndex | null;
+    /**
+     * Get the index of the column at the specified x coordinate
+     * @param x Coordinate to get the item of
+     * @param metrics Grid metrics
+     * @returns Index of the column at that coordinate, or null if no column matches
+     */
+    static getColumnAtX(x: Coordinate, metrics: GridMetrics, ignoreFloating?: boolean): VisibleIndex | null;
+    /**
+     * Get the index of the row at the specified y coordinate
+     * @param y Coordinate to get the item of
+     * @param metrics Grid metrics
+     * @returns Index of the row at that coordinate, or null if no row matches
+     */
+    static getRowAtY(y: Coordinate, metrics: GridMetrics): VisibleIndex | null;
+    /**
+     * Iterate backward through the visible items until a shown item is hit
+     * @param startIndex The index to start from
+     * @param modelIndexes The mapping of model indexes
+     * @param visibleItems The visible items
+     * @param userSizes The user set sizes
+     * @returns Index of the next visible item, or null if no more are visible
+     */
+    static getNextShownItem(startIndex: VisibleIndex, modelIndexes: VisibleToModelMap, visibleItems: readonly VisibleIndex[], userSizes: ModelSizeMap): VisibleIndex | null;
+    /**
+     * Iterate backward through the visible columns until a shown column is hit
+     * @param columnIndex The column index to start iterating backward from
+     * @param metrics The GridMetricCalculator metrics
+     * @returns Index of the next visible item, or null if no more are visible
+     */
+    static getNextShownColumn(startIndex: VisibleIndex, metrics: GridMetrics): VisibleIndex | null;
+    /**
+     * Iterate backward through the visible rows until a shown row is hit
+     * @param rowIndex The row index to start iterating backward from
+     * @param metrics The GridMetricCalculator metrics
+     * @returns Index of the next visible item, or null if no more are visible
+     */
+    static getNextShownRow(startIndex: VisibleIndex, metrics: GridMetrics): VisibleIndex | null;
+    /**
+     * Determine whether two adjacent columns belong to the same column-header group
+     * at the given depth.
+     *
+     * - When the model exposes group instances via `getColumnHeaderGroup`, identity
+     *   decides: two distinct group instances that happen to share a display name
+     *   (e.g. pivot Totals groups) are treated as different groups.
+     * - When only one side has a declared group, they are different groups.
+     * - When neither side has a declared group, fall back to header-text equality so
+     *   plain grouped-header models (which express grouping only through repeated
+     *   text) keep their existing behavior.
+     *
+     * @param model The grid model
+     * @param depth The header depth to check at
+     * @param columnIndex The first model column index
+     * @param otherColumnIndex The second model column index
+     * @returns true if both columns are part of the same group at this depth
+     */
+    static isSameColumnGroupAtDepth(model: GridModel, depth: number, columnIndex: ModelIndex, otherColumnIndex: ModelIndex): boolean;
+    /**
+     * Check if a separator exists between the column at `visibleIndex` and the
+     * column immediately after it at a given header depth.
+     *
+     * - At leaf depth (0), every model column has a separator on its trailing edge.
+     * - At deeper depths, separator existence follows column-header-group identity
+     *   (see {@link isSameColumnGroupAtDepth}). Distinct group instances that share a
+     *   display name (e.g. pivot Totals groups) are correctly treated as separate.
+     * - The true trailing edge of the table (the last column) always has a separator.
+     *
+     * The next model column is resolved from `visibleIndex + 1` so that an off-screen
+     * neighbor is handled correctly and is not mistaken for the table's trailing edge.
+     *
+     * @param model The grid model
+     * @param depth The header depth to check at
+     * @param visibleIndex The visible index of the current column
+     * @param columnCount The total number of columns in the model
+     * @param movedColumns The current column-move operations
+     * @returns true if a separator should be shown, false otherwise
+     */
+    static hasColumnSeparatorAtDepth(model: GridModel, depth: number | undefined, visibleIndex: VisibleIndex | undefined, columnCount: number, movedColumns: readonly MoveOperation[]): boolean;
+    /**
+     * Gets the column index if the x/y coordinates provided are close enough to the separator, otherwise null
+     * @param x Mouse x coordinate
+     * @param y Mouse y coordinate
+     * @param metrics The grid metrics
+     * @param theme The grid theme with potential user overrides
+     * @param model The grid model
+     * @returns Index of the column separator at the coordinates provided, or null if none match
+     */
+    static getColumnSeparatorIndex(x: Coordinate, y: Coordinate, metrics: GridMetrics, theme: GridTheme, model: GridModel): VisibleIndex | null;
+    /**
+     * Check if the item specified is hidden
+     * @param itemIndex Index of the item to check
+     * @param visibleSizes Sizes of all visible items
+     * @returns True if the item is hidden, false otherwise
+     */
+    static isItemHidden(itemIndex: VisibleIndex, visibleSizes: SizeMap): boolean;
+    /**
+     * Check if the column specified is hidden
+     * @param columnIndex Index of the column to check
+     * @param metrics Grid metrics
+     * @returns True if the column is hidden, false otherwise
+     */
+    static isColumnHidden(columnIndex: VisibleIndex, metrics: GridMetrics): boolean;
+    /**
+     * Check if the provided row is a floating row
+     * @param row The row index to check
+     * @param metrics The grid metrics to check against
+     * @returns True if it's a floating row, false otherwise
+     */
+    static isFloatingRow(row: VisibleIndex, metrics: GridMetrics): boolean;
+    /**
+     * Check if the provided column is a floating column
+     * @param column The column index to check
+     * @param metrics The grid metrics to check against
+     * @returns True if it's a floating column, false otherwise
+     */
+    static isFloatingColumn(column: VisibleIndex, metrics: GridMetrics): boolean;
+    /**
+     * Get all the items that are hidden under the same Index
+     * E.g. If columns are 1, 2, 3, 4, 5, and column 2, 3, 4 are hidden, and we check for item 4, the return will be [2, 3, 4]
+     * @param itemIndex Index of the item to start at
+     * @param visibleSizes Visible size map
+     * @param visibleItems Visible items
+     * @returns Array of items that are hidden
+     */
+    static getHiddenItems(itemIndex: VisibleIndex, visibleSizes: SizeMap, visibleItems: readonly VisibleIndex[]): VisibleIndex[];
+    /**
+     * Get all the columns that are hidden under the same Index
+     * @param columnIndex Index of the item to start at
+     * @param metrics Grid metrics
+     * @returns Array of items that are hidden
+     */
+    static getHiddenColumns(columnIndex: VisibleIndex, metrics: GridMetrics): VisibleIndex[];
+    /**
+     * Returns the row index if the x/y coordinates provided are close enough to the separator, otherwise null
+     * @param x X coordinate to check
+     * @param y Y coordinate to check
+     * @param metrics The grid metrics
+     * @param theme The grid theme
+     * @returns Index of the row separator at the coordinates provided, or null if none match
+     */
+    static getRowSeparatorIndex(x: Coordinate, y: Coordinate, metrics: GridMetrics, theme: GridTheme): VisibleIndex | null;
+    /**
+     * Check if the row specified is hidden
+     * @param rowIndex Index of the row to check
+     * @param metrics Grid metrics
+     * @returns True if the row is hidden, false otherwise
+     */
+    static isRowHidden(rowIndex: VisibleIndex, metrics: GridMetrics): boolean;
+    /**
+     * Get all the rows that are hidden under the same Index
+     * @param rowIndex Index of the item to start at
+     * @param metrics Grid metrics
+     * @returns Array of items that are hidden
+     */
+    static getHiddenRows(rowIndex: VisibleIndex, metrics: GridMetrics): VisibleIndex[];
+    /**
+     * Set a new order for items in the grid
+     * @param from The visible index to move from
+     * @param to The visible index to move the item to
+     * @param oldMovedItems The old reordered items
+     * @returns The new reordered items. The original array if the operation is a no-op.
+     */
+    static moveItem(from: VisibleIndex, to: VisibleIndex, oldMovedItems: MoveOperation[]): MoveOperation[];
+    static moveItem(from: VisibleIndex, to: VisibleIndex, oldMovedItems: readonly MoveOperation[]): readonly MoveOperation[];
+    /**
+     * Move a visible range in the grid
+     *
+     * This will effectively slice the range out of the grid,
+     * re-index the remaining columns,
+     * then insert the range with the first element at the provided index
+     *
+     * @param from The visible axis range to move
+     * @param to The visible index to move the start of the range to
+     * @param oldMovedItems The old reordered items
+     * @param isPreMoveTo If toParam is the index before the movement
+     *                    If true, this will account for the shift when moving
+     *                    a range before the drop positin
+     *                    E.g. Move range [0, 2] 1 item down (after element 3)
+     *                    The move is [0, 2] -> 1 if this is false. [0, 2] -> 3 if this is true
+     *                    Both will result in [0, 2] -> 1
+     * @returns The new reordered items. The original array if the operation is a no-op.
+     */
+    static moveRange(from: BoundedAxisRange, to: VisibleIndex, oldMovedItems: MoveOperation[], isPreMoveTo?: boolean): MoveOperation[];
+    static moveRange(from: BoundedAxisRange, toParam: VisibleIndex, oldMovedItems: readonly MoveOperation[], isPreMoveTo?: boolean): readonly MoveOperation[];
+    static moveItemOrRange(from: VisibleIndex | BoundedAxisRange, to: VisibleIndex, oldMovedItems: MoveOperation[], isPreMoveTo?: boolean): MoveOperation[];
+    static moveItemOrRange(from: VisibleIndex | BoundedAxisRange, to: VisibleIndex, oldMovedItems: readonly MoveOperation[], isPreMoveTo?: boolean): readonly MoveOperation[];
+    /**
+     * Applies the items moves to the AxisRange
+     * @param start The start index of the range
+     * @param end The end index of the range
+     * @param movedItems The move operations to apply
+     * @param reverse If the moved items should be applied in reverse (this reverses the effects of the moves)
+     * @returns A list of AxisRanges in the translated space. Possibly multiple non-continuous ranges
+     */
+    static applyItemMoves<T extends number | GridRangeIndex>(start: T, end: T, movedItems: readonly MoveOperation[], reverse?: boolean): Range<T>[];
+    /**
+     * Applies the items moves to the givengrid range
+     * @param range The grid range to translate
+     * @param movedColumns The moved columns
+     * @param movedRows The moved rows
+     * @param reverse If the moved items should be reversed (i.e. visible to model range)
+     * @returns A list of grid ranges in the translated space. Possibly multiple non-continuous ranges
+     */
+    static translateRange(range: GridRange, movedColumns: readonly MoveOperation[], movedRows: readonly MoveOperation[], reverse: boolean): GridRange[];
+    /**
+     * Retrieve the model index given the currently moved items
+     * @param visibleIndex The visible index of the item to get the model index for
+     * @param movedItems The moved items
+     * @returns The model index of the item
+     */
+    static getModelIndex(visibleIndex: VisibleIndex, movedItems: readonly MoveOperation[]): ModelIndex;
+    /**
+     * Retrieve the model indexes given the currently moved items
+     * @param visibleIndexes The visible indexes of the item to get the model indexes for
+     * @param movedItems The moved items
+     * @returns The model indexes of the item
+     */
+    static getModelIndexes(visibleIndexes: ModelIndex[], movedItems: MoveOperation[]): VisibleIndex[];
+    /**
+     * Translate the provided UI start/end indexes to the model start/end indexes by applying the `movedItems` transformations.
+     * Since moved items can split apart a range, multiple pairs of indexes are returned
+     *
+     * @param start Start item in one dimension
+     * @param end End item in one dimension
+     * @param movedItems Moved item pairs in this dimension
+     * @returns Array of start/end pairs of the indexes after transformations applied.
+     */
+    static getModelRangeIndexes(start: GridRangeIndex, end: GridRangeIndex, movedItems: readonly MoveOperation[]): AxisRange[];
+    /**
+     * Translate the provided UI range into model range, using the `movedColumns` and `movedRows` to apply the necessary transforms.
+     * `movedColumns` and `movedRows` are array of operations done to the UI indexes to re-order items
+     *
+     * @param uiRange The currently selected UI ranges
+     * @param movedColumns The moved column pairs
+     * @param movedRows The moved row pairs
+     * @returns The model ranges after translation.
+     */
+    static getModelRange(uiRange: GridRange, movedColumns?: readonly MoveOperation[], movedRows?: readonly MoveOperation[]): GridRange[];
+    /**
+     * Translate the provided UI range into model ranges, using the `movedColumns` and `movedRows` to apply the necessary transforms.
+     * `movedColumns` and `movedRows` are array of operations done to the UI indexes to re-order items
+     *
+     * @param uiRanges The currently selected UI ranges
+     * @param movedColumns The moved column pairs
+     * @param movedRows The moved row pairs
+     * @returns The model ranges after translation.
+     */
+    static getModelRanges(uiRanges: readonly GridRange[], movedColumns?: readonly MoveOperation[], movedRows?: readonly MoveOperation[]): GridRange[];
+    /**
+     * Translate the provided UI start/end indexes to the visible start/end indexes by applying the `movedItems` transformations.
+     * Since moved items can split apart a range, multiple pairs of indexes are returned
+     *
+     * @param start Start item in one dimension
+     * @param end End item in one dimension
+     * @param movedItems Moved item pairs in this dimension
+     * @returns Array of start/end pairs of the indexes after transformations applied.
+     */
+    static getVisibleRangeIndexes(start: GridRangeIndex, end: GridRangeIndex, movedItems: readonly MoveOperation[]): AxisRange[];
+    /**
+     * Translate the provided UI range into visible range, using the `movedColumns` and `movedRows` to apply the necessary transforms.
+     * `movedColumns` and `movedRows` are array of operations done to the UI indexes to re-order items
+     *
+     * @param uiRange The currently selected UI ranges
+     * @param movedColumns The moved column pairs
+     * @param movedRows The moved row pairs
+     * @returns The model ranges after translation.
+     */
+    static getVisibleRange(modelRange: GridRange, movedColumns?: readonly MoveOperation[], movedRows?: readonly MoveOperation[]): GridRange[];
+    /**
+     * Translate the provided model ranges into visible ranges, using the `movedColumns` and `movedRows` to apply the necessary transforms.
+     * `movedColumns` and `movedRows` are array of operations done to the UI indexes to re-order items
+     *
+     * @param modelRanges The model ranges
+     * @param movedColumns The moved column pairs
+     * @param movedRows The moved row pairs
+     * @returns The model ranges after translation.
+     */
+    static getVisibleRanges(modelRanges: readonly GridRange[], movedColumns?: readonly MoveOperation[], movedRows?: readonly MoveOperation[]): GridRange[];
+    /**
+     * Retrieve the visible index given the currently moved items
+     * @param modelIndex The model index to get the visible index for
+     * @param movedItems Moved items
+     * @returns The visible index of the item
+     */
+    static getVisibleIndex(modelIndex: ModelIndex, movedItems: readonly MoveOperation[]): VisibleIndex;
+    /**
+     * Retrieve the visible indexes given the currently moved items
+     * @param modelIndexes The model indexes to get the visible indexes for
+     * @param movedItems Moved items
+     * @returns The visible indexes of the item
+     */
+    static getVisibleIndexes(modelIndexes: readonly ModelIndex[], movedItems: readonly MoveOperation[]): VisibleIndex[];
+    /**
+     * Check if the current platform is Mac
+     * @returns True if this platform is a Mac, false otherwise
+     */
+    static isMacPlatform(): boolean;
+    /**
+     * Get the modifier key for the current platform
+     * @returns The modifier key for the current platform
+     */
+    static getModifierKey(): 'metaKey' | 'ctrlKey';
+    /**
+     * Check if the modifier key is down for the given event
+     * @param event The event to check
+     * @returns True if the modifier key is down, false otherwise
+     */
+    static isModifierKeyDown(event: MouseEvent | KeyboardEvent | React.KeyboardEvent | React.MouseEvent): boolean;
+    /**
+     * Check if the user has hidden the specified column
+     * @param modelIndex The model index to check
+     * @param userColumnWidths The user set column widths
+     * @returns True if the user has hidden the column
+     */
+    static checkColumnHidden(modelIndex: ModelIndex, userColumnWidths: ModelSizeMap): boolean;
+    /**
+     * Check if all the columns specified are hidden
+     * @param columns Columns to check
+     * @param userColumnWidths The user set column widths
+     * @returns True if the user has hidden all of the columns
+     */
+    static checkAllColumnsHidden(columns: readonly ModelIndex[], userColumnWidths: ModelSizeMap): boolean;
+    /**
+     * Get the bounds the mouse needs to be dragged outside of from an initial selection before scrolling occurs.
+     * Taking into account any floating rows that may be covering the viewport.
+     * @param metrics Grid metrics
+     * @param row The row they started dragging in
+     * @param column The column they started the drag from
+     * @returns Dimensions of the drag area in relation to the canvas they need to drag outside of to start scrolling
+     */
+    static getScrollDragBounds(metrics: GridMetrics, row: GridRangeIndex, column: GridRangeIndex): BoxCoordinates;
+    /**
+     * Converts the delta coordinates from the provided wheel event to pixels
+     * Different platforms have different ways of providing the delta so this normalizes it
+     * @param wheelEvent The mouse wheel event to get the scrolling delta for
+     * @param pageWidth The width of the page that is scrolling
+     * @param pageHeight The height of the page that is scrolling
+     * @param lineWidth The width of the line scrolling in line mode
+     * @param lineHeight The height of the line scrolling in line mode
+     * @returns The delta coordinates normalized to pixels
+     */
+    static getScrollDelta(wheelEvent: GridWheelEvent, pageWidth?: number, pageHeight?: number, lineWidth?: number, lineHeight?: number): {
+        deltaX: number;
+        deltaY: number;
+    };
+    static compareRanges(range1: AxisRange, range2: AxisRange): number;
+    static mergeSortedRanges(ranges: BoundedAxisRange[]): BoundedAxisRange[];
+    /**
+     * Gets textWidth and X-Y position for a specific cell
+     * The textWidth returned is the width that the text can occupy accounting for cell padding
+     *
+     * @param state GridRenderState to get the text metrics for
+     * @param column Column of cell to get text metrics for
+     * @param row Row of cell to get text metrics for
+     * @returns Object with width, x, and y of the text
+     */
+    static getTextRenderMetrics(state: GridRenderState, column: VisibleIndex, row: VisibleIndex): {
+        width: number;
+        x: number;
+        y: number;
+    };
+}
+export default GridUtils;

package/dist/KeyHandler.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Handle keys in a grid
+ * Return true from any of the events to indicate they're consumed, and stopPropagation/preventDefault will be called.
+ */
+import type React from 'react';
+import { type EventHandlerResult } from './EventHandlerResult';
+import type Grid from './Grid';
+/**
+ * Some events we listen to are a native keyboard event, and others are wrapped with React's SyntheticEvent.
+ * The KeyHandler shouldn't care though - the properties it accesses should be common on both types of events.
+ */
+export type GridKeyboardEvent = KeyboardEvent | React.KeyboardEvent;
+export type GridKeyHandlerFunctionName = 'onDown' | 'onUp';
+export declare class KeyHandler {
+    order: number;
+    constructor(order?: number);
+    cursor: string | null;
+    /**
+     * Handle a keydown event on the grid.
+     * @param event The keyboard event
+     * @param grid The grid component the key press is on
+     * @returns Response indicating if the key was consumed
+     */
+    onDown(event: GridKeyboardEvent, grid: Grid): EventHandlerResult;
+    /**
+     * Handle a keyup event on the grid.
+     * @param event The keyboard event
+     * @param grid The grid component the key press is on
+     * @returns Response indicating if the key was consumed
+     */
+    onUp(event: GridKeyboardEvent, grid: Grid): EventHandlerResult;
+}
+export default KeyHandler;