@deephaven/grid 0.4.1-modules.0 → 0.5.2-beta.0

package/dist/GridUtils.js

@@ -1,799 +1,837 @@
-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 _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
 
-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 _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 _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 _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
 
-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 _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
 
-  static iterateFloatingStart(start, total, callback) {
-    for (var i = 0; i < start && i < total; i += 1) {
-      var result = callback(i);
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
 
-      if (result !== undefined) {
-        return result;
-      }
-    }
+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."); }
 
-    return undefined;
-  }
-  /**
-   * Iterate through floating items at the end. Iterates in increasing order.
-   */
+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); }
 
+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; }
 
-  static iterateFloatingEnd(end, total, callback) {
-    for (var i = 0; i < end && total - (end - i) >= 0; i += 1) {
-      var result = callback(total - (end - i));
+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; }
 
-      if (result !== undefined) {
-        return result;
-      }
-    }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 
-    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 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 _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; }
 
-  static iterateFloating(start, end, total, callback) {
-    var result = GridUtils.iterateFloatingStart(start, total, callback);
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-    if (result !== undefined) {
-      return result;
-    }
+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); } }
 
-    return GridUtils.iterateFloatingEnd(end, total, callback);
-  }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
 
-  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);
+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; }
 
-    if (result !== undefined) {
-      return result;
+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;
+        }
+      }
 
-    for (var i = visibleStartIndex; i <= visibleEndIndex; i += 1) {
-      result = callback(i);
+      return undefined;
+    }
+    /**
+     * 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);
 
       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);
 
-    return undefined;
-  }
+      if (result !== undefined) {
+        return result;
+      }
 
-  static isInItem(itemIndex, itemXs, itemSizes, x) {
-    var itemX = itemXs.get(itemIndex);
-    var itemSize = itemSizes.get(itemIndex);
-    return itemX <= x && x <= itemX + itemSize;
-  }
+      for (var i = visibleStartIndex; i <= visibleEndIndex; i += 1) {
+        result = callback(i);
 
-  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;
+        if (result !== undefined) {
+          return result;
+        }
       }
 
       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;
+        }
 
-    for (var i = 0; i < items.length; i += 1) {
-      var item = items[i];
+        return undefined;
+      });
 
-      if (GridUtils.isInItem(item, itemXs, itemSizes, offset)) {
-        return item;
+      if (floatingItem !== undefined) {
+        return floatingItem;
       }
-    }
 
-    return null;
-  }
+      for (var i = 0; i < items.length; i += 1) {
+        var item = items[i];
 
-  static getColumnAtX(x, metrics) {
-    var {
-      columnCount,
-      floatingLeftColumnCount,
-      floatingRightColumnCount,
-      visibleColumns,
-      visibleColumnXs,
-      visibleColumnWidths,
-      gridX
-    } = metrics;
-
-    if (x < gridX) {
-      return null;
-    }
-
-    return this.getItemAtOffset(x - gridX, columnCount, floatingLeftColumnCount, floatingRightColumnCount, visibleColumns, visibleColumnXs, visibleColumnWidths);
-  }
+        if (GridUtils.isInItem(item, itemXs, itemSizes, offset)) {
+          return item;
+        }
+      }
 
-  static getRowAtY(y, metrics) {
-    var {
-      floatingTopRowCount,
-      floatingBottomRowCount,
-      rowCount,
-      visibleRows,
-      visibleRowYs,
-      visibleRowHeights,
-      gridY
-    } = metrics;
-
-    if (y < gridY) {
       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(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
-   */
+      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(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
+     */
+
+  }, {
+    key: "getNextShownItem",
+    value: function getNextShownItem(startIndex, modelIndexes, visibleItems, userSizes) {
+      var visibleItemIndex = visibleItems.findIndex(function (value) {
+        return value === startIndex;
+      }) || 0;
+      visibleItemIndex -= 1;
 
-  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);
 
-    while (visibleItemIndex != null && visibleItemIndex >= 0) {
-      var item = visibleItems[visibleItemIndex];
-      var modelIndex = modelIndexes.get(item);
+        if (userSizes.get(modelIndex) !== 0) {
+          return item;
+        }
 
-      if (userSizes.get(modelIndex) !== 0) {
-        return item;
+        visibleItemIndex -= 1;
       }
 
-      visibleItemIndex -= 1;
-    }
-
-    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;
     }
+    /**
+     * 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);
+    }
+    /**
+     * 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
+      var gridX = x - rowHeaderWidth;
+      var halfSeparatorSize = headerSeparatorHandleSize * 0.5; // Iterate backward so that you can reveal hidden columns properly
 
-    var isPreviousColumnHidden = false;
+      var isPreviousColumnHidden = false;
 
-    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;
+      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 (!isPreviousColumnHidden || !isColumnHidden) {
-        var midX = columnX + columnWidth;
+        if (!isPreviousColumnHidden || !isColumnHidden) {
+          var midX = columnX + columnWidth;
 
-        if (isColumnHidden) {
-          midX += halfSeparatorSize;
-        } else if (isPreviousColumnHidden) {
-          midX -= halfSeparatorSize;
-        }
+          if (isColumnHidden) {
+            midX += halfSeparatorSize;
+          } else if (isPreviousColumnHidden) {
+            midX -= halfSeparatorSize;
+          }
 
-        var minX = midX - halfSeparatorSize;
-        var maxX = midX + halfSeparatorSize;
+          var minX = midX - halfSeparatorSize;
+          var maxX = midX + halfSeparatorSize;
 
-        if (minX <= gridX && gridX <= maxX) {
-          return column;
-        }
+          if (minX <= gridX && gridX <= maxX) {
+            return column;
+          }
 
-        isPreviousColumnHidden = isColumnHidden;
+          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
-   */
-
 
-  static isFloatingRow(row, metrics) {
-    if (row == null) {
-      return false;
+      return null;
     }
-
-    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: "isItemHidden",
+    value: function isItemHidden(itemIndex, visibleSizes) {
+      return visibleSizes.get(itemIndex) === 0;
     }
-
-    var {
-      floatingLeftColumnCount,
-      floatingRightColumnCount,
-      columnCount
-    } = metrics;
-    return column < floatingLeftColumnCount || column >= columnCount - floatingRightColumnCount;
-  }
-
-  static getHiddenItems(itemIndex, visibleSizes, visibleItems) {
-    if (!GridUtils.isItemHidden(itemIndex, visibleSizes)) {
-      return [];
+  }, {
+    key: "isColumnHidden",
+    value: function isColumnHidden(columnIndex, metrics) {
+      var visibleColumnWidths = metrics.visibleColumnWidths;
+      return GridUtils.isItemHidden(columnIndex, visibleColumnWidths);
     }
-
-    var hiddenItems = [itemIndex];
-    var visibleItemIndex = visibleItems.findIndex(value => value === itemIndex);
-
-    for (var i = visibleItemIndex - 1; i >= 0; i -= 1) {
-      var item = visibleItems[i];
-
-      if (!GridUtils.isItemHidden(item, visibleSizes)) {
-        break;
+    /**
+     * 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;
       }
 
-      hiddenItems.push(item);
+      var floatingTopRowCount = metrics.floatingTopRowCount,
+          floatingBottomRowCount = metrics.floatingBottomRowCount,
+          rowCount = metrics.rowCount;
+      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
+     */
+
+  }, {
+    key: "isFloatingColumn",
+    value: function isFloatingColumn(column, metrics) {
+      if (column == null) {
+        return false;
+      }
 
-    return hiddenItems;
-  }
-
-  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;
+      var floatingLeftColumnCount = metrics.floatingLeftColumnCount,
+          floatingRightColumnCount = metrics.floatingRightColumnCount,
+          columnCount = metrics.columnCount;
+      return column < floatingLeftColumnCount || column >= columnCount - floatingRightColumnCount;
     }
+  }, {
+    key: "getHiddenItems",
+    value: function getHiddenItems(itemIndex, visibleSizes, visibleItems) {
+      if (!GridUtils.isItemHidden(itemIndex, visibleSizes)) {
+        return [];
+      }
 
-    var gridY = y - columnHeaderHeight;
-    var halfSeparatorSize = headerSeparatorHandleSize * 0.5; // Iterate backward so you can reveal hidden rows properly
-
-    var isPreviousRowHidden = false;
-
-    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;
-
-      if (!isPreviousRowHidden || !isRowHidden) {
-        var midY = rowY + rowHeight;
-
-        if (isRowHidden) {
-          midY += halfSeparatorSize;
-        } else if (isPreviousRowHidden) {
-          midY -= halfSeparatorSize;
-        }
+      var hiddenItems = [itemIndex];
+      var visibleItemIndex = visibleItems.findIndex(function (value) {
+        return value === itemIndex;
+      });
 
-        var minY = midY - halfSeparatorSize;
-        var maxY = midY + halfSeparatorSize;
+      for (var i = visibleItemIndex - 1; i >= 0; i -= 1) {
+        var item = visibleItems[i];
 
-        if (minY <= gridY && gridY <= maxY) {
-          return row;
+        if (!GridUtils.isItemHidden(item, visibleSizes)) {
+          break;
         }
 
-        isPreviousRowHidden = isRowHidden;
+        hiddenItems.push(item);
       }
-    }
 
-    return null;
-  }
+      return hiddenItems;
+    }
+  }, {
+    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;
+      }
 
-  static isRowHidden(rowIndex, metrics) {
-    var {
-      visibleRowHeights
-    } = metrics;
-    return GridUtils.isItemHidden(rowIndex, visibleRowHeights);
-  }
+      var gridY = y - columnHeaderHeight;
+      var halfSeparatorSize = headerSeparatorHandleSize * 0.5; // Iterate backward so you can reveal hidden rows properly
 
-  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
-   */
+      var isPreviousRowHidden = false;
 
+      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;
 
-  static moveItem(from, to) {
-    var oldMovedItems = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+        if (!isPreviousRowHidden || !isRowHidden) {
+          var midY = rowY + rowHeight;
 
-    if (from === to) {
-      return oldMovedItems;
-    }
+          if (isRowHidden) {
+            midY += halfSeparatorSize;
+          } else if (isPreviousRowHidden) {
+            midY -= halfSeparatorSize;
+          }
 
-    var movedItems = [].concat(oldMovedItems);
+          var minY = midY - halfSeparatorSize;
+          var maxY = midY + halfSeparatorSize;
 
-    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
-      });
-    }
+          if (minY <= gridY && gridY <= maxY) {
+            return row;
+          }
 
-    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;
+          isPreviousRowHidden = isRowHidden;
+        }
       }
+
+      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;
+      }
 
-    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.
-   */
+      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: to
+        });
+      } else {
+        movedItems.push({
+          from: from,
+          to: to
+        });
+      }
 
-  static getModelRangeIndexes(start, end, movedItems) {
-    var result = [[start, end]];
+      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
+     */
+
+  }, {
+    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;
+    }
+    /**
+     * 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]);
+            }
 
-    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([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([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([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([from + 1, currentEnd]);
+            if (from < currentEnd) {
+              nextResult.push([to + 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 (from < currentEnd) {
-            nextResult.push([to + 1, currentEnd]);
+          if (startLength === nextResult.length) {
+            // No modifications were made, add the original range indexes
+            nextResult.push([currentStart, currentEnd]);
           }
         }
 
-        if (startLength === nextResult.length) {
-          // No modifications were made, add the original range indexes
-          nextResult.push([currentStart, currentEnd]);
-        }
+        result = nextResult;
       }
 
-      result = nextResult;
+      return result;
     }
-
-    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]));
+    /**
+     * 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]));
+        }
       }
-    }
-
-    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));
+      return ranges;
     }
-
-    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;
+    /**
+     * 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 visibleIndex;
-  }
-
-  static isMacPlatform() {
-    var {
-      platform
-    } = window.navigator;
-    return platform.startsWith('Mac');
-  }
-
-  static getModifierKey() {
-    if (GridUtils.isMacPlatform()) {
-      return 'metaKey';
+      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 '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;
+      return visibleIndex;
     }
-
-    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;
+  }, {
+    key: "isMacPlatform",
+    value: function isMacPlatform() {
+      var platform = window.navigator.platform;
+      return platform.startsWith('Mac');
+    }
+  }, {
+    key: "getModifierKey",
+    value: function getModifierKey() {
+      if (GridUtils.isMacPlatform()) {
+        return 'metaKey';
       }
 
-      if (column < columnCount - floatingRightColumnCount) {
-        x2 -= floatingRightWidth;
+      return 'ctrlKey';
+    }
+  }, {
+    key: "isModifierKeyDown",
+    value: function isModifierKeyDown(event) {
+      var modifierKey = GridUtils.getModifierKey();
+      return event[modifierKey];
+    }
+  }, {
+    key: "checkColumnHidden",
+    value: function checkColumnHidden(modelIndex, userColumnWidths) {
+      return userColumnWidths.get(modelIndex) === 0;
+    }
+  }, {
+    key: "checkAllColumnsHidden",
+    value: function checkAllColumnsHidden(columns, userColumnWidths) {
+      if (userColumnWidths.size === 0) {
+        return false;
       }
+
+      return columns.every(function (column) {
+        return 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
+     */
+
+  }, {
+    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 (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,
-      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);
+        if (row < rowCount - floatingBottomRowCount) {
+          y2 -= floatingBottomHeight;
+        }
       }
+
+      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);
+        }
+      }
 
-    return {
-      deltaX,
-      deltaY
-    };
-  }
+      return {
+        deltaX: deltaX,
+        deltaY: deltaY
+      };
+    }
+  }]);
 
-}
+  return GridUtils;
+}();
 
 _defineProperty(GridUtils, "PIXELS_PER_LINE", 100 / 3);