@deephaven/grid 0.6.3-beta.9 → 0.6.3

package/dist/GridMetricCalculator.d.ts

@@ -1,48 +1,4 @@
-import GridModel from './GridModel';
-import GridMetrics, { BoxCoordinates, Coordinate, CoordinateMap, VisibleIndex, IndexModelMap, ModelIndex, ModelSizeMap, MoveOperation, SizeMap } from './GridMetrics';
-import { GridFont, GridTheme } from './GridTheme';
-export declare type GridMetricState = {
-    left: VisibleIndex;
-    top: VisibleIndex;
-    leftOffset: Coordinate;
-    topOffset: Coordinate;
-    width: number;
-    height: number;
-    context: CanvasRenderingContext2D;
-    theme: GridTheme;
-    model: GridModel;
-    movedColumns: MoveOperation[];
-    movedRows: MoveOperation[];
-    isDraggingHorizontalScrollBar: boolean;
-    isDraggingVerticalScrollBar: boolean;
-};
-/**
- * Retrieve a value from a map. If the value is not found and no default value is provided, throw.
- * Use when the value _must_ be present
- * @param map The map to get the value from
- * @param key The key to fetch the value for
- * @param defaultValue A default value to set if the key is not present
- * @returns The value set for that key
- */
-export declare function getOrThrow<K, V>(map: Map<K, V>, key: K, defaultValue?: V | undefined): V;
-/**
- * Trim the provided map in place. Trims oldest inserted items down to the target size if the cache size is exceeded.
- * Instead of trimming one item on every tick, we trim half the items so there isn't a cache clear on every new item.
- * @param map The map to trim
- * @param cacheSize The maximum number of elements to cache
- * @param targetSize The number of elements to reduce the cache down to if `cacheSize` is exceeded
- */
-export declare function trimMap(map: Map<unknown, unknown>, cacheSize?: number, targetSize?: number): void;
-/**
- * Get the coordinates of floating items in one dimension.
- * Can be used for getting the y coordinates of floating rows, or x coordinates of floating columns, calculated using the `sizeMap` passed in.
- * @param startCount The number of floating items at the start (ie. `floatingTopRowCount` for rows, `floatingLeftColumnCount` for columns)
- * @param endCount The number of floating items at the end (ie. `floatingBottomRowCount` for rows, `floatingRightColumnCount` for columns)
- * @param totalCount Total number of items in this dimension (ie. `rowCount` for rows, `columnCount` for columns)
- * @param max The max coordinate value (ie. `maxY` for rows, `maxX` for columns)
- * @param sizeMap Map from index to size of item (ie. `rowHeightMap` for rows, `columnWidthMap` for columns)
- */
-export declare function getFloatingCoordinates(startCount: number, endCount: number, totalCount: number, max: number, sizeMap: SizeMap): CoordinateMap;
+export default GridMetricCalculator;
 /**
  * Class to calculate all the metrics for drawing a grid.
  * Call getMetrics() with the state to get the full metrics.
@@ -53,429 +9,190 @@ declare class GridMetricCalculator {
     static CACHE_SIZE: number;
     /** The maximum column width as a percentage of the full grid */
     static MAX_COLUMN_WIDTH: number;
-    /** User set column widths */
-    private userColumnWidths;
-    /** User set row heights */
-    private userRowHeights;
-    /** Calculated column widths based on cell contents */
-    private calculatedColumnWidths;
-    /** Calculated row heights based on cell contents */
-    private calculatedRowHeights;
-    /** Cache of fonts to estimated width of one char */
-    private fontWidths;
-    /** Map from visible index to model index for rows (e.g. reversing movedRows operations) */
-    private modelRows;
-    /** Map from visible index to model index for columns (e.g. reversing movedColumns operations) */
-    private modelColumns;
-    /** List of moved row operations. Need to track the previous value so we know if modelRows needs to be cleared. */
-    private movedRows;
-    /** List of moved column operations. Need to track the previous value so we know if modelColumns needs to be cleared. */
-    private movedColumns;
-    constructor({ userColumnWidths, userRowHeights, calculatedColumnWidths, calculatedRowHeights, fontWidths, modelRows, modelColumns, movedRows, movedColumns, }?: {
+    /**
+     * Trim the provided map in place. Trims oldest inserted items down to the target size if the cache size is exceeded.
+     * Instead of trimming one item on every tick, we trim half the items so there isn't a cache clear on every new item.
+     * @param {Map} map The map to trim
+     * @param {number} cacheSize The maximum number of elements to cache
+     * @param {number} targetSize The number of elements to reduce the cache down to if `cacheSize` is exceeded
+     */
+    static trimMap(map: Map<any, any>, cacheSize?: number, targetSize?: number): void;
+    /**
+     * Get the coordinates of floating items in one dimension.
+     * Can be used for getting the y coordinates of floating rows, or x coordinates of floating columns, calculated using the `sizeMap` passed in.
+     * @param {number} startCount The number of floating items at the start (ie. `floatingTopRowCount` for rows, `floatingLeftColumnCount` for columns)
+     * @param {number} endCount The number of floating items at the end (ie. `floatingBottomRowCount` for rows, `floatingRightColumnCount` for columns)
+     * @param {number} totalCount Total number of items in this dimension (ie. `rowCount` for rows, `columnCount` for columns)
+     * @param {number} max The max coordinate value (ie. `maxY` for rows, `maxX` for columns)
+     * @param {Map<number, number>} sizeMap Map from index to size of item (ie. `rowHeightMap` for rows, `columnWidthMap` for columns)
+     */
+    static getFloatingCoordinates(startCount: number, endCount: number, totalCount: number, max: number, sizeMap: Map<number, number>): Map<any, any>;
+    constructor({ userColumnWidths, userRowHeights, calculatedRowHeights, calculatedColumnWidths, fontWidths, modelRows, modelColumns, movedRows, movedColumns, }?: {
         userColumnWidths?: Map<any, any> | undefined;
         userRowHeights?: Map<any, any> | undefined;
-        calculatedColumnWidths?: Map<any, any> | undefined;
         calculatedRowHeights?: Map<any, any> | undefined;
+        calculatedColumnWidths?: Map<any, any> | undefined;
         fontWidths?: Map<any, any> | undefined;
         modelRows?: Map<any, any> | undefined;
         modelColumns?: Map<any, any> | undefined;
-        movedRows?: never[] | undefined;
-        movedColumns?: never[] | undefined;
+        movedRows?: any;
+        movedColumns?: any;
     });
-    /**
-     * Get the metrics for the provided metric state
-     * @params state The state to get metrics for
-     * @returns The full metrics
-     */
-    getMetrics(state: GridMetricState): GridMetrics;
-    /**
-     * The x offset of the grid
-     * @param state The current grid state
-     * @returns x value of the left side of the first cell
-     */
-    getGridX(state: GridMetricState): Coordinate;
-    /**
-     * The y offset of the grid
-     * @param state The current grid state
-     * @returns y value of the top side of the first cell
-     */
-    getGridY(state: GridMetricState): Coordinate;
-    /**
-     * The height of the "visible" area (excludes floating areas)
-     * @param state The current grid state
-     * @param visibleRowHeights All the visible row heights
-     * @returns The visible height in pixels
-     */
-    getVisibleHeight(state: GridMetricState, visibleRowHeights?: SizeMap): number;
-    /**
-     * The width of the "visible" area (excludes floating areas)
-     * @param state The current grid state
-     * @param visibleColumnWidths All the visible column widths
-     * @returns The visible width in pixels
-     */
-    getVisibleWidth(state: GridMetricState, visibleColumnWidths?: SizeMap): number;
-    /**
-     * Retrieve the index of the first non-hidden item
-     * @param itemSizes The size of the items in this dimension
-     * @param getModelIndex A function to map from the Index to the ModelIndex
-     * @param state The current grid state
-     * @returns The first item that is not hidden
-     */
-    getFirstIndex(itemSizes: ModelSizeMap, getModelIndex: (visibleIndex: VisibleIndex, state: GridMetricState) => ModelIndex, state: GridMetricState): VisibleIndex;
-    /**
-     * Get the first column index that isn't hidden
-     * @param state The current grid state
-     * @returns The first column that is not hidden
-     */
-    getFirstColumn(state: GridMetricState): VisibleIndex;
-    /**
-     * Get the first row index that isn't hidden
-     * @param state The current grid state
-     * @returns The first row that is not hidden
-     */
-    getFirstRow(state: GridMetricState): VisibleIndex;
-    /**
-     * Get the last column that can be the left most column (e.g. scrolled to the right)
+    userColumnWidths: Map<any, any>;
+    userRowHeights: Map<any, any>;
+    calculatedRowHeights: Map<any, any>;
+    calculatedColumnWidths: Map<any, any>;
+    fontWidths: Map<any, any>;
+    modelRows: Map<any, any>;
+    modelColumns: Map<any, any>;
+    movedRows: any;
+    movedColumns: any;
+    /** update the calculated metrics from the model/canvas that are useful for many functions */
+    getMetrics(state: any): {
+        rowHeight: any;
+        rowHeaderWidth: any;
+        rowFooterWidth: any;
+        rowCount: any;
+        columnWidth: any;
+        columnCount: any;
+        columnHeaderHeight: any;
+        floatingTopRowCount: any;
+        floatingBottomRowCount: any;
+        floatingLeftColumnCount: any;
+        floatingRightColumnCount: any;
+        gridX: any;
+        gridY: any;
+        firstRow: number;
+        firstColumn: number;
+        treePaddingX: number;
+        treePaddingY: number;
+        left: any;
+        top: any;
+        bottom: any;
+        right: any;
+        topOffset: any;
+        leftOffset: any;
+        topVisible: any;
+        leftVisible: any;
+        bottomVisible: any;
+        rightVisible: any;
+        bottomViewport: number;
+        rightViewport: number;
+        width: any;
+        height: any;
+        maxX: number;
+        maxY: number;
+        lastLeft: number;
+        lastTop: number;
+        barHeight: number;
+        barWidth: number;
+        handleHeight: number;
+        handleWidth: number;
+        hasHorizontalBar: boolean;
+        hasVerticalBar: boolean;
+        verticalBarWidth: any;
+        horizontalBarHeight: any;
+        scrollX: number;
+        scrollY: number;
+        visibleRows: any[];
+        visibleColumns: any[];
+        floatingRows: any[];
+        floatingColumns: any[];
+        allRows: any[];
+        allColumns: any[];
+        visibleRowHeights: Map<any, any>;
+        visibleColumnWidths: Map<any, any>;
+        floatingTopHeight: number;
+        floatingBottomHeight: number;
+        floatingLeftWidth: number;
+        floatingRightWidth: number;
+        visibleRowYs: Map<any, any>;
+        visibleColumnXs: Map<any, any>;
+        visibleRowTreeBoxes: Map<any, any>;
+        modelRows: Map<any, any>;
+        modelColumns: Map<any, any>;
+        fontWidths: Map<any, any>;
+        userColumnWidths: Map<any, any>;
+        userRowHeights: Map<any, any>;
+        calculatedRowHeights: Map<any, any>;
+        calculatedColumnWidths: Map<any, any>;
+    };
+    getGridX(state: any): any;
+    getGridY(state: any): any;
+    getVisibleHeight(state: any, visibleRowHeights?: Map<any, any>): number;
+    getVisibleWidth(state: any, visibleColumnWidths?: Map<any, any>): number;
+    getFirstIndex(itemSizes: any, getModelIndex: any, state: any): number;
+    /** Get the first column index that isn't hidden */
+    getFirstColumn(state: any): number;
+    /** Get the first row index that isn't hidden */
+    getFirstRow(state: any): number;
+    /**
+     * Get the last column that can be the left most column (eg. scrolled to the right)
      * If no right column is provided, then the last column is used.
-     * @param state The current grid state
-     * @param right The right-most column to be visible, or null to default to last cell
-     * @param visibleWidth The width of the "visible" area (excluding floating items)
-     * @returns The index of the last left visible column
      */
-    getLastLeft(state: GridMetricState, right?: VisibleIndex | null, visibleWidth?: number): VisibleIndex;
+    getLastLeft(state: any, right?: any, visibleWidth?: number): number;
     /**
-     * The last row that can be the top row (e.g. scrolled to the bottom)
+     * The last row that can be the top row (eg. scrolled to the bottom)
      * If no bottom row is provided, then the last row that is not floating is used
      */
-    /**
-     * The last row that can be the top row (e.g. scrolled to the bottom)
-     * If no bottom row is provided, then the last row that is not floating is used
-     * @param state The current grid state
-     * @param bottom The bottom-most row to be visible, or null to default to last cell
-     * @param visibleHeight The height of the "visible" area (excluding floating items)
-     * @returns The index of the last left visible column
-     */
-    getLastTop(state: GridMetricState, bottom?: VisibleIndex | null, visibleHeight?: number): VisibleIndex;
-    /**
-     * Retrieve the top row to scroll to so the passed in `topVisible` is completely visible, taking the floating rows into account.
-     * The `top` row is at the top underneath any floating rows, whereas `topVisible` is visible below the floating rows.
-     * If there are no floating rows, they should be the same value.
-     * @param state The grid metric state
-     * @param topVisible The top row to be visible
-     * @returns The index of the top row to scroll to (under the floating top rows)
-     */
-    getTopForTopVisible(state: GridMetricState, topVisible: VisibleIndex): VisibleIndex;
-    /**
-     * Retrieve the top row to scroll to so the passed in `bottomVisible` is completely visible
-     * at the bottom of the visible viewport, taking the floating rows into account.
-     * @param state The grid metric state
-     * @param bottomVisible The bottom row to be visible
-     * @returns The index of the top row to scroll to (under the floating top rows)
-     */
-    getTopForBottomVisible(state: GridMetricState, bottomVisible: VisibleIndex): VisibleIndex;
-    /**
-     * Retrieve the left column to scroll to so the passed in `leftVisible` is completely visible
-     * at the left of the visible viewport, taking the floating columns into account.
-     * @param state The grid metric state
-     * @param leftVisible The left column to be visible
-     * @returns The index of the left column to scroll to (under the floating left columns)
-     */
-    getLeftForLeftVisible(state: GridMetricState, leftVisible: VisibleIndex): VisibleIndex;
-    /**
-     * Retrieve the left column to scroll to so the passed in `rightVisible` is completely visible
-     * at the right of the visible viewport, taking the floating columns into account.
-     * @param state The grid metric state
-     * @param rightVisible The right column to be visible
-     * @returns The index of the left column to scroll to (under the floating left columns)
-     */
-    getLeftForRightVisible(state: GridMetricState, rightVisible: VisibleIndex): VisibleIndex;
-    /**
-     * Retrieve a map of the height of each floating row
-     * @param state The grid metric state
-     * @returns The heights of all the floating rows
-     */
-    getFloatingRowHeights(state: GridMetricState): SizeMap;
-    /**
-     * Retrieve a map of the height of all the visible rows (non-floating)
-     * @param state The grid metric state
-     * @returns The heights of all the visible rows
-     */
-    getVisibleRowHeights(state: GridMetricState): SizeMap;
-    /**
-     * Retrieve a map of the width of each floating column
-     * @param state The grid metric state
-     * @param firstColumn The first non-hidden column
-     * @param treePaddingX The amount of padding taken up for the tree expansion buttons
-     * @returns The widths of all the floating columns
-     */
-    getFloatingColumnWidths(state: GridMetricState, firstColumn?: VisibleIndex, treePaddingX?: number): SizeMap;
-    /**
-     * Retrieve a map of the width of all the visible columns (non-floating)
-     * @param state The grid metric state
-     * @returns The widths of all the visible columns
-     */
-    getVisibleColumnWidths(state: GridMetricState, firstColumn?: VisibleIndex, treePaddingX?: number): SizeMap;
-    /**
-     * Retrieve a map of all the floating columns to their x coordinate
-     * @param state The grid metric state
-     * @param columnWidthMap Map from visible index to column width
-     * @param maxX The maximum X size for the grid
-     * @returns Map of the x coordinate of all floating columns
-     */
-    getFloatingColumnXs(state: GridMetricState, columnWidthMap: SizeMap, maxX: Coordinate): CoordinateMap;
-    /**
-     * Retrieve a map of all the visible columns to their x coordinate.
-     * Starts at leftOffset with the first index in `visibleColumns`, then
-     * calculates all the coordinates from there
-     * @param visibleColumnWidths Map of visible column index to widths
-     * @param visibleColumns All visible columns
-     * @param leftOffset The left scroll offset
-     * @returns Map of the x coordinate of all visible columns
-     */
-    getVisibleColumnXs(visibleColumnWidths: SizeMap, visibleColumns: VisibleIndex[], leftOffset: number): CoordinateMap;
-    /**
-     * Retrieve a map of all the floating rows to their y coordinate
-     * @param state The grid metric state
-     * @param rowHeightMap Map of visible index to row height
-     * @param maxY The maximum Y size for the grid
-     * @returns Map of the y coordinate of all floating rows
-     */
-    getFloatingRowYs(state: GridMetricState, rowHeightMap: SizeMap, maxY: Coordinate): CoordinateMap;
-    /**
-     * Retrieve a map of all the visible rows to their y coordinate.
-     * Starts at topOffset with the first index in `visibleRows`, then
-     * calculates all the coordinates from there
-     * @param visibleRowHeights Map of visible row index to heights
-     * @param visibleRows All visible rows
-     * @param topOffset The top scroll offset
-     * @returns Map of the y coordinate of all visible rows
-     */
-    getVisibleRowYs(visibleRowHeights: SizeMap, visibleRows: VisibleIndex[], topOffset: number): CoordinateMap;
-    /**
-     * Calculates the tree box click areas that are visible. In relation to the columnX/rowY
-     * @param visibleRowHeights Map of visible index to row height
-     * @param modelRows Map from visible `Index` to `ModelIndex`
-     * @param state The grid metric state
-     * @returns Coordinates of tree boxes for each row
-     */
-    getVisibleRowTreeBoxes(visibleRowHeights: SizeMap, modelRows: IndexModelMap, state: GridMetricState): Map<VisibleIndex, BoxCoordinates>;
-    /**
-     * Get the total width of the floating columns on the left
-     * @param state The grid metric state
-     * @param columnWidths Map of column index to width
-     * @returns The total width of the floating left section
-     */
-    getFloatingLeftWidth(state: GridMetricState, columnWidths?: SizeMap): number;
-    /**
-     * Get the total width of the floating columns on the right
-     * @param state The grid metric state
-     * @param columnWidths Map of column index to width
-     * @returns The total width of the floating right section
-     */
-    getFloatingRightWidth(state: GridMetricState, columnWidths?: SizeMap): number;
-    /**
-     * Get the total height of the floating rows on the top
-     * @param state The grid metric state
-     * @param rowHeights Map of row index to height
-     * @returns The total height of the floating top section
-     */
-    getFloatingTopHeight(state: GridMetricState, rowHeights?: SizeMap): number;
-    /**
-     * Get the total height of the floating rows on the bottom
-     * @param state The grid metric state
-     * @param rowHeights Map of row index to height
-     * @returns The total height of the floating bottom section
-     */
-    getFloatingBottomHeight(state: GridMetricState, rowHeights?: SizeMap): number;
-    /**
-     * Retrieve the index of the first fully visible row in the "visible" viewport of the grid.
-     * E.g. First row visible after the floating rows, provided the visible rows.
-     * @param state The grid metric state
-     * @param visibleRowYs Map of row index to y coordinate
-     * @param visibleRowHeights Map of row index to height
-     * @param visibleRows Array of visible row indexes
-     * @returns Index of the top visible row
-     */
-    getTopVisible(state: GridMetricState, visibleRowYs: CoordinateMap, visibleRowHeights: SizeMap, visibleRows: VisibleIndex[]): VisibleIndex;
-    /**
-     * Retrieve the index of the first fully visible column in the "visible" viewport of the grid.
-     * E.g. First column visible after the floating columns, provided the visible columns.
-     * @param state The grid metric state
-     * @param visibleColumnXs Map of column index to x coordinate
-     * @param visibleColumnWidths Map of column index to widths
-     * @param visibleColumns Array of visible row indexes
-     * @returns Index of the left visible column
-     */
-    getLeftVisible(state: GridMetricState, visibleColumnXs: CoordinateMap, visibleColumnWidths: SizeMap, visibleColumns: VisibleIndex[]): VisibleIndex;
-    /**
-     * Retrieve the index of the last fully visible row in the "visible" viewport of the grid.
-     * E.g. Last row visible before the bottom floating rows, provided the visible rows.
-     * @param state The grid metric state
-     * @param visibleRowYs Map of row index to y coordinate
-     * @param visibleRowHeights Map of row index to height
-     * @param visibleRows Array of visible row indexes
-     * @param gridY The starting y coordinate of the grid
-     * @returns Index of the bottom visible row
-     */
-    getBottomVisible(state: GridMetricState, visibleRowYs: CoordinateMap, visibleRowHeights: SizeMap, visibleRows: VisibleIndex[], gridY: Coordinate): VisibleIndex;
-    /**
-     * Retrieve the index of the last fully visible column in the "visible" viewport of the grid.
-     * E.g. Last column visible before the floating columns, provided the visible columns.
-     * @param state The grid metric state
-     * @param visibleColumnXs Map of column index to x coordinate
-     * @param visibleColumnWidths Map of column index to widths
-     * @param visibleColumns Array of visible column indexes
-     * @returns Index of the right visible column
-     */
-    getRightVisible(state: GridMetricState, visibleColumnXs: CoordinateMap, visibleColumnWidths: SizeMap, visibleColumns: VisibleIndex[], gridX: Coordinate): VisibleIndex;
-    /**
-     * Retrieve the possible bottom of the visible viewport (not limited by data size)
-     * @param state The grid metric state
-     * @param visibleRows Array of visible row indexes
-     * @param visibleRowYs Map of row index to y coordinate
-     * @param visibleRowHeights Map of row index to height
-     * @returns The index of the bottom viewport possible
-     */
-    getBottomViewport(state: GridMetricState, visibleRows: VisibleIndex[], visibleRowYs: CoordinateMap, visibleRowHeights: SizeMap): VisibleIndex;
-    /**
-     * Retrieve the possible right of the visible viewport (not limited by data size)
-     * @param state The grid metric state
-     * @param visibleColumns Array of visible column indexes
-     * @param visibleColumnXs Map of column index to x coordinate
-     * @param visibleColumnWidths Map of column index to width
-     * @returns The index of the right viewport possible
-     */
-    getRightViewport(state: GridMetricState, visibleColumns: VisibleIndex[], visibleColumnXs: CoordinateMap, visibleColumnWidths: SizeMap): VisibleIndex;
-    /**
-     * Get the Index of the of the last index visible
-     * @param items Array of visible item indexes
-     * @param itemXs Map of index to coordinate
-     * @param itemSizes Map of index to size
-     * @param maxSize Full size of the grid
-     * @param defaultItemSize Default size of an item
-     * @returns The Index of the last index visible
-     */
-    getLastIndexViewport(items: VisibleIndex[], itemXs: CoordinateMap, itemSizes: SizeMap, maxSize: number, defaultItemSize: number): VisibleIndex;
-    /**
-     * Get the size from the provided size map of the specified item
-     * @param modelIndex The model index to get the size for
-     * @param userSizes The user set sizes
-     * @param calculateSize Method to calculate the size for this item
-     * @returns The size from the provided size map of the specified item
-     */
-    getVisibleItemSize(modelIndex: ModelIndex, userSizes: ModelSizeMap, calculateSize: () => number): number;
-    /**
-     * Get the height of the specified row
-     * @param row Index of the row to get the height of
-     * @param state The grid metric state
-     * @returns The height of the row specified
-     */
-    getVisibleRowHeight(row: VisibleIndex, state: GridMetricState): number;
-    /**
-     * Get the width of the specified column
-     * @param column Index of the column to get the width of
-     * @param state The grid metric state
-     * @param firstColumn Index of first visible column
-     * @param treePaddingX The amount of tree padding to add to the first visible column
-     * @returns The width of the column
-     */
-    getVisibleColumnWidth(column: VisibleIndex, state: GridMetricState, firstColumn?: VisibleIndex, treePaddingX?: number): number;
-    /**
-     * Get a map of ModelIndex to Index
-     * @param visibleRows Array of visible row indexes
-     * @param state The grid metric state
-     * @returns Map of Index to ModelIndex
-     */
-    getModelRows(visibleRows: VisibleIndex[], state: GridMetricState): IndexModelMap;
-    /**
-     * Get the ModelIndex of the specified row
-     * @param visibleRow Index of the row
-     * @param state The grid metric state
-     * @returns ModelIndex of the row
-     */
-    getModelRow(visibleRow: VisibleIndex, state: GridMetricState): ModelIndex;
-    /**
-     * Get a map of Index to ModelIndex. Applies the move operations to get the transformation.
-     * @param visibleColumns Array of visible column indexes
-     * @param state The grid metric state
-     * @returns Map of Index to ModelIndex
-     */
-    getModelColumns(visibleColumns: VisibleIndex[], state: GridMetricState): IndexModelMap;
-    /**
-     * Get the ModelIndex of the specified column
-     * @param visibleColumn Index of the column
-     * @param state The grid metric state
-     * @returns ModelIndex of the column
-     */
-    getModelColumn(visibleColumn: VisibleIndex, state: GridMetricState): ModelIndex;
-    /**
-     * Calculate the height of the row specified.
-     * @param row Index of the row to calculate the height for
-     * @param modelRow ModelIndex of the row to calculate the height
-     * @param state The grid metric state
-     * @returns The height of the row
-     */
-    calculateRowHeight(row: VisibleIndex, modelRow: ModelIndex, state: GridMetricState): number;
-    /**
-     * Calculates the column width based on the provided column model index
-     * @param column Index of the column to calculate the width for
-     * @param modelColumn ModelIndex of the column to calculate the width
-     * @param state The grid metric state
-     * @param firstColumn The first visible column
-     * @param treePaddingX Tree padding offset for expandable rows
-     * @returns The width of the column
-     */
-    calculateColumnWidth(column: VisibleIndex, modelColumn: ModelIndex, state: GridMetricState, firstColumn?: VisibleIndex, treePaddingX?: number): number;
-    /**
-     * Calculate the width of the specified column's header
-     * @param modelColumn ModelIndex of the column to get the header width for
-     * @param state The grid metric state
-     * @returns The calculated width of the column header
-     */
-    calculateColumnHeaderWidth(modelColumn: ModelIndex, state: GridMetricState): number;
-    /**
-     * Calculate the width of the specified column's data
-     * @param modelColumn ModelIndex of the column to get the data width for
-     * @param state The grid metric state
-     * @returns The calculated width of the column data
-     */
-    calculateColumnDataWidth(modelColumn: ModelIndex, state: GridMetricState): number;
-    /**
-     * The coordinate for where the tree padding should be drawn
-     * @param state The grid metric state
-     * @returns The coordinate for tree padding
-     */
-    calculateTreePaddingX(state: GridMetricState): Coordinate;
-    /**
-     * Get the width of the provided font. Exploits the fact that we're
-     * using tabular figures so every character is same width
-     * @param font The font to get the width for
-     * @param state The grid metric state
-     * @returns Width of the char `8` for the specified font
-     */
-    getWidthForFont(font: GridFont, state: GridMetricState): number;
+    getLastTop(state: any, bottom?: any, visibleHeight?: number): number;
+    getTopForTopVisible(state: any, topVisible: any): any;
+    getTopForBottomVisible(state: any, bottomVisible: any): number;
+    getLeftForLeftVisible(state: any, leftVisible: any): any;
+    getLeftForRightVisible(state: any, rightVisible: any): number;
+    getFloatingRowHeights(state: any): Map<any, any>;
+    getVisibleRowHeights(state: any): Map<any, any>;
+    getFloatingColumnWidths(state: any, firstColumn?: number, treePaddingX?: number): Map<any, any>;
+    getVisibleColumnWidths(state: any, firstColumn?: number, treePaddingX?: number): Map<any, any>;
+    getFloatingColumnXs(state: any, columnWidthMap: any, maxX: any): Map<any, any>;
+    getVisibleColumnXs(visibleColumnWidths: any, visibleColumns: any, leftOffset: any): Map<any, any>;
+    getFloatingRowYs(state: any, rowHeightMap: any, maxY: any): Map<any, any>;
+    getVisibleRowYs(visibleRowHeights: any, visibleRows: any, topOffset: any): Map<any, any>;
+    /** Calculates the tree box click areas that are visible. In relation to the columnX/rowY */
+    getVisibleRowTreeBoxes(visibleRowHeights: any, modelRows: any, state: any): Map<any, any>;
+    getFloatingLeftWidth(state: any, columnWidths?: Map<any, any>): number;
+    getFloatingRightWidth(state: any, columnWidths?: Map<any, any>): number;
+    getFloatingTopHeight(state: any, rowHeights?: Map<any, any>): number;
+    getFloatingBottomHeight(state: any, rowHeights?: Map<any, any>): number;
+    getTopVisible(state: any, visibleRowYs: any, visibleRowHeights: any, visibleRows: any): any;
+    getLeftVisible(state: any, visibleColumnXs: any, visibleColumnWidths: any, visibleColumns: any): any;
+    getBottomVisible(state: any, visibleRowYs: any, visibleRowHeights: any, visibleRows: any, gridY: any): any;
+    getRightVisible(state: any, visibleColumnXs: any, visibleColumnWidths: any, visibleColumns: any, gridX: any): any;
+    getBottomViewport(state: any, visibleRows: any, visibleRowYs: any, visibleRowHeights: any): number;
+    getRightViewport(state: any, visibleColumns: any, visibleColumnXs: any, visibleColumnWidths: any): number;
+    getLastIndexViewport(items: any, itemXs: any, itemSizes: any, maxSize: any, defaultItemSize: any): number;
+    getVisibleItemSize(modelIndex: any, userSizes: any, calculateSize: any): any;
+    getVisibleRowHeight(row: any, state: any): any;
+    getVisibleColumnWidth(column: any, state: any, firstColumn?: number, treePaddingX?: number): any;
+    getModelRows(visibleRows: any, state: any): Map<any, any>;
+    getModelRow(visibleRow: any, state: any): any;
+    getModelColumns(visibleColumns: any, state: any): Map<any, any>;
+    getModelColumn(visibleColumn: any, state: any): any;
+    calculateRowHeight(row: any, modelRow: any, state: any): any;
+    /** Calculates the column width based on the provided column model index */
+    calculateColumnWidth(column: any, modelColumn: any, state: any, firstColumn?: number, treePaddingX?: number): any;
+    calculateColumnHeaderWidth(modelColumn: any, state: any): number;
+    calculateColumnDataWidth(modelColumn: any, state: any): number;
+    calculateTreePaddingX(state: any): number;
+    /** Get the width of the provided font. Exploits the fact that we're using tabular figures so every character is same width */
+    getWidthForFont(font: any, state: any): any;
     /**
      * Sets the width for the specified column
-     * @param column The column model index to set
-     * @param size The size to set it to
+     * @param {Number} column The column model index to set
+     * @param {Number} size The size to set it to, or null to reset the column size
      */
-    setColumnWidth(column: ModelIndex, size: number): void;
+    setColumnWidth(column: number, size: number): void;
     /**
      * Resets the column width for the specified column to the calculated width
-     * @param column The column model index to reset
+     * @param {Number} column The column model index to reset
      */
-    resetColumnWidth(column: ModelIndex): void;
+    resetColumnWidth(column: number): void;
     /**
      * Sets the width for the specified row
-     * @param row The row model index to set
-     * @param size The size to set it to
+     * @param {Number} row The row model index to set
+     * @param {Number} size The size to set it to, or null to reset the row size
      */
-    setRowHeight(row: ModelIndex, size: number): void;
-    /**
-     * Resets the row height for the specified row to the calculated height
-     * @param row The row model index to reset
-     */
-    resetRowHeight(row: ModelIndex): void;
+    setRowHeight(row: number, size: number): void;
+    resetRowHeight(row: any): void;
 }
-export default GridMetricCalculator;
 //# sourceMappingURL=GridMetricCalculator.d.ts.map