@deephaven/grid 0.6.3-beta.9 → 0.7.0

package/dist/GridMetricCalculator.js

@@ -1,75 +1,10 @@
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
 import GridUtils from "./GridUtils.js";
+/* eslint class-methods-use-this: "off" */
 
-/**
- * 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 function getOrThrow(map, key) {
-  var _map$get;
-
-  var defaultValue = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;
-  var value = (_map$get = map.get(key)) !== null && _map$get !== void 0 ? _map$get : defaultValue;
-
-  if (value !== undefined) {
-    return value;
-  }
-
-  throw new Error("Missing value for key ".concat(key));
-}
-/**
- * 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);
-  }
+/* eslint react/destructuring-assignment: "off" */
 
-  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.
@@ -81,54 +16,67 @@ class GridMetricCalculator {
 
   /** The maximum column width as a percentage of the full grid */
 
-  /** User set column widths */
+  /**
+   * 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) {
+    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);
 
-  /** User set row heights */
+    if (map.size > cacheSize) {
+      var iter = map.keys();
 
-  /** Calculated column widths based on cell contents */
+      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 {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)
+   */
 
-  /** Calculated row heights based on cell contents */
 
-  /** Cache of fonts to estimated width of one char */
+  static getFloatingCoordinates(startCount, endCount, totalCount, max, sizeMap) {
+    var coordinates = new Map();
+    var x = 0;
 
-  /** Map from visible index to model index for rows (e.g. reversing movedRows operations) */
+    for (var i = 0; i < startCount && i < totalCount; i += 1) {
+      coordinates.set(i, x);
+      x += sizeMap.get(i);
+    }
 
-  /** Map from visible index to model index for columns (e.g. reversing movedColumns operations) */
+    x = max;
 
-  /** List of moved row operations. Need to track the previous value so we know if modelRows needs to be cleared. */
+    for (var _i = 0; _i < endCount && totalCount - _i - 1 >= 0; _i += 1) {
+      x -= sizeMap.get(totalCount - _i - 1);
+      coordinates.set(totalCount - _i - 1, x);
+    }
+
+    return coordinates;
+  }
 
-  /** 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(),
+      calculatedColumnWidths = new Map(),
       fontWidths = new Map(),
       modelRows = new Map(),
       modelColumns = new Map(),
-      movedRows = [],
-      movedColumns = []
+      movedRows = null,
+      movedColumns = null
     } = arguments.length > 0 && arguments[0] !== undefined ? arguments[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;
@@ -140,11 +88,7 @@ class GridMetricCalculator {
     this.movedRows = movedRows;
     this.movedColumns = movedColumns;
   }
-  /**
-   * Get the metrics for the provided metric state
-   * @params state The state to get metrics for
-   * @returns The full metrics
-   */
+  /** update the calculated metrics from the model/canvas that are useful for many functions */
 
 
   getMetrics(state) {
@@ -196,8 +140,8 @@ class GridMetricCalculator {
     var treePaddingX = model.hasExpandableRows ? this.calculateTreePaddingX(state) : 0;
     var treePaddingY = 0; // We don't support trees on columns (at least not yet)
 
-    var visibleRowHeights = new Map([...this.getVisibleRowHeights(state), ...this.getFloatingRowHeights(state)]);
-    var visibleColumnWidths = new Map([...this.getVisibleColumnWidths(state, firstColumn, treePaddingX), ...this.getFloatingColumnWidths(state)]); // Calculate the metrics for the main grid
+    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());
@@ -223,17 +167,18 @@ class GridMetricCalculator {
     var barHeight = height - columnHeaderHeight - horizontalBarHeight;
     var handleWidth = lastLeft > 0 ? Math.min(Math.max(minScrollHandleSize, barWidth * ((columnCount - lastLeft) / columnCount)), barWidth - 1) : 0;
     var handleHeight = lastTop > 0 ? Math.min(Math.max(minScrollHandleSize, barHeight * ((rowCount - lastTop) / rowCount)), barHeight - 1) : 0;
-    var leftColumnWidth = getOrThrow(visibleColumnWidths, left, 0);
-    var topRowHeight = getOrThrow(visibleRowHeights, top, 0);
+    var leftColumnWidth = visibleColumnWidths.get(left);
+    var topRowHeight = visibleRowHeights.get(top);
     var leftOffsetPercent = leftColumnWidth > 0 ? leftOffset / leftColumnWidth : 0;
     var topOffsetPercent = topRowHeight > 0 ? topOffset / topRowHeight : 0;
     var scrollX = lastLeft > 0 ? (left + leftOffsetPercent) / lastLeft * (barWidth - handleWidth) : 0;
-    var scrollY = lastTop > 0 ? (top + topOffsetPercent) / lastTop * (barHeight - handleHeight) : 0; // Now add the floating sections positions
+    var scrollY = lastTop > 0 ? (top + topOffsetPercent) / lastTop * (barHeight - handleHeight) : 0; // Now add the floating sections
 
     var floatingRows = [];
 
     if (floatingTopRowCount > 0 || floatingBottomRowCount > 0) {
       floatingRows = [...Array(floatingTopRowCount).keys(), ...[...Array(floatingBottomRowCount).keys()].map(i => rowCount - i - 1)];
+      visibleRowHeights = new Map([...visibleRowHeights, ...this.getFloatingRowHeights(state)]);
       visibleRowYs = new Map([...visibleRowYs, ...this.getFloatingRowYs(state, visibleRowHeights, Math.floor(height - gridY - horizontalBarHeight))]);
     }
 
@@ -241,6 +186,7 @@ class GridMetricCalculator {
 
     if (floatingLeftColumnCount > 0 || floatingRightColumnCount > 0) {
       floatingColumns = [...Array(floatingLeftColumnCount).keys(), ...[...Array(floatingRightColumnCount).keys()].map(i => columnCount - i - 1)];
+      visibleColumnWidths = new Map([...visibleColumnWidths, ...this.getFloatingColumnWidths(state)]);
       visibleColumnXs = new Map([...visibleColumnXs, ...this.getFloatingColumnXs(state, visibleColumnWidths, Math.floor(width - gridX - verticalBarWidth))]);
     }
 
@@ -250,8 +196,8 @@ class GridMetricCalculator {
     var modelColumns = this.getModelColumns(allColumns, state);
     var visibleRowTreeBoxes = this.getVisibleRowTreeBoxes(visibleRowHeights, modelRows, state); // Calculate the visible viewport based on scroll position and floating sections
 
-    var topVisible = this.getTopVisible(state, visibleRowYs, visibleRowHeights, visibleRows);
-    var leftVisible = this.getLeftVisible(state, visibleColumnXs, visibleColumnWidths, visibleColumns);
+    var topVisible = this.getTopVisible(state, visibleRowYs, visibleRowHeights, visibleRows, gridY);
+    var leftVisible = this.getLeftVisible(state, visibleColumnXs, visibleColumnWidths, visibleColumns, gridX);
     var bottomVisible = lastTop > 0 ? this.getBottomVisible(state, visibleRowYs, visibleRowHeights, visibleRows, gridY) : bottom;
     var rightVisible = lastLeft > 0 ? this.getRightVisible(state, visibleColumnXs, visibleColumnWidths, visibleColumns, gridX) : right;
     var floatingTopHeight = this.getFloatingTopHeight(state, visibleRowHeights);
@@ -358,12 +304,6 @@ class GridMetricCalculator {
       calculatedColumnWidths
     };
   }
-  /**
-   * 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 {
@@ -374,12 +314,6 @@ class GridMetricCalculator {
     } = 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 {
@@ -390,13 +324,6 @@ class GridMetricCalculator {
     } = theme;
     return 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);
@@ -412,13 +339,6 @@ class GridMetricCalculator {
     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);
@@ -435,14 +355,6 @@ class GridMetricCalculator {
     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
@@ -458,33 +370,21 @@ class GridMetricCalculator {
 
     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
-   */
+  /** Get the first column index that isn't 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
-   */
+  /** Get the first row index that isn't 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)
+   * 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
    */
 
 
@@ -519,17 +419,8 @@ class GridMetricCalculator {
     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
-   */
-
-  /**
-   * 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
-   * @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
    */
 
 
@@ -564,15 +455,6 @@ class GridMetricCalculator {
 
     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);
@@ -586,14 +468,6 @@ class GridMetricCalculator {
 
     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 {
@@ -604,14 +478,6 @@ class GridMetricCalculator {
     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);
@@ -625,14 +491,6 @@ class GridMetricCalculator {
 
     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 {
@@ -643,12 +501,6 @@ class GridMetricCalculator {
     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 {
@@ -672,12 +524,6 @@ class GridMetricCalculator {
 
     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 {
@@ -702,14 +548,6 @@ class GridMetricCalculator {
 
     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);
@@ -735,12 +573,6 @@ class GridMetricCalculator {
 
     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);
@@ -767,14 +599,6 @@ class GridMetricCalculator {
 
     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 {
@@ -785,18 +609,8 @@ class GridMetricCalculator {
       floatingLeftColumnCount,
       floatingRightColumnCount
     } = model;
-    return getFloatingCoordinates(floatingLeftColumnCount, floatingRightColumnCount, columnCount, maxX, columnWidthMap);
+    return GridMetricCalculator.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();
@@ -804,21 +618,13 @@ class GridMetricCalculator {
 
     for (var i = 0; i < visibleColumns.length; i += 1) {
       var column = visibleColumns[i];
-      var columnWidth = getOrThrow(visibleColumnWidths, column);
+      var columnWidth = visibleColumnWidths.get(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 {
@@ -829,18 +635,8 @@ class GridMetricCalculator {
       floatingBottomRowCount,
       rowCount
     } = model;
-    return getFloatingCoordinates(floatingTopRowCount, floatingBottomRowCount, rowCount, maxY, rowHeightMap);
+    return GridMetricCalculator.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();
@@ -848,20 +644,14 @@ class GridMetricCalculator {
 
     for (var i = 0; i < visibleRows.length; i += 1) {
       var row = visibleRows[i];
-      var rowHeight = getOrThrow(visibleRowHeights, row);
+      var rowHeight = visibleRowHeights.get(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
-   */
+  /** Calculates the tree box click areas that are visible. In relation to the columnX/rowY */
 
 
   getVisibleRowTreeBoxes(visibleRowHeights, modelRows, state) {
@@ -885,25 +675,13 @@ class GridMetricCalculator {
           var x2 = (depth + 1) * treeDepthIndent + treeHorizontalPadding;
           var y1 = 0;
           var y2 = rowHeight;
-          visibleRowTreeBoxes.set(row, {
-            x1,
-            y1,
-            x2,
-            y2
-          });
+          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);
@@ -916,18 +694,13 @@ class GridMetricCalculator {
     var floatingWidth = 0;
 
     for (var i = 0; i < floatingLeftColumnCount; i += 1) {
-      floatingWidth += getOrThrow(columnWidths, i);
+      var _columnWidths$get;
+
+      floatingWidth += (_columnWidths$get = columnWidths.get(i)) !== null && _columnWidths$get !== void 0 ? _columnWidths$get : 0;
     }
 
     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);
@@ -941,18 +714,13 @@ class GridMetricCalculator {
     var floatingWidth = 0;
 
     for (var i = 0; i < floatingRightColumnCount; i += 1) {
-      floatingWidth += getOrThrow(columnWidths, columnCount - i - 1);
+      var _columnWidths$get2;
+
+      floatingWidth += (_columnWidths$get2 = columnWidths.get(columnCount - i - 1)) !== null && _columnWidths$get2 !== void 0 ? _columnWidths$get2 : 0;
     }
 
     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);
@@ -965,18 +733,13 @@ class GridMetricCalculator {
     var floatingHeight = 0;
 
     for (var i = 0; i < floatingTopRowCount; i += 1) {
-      floatingHeight += getOrThrow(rowHeights, i);
+      var _rowHeights$get;
+
+      floatingHeight += (_rowHeights$get = rowHeights.get(i)) !== null && _rowHeights$get !== void 0 ? _rowHeights$get : 0;
     }
 
     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);
@@ -990,72 +753,41 @@ class GridMetricCalculator {
     var floatingHeight = 0;
 
     for (var i = 0; i < floatingBottomRowCount; i += 1) {
-      floatingHeight += getOrThrow(rowHeights, rowCount - i - 1);
+      var _rowHeights$get2;
+
+      floatingHeight += (_rowHeights$get2 = rowHeights.get(rowCount - i - 1)) !== null && _rowHeights$get2 !== void 0 ? _rowHeights$get2 : 0;
     }
 
     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) {
+      if (visibleRowYs.get(row) >= 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) {
+      if (visibleColumnXs.get(column) >= 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 {
@@ -1070,8 +802,8 @@ class GridMetricCalculator {
 
     for (var i = visibleRows.length - 1; i >= 0; i -= 1) {
       var row = visibleRows[i];
-      var rowY = getOrThrow(visibleRowYs, row);
-      var rowHeight = getOrThrow(visibleRowHeights, row);
+      var rowY = visibleRowYs.get(row);
+      var rowHeight = visibleRowHeights.get(row);
 
       if (rowY + rowHeight <= visibleHeight) {
         return row;
@@ -1080,16 +812,6 @@ class GridMetricCalculator {
 
     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 {
@@ -1104,8 +826,8 @@ class GridMetricCalculator {
 
     for (var i = visibleColumns.length - 1; i >= 0; i -= 1) {
       var column = visibleColumns[i];
-      var columnX = getOrThrow(visibleColumnXs, column);
-      var columnWidth = getOrThrow(visibleColumnWidths, column);
+      var columnX = visibleColumnXs.get(column);
+      var columnWidth = visibleColumnWidths.get(column);
 
       if (columnX + columnWidth <= visibleWidth) {
         return column;
@@ -1114,15 +836,6 @@ class GridMetricCalculator {
 
     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 {
@@ -1134,15 +847,6 @@ class GridMetricCalculator {
     } = 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 {
@@ -1154,16 +858,6 @@ class GridMetricCalculator {
     } = 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;
@@ -1171,7 +865,7 @@ class GridMetricCalculator {
 
     if (items.length > 0) {
       lastIndex = items[items.length - 1];
-      dataSize = getOrThrow(itemXs, lastIndex) + getOrThrow(itemSizes, lastIndex);
+      dataSize = itemXs.get(lastIndex) + itemSizes.get(lastIndex);
     }
 
     if (dataSize < maxSize) {
@@ -1180,41 +874,19 @@ class GridMetricCalculator {
 
     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 calculateSize Method to calculate the size for this item
-   * @returns The size from the provided size map of the specified item
-   */
-
 
   getVisibleItemSize(modelIndex, userSizes, calculateSize) {
-    var _userSizes$get;
+    if (userSizes.has(modelIndex)) {
+      return userSizes.get(modelIndex);
+    }
 
-    return (_userSizes$get = userSizes.get(modelIndex)) !== null && _userSizes$get !== void 0 ? _userSizes$get : calculateSize();
+    return calculateSize();
   }
-  /**
-   * 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);
     return this.getVisibleItemSize(modelRow, this.userRowHeights, () => this.calculateRowHeight(row, modelRow, state));
   }
-  /**
-   * 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);
@@ -1222,13 +894,6 @@ class GridMetricCalculator {
     var modelColumn = this.getModelColumn(column, state);
     return this.getVisibleItemSize(modelColumn, this.userColumnWidths, () => this.calculateColumnWidth(column, modelColumn, state, firstColumn, treePaddingX));
   }
-  /**
-   * 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, state) {
     var modelRows = new Map();
@@ -1241,17 +906,10 @@ class GridMetricCalculator {
 
     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);
+      return this.modelRows.get(visibleRow);
     }
 
     var {
@@ -1261,13 +919,6 @@ class GridMetricCalculator {
     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();
@@ -1280,17 +931,10 @@ class GridMetricCalculator {
 
     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) {
     if (this.modelColumns.has(visibleColumn)) {
-      return getOrThrow(this.modelColumns, visibleColumn);
+      return this.modelColumns.get(visibleColumn);
     }
 
     var {
@@ -1300,14 +944,6 @@ class GridMetricCalculator {
     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 {
@@ -1330,18 +966,10 @@ class GridMetricCalculator {
 
 
     this.calculatedRowHeights.set(modelRow, Math.ceil(rowHeight));
-    trimMap(this.calculatedRowHeights);
+    GridMetricCalculator.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
-   */
+  /** Calculates the column width based on the provided column model index */
 
 
   calculateColumnWidth(column, modelColumn, state) {
@@ -1372,7 +1000,7 @@ class GridMetricCalculator {
       columnWidth = cachedValue;
     } else {
       this.calculatedColumnWidths.set(modelColumn, columnWidth);
-      trimMap(this.calculatedColumnWidths);
+      GridMetricCalculator.trimMap(this.calculatedColumnWidths);
     }
 
     if (column === firstColumn) {
@@ -1381,13 +1009,6 @@ class GridMetricCalculator {
 
     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 {
@@ -1407,13 +1028,6 @@ class GridMetricCalculator {
 
     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 {
@@ -1452,12 +1066,6 @@ class GridMetricCalculator {
     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 {
@@ -1487,18 +1095,12 @@ class GridMetricCalculator {
 
     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
-   */
+  /** Get the width of the provided font. Exploits the fact that we're using tabular figures so every character is same width */
 
 
   getWidthForFont(font, state) {
     if (this.fontWidths.has(font)) {
-      return getOrThrow(this.fontWidths, font);
+      return this.fontWidths.get(font);
     }
 
     var {
@@ -1508,7 +1110,7 @@ class GridMetricCalculator {
     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"'
+    } = textMetrics; // context.font changes the string a little bit, eg. '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);
@@ -1517,56 +1119,55 @@ class GridMetricCalculator {
   }
   /**
    * 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, 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);
+
+    if (size != null) {
+      userColumnWidths.set(column, Math.ceil(size));
+      GridMetricCalculator.trimMap(userColumnWidths);
+    } else {
+      userColumnWidths.delete(column);
+    }
+
     this.userColumnWidths = userColumnWidths;
   }
   /**
    * 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) {
-    // 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;
+    this.setColumnWidth(column, null);
     this.calculatedColumnWidths.delete(column);
   }
   /**
    * 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, 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);
+
+    if (size != null) {
+      userRowHeights.set(row, Math.ceil(size));
+      GridMetricCalculator.trimMap(userRowHeights);
+    } else {
+      userRowHeights.delete(row);
+    }
+
     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.setRowHeight(row, null);
     this.calculatedRowHeights.delete(row);
   }