@deephaven/grid 0.22.3-beta.18 → 0.22.3-beta.21

package/dist/GridMetricCalculator.js

@@ -1,9 +1,7 @@
 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 clamp from 'lodash.clamp';
 import GridUtils from "./GridUtils.js";
 import { isExpandableGridModel } from "./ExpandableGridModel.js";
-
 /**
  * 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
@@ -14,16 +12,14 @@ import { isExpandableGridModel } from "./ExpandableGridModel.js";
  */
 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.
@@ -31,19 +27,17 @@ export function getOrThrow(map, key) {
  * @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.
@@ -53,31 +47,26 @@ export function trimMap(map) {
  * @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 */
 
@@ -100,6 +89,7 @@ export class GridMetricCalculator {
   /** 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(),
@@ -112,43 +102,33 @@ export class GridMetricCalculator {
       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;
     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.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;
   }
+
   /**
    * Get the metrics for the provided metric state
    * @params state The state to get metrics for
    * @returns The full metrics
    */
-
-
   getMetrics(state) {
     var {
       left,
@@ -172,17 +152,14 @@ export class GridMetricCalculator {
       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,
@@ -191,8 +168,9 @@ export class GridMetricCalculator {
       floatingLeftColumnCount,
       floatingRightColumnCount,
       columnHeaderMaxDepth
-    } = model; // Get some basic metrics
+    } = model;
 
+    // Get some basic metrics
     var firstRow = this.getFirstRow(state);
     var firstColumn = this.getFirstColumn(state);
     var gridX = this.getGridX(state);
@@ -201,12 +179,14 @@ export class GridMetricCalculator {
     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 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
-    // TODO #316: Create an allRowHeights/allColumnWidths maps
+    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);
@@ -224,14 +204,17 @@ export class GridMetricCalculator {
     var maxX = columnWidthValues.reduce((x, w) => x + w, 0) - leftOffset;
     var maxY = rowHeightValues.reduce((y, h) => y + h, 0) - topOffset;
     var lastLeft = this.getLastLeft(state, null, width - gridX - scrollBarSize - rowFooterWidth);
-    var lastTop = this.getLastTop(state, null, height - gridY - scrollBarSize - floatingBottomHeight); // How much total space the content will take
+    var lastTop = this.getLastTop(state, null, height - gridY - scrollBarSize - floatingBottomHeight);
 
+    // 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 scrollableContentHeight = topOffset + maxY;
 
+    // Visible space available in the canvas viewport
     var scrollableViewportWidth = width - gridX;
-    var scrollableViewportHeight = height - gridY; // Calculate some metrics for the scroll bars
+    var scrollableViewportHeight = height - gridY;
 
+    // Calculate some metrics for the scroll bars
     var hasHorizontalBar = lastLeft > 0 || scrollableContentWidth > scrollableViewportWidth;
     var horizontalBarHeight = hasHorizontalBar ? scrollBarSize : 0;
     var hasVerticalBar = lastTop > 0 || scrollableContentHeight > scrollableViewportHeight - horizontalBarHeight;
@@ -239,8 +222,9 @@ export class GridMetricCalculator {
     var barWidth = width - rowHeaderWidth - verticalBarWidth;
     var barHeight = height - columnHeaderHeight - horizontalBarHeight;
     var barLeft = rowHeaderWidth;
-    var barTop = columnHeaderHeight; // How big the scroll handle is relative to the bar
+    var barTop = columnHeaderHeight;
 
+    // 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;
@@ -248,49 +232,44 @@ export class GridMetricCalculator {
     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; // How much of the available space has been scrolled
+    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 scrollY = hasVerticalBar ? verticalScrollPercent * (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)];
       visibleRowYs = new Map([...visibleRowYs, ...this.getFloatingRowYs(state, visibleRowHeights, Math.floor(height - gridY - horizontalBarHeight))]);
     }
-
     var floatingColumns = [];
-
     if (floatingLeftColumnCount > 0 || floatingRightColumnCount > 0) {
       floatingColumns = [...Array(floatingLeftColumnCount).keys(), ...[...Array(floatingRightColumnCount).keys()].map(i => columnCount - i - 1)];
       visibleColumnXs = new Map([...visibleColumnXs, ...this.getFloatingColumnXs(state, visibleColumnWidths, 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 (!visibleColumnWidths.has(i)) {
           visibleColumnWidths.set(i, this.getVisibleColumnWidth(i, state));
         }
-
         if (!visibleColumnXs.has(i)) {
           visibleColumnXs.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(visibleRowHeights, modelRows, state); // Calculate the visible viewport based on scroll position and floating sections
+    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 bottomVisible = lastTop > 0 ? this.getBottomVisible(state, visibleRowYs, visibleRowHeights, visibleRows, gridY) : bottom;
@@ -406,13 +385,12 @@ export class GridMetricCalculator {
       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
@@ -422,13 +400,12 @@ export 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 {
       theme,
@@ -442,14 +419,13 @@ export class GridMetricCalculator {
     } = 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 {
@@ -464,14 +440,13 @@ export 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);
     var {
@@ -487,6 +462,7 @@ export 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
@@ -494,42 +470,36 @@ export class GridMetricCalculator {
    * @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.
@@ -538,8 +508,6 @@ export class GridMetricCalculator {
    * @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
@@ -549,26 +517,21 @@ export class GridMetricCalculator {
       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 Math.min(lastLeft + 1, 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
@@ -577,8 +540,6 @@ export class GridMetricCalculator {
    * @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
@@ -588,26 +549,21 @@ export class GridMetricCalculator {
       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 Math.min(lastTop + 1, 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.
@@ -616,20 +572,17 @@ export class GridMetricCalculator {
    * @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.
@@ -637,8 +590,6 @@ export class GridMetricCalculator {
    * @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
@@ -648,6 +599,7 @@ export 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.
@@ -655,20 +607,17 @@ export class GridMetricCalculator {
    * @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.
@@ -676,8 +625,6 @@ export class GridMetricCalculator {
    * @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
@@ -687,13 +634,12 @@ export 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 {
       model
@@ -704,25 +650,21 @@ export class GridMetricCalculator {
       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,
@@ -736,16 +678,15 @@ export class GridMetricCalculator {
     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
@@ -753,8 +694,6 @@ export class GridMetricCalculator {
    * @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);
@@ -767,25 +706,21 @@ export class GridMetricCalculator {
       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);
@@ -801,16 +736,15 @@ export class GridMetricCalculator {
     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
@@ -818,8 +752,6 @@ export class GridMetricCalculator {
    * @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
@@ -831,6 +763,7 @@ export class GridMetricCalculator {
     } = 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
@@ -840,21 +773,18 @@ export class GridMetricCalculator {
    * @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
@@ -862,8 +792,6 @@ export class GridMetricCalculator {
    * @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
@@ -875,6 +803,7 @@ export class GridMetricCalculator {
     } = 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
@@ -884,21 +813,18 @@ export class GridMetricCalculator {
    * @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
@@ -906,8 +832,6 @@ export class GridMetricCalculator {
    * @param state The grid metric state
    * @returns Coordinates of tree boxes for each row
    */
-
-
   getVisibleRowTreeBoxes(visibleRowHeights, modelRows, state) {
     var visibleRowTreeBoxes = new Map();
     var {
@@ -918,11 +842,9 @@ export class GridMetricCalculator {
       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;
@@ -938,17 +860,15 @@ export class GridMetricCalculator {
         }
       });
     }
-
     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 {
@@ -958,21 +878,18 @@ export class GridMetricCalculator {
       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 {
@@ -983,21 +900,18 @@ export class GridMetricCalculator {
       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 {
@@ -1007,21 +921,18 @@ export class GridMetricCalculator {
       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 {
@@ -1032,13 +943,12 @@ export class GridMetricCalculator {
       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.
@@ -1048,22 +958,18 @@ export class GridMetricCalculator {
    * @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.
@@ -1073,22 +979,18 @@ export class GridMetricCalculator {
    * @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.
@@ -1099,8 +1001,6 @@ export class GridMetricCalculator {
    * @param gridY The starting y coordinate of the grid
    * @returns Index of the bottom visible row
    */
-
-
   getBottomVisible(state, visibleRowYs, visibleRowHeights, visibleRows, gridY) {
     var {
       height,
@@ -1111,19 +1011,17 @@ export class GridMetricCalculator {
     } = 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.
@@ -1133,8 +1031,6 @@ export class GridMetricCalculator {
    * @param visibleColumns Array of visible column indexes
    * @returns Index of the right visible column
    */
-
-
   getRightVisible(state, visibleColumnXs, visibleColumnWidths, visibleColumns, gridX) {
     var {
       width,
@@ -1145,19 +1041,17 @@ export class GridMetricCalculator {
     } = 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
@@ -1166,8 +1060,6 @@ export class GridMetricCalculator {
    * @param visibleRowHeights Map of row index to height
    * @returns The index of the bottom viewport possible
    */
-
-
   getBottomViewport(state, visibleRows, visibleRowYs, visibleRowHeights) {
     var {
       height,
@@ -1178,6 +1070,7 @@ export 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
@@ -1186,8 +1079,6 @@ export class GridMetricCalculator {
    * @param visibleColumnWidths Map of column index to width
    * @returns The index of the right viewport possible
    */
-
-
   getRightViewport(state, visibleColumns, visibleColumnXs, visibleColumnWidths) {
     var {
       width,
@@ -1198,6 +1089,7 @@ export 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
@@ -1207,23 +1099,19 @@ export class GridMetricCalculator {
    * @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
@@ -1231,27 +1119,24 @@ export class GridMetricCalculator {
    * @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;
-
     // Always re-calculate the size of the item so the calculated size maps are populated
     var calculatedSize = calculateSize();
     return (_userSizes$get = userSizes.get(modelIndex)) !== null && _userSizes$get !== void 0 ? _userSizes$get : calculatedSize;
   }
+
   /**
    * 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
@@ -1260,46 +1145,39 @@ export class GridMetricCalculator {
    * @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);
     return this.getVisibleItemSize(modelColumn, this.userColumnWidths, () => this.calculateColumnWidth(column, modelColumn, state, firstColumn, treePaddingX));
   }
+
   /**
    * 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;
@@ -1307,40 +1185,34 @@ export 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();
-
     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;
@@ -1348,6 +1220,7 @@ export 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
@@ -1355,8 +1228,6 @@ export class GridMetricCalculator {
    * @param state The grid metric state
    * @returns The height of the row
    */
-
-
   calculateRowHeight(row, modelRow, state) {
     var {
       theme
@@ -1365,22 +1236,20 @@ export class GridMetricCalculator {
       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.
-
+    }
 
+    // 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
@@ -1390,8 +1259,6 @@ export class GridMetricCalculator {
    * @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);
@@ -1402,41 +1269,35 @@ export class GridMetricCalculator {
       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,
@@ -1447,22 +1308,19 @@ export class GridMetricCalculator {
       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,
@@ -1491,7 +1349,6 @@ export class GridMetricCalculator {
     GridUtils.iterateAllItems(top, bottom, floatingTopRowCount, floatingBottomRowCount, rowCount, row => {
       var modelRow = this.getModelRow(row, state);
       var text = model.textForCell(modelColumn, modelRow);
-
       if (text) {
         var cellPadding = cellHorizontalPadding * 2;
         columnWidth = Math.max(columnWidth, text.length * fontWidth + cellPadding);
@@ -1500,13 +1357,12 @@ export 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 {
       top,
@@ -1518,23 +1374,20 @@ export class GridMetricCalculator {
       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
@@ -1542,13 +1395,10 @@ export class GridMetricCalculator {
    * @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;
@@ -1556,20 +1406,20 @@ export 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"'
-    // Rather than require checking with the correct font def (theme, or context font), just key it to both
+    } = 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);
@@ -1577,25 +1427,23 @@ export class GridMetricCalculator {
     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);
@@ -1603,12 +1451,11 @@ export class GridMetricCalculator {
     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);
@@ -1616,12 +1463,8 @@ export class GridMetricCalculator {
     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