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

package/dist/GridRange.js

@@ -1,752 +1,694 @@
-function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
+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 _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+class GridRange {
+  static normalize(startColumn, startRow, endColumn, endRow) {
+    var left = startColumn;
+    var top = startRow;
+    var right = endColumn;
+    var bottom = endRow;
 
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+    if (left != null && right != null && right < left) {
+      left = right;
+      right = startColumn;
+    }
 
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+    if (top != null && bottom != null && bottom < top) {
+      top = bottom;
+      bottom = startRow;
+    }
 
-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."); }
+    return [left, top, right, bottom];
+  }
+  /** Make a GridRange, but ensure startColumn <= endColumn, startRow <= endRow */
 
-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 _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
+  static makeNormalized() {
+    return new GridRange(...GridRange.normalize(...arguments));
+  }
 
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+  static makeCell(column, row) {
+    return new GridRange(column, row, column, row);
+  }
 
-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 makeColumn(column) {
+    return new GridRange(column, null, column, null);
+  }
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+  static makeRow(row) {
+    return new GridRange(null, row, null, row);
+  }
 
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+  static minOrNull(value1, value2) {
+    if (value1 == null || value2 == null) {
+      return null;
+    }
 
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+    return Math.min(value1, value2);
+  }
 
-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; }
+  static maxOrNull(value1, value2) {
+    if (value1 == null || value2 == null) {
+      return null;
+    }
 
-var GridRange = /*#__PURE__*/function () {
-  function GridRange(startColumn, startRow, endColumn, endRow) {
-    _classCallCheck(this, GridRange);
+    return Math.max(value1, value2);
+  }
+  /**
+   * Consolidate the passed in ranges to the minimum set, merging overlapping ranges.
+   * @param {[GridRange]} ranges The ranges to consolidate
+   */
+
+
+  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;
 
-    this.startColumn = startColumn;
-    this.startRow = startRow;
-    this.endColumn = endColumn;
-    this.endRow = endRow;
+              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;
   }
 
-  _createClass(GridRange, [{
-    key: "equals",
-    value: function equals(other) {
-      return this.startColumn === other.startColumn && this.startRow === other.startRow && this.endColumn === other.endColumn && this.endRow === other.endRow;
+  static isAxisRangeTouching(start, end, otherStart, otherEnd) {
+    if (start == null) {
+      if (end == null) {
+        return true;
+      }
+
+      if (otherStart == null) {
+        return true;
+      }
+
+      return otherStart <= end + 1;
     }
-    /** @returns {boolean} true if this GridRange completely contains `other` */
 
-  }, {
-    key: "contains",
-    value: function 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);
+    if (end == null) {
+      if (otherEnd == null) {
+        return true;
+      }
+
+      return otherEnd >= start - 1;
     }
-    /**
-     * Check if the provided cell is in this range
-     * @param {number} column The column to check
-     * @param {number} row The row to check
-     * @returns {boolean} True if this cell is within this range
-     */
-
-  }, {
-    key: "containsCell",
-    value: function containsCell(column, row) {
-      if (column == null || row == null) {
-        return false;
+
+    if (otherStart == null) {
+      if (otherEnd == null) {
+        return true;
       }
 
-      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);
+      return start <= otherEnd + 1;
     }
-    /** @returns {boolean} true if this GridRange touches `other` */
 
-  }, {
-    key: "touches",
-    value: function touches(other) {
-      return GridRange.isAxisRangeTouching(this.startRow, this.endRow, other.startRow, other.endRow) && GridRange.isAxisRangeTouching(this.startColumn, this.endColumn, other.startColumn, other.endColumn);
+    if (otherEnd == null) {
+      return end >= otherStart - 1;
     }
-    /**
-     * @param {GridRange} other The range to deselect from within this range
-     * @returns {[GridRange]} The ranges needed to represent the remaining
-     */
-
-  }, {
-    key: "subtract",
-    value: function subtract(other) {
-      return GridRange.subtractFromRange(this, other);
+
+    if (otherStart >= start - 1) {
+      return otherStart <= end + 1;
     }
-    /**
-     * Get the first cell in this range. Throws if this range is unbounded.
-     *
-     * @param {GridRange.SELECTION_DIRECTION?} direction The direction to get the starting cell in. Defaults to DOWN
-     * @returns {{column: number, row: number}} The first cell in this range in the direction specified
-     */
-
-  }, {
-    key: "startCell",
-    value: function 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
-          };
+    return otherEnd >= start - 1;
+  }
 
-        case GridRange.SELECTION_DIRECTION.LEFT:
-        case GridRange.SELECTION_DIRECTION.UP:
-          {
-            return {
-              column: this.endColumn,
-              row: this.endRow
-            };
-          }
+  static rangeArraysEqual(ranges1, ranges2) {
+    if (ranges1 === ranges2) {
+      return true;
+    }
 
-        default:
-          throw new Error("Invalid direction: ".concat(direction));
-      }
+    if (ranges1 == null || ranges2 == null || ranges1.length !== ranges2.length) {
+      return false;
     }
-    /**
-     * 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 {number} column The cursor column
-     * @param {number} row The cursor row
-     * @param {SELECTION_DIRECTION} direction The direction to go in
-     * @returns {GridCell|null} The next cell in the direction specified, or `null` if at the end of the range
-     */
-
-  }, {
-    key: "nextCell",
-    value: function 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');
+    for (var i = 0; i < ranges1.length; i += 1) {
+      if (!ranges1[i].equals(ranges2[i])) {
+        return false;
       }
+    }
 
-      var startColumn = this.startColumn,
-          endColumn = this.endColumn,
-          startRow = this.startRow,
-          endRow = this.endRow;
-
-      switch (direction) {
-        case GridRange.SELECTION_DIRECTION.DOWN:
-          if (row < endRow) {
-            return {
-              column: column,
-              row: Math.max(row + 1, startRow)
-            };
-          }
-
-          if (column < endColumn) {
-            return {
-              column: Math.max(column + 1, startColumn),
-              row: startRow
-            };
-          }
+    return true;
+  }
+  /**
+   * Get the intersection (overlapping area) of two ranges
+   * @param {GridRange} range One range to check for the intersection
+   * @param {GridRange} otherRange The other range to check for the intersection
+   * @returns {GridRange|null} Intersection of the two ranges. If they do not intersect, returns `null`.
+   */
 
-          break;
 
-        case GridRange.SELECTION_DIRECTION.UP:
-          if (row > startRow) {
-            return {
-              column: column,
-              row: Math.min(row - 1, endRow)
-            };
-          }
+  static intersection(range, otherRange) {
+    var _startColumn2, _endColumn2, _startRow2, _endRow2;
 
-          if (column > startColumn) {
-            return {
-              column: Math.min(column - 1, endColumn),
-              row: endRow
-            };
-          }
+    if (range.equals(otherRange)) {
+      return range;
+    }
 
-          break;
+    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;
 
-        case GridRange.SELECTION_DIRECTION.RIGHT:
-          if (column < endColumn) {
-            return {
-              column: Math.max(column + 1, startColumn),
-              row: row
-            };
-          }
+    if (startColumn != null && startColumn > endColumn || startRow != null && startRow > endRow) {
+      return null;
+    }
 
-          if (row < endRow) {
-            return {
-              column: startColumn,
-              row: Math.max(row + 1, startRow)
-            };
-          }
+    return new GridRange(startColumn, startRow, endColumn, endRow);
+  }
+  /**
+   * @param {GridRange} range The range to be subtracted from
+   * @param {GridRange} subtractRange The range to subtract from within this range
+   * @returns {GridRange[]} The ranges needed to represent the remaining
+   */
 
-          break;
 
-        case GridRange.SELECTION_DIRECTION.LEFT:
-          if (column > startColumn) {
-            return {
-              column: Math.min(column - 1, endColumn),
-              row: row
-            };
-          }
+  static subtractFromRange(range, subtractRange) {
+    var result = []; // Make it a little easier by finding only the part the subtraction range intersects
 
-          if (row > startRow) {
-            return {
-              column: endColumn,
-              row: Math.min(row - 1, endRow)
-            };
-          }
+    var subtract = GridRange.intersection(range, subtractRange);
 
-          break;
+    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)
 
-        default:
-          throw new Error("Invalid direction: ".concat(direction));
-      }
 
-      return null;
-    }
-    /**
-     * Iterate through each cell in the range
-     * @param {(column:number, row:number, index:number) => void} callback Callback to execute. `index` is the index within this range
-     * @param {GridRange.SELECTION_DIRECTION} direction The direction to iterate in
-     */
+    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
 
-  }, {
-    key: "forEach",
-    value: function forEach(callback) {
-      var direction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : GridRange.SELECTION_DIRECTION.RIGHT;
-      var i = 0;
 
-      var _this$startCell = this.startCell(direction),
-          c = _this$startCell.column,
-          r = _this$startCell.row;
+    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
 
-      while (c != null && r != null) {
-        var _this$nextCell;
 
-        callback(c, r, i);
-        i += 1;
+    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
 
-        var _ref = (_this$nextCell = this.nextCell(c, r, direction)) !== null && _this$nextCell !== void 0 ? _this$nextCell : {};
 
-        c = _ref.column;
-        r = _ref.row;
-      }
+    if (subtract.endRow != null && (range.endRow == null || range.endRow > subtract.endRow)) {
+      result.push(new GridRange(range.startColumn, subtract.endRow + 1, range.endColumn, range.endRow));
     }
-  }], [{
-    key: "normalize",
-    value: function 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 result;
+  }
+  /**
+   * Subtract a range from multiple ranges
+   * @param {GridRange[]} ranges The ranges to be subtracted from
+   * @param {GridRange} subtractRange The range to subtract from within these ranges
+   * @returns {GridRange[]} The ranges needed to represent the remaining
+   */
 
-      return [left, top, right, bottom];
-    }
-    /** Make a GridRange, but ensure startColumn <= endColumn, startRow <= endRow */
 
-  }, {
-    key: "makeNormalized",
-    value: function makeNormalized() {
-      return _construct(GridRange, _toConsumableArray(GridRange.normalize.apply(GridRange, arguments)));
-    }
-  }, {
-    key: "makeCell",
-    value: function makeCell(column, row) {
-      return new GridRange(column, row, column, row);
-    }
-  }, {
-    key: "makeColumn",
-    value: function makeColumn(column) {
-      return new GridRange(column, null, column, null);
+  static subtractFromRanges(ranges, subtractRange) {
+    var result = [];
+
+    for (var i = 0; i < ranges.length; i += 1) {
+      result.push(...GridRange.subtractFromRange(ranges[i], subtractRange));
     }
-  }, {
-    key: "makeRow",
-    value: function makeRow(row) {
-      return new GridRange(null, row, null, row);
+
+    return result;
+  }
+  /**
+   * Subtract multiple ranges from multiple ranges
+   * @param {GridRange[]} ranges The ranges to be subtracted from
+   * @param {GridRange[]} subtractRanges The ranges to subtract from within these ranges
+   * @returns {GridRange[]} The ranges needed to represent the remaining
+   */
+
+
+  static subtractRangesFromRanges(ranges, subtractRanges) {
+    if (!subtractRanges || subtractRanges.length === 0) {
+      return ranges;
     }
-  }, {
-    key: "minOrNull",
-    value: function minOrNull(value1, value2) {
-      if (value1 == null || value2 == null) {
-        return null;
-      }
 
-      return Math.min(value1, value2);
+    var result = [...ranges];
+
+    for (var i = 0; i < subtractRanges.length; i += 1) {
+      result = GridRange.subtractFromRanges(result, subtractRanges[i]);
     }
-  }, {
-    key: "maxOrNull",
-    value: function maxOrNull(value1, value2) {
-      if (value1 == null || value2 == null) {
-        return null;
-      }
 
-      return Math.max(value1, value2);
+    return result;
+  }
+  /**
+   * Test if a given range is bounded (all values are non-null)
+   * @param {GridRange} range The range to test
+   * @returns {boolean} 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 {GridRange} range The range to get the bounded range of
+   * @param {number} columnCount The number of columns
+   * @param {number} rowCount The number of rows
+   * @returns {GridRange} 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;
     }
-    /**
-     * Consolidate the passed in ranges to the minimum set, merging overlapping ranges.
-     * @param {[GridRange]} ranges The ranges to consolidate
-     */
 
-  }, {
-    key: "consolidate",
-    value: function consolidate(ranges) {
-      var result = ranges.slice();
-      var wasModified = true;
+    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 {GridRange[]} ranges The ranges to get the bounded ranges of
+   * @param {number} columnCount The number of columns
+   * @param {number} rowCount The number of rows
+   * @returns {GridRange} 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 {GridRange} range The range to offset
+   * @param {number} columnOffset The number of columns to offset
+   * @param {number} rowOffset The number of rows to offset
+   * @returns {GridRange} 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 {GridRange[]} ranges The selected bounded ranges within the grid
+   * @param {number|null} column The cursor column, or null if none focused
+   * @param {number|null} row The cursor row, or null if none focused
+   * @param {SELECTION_DIRECTION} direction The direction in which to select next
+   * @returns {Cell} 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;
+    }
 
-      while (wasModified) {
-        wasModified = false;
+    var rangeIndex = -1;
 
-        for (var i = 0; i < result.length && !wasModified; i += 1) {
-          var range = result[i];
+    if (column != null && row != null) {
+      rangeIndex = ranges.findIndex(r => r.containsCell(column, row));
 
-          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 (rangeIndex >= 0) {
+        var range = ranges[rangeIndex];
+        var nextCell = range.nextCell(column, row, direction);
 
-            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 = range.startRow,
-                    endRow = range.endRow;
-                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 = range.startColumn,
-                    _endColumn = range.endColumn;
-
-                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;
-              }
-            }
-          }
+        if (nextCell != null) {
+          return nextCell;
         }
       }
+    } // Otherwise go to the start of the next range (could be same range if only one range)
 
-      return result;
-    }
-  }, {
-    key: "isAxisRangeTouching",
-    value: function isAxisRangeTouching(start, end, otherStart, otherEnd) {
-      if (start == null) {
-        if (end == null) {
-          return true;
-        }
 
-        if (otherStart == null) {
-          return true;
+    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);
         }
 
-        return otherStart <= end + 1;
-      }
+      case GridRange.SELECTION_DIRECTION.LEFT:
+      case GridRange.SELECTION_DIRECTION.UP:
+        {
+          var _nextRangeIndex = rangeIndex > 0 ? rangeIndex - 1 : ranges.length - 1;
 
-      if (end == null) {
-        if (otherEnd == null) {
-          return true;
+          var _nextRange = ranges[_nextRangeIndex];
+          return _nextRange.startCell(direction);
         }
 
-        return otherEnd >= start - 1;
-      }
+      default:
+        throw new Error("Invalid direction: ".concat(direction));
+    }
+  }
+  /**
+   * Count the number of cells in the provided grid ranges
+   * @param {GridRange[]} ranges The ranges to count the rows of
+   * @returns {number|NaN} The number of cells in the ranges, or `NaN` if any of the ranges were unbounded
+   */
 
-      if (otherStart == null) {
-        if (otherEnd == null) {
-          return true;
-        }
 
-        return start <= otherEnd + 1;
-      }
+  static cellCount(ranges) {
+    return ranges.reduce((cellCount, range) => {
+      var _range$endRow2, _range$startRow2, _range$endColumn2, _range$startColumn2;
 
-      if (otherEnd == null) {
-        return end >= otherStart - 1;
-      }
+      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 {GridRange[]} ranges The ranges to count the rows of
+   * @returns {number|NaN} The number of rows in the ranges, or `NaN` if any of the ranges were unbounded
+   */
 
-      if (otherStart >= start - 1) {
-        return otherStart <= end + 1;
-      }
 
-      return otherEnd >= start - 1;
-    }
-  }, {
-    key: "rangeArraysEqual",
-    value: function rangeArraysEqual(ranges1, ranges2) {
-      if (ranges1 === ranges2) {
-        return true;
-      }
+  static rowCount(ranges) {
+    return ranges.reduce((rowCount, range) => {
+      var _range$endRow3, _range$startRow3;
 
-      if (ranges1 == null || ranges2 == null || ranges1.length !== ranges2.length) {
-        return false;
-      }
+      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 {GridRange[]} ranges The ranges to count the columns of
+   * @returns {number|NaN} The number of columns in the ranges, or `NaN` if any of the ranges were unbounded
+   */
 
-      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 {GridRange} range One range to check for the intersection
-     * @param {GridRange} otherRange The other range to check for the intersection
-     * @returns {GridRange|null} Intersection of the two ranges. If they do not intersect, returns `null`.
-     */
-
-  }, {
-    key: "intersection",
-    value: function intersection(range, otherRange) {
-      var _startColumn2, _endColumn2, _startRow2, _endRow2;
-
-      if (range.equals(otherRange)) {
-        return range;
-      }
+  static columnCount(ranges) {
+    return ranges.reduce((columnCount, range) => {
+      var _range$endColumn3, _range$startColumn3;
 
-      var startColumn = range.startColumn,
-          startRow = range.startRow,
-          endColumn = range.endColumn,
-          endRow = range.endRow;
-      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 > endColumn || startRow != null && startRow > endRow) {
-        return null;
-      }
+      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 {GridRange[]} ranges The ranges to check
+   * @param {number} column The column index
+   * @param {number} row The row index
+   * @returns {boolean} True if the cell is within the provided ranges, false otherwise.
+   */
 
-      return new GridRange(startColumn, startRow, endColumn, endRow);
-    }
-    /**
-     * @param {GridRange} range The range to be subtracted from
-     * @param {GridRange} subtractRange The range to subtract from within this range
-     * @returns {GridRange[]} The ranges needed to represent the remaining
-     */
 
-  }, {
-    key: "subtractFromRange",
-    value: function subtractFromRange(range, subtractRange) {
-      var result = []; // Make it a little easier by finding only the part the subtraction range intersects
+  static containsCell(ranges, column, row) {
+    for (var i = 0; i < ranges.length; i += 1) {
+      var range = ranges[i];
 
-      var subtract = GridRange.intersection(range, subtractRange);
+      if (range.containsCell(column, row)) {
+        return true;
+      }
+    }
 
-      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)
+    return false;
+  }
+  /**
+   * Iterate through each cell in the provided ranges
+   * @param {GridRange[]} 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
+   */
 
 
-      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
+  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);
+    }
+  }
 
-      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
+  constructor(startColumn, startRow, endColumn, endRow) {
+    this.startColumn = startColumn;
+    this.startRow = startRow;
+    this.endColumn = endColumn;
+    this.endRow = endRow;
+  }
 
+  equals(other) {
+    return this.startColumn === other.startColumn && this.startRow === other.startRow && this.endColumn === other.endColumn && this.endRow === other.endRow;
+  }
+  /** @returns {boolean} true if this GridRange completely contains `other` */
 
-      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
 
+  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 {number} column The column to check
+   * @param {number} row The row to check
+   * @returns {boolean} True if this cell is within this range
+   */
 
-      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;
+  containsCell(column, row) {
+    if (column == null || row == null) {
+      return false;
     }
-    /**
-     * Subtract a range from multiple ranges
-     * @param {GridRange[]} ranges The ranges to be subtracted from
-     * @param {GridRange} subtractRange The range to subtract from within these ranges
-     * @returns {GridRange[]} The ranges needed to represent the remaining
-     */
-
-  }, {
-    key: "subtractFromRanges",
-    value: function subtractFromRanges(ranges, subtractRange) {
-      var result = [];
-
-      for (var i = 0; i < ranges.length; i += 1) {
-        result.push.apply(result, _toConsumableArray(GridRange.subtractFromRange(ranges[i], subtractRange)));
-      }
 
-      return result;
-    }
-    /**
-     * Subtract multiple ranges from multiple ranges
-     * @param {GridRange[]} ranges The ranges to be subtracted from
-     * @param {GridRange[]} subtractRanges The ranges to subtract from within these ranges
-     * @returns {GridRange[]} The ranges needed to represent the remaining
-     */
-
-  }, {
-    key: "subtractRangesFromRanges",
-    value: function subtractRangesFromRanges(ranges, subtractRanges) {
-      if (!subtractRanges || subtractRanges.length === 0) {
-        return ranges;
-      }
+    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);
+  }
+  /** @returns {boolean} true if this GridRange touches `other` */
 
-      var result = _toConsumableArray(ranges);
 
-      for (var i = 0; i < subtractRanges.length; i += 1) {
-        result = GridRange.subtractFromRanges(result, subtractRanges[i]);
-      }
+  touches(other) {
+    return GridRange.isAxisRangeTouching(this.startRow, this.endRow, other.startRow, other.endRow) && GridRange.isAxisRangeTouching(this.startColumn, this.endColumn, other.startColumn, other.endColumn);
+  }
+  /**
+   * @param {GridRange} other The range to deselect from within this range
+   * @returns {[GridRange]} The ranges needed to represent the remaining
+   */
 
-      return result;
-    }
-    /**
-     * Test if a given range is bounded (all values are non-null)
-     * @param {GridRange} range The range to test
-     * @returns {boolean} True if this range is bounded, false otherwise
-     */
-
-  }, {
-    key: "isBounded",
-    value: function 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 {GridRange} range The range to get the bounded range of
-     * @param {number} columnCount The number of columns
-     * @param {number} rowCount The number of rows
-     * @returns {GridRange} The passed in GridRange with any null values filled in
-     */
-
-  }, {
-    key: "boundedRange",
-    value: function 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 {GridRange[]} ranges The ranges to get the bounded ranges of
-     * @param {number} columnCount The number of columns
-     * @param {number} rowCount The number of rows
-     * @returns {GridRange} The passed in GridRange with any null values filled in
-     */
-
-  }, {
-    key: "boundedRanges",
-    value: function boundedRanges(ranges, columnCount, rowCount) {
-      return ranges.map(function (r) {
-        return GridRange.boundedRange(r, columnCount, rowCount);
-      });
+  subtract(other) {
+    return GridRange.subtractFromRange(this, other);
+  }
+  /**
+   * Get the first cell in this range. Throws if this range is unbounded.
+   *
+   * @param {GridRange.SELECTION_DIRECTION?} direction The direction to get the starting cell in. Defaults to DOWN
+   * @returns {{column: number, row: number}} 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');
     }
-    /**
-     * Offsets a GridRange by the specified amount in the x and y directions
-     *
-     * @param {GridRange} range The range to offset
-     * @param {number} columnOffset The number of columns to offset
-     * @param {number} rowOffset The number of rows to offset
-     * @returns {GridRange} The new grid range offset from the original
-     */
-
-  }, {
-    key: "offset",
-    value: function 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);
+
+    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 given the selected ranges and the current cell
-     * @param {GridRange[]} ranges The selected bounded ranges within the grid
-     * @param {number|null} column The cursor column, or null if none focused
-     * @param {number|null} row The cursor row, or null if none focused
-     * @param {SELECTION_DIRECTION} direction The direction in which to select next
-     * @returns {Cell} The next cell to focus, or null if there should be no more focus
-     */
-
-  }, {
-    key: "nextCell",
-    value: function 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;
-      }
+  }
+  /**
+   * 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 {number} column The cursor column
+   * @param {number} row The cursor row
+   * @param {SELECTION_DIRECTION} direction The direction to go in
+   * @returns {GridCell|null} 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)
+          };
+        }
 
-      var rangeIndex = -1;
+        if (column < endColumn) {
+          return {
+            column: Math.max(column + 1, startColumn),
+            row: startRow
+          };
+        }
 
-      if (column != null && row != null) {
-        rangeIndex = ranges.findIndex(function (r) {
-          return r.containsCell(column, row);
-        });
+        break;
 
-        if (rangeIndex >= 0) {
-          var range = ranges[rangeIndex];
-          var nextCell = range.nextCell(column, row, direction);
+      case GridRange.SELECTION_DIRECTION.UP:
+        if (row > startRow) {
+          return {
+            column,
+            row: Math.min(row - 1, endRow)
+          };
+        }
 
-          if (nextCell != null) {
-            return nextCell;
-          }
+        if (column > startColumn) {
+          return {
+            column: Math.min(column - 1, endColumn),
+            row: endRow
+          };
         }
-      } // Otherwise go to the start of the next range (could be same range if only one range)
 
+        break;
 
-      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.RIGHT:
+        if (column < endColumn) {
+          return {
+            column: Math.max(column + 1, startColumn),
+            row
+          };
+        }
 
-        case GridRange.SELECTION_DIRECTION.LEFT:
-        case GridRange.SELECTION_DIRECTION.UP:
-          {
-            var _nextRangeIndex = rangeIndex > 0 ? rangeIndex - 1 : ranges.length - 1;
+        if (row < endRow) {
+          return {
+            column: startColumn,
+            row: Math.max(row + 1, startRow)
+          };
+        }
 
-            var _nextRange = ranges[_nextRangeIndex];
-            return _nextRange.startCell(direction);
-          }
+        break;
 
-        default:
-          throw new Error("Invalid direction: ".concat(direction));
-      }
-    }
-    /**
-     * Count the number of cells in the provided grid ranges
-     * @param {GridRange[]} ranges The ranges to count the rows of
-     * @returns {number|NaN} The number of cells in the ranges, or `NaN` if any of the ranges were unbounded
-     */
-
-  }, {
-    key: "cellCount",
-    value: function cellCount(ranges) {
-      return ranges.reduce(function (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 {GridRange[]} ranges The ranges to count the rows of
-     * @returns {number|NaN} The number of rows in the ranges, or `NaN` if any of the ranges were unbounded
-     */
-
-  }, {
-    key: "rowCount",
-    value: function rowCount(ranges) {
-      return ranges.reduce(function (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 {GridRange[]} ranges The ranges to count the columns of
-     * @returns {number|NaN} The number of columns in the ranges, or `NaN` if any of the ranges were unbounded
-     */
-
-  }, {
-    key: "columnCount",
-    value: function columnCount(ranges) {
-      return ranges.reduce(function (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 {GridRange[]} ranges The ranges to check
-     * @param {number} column The column index
-     * @param {number} row The row index
-     * @returns {boolean} True if the cell is within the provided ranges, false otherwise.
-     */
-
-  }, {
-    key: "containsCell",
-    value: function containsCell(ranges, column, row) {
-      for (var i = 0; i < ranges.length; i += 1) {
-        var range = ranges[i];
-
-        if (range.containsCell(column, row)) {
-          return true;
+      case GridRange.SELECTION_DIRECTION.LEFT:
+        if (column > startColumn) {
+          return {
+            column: Math.min(column - 1, endColumn),
+            row
+          };
         }
-      }
 
-      return false;
+        if (row > startRow) {
+          return {
+            column: endColumn,
+            row: Math.min(row - 1, endRow)
+          };
+        }
+
+        break;
+
+      default:
+        throw new Error("Invalid direction: ".concat(direction));
     }
-    /**
-     * Iterate through each cell in the provided ranges
-     * @param {GridRange[]} 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
-     */
-
-  }, {
-    key: "forEachCell",
-    value: function 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);
-      }
+
+    return null;
+  }
+  /**
+   * Iterate through each cell in the range
+   * @param {(column:number, row:number, index:number) => void} callback Callback to execute. `index` is the index within this range
+   * @param {GridRange.SELECTION_DIRECTION} 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 : {});
     }
-  }]);
+  }
 
-  return GridRange;
-}();
+}
 
 _defineProperty(GridRange, "SELECTION_DIRECTION", Object.freeze({
   DOWN: 'DOWN',