@deephaven/grid 0.43.0 → 0.44.0

package/dist/GridUtils.js

@@ -0,0 +1,1198 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+import clamp from 'lodash.clamp';
+import { find as linkifyFind } from 'linkifyjs';
+import { EMPTY_ARRAY, getOrThrow } from '@deephaven/utils';
+import GridRange from "./GridRange.js";
+import { isBoundedAxisRange } from "./GridAxisRange.js";
+import { isExpandableGridModel } from "./ExpandableGridModel.js";
+export function isLinkToken(token) {
+  return (token === null || token === void 0 ? void 0 : token.href) !== undefined;
+}
+export 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
+
+  /**
+   * Get the GridPoint for the coordinates provided
+   * @param x The grid x coordinate
+   * @param y The grid y coordinate
+   * @param metrics The grid metrics
+   * @returns The GridPoint including the column/row information
+   */
+  static getGridPointFromXY(x, y, metrics) {
+    var column = GridUtils.getColumnAtX(x, metrics);
+    var row = GridUtils.getRowAtY(y, metrics);
+    var columnHeaderDepth = GridUtils.getColumnHeaderDepthAtY(y, metrics);
+    return {
+      x,
+      y,
+      row,
+      column,
+      columnHeaderDepth
+    };
+  }
+  static getCellInfoFromXY(x, y, metrics) {
+    var {
+      row,
+      column
+    } = GridUtils.getGridPointFromXY(x, y, metrics);
+    var {
+      allColumnWidths,
+      allRowHeights,
+      allColumnXs,
+      allRowYs,
+      modelColumns,
+      modelRows
+    } = metrics;
+    var modelRow = row !== null ? modelRows.get(row) : null;
+    var modelColumn = column !== null ? modelColumns.get(column) : null;
+    var left = column !== null ? allColumnXs.get(column) : null;
+    var top = row !== null ? allRowYs.get(row) : null;
+    var columnWidth = column !== null ? allColumnWidths.get(column) : null;
+    var rowHeight = row !== null ? allRowHeights.get(row) : null;
+    return {
+      row,
+      column,
+      modelRow: modelRow !== null && modelRow !== void 0 ? modelRow : null,
+      modelColumn: modelColumn !== null && modelColumn !== void 0 ? modelColumn : null,
+      left: left !== null && left !== void 0 ? left : null,
+      top: top !== null && top !== void 0 ? top : null,
+      columnWidth: columnWidth !== null && columnWidth !== void 0 ? columnWidth : null,
+      rowHeight: rowHeight !== null && rowHeight !== void 0 ? rowHeight : null
+    };
+  }
+  static getColumnHeaderDepthAtY(y, metrics) {
+    var row = GridUtils.getRowAtY(y, metrics);
+    var {
+      columnHeaderHeight,
+      columnHeaderMaxDepth
+    } = metrics;
+    if (row === null && y <= columnHeaderHeight * columnHeaderMaxDepth) {
+      return clamp(columnHeaderMaxDepth - Math.ceil(y / columnHeaderHeight), 0, columnHeaderMaxDepth - 1);
+    }
+    return undefined;
+  }
+
+  /**
+   * Iterate through each floating item at the start and call a callback, returning the first result
+   * @param start The count of floating items at the start
+   * @param total The total number of items
+   * @param callback Function to call for each item
+   * @returns The result from the callback
+   */
+  static iterateFloatingStart(start, total, callback) {
+    for (var i = 0; i < start && i < total; i += 1) {
+      var result = callback(i);
+      if (result !== undefined) {
+        return result;
+      }
+    }
+    return undefined;
+  }
+
+  /**
+   * Iterate through floating items at the end. Iterates in increasing order.
+   * @param end The count of floating items at the end
+   * @param total The total number of items
+   * @param callback Function to call for each item
+   * @returns The result from the callback
+   */
+  static 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 start Count of start floating rows, e.g. floatingTopRowCount
+   * @param end Count of end floating rows, e.g. floatingBottomRowCount
+   * @param total Total number of items
+   * @param callback Callback called for each value, stopping the iterating and returning the value if one is returned
+   */
+  static iterateFloating(start, end, total, callback) {
+    var result = GridUtils.iterateFloatingStart(start, total, callback);
+    if (result !== undefined) {
+      return result;
+    }
+    return GridUtils.iterateFloatingEnd(end, total, callback);
+  }
+
+  /**
+   * Iterate through all items in one dimension on the grid - first floating, then visible.
+   * Call the callback for each item, break if a result is returned and return that result.
+   * @param visibleStart Index of the start of the visible viewport
+   * @param visibleEnd Index of the end of the visible viewport
+   * @param floatingStartCount Number of items floating at the start
+   * @param floatingEndCount Number of items floating at the end
+   * @param totalCount Total number of items
+   * @param callback Callback to call for each item
+   * @returns The first result from the callback called, or undefined
+   */
+  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);
+    if (result !== undefined) {
+      return result;
+    }
+    for (var i = visibleStartIndex; i <= visibleEndIndex; i += 1) {
+      result = callback(i);
+      if (result !== undefined) {
+        return result;
+      }
+    }
+    return undefined;
+  }
+
+  /**
+   * Check if the coordinate is within the item specified in this dimension
+   * @param itemIndex Index of the item to check
+   * @param itemCoordinatess Coordinate of all items in this dimension
+   * @param itemSizes Size of all items in this dimension
+   * @param coordinate The coordinate to check
+   * @returns True if the coordinate is within the item specified, false otherwise
+   */
+  static isInItem(itemIndex, itemCoordinates, itemSizes, coordinate) {
+    var _itemCoordinates$get, _itemSizes$get;
+    var itemX = (_itemCoordinates$get = itemCoordinates.get(itemIndex)) !== null && _itemCoordinates$get !== void 0 ? _itemCoordinates$get : 0;
+    var itemSize = (_itemSizes$get = itemSizes.get(itemIndex)) !== null && _itemSizes$get !== void 0 ? _itemSizes$get : 0;
+    return itemX <= coordinate && coordinate <= itemX + itemSize;
+  }
+
+  /**
+   * Get the Index of the item at the provided offset
+   * @param offset Coordinate of the offset to get the item of
+   * @param itemCount The total count of items
+   * @param floatingStart Count of floating items at the start
+   * @param floatingEnd Count of floating items at the end
+   * @param items Index of all items
+   * @param itemCoordinates The coordinate of each item
+   * @param itemSizes The size of each item
+   * @returns The item index, or null if no item matches
+   */
+  static getItemAtOffset(offset, itemCount, floatingStart, floatingEnd, items, itemCoordinates, itemSizes) {
+    var ignoreFloating = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : false;
+    var floatingItem = ignoreFloating ? undefined : GridUtils.iterateFloating(floatingStart, floatingEnd, itemCount, item => {
+      if (GridUtils.isInItem(item, itemCoordinates, itemSizes, offset)) {
+        return item;
+      }
+      return undefined;
+    });
+    if (!ignoreFloating && floatingItem !== undefined) {
+      return floatingItem;
+    }
+    for (var i = 0; i < items.length; i += 1) {
+      var item = items[i];
+      if (GridUtils.isInItem(item, itemCoordinates, itemSizes, offset)) {
+        return item;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Get the index of the column at the specified x coordinate
+   * @param x Coordinate to get the item of
+   * @param metrics Grid metrics
+   * @returns Index of the column at that coordinate, or null if no column matches
+   */
+  static getColumnAtX(x, metrics) {
+    var ignoreFloating = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    var {
+      columnCount,
+      floatingLeftColumnCount,
+      floatingRightColumnCount,
+      visibleColumns,
+      allColumnXs,
+      allColumnWidths,
+      gridX
+    } = metrics;
+    if (x < gridX) {
+      return null;
+    }
+    return this.getItemAtOffset(x - gridX, columnCount, floatingLeftColumnCount, floatingRightColumnCount, visibleColumns, allColumnXs, allColumnWidths, ignoreFloating);
+  }
+
+  /**
+   * Get the index of the row at the specified y coordinate
+   * @param y Coordinate to get the item of
+   * @param metrics Grid metrics
+   * @returns Index of the row at that coordinate, or null if no row matches
+   */
+  static getRowAtY(y, metrics) {
+    var {
+      floatingTopRowCount,
+      floatingBottomRowCount,
+      rowCount,
+      visibleRows,
+      allRowYs,
+      allRowHeights,
+      gridY
+    } = metrics;
+    if (y < gridY) {
+      return null;
+    }
+    return this.getItemAtOffset(y - gridY, rowCount, floatingTopRowCount, floatingBottomRowCount, visibleRows, allRowYs, allRowHeights);
+  }
+
+  /**
+   * Iterate backward through the visible items until a shown item is hit
+   * @param startIndex The index to start from
+   * @param modelIndexes The mapping of model indexes
+   * @param visibleItems The visible items
+   * @param userSizes The user set sizes
+   * @returns Index of the next visible item, or null if no more are visible
+   */
+  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);
+      if (modelIndex != null && userSizes.get(modelIndex) !== 0) {
+        return item;
+      }
+      visibleItemIndex -= 1;
+    }
+    return null;
+  }
+
+  /**
+   * Iterate backward through the visible columns until a shown column is hit
+   * @param columnIndex The column index to start iterating backward from
+   * @param metrics The GridMetricCalculator metrics
+   * @returns Index of the next visible item, or null if no more are visible
+   */
+  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 rowIndex The row index to start iterating backward from
+   * @param metrics The GridMetricCalculator metrics
+   * @returns Index of the next visible item, or null if no more are visible
+   */
+  static getNextShownRow(startIndex, metrics) {
+    var {
+      modelRows,
+      visibleRows,
+      userRowHeights
+    } = metrics;
+    return GridUtils.getNextShownItem(startIndex, modelRows, visibleRows, userRowHeights);
+  }
+
+  /**
+   * Gets the column index if the x/y coordinates provided are close enough to the separator, otherwise null
+   * @param x Mouse x coordinate
+   * @param y Mouse y coordinate
+   * @param metrics The grid metrics
+   * @param theme The grid theme with potential user overrides
+   * @returns Index of the column separator at the coordinates provided, or null if none match
+   */
+  static getColumnSeparatorIndex(x, y, metrics, theme) {
+    var {
+      rowHeaderWidth,
+      columnHeaderHeight,
+      floatingColumns,
+      floatingLeftWidth,
+      visibleColumns,
+      allColumnXs,
+      allColumnWidths,
+      columnHeaderMaxDepth
+    } = metrics;
+    var {
+      allowColumnResize,
+      headerSeparatorHandleSize
+    } = theme;
+    if (columnHeaderMaxDepth * columnHeaderHeight < y || !allowColumnResize || headerSeparatorHandleSize <= 0) {
+      return null;
+    }
+    var gridX = x - rowHeaderWidth;
+    var halfSeparatorSize = headerSeparatorHandleSize * 0.5;
+
+    // Iterate through the floating columns first since they're on top
+    var isPreviousColumnHidden = false;
+    for (var i = floatingColumns.length - 1; i >= 0; i -= 1) {
+      var _allColumnXs$get, _allColumnWidths$get;
+      var column = floatingColumns[i];
+      var columnX = (_allColumnXs$get = allColumnXs.get(column)) !== null && _allColumnXs$get !== void 0 ? _allColumnXs$get : 0;
+      var columnWidth = (_allColumnWidths$get = allColumnWidths.get(column)) !== null && _allColumnWidths$get !== void 0 ? _allColumnWidths$get : 0;
+      var isColumnHidden = columnWidth === 0;
+      if (!isPreviousColumnHidden || !isColumnHidden) {
+        var midX = columnX + columnWidth;
+        if (isColumnHidden) {
+          midX += halfSeparatorSize;
+        } else if (isPreviousColumnHidden) {
+          midX -= halfSeparatorSize;
+        }
+        var minX = midX - halfSeparatorSize;
+        var maxX = midX + halfSeparatorSize;
+        if (minX <= gridX && gridX <= maxX) {
+          return column;
+        }
+        isPreviousColumnHidden = isColumnHidden;
+      }
+    }
+
+    // Iterate backward so that you can reveal hidden columns properly
+    isPreviousColumnHidden = false;
+    for (var _i = visibleColumns.length - 1; _i >= 0; _i -= 1) {
+      var _allColumnXs$get2, _allColumnWidths$get2;
+      var _column = visibleColumns[_i];
+      var _columnX = (_allColumnXs$get2 = allColumnXs.get(_column)) !== null && _allColumnXs$get2 !== void 0 ? _allColumnXs$get2 : 0;
+      var _columnWidth = (_allColumnWidths$get2 = allColumnWidths.get(_column)) !== null && _allColumnWidths$get2 !== void 0 ? _allColumnWidths$get2 : 0;
+      var _isColumnHidden = _columnWidth === 0;
+
+      // If this column is under the floating columns "layer". Terminate early.
+      if (_columnX < floatingLeftWidth - _columnWidth) {
+        return null;
+      }
+      if (!isPreviousColumnHidden || !_isColumnHidden) {
+        var _midX = _columnX + _columnWidth;
+        if (_isColumnHidden) {
+          _midX += halfSeparatorSize;
+        } else if (isPreviousColumnHidden) {
+          _midX -= halfSeparatorSize;
+        }
+        var _minX = _midX - halfSeparatorSize;
+        var _maxX = _midX + halfSeparatorSize;
+        if (_minX <= gridX && gridX <= _maxX) {
+          return _column;
+        }
+        isPreviousColumnHidden = _isColumnHidden;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Check if the item specified is hidden
+   * @param itemIndex Index of the item to check
+   * @param visibleSizes Sizes of all visible items
+   * @returns True if the item is hidden, false otherwise
+   */
+  static isItemHidden(itemIndex, visibleSizes) {
+    return visibleSizes.get(itemIndex) === 0;
+  }
+
+  /**
+   * Check if the column specified is hidden
+   * @param columnIndex Index of the column to check
+   * @param metrics Grid metrics
+   * @returns True if the column is hidden, false otherwise
+   */
+  static isColumnHidden(columnIndex, metrics) {
+    var {
+      allColumnWidths
+    } = metrics;
+    return GridUtils.isItemHidden(columnIndex, allColumnWidths);
+  }
+
+  /**
+   * Check if the provided row is a floating row
+   * @param row The row index to check
+   * @param metrics The grid metrics to check against
+   * @returns True if it's a floating row, false otherwise
+   */
+  static isFloatingRow(row, metrics) {
+    if (row == null) {
+      return false;
+    }
+    var {
+      floatingTopRowCount,
+      floatingBottomRowCount,
+      rowCount
+    } = metrics;
+    return row < floatingTopRowCount || row >= rowCount - floatingBottomRowCount;
+  }
+
+  /**
+   * Check if the provided column is a floating column
+   * @param column The column index to check
+   * @param metrics The grid metrics to check against
+   * @returns True if it's a floating column, false otherwise
+   */
+  static isFloatingColumn(column, metrics) {
+    if (column == null) {
+      return false;
+    }
+    var {
+      floatingLeftColumnCount,
+      floatingRightColumnCount,
+      columnCount
+    } = metrics;
+    return column < floatingLeftColumnCount || column >= columnCount - floatingRightColumnCount;
+  }
+
+  /**
+   * Get all the items that are hidden under the same Index
+   * E.g. If columns are 1, 2, 3, 4, 5, and column 2, 3, 4 are hidden, and we check for item 4, the return will be [2, 3, 4]
+   * @param itemIndex Index of the item to start at
+   * @param visibleSizes Visible size map
+   * @param visibleItems Visible items
+   * @returns Array of items that are hidden
+   */
+  static getHiddenItems(itemIndex, visibleSizes, visibleItems) {
+    if (!GridUtils.isItemHidden(itemIndex, visibleSizes)) {
+      return [];
+    }
+    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;
+      }
+      hiddenItems.push(item);
+    }
+    return hiddenItems;
+  }
+
+  /**
+   * Get all the columns that are hidden under the same Index
+   * @param columnIndex Index of the item to start at
+   * @param metrics Grid metrics
+   * @returns Array of items that are hidden
+   */
+  static getHiddenColumns(columnIndex, metrics) {
+    var {
+      visibleColumns,
+      allColumnWidths
+    } = metrics;
+    return GridUtils.getHiddenItems(columnIndex, allColumnWidths, visibleColumns);
+  }
+
+  /**
+   * Returns the row index if the x/y coordinates provided are close enough to the separator, otherwise null
+   * @param x X coordinate to check
+   * @param y Y coordinate to check
+   * @param metrics The grid metrics
+   * @param theme The grid theme
+   * @returns Index of the row separator at the coordinates provided, or null if none match
+   */
+  static getRowSeparatorIndex(x, y, metrics, theme) {
+    var {
+      rowHeaderWidth,
+      columnHeaderHeight,
+      visibleRows,
+      allRowYs,
+      allRowHeights
+    } = metrics;
+    var {
+      allowRowResize,
+      headerSeparatorHandleSize
+    } = theme;
+    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
+    var isPreviousRowHidden = false;
+    for (var i = visibleRows.length - 1; i >= 0; i -= 1) {
+      var _allRowYs$get, _allRowHeights$get;
+      var row = visibleRows[i];
+      var rowY = (_allRowYs$get = allRowYs.get(row)) !== null && _allRowYs$get !== void 0 ? _allRowYs$get : 0;
+      var rowHeight = (_allRowHeights$get = allRowHeights.get(row)) !== null && _allRowHeights$get !== void 0 ? _allRowHeights$get : 0;
+      var isRowHidden = rowHeight === 0;
+      if (!isPreviousRowHidden || !isRowHidden) {
+        var midY = rowY + rowHeight;
+        if (isRowHidden) {
+          midY += halfSeparatorSize;
+        } else if (isPreviousRowHidden) {
+          midY -= halfSeparatorSize;
+        }
+        var minY = midY - halfSeparatorSize;
+        var maxY = midY + halfSeparatorSize;
+        if (minY <= gridY && gridY <= maxY) {
+          return row;
+        }
+        isPreviousRowHidden = isRowHidden;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Check if the row specified is hidden
+   * @param rowIndex Index of the row to check
+   * @param metrics Grid metrics
+   * @returns True if the row is hidden, false otherwise
+   */
+  static isRowHidden(rowIndex, metrics) {
+    var {
+      allRowHeights
+    } = metrics;
+    return GridUtils.isItemHidden(rowIndex, allRowHeights);
+  }
+
+  /**
+   * Get all the rows that are hidden under the same Index
+   * @param rowIndex Index of the item to start at
+   * @param metrics Grid metrics
+   * @returns Array of items that are hidden
+   */
+  static getHiddenRows(rowIndex, metrics) {
+    var {
+      visibleRows,
+      allRowHeights
+    } = metrics;
+    return GridUtils.getHiddenItems(rowIndex, allRowHeights, visibleRows);
+  }
+
+  /**
+   * Set a new order for items in the grid
+   * @param from The visible index to move from
+   * @param to The visible index to move the item to
+   * @param oldMovedItems The old reordered items
+   * @returns The new reordered items
+   */
+  static moveItem(from, to, oldMovedItems) {
+    if (from === to) {
+      return [...oldMovedItems];
+    }
+    var movedItems = [...oldMovedItems];
+    var lastMovedItem = movedItems[movedItems.length - 1];
+
+    // Check if we should combine with the previous move
+    // E.g. 1 -> 2, 2 -> 3 can just be 1 -> 3
+    if (lastMovedItem != null && !isBoundedAxisRange(lastMovedItem.from) && lastMovedItem.to === from) {
+      // Remove the move if it is now a no-op
+      if (lastMovedItem.from === to) {
+        movedItems.pop();
+      } else {
+        movedItems[movedItems.length - 1] = _objectSpread(_objectSpread({}, lastMovedItem), {}, {
+          to
+        });
+      }
+    } else {
+      movedItems.push({
+        from,
+        to
+      });
+    }
+    return movedItems;
+  }
+
+  /**
+   * Move a visible range in the grid
+   *
+   * This will effectively slice the range out of the grid,
+   * re-index the remaining columns,
+   * then insert the range with the first element at the provided index
+   *
+   * @param from The visible axis range to move
+   * @param to The visible index to move the start of the range to
+   * @param oldMovedItems The old reordered items
+   * @param isPreMoveTo If toParam is the index before the movement
+   *                    If true, this will account for the shift when moving
+   *                    a range before the drop positin
+   *                    E.g. Move range [0, 2] 1 item down (after element 3)
+   *                    The move is [0, 2] -> 1 if this is false. [0, 2] -> 3 if this is true
+   *                    Both will result in [0, 2] -> 1
+   * @returns The new reordered items
+   */
+  static moveRange(from, toParam, oldMovedItems) {
+    var isPreMoveTo = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+    if (from[0] === from[1]) {
+      return GridUtils.moveItem(from[0], toParam, oldMovedItems);
+    }
+    var to = toParam;
+    if (isPreMoveTo && from[0] < toParam) {
+      to -= from[1] - from[0];
+    }
+    if (from[0] === to) {
+      return [...oldMovedItems];
+    }
+    var movedItems = [...oldMovedItems];
+    var lastMovedItem = movedItems[movedItems.length - 1];
+
+    // Check if we should combine with the previous move
+    // E.g. [1, 2] -> 2, [2, 3] -> 3 can just be [1, 2] -> 3
+    if (lastMovedItem != null && isBoundedAxisRange(lastMovedItem.from) && lastMovedItem.from[1] - lastMovedItem.from[0] === from[1] - from[0] && lastMovedItem.to === from[0]) {
+      movedItems[movedItems.length - 1] = _objectSpread(_objectSpread({}, lastMovedItem), {}, {
+        to
+      });
+    } else {
+      movedItems.push({
+        from,
+        to
+      });
+    }
+    var newLastMovedItem = movedItems[movedItems.length - 1];
+    // Remove the move if it is now a no-op
+    if (isBoundedAxisRange(newLastMovedItem.from) && newLastMovedItem.from[0] === newLastMovedItem.to) {
+      movedItems.pop();
+    }
+    return movedItems;
+  }
+  static moveItemOrRange(from, to, oldMovedItems) {
+    var isPreMoveTo = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+    return Array.isArray(from) ? GridUtils.moveRange(from, to, oldMovedItems, isPreMoveTo) : GridUtils.moveItem(from, to, oldMovedItems);
+  }
+
+  /**
+   * Applies the items moves to the AxisRange
+   * @param start The start index of the range
+   * @param end The end index of the range
+   * @param movedItems The move operations to apply
+   * @param reverse If the moved items should be applied in reverse (this reverses the effects of the moves)
+   * @returns A list of AxisRanges in the translated space. Possibly multiple non-continuous ranges
+   */
+  static applyItemMoves(start, end, movedItems) {
+    var reverse = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+    var result = [[start, end]];
+    var _loop = function _loop() {
+      var {
+        from: fromItemOrRange,
+        to: toItem
+      } = movedItems[i];
+      var length = 1;
+      var fromItem;
+      if (isBoundedAxisRange(fromItemOrRange)) {
+        length = fromItemOrRange[1] - fromItemOrRange[0] + 1; // Ranges are inclusive
+        [fromItem] = fromItemOrRange;
+      } else {
+        fromItem = fromItemOrRange;
+      }
+      var fromStart = reverse ? toItem : fromItem;
+      var fromEnd = fromStart + length - 1;
+      var toStart = reverse ? fromItem : toItem;
+      var moveDistance = toStart - fromStart;
+      var nextResult = [];
+      var _loop2 = function _loop2() {
+        var _result$j$, _result$j$2;
+        var currentStart = (_result$j$ = result[j][0]) !== null && _result$j$ !== void 0 ? _result$j$ : Number.NEGATIVE_INFINITY;
+        var currentEnd = (_result$j$2 = result[j][1]) !== null && _result$j$2 !== void 0 ? _result$j$2 : Number.POSITIVE_INFINITY;
+        var movedRange;
+        var currentResult = [[currentStart, fromStart - 1], [fromStart, fromEnd], [fromEnd + 1, currentEnd]].map(_ref2 => {
+          var [s, e] = _ref2;
+          return [
+          // Cap the ranges to within the current range bounds
+          Math.max(s, currentStart), Math.min(e, currentEnd)];
+        }).filter(_ref3 => {
+          var [s, e] = _ref3;
+          return s <= e;
+        }) // Remove invalid ranges
+        .map(range => {
+          var [s, e] = range;
+          if (fromStart <= s && fromEnd >= e) {
+            // Current range in moved range
+            movedRange = [s + moveDistance, e + moveDistance];
+            return movedRange;
+          }
+          if (fromEnd < s) {
+            // Current range is after moved range
+            return [s - length, e - length];
+          }
+          return range;
+        }).map(range => {
+          var [s, e] = range;
+          if (toStart > s && toStart <= e) {
+            // Moved range splits this range
+            return [[s, toStart - 1], [toStart + length, e + length]];
+          }
+          if (range === movedRange) {
+            // Moved range has already been shifted
+            return [range];
+          }
+          if (toStart <= s) {
+            // Moved range shifts this range right
+            return [[s + length, e + length]];
+          }
+          return [range];
+        }).flat();
+        nextResult.push(...currentResult);
+      };
+      for (var j = 0; j < result.length; j += 1) {
+        _loop2();
+      }
+
+      // Return infinity values back to null
+      result = nextResult.map(_ref => {
+        var [s, e] = _ref;
+        return [Number.isFinite(s) ? s : null, Number.isFinite(e) ? e : null];
+      });
+    };
+    for (var i = reverse ? movedItems.length - 1 : 0; reverse ? i >= 0 : i < movedItems.length; reverse ? i -= 1 : i += 1) {
+      _loop();
+    }
+    return result;
+  }
+
+  /**
+   * Applies the items moves to the givengrid range
+   * @param range The grid range to translate
+   * @param movedColumns The moved columns
+   * @param movedRows The moved rows
+   * @param reverse If the moved items should be reversed (i.e. visible to model range)
+   * @returns A list of grid ranges in the translated space. Possibly multiple non-continuous ranges
+   */
+  static translateRange(range, movedColumns, movedRows, reverse) {
+    var columnRanges = GridUtils.applyItemMoves(range.startColumn, range.endColumn, movedColumns, reverse);
+    var rowRanges = GridUtils.applyItemMoves(range.startRow, range.endRow, movedRows, reverse);
+    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;
+  }
+
+  /**
+   * Retrieve the model index given the currently moved items
+   * @param visibleIndex The visible index of the item to get the model index for
+   * @param movedItems The moved items
+   * @returns The model index of the item
+   */
+  static getModelIndex(visibleIndex, movedItems) {
+    var modelIndex = GridUtils.applyItemMoves(visibleIndex, visibleIndex, movedItems, true)[0][0];
+    return modelIndex;
+  }
+
+  /**
+   * Retrieve the model indexes given the currently moved items
+   * @param visibleIndexes The visible indexes of the item to get the model indexes for
+   * @param movedItems The moved items
+   * @returns The model indexes of the item
+   */
+  static getModelIndexes(visibleIndexes, movedItems) {
+    return visibleIndexes.map(i => GridUtils.getModelIndex(i, movedItems));
+  }
+
+  /**
+   * 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 start Start item in one dimension
+   * @param end End item in one dimension
+   * @param movedItems Moved item pairs in this dimension
+   * @returns Array of start/end pairs of the indexes after transformations applied.
+   */
+  static getModelRangeIndexes(start, end, movedItems) {
+    return GridUtils.applyItemMoves(start, end, movedItems, true);
+  }
+
+  /**
+   * 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 uiRange The currently selected UI ranges
+   * @param movedColumns The moved column pairs
+   * @param movedRows The moved row pairs
+   * @returns The model ranges after translation.
+   */
+  static getModelRange(uiRange) {
+    var movedColumns = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : EMPTY_ARRAY;
+    var movedRows = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : EMPTY_ARRAY;
+    return GridUtils.translateRange(uiRange, movedColumns, movedRows, true);
+  }
+
+  /**
+   * 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 uiRanges The currently selected UI ranges
+   * @param movedColumns The moved column pairs
+   * @param movedRows The moved row pairs
+   * @returns The model ranges after translation.
+   */
+  static getModelRanges(uiRanges) {
+    var movedColumns = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : EMPTY_ARRAY;
+    var movedRows = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : EMPTY_ARRAY;
+    var modelRanges = [];
+    for (var i = 0; i < uiRanges.length; i += 1) {
+      modelRanges.push(...GridUtils.getModelRange(uiRanges[i], movedColumns, movedRows));
+    }
+    return modelRanges;
+  }
+
+  /**
+   * Translate the provided UI start/end indexes to the visible start/end indexes by applying the `movedItems` transformations.
+   * Since moved items can split apart a range, multiple pairs of indexes are returned
+   *
+   * @param start Start item in one dimension
+   * @param end End item in one dimension
+   * @param movedItems Moved item pairs in this dimension
+   * @returns Array of start/end pairs of the indexes after transformations applied.
+   */
+  static getVisibleRangeIndexes(start, end, movedItems) {
+    return GridUtils.applyItemMoves(start, end, movedItems, false);
+  }
+
+  /**
+   * Translate the provided UI range into visible 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 uiRange The currently selected UI ranges
+   * @param movedColumns The moved column pairs
+   * @param movedRows The moved row pairs
+   * @returns The model ranges after translation.
+   */
+  static getVisibleRange(modelRange) {
+    var movedColumns = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : EMPTY_ARRAY;
+    var movedRows = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : EMPTY_ARRAY;
+    return this.translateRange(modelRange, movedColumns, movedRows, false);
+  }
+
+  /**
+   * Translate the provided model ranges into visible 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 modelRanges The model ranges
+   * @param movedColumns The moved column pairs
+   * @param movedRows The moved row pairs
+   * @returns The model ranges after translation.
+   */
+  static getVisibleRanges(modelRanges) {
+    var movedColumns = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : EMPTY_ARRAY;
+    var movedRows = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : EMPTY_ARRAY;
+    var visibleRanges = [];
+    for (var i = 0; i < modelRanges.length; i += 1) {
+      visibleRanges.push(...GridUtils.getVisibleRange(modelRanges[i], movedColumns, movedRows));
+    }
+    return visibleRanges;
+  }
+
+  /**
+   * Retrieve the visible index given the currently moved items
+   * @param modelIndex The model index to get the visible index for
+   * @param movedItems Moved items
+   * @returns The visible index of the item
+   */
+  static getVisibleIndex(modelIndex, movedItems) {
+    var visibleIndex = GridUtils.applyItemMoves(modelIndex, modelIndex, movedItems)[0][0];
+    return visibleIndex;
+  }
+
+  /**
+   * Retrieve the visible indexes given the currently moved items
+   * @param modelIndexes The model indexes to get the visible indexes for
+   * @param movedItems Moved items
+   * @returns The visible indexes of the item
+   */
+  static getVisibleIndexes(modelIndexes, movedItems) {
+    return modelIndexes.map(i => GridUtils.getVisibleIndex(i, movedItems));
+  }
+
+  /**
+   * Check if the current platform is Mac
+   * @returns True if this platform is a Mac, false otherwise
+   */
+  static isMacPlatform() {
+    var {
+      platform
+    } = window.navigator;
+    return platform.startsWith('Mac');
+  }
+
+  /**
+   * Get the modifier key for the current platform
+   * @returns The modifier key for the current platform
+   */
+  static getModifierKey() {
+    if (GridUtils.isMacPlatform()) {
+      return 'metaKey';
+    }
+    return 'ctrlKey';
+  }
+
+  /**
+   * Check if the modifier key is down for the given event
+   * @param event The event to check
+   * @returns True if the modifier key is down, false otherwise
+   */
+  static isModifierKeyDown(event) {
+    var modifierKey = GridUtils.getModifierKey();
+    return event[modifierKey];
+  }
+
+  /**
+   * Check if the user has hidden the specified column
+   * @param modelIndex The model index to check
+   * @param userColumnWidths The user set column widths
+   * @returns True if the user has hidden the column
+   */
+  static checkColumnHidden(modelIndex, userColumnWidths) {
+    return userColumnWidths.get(modelIndex) === 0;
+  }
+
+  /**
+   * Check if all the columns specified are hidden
+   * @param columns Columns to check
+   * @param userColumnWidths The user set column widths
+   * @returns True if the user has hidden all of the columns
+   */
+  static checkAllColumnsHidden(columns, userColumnWidths) {
+    if (userColumnWidths.size === 0) {
+      return false;
+    }
+    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 metrics Grid metrics
+   * @param row The row they started dragging in
+   * @param 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 x1 = gridX;
+    var y1 = gridY;
+    var x2 = width;
+    var y2 = height;
+    if (column != null) {
+      if (column > floatingLeftColumnCount) {
+        x1 += floatingLeftWidth;
+      }
+      if (column < columnCount - floatingRightColumnCount) {
+        x2 -= floatingRightWidth;
+      }
+    }
+    if (row != null) {
+      if (row > floatingTopRowCount) {
+        y1 += floatingTopHeight;
+      }
+      if (row < rowCount - floatingBottomRowCount) {
+        y2 -= floatingBottomHeight;
+      }
+    }
+    return {
+      x1,
+      y1,
+      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 The mouse wheel event to get the scrolling delta for
+   * @param pageWidth The width of the page that is scrolling
+   * @param pageHeight The height of the page that is scrolling
+   * @param lineWidth The width of the line scrolling in line mode
+   * @param lineHeight The height of the line scrolling in line mode
+   * @returns 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 {
+      deltaX,
+      deltaY
+    };
+  }
+  static compareRanges(range1, range2) {
+    if (range1[0] == null || range1[1] == null || range2[0] == null || range2[1] == null) {
+      return 0;
+    }
+    return range1[0] !== range2[0] ? range1[0] - range2[0] : range1[1] - range2[1];
+  }
+  static mergeSortedRanges(ranges) {
+    var mergedRanges = [];
+    for (var i = 0; i < ranges.length; i += 1) {
+      var range = ranges[i];
+      var start = range[0];
+      var end = range[1];
+      if (i === 0) {
+        mergedRanges.push([start, end]);
+      } else if (start - 1 <= mergedRanges[mergedRanges.length - 1][1]) {
+        mergedRanges[mergedRanges.length - 1][1] = Math.max(mergedRanges[mergedRanges.length - 1][1], end);
+      } else {
+        mergedRanges.push([start, end]);
+      }
+    }
+    return mergedRanges;
+  }
+
+  /**
+   * Translates coordinates that are relative to gridX/gridY to be translated by gridX and gridY
+   * @param tokenBox The token box to translate
+   * @param metrics The grid metrics
+   * @returns The token box with translated coordinates
+   */
+  static translateTokenBox(tokenBox, metrics) {
+    var {
+      x1: left,
+      y1: top,
+      x2: right,
+      y2: bottom
+    } = tokenBox;
+    var {
+      gridX,
+      gridY,
+      width: gridWidth,
+      height: gridHeight,
+      verticalBarWidth,
+      horizontalBarHeight
+    } = metrics;
+
+    // Clamp the values within the grid
+    var newLeft = clamp(gridX + left, gridX, gridWidth - verticalBarWidth);
+    var newRight = clamp(gridX + right, gridX, gridWidth - verticalBarWidth);
+    var newTop = clamp(gridY + top, gridY, gridHeight - horizontalBarHeight);
+    var newBottom = clamp(gridY + bottom, gridY, gridHeight - horizontalBarHeight);
+    return {
+      x1: newLeft,
+      y1: newTop,
+      x2: newRight,
+      y2: newBottom,
+      token: tokenBox.token
+    };
+  }
+
+  /**
+   * Gets textWidth and X-Y position for a specific cell
+   * The textWidth returned is the width that the text can occupy accounting for any other cell markings
+   * The width accounts for tree table indents and cell padding, so it is the width the text may consume
+   *
+   * @param state GridRenderState to get the text metrics for
+   * @param column Column of cell to get text metrics for
+   * @param row Row of cell to get text metrics for
+   * @returns Object with width, x, and y of the text
+   */
+  static getTextRenderMetrics(state, column, row) {
+    var {
+      metrics,
+      model,
+      theme
+    } = state;
+    var {
+      firstColumn,
+      allColumnXs,
+      allColumnWidths,
+      allRowYs,
+      allRowHeights,
+      modelRows,
+      modelColumns
+    } = metrics;
+    var {
+      cellHorizontalPadding,
+      treeDepthIndent,
+      treeHorizontalPadding
+    } = theme;
+    var modelRow = getOrThrow(modelRows, row);
+    var modelColumn = getOrThrow(modelColumns, column);
+    var textAlign = model.textAlignForCell(modelColumn, modelRow);
+    var x = getOrThrow(allColumnXs, column);
+    var y = getOrThrow(allRowYs, row);
+    var columnWidth = getOrThrow(allColumnWidths, column);
+    var rowHeight = getOrThrow(allRowHeights, row);
+    var isFirstColumn = column === firstColumn;
+    var treeIndent = 0;
+    if (isExpandableGridModel(model) && model.hasExpandableRows && isFirstColumn) {
+      treeIndent = treeDepthIndent * (model.depthForRow(row) + 1) + treeHorizontalPadding;
+    }
+    var textWidth = columnWidth - treeIndent;
+    var textX = x + cellHorizontalPadding;
+    var textY = y + rowHeight * 0.5;
+    if (textAlign === 'right') {
+      textX = x + textWidth - cellHorizontalPadding;
+    } else if (textAlign === 'center') {
+      textX = x + textWidth * 0.5;
+    }
+    textX += treeIndent;
+    return {
+      width: textWidth - cellHorizontalPadding * 2,
+      x: textX,
+      y: textY
+    };
+  }
+
+  /**
+   * Finds tokens in text (urls, emails) that start with https:// or http://
+   * @param text The text to search in
+   * @returns An array of tokens
+   */
+  static findTokensWithProtocolInText(text) {
+    var tokens = linkifyFind(text);
+    return tokens.filter(token => {
+      if (token.type === 'url') {
+        return /^https?:\/\//.test(token.value);
+      }
+      return true;
+    });
+  }
+}
+_defineProperty(GridUtils, "PIXELS_PER_LINE", 100 / 3);
+export default GridUtils;
+//# sourceMappingURL=GridUtils.js.map