@deephaven/grid 0.5.2-beta.0 → 0.6.1-demo.10

package/dist/GridUtils.js

@@ -1,837 +1,799 @@
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
 
-function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+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; }
 
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+import GridRange from "./GridRange.js";
+
+class GridUtils {
+  // use same constant as chrome source for windows
+  // https://github.com/chromium/chromium/blob/973af9d461b6b5dc60208c8d3d66adc27e53da78/ui/events/blink/web_input_event_builders_win.cc#L285
+  static getGridPointFromXY(x, y, metrics) {
+    var column = GridUtils.getColumnAtX(x, metrics);
+    var row = GridUtils.getRowAtY(y, metrics);
+    return {
+      x,
+      y,
+      row,
+      column
+    };
+  }
 
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+  static iterateFloatingStart(start, total, callback) {
+    for (var i = 0; i < start && i < total; i += 1) {
+      var result = callback(i);
 
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+      if (result !== undefined) {
+        return result;
+      }
+    }
 
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+    return undefined;
+  }
+  /**
+   * Iterate through floating items at the end. Iterates in increasing order.
+   */
 
-function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
 
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+  static iterateFloatingEnd(end, total, callback) {
+    for (var i = 0; i < end && total - (end - i) >= 0; i += 1) {
+      var result = callback(total - (end - i));
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+      if (result !== undefined) {
+        return result;
+      }
+    }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+    return undefined;
+  }
+  /**
+   * Iterate through all floating items in increasing order, starting with the top items.
+   * @param {number} start Count of start floating rows, eg. floatingTopRowCount
+   * @param {number} end Count of end floating rows, eg. floatingBottomRowCount
+   * @param {number} total Total number of items
+   * @param {(itemIndex:number) => any | undefined} callback Callback called for each value, stopping the iterating and returning the value if one is returned
+   */
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+  static iterateFloating(start, end, total, callback) {
+    var result = GridUtils.iterateFloatingStart(start, total, callback);
 
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+    if (result !== undefined) {
+      return result;
+    }
 
-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; }
+    return GridUtils.iterateFloatingEnd(end, total, callback);
+  }
 
-import GridRange from './GridRange';
-
-var GridUtils = /*#__PURE__*/function () {
-  function GridUtils() {
-    _classCallCheck(this, GridUtils);
-  }
-
-  _createClass(GridUtils, null, [{
-    key: "getGridPointFromXY",
-    value: // use same constant as chrome source for windows
-    // https://github.com/chromium/chromium/blob/973af9d461b6b5dc60208c8d3d66adc27e53da78/ui/events/blink/web_input_event_builders_win.cc#L285
-    function getGridPointFromXY(x, y, metrics) {
-      var column = GridUtils.getColumnAtX(x, metrics);
-      var row = GridUtils.getRowAtY(y, metrics);
-      return {
-        x: x,
-        y: y,
-        row: row,
-        column: column
-      };
-    }
-  }, {
-    key: "iterateFloatingStart",
-    value: function iterateFloatingStart(start, total, callback) {
-      for (var i = 0; i < start && i < total; i += 1) {
-        var result = callback(i);
-
-        if (result !== undefined) {
-          return result;
-        }
-      }
+  static iterateAllItems(visibleStart, visibleEnd, floatingStartCount, floatingEndCount, totalCount, callback) {
+    var visibleStartIndex = Math.max(visibleStart, floatingStartCount);
+    var visibleEndIndex = Math.min(visibleEnd, totalCount - floatingEndCount - 1);
+    var result = GridUtils.iterateFloating(floatingStartCount, floatingEndCount, totalCount, callback);
 
-      return undefined;
+    if (result !== undefined) {
+      return result;
     }
-    /**
-     * Iterate through floating items at the end. Iterates in increasing order.
-     */
-
-  }, {
-    key: "iterateFloatingEnd",
-    value: function iterateFloatingEnd(end, total, callback) {
-      for (var i = 0; i < end && total - (end - i) >= 0; i += 1) {
-        var result = callback(total - (end - i));
-
-        if (result !== undefined) {
-          return result;
-        }
-      }
 
-      return undefined;
-    }
-    /**
-     * Iterate through all floating items in increasing order, starting with the top items.
-     * @param {number} start Count of start floating rows, eg. floatingTopRowCount
-     * @param {number} end Count of end floating rows, eg. floatingBottomRowCount
-     * @param {number} total Total number of items
-     * @param {(itemIndex:number) => any | undefined} callback Callback called for each value, stopping the iterating and returning the value if one is returned
-     */
-
-  }, {
-    key: "iterateFloating",
-    value: function iterateFloating(start, end, total, callback) {
-      var result = GridUtils.iterateFloatingStart(start, total, callback);
+    for (var i = visibleStartIndex; i <= visibleEndIndex; i += 1) {
+      result = callback(i);
 
       if (result !== undefined) {
         return result;
       }
-
-      return GridUtils.iterateFloatingEnd(end, total, callback);
     }
-  }, {
-    key: "iterateAllItems",
-    value: function iterateAllItems(visibleStart, visibleEnd, floatingStartCount, floatingEndCount, totalCount, callback) {
-      var visibleStartIndex = Math.max(visibleStart, floatingStartCount);
-      var visibleEndIndex = Math.min(visibleEnd, totalCount - floatingEndCount - 1);
-      var result = GridUtils.iterateFloating(floatingStartCount, floatingEndCount, totalCount, callback);
 
-      if (result !== undefined) {
-        return result;
-      }
+    return undefined;
+  }
 
-      for (var i = visibleStartIndex; i <= visibleEndIndex; i += 1) {
-        result = callback(i);
+  static isInItem(itemIndex, itemXs, itemSizes, x) {
+    var itemX = itemXs.get(itemIndex);
+    var itemSize = itemSizes.get(itemIndex);
+    return itemX <= x && x <= itemX + itemSize;
+  }
 
-        if (result !== undefined) {
-          return result;
-        }
+  static getItemAtOffset(offset, itemCount, floatingStart, floatingEnd, items, itemXs, itemSizes) {
+    var floatingItem = GridUtils.iterateFloating(floatingStart, floatingEnd, itemCount, item => {
+      if (GridUtils.isInItem(item, itemXs, itemSizes, offset)) {
+        return item;
       }
 
       return undefined;
+    });
+
+    if (floatingItem !== undefined) {
+      return floatingItem;
     }
-  }, {
-    key: "isInItem",
-    value: function isInItem(itemIndex, itemXs, itemSizes, x) {
-      var itemX = itemXs.get(itemIndex);
-      var itemSize = itemSizes.get(itemIndex);
-      return itemX <= x && x <= itemX + itemSize;
-    }
-  }, {
-    key: "getItemAtOffset",
-    value: function getItemAtOffset(offset, itemCount, floatingStart, floatingEnd, items, itemXs, itemSizes) {
-      var floatingItem = GridUtils.iterateFloating(floatingStart, floatingEnd, itemCount, function (item) {
-        if (GridUtils.isInItem(item, itemXs, itemSizes, offset)) {
-          return item;
-        }
 
-        return undefined;
-      });
+    for (var i = 0; i < items.length; i += 1) {
+      var item = items[i];
 
-      if (floatingItem !== undefined) {
-        return floatingItem;
+      if (GridUtils.isInItem(item, itemXs, itemSizes, offset)) {
+        return item;
       }
+    }
 
-      for (var i = 0; i < items.length; i += 1) {
-        var item = items[i];
-
-        if (GridUtils.isInItem(item, itemXs, itemSizes, offset)) {
-          return item;
-        }
-      }
+    return null;
+  }
 
+  static getColumnAtX(x, metrics) {
+    var {
+      columnCount,
+      floatingLeftColumnCount,
+      floatingRightColumnCount,
+      visibleColumns,
+      visibleColumnXs,
+      visibleColumnWidths,
+      gridX
+    } = metrics;
+
+    if (x < gridX) {
       return null;
     }
-  }, {
-    key: "getColumnAtX",
-    value: function getColumnAtX(x, metrics) {
-      var columnCount = metrics.columnCount,
-          floatingLeftColumnCount = metrics.floatingLeftColumnCount,
-          floatingRightColumnCount = metrics.floatingRightColumnCount,
-          visibleColumns = metrics.visibleColumns,
-          visibleColumnXs = metrics.visibleColumnXs,
-          visibleColumnWidths = metrics.visibleColumnWidths,
-          gridX = metrics.gridX;
-
-      if (x < gridX) {
-        return null;
-      }
 
-      return this.getItemAtOffset(x - gridX, columnCount, floatingLeftColumnCount, floatingRightColumnCount, visibleColumns, visibleColumnXs, visibleColumnWidths);
-    }
-  }, {
-    key: "getRowAtY",
-    value: function getRowAtY(y, metrics) {
-      var floatingTopRowCount = metrics.floatingTopRowCount,
-          floatingBottomRowCount = metrics.floatingBottomRowCount,
-          rowCount = metrics.rowCount,
-          visibleRows = metrics.visibleRows,
-          visibleRowYs = metrics.visibleRowYs,
-          visibleRowHeights = metrics.visibleRowHeights,
-          gridY = metrics.gridY;
-
-      if (y < gridY) {
-        return null;
-      }
+    return this.getItemAtOffset(x - gridX, columnCount, floatingLeftColumnCount, floatingRightColumnCount, visibleColumns, visibleColumnXs, visibleColumnWidths);
+  }
 
-      return this.getItemAtOffset(y - gridY, rowCount, floatingTopRowCount, floatingBottomRowCount, visibleRows, visibleRowYs, visibleRowHeights);
+  static getRowAtY(y, metrics) {
+    var {
+      floatingTopRowCount,
+      floatingBottomRowCount,
+      rowCount,
+      visibleRows,
+      visibleRowYs,
+      visibleRowHeights,
+      gridY
+    } = metrics;
+
+    if (y < gridY) {
+      return null;
     }
-    /**
-     * Iterate backward through the visible items until a shown item is hit
-     * @param {Number} startIndex The index to start from
-     * @param {Map} modelIndexes The mapping of model indexes
-     * @param {Number[]} visibleItems The visible items
-     * @param {Map} userSizes The user set sizes
-     */
-
-  }, {
-    key: "getNextShownItem",
-    value: function getNextShownItem(startIndex, modelIndexes, visibleItems, userSizes) {
-      var visibleItemIndex = visibleItems.findIndex(function (value) {
-        return value === startIndex;
-      }) || 0;
-      visibleItemIndex -= 1;
 
-      while (visibleItemIndex != null && visibleItemIndex >= 0) {
-        var item = visibleItems[visibleItemIndex];
-        var modelIndex = modelIndexes.get(item);
+    return this.getItemAtOffset(y - gridY, rowCount, floatingTopRowCount, floatingBottomRowCount, visibleRows, visibleRowYs, visibleRowHeights);
+  }
+  /**
+   * Iterate backward through the visible items until a shown item is hit
+   * @param {Number} startIndex The index to start from
+   * @param {Map} modelIndexes The mapping of model indexes
+   * @param {Number[]} visibleItems The visible items
+   * @param {Map} userSizes The user set sizes
+   */
+
 
-        if (userSizes.get(modelIndex) !== 0) {
-          return item;
-        }
+  static getNextShownItem(startIndex, modelIndexes, visibleItems, userSizes) {
+    var visibleItemIndex = visibleItems.findIndex(value => value === startIndex) || 0;
+    visibleItemIndex -= 1;
+
+    while (visibleItemIndex != null && visibleItemIndex >= 0) {
+      var item = visibleItems[visibleItemIndex];
+      var modelIndex = modelIndexes.get(item);
 
-        visibleItemIndex -= 1;
+      if (userSizes.get(modelIndex) !== 0) {
+        return item;
       }
 
-      return null;
-    }
-    /**
-     * Iterate backward through the visible columns until a shown column is hit
-     * @param {Number} columnIndex The column index to start iterating backward from
-     * @param {GridMetrics} metrics The GridMetricCalculator metrics
-     */
-
-  }, {
-    key: "getNextShownColumn",
-    value: function getNextShownColumn(startIndex, metrics) {
-      var modelColumns = metrics.modelColumns,
-          visibleColumns = metrics.visibleColumns,
-          userColumnWidths = metrics.userColumnWidths;
-      return GridUtils.getNextShownItem(startIndex, modelColumns, visibleColumns, userColumnWidths);
+      visibleItemIndex -= 1;
     }
-    /**
-     * Iterate backward through the visible rows until a shown row is hit
-     * @param {Number} rowIndex The row index to start iterating backward from
-     * @param {GridMetrics} metrics The GridMetricCalculator metrics
-     */
-
-  }, {
-    key: "getNextShownRow",
-    value: function getNextShownRow(startIndex, metrics) {
-      var modelRows = metrics.modelRows,
-          visibleRows = metrics.visibleRows,
-          userRowHeights = metrics.userRowHeights;
-      return GridUtils.getNextShownItem(startIndex, modelRows, visibleRows, userRowHeights);
-    } // Returns the column index if the x/y coordinates provided are close enough to the separator, otherwise false
-
-  }, {
-    key: "getColumnSeparatorIndex",
-    value: function getColumnSeparatorIndex(x, y, metrics, theme) {
-      var rowHeaderWidth = metrics.rowHeaderWidth,
-          columnHeaderHeight = metrics.columnHeaderHeight,
-          visibleColumns = metrics.visibleColumns,
-          visibleColumnXs = metrics.visibleColumnXs,
-          visibleColumnWidths = metrics.visibleColumnWidths;
-      var allowColumnResize = theme.allowColumnResize,
-          headerSeparatorHandleSize = theme.headerSeparatorHandleSize;
-
-      if (columnHeaderHeight < y || !allowColumnResize || headerSeparatorHandleSize <= 0) {
-        return null;
-      }
 
-      var gridX = x - rowHeaderWidth;
-      var halfSeparatorSize = headerSeparatorHandleSize * 0.5; // Iterate backward so that you can reveal hidden columns properly
+    return null;
+  }
+  /**
+   * Iterate backward through the visible columns until a shown column is hit
+   * @param {Number} columnIndex The column index to start iterating backward from
+   * @param {GridMetrics} metrics The GridMetricCalculator metrics
+   */
+
+
+  static getNextShownColumn(startIndex, metrics) {
+    var {
+      modelColumns,
+      visibleColumns,
+      userColumnWidths
+    } = metrics;
+    return GridUtils.getNextShownItem(startIndex, modelColumns, visibleColumns, userColumnWidths);
+  }
+  /**
+   * Iterate backward through the visible rows until a shown row is hit
+   * @param {Number} rowIndex The row index to start iterating backward from
+   * @param {GridMetrics} metrics The GridMetricCalculator metrics
+   */
+
+
+  static getNextShownRow(startIndex, metrics) {
+    var {
+      modelRows,
+      visibleRows,
+      userRowHeights
+    } = metrics;
+    return GridUtils.getNextShownItem(startIndex, modelRows, visibleRows, userRowHeights);
+  } // Returns the column index if the x/y coordinates provided are close enough to the separator, otherwise false
+
+
+  static getColumnSeparatorIndex(x, y, metrics, theme) {
+    var {
+      rowHeaderWidth,
+      columnHeaderHeight,
+      visibleColumns,
+      visibleColumnXs,
+      visibleColumnWidths
+    } = metrics;
+    var {
+      allowColumnResize,
+      headerSeparatorHandleSize
+    } = theme;
+
+    if (columnHeaderHeight < y || !allowColumnResize || headerSeparatorHandleSize <= 0) {
+      return null;
+    }
 
-      var isPreviousColumnHidden = false;
+    var gridX = x - rowHeaderWidth;
+    var halfSeparatorSize = headerSeparatorHandleSize * 0.5; // Iterate backward so that you can reveal hidden columns properly
 
-      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 isColumnHidden = columnWidth === 0;
+    var isPreviousColumnHidden = false;
 
-        if (!isPreviousColumnHidden || !isColumnHidden) {
-          var midX = columnX + columnWidth;
+    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 isColumnHidden = columnWidth === 0;
 
-          if (isColumnHidden) {
-            midX += halfSeparatorSize;
-          } else if (isPreviousColumnHidden) {
-            midX -= halfSeparatorSize;
-          }
+      if (!isPreviousColumnHidden || !isColumnHidden) {
+        var midX = columnX + columnWidth;
 
-          var minX = midX - halfSeparatorSize;
-          var maxX = midX + halfSeparatorSize;
+        if (isColumnHidden) {
+          midX += halfSeparatorSize;
+        } else if (isPreviousColumnHidden) {
+          midX -= halfSeparatorSize;
+        }
 
-          if (minX <= gridX && gridX <= maxX) {
-            return column;
-          }
+        var minX = midX - halfSeparatorSize;
+        var maxX = midX + halfSeparatorSize;
 
-          isPreviousColumnHidden = isColumnHidden;
+        if (minX <= gridX && gridX <= maxX) {
+          return column;
         }
-      }
 
-      return null;
-    }
-  }, {
-    key: "isItemHidden",
-    value: function isItemHidden(itemIndex, visibleSizes) {
-      return visibleSizes.get(itemIndex) === 0;
-    }
-  }, {
-    key: "isColumnHidden",
-    value: function isColumnHidden(columnIndex, metrics) {
-      var visibleColumnWidths = metrics.visibleColumnWidths;
-      return GridUtils.isItemHidden(columnIndex, visibleColumnWidths);
-    }
-    /**
-     * Check if the provided row is a floating row
-     * @param {number} row The row index to check
-     * @param {GridMetrics} metrics The grid metrics to check against
-     */
-
-  }, {
-    key: "isFloatingRow",
-    value: function isFloatingRow(row, metrics) {
-      if (row == null) {
-        return false;
+        isPreviousColumnHidden = isColumnHidden;
       }
+    }
+
+    return null;
+  }
+
+  static isItemHidden(itemIndex, visibleSizes) {
+    return visibleSizes.get(itemIndex) === 0;
+  }
+
+  static isColumnHidden(columnIndex, metrics) {
+    var {
+      visibleColumnWidths
+    } = metrics;
+    return GridUtils.isItemHidden(columnIndex, visibleColumnWidths);
+  }
+  /**
+   * Check if the provided row is a floating row
+   * @param {number} row The row index to check
+   * @param {GridMetrics} metrics The grid metrics to check against
+   */
 
-      var floatingTopRowCount = metrics.floatingTopRowCount,
-          floatingBottomRowCount = metrics.floatingBottomRowCount,
-          rowCount = metrics.rowCount;
-      return row < floatingTopRowCount || row >= rowCount - floatingBottomRowCount;
+
+  static isFloatingRow(row, metrics) {
+    if (row == null) {
+      return false;
     }
-    /**
-     * Check if the provided column is a floating column
-     * @param {number} column The column index to check
-     * @param {GridMetrics} metrics The grid metrics to check against
-     */
-
-  }, {
-    key: "isFloatingColumn",
-    value: function isFloatingColumn(column, metrics) {
-      if (column == null) {
-        return false;
-      }
 
-      var floatingLeftColumnCount = metrics.floatingLeftColumnCount,
-          floatingRightColumnCount = metrics.floatingRightColumnCount,
-          columnCount = metrics.columnCount;
-      return column < floatingLeftColumnCount || column >= columnCount - floatingRightColumnCount;
+    var {
+      floatingTopRowCount,
+      floatingBottomRowCount,
+      rowCount
+    } = metrics;
+    return row < floatingTopRowCount || row >= rowCount - floatingBottomRowCount;
+  }
+  /**
+   * Check if the provided column is a floating column
+   * @param {number} column The column index to check
+   * @param {GridMetrics} metrics The grid metrics to check against
+   */
+
+
+  static isFloatingColumn(column, metrics) {
+    if (column == null) {
+      return false;
     }
-  }, {
-    key: "getHiddenItems",
-    value: function getHiddenItems(itemIndex, visibleSizes, visibleItems) {
-      if (!GridUtils.isItemHidden(itemIndex, visibleSizes)) {
-        return [];
-      }
 
-      var hiddenItems = [itemIndex];
-      var visibleItemIndex = visibleItems.findIndex(function (value) {
-        return value === itemIndex;
-      });
+    var {
+      floatingLeftColumnCount,
+      floatingRightColumnCount,
+      columnCount
+    } = metrics;
+    return column < floatingLeftColumnCount || column >= columnCount - floatingRightColumnCount;
+  }
 
-      for (var i = visibleItemIndex - 1; i >= 0; i -= 1) {
-        var item = visibleItems[i];
+  static getHiddenItems(itemIndex, visibleSizes, visibleItems) {
+    if (!GridUtils.isItemHidden(itemIndex, visibleSizes)) {
+      return [];
+    }
 
-        if (!GridUtils.isItemHidden(item, visibleSizes)) {
-          break;
-        }
+    var hiddenItems = [itemIndex];
+    var visibleItemIndex = visibleItems.findIndex(value => value === itemIndex);
+
+    for (var i = visibleItemIndex - 1; i >= 0; i -= 1) {
+      var item = visibleItems[i];
 
-        hiddenItems.push(item);
+      if (!GridUtils.isItemHidden(item, visibleSizes)) {
+        break;
       }
 
-      return hiddenItems;
+      hiddenItems.push(item);
     }
-  }, {
-    key: "getHiddenColumns",
-    value: function getHiddenColumns(columnIndex, metrics) {
-      var visibleColumns = metrics.visibleColumns,
-          visibleColumnWidths = metrics.visibleColumnWidths;
-      return GridUtils.getHiddenItems(columnIndex, visibleColumnWidths, visibleColumns);
-    } // Returns the row index if the x/y coordinates provided are close enough to the separator, otherwise false
-
-  }, {
-    key: "getRowSeparatorIndex",
-    value: function getRowSeparatorIndex(x, y, metrics, theme) {
-      var rowHeaderWidth = metrics.rowHeaderWidth,
-          columnHeaderHeight = metrics.columnHeaderHeight,
-          visibleRows = metrics.visibleRows,
-          visibleRowYs = metrics.visibleRowYs,
-          visibleRowHeights = metrics.visibleRowHeights;
-      var allowRowResize = theme.allowRowResize,
-          headerSeparatorHandleSize = theme.headerSeparatorHandleSize;
-
-      if (rowHeaderWidth < x || !allowRowResize || headerSeparatorHandleSize <= 0) {
-        return null;
-      }
 
-      var gridY = y - columnHeaderHeight;
-      var halfSeparatorSize = headerSeparatorHandleSize * 0.5; // Iterate backward so you can reveal hidden rows properly
+    return hiddenItems;
+  }
 
-      var isPreviousRowHidden = false;
+  static getHiddenColumns(columnIndex, metrics) {
+    var {
+      visibleColumns,
+      visibleColumnWidths
+    } = metrics;
+    return GridUtils.getHiddenItems(columnIndex, visibleColumnWidths, visibleColumns);
+  } // Returns the row index if the x/y coordinates provided are close enough to the separator, otherwise false
+
+
+  static getRowSeparatorIndex(x, y, metrics, theme) {
+    var {
+      rowHeaderWidth,
+      columnHeaderHeight,
+      visibleRows,
+      visibleRowYs,
+      visibleRowHeights
+    } = metrics;
+    var {
+      allowRowResize,
+      headerSeparatorHandleSize
+    } = theme;
+
+    if (rowHeaderWidth < x || !allowRowResize || headerSeparatorHandleSize <= 0) {
+      return null;
+    }
 
-      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 isRowHidden = rowHeight === 0;
+    var gridY = y - columnHeaderHeight;
+    var halfSeparatorSize = headerSeparatorHandleSize * 0.5; // Iterate backward so you can reveal hidden rows properly
 
-        if (!isPreviousRowHidden || !isRowHidden) {
-          var midY = rowY + rowHeight;
+    var isPreviousRowHidden = false;
 
-          if (isRowHidden) {
-            midY += halfSeparatorSize;
-          } else if (isPreviousRowHidden) {
-            midY -= halfSeparatorSize;
-          }
+    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 isRowHidden = rowHeight === 0;
 
-          var minY = midY - halfSeparatorSize;
-          var maxY = midY + halfSeparatorSize;
+      if (!isPreviousRowHidden || !isRowHidden) {
+        var midY = rowY + rowHeight;
 
-          if (minY <= gridY && gridY <= maxY) {
-            return row;
-          }
+        if (isRowHidden) {
+          midY += halfSeparatorSize;
+        } else if (isPreviousRowHidden) {
+          midY -= halfSeparatorSize;
+        }
+
+        var minY = midY - halfSeparatorSize;
+        var maxY = midY + halfSeparatorSize;
 
-          isPreviousRowHidden = isRowHidden;
+        if (minY <= gridY && gridY <= maxY) {
+          return row;
         }
-      }
 
-      return null;
-    }
-  }, {
-    key: "isRowHidden",
-    value: function isRowHidden(rowIndex, metrics) {
-      var visibleRowHeights = metrics.visibleRowHeights;
-      return GridUtils.isItemHidden(rowIndex, visibleRowHeights);
-    }
-  }, {
-    key: "getHiddenRows",
-    value: function getHiddenRows(rowIndex, metrics) {
-      var visibleRows = metrics.visibleRows,
-          visibleRowHeights = metrics.visibleRowHeights;
-      return GridUtils.getHiddenItems(rowIndex, visibleRowHeights, visibleRows);
-    }
-    /**
-     * Set a new order for items in the grid
-     * @param {Number} from The visible index to move from
-     * @param {Number} to The visible index to move the itme to
-     * @param {Array} oldMovedItems The old reordered items
-     * @returns {Number} The new reordered items
-     */
-
-  }, {
-    key: "moveItem",
-    value: function moveItem(from, to) {
-      var oldMovedItems = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
-
-      if (from === to) {
-        return oldMovedItems;
+        isPreviousRowHidden = isRowHidden;
       }
+    }
 
-      var movedItems = [].concat(oldMovedItems);
+    return null;
+  }
+
+  static isRowHidden(rowIndex, metrics) {
+    var {
+      visibleRowHeights
+    } = metrics;
+    return GridUtils.isItemHidden(rowIndex, visibleRowHeights);
+  }
+
+  static getHiddenRows(rowIndex, metrics) {
+    var {
+      visibleRows,
+      visibleRowHeights
+    } = metrics;
+    return GridUtils.getHiddenItems(rowIndex, visibleRowHeights, visibleRows);
+  }
+  /**
+   * Set a new order for items in the grid
+   * @param {Number} from The visible index to move from
+   * @param {Number} to The visible index to move the itme to
+   * @param {Array} oldMovedItems The old reordered items
+   * @returns {Number} The new reordered items
+   */
 
-      if (movedItems.length > 0 && movedItems[movedItems.length - 1].to === from) {
-        movedItems[movedItems.length - 1] = _objectSpread(_objectSpread({}, movedItems[movedItems.length - 1]), {}, {
-          to: to
-        });
-      } else {
-        movedItems.push({
-          from: from,
-          to: to
-        });
-      }
 
-      return movedItems;
+  static moveItem(from, to) {
+    var oldMovedItems = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+
+    if (from === to) {
+      return oldMovedItems;
+    }
+
+    var movedItems = [].concat(oldMovedItems);
+
+    if (movedItems.length > 0 && movedItems[movedItems.length - 1].to === from) {
+      movedItems[movedItems.length - 1] = _objectSpread(_objectSpread({}, movedItems[movedItems.length - 1]), {}, {
+        to
+      });
+    } else {
+      movedItems.push({
+        from,
+        to
+      });
     }
-    /**
-     * Retrieve the model index given the currently moved items
-     * @param {Number} visibleIndex The visible index of the item to get the model index for
-     * @param {Array} movedItems The moved items
-     * @returns {Number} The model index of the item
-     */
-
-  }, {
-    key: "getModelIndex",
-    value: function getModelIndex(visibleIndex) {
-      var movedItems = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-      var modelIndex = visibleIndex;
-
-      for (var i = movedItems.length - 1; i >= 0; i -= 1) {
-        var movedItem = movedItems[i];
-
-        if (modelIndex === movedItem.to) {
-          modelIndex = movedItem.from;
-        } else if (movedItem.from <= modelIndex && modelIndex < movedItem.to) {
-          modelIndex += 1;
-        } else if (movedItem.to < modelIndex && modelIndex <= movedItem.from) {
-          modelIndex -= 1;
-        }
-      }
 
-      return modelIndex;
+    return movedItems;
+  }
+  /**
+   * Retrieve the model index given the currently moved items
+   * @param {Number} visibleIndex The visible index of the item to get the model index for
+   * @param {Array} movedItems The moved items
+   * @returns {Number} The model index of the item
+   */
+
+
+  static getModelIndex(visibleIndex) {
+    var movedItems = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    var modelIndex = visibleIndex;
+
+    for (var i = movedItems.length - 1; i >= 0; i -= 1) {
+      var movedItem = movedItems[i];
+
+      if (modelIndex === movedItem.to) {
+        ({
+          from: modelIndex
+        } = movedItem);
+      } else if (movedItem.from <= modelIndex && modelIndex < movedItem.to) {
+        modelIndex += 1;
+      } else if (movedItem.to < modelIndex && modelIndex <= movedItem.from) {
+        modelIndex -= 1;
+      }
     }
-    /**
-     * Translate the provided UI start/end indexes to the model start/end indexes by applying the `movedItems` transformations.
-     * Since moved items can split apart a range, multiple pairs of indexes are returned
-     *
-     * @param {number} start Start item in one dimension
-     * @param {number} end End item in one dimension
-     * @param {MovedItem[]} movedItems Moved item pairs in this dimension
-     * @returns {AxisRange[]} Array of start/end pairs of the indexes after transformations applied.
-     */
-
-  }, {
-    key: "getModelRangeIndexes",
-    value: function getModelRangeIndexes(start, end, movedItems) {
-      var result = [[start, end]];
-
-      if (start == null) {
-        return result;
-      } // movedItems is built by adding a new item whenever an item in the UI is dragged/moved, transforming a model
-      // index to the new UI index. We want to find the model index from the UI index here, so we unwind the
-      // transformations applied - the start/end axis range passed in is the current UI range, so we need to apply
-      // the transformations starting at the end of the chain backward to find the appropriate model indexes
-
-
-      for (var i = movedItems.length - 1; i >= 0; i -= 1) {
-        var _movedItems$i = movedItems[i],
-            from = _movedItems$i.from,
-            to = _movedItems$i.to;
-        var nextResult = [];
-
-        for (var j = 0; j < result.length; j += 1) {
-          var _result$j = _slicedToArray(result[j], 2),
-              currentStart = _result$j[0],
-              currentEnd = _result$j[1];
-
-          var startLength = nextResult.length;
-
-          if (from <= currentStart) {
-            // From before
-            if (to > currentEnd) {
-              // To after
-              nextResult.push([currentStart + 1, currentEnd + 1]);
-            } else if (to >= currentStart) {
-              // To within
-              nextResult.push([from, from]);
-              nextResult.push([currentStart + 1, currentEnd]);
-            }
-          } else if (from > currentEnd) {
-            // From after
-            if (to < currentStart) {
-              // To before
-              nextResult.push([currentStart - 1, currentEnd - 1]);
-            } else if (to <= currentEnd) {
-              // To within
-              nextResult.push([from, from]);
-              nextResult.push([currentStart, currentEnd - 1]);
-            }
-          } else if (to < currentStart) {
-            // From within to before
-            nextResult.push([currentStart - 1, from - 1]);
-            nextResult.push([from + 1, currentEnd]);
-          } else if (to > currentEnd) {
-            // From within to after
-            nextResult.push([currentStart, from - 1]);
-            nextResult.push([from + 1, currentEnd + 1]);
-          } else if (from > to) {
-            // From within after to within before
-            if (to > currentStart) {
-              nextResult.push([currentStart, to - 1]);
-            }
 
+    return modelIndex;
+  }
+  /**
+   * Translate the provided UI start/end indexes to the model start/end indexes by applying the `movedItems` transformations.
+   * Since moved items can split apart a range, multiple pairs of indexes are returned
+   *
+   * @param {number} start Start item in one dimension
+   * @param {number} end End item in one dimension
+   * @param {MovedItem[]} movedItems Moved item pairs in this dimension
+   * @returns {AxisRange[]} Array of start/end pairs of the indexes after transformations applied.
+   */
+
+
+  static getModelRangeIndexes(start, end, movedItems) {
+    var result = [[start, end]];
+
+    if (start == null) {
+      return result;
+    } // movedItems is built by adding a new item whenever an item in the UI is dragged/moved, transforming a model
+    // index to the new UI index. We want to find the model index from the UI index here, so we unwind the
+    // transformations applied - the start/end axis range passed in is the current UI range, so we need to apply
+    // the transformations starting at the end of the chain backward to find the appropriate model indexes
+
+
+    for (var i = movedItems.length - 1; i >= 0; i -= 1) {
+      var {
+        from,
+        to
+      } = movedItems[i];
+      var nextResult = [];
+
+      for (var j = 0; j < result.length; j += 1) {
+        var [currentStart, currentEnd] = result[j];
+        var startLength = nextResult.length;
+
+        if (from <= currentStart) {
+          // From before
+          if (to > currentEnd) {
+            // To after
+            nextResult.push([currentStart + 1, currentEnd + 1]);
+          } else if (to >= currentStart) {
+            // To within
             nextResult.push([from, from]);
-            nextResult.push([to, from - 1]);
-
-            if (from < currentEnd) {
-              nextResult.push([from + 1, currentEnd]);
-            }
-          } else if (from < to) {
-            // From within before to within after
-            if (from > currentStart) {
-              nextResult.push([currentStart, from - 1]);
-            }
-
-            nextResult.push([from + 1, to]);
+            nextResult.push([currentStart + 1, currentEnd]);
+          }
+        } else if (from > currentEnd) {
+          // From after
+          if (to < currentStart) {
+            // To before
+            nextResult.push([currentStart - 1, currentEnd - 1]);
+          } else if (to <= currentEnd) {
+            // To within
             nextResult.push([from, from]);
+            nextResult.push([currentStart, currentEnd - 1]);
+          }
+        } else if (to < currentStart) {
+          // From within to before
+          nextResult.push([currentStart - 1, from - 1]);
+          nextResult.push([from + 1, currentEnd]);
+        } else if (to > currentEnd) {
+          // From within to after
+          nextResult.push([currentStart, from - 1]);
+          nextResult.push([from + 1, currentEnd + 1]);
+        } else if (from > to) {
+          // From within after to within before
+          if (to > currentStart) {
+            nextResult.push([currentStart, to - 1]);
+          }
+
+          nextResult.push([from, from]);
+          nextResult.push([to, from - 1]);
 
-            if (from < currentEnd) {
-              nextResult.push([to + 1, currentEnd]);
-            }
+          if (from < currentEnd) {
+            nextResult.push([from + 1, currentEnd]);
           }
+        } else if (from < to) {
+          // From within before to within after
+          if (from > currentStart) {
+            nextResult.push([currentStart, from - 1]);
+          }
+
+          nextResult.push([from + 1, to]);
+          nextResult.push([from, from]);
 
-          if (startLength === nextResult.length) {
-            // No modifications were made, add the original range indexes
-            nextResult.push([currentStart, currentEnd]);
+          if (from < currentEnd) {
+            nextResult.push([to + 1, currentEnd]);
           }
         }
 
-        result = nextResult;
-      }
-
-      return result;
-    }
-    /**
-     * Translate the provided UI range into model range, using the `movedColumns` and `movedRows` to apply the necessary transforms.
-     * `movedColumns` and `movedRows` are array of operations done to the UI indexes to re-order items
-     *
-     * @param {GridRange} uiRange The currently selected UI ranges
-     * @param {Array} movedColumns The moved column pairs
-     * @param {Array} movedRows The moved row pairs
-     * @returns {GridRange[]} The model ranges after translation.
-     */
-
-  }, {
-    key: "getModelRange",
-    value: function getModelRange(uiRange) {
-      var movedColumns = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-      var movedRows = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
-      var columnRanges = GridUtils.getModelRangeIndexes(uiRange.startColumn, uiRange.endColumn, movedColumns);
-      var rowRanges = GridUtils.getModelRangeIndexes(uiRange.startRow, uiRange.endRow, movedRows);
-      var ranges = [];
-
-      for (var i = 0; i < columnRanges.length; i += 1) {
-        var c = columnRanges[i];
-
-        for (var j = 0; j < rowRanges.length; j += 1) {
-          var r = rowRanges[j];
-          ranges.push(new GridRange(c[0], r[0], c[1], r[1]));
+        if (startLength === nextResult.length) {
+          // No modifications were made, add the original range indexes
+          nextResult.push([currentStart, currentEnd]);
         }
       }
 
-      return ranges;
+      result = nextResult;
     }
-    /**
-     * Translate the provided UI range into model ranges, using the `movedColumns` and `movedRows` to apply the necessary transforms.
-     * `movedColumns` and `movedRows` are array of operations done to the UI indexes to re-order items
-     *
-     * @param {GridRange[]} uiRanges The currently selected UI ranges
-     * @param {Array} movedColumns The moved column pairs
-     * @param {Array} movedRows The moved row pairs
-     * @returns {GridRange[]} The model ranges after translation.
-     */
-
-  }, {
-    key: "getModelRanges",
-    value: function getModelRanges(uiRanges) {
-      var movedColumns = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-      var movedRows = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
-      var modelRanges = [];
-
-      for (var i = 0; i < uiRanges.length; i += 1) {
-        modelRanges.push.apply(modelRanges, _toConsumableArray(GridUtils.getModelRange(uiRanges[i], movedColumns, movedRows)));
-      }
 
-      return modelRanges;
-    }
-    /**
-     * Retrieve the visible index given the currently moved items
-     * @param {Number} modelIndex The model index to get the visible index for
-     * @param {Array} movedItems Moved items
-     * @returns {Number} The visible index of the item
-     */
-
-  }, {
-    key: "getVisibleIndex",
-    value: function getVisibleIndex(modelIndex) {
-      var movedItems = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-      var visibleIndex = modelIndex;
-
-      for (var i = 0; i < movedItems.length; i += 1) {
-        var movedItem = movedItems[i];
-
-        if (visibleIndex === movedItem.from) {
-          visibleIndex = movedItem.to;
-        } else if (movedItem.from < visibleIndex && visibleIndex <= movedItem.to) {
-          visibleIndex -= 1;
-        } else if (movedItem.to <= visibleIndex && visibleIndex < movedItem.from) {
-          visibleIndex += 1;
-        }
+    return result;
+  }
+  /**
+   * Translate the provided UI range into model range, using the `movedColumns` and `movedRows` to apply the necessary transforms.
+   * `movedColumns` and `movedRows` are array of operations done to the UI indexes to re-order items
+   *
+   * @param {GridRange} uiRange The currently selected UI ranges
+   * @param {Array} movedColumns The moved column pairs
+   * @param {Array} movedRows The moved row pairs
+   * @returns {GridRange[]} The model ranges after translation.
+   */
+
+
+  static getModelRange(uiRange) {
+    var movedColumns = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    var movedRows = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+    var columnRanges = GridUtils.getModelRangeIndexes(uiRange.startColumn, uiRange.endColumn, movedColumns);
+    var rowRanges = GridUtils.getModelRangeIndexes(uiRange.startRow, uiRange.endRow, movedRows);
+    var ranges = [];
+
+    for (var i = 0; i < columnRanges.length; i += 1) {
+      var c = columnRanges[i];
+
+      for (var j = 0; j < rowRanges.length; j += 1) {
+        var r = rowRanges[j];
+        ranges.push(new GridRange(c[0], r[0], c[1], r[1]));
       }
-
-      return visibleIndex;
-    }
-  }, {
-    key: "isMacPlatform",
-    value: function isMacPlatform() {
-      var platform = window.navigator.platform;
-      return platform.startsWith('Mac');
     }
-  }, {
-    key: "getModifierKey",
-    value: function getModifierKey() {
-      if (GridUtils.isMacPlatform()) {
-        return 'metaKey';
-      }
 
-      return 'ctrlKey';
+    return ranges;
+  }
+  /**
+   * Translate the provided UI range into model ranges, using the `movedColumns` and `movedRows` to apply the necessary transforms.
+   * `movedColumns` and `movedRows` are array of operations done to the UI indexes to re-order items
+   *
+   * @param {GridRange[]} uiRanges The currently selected UI ranges
+   * @param {Array} movedColumns The moved column pairs
+   * @param {Array} movedRows The moved row pairs
+   * @returns {GridRange[]} The model ranges after translation.
+   */
+
+
+  static getModelRanges(uiRanges) {
+    var movedColumns = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    var movedRows = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+    var modelRanges = [];
+
+    for (var i = 0; i < uiRanges.length; i += 1) {
+      modelRanges.push(...GridUtils.getModelRange(uiRanges[i], movedColumns, movedRows));
     }
-  }, {
-    key: "isModifierKeyDown",
-    value: function isModifierKeyDown(event) {
-      var modifierKey = GridUtils.getModifierKey();
-      return event[modifierKey];
+
+    return modelRanges;
+  }
+  /**
+   * Retrieve the visible index given the currently moved items
+   * @param {Number} modelIndex The model index to get the visible index for
+   * @param {Array} movedItems Moved items
+   * @returns {Number} The visible index of the item
+   */
+
+
+  static getVisibleIndex(modelIndex) {
+    var movedItems = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    var visibleIndex = modelIndex;
+
+    for (var i = 0; i < movedItems.length; i += 1) {
+      var movedItem = movedItems[i];
+
+      if (visibleIndex === movedItem.from) {
+        ({
+          to: visibleIndex
+        } = movedItem);
+      } else if (movedItem.from < visibleIndex && visibleIndex <= movedItem.to) {
+        visibleIndex -= 1;
+      } else if (movedItem.to <= visibleIndex && visibleIndex < movedItem.from) {
+        visibleIndex += 1;
+      }
     }
-  }, {
-    key: "checkColumnHidden",
-    value: function checkColumnHidden(modelIndex, userColumnWidths) {
-      return userColumnWidths.get(modelIndex) === 0;
+
+    return visibleIndex;
+  }
+
+  static isMacPlatform() {
+    var {
+      platform
+    } = window.navigator;
+    return platform.startsWith('Mac');
+  }
+
+  static getModifierKey() {
+    if (GridUtils.isMacPlatform()) {
+      return 'metaKey';
     }
-  }, {
-    key: "checkAllColumnsHidden",
-    value: function checkAllColumnsHidden(columns, userColumnWidths) {
-      if (userColumnWidths.size === 0) {
-        return false;
-      }
 
-      return columns.every(function (column) {
-        return userColumnWidths.get(column) === 0;
-      });
+    return 'ctrlKey';
+  }
+
+  static isModifierKeyDown(event) {
+    var modifierKey = GridUtils.getModifierKey();
+    return event[modifierKey];
+  }
+
+  static checkColumnHidden(modelIndex, userColumnWidths) {
+    return userColumnWidths.get(modelIndex) === 0;
+  }
+
+  static checkAllColumnsHidden(columns, userColumnWidths) {
+    if (userColumnWidths.size === 0) {
+      return false;
     }
-    /**
-     * Get the bounds the mouse needs to be dragged outside of from an initial selection before scrolling occurs.
-     * Taking into account any floating rows that may be covering the viewport.
-     * @param {GridMetrics} metrics Grid metrics
-     * @param {number} row The row they started dragging in
-     * @param {number} column The column they started the drag from
-     * @returns Dimensions of the drag area in relation to the canvas they need to drag outside of to start scrolling
-     */
-
-  }, {
-    key: "getScrollDragBounds",
-    value: function getScrollDragBounds(metrics, row, column) {
-      var gridX = metrics.gridX,
-          gridY = metrics.gridY,
-          width = metrics.width,
-          height = metrics.height,
-          floatingTopRowCount = metrics.floatingTopRowCount,
-          floatingBottomRowCount = metrics.floatingBottomRowCount,
-          floatingLeftColumnCount = metrics.floatingLeftColumnCount,
-          floatingRightColumnCount = metrics.floatingRightColumnCount,
-          floatingLeftWidth = metrics.floatingLeftWidth,
-          floatingRightWidth = metrics.floatingRightWidth,
-          floatingTopHeight = metrics.floatingTopHeight,
-          floatingBottomHeight = metrics.floatingBottomHeight,
-          columnCount = metrics.columnCount,
-          rowCount = metrics.rowCount;
-      var x = gridX;
-      var y = gridY;
-      var x2 = width;
-      var y2 = height;
-
-      if (column != null) {
-        if (column > floatingLeftColumnCount) {
-          x += floatingLeftWidth;
-        }
 
-        if (column < columnCount - floatingRightColumnCount) {
-          x2 -= floatingRightWidth;
-        }
+    return columns.every(column => userColumnWidths.get(column) === 0);
+  }
+  /**
+   * Get the bounds the mouse needs to be dragged outside of from an initial selection before scrolling occurs.
+   * Taking into account any floating rows that may be covering the viewport.
+   * @param {GridMetrics} metrics Grid metrics
+   * @param {number} row The row they started dragging in
+   * @param {number} column The column they started the drag from
+   * @returns Dimensions of the drag area in relation to the canvas they need to drag outside of to start scrolling
+   */
+
+
+  static getScrollDragBounds(metrics, row, column) {
+    var {
+      gridX,
+      gridY,
+      width,
+      height,
+      floatingTopRowCount,
+      floatingBottomRowCount,
+      floatingLeftColumnCount,
+      floatingRightColumnCount,
+      floatingLeftWidth,
+      floatingRightWidth,
+      floatingTopHeight,
+      floatingBottomHeight,
+      columnCount,
+      rowCount
+    } = metrics;
+    var x = gridX;
+    var y = gridY;
+    var x2 = width;
+    var y2 = height;
+
+    if (column != null) {
+      if (column > floatingLeftColumnCount) {
+        x += floatingLeftWidth;
       }
 
-      if (row != null) {
-        if (row > floatingTopRowCount) {
-          y += floatingTopHeight;
-        }
+      if (column < columnCount - floatingRightColumnCount) {
+        x2 -= floatingRightWidth;
+      }
+    }
 
-        if (row < rowCount - floatingBottomRowCount) {
-          y2 -= floatingBottomHeight;
-        }
+    if (row != null) {
+      if (row > floatingTopRowCount) {
+        y += floatingTopHeight;
       }
 
-      return {
-        x: x,
-        y: y,
-        x2: x2,
-        y2: y2
-      };
-    }
-    /**
-     * Converts the delta coordinates from the provided wheel event to pixels
-     * Different platforms have different ways of providing the delta so this normalizes it
-     * @param {WheelEvent} wheelEvent The mouse wheel event to get the scrolling delta for
-     * @param {number?} pageWidth The width of the page that is scrolling
-     * @param {number?} pageHeight The height of the page that is scrolling
-     * @param {number?} lineWidth The width of the line scrolling in line mode
-     * @param {number?} lineHeight The height of the line scrolling in line mode
-     * @returns {{deltaX:number, deltaY: number}} The delta coordinates normalized to pixels
-     */
-
-  }, {
-    key: "getScrollDelta",
-    value: function getScrollDelta(wheelEvent) {
-      var pageWidth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1024;
-      var pageHeight = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 768;
-      var lineWidth = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 20;
-      var lineHeight = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 20;
-      var deltaX = wheelEvent.deltaX,
-          deltaY = wheelEvent.deltaY; // Flip scroll direction if shiftKey is held on windows/linux.
-      // On mac, deltaX/Y values are switched at the event level when shiftKey=true.
-      // Guard on strictly Y only changing, to ignore trackpad diagonal motion,
-      // through that guard may not be necessary, but it is difficult to determine for
-      // all platforms/browser/scroll method combos.
-
-      if (!GridUtils.isMacPlatform() && wheelEvent.shiftKey && wheelEvent.deltaX === 0 && wheelEvent.deltaY !== 0) {
-        deltaX = wheelEvent.deltaY;
-        deltaY = wheelEvent.deltaX;
-      } // Normalize other deltaMode values to pixel units
-      // deltaMode 0, is already in pixel units
-
-
-      if ((wheelEvent === null || wheelEvent === void 0 ? void 0 : wheelEvent.deltaMode) === WheelEvent.DOM_DELTA_PAGE) {
-        // Users can set OS to be in deltaMode page
-        // scrolly by page units as pixels
-        deltaX *= pageWidth;
-        deltaY *= pageHeight;
-      } else if ((wheelEvent === null || wheelEvent === void 0 ? void 0 : wheelEvent.deltaMode) === WheelEvent.DOM_DELTA_LINE) {
-        // Firefox reports deltaMode line
-        // Normalize distance travelled between browsers
-        // but remain ~platform/browser combo consistent
-        if (GridUtils.isMacPlatform()) {
-          // for mac treat lines as a standard row height
-          // on mac, firefox travels less distance then chrome per tick
-          deltaX = Math.round(deltaX * lineWidth);
-          deltaY = Math.round(deltaY * lineHeight);
-        } else {
-          // for windows convert to pixels using the same method as chrome
-          // chrome goes 100 per 3 lines, and firefox would go 102 per 3 (17 lineheight * 3 lines * 2)
-          // make the behaviour the same between as it's close enough
-          deltaX = Math.round(deltaX * this.PIXELS_PER_LINE);
-          deltaY = Math.round(deltaY * this.PIXELS_PER_LINE);
-        }
+      if (row < rowCount - floatingBottomRowCount) {
+        y2 -= floatingBottomHeight;
       }
+    }
 
-      return {
-        deltaX: deltaX,
-        deltaY: deltaY
-      };
+    return {
+      x,
+      y,
+      x2,
+      y2
+    };
+  }
+  /**
+   * Converts the delta coordinates from the provided wheel event to pixels
+   * Different platforms have different ways of providing the delta so this normalizes it
+   * @param {WheelEvent} wheelEvent The mouse wheel event to get the scrolling delta for
+   * @param {number?} pageWidth The width of the page that is scrolling
+   * @param {number?} pageHeight The height of the page that is scrolling
+   * @param {number?} lineWidth The width of the line scrolling in line mode
+   * @param {number?} lineHeight The height of the line scrolling in line mode
+   * @returns {{deltaX:number, deltaY: number}} The delta coordinates normalized to pixels
+   */
+
+
+  static getScrollDelta(wheelEvent) {
+    var pageWidth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1024;
+    var pageHeight = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 768;
+    var lineWidth = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 20;
+    var lineHeight = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 20;
+    var {
+      deltaX,
+      deltaY
+    } = wheelEvent; // Flip scroll direction if shiftKey is held on windows/linux.
+    // On mac, deltaX/Y values are switched at the event level when shiftKey=true.
+    // Guard on strictly Y only changing, to ignore trackpad diagonal motion,
+    // through that guard may not be necessary, but it is difficult to determine for
+    // all platforms/browser/scroll method combos.
+
+    if (!GridUtils.isMacPlatform() && wheelEvent.shiftKey && wheelEvent.deltaX === 0 && wheelEvent.deltaY !== 0) {
+      deltaX = wheelEvent.deltaY;
+      deltaY = wheelEvent.deltaX;
+    } // Normalize other deltaMode values to pixel units
+    // deltaMode 0, is already in pixel units
+
+
+    if ((wheelEvent === null || wheelEvent === void 0 ? void 0 : wheelEvent.deltaMode) === WheelEvent.DOM_DELTA_PAGE) {
+      // Users can set OS to be in deltaMode page
+      // scrolly by page units as pixels
+      deltaX *= pageWidth;
+      deltaY *= pageHeight;
+    } else if ((wheelEvent === null || wheelEvent === void 0 ? void 0 : wheelEvent.deltaMode) === WheelEvent.DOM_DELTA_LINE) {
+      // Firefox reports deltaMode line
+      // Normalize distance travelled between browsers
+      // but remain ~platform/browser combo consistent
+      if (GridUtils.isMacPlatform()) {
+        // for mac treat lines as a standard row height
+        // on mac, firefox travels less distance then chrome per tick
+        deltaX = Math.round(deltaX * lineWidth);
+        deltaY = Math.round(deltaY * lineHeight);
+      } else {
+        // for windows convert to pixels using the same method as chrome
+        // chrome goes 100 per 3 lines, and firefox would go 102 per 3 (17 lineheight * 3 lines * 2)
+        // make the behaviour the same between as it's close enough
+        deltaX = Math.round(deltaX * this.PIXELS_PER_LINE);
+        deltaY = Math.round(deltaY * this.PIXELS_PER_LINE);
+      }
     }
-  }]);
 
-  return GridUtils;
-}();
+    return {
+      deltaX,
+      deltaY
+    };
+  }
+
+}
 
 _defineProperty(GridUtils, "PIXELS_PER_LINE", 100 / 3);