@deephaven/grid 0.7.0 → 0.7.1-beta.13

package/dist/GridRange.js

@@ -1,6 +1,24 @@
 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 = {}));
+
 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;
@@ -19,43 +37,84 @@ class GridRange {
 
     return [left, top, right, bottom];
   }
-  /** Make a GridRange, but ensure startColumn <= endColumn, startRow <= endRow */
+  /**
+   * 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() {
-    return new GridRange(...GridRange.normalize(...arguments));
+  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(value1, value2) {
-    if (value1 == null || value2 == null) {
+
+  static minOrNull(index1, index2) {
+    if (index1 == null || index2 == null) {
       return null;
     }
 
-    return Math.min(value1, value2);
+    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(value1, value2) {
-    if (value1 == null || value2 == null) {
+  static maxOrNull(index1, index2) {
+    if (index1 == null || index2 == null) {
       return null;
     }
 
-    return Math.max(value1, value2);
+    return Math.max(index1, index2);
   }
   /**
    * Consolidate the passed in ranges to the minimum set, merging overlapping ranges.
-   * @param {[GridRange]} ranges The ranges to consolidate
+   * @param ranges The ranges to consolidate
+   * @returns Consolidated ranges
    */
 
 
@@ -117,46 +176,65 @@ 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.
+   * [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(start, end, otherStart, otherEnd) {
-    if (start == null) {
-      if (end == null) {
+  static isAxisRangeTouching(start1, end1, start2, end2) {
+    if (start1 == null) {
+      if (end1 == null) {
         return true;
       }
 
-      if (otherStart == null) {
+      if (start2 == null) {
         return true;
       }
 
-      return otherStart <= end + 1;
+      return start2 <= end1 + 1;
     }
 
-    if (end == null) {
-      if (otherEnd == null) {
+    if (end1 == null) {
+      if (end2 == null) {
         return true;
       }
 
-      return otherEnd >= start - 1;
+      return end2 >= start1 - 1;
     }
 
-    if (otherStart == null) {
-      if (otherEnd == null) {
+    if (start2 == null) {
+      if (end2 == null) {
         return true;
       }
 
-      return start <= otherEnd + 1;
+      return start1 <= end2 + 1;
     }
 
-    if (otherEnd == null) {
-      return end >= otherStart - 1;
+    if (end2 == null) {
+      return end1 >= start2 - 1;
     }
 
-    if (otherStart >= start - 1) {
-      return otherStart <= end + 1;
+    if (start2 >= start1 - 1) {
+      return start2 <= end1 + 1;
     }
 
-    return otherEnd >= start - 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) {
@@ -177,14 +255,14 @@ class GridRange {
   }
   /**
    * 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`.
+   * @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;
+    var _startColumn2, _endColumn2, _startRow2, _endRow2, _endColumn3, _endRow3;
 
     if (range.equals(otherRange)) {
       return range;
@@ -201,16 +279,17 @@ class GridRange {
     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) {
+    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);
   }
   /**
-   * @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
+   * 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
    */
 
 
@@ -248,9 +327,9 @@ class GridRange {
   }
   /**
    * 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
+   * @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
    */
 
 
@@ -265,9 +344,9 @@ class GridRange {
   }
   /**
    * 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
+   * @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
    */
 
 
@@ -286,8 +365,8 @@ class GridRange {
   }
   /**
    * 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
+   * @param range The range to test
+   * @returns True if this range is bounded, false otherwise
    */
 
 
@@ -298,10 +377,10 @@ class GridRange {
    * 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
+   * @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
    */
 
 
@@ -317,10 +396,10 @@ class GridRange {
   /**
    * 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
+   * @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
    */
 
 
@@ -330,10 +409,10 @@ class GridRange {
   /**
    * 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
+   * @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
    */
 
 
@@ -342,11 +421,11 @@ class GridRange {
   }
   /**
    * 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
+   * @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
    */
 
 
@@ -399,8 +478,8 @@ class GridRange {
   }
   /**
    * 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
+   * @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
    */
 
 
@@ -413,8 +492,8 @@ class GridRange {
   }
   /**
    * 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
+   * @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
    */
 
 
@@ -427,8 +506,8 @@ class GridRange {
   }
   /**
    * 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
+   * @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
    */
 
 
@@ -441,10 +520,10 @@ class GridRange {
   }
   /**
    * 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.
+   * @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.
    */
 
 
@@ -461,7 +540,7 @@ class GridRange {
   }
   /**
    * Iterate through each cell in the provided ranges
-   * @param {GridRange[]} ranges The ranges to iterate through
+   * @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
    */
@@ -476,16 +555,34 @@ class GridRange {
   }
 
   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;
   }
-  /** @returns {boolean} true if this GridRange completely contains `other` */
+  /**
+   * Checks if this GridRange contains another range
+   * @param other The range to check
+   * @returns True if this GridRange completely contains `other`
+   * */
 
 
   contains(other) {
@@ -493,9 +590,9 @@ class GridRange {
   }
   /**
    * 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
+   * @param column The column to check
+   * @param row The row to check
+   * @returns True if this cell is within this range
    */
 
 
@@ -506,15 +603,21 @@ class GridRange {
 
     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` */
+  /**
+   * 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);
   }
   /**
-   * @param {GridRange} other The range to deselect from within this range
-   * @returns {[GridRange]} The ranges needed to represent the remaining
+   * Subtracts a range from this range
+   * @param other The range to deselect from within this range
+   * @returns The ranges needed to represent the remaining
    */
 
 
@@ -524,8 +627,8 @@ class GridRange {
   /**
    * 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
+   * @param direction The direction to get the starting cell in. Defaults to DOWN
+   * @returns The first cell in this range in the direction specified
    */
 
 
@@ -663,8 +766,8 @@ class GridRange {
   }
   /**
    * 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
+   * @param callback Callback to execute. `index` is the index within this range
+   * @param direction The direction to iterate in
    */
 
 
@@ -690,12 +793,7 @@ class GridRange {
 
 }
 
-_defineProperty(GridRange, "SELECTION_DIRECTION", Object.freeze({
-  DOWN: 'DOWN',
-  UP: 'UP',
-  LEFT: 'LEFT',
-  RIGHT: 'RIGHT'
-}));
+_defineProperty(GridRange, "SELECTION_DIRECTION", SELECTION_DIRECTION);
 
 export default GridRange;
 //# sourceMappingURL=GridRange.js.map