@deephaven/grid 0.22.3-beta.18 → 0.22.3-beta.21

package/dist/GridRange.js

@@ -1,15 +1,12 @@
 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; }
-
 // 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
@@ -24,19 +21,17 @@ export class GridRange {
     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
@@ -45,92 +40,80 @@ export class GridRange {
    * @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
+          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)) {
@@ -159,11 +142,8 @@ export class GridRange {
                 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);
@@ -173,9 +153,9 @@ export class GridRange {
         }
       }
     }
-
     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.
@@ -187,87 +167,69 @@ export class GridRange {
    * @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,
@@ -278,101 +240,90 @@ export class GridRange {
     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 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)
-
+    }
 
+    // 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
-
+    }
 
+    // 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
-
+    }
 
+    // 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
-
+    }
 
+    // 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) {
     if (subtractRanges == null || subtractRanges.length === 0) {
       return ranges;
     }
-
     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
@@ -382,17 +333,14 @@ export class GridRange {
    * @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
    *
@@ -401,11 +349,10 @@ export class GridRange {
    * @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
    *
@@ -414,11 +361,10 @@ export class GridRange {
    * @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
@@ -427,33 +373,26 @@ export class GridRange {
    * @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)
-
+    }
 
+    // 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:
@@ -462,62 +401,54 @@ export class GridRange {
           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
@@ -525,120 +456,100 @@ export class GridRange {
    * @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:
@@ -646,7 +557,6 @@ export class GridRange {
           column: this.startColumn,
           row: this.startRow
         };
-
       case GridRange.SELECTION_DIRECTION.LEFT:
       case GridRange.SELECTION_DIRECTION.UP:
         {
@@ -655,11 +565,11 @@ export class GridRange {
             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
@@ -671,24 +581,19 @@ export class GridRange {
    * @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) {
@@ -697,16 +602,13 @@ export class GridRange {
             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 {
@@ -714,16 +616,13 @@ export class GridRange {
             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 {
@@ -731,16 +630,13 @@ export class GridRange {
             row
           };
         }
-
         if (row < endRow) {
           return {
             column: startColumn,
             row: Math.max(row + 1, startRow)
           };
         }
-
         break;
-
       case GridRange.SELECTION_DIRECTION.LEFT:
         if (column > startColumn) {
           return {
@@ -748,29 +644,24 @@ export class GridRange {
             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;
@@ -778,10 +669,8 @@ export class GridRange {
       column: c,
       row: r
     } = this.startCell(direction);
-
     while (c != null && r != null) {
       var _this$nextCell;
-
       callback(c, r, i);
       i += 1;
       ({
@@ -790,10 +679,7 @@ export class GridRange {
       } = (_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