@deephaven/grid 0.7.0 → 0.7.1-beta.4

package/dist/GridMetricCalculator.js

@@ -1,10 +1,75 @@
 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" */
 
-/* eslint react/destructuring-assignment: "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);
+  }
 
+  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.
@@ -16,67 +81,54 @@ class GridMetricCalculator {
 
   /** The maximum column width as a percentage of the full grid */
 
-  /**
-   * 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 column widths */
 
-    if (map.size > cacheSize) {
-      var iter = map.keys();
+  /** User set row heights */
 
-      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 column widths based on cell contents */
 
+  /** Calculated row heights based on cell contents */
 
-  static getFloatingCoordinates(startCount, endCount, totalCount, max, sizeMap) {
-    var coordinates = new Map();
-    var x = 0;
+  /** Cache of fonts to estimated width of one char */
 
-    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 rows (e.g. reversing movedRows operations) */
 
-    x = max;
+  /** Map from visible index to model index for columns (e.g. reversing movedColumns operations) */
 
-    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 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(),
-      calculatedRowHeights = new Map(),
       calculatedColumnWidths = new Map(),
+      calculatedRowHeights = new Map(),
       fontWidths = new Map(),
       modelRows = new Map(),
       modelColumns = new Map(),
-      movedRows = null,
-      movedColumns = null
+      movedRows = [],
+      movedColumns = []
     } = 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;
@@ -88,7 +140,11 @@ class GridMetricCalculator {
     this.movedRows = movedRows;
     this.movedColumns = movedColumns;
   }
-  /** update the calculated metrics from the model/canvas that are useful for many functions */
+  /**
+   * Get the metrics for the provided metric state
+   * @params state The state to get metrics for
+   * @returns The full metrics
+   */
 
 
   getMetrics(state) {
@@ -144,7 +200,11 @@ class GridMetricCalculator {
     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());
+    var visibleColumns = Array.from(visibleColumnWidths.keys()); // Add the floating row heights/column widths
+    // TODO #316: Create an allRowHeights/allColumnWidths maps
+
+    visibleRowHeights = new Map([...visibleRowHeights, ...this.getFloatingRowHeights(state)]);
+    visibleColumnWidths = new Map([...visibleColumnWidths, ...this.getFloatingColumnWidths(state)]);
     var visibleColumnXs = this.getVisibleColumnXs(visibleColumnWidths, visibleColumns, leftOffset);
     var visibleRowYs = this.getVisibleRowYs(visibleRowHeights, visibleRows, topOffset);
     var bottom = visibleRows.length > 0 ? visibleRows[visibleRows.length - 1] : top;
@@ -167,18 +227,17 @@ 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 = visibleColumnWidths.get(left);
-    var topRowHeight = visibleRowHeights.get(top);
+    var leftColumnWidth = getOrThrow(visibleColumnWidths, left, 0);
+    var topRowHeight = getOrThrow(visibleRowHeights, top, 0);
     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
+    var scrollY = lastTop > 0 ? (top + topOffsetPercent) / lastTop * (barHeight - handleHeight) : 0; // Now add the floating sections positions
 
     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))]);
     }
 
@@ -186,7 +245,6 @@ 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))]);
     }
 
@@ -196,8 +254,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, gridY);
-    var leftVisible = this.getLeftVisible(state, visibleColumnXs, visibleColumnWidths, visibleColumns, gridX);
+    var topVisible = this.getTopVisible(state, visibleRowYs, visibleRowHeights, visibleRows);
+    var leftVisible = this.getLeftVisible(state, visibleColumnXs, visibleColumnWidths, visibleColumns);
     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);
@@ -279,6 +337,7 @@ class GridMetricCalculator {
       allRows,
       allColumns,
       // Map of the height/width of visible rows/columns
+      // TODO #316: This should be split into allRowHeights/visibleRowHeights/floatingRowHeights ideally
       visibleRowHeights,
       visibleColumnWidths,
       // Floating metrics
@@ -304,6 +363,12 @@ 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 {
@@ -314,6 +379,12 @@ 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 {
@@ -324,6 +395,13 @@ 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);
@@ -339,6 +417,13 @@ 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);
@@ -355,6 +440,14 @@ 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
@@ -370,21 +463,33 @@ class GridMetricCalculator {
 
     return 0;
   }
-  /** Get the first column index that isn't hidden */
+  /**
+   * 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 */
+  /**
+   * 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 (eg. scrolled to the right)
+   * 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
    */
 
 
@@ -419,10 +524,19 @@ class GridMetricCalculator {
     return 0;
   }
   /**
-   * The last row that can be the top row (eg. scrolled to the bottom)
+   * 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)
+   * If no bottom row is provided, then the last row that is not floating is used
+   * @param state The current grid state
+   * @param bottom The bottom-most row to be visible, or null to default to last cell
+   * @param visibleHeight The height of the "visible" area (excluding floating items)
+   * @returns The index of the last left visible column
+   */
+
 
   getLastTop(state) {
     var bottom = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
@@ -455,6 +569,15 @@ 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);
@@ -468,6 +591,14 @@ 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 {
@@ -478,6 +609,14 @@ 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);
@@ -491,6 +630,14 @@ 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 {
@@ -501,6 +648,12 @@ 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 {
@@ -524,6 +677,12 @@ 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 {
@@ -548,6 +707,14 @@ 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);
@@ -573,6 +740,12 @@ 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);
@@ -599,6 +772,14 @@ 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 {
@@ -609,8 +790,18 @@ class GridMetricCalculator {
       floatingLeftColumnCount,
       floatingRightColumnCount
     } = model;
-    return GridMetricCalculator.getFloatingCoordinates(floatingLeftColumnCount, floatingRightColumnCount, columnCount, maxX, columnWidthMap);
+    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();
@@ -618,13 +809,21 @@ class GridMetricCalculator {
 
     for (var i = 0; i < visibleColumns.length; i += 1) {
       var column = visibleColumns[i];
-      var columnWidth = visibleColumnWidths.get(column);
+      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 {
@@ -635,8 +834,18 @@ class GridMetricCalculator {
       floatingBottomRowCount,
       rowCount
     } = model;
-    return GridMetricCalculator.getFloatingCoordinates(floatingTopRowCount, floatingBottomRowCount, rowCount, maxY, rowHeightMap);
+    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();
@@ -644,14 +853,20 @@ class GridMetricCalculator {
 
     for (var i = 0; i < visibleRows.length; i += 1) {
       var row = visibleRows[i];
-      var rowHeight = visibleRowHeights.get(row);
+      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 */
+  /**
+   * 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) {
@@ -675,13 +890,25 @@ 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);
@@ -694,13 +921,18 @@ class GridMetricCalculator {
     var floatingWidth = 0;
 
     for (var i = 0; i < floatingLeftColumnCount; i += 1) {
-      var _columnWidths$get;
-
-      floatingWidth += (_columnWidths$get = columnWidths.get(i)) !== null && _columnWidths$get !== void 0 ? _columnWidths$get : 0;
+      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);
@@ -714,13 +946,18 @@ class GridMetricCalculator {
     var floatingWidth = 0;
 
     for (var i = 0; i < floatingRightColumnCount; i += 1) {
-      var _columnWidths$get2;
-
-      floatingWidth += (_columnWidths$get2 = columnWidths.get(columnCount - i - 1)) !== null && _columnWidths$get2 !== void 0 ? _columnWidths$get2 : 0;
+      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);
@@ -733,13 +970,18 @@ class GridMetricCalculator {
     var floatingHeight = 0;
 
     for (var i = 0; i < floatingTopRowCount; i += 1) {
-      var _rowHeights$get;
-
-      floatingHeight += (_rowHeights$get = rowHeights.get(i)) !== null && _rowHeights$get !== void 0 ? _rowHeights$get : 0;
+      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);
@@ -753,41 +995,72 @@ class GridMetricCalculator {
     var floatingHeight = 0;
 
     for (var i = 0; i < floatingBottomRowCount; i += 1) {
-      var _rowHeights$get2;
-
-      floatingHeight += (_rowHeights$get2 = rowHeights.get(rowCount - i - 1)) !== null && _rowHeights$get2 !== void 0 ? _rowHeights$get2 : 0;
+      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 (visibleRowYs.get(row) >= floatingHeight) {
+      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 (visibleColumnXs.get(column) >= floatingWidth) {
+      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 {
@@ -802,8 +1075,8 @@ class GridMetricCalculator {
 
     for (var i = visibleRows.length - 1; i >= 0; i -= 1) {
       var row = visibleRows[i];
-      var rowY = visibleRowYs.get(row);
-      var rowHeight = visibleRowHeights.get(row);
+      var rowY = getOrThrow(visibleRowYs, row);
+      var rowHeight = getOrThrow(visibleRowHeights, row);
 
       if (rowY + rowHeight <= visibleHeight) {
         return row;
@@ -812,6 +1085,16 @@ 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 {
@@ -826,8 +1109,8 @@ class GridMetricCalculator {
 
     for (var i = visibleColumns.length - 1; i >= 0; i -= 1) {
       var column = visibleColumns[i];
-      var columnX = visibleColumnXs.get(column);
-      var columnWidth = visibleColumnWidths.get(column);
+      var columnX = getOrThrow(visibleColumnXs, column);
+      var columnWidth = getOrThrow(visibleColumnWidths, column);
 
       if (columnX + columnWidth <= visibleWidth) {
         return column;
@@ -836,6 +1119,15 @@ 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 {
@@ -847,6 +1139,15 @@ 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 {
@@ -858,6 +1159,16 @@ 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;
@@ -865,7 +1176,7 @@ class GridMetricCalculator {
 
     if (items.length > 0) {
       lastIndex = items[items.length - 1];
-      dataSize = itemXs.get(lastIndex) + itemSizes.get(lastIndex);
+      dataSize = getOrThrow(itemXs, lastIndex) + getOrThrow(itemSizes, lastIndex);
     }
 
     if (dataSize < maxSize) {
@@ -874,19 +1185,41 @@ 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) {
-    if (userSizes.has(modelIndex)) {
-      return userSizes.get(modelIndex);
-    }
+    var _userSizes$get;
 
-    return calculateSize();
+    return (_userSizes$get = userSizes.get(modelIndex)) !== null && _userSizes$get !== void 0 ? _userSizes$get : 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);
@@ -894,6 +1227,13 @@ 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();
@@ -906,10 +1246,17 @@ 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 this.modelRows.get(visibleRow);
+      return getOrThrow(this.modelRows, visibleRow);
     }
 
     var {
@@ -919,6 +1266,13 @@ 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();
@@ -931,10 +1285,17 @@ 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 this.modelColumns.get(visibleColumn);
+      return getOrThrow(this.modelColumns, visibleColumn);
     }
 
     var {
@@ -944,6 +1305,14 @@ 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 {
@@ -966,10 +1335,18 @@ class GridMetricCalculator {
 
 
     this.calculatedRowHeights.set(modelRow, Math.ceil(rowHeight));
-    GridMetricCalculator.trimMap(this.calculatedRowHeights);
+    trimMap(this.calculatedRowHeights);
     return rowHeight;
   }
-  /** Calculates the column width based on the provided column model index */
+  /**
+   * 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) {
@@ -1000,7 +1377,7 @@ class GridMetricCalculator {
       columnWidth = cachedValue;
     } else {
       this.calculatedColumnWidths.set(modelColumn, columnWidth);
-      GridMetricCalculator.trimMap(this.calculatedColumnWidths);
+      trimMap(this.calculatedColumnWidths);
     }
 
     if (column === firstColumn) {
@@ -1009,6 +1386,13 @@ 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 {
@@ -1028,6 +1412,13 @@ 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 {
@@ -1066,6 +1457,12 @@ 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 {
@@ -1095,12 +1492,18 @@ 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 */
+  /**
+   * 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 this.fontWidths.get(font);
+      return getOrThrow(this.fontWidths, font);
     }
 
     var {
@@ -1110,7 +1513,7 @@ class GridMetricCalculator {
     var textMetrics = context.measureText('8');
     var {
       width
-    } = textMetrics; // context.font changes the string a little bit, eg. '10px Arial, sans serif' => '10px Arial, "sans serif"'
+    } = 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);
@@ -1119,55 +1522,56 @@ class GridMetricCalculator {
   }
   /**
    * Sets the width for the specified column
-   * @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
+   * @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);
-
-    if (size != null) {
-      userColumnWidths.set(column, Math.ceil(size));
-      GridMetricCalculator.trimMap(userColumnWidths);
-    } else {
-      userColumnWidths.delete(column);
-    }
-
+    userColumnWidths.set(column, Math.ceil(size));
+    trimMap(userColumnWidths);
     this.userColumnWidths = userColumnWidths;
   }
   /**
    * Resets the column width for the specified column to the calculated width
-   * @param {Number} column The column model index to reset
+   * @param column The column model index to reset
    */
 
 
   resetColumnWidth(column) {
-    this.setColumnWidth(column, null);
+    // 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.calculatedColumnWidths.delete(column);
   }
   /**
    * Sets the width for the specified row
-   * @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
+   * @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);
-
-    if (size != null) {
-      userRowHeights.set(row, Math.ceil(size));
-      GridMetricCalculator.trimMap(userRowHeights);
-    } else {
-      userRowHeights.delete(row);
-    }
-
+    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) {
-    this.setRowHeight(row, null);
+    // 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);
   }