@deephaven/grid 0.43.0 → 0.44.0

package/dist/GridRange.js

@@ -0,0 +1,684 @@
+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); }
+// Also exported via GridRange.SELECTION_DIRECTION
+export var SELECTION_DIRECTION;
+(function (SELECTION_DIRECTION) {
+  SELECTION_DIRECTION["DOWN"] = "DOWN";
+  SELECTION_DIRECTION["UP"] = "UP";
+  SELECTION_DIRECTION["LEFT"] = "LEFT";
+  SELECTION_DIRECTION["RIGHT"] = "RIGHT";
+})(SELECTION_DIRECTION || (SELECTION_DIRECTION = {}));
+export class GridRange {
+  /**
+   * Returns a normalized array of indexes ensuring left <= right and top <= bottom
+   * @param startColumn Start column index
+   * @param startRow Start row index
+   * @param endColumn End column index
+   * @param endRow End row index
+   * @returns Array containing normalized indexes [left, top, right, bottom]
+   */
+  static normalize(startColumn, startRow, endColumn, endRow) {
+    var left = startColumn;
+    var top = startRow;
+    var right = endColumn;
+    var bottom = endRow;
+    if (left != null && right != null && right < left) {
+      left = right;
+      right = startColumn;
+    }
+    if (top != null && bottom != null && bottom < top) {
+      top = bottom;
+      bottom = startRow;
+    }
+    return [left, top, right, bottom];
+  }
+
+  /**
+   * Makes a GridRange ensuring startColumn <= endColumn, startRow <= endRow
+   * @param startColumn Start column index
+   * @param startRow Start row index
+   * @param endColumn End column index
+   * @param endRow End row index
+   * @returns Normalized GridRange
+   */
+  static makeNormalized(startColumn, startRow, endColumn, endRow) {
+    return new GridRange(...GridRange.normalize(startColumn, startRow, endColumn, endRow));
+  }
+
+  /**
+   * Creates a GridRange representing a single cell
+   * @param column Column index
+   * @param row Row index
+   * @returns GridRange representing the cell
+   */
+  static makeCell(column, row) {
+    return new GridRange(column, row, column, row);
+  }
+
+  /**
+   * Creates a GridRange representing an infinite length column
+   * @param column Column index
+   * @returns GridRange representing the column
+   */
+  static makeColumn(column) {
+    return new GridRange(column, null, column, null);
+  }
+
+  /**
+   * Creates a GridRange representing an infinite length row
+   * @param row Row index
+   * @returns GridRange representing the row
+   */
+  static makeRow(row) {
+    return new GridRange(null, row, null, row);
+  }
+
+  /**
+   * Returns the minimum value between 2 range indexes or null if at least 1 is null
+   * @param index1 First grid range index
+   * @param index2 Second grid range index
+   * @returns Minimum index or null if either index is null
+   */
+  static minOrNull(index1, index2) {
+    if (index1 == null || index2 == null) {
+      return null;
+    }
+    return Math.min(index1, index2);
+  }
+
+  /**
+   * Returns the maximum value between 2 range indexes or null if at least 1 is null
+   * @param index1 First grid range index
+   * @param index2 Second grid range index
+   * @returns Maximum index or null if either index is null
+   */
+  static maxOrNull(index1, index2) {
+    if (index1 == null || index2 == null) {
+      return null;
+    }
+    return Math.max(index1, index2);
+  }
+
+  /**
+   * Consolidate the passed in ranges to the minimum set, merging overlapping ranges.
+   * @param ranges The ranges to consolidate
+   * @returns Consolidated ranges
+   */
+  static consolidate(ranges) {
+    var result = ranges.slice();
+    var wasModified = true;
+    while (wasModified) {
+      wasModified = false;
+      for (var i = 0; i < result.length && !wasModified; i += 1) {
+        var range = result[i];
+        for (var j = result.length - 1; j > i; j -= 1) {
+          var other = result[j];
+
+          // If one contains the other, we can just keep the bigger one
+          if (range.contains(other)) {
+            result.splice(j, 1);
+          } else if (other.contains(range)) {
+            wasModified = true;
+            result[i] = other;
+            result.splice(j, 1);
+            break;
+          } else if (range.startRow === other.startRow && range.endRow === other.endRow) {
+            if (range.touches(other)) {
+              // If the start/end rows match, and columns touch, consolidate
+              var {
+                startRow,
+                endRow
+              } = range;
+              var startColumn = GridRange.minOrNull(range.startColumn, other.startColumn);
+              var endColumn = GridRange.maxOrNull(range.endColumn, other.endColumn);
+              wasModified = true;
+              result[i] = new GridRange(startColumn, startRow, endColumn, endRow);
+              result.splice(j, 1);
+              break;
+            }
+          } else if (range.startColumn === other.startColumn && range.endColumn === other.endColumn) {
+            if (range.touches(other)) {
+              // If the start/end rows match, and columns touch, consolidate
+              var {
+                startColumn: _startColumn,
+                endColumn: _endColumn
+              } = range;
+              var _startRow = GridRange.minOrNull(range.startRow, other.startRow);
+              var _endRow = GridRange.maxOrNull(range.endRow, other.endRow);
+              wasModified = true;
+              result[i] = new GridRange(_startColumn, _startRow, _endColumn, _endRow);
+              result.splice(j, 1);
+              break;
+            }
+          }
+        }
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Checks if the 1-D ranges between 2 index pairs overlap or are continuous.
+   * For example ranges [0, 1] and [2, 3] are continuous and will return true.
+   * [0, 1] and [1, 3] overlap and return true.
+   * [0, 1] and [3, 4] do not overlap and have a gap so this will return false.
+   * @param start1 Start of 1st range
+   * @param end1 End of 1st range
+   * @param start2 Start of 2nd range
+   * @param end2 End of 2nd range
+   * @returns True if the ranges overlap or touch, else false
+   */
+  static isAxisRangeTouching(start1, end1, start2, end2) {
+    if (start1 == null) {
+      if (end1 == null) {
+        return true;
+      }
+      if (start2 == null) {
+        return true;
+      }
+      return start2 <= end1 + 1;
+    }
+    if (end1 == null) {
+      if (end2 == null) {
+        return true;
+      }
+      return end2 >= start1 - 1;
+    }
+    if (start2 == null) {
+      if (end2 == null) {
+        return true;
+      }
+      return start1 <= end2 + 1;
+    }
+    if (end2 == null) {
+      return end1 >= start2 - 1;
+    }
+    if (start2 >= start1 - 1) {
+      return start2 <= end1 + 1;
+    }
+    return end2 >= start1 - 1;
+  }
+
+  /**
+   * Checks if 2 arrays of ranges are the same ranges
+   * @param ranges1 First array of ranges
+   * @param ranges2 Second array of ranges
+   * @returns True if the arrays contain the same ranges in the same order
+   */
+  static rangeArraysEqual(ranges1, ranges2) {
+    if (ranges1 === ranges2) {
+      return true;
+    }
+    if (ranges1 == null || ranges2 == null || ranges1.length !== ranges2.length) {
+      return false;
+    }
+    for (var i = 0; i < ranges1.length; i += 1) {
+      if (!ranges1[i].equals(ranges2[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * Get the intersection (overlapping area) of two ranges
+   * @param range One range to check for the intersection
+   * @param otherRange The other range to check for the intersection
+   * @returns Intersection of the two ranges. If they do not intersect, returns `null`.
+   */
+  static intersection(range, otherRange) {
+    var _startColumn2, _endColumn2, _startRow2, _endRow2, _endColumn3, _endRow3;
+    if (range.equals(otherRange)) {
+      return range;
+    }
+    var {
+      startColumn,
+      startRow,
+      endColumn,
+      endRow
+    } = range;
+    startColumn = startColumn != null && otherRange.startColumn != null ? Math.max(startColumn, otherRange.startColumn) : (_startColumn2 = startColumn) !== null && _startColumn2 !== void 0 ? _startColumn2 : otherRange.startColumn;
+    endColumn = endColumn != null && otherRange.endColumn != null ? Math.min(endColumn, otherRange.endColumn) : (_endColumn2 = endColumn) !== null && _endColumn2 !== void 0 ? _endColumn2 : otherRange.endColumn;
+    startRow = startRow != null && otherRange.startRow != null ? Math.max(startRow, otherRange.startRow) : (_startRow2 = startRow) !== null && _startRow2 !== void 0 ? _startRow2 : otherRange.startRow;
+    endRow = endRow != null && otherRange.endRow != null ? Math.min(endRow, otherRange.endRow) : (_endRow2 = endRow) !== null && _endRow2 !== void 0 ? _endRow2 : otherRange.endRow;
+    if (startColumn != null && startColumn > ((_endColumn3 = endColumn) !== null && _endColumn3 !== void 0 ? _endColumn3 : -1) || startRow != null && startRow > ((_endRow3 = endRow) !== null && _endRow3 !== void 0 ? _endRow3 : -1)) {
+      return null;
+    }
+    return new GridRange(startColumn, startRow, endColumn, endRow);
+  }
+
+  /**
+   * Subtracts 1 range from another
+   * @param range The range to be subtracted from
+   * @param subtractRange The range to subtract from within this range
+   * @returns The ranges needed to represent the remaining
+   */
+  static subtractFromRange(range, subtractRange) {
+    var result = [];
+
+    // Make it a little easier by finding only the part the subtraction range intersects
+    var subtract = GridRange.intersection(range, subtractRange);
+    if (subtract == null) {
+      return [range];
+    }
+
+    // Go through each of the quadrants for deselection, there can be up to 4
+    // Top quadrant (above the subtracted area)
+    if (subtract.startRow != null && (range.startRow == null || range.startRow < subtract.startRow)) {
+      result.push(new GridRange(range.startColumn, range.startRow, range.endColumn, subtract.startRow - 1));
+    }
+
+    // middle left
+    if (subtract.startColumn != null && (range.startColumn == null || range.startColumn < subtract.startColumn)) {
+      result.push(new GridRange(range.startColumn, subtract.startRow, subtract.startColumn - 1, subtract.endRow));
+    }
+
+    // middle right
+    if (subtract.endColumn != null && (range.endColumn == null || range.endColumn > subtract.endColumn)) {
+      result.push(new GridRange(subtract.endColumn + 1, subtract.startRow, range.endColumn, subtract.endRow));
+    }
+
+    // Bottom quadrant
+    if (subtract.endRow != null && (range.endRow == null || range.endRow > subtract.endRow)) {
+      result.push(new GridRange(range.startColumn, subtract.endRow + 1, range.endColumn, range.endRow));
+    }
+    return result;
+  }
+
+  /**
+   * Subtract a range from multiple ranges
+   * @param ranges The ranges to be subtracted from
+   * @param subtractRange The range to subtract from within these ranges
+   * @returns The ranges needed to represent the remaining
+   */
+  static subtractFromRanges(ranges, subtractRange) {
+    var result = [];
+    for (var i = 0; i < ranges.length; i += 1) {
+      result.push(...GridRange.subtractFromRange(ranges[i], subtractRange));
+    }
+    return result;
+  }
+
+  /**
+   * Subtract multiple ranges from multiple ranges
+   * @param ranges The ranges to be subtracted from
+   * @param subtractRanges The ranges to subtract from within these ranges
+   * @returns The ranges needed to represent the remaining
+   */
+  static subtractRangesFromRanges(ranges, subtractRanges) {
+    var result = [...ranges];
+    for (var i = 0; i < subtractRanges.length; i += 1) {
+      result = GridRange.subtractFromRanges(result, subtractRanges[i]);
+    }
+    return result;
+  }
+
+  /**
+   * Test if a given range is bounded (all values are non-null)
+   * @param range The range to test
+   * @returns True if this range is bounded, false otherwise
+   */
+  static isBounded(range) {
+    return range.startRow != null && range.startColumn != null && range.endRow != null && range.endColumn != null;
+  }
+
+  /**
+   * Converts any GridRange passed in that is a full row or column selection to be bound
+   * to the `columnCount` and `rowCount` passed in
+   *
+   * @param range The range to get the bounded range of
+   * @param columnCount The number of columns
+   * @param rowCount The number of rows
+   * @returns The passed in GridRange with any null values filled in
+   */
+  static boundedRange(range, columnCount, rowCount) {
+    var _range$startColumn, _range$startRow, _range$endColumn, _range$endRow;
+    if (GridRange.isBounded(range)) {
+      return range;
+    }
+    return new GridRange((_range$startColumn = range.startColumn) !== null && _range$startColumn !== void 0 ? _range$startColumn : 0, (_range$startRow = range.startRow) !== null && _range$startRow !== void 0 ? _range$startRow : 0, (_range$endColumn = range.endColumn) !== null && _range$endColumn !== void 0 ? _range$endColumn : columnCount - 1, (_range$endRow = range.endRow) !== null && _range$endRow !== void 0 ? _range$endRow : rowCount - 1);
+  }
+
+  /**
+   * Converts the GridRanges passed in to be bound to the `columnCount` and `rowCount` passed in
+   *
+   * @param ranges The ranges to get the bounded ranges of
+   * @param columnCount The number of columns
+   * @param rowCount The number of rows
+   * @returns The passed in GridRange with any null values filled in
+   */
+  static boundedRanges(ranges, columnCount, rowCount) {
+    return ranges.map(r => GridRange.boundedRange(r, columnCount, rowCount));
+  }
+
+  /**
+   * Offsets a GridRange by the specified amount in the x and y directions
+   *
+   * @param range The range to offset
+   * @param columnOffset The number of columns to offset
+   * @param rowOffset The number of rows to offset
+   * @returns The new grid range offset from the original
+   */
+  static offset(range, columnOffset, rowOffset) {
+    return new GridRange(range.startColumn != null ? range.startColumn + columnOffset : null, range.startRow != null ? range.startRow + rowOffset : null, range.endColumn != null ? range.endColumn + columnOffset : null, range.endRow != null ? range.endRow + rowOffset : null);
+  }
+
+  /**
+   * Get the next cell given the selected ranges and the current cell
+   * @param ranges The selected bounded ranges within the grid
+   * @param column The cursor column, or null if none focused
+   * @param row The cursor row, or null if none focused
+   * @param direction The direction in which to select next
+   * @returns The next cell to focus, or null if there should be no more focus
+   */
+  static nextCell(ranges) {
+    var column = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    var row = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+    var direction = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : GridRange.SELECTION_DIRECTION.DOWN;
+    if (ranges.length === 0) {
+      return null;
+    }
+    var rangeIndex = -1;
+    if (column != null && row != null) {
+      rangeIndex = ranges.findIndex(r => r.containsCell(column, row));
+      if (rangeIndex >= 0) {
+        var range = ranges[rangeIndex];
+        var nextCell = range.nextCell(column, row, direction);
+        if (nextCell != null) {
+          return nextCell;
+        }
+      }
+    }
+
+    // Otherwise go to the start of the next range (could be same range if only one range)
+    switch (direction) {
+      case GridRange.SELECTION_DIRECTION.DOWN:
+      case GridRange.SELECTION_DIRECTION.RIGHT:
+        {
+          var nextRangeIndex = rangeIndex < ranges.length - 1 ? rangeIndex + 1 : 0;
+          var nextRange = ranges[nextRangeIndex];
+          return nextRange.startCell(direction);
+        }
+      case GridRange.SELECTION_DIRECTION.LEFT:
+      case GridRange.SELECTION_DIRECTION.UP:
+        {
+          var _nextRangeIndex = rangeIndex > 0 ? rangeIndex - 1 : ranges.length - 1;
+          var _nextRange = ranges[_nextRangeIndex];
+          return _nextRange.startCell(direction);
+        }
+      default:
+        throw new Error("Invalid direction: ".concat(direction));
+    }
+  }
+
+  /**
+   * Count the number of cells in the provided grid ranges
+   * @param ranges The ranges to count the rows of
+   * @returns The number of cells in the ranges, or `NaN` if any of the ranges were unbounded
+   */
+  static cellCount(ranges) {
+    return ranges.reduce((cellCount, range) => {
+      var _range$endRow2, _range$startRow2, _range$endColumn2, _range$startColumn2;
+      return cellCount + (((_range$endRow2 = range.endRow) !== null && _range$endRow2 !== void 0 ? _range$endRow2 : NaN) - ((_range$startRow2 = range.startRow) !== null && _range$startRow2 !== void 0 ? _range$startRow2 : NaN) + 1) * (((_range$endColumn2 = range.endColumn) !== null && _range$endColumn2 !== void 0 ? _range$endColumn2 : NaN) - ((_range$startColumn2 = range.startColumn) !== null && _range$startColumn2 !== void 0 ? _range$startColumn2 : NaN) + 1);
+    }, 0);
+  }
+
+  /**
+   * Count the number of rows in the provided grid ranges
+   * @param ranges The ranges to count the rows of
+   * @returns The number of rows in the ranges, or `NaN` if any of the ranges were unbounded
+   */
+  static rowCount(ranges) {
+    return ranges.reduce((rowCount, range) => {
+      var _range$endRow3, _range$startRow3;
+      return rowCount + ((_range$endRow3 = range.endRow) !== null && _range$endRow3 !== void 0 ? _range$endRow3 : NaN) - ((_range$startRow3 = range.startRow) !== null && _range$startRow3 !== void 0 ? _range$startRow3 : NaN) + 1;
+    }, 0);
+  }
+
+  /**
+   * Count the number of columns in the provided grid ranges
+   * @param ranges The ranges to count the columns of
+   * @returns The number of columns in the ranges, or `NaN` if any of the ranges were unbounded
+   */
+  static columnCount(ranges) {
+    return ranges.reduce((columnCount, range) => {
+      var _range$endColumn3, _range$startColumn3;
+      return columnCount + ((_range$endColumn3 = range.endColumn) !== null && _range$endColumn3 !== void 0 ? _range$endColumn3 : NaN) - ((_range$startColumn3 = range.startColumn) !== null && _range$startColumn3 !== void 0 ? _range$startColumn3 : NaN) + 1;
+    }, 0);
+  }
+
+  /**
+   * Check if the provided ranges contain the provided cell
+   * @param ranges The ranges to check
+   * @param column The column index
+   * @param row The row index
+   * @returns True if the cell is within the provided ranges, false otherwise.
+   */
+  static containsCell(ranges, column, row) {
+    for (var i = 0; i < ranges.length; i += 1) {
+      var range = ranges[i];
+      if (range.containsCell(column, row)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Iterate through each cell in the provided ranges
+   * @param ranges The ranges to iterate through
+   * @param {(column: number, row: number, index: number) => void} callback The callback to execute. `index` is the index within that range
+   * @param {GridRange.SELECTION_DIRECTION} direction The direction to iterate in
+   */
+  static forEachCell(ranges, callback) {
+    var direction = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : GridRange.SELECTION_DIRECTION.RIGHT;
+    for (var i = 0; i < ranges.length; i += 1) {
+      ranges[i].forEach(callback, direction);
+    }
+  }
+  constructor(startColumn, startRow, endColumn, endRow) {
+    _defineProperty(this, "startColumn", void 0);
+    _defineProperty(this, "startRow", void 0);
+    _defineProperty(this, "endColumn", void 0);
+    _defineProperty(this, "endRow", void 0);
+    this.startColumn = startColumn;
+    this.startRow = startRow;
+    this.endColumn = endColumn;
+    this.endRow = endRow;
+  }
+
+  /**
+   * Checks if the provided range is equivalent to this range (same start and end column/row indexes)
+   * @param other Grid range to check against
+   * @returns True if the ranges cover the same area
+   */
+  equals(other) {
+    return this.startColumn === other.startColumn && this.startRow === other.startRow && this.endColumn === other.endColumn && this.endRow === other.endRow;
+  }
+
+  /**
+   * Checks if this GridRange contains another range
+   * @param other The range to check
+   * @returns True if this GridRange completely contains `other`
+   * */
+  contains(other) {
+    return (this.startColumn == null || other.startColumn != null && this.startColumn <= other.startColumn) && (this.startRow == null || other.startRow != null && this.startRow <= other.startRow) && (this.endColumn == null || other.endColumn != null && this.endColumn >= other.endColumn) && (this.endRow == null || other.endRow != null && this.endRow >= other.endRow);
+  }
+
+  /**
+   * Check if the provided cell is in this range
+   * @param column The column to check
+   * @param row The row to check
+   * @returns True if this cell is within this range
+   */
+  containsCell(column, row) {
+    if (column == null || row == null) {
+      return false;
+    }
+    return (this.startColumn == null || this.startColumn <= column) && (this.endColumn == null || this.endColumn >= column) && (this.startRow == null || this.startRow <= row) && (this.endRow == null || this.endRow >= row);
+  }
+
+  /**
+   * Check if the provided range touches (or overlaps) this GridRange
+   * Effectively checks if the 2 ranges could be represented by 1 continuous range
+   * @param other The range to check
+   * @returns True if this GridRange touches `other`
+   * */
+  touches(other) {
+    return GridRange.isAxisRangeTouching(this.startRow, this.endRow, other.startRow, other.endRow) && GridRange.isAxisRangeTouching(this.startColumn, this.endColumn, other.startColumn, other.endColumn);
+  }
+
+  /**
+   * Subtracts a range from this range
+   * @param other The range to deselect from within this range
+   * @returns The ranges needed to represent the remaining
+   */
+  subtract(other) {
+    return GridRange.subtractFromRange(this, other);
+  }
+
+  /**
+   * Get the first cell in this range. Throws if this range is unbounded.
+   *
+   * @param direction The direction to get the starting cell in. Defaults to DOWN
+   * @returns The first cell in this range in the direction specified
+   */
+  startCell() {
+    var direction = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : GridRange.SELECTION_DIRECTION.DOWN;
+    if (!GridRange.isBounded(this)) {
+      throw new Error('Cannot get the startCell of an unbounded range');
+    }
+    switch (direction) {
+      case GridRange.SELECTION_DIRECTION.DOWN:
+      case GridRange.SELECTION_DIRECTION.RIGHT:
+        return {
+          column: this.startColumn,
+          row: this.startRow
+        };
+      case GridRange.SELECTION_DIRECTION.LEFT:
+      case GridRange.SELECTION_DIRECTION.UP:
+        {
+          return {
+            column: this.endColumn,
+            row: this.endRow
+          };
+        }
+      default:
+        throw new Error("Invalid direction: ".concat(direction));
+    }
+  }
+
+  /**
+   * Get the next cell in the direction specified. Throws if this range is unbounded.
+   * If already at the bounds of the range in that direction, wrap to the next column or row
+   * If at the end of the entire range, return null
+   * If outside of the range, returns the next cell closest within this range.
+   *
+   * @param column The cursor column
+   * @param row The cursor row
+   * @param direction The direction to go in
+   * @returns The next cell in the direction specified, or `null` if at the end of the range
+   */
+  nextCell(column, row, direction) {
+    if (!GridRange.isBounded(this)) {
+      throw new Error('Bounded range required');
+    }
+    if (column == null || row == null) {
+      throw new Error('Require a non-null cursor');
+    }
+    var {
+      startColumn,
+      endColumn,
+      startRow,
+      endRow
+    } = this;
+    switch (direction) {
+      case GridRange.SELECTION_DIRECTION.DOWN:
+        if (row < endRow) {
+          return {
+            column,
+            row: Math.max(row + 1, startRow)
+          };
+        }
+        if (column < endColumn) {
+          return {
+            column: Math.max(column + 1, startColumn),
+            row: startRow
+          };
+        }
+        break;
+      case GridRange.SELECTION_DIRECTION.UP:
+        if (row > startRow) {
+          return {
+            column,
+            row: Math.min(row - 1, endRow)
+          };
+        }
+        if (column > startColumn) {
+          return {
+            column: Math.min(column - 1, endColumn),
+            row: endRow
+          };
+        }
+        break;
+      case GridRange.SELECTION_DIRECTION.RIGHT:
+        if (column < endColumn) {
+          return {
+            column: Math.max(column + 1, startColumn),
+            row
+          };
+        }
+        if (row < endRow) {
+          return {
+            column: startColumn,
+            row: Math.max(row + 1, startRow)
+          };
+        }
+        break;
+      case GridRange.SELECTION_DIRECTION.LEFT:
+        if (column > startColumn) {
+          return {
+            column: Math.min(column - 1, endColumn),
+            row
+          };
+        }
+        if (row > startRow) {
+          return {
+            column: endColumn,
+            row: Math.min(row - 1, endRow)
+          };
+        }
+        break;
+      default:
+        throw new Error("Invalid direction: ".concat(direction));
+    }
+    return null;
+  }
+
+  /**
+   * Iterate through each cell in the range
+   * @param callback Callback to execute. `index` is the index within this range
+   * @param direction The direction to iterate in
+   */
+  forEach(callback) {
+    var direction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : GridRange.SELECTION_DIRECTION.RIGHT;
+    var i = 0;
+    var {
+      column: c,
+      row: r
+    } = this.startCell(direction);
+    while (c != null && r != null) {
+      var _this$nextCell;
+      callback(c, r, i);
+      i += 1;
+      ({
+        column: c,
+        row: r
+      } = (_this$nextCell = this.nextCell(c, r, direction)) !== null && _this$nextCell !== void 0 ? _this$nextCell : {});
+    }
+  }
+}
+_defineProperty(GridRange, "SELECTION_DIRECTION", SELECTION_DIRECTION);
+export default GridRange;
+//# sourceMappingURL=GridRange.js.map