@deephaven/grid 0.6.3-beta.9 → 0.6.3

package/dist/GridRange.js

@@ -1,24 +1,6 @@
 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;
@@ -37,84 +19,43 @@ class GridRange {
 
     return [left, top, right, bottom];
   }
-  /**
-   * Makes a GridRange ensuring startColumn <= endColumn, startRow <= endRow
-   * @param startColumn Start column index
-   * @param startRow Start row index
-   * @param endColumn End column index
-   * @param endRow End row index
-   * @returns Normalized GridRange
-   */
+  /** Make a GridRange, but ensure startColumn <= endColumn, startRow <= endRow */
 
 
-  static makeNormalized(startColumn, startRow, endColumn, endRow) {
-    return new GridRange(...GridRange.normalize(startColumn, startRow, endColumn, endRow));
+  static makeNormalized() {
+    return new GridRange(...GridRange.normalize(...arguments));
   }
-  /**
-   * 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) {
+  static minOrNull(value1, value2) {
+    if (value1 == null || value2 == null) {
       return null;
     }
 
-    return Math.min(index1, index2);
+    return Math.min(value1, value2);
   }
-  /**
-   * 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) {
+  static maxOrNull(value1, value2) {
+    if (value1 == null || value2 == null) {
       return null;
     }
 
-    return Math.max(index1, index2);
+    return Math.max(value1, value2);
   }
   /**
    * Consolidate the passed in ranges to the minimum set, merging overlapping ranges.
-   * @param ranges The ranges to consolidate
-   * @returns Consolidated ranges
+   * @param {[GridRange]} ranges The ranges to consolidate
    */
 
 
@@ -176,65 +117,46 @@ 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(start1, end1, start2, end2) {
-    if (start1 == null) {
-      if (end1 == null) {
+  static isAxisRangeTouching(start, end, otherStart, otherEnd) {
+    if (start == null) {
+      if (end == null) {
         return true;
       }
 
-      if (start2 == null) {
+      if (otherStart == null) {
         return true;
       }
 
-      return start2 <= end1 + 1;
+      return otherStart <= end + 1;
     }
 
-    if (end1 == null) {
-      if (end2 == null) {
+    if (end == null) {
+      if (otherEnd == null) {
         return true;
       }
 
-      return end2 >= start1 - 1;
+      return otherEnd >= start - 1;
     }
 
-    if (start2 == null) {
-      if (end2 == null) {
+    if (otherStart == null) {
+      if (otherEnd == null) {
         return true;
       }
 
-      return start1 <= end2 + 1;
+      return start <= otherEnd + 1;
     }
 
-    if (end2 == null) {
-      return end1 >= start2 - 1;
+    if (otherEnd == null) {
+      return end >= otherStart - 1;
     }
 
-    if (start2 >= start1 - 1) {
-      return start2 <= end1 + 1;
+    if (otherStart >= start - 1) {
+      return otherStart <= end + 1;
     }
 
-    return end2 >= start1 - 1;
+    return otherEnd >= start - 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) {
@@ -255,14 +177,14 @@ class GridRange {
   }
   /**
    * 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`.
+   * @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`.
    */
 
 
   static intersection(range, otherRange) {
-    var _startColumn2, _endColumn2, _startRow2, _endRow2, _endColumn3, _endRow3;
+    var _startColumn2, _endColumn2, _startRow2, _endRow2;
 
     if (range.equals(otherRange)) {
       return range;
@@ -279,17 +201,16 @@ 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 > ((_endColumn3 = endColumn) !== null && _endColumn3 !== void 0 ? _endColumn3 : -1) || startRow != null && startRow > ((_endRow3 = endRow) !== null && _endRow3 !== void 0 ? _endRow3 : -1)) {
+    if (startColumn != null && startColumn > endColumn || startRow != null && startRow > endRow) {
       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
+   * @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
    */
 
 
@@ -327,9 +248,9 @@ class GridRange {
   }
   /**
    * 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
+   * @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
    */
 
 
@@ -344,9 +265,9 @@ class GridRange {
   }
   /**
    * 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
+   * @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
    */
 
 
@@ -365,8 +286,8 @@ class GridRange {
   }
   /**
    * 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
+   * @param {GridRange} range The range to test
+   * @returns {boolean} True if this range is bounded, false otherwise
    */
 
 
@@ -377,10 +298,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 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
+   * @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
    */
 
 
@@ -396,10 +317,10 @@ class GridRange {
   /**
    * Converts the GridRanges passed in to be bound to the `columnCount` and `rowCount` passed in
    *
-   * @param ranges The ranges to get the bounded ranges of
-   * @param columnCount The number of columns
-   * @param rowCount The number of rows
-   * @returns The passed in GridRange with any null values filled in
+   * @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
    */
 
 
@@ -409,10 +330,10 @@ class GridRange {
   /**
    * Offsets a GridRange by the specified amount in the x and y directions
    *
-   * @param range The range to offset
-   * @param columnOffset The number of columns to offset
-   * @param rowOffset The number of rows to offset
-   * @returns The new grid range offset from the original
+   * @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
    */
 
 
@@ -421,11 +342,11 @@ class GridRange {
   }
   /**
    * Get the next cell given the selected ranges and the current cell
-   * @param ranges The selected bounded ranges within the grid
-   * @param column The cursor column, or null if none focused
-   * @param row The cursor row, or null if none focused
-   * @param direction The direction in which to select next
-   * @returns The next cell to focus, or null if there should be no more focus
+   * @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
    */
 
 
@@ -478,8 +399,8 @@ class GridRange {
   }
   /**
    * 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
+   * @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
    */
 
 
@@ -492,8 +413,8 @@ class GridRange {
   }
   /**
    * 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
+   * @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
    */
 
 
@@ -506,8 +427,8 @@ class GridRange {
   }
   /**
    * 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
+   * @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
    */
 
 
@@ -520,10 +441,10 @@ class GridRange {
   }
   /**
    * Check if the provided ranges contain the provided cell
-   * @param ranges The ranges to check
-   * @param column The column index
-   * @param row The row index
-   * @returns True if the cell is within the provided ranges, false otherwise.
+   * @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.
    */
 
 
@@ -540,7 +461,7 @@ class GridRange {
   }
   /**
    * Iterate through each cell in the provided ranges
-   * @param ranges The ranges to iterate through
+   * @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
    */
@@ -555,34 +476,16 @@ 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;
   }
-  /**
-   * Checks if this GridRange contains another range
-   * @param other The range to check
-   * @returns True if this GridRange completely contains `other`
-   * */
+  /** @returns {boolean} true if this GridRange completely contains `other` */
 
 
   contains(other) {
@@ -590,9 +493,9 @@ class GridRange {
   }
   /**
    * 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
+   * @param {number} column The column to check
+   * @param {number} row The row to check
+   * @returns {boolean} True if this cell is within this range
    */
 
 
@@ -603,21 +506,15 @@ 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);
   }
-  /**
-   * 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`
-   * */
+  /** @returns {boolean} 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
+   * @param {GridRange} other The range to deselect from within this range
+   * @returns {[GridRange]} The ranges needed to represent the remaining
    */
 
 
@@ -627,8 +524,8 @@ class GridRange {
   /**
    * 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
+   * @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
    */
 
 
@@ -766,8 +663,8 @@ class GridRange {
   }
   /**
    * 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
+   * @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
    */
 
 
@@ -793,7 +690,12 @@ class GridRange {
 
 }
 
-_defineProperty(GridRange, "SELECTION_DIRECTION", SELECTION_DIRECTION);
+_defineProperty(GridRange, "SELECTION_DIRECTION", Object.freeze({
+  DOWN: 'DOWN',
+  UP: 'UP',
+  LEFT: 'LEFT',
+  RIGHT: 'RIGHT'
+}));
 
 export default GridRange;
 //# sourceMappingURL=GridRange.js.map