@deephaven/grid 0.43.0 → 0.44.0

package/dist/GridMetricCalculator.js

@@ -0,0 +1,1500 @@
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+import clamp from 'lodash.clamp';
+import { getOrThrow } from '@deephaven/utils';
+import GridUtils from "./GridUtils.js";
+import { isExpandableGridModel } from "./ExpandableGridModel.js";
+export { getOrThrow } from '@deephaven/utils';
+/* eslint class-methods-use-this: "off" */
+/* eslint react/destructuring-assignment: "off" */
+
+/**
+ * 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 function trimMap(map) {
+  var cacheSize = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : GridMetricCalculator.CACHE_SIZE;
+  var targetSize = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Math.floor(cacheSize / 2);
+  if (map.size > cacheSize) {
+    var iter = map.keys();
+    while (map.size > targetSize) {
+      map.delete(iter.next().value);
+    }
+  }
+}
+
+/**
+ * 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 function getFloatingCoordinates(startCount, endCount, totalCount, max, sizeMap) {
+  var coordinates = new Map();
+  var x = 0;
+  for (var i = 0; i < startCount && i < totalCount; i += 1) {
+    coordinates.set(i, x);
+    x += getOrThrow(sizeMap, i);
+  }
+  x = max;
+  for (var _i = 0; _i < endCount && totalCount - _i - 1 >= 0; _i += 1) {
+    x -= getOrThrow(sizeMap, totalCount - _i - 1);
+    coordinates.set(totalCount - _i - 1, x);
+  }
+  return coordinates;
+}
+
+/**
+ * Class to calculate all the metrics for drawing a grid.
+ * Call getMetrics() with the state to get the full metrics.
+ * Override this class and override the individual methods to provide additional functionality.
+ */
+export class GridMetricCalculator {
+  /** The size of the caches this calculator stores */
+
+  /** The maximum column width as a percentage of the full grid */
+
+  /** The initial row heights if any overrides from the default calculated values */
+  // Readonly so it should be safe to make public
+
+  /** The initial column widths if any overrides from the default calculated values */
+  // Readonly so it should be safe to make public
+
+  /** User set column widths */
+
+  /** User set row heights */
+
+  /** Calculated column widths based on cell contents */
+
+  /** Calculated row heights based on cell contents */
+
+  /** Cache of fonts to estimated width of one char */
+
+  /** Map from visible index to model index for rows (e.g. reversing movedRows operations) */
+
+  /** Map from visible index to model index for columns (e.g. reversing movedColumns operations) */
+
+  /** List of moved row operations. Need to track the previous value so we know if modelRows needs to be cleared. */
+
+  /** List of moved column operations. Need to track the previous value so we know if modelColumns needs to be cleared. */
+
+  constructor() {
+    var {
+      userColumnWidths = new Map(),
+      userRowHeights = new Map(),
+      calculatedColumnWidths = new Map(),
+      calculatedRowHeights = new Map(),
+      fontWidths = new Map(),
+      modelRows = new Map(),
+      modelColumns = new Map(),
+      movedRows = [],
+      movedColumns = [],
+      initialRowHeights = new Map(),
+      initialColumnWidths = new Map()
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    _defineProperty(this, "initialRowHeights", void 0);
+    _defineProperty(this, "initialColumnWidths", void 0);
+    _defineProperty(this, "userColumnWidths", void 0);
+    _defineProperty(this, "userRowHeights", void 0);
+    _defineProperty(this, "calculatedColumnWidths", void 0);
+    _defineProperty(this, "calculatedRowHeights", void 0);
+    _defineProperty(this, "fontWidths", void 0);
+    _defineProperty(this, "modelRows", void 0);
+    _defineProperty(this, "modelColumns", void 0);
+    _defineProperty(this, "movedRows", void 0);
+    _defineProperty(this, "movedColumns", void 0);
+    this.userColumnWidths = userColumnWidths;
+    this.userRowHeights = userRowHeights;
+    this.calculatedRowHeights = calculatedRowHeights;
+    this.calculatedColumnWidths = calculatedColumnWidths;
+    this.fontWidths = fontWidths;
+
+    // Need to track the last moved rows/columns array so we know if we need to reset our models cache
+    this.modelRows = modelRows;
+    this.modelColumns = modelColumns;
+    this.movedRows = movedRows;
+    this.movedColumns = movedColumns;
+    this.initialRowHeights = initialRowHeights;
+    this.initialColumnWidths = initialColumnWidths;
+  }
+
+  /**
+   * Get the metrics for the provided metric state
+   * @params state The state to get metrics for
+   * @returns The full metrics
+   */
+  getMetrics(state) {
+    var {
+      left,
+      top,
+      leftOffset,
+      topOffset,
+      width,
+      height,
+      theme,
+      model,
+      movedRows,
+      movedColumns,
+      draggingColumn
+    } = state;
+    var {
+      rowHeight,
+      rowHeaderWidth,
+      rowFooterWidth,
+      columnWidth,
+      columnHeaderHeight,
+      minScrollHandleSize,
+      scrollBarSize
+    } = theme;
+    if (movedRows !== this.movedRows) {
+      this.movedRows = movedRows;
+      this.modelRows.clear();
+    }
+    if (movedColumns !== this.movedColumns) {
+      this.movedColumns = movedColumns;
+      this.modelColumns.clear();
+    }
+    var {
+      columnCount,
+      rowCount,
+      floatingTopRowCount,
+      floatingBottomRowCount,
+      floatingLeftColumnCount,
+      floatingRightColumnCount,
+      columnHeaderMaxDepth
+    } = model;
+
+    // Get some basic metrics
+    var firstRow = this.getFirstRow(state);
+    var firstColumn = this.getFirstColumn(state);
+    var gridX = this.getGridX(state);
+    var gridY = this.getGridY(state);
+    var treePaddingX = isExpandableGridModel(model) && model.hasExpandableRows ? this.calculateTreePaddingX(state) : 0;
+    var treePaddingY = 0; // We don't support trees on columns (at least not yet)
+
+    var visibleRowHeights = this.getVisibleRowHeights(state);
+    var visibleColumnWidths = this.getVisibleColumnWidths(state, firstColumn, treePaddingX);
+
+    // Calculate the metrics for the main grid
+    var visibleRows = Array.from(visibleRowHeights.keys());
+    var visibleColumns = Array.from(visibleColumnWidths.keys());
+
+    // Add the floating row heights/column widths
+    var allRowHeights = new Map([...visibleRowHeights, ...this.getFloatingRowHeights(state)]);
+    var allColumnWidths = new Map([...visibleColumnWidths, ...this.getFloatingColumnWidths(state)]);
+    var visibleColumnXs = this.getVisibleColumnXs(allColumnWidths, visibleColumns, leftOffset);
+    var visibleRowYs = this.getVisibleRowYs(allRowHeights, visibleRows, topOffset);
+    var bottom = visibleRows.length > 0 ? visibleRows[visibleRows.length - 1] : top;
+    var right = visibleColumns.length > 0 ? visibleColumns[visibleColumns.length - 1] : left;
+    var bottomViewport = this.getBottomViewport(state, visibleRows, visibleRowYs, allRowHeights);
+    var rightViewport = this.getRightViewport(state, visibleColumns, visibleColumnXs, allColumnWidths);
+    var floatingTopHeight = this.getFloatingTopHeight(state, allRowHeights);
+    var floatingBottomHeight = this.getFloatingBottomHeight(state, allRowHeights);
+    var floatingLeftWidth = this.getFloatingLeftWidth(state, allColumnWidths);
+    var floatingRightWidth = this.getFloatingRightWidth(state, allColumnWidths);
+    var columnWidthValues = Array.from(allColumnWidths.values());
+    var rowHeightValues = Array.from(allRowHeights.values());
+    var maxX = columnWidthValues.reduce((x, w) => x + w, 0) - leftOffset;
+    var maxY = rowHeightValues.reduce((y, h) => y + h, 0) - topOffset;
+
+    // How much total space the content will take
+    var scrollableContentWidth = leftOffset + maxX + rowFooterWidth;
+    var scrollableContentHeight = topOffset + maxY;
+
+    // Visible space available in the canvas viewport
+    var scrollableViewportWidth = width - gridX;
+    var scrollableViewportHeight = height - gridY;
+    var lastLeftWithoutScroll = this.getLastLeft(state, null, scrollableViewportWidth - rowFooterWidth);
+    var lastLeftWithScroll = this.getLastLeft(state, null, scrollableViewportWidth - rowFooterWidth - scrollBarSize);
+    var lastTopWithoutScroll = this.getLastTop(state, null, scrollableViewportHeight - floatingBottomHeight);
+    var lastTopWithScroll = this.getLastTop(state, null, scrollableViewportHeight - floatingBottomHeight - scrollBarSize);
+    var lastLeft = lastLeftWithScroll;
+    var lastTop = lastTopWithScroll;
+    if (lastLeftWithoutScroll === 0 && lastTopWithoutScroll === 0) {
+      // Fully visible without any scroll bars
+      lastLeft = 0;
+      lastTop = 0;
+    }
+
+    // Calculate some metrics for the scroll bars
+    var hasHorizontalBar = lastLeft > 0;
+    var horizontalBarHeight = hasHorizontalBar ? scrollBarSize : 0;
+    var hasVerticalBar = lastTop > 0;
+    var verticalBarWidth = hasVerticalBar ? scrollBarSize : 0;
+    var barLeft = gridX;
+    var barTop = columnHeaderMaxDepth * columnHeaderHeight;
+    var barWidth = width - barLeft - verticalBarWidth;
+    var barHeight = height - barTop - horizontalBarHeight;
+
+    // How big the scroll handle is relative to the bar
+    var horizontalHandlePercent = columnCount === 1 ? barWidth / scrollableContentWidth : (columnCount - lastLeft) / columnCount;
+    var verticalHandlePercent = rowCount === 1 ? barHeight / scrollableContentHeight : (rowCount - lastTop) / rowCount;
+    var handleWidth = hasHorizontalBar ? clamp(barWidth * horizontalHandlePercent, minScrollHandleSize, barWidth - 1) : 0;
+    var handleHeight = hasVerticalBar ? clamp(barHeight * verticalHandlePercent, minScrollHandleSize, barHeight - 1) : 0;
+    var leftColumnWidth = getOrThrow(allColumnWidths, left, 0);
+    var topRowHeight = getOrThrow(allRowHeights, top, 0);
+    var leftOffsetPercent = leftColumnWidth > 0 ? leftOffset / leftColumnWidth : 0;
+    var topOffsetPercent = topRowHeight > 0 ? topOffset / topRowHeight : 0;
+
+    // How much of the available space has been scrolled
+    var horizontalScrollPercent = columnCount === 1 ? leftOffset / (scrollableContentWidth - scrollableViewportWidth) : (left + leftOffsetPercent) / lastLeft;
+    var verticalScrollPercent = rowCount === 1 ? topOffset / (scrollableContentHeight - scrollableViewportHeight) : (top + topOffsetPercent) / lastTop;
+    var scrollX = hasHorizontalBar ? horizontalScrollPercent * (barWidth - handleWidth) : 0;
+    var scrollY = hasVerticalBar ? verticalScrollPercent * (barHeight - handleHeight) : 0;
+
+    // Now add the floating sections positions
+    var floatingRows = [...Array(floatingTopRowCount).keys(), ...[...Array(floatingBottomRowCount).keys()].map(i => rowCount - i - 1)];
+    var allRowYs = new Map([...visibleRowYs, ...this.getFloatingRowYs(state, allRowHeights, Math.floor(height - gridY - horizontalBarHeight))]);
+    var floatingColumns = [...Array(floatingLeftColumnCount).keys(), ...[...Array(floatingRightColumnCount).keys()].map(i => columnCount - i - 1)];
+    var allColumnXs = new Map([...visibleColumnXs, ...this.getFloatingColumnXs(state, allColumnWidths, Math.floor(width - gridX - verticalBarWidth))]);
+    var draggingColumns = [];
+    if (draggingColumn) {
+      for (var i = draggingColumn.range[0]; i <= draggingColumn.range[1]; i += 1) {
+        draggingColumns.push(i);
+        if (!allColumnWidths.has(i)) {
+          allColumnWidths.set(i, this.getVisibleColumnWidth(i, state));
+        }
+        if (!allColumnXs.has(i)) {
+          allColumnXs.set(i, 0);
+        }
+      }
+    }
+    var allRows = visibleRows.concat(floatingRows);
+    var allColumns = visibleColumns.concat(floatingColumns).concat(draggingColumns);
+    var modelRows = this.getModelRows(allRows, state);
+    var modelColumns = this.getModelColumns(allColumns, state);
+    var visibleRowTreeBoxes = this.getVisibleRowTreeBoxes(allRowHeights, modelRows, state);
+
+    // Calculate the visible viewport based on scroll position and floating sections
+    var topVisible = this.getTopVisible(state, allRowYs, allRowHeights, visibleRows);
+    var leftVisible = this.getLeftVisible(state, allColumnXs, allColumnWidths, visibleColumns);
+    var bottomVisible = lastTop > 0 ? this.getBottomVisible(state, allRowYs, allRowHeights, visibleRows, gridY) : bottom;
+    var rightVisible = lastLeft > 0 ? this.getRightVisible(state, allColumnXs, allColumnWidths, visibleColumns, gridX) : right;
+    var {
+      fontWidths,
+      userColumnWidths,
+      userRowHeights,
+      calculatedRowHeights,
+      calculatedColumnWidths
+    } = this;
+    return {
+      // Row/Column metrics from model
+      rowHeight,
+      rowHeaderWidth,
+      rowFooterWidth,
+      rowCount,
+      columnWidth,
+      columnCount,
+      columnHeaderHeight,
+      // Floating row and column counts
+      floatingTopRowCount,
+      floatingBottomRowCount,
+      floatingLeftColumnCount,
+      floatingRightColumnCount,
+      // The grid offset from the top left
+      gridX,
+      gridY,
+      // Index of non-hidden row/columns
+      firstRow,
+      firstColumn,
+      // The amount of padding for tree (if applicable)
+      treePaddingX,
+      treePaddingY,
+      // What viewport is currently visible, limited by data size
+      left,
+      top,
+      bottom,
+      right,
+      topOffset,
+      leftOffset,
+      // Bottom and right that are fully visible, not overlapped by scroll bars or anything
+      topVisible,
+      leftVisible,
+      bottomVisible,
+      rightVisible,
+      // Bottom and right of the viewport, not limited by data size
+      bottomViewport,
+      rightViewport,
+      // Canvas width/height
+      width,
+      height,
+      // Max x/y coordinate of the grid (does not include headers)
+      maxX,
+      maxY,
+      // Last valid column/row that can be the left/top of the grid
+      lastLeft,
+      lastTop,
+      // Scroll bar metrics
+      barHeight,
+      barTop,
+      barWidth,
+      barLeft,
+      handleHeight,
+      handleWidth,
+      hasHorizontalBar,
+      hasVerticalBar,
+      verticalBarWidth,
+      horizontalBarHeight,
+      // The vertical x/y scroll amount
+      scrollX,
+      scrollY,
+      scrollableContentWidth,
+      scrollableContentHeight,
+      scrollableViewportWidth,
+      scrollableViewportHeight,
+      // Array of visible rows/columns, by grid index
+      visibleRows,
+      visibleColumns,
+      // Map of the height/width of visible rows/columns
+      visibleRowHeights,
+      visibleColumnWidths,
+      // Array of floating rows/columns, by grid index
+      floatingRows,
+      floatingColumns,
+      // Array of all rows/columns, visible and floating, by grid index
+      allRows,
+      allColumns,
+      // Map of the height/width of visible rows/columns
+      allRowHeights,
+      allColumnWidths,
+      // Floating metrics
+      floatingTopHeight,
+      floatingBottomHeight,
+      floatingLeftWidth,
+      floatingRightWidth,
+      // Map of the X/Y coordinates of the visible rows/columns, from the top left of the grid
+      visibleRowYs,
+      visibleColumnXs,
+      // Map of the X/Y coordinates of all rows/columns, visible and floating, from the top left of the grid
+      allRowYs,
+      allColumnXs,
+      // The boxes user can click on for expanding/collapsing tree rows
+      visibleRowTreeBoxes,
+      // Mapping from visible row indexes to the model row/columns they pull from
+      modelRows,
+      modelColumns,
+      movedRows,
+      movedColumns,
+      // Map of the width of the fonts
+      fontWidths,
+      // Map of user set column/row width/height
+      userColumnWidths,
+      userRowHeights,
+      // Map of calculated row/column height/width
+      calculatedRowHeights,
+      calculatedColumnWidths,
+      columnHeaderMaxDepth
+    };
+  }
+
+  /**
+   * 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) {
+    var {
+      theme
+    } = state;
+    var {
+      rowHeaderWidth
+    } = theme;
+    return rowHeaderWidth;
+  }
+
+  /**
+   * 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) {
+    var {
+      theme,
+      model
+    } = state;
+    var {
+      columnHeaderHeight
+    } = theme;
+    var {
+      columnHeaderMaxDepth
+    } = model;
+    return columnHeaderMaxDepth * columnHeaderHeight;
+  }
+
+  /**
+   * 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) {
+    var visibleRowHeights = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getFloatingRowHeights(state);
+    var {
+      height,
+      theme
+    } = state;
+    var {
+      scrollBarSize
+    } = theme;
+    var gridY = this.getGridY(state);
+    var floatingBottomHeight = this.getFloatingBottomHeight(state, visibleRowHeights);
+    var floatingTopHeight = this.getFloatingTopHeight(state, visibleRowHeights);
+    return height - floatingBottomHeight - floatingTopHeight - gridY - scrollBarSize;
+  }
+
+  /**
+   * 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) {
+    var visibleColumnWidths = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getFloatingColumnWidths(state);
+    var {
+      width,
+      theme
+    } = state;
+    var {
+      scrollBarSize,
+      rowFooterWidth
+    } = theme;
+    var gridX = this.getGridX(state);
+    var floatingRightWidth = this.getFloatingRightWidth(state, visibleColumnWidths);
+    var floatingLeftWidth = this.getFloatingLeftWidth(state, visibleColumnWidths);
+    return width - floatingLeftWidth - floatingRightWidth - gridX - scrollBarSize - rowFooterWidth;
+  }
+
+  /**
+   * 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, getModelIndex, state) {
+    // We only need to check at the very most the number of items the user has hidden + 1
+    var max = itemSizes.size + 1;
+    for (var i = 0; i < max; i += 1) {
+      var modelIndex = getModelIndex(i, state);
+      if (itemSizes.get(modelIndex) !== 0) {
+        return i;
+      }
+    }
+    return 0;
+  }
+
+  /**
+   * 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) {
+    return this.getFirstIndex(this.userColumnWidths, this.getModelColumn.bind(this), state);
+  }
+
+  /**
+   * 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) {
+    return this.getFirstIndex(this.userRowHeights, this.getModelRow.bind(this), state);
+  }
+
+  /**
+   * Get the last column that can be the left most column (e.g. 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, right, visibleWidth) {
+    var {
+      model
+    } = state;
+    var {
+      columnCount,
+      floatingRightColumnCount
+    } = model;
+    var lastLeft = Math.max(0, columnCount - floatingRightColumnCount - 1);
+    if (right != null) {
+      lastLeft = right;
+    }
+    var x = 0;
+    while (lastLeft >= 0) {
+      var columnWidth = this.getVisibleColumnWidth(lastLeft, state);
+      x += columnWidth;
+      if (x >= visibleWidth) {
+        return clamp(lastLeft + 1, 0, right !== null && right !== void 0 ? right : columnCount - 1);
+      }
+      lastLeft -= 1;
+    }
+    return 0;
+  }
+
+  /**
+   * 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 top visible row
+   */
+  getLastTop(state, bottom, visibleHeight) {
+    var {
+      model
+    } = state;
+    var {
+      rowCount,
+      floatingBottomRowCount
+    } = model;
+    var lastTop = Math.max(0, rowCount - floatingBottomRowCount - 1);
+    if (bottom != null) {
+      lastTop = bottom;
+    }
+    var y = 0;
+    while (lastTop >= 0) {
+      var rowHeight = this.getVisibleRowHeight(lastTop, state);
+      y += rowHeight;
+      if (y >= visibleHeight) {
+        return clamp(lastTop + 1, 0, rowCount - 1);
+      }
+      lastTop -= 1;
+    }
+    return 0;
+  }
+
+  /**
+   * 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, topVisible) {
+    var floatingTopHeight = this.getFloatingTopHeight(state);
+    var top = topVisible;
+    var y = 0;
+    while (top > 0 && y < floatingTopHeight) {
+      top -= 1;
+      y += this.getVisibleRowHeight(top, state);
+    }
+    return top;
+  }
+
+  /**
+   * 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, bottomVisible) {
+    var {
+      height
+    } = state;
+    var gridY = this.getGridY(state);
+    var floatingBottomHeight = this.getFloatingBottomHeight(state);
+    var availableHeight = height - gridY - floatingBottomHeight;
+    return this.getLastTop(state, bottomVisible, availableHeight);
+  }
+
+  /**
+   * 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, leftVisible) {
+    var floatingLeftWidth = this.getFloatingLeftWidth(state);
+    var left = leftVisible;
+    var x = 0;
+    while (left > 0 && x < floatingLeftWidth) {
+      left -= 1;
+      x += this.getVisibleColumnWidth(left, state);
+    }
+    return left;
+  }
+
+  /**
+   * 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, rightVisible) {
+    var {
+      width
+    } = state;
+    var gridX = this.getGridX(state);
+    var floatingRightWidth = this.getFloatingRightWidth(state);
+    var availableWidth = width - gridX - floatingRightWidth;
+    return this.getLastLeft(state, rightVisible, availableWidth);
+  }
+
+  /**
+   * 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) {
+    var {
+      model
+    } = state;
+    var {
+      floatingTopRowCount,
+      floatingBottomRowCount,
+      rowCount
+    } = model;
+    var rowHeights = new Map();
+    for (var i = 0; i < floatingTopRowCount && i < rowCount; i += 1) {
+      rowHeights.set(i, this.getVisibleRowHeight(i, state));
+    }
+    for (var _i2 = 0; _i2 < floatingBottomRowCount && rowCount - _i2 - 1 >= 0; _i2 += 1) {
+      var row = rowCount - _i2 - 1;
+      rowHeights.set(row, this.getVisibleRowHeight(row, state));
+    }
+    return rowHeights;
+  }
+
+  /**
+   * 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) {
+    var {
+      top,
+      topOffset,
+      height,
+      model
+    } = state;
+    var y = 0;
+    var row = top;
+    var rowHeights = new Map();
+    var {
+      rowCount
+    } = model;
+    while (y < height + topOffset && row < rowCount) {
+      var rowHeight = this.getVisibleRowHeight(row, state);
+      rowHeights.set(row, rowHeight);
+      y += rowHeight;
+      row += 1;
+    }
+    return rowHeights;
+  }
+
+  /**
+   * 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) {
+    var firstColumn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getFirstColumn(state);
+    var treePaddingX = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.calculateTreePaddingX(state);
+    var {
+      model
+    } = state;
+    var {
+      columnCount,
+      floatingLeftColumnCount,
+      floatingRightColumnCount
+    } = model;
+    var columnWidths = new Map();
+    for (var i = 0; i < floatingLeftColumnCount && i < columnCount; i += 1) {
+      columnWidths.set(i, this.getVisibleColumnWidth(i, state, firstColumn, treePaddingX));
+    }
+    for (var _i3 = 0; _i3 < floatingRightColumnCount && columnCount - _i3 - 1 >= 0; _i3 += 1) {
+      var column = columnCount - _i3 - 1;
+      columnWidths.set(column, this.getVisibleColumnWidth(column, state, firstColumn, treePaddingX));
+    }
+    return columnWidths;
+  }
+
+  /**
+   * 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) {
+    var firstColumn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getFirstColumn(state);
+    var treePaddingX = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.calculateTreePaddingX(state);
+    var {
+      left,
+      leftOffset,
+      width,
+      model
+    } = state;
+    var x = 0;
+    var column = left;
+    var columnWidths = new Map();
+    var {
+      columnCount
+    } = model;
+    while (x < width + leftOffset && column < columnCount) {
+      var columnWidth = this.getVisibleColumnWidth(column, state, firstColumn, treePaddingX);
+      columnWidths.set(column, columnWidth);
+      x += columnWidth;
+      column += 1;
+    }
+    return columnWidths;
+  }
+
+  /**
+   * 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, columnWidthMap, maxX) {
+    var {
+      model
+    } = state;
+    var {
+      columnCount,
+      floatingLeftColumnCount,
+      floatingRightColumnCount
+    } = model;
+    return getFloatingCoordinates(floatingLeftColumnCount, floatingRightColumnCount, columnCount, maxX, columnWidthMap);
+  }
+
+  /**
+   * 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, visibleColumns, leftOffset) {
+    var visibleColumnXs = new Map();
+    var x = -leftOffset;
+    for (var i = 0; i < visibleColumns.length; i += 1) {
+      var column = visibleColumns[i];
+      var columnWidth = getOrThrow(visibleColumnWidths, column);
+      visibleColumnXs.set(column, x);
+      x += columnWidth;
+    }
+    return visibleColumnXs;
+  }
+
+  /**
+   * 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, rowHeightMap, maxY) {
+    var {
+      model
+    } = state;
+    var {
+      floatingTopRowCount,
+      floatingBottomRowCount,
+      rowCount
+    } = model;
+    return getFloatingCoordinates(floatingTopRowCount, floatingBottomRowCount, rowCount, maxY, rowHeightMap);
+  }
+
+  /**
+   * 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, visibleRows, topOffset) {
+    var visibleRowYs = new Map();
+    var y = -topOffset;
+    for (var i = 0; i < visibleRows.length; i += 1) {
+      var row = visibleRows[i];
+      var rowHeight = getOrThrow(visibleRowHeights, row);
+      visibleRowYs.set(row, y);
+      y += rowHeight;
+    }
+    return visibleRowYs;
+  }
+
+  /**
+   * 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, modelRows, state) {
+    var visibleRowTreeBoxes = new Map();
+    var {
+      model,
+      theme
+    } = state;
+    var {
+      treeDepthIndent,
+      treeHorizontalPadding
+    } = theme;
+    if (isExpandableGridModel(model) && model.hasExpandableRows) {
+      visibleRowHeights.forEach((rowHeight, row) => {
+        var modelRow = getOrThrow(modelRows, row);
+        if (model.isRowExpandable(modelRow)) {
+          var depth = model.depthForRow(modelRow);
+          var x1 = depth * treeDepthIndent + treeHorizontalPadding;
+          var x2 = (depth + 1) * treeDepthIndent + treeHorizontalPadding;
+          var y1 = 0;
+          var y2 = rowHeight;
+          visibleRowTreeBoxes.set(row, {
+            x1,
+            y1,
+            x2,
+            y2
+          });
+        }
+      });
+    }
+    return visibleRowTreeBoxes;
+  }
+
+  /**
+   * 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) {
+    var columnWidths = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getFloatingColumnWidths(state);
+    var {
+      model
+    } = state;
+    var {
+      floatingLeftColumnCount
+    } = model;
+    var floatingWidth = 0;
+    for (var i = 0; i < floatingLeftColumnCount; i += 1) {
+      floatingWidth += getOrThrow(columnWidths, i);
+    }
+    return floatingWidth;
+  }
+
+  /**
+   * 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) {
+    var columnWidths = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getFloatingColumnWidths(state);
+    var {
+      model
+    } = state;
+    var {
+      floatingRightColumnCount,
+      columnCount
+    } = model;
+    var floatingWidth = 0;
+    for (var i = 0; i < floatingRightColumnCount; i += 1) {
+      floatingWidth += getOrThrow(columnWidths, columnCount - i - 1);
+    }
+    return floatingWidth;
+  }
+
+  /**
+   * 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) {
+    var rowHeights = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getFloatingRowHeights(state);
+    var {
+      model
+    } = state;
+    var {
+      floatingTopRowCount
+    } = model;
+    var floatingHeight = 0;
+    for (var i = 0; i < floatingTopRowCount; i += 1) {
+      floatingHeight += getOrThrow(rowHeights, i);
+    }
+    return floatingHeight;
+  }
+
+  /**
+   * 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) {
+    var rowHeights = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getFloatingRowHeights(state);
+    var {
+      model
+    } = state;
+    var {
+      floatingBottomRowCount,
+      rowCount
+    } = model;
+    var floatingHeight = 0;
+    for (var i = 0; i < floatingBottomRowCount; i += 1) {
+      floatingHeight += getOrThrow(rowHeights, rowCount - i - 1);
+    }
+    return floatingHeight;
+  }
+
+  /**
+   * 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, visibleRowYs, visibleRowHeights, visibleRows) {
+    var floatingHeight = this.getFloatingTopHeight(state, visibleRowHeights);
+    for (var i = 0; i < visibleRows.length; i += 1) {
+      var row = visibleRows[i];
+      var y = getOrThrow(visibleRowYs, row);
+      if (y >= floatingHeight) {
+        return row;
+      }
+    }
+    return 0;
+  }
+
+  /**
+   * 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, visibleColumnXs, visibleColumnWidths, visibleColumns) {
+    var floatingWidth = this.getFloatingLeftWidth(state, visibleColumnWidths);
+    for (var i = 0; i < visibleColumns.length; i += 1) {
+      var column = visibleColumns[i];
+      var x = getOrThrow(visibleColumnXs, column);
+      if (x >= floatingWidth) {
+        return column;
+      }
+    }
+    return 0;
+  }
+
+  /**
+   * 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, visibleRowYs, visibleRowHeights, visibleRows, gridY) {
+    var {
+      height,
+      theme
+    } = state;
+    var {
+      scrollBarSize
+    } = theme;
+    var floatingHeight = this.getFloatingBottomHeight(state, visibleRowHeights);
+    var visibleHeight = height - gridY - scrollBarSize - floatingHeight;
+    for (var i = visibleRows.length - 1; i >= 0; i -= 1) {
+      var row = visibleRows[i];
+      var rowY = getOrThrow(visibleRowYs, row);
+      var rowHeight = getOrThrow(visibleRowHeights, row);
+      if (rowY + rowHeight <= visibleHeight) {
+        return row;
+      }
+    }
+    return 0;
+  }
+
+  /**
+   * 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, visibleColumnXs, visibleColumnWidths, visibleColumns, gridX) {
+    var {
+      width,
+      theme
+    } = state;
+    var {
+      scrollBarSize
+    } = theme;
+    var floatingWidth = this.getFloatingRightWidth(state, visibleColumnWidths);
+    var visibleWidth = width - gridX - scrollBarSize - floatingWidth;
+    for (var i = visibleColumns.length - 1; i >= 0; i -= 1) {
+      var column = visibleColumns[i];
+      var columnX = getOrThrow(visibleColumnXs, column);
+      var columnWidth = getOrThrow(visibleColumnWidths, column);
+      if (columnX + columnWidth <= visibleWidth) {
+        return column;
+      }
+    }
+    return 0;
+  }
+
+  /**
+   * 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, visibleRows, visibleRowYs, visibleRowHeights) {
+    var {
+      height,
+      theme
+    } = state;
+    var {
+      rowHeight
+    } = theme;
+    return this.getLastIndexViewport(visibleRows, visibleRowYs, visibleRowHeights, height, rowHeight);
+  }
+
+  /**
+   * 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, visibleColumns, visibleColumnXs, visibleColumnWidths) {
+    var {
+      width,
+      theme
+    } = state;
+    var {
+      columnWidth
+    } = theme;
+    return this.getLastIndexViewport(visibleColumns, visibleColumnXs, visibleColumnWidths, width, columnWidth);
+  }
+
+  /**
+   * 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, itemXs, itemSizes, maxSize, defaultItemSize) {
+    var lastIndex = 0;
+    var dataSize = 0;
+    if (items.length > 0) {
+      lastIndex = items[items.length - 1];
+      dataSize = getOrThrow(itemXs, lastIndex) + getOrThrow(itemSizes, lastIndex);
+    }
+    if (dataSize < maxSize) {
+      lastIndex += Math.ceil((maxSize - dataSize) / defaultItemSize);
+    }
+    return lastIndex;
+  }
+
+  /**
+   * 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 getDefaultSize Method to get the default size for this item
+   * @returns The size from the provided size map of the specified item
+   */
+  getVisibleItemSize(modelIndex, userSizes, getDefaultSize) {
+    var _userSizes$get;
+    return (_userSizes$get = userSizes.get(modelIndex)) !== null && _userSizes$get !== void 0 ? _userSizes$get : getDefaultSize();
+  }
+
+  /**
+   * 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, state) {
+    var modelRow = this.getModelRow(row, state);
+    var calculatedHeight = this.calculateRowHeight(row, modelRow, state); // Need to call this so calculated map is always populated
+
+    return this.getVisibleItemSize(modelRow, this.userRowHeights, () => {
+      var initialHeight = this.initialRowHeights.get(modelRow);
+      if (initialHeight !== undefined) {
+        return initialHeight;
+      }
+      return calculatedHeight;
+    });
+  }
+
+  /**
+   * 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, state) {
+    var firstColumn = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getFirstColumn(state);
+    var treePaddingX = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : this.calculateTreePaddingX(state);
+    var modelColumn = this.getModelColumn(column, state);
+
+    // Need to call this so calculated map is always populated
+    var calculatedWidth = this.calculateColumnWidth(column, modelColumn, state, firstColumn, treePaddingX);
+    return this.getVisibleItemSize(modelColumn, this.userColumnWidths, () => {
+      var initialWidth = this.initialColumnWidths.get(modelColumn);
+      if (initialWidth !== undefined) {
+        return initialWidth;
+      }
+      return calculatedWidth;
+    });
+  }
+
+  /**
+   * Get a map of VisibleIndex to ModelIndex
+   * @param visibleRows Array of visible row indexes
+   * @param state The grid metric state
+   * @returns Map of VisibleIndex to ModelIndex
+   */
+  getModelRows(visibleRows, state) {
+    var modelRows = new Map();
+    for (var i = 0; i < visibleRows.length; i += 1) {
+      var visibleRow = visibleRows[i];
+      var modelRow = this.getModelRow(visibleRow, state);
+      modelRows.set(visibleRow, modelRow);
+    }
+    return modelRows;
+  }
+
+  /**
+   * 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, state) {
+    if (this.modelRows.has(visibleRow)) {
+      return getOrThrow(this.modelRows, visibleRow);
+    }
+    var {
+      movedRows
+    } = state;
+    var modelRow = GridUtils.getModelIndex(visibleRow, movedRows);
+    this.modelRows.set(visibleRow, modelRow);
+    return modelRow;
+  }
+
+  /**
+   * 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, state) {
+    var modelColumns = new Map();
+    for (var i = 0; i < visibleColumns.length; i += 1) {
+      var visibleColumn = visibleColumns[i];
+      var modelColumn = this.getModelColumn(visibleColumn, state);
+      modelColumns.set(visibleColumn, modelColumn);
+    }
+    return modelColumns;
+  }
+
+  /**
+   * 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, state) {
+    var hasVisibleColumn = this.modelColumns.has(visibleColumn);
+    if (hasVisibleColumn) {
+      return getOrThrow(this.modelColumns, visibleColumn);
+    }
+    var {
+      movedColumns
+    } = state;
+    var modelColumn = GridUtils.getModelIndex(visibleColumn, movedColumns);
+    this.modelColumns.set(visibleColumn, modelColumn);
+    return modelColumn;
+  }
+
+  /**
+   * 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, modelRow, state) {
+    var {
+      theme
+    } = state;
+    var {
+      autoSizeRows,
+      rowHeight
+    } = theme;
+    if (!autoSizeRows) {
+      return rowHeight;
+    }
+    var cachedValue = this.calculatedRowHeights.get(modelRow);
+    if (cachedValue != null) {
+      return cachedValue;
+    }
+
+    // Not sure how to accurately get the height of text. For now just return the theme height.
+    this.calculatedRowHeights.set(modelRow, Math.ceil(rowHeight));
+    trimMap(this.calculatedRowHeights);
+    return rowHeight;
+  }
+
+  /**
+   * 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, modelColumn, state) {
+    var firstColumn = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : this.getFirstColumn(state);
+    var treePaddingX = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : this.calculateTreePaddingX(state);
+    var {
+      theme
+    } = state;
+    var {
+      autoSizeColumns,
+      minColumnWidth
+    } = theme;
+    if (!autoSizeColumns) {
+      var {
+        columnWidth: _columnWidth
+      } = theme;
+      return _columnWidth;
+    }
+    var headerWidth = this.calculateColumnHeaderWidth(modelColumn, state);
+    var dataWidth = this.calculateColumnDataWidth(modelColumn, state);
+    var cachedValue = this.calculatedColumnWidths.get(modelColumn);
+    var columnWidth = Math.ceil(Math.max(headerWidth, dataWidth));
+    columnWidth = Math.max(minColumnWidth, columnWidth);
+    if (cachedValue != null && cachedValue > columnWidth) {
+      columnWidth = cachedValue;
+    } else {
+      this.calculatedColumnWidths.set(modelColumn, columnWidth);
+      trimMap(this.calculatedColumnWidths);
+    }
+    if (column === firstColumn) {
+      columnWidth += treePaddingX;
+    }
+    return columnWidth;
+  }
+
+  /**
+   * 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, state) {
+    var {
+      model,
+      theme
+    } = state;
+    var {
+      headerFont,
+      headerHorizontalPadding
+    } = theme;
+    var headerText = model.textForColumnHeader(modelColumn, 0);
+    if (headerText !== undefined && headerText !== '') {
+      var headerFontWidth = this.getWidthForFont(headerFont, state);
+      return headerText.length * headerFontWidth + headerHorizontalPadding * 2;
+    }
+    return headerHorizontalPadding * 2;
+  }
+
+  /**
+   * 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, state) {
+    var {
+      top,
+      height,
+      width,
+      model,
+      theme
+    } = state;
+    var {
+      floatingTopRowCount,
+      floatingBottomRowCount,
+      rowCount
+    } = model;
+    var {
+      font,
+      cellHorizontalPadding,
+      rowHeight,
+      rowHeaderWidth,
+      rowFooterWidth,
+      scrollBarSize,
+      dataBarHorizontalPadding
+    } = theme;
+    var columnWidth = 0;
+    var fontWidth = this.getWidthForFont(font, state);
+    var rowsPerPage = height / rowHeight;
+    var bottom = Math.ceil(top + rowsPerPage);
+    GridUtils.iterateAllItems(top, bottom, floatingTopRowCount, floatingBottomRowCount, rowCount, row => {
+      var modelRow = this.getModelRow(row, state);
+      var text = model.textForCell(modelColumn, modelRow);
+      var cellRenderType = model.renderTypeForCell(modelColumn, modelRow);
+      var cellWidth = 0;
+      if (text) {
+        var cellPadding = cellHorizontalPadding * 2;
+        cellWidth = text.length * fontWidth + cellPadding;
+      }
+      if (cellRenderType === 'dataBar') {
+        cellWidth += dataBarHorizontalPadding;
+      }
+      columnWidth = Math.max(columnWidth, cellWidth);
+    });
+    columnWidth = Math.max(Math.min(columnWidth, (width - rowHeaderWidth - scrollBarSize - rowFooterWidth) * GridMetricCalculator.MAX_COLUMN_WIDTH), cellHorizontalPadding * 2);
+    return columnWidth;
+  }
+
+  /**
+   * The coordinate for where the tree padding should be drawn
+   * @param state The grid metric state
+   * @returns The coordinate for tree padding
+   */
+  calculateTreePaddingX(state) {
+    var {
+      top,
+      height,
+      model,
+      theme
+    } = state;
+    var {
+      rowHeight,
+      treeDepthIndent
+    } = theme;
+    if (!isExpandableGridModel(model) || !model.hasExpandableRows) {
+      return 0;
+    }
+    var treePadding = 0;
+    var rowsPerPage = height / rowHeight;
+    var bottom = Math.ceil(top + rowsPerPage);
+    for (var row = top; row <= bottom; row += 1) {
+      var modelRow = this.getModelRow(row, state);
+      var depth = model.depthForRow(modelRow);
+      treePadding = Math.max(treePadding, treeDepthIndent * (depth + 1));
+    }
+    return treePadding;
+  }
+
+  /**
+   * 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, state) {
+    if (this.fontWidths.has(font)) {
+      return getOrThrow(this.fontWidths, font);
+    }
+    var {
+      context
+    } = state;
+    context.font = font;
+    var textMetrics = context.measureText('8');
+    var {
+      width
+    } = textMetrics;
+
+    // context.font changes the string a little bit, e.g. '10px Arial, sans serif' => '10px Arial, "sans serif"'
+    // Rather than require checking with the correct font def (theme, or context font), just key it to both
+    this.fontWidths.set(font, width);
+    this.fontWidths.set(context.font, width);
+    return width;
+  }
+
+  /**
+   * Sets the width for the specified column
+   * @param column The column model index to set
+   * @param size The size to set it to
+   */
+  setColumnWidth(column, size) {
+    // Always use a new instance of the map so any consumer of the metrics knows there has been a change
+    var userColumnWidths = new Map(this.userColumnWidths);
+    userColumnWidths.set(column, Math.ceil(size));
+    trimMap(userColumnWidths);
+    this.userColumnWidths = userColumnWidths;
+  }
+
+  /**
+   * Resets the column width for the specified column to the calculated width
+   * @param column The column model index to reset
+   */
+  resetColumnWidth(column) {
+    // Always use a new instance of the map so any consumer of the metrics knows there has been a change
+    var userColumnWidths = new Map(this.userColumnWidths);
+    userColumnWidths.delete(column);
+    this.userColumnWidths = userColumnWidths;
+  }
+
+  /**
+   * Sets the width for the specified row
+   * @param row The row model index to set
+   * @param size The size to set it to
+   */
+  setRowHeight(row, size) {
+    // Always use a new instance of the map so any consumer of the metrics knows there has been a change
+    var userRowHeights = new Map(this.userRowHeights);
+    userRowHeights.set(row, Math.ceil(size));
+    trimMap(userRowHeights);
+    this.userRowHeights = userRowHeights;
+  }
+
+  /**
+   * Resets the row height for the specified row to the calculated height
+   * @param row The row model index to reset
+   */
+  resetRowHeight(row) {
+    // Always use a new instance of the map so any consumer of the metrics knows there has been a change
+    var userRowHeights = new Map(this.userRowHeights);
+    userRowHeights.delete(row);
+    this.userRowHeights = userRowHeights;
+    this.calculatedRowHeights.delete(row);
+  }
+}
+_defineProperty(GridMetricCalculator, "CACHE_SIZE", 10000);
+_defineProperty(GridMetricCalculator, "MAX_COLUMN_WIDTH", 0.8);
+export default GridMetricCalculator;
+//# sourceMappingURL=GridMetricCalculator.js.map