@deephaven/grid 0.7.0 → 0.7.1-beta.4

package/dist/GridUtils.js

@@ -9,6 +9,14 @@ import GridRange from "./GridRange.js";
 class GridUtils {
   // use same constant as chrome source for windows
   // https://github.com/chromium/chromium/blob/973af9d461b6b5dc60208c8d3d66adc27e53da78/ui/events/blink/web_input_event_builders_win.cc#L285
+
+  /**
+   * Get the GridPoint for the coordinates provided
+   * @param x The grid x coordinate
+   * @param y The grid y coordinate
+   * @param metrics The grid metrics
+   * @returns The GridPoint including the column/row information
+   */
   static getGridPointFromXY(x, y, metrics) {
     var column = GridUtils.getColumnAtX(x, metrics);
     var row = GridUtils.getRowAtY(y, metrics);
@@ -19,6 +27,14 @@ class GridUtils {
       column
     };
   }
+  /**
+   * Iterate through each floating item at the start and call a callback, returning the first result
+   * @param start The count of floating items at the start
+   * @param total The total number of items
+   * @param callback Function to call for each item
+   * @returns The result from the callback
+   */
+
 
   static iterateFloatingStart(start, total, callback) {
     for (var i = 0; i < start && i < total; i += 1) {
@@ -33,6 +49,10 @@ class GridUtils {
   }
   /**
    * Iterate through floating items at the end. Iterates in increasing order.
+   * @param end The count of floating items at the end
+   * @param total The total number of items
+   * @param callback Function to call for each item
+   * @returns The result from the callback
    */
 
 
@@ -49,10 +69,10 @@ class GridUtils {
   }
   /**
    * Iterate through all floating items in increasing order, starting with the top items.
-   * @param {number} start Count of start floating rows, eg. floatingTopRowCount
-   * @param {number} end Count of end floating rows, eg. floatingBottomRowCount
-   * @param {number} total Total number of items
-   * @param {(itemIndex:number) => any | undefined} callback Callback called for each value, stopping the iterating and returning the value if one is returned
+   * @param start Count of start floating rows, e.g. floatingTopRowCount
+   * @param end Count of end floating rows, e.g. floatingBottomRowCount
+   * @param total Total number of items
+   * @param callback Callback called for each value, stopping the iterating and returning the value if one is returned
    */
 
 
@@ -65,6 +85,18 @@ class GridUtils {
 
     return GridUtils.iterateFloatingEnd(end, total, callback);
   }
+  /**
+   * Iterate through all items in one dimension on the grid - first floating, then visible.
+   * Call the callback for each item, break if a result is returned and return that result.
+   * @param visibleStart Index of the start of the visible viewport
+   * @param visibleEnd Index of the end of the visible viewport
+   * @param floatingStartCount Number of items floating at the start
+   * @param floatingEndCount Number of items floating at the end
+   * @param totalCount Total number of items
+   * @param callback Callback to call for each item
+   * @returns The first result from the callback called, or undefined
+   */
+
 
   static iterateAllItems(visibleStart, visibleEnd, floatingStartCount, floatingEndCount, totalCount, callback) {
     var visibleStartIndex = Math.max(visibleStart, floatingStartCount);
@@ -85,16 +117,39 @@ class GridUtils {
 
     return undefined;
   }
+  /**
+   * Check if the coordinate is within the item specified in this dimension
+   * @param itemIndex Index of the item to check
+   * @param itemCoordinatess Coordinate of all items in this dimension
+   * @param itemSizes Size of all items in this dimension
+   * @param coordinate The coordinate to check
+   * @returns True if the coordinate is within the item specified, false otherwise
+   */
+
+
+  static isInItem(itemIndex, itemCoordinates, itemSizes, coordinate) {
+    var _itemCoordinates$get, _itemSizes$get;
 
-  static isInItem(itemIndex, itemXs, itemSizes, x) {
-    var itemX = itemXs.get(itemIndex);
-    var itemSize = itemSizes.get(itemIndex);
-    return itemX <= x && x <= itemX + itemSize;
+    var itemX = (_itemCoordinates$get = itemCoordinates.get(itemIndex)) !== null && _itemCoordinates$get !== void 0 ? _itemCoordinates$get : 0;
+    var itemSize = (_itemSizes$get = itemSizes.get(itemIndex)) !== null && _itemSizes$get !== void 0 ? _itemSizes$get : 0;
+    return itemX <= coordinate && coordinate <= itemX + itemSize;
   }
+  /**
+   * Get the Index of the item at the provided offset
+   * @param offset Coordinate of the offset to get the item of
+   * @param itemCount The total count of items
+   * @param floatingStart Count of floating items at the start
+   * @param floatingEnd Count of floating items at the end
+   * @param items Index of all items
+   * @param itemCoordinates The coordinate of each item
+   * @param itemSizes The size of each item
+   * @returns The item index, or null if no item matches
+   */
 
-  static getItemAtOffset(offset, itemCount, floatingStart, floatingEnd, items, itemXs, itemSizes) {
+
+  static getItemAtOffset(offset, itemCount, floatingStart, floatingEnd, items, itemCoordinates, itemSizes) {
     var floatingItem = GridUtils.iterateFloating(floatingStart, floatingEnd, itemCount, item => {
-      if (GridUtils.isInItem(item, itemXs, itemSizes, offset)) {
+      if (GridUtils.isInItem(item, itemCoordinates, itemSizes, offset)) {
         return item;
       }
 
@@ -108,13 +163,20 @@ class GridUtils {
     for (var i = 0; i < items.length; i += 1) {
       var item = items[i];
 
-      if (GridUtils.isInItem(item, itemXs, itemSizes, offset)) {
+      if (GridUtils.isInItem(item, itemCoordinates, itemSizes, offset)) {
         return item;
       }
     }
 
     return null;
   }
+  /**
+   * Get the index of the column at the specified x coordinate
+   * @param x Coordinate to get the item of
+   * @param metrics Grid metrics
+   * @returns Index of the column at that coordinate, or null if no column matches
+   */
+
 
   static getColumnAtX(x, metrics) {
     var {
@@ -133,6 +195,13 @@ class GridUtils {
 
     return this.getItemAtOffset(x - gridX, columnCount, floatingLeftColumnCount, floatingRightColumnCount, visibleColumns, visibleColumnXs, visibleColumnWidths);
   }
+  /**
+   * Get the index of the row at the specified y coordinate
+   * @param y Coordinate to get the item of
+   * @param metrics Grid metrics
+   * @returns Index of the row at that coordinate, or null if no row matches
+   */
+
 
   static getRowAtY(y, metrics) {
     var {
@@ -157,6 +226,7 @@ class GridUtils {
    * @param {Map} modelIndexes The mapping of model indexes
    * @param {Number[]} visibleItems The visible items
    * @param {Map} userSizes The user set sizes
+   * @returns Index of the next visible item, or null if no more are visible
    */
 
 
@@ -168,7 +238,7 @@ class GridUtils {
       var item = visibleItems[visibleItemIndex];
       var modelIndex = modelIndexes.get(item);
 
-      if (userSizes.get(modelIndex) !== 0) {
+      if (modelIndex != null && userSizes.get(modelIndex) !== 0) {
         return item;
       }
 
@@ -179,8 +249,9 @@ class GridUtils {
   }
   /**
    * Iterate backward through the visible columns until a shown column is hit
-   * @param {Number} columnIndex The column index to start iterating backward from
-   * @param {GridMetrics} metrics The GridMetricCalculator metrics
+   * @param columnIndex The column index to start iterating backward from
+   * @param metrics The GridMetricCalculator metrics
+   * @returns Index of the next visible item, or null if no more are visible
    */
 
 
@@ -194,8 +265,9 @@ class GridUtils {
   }
   /**
    * Iterate backward through the visible rows until a shown row is hit
-   * @param {Number} rowIndex The row index to start iterating backward from
-   * @param {GridMetrics} metrics The GridMetricCalculator metrics
+   * @param rowIndex The row index to start iterating backward from
+   * @param metrics The GridMetricCalculator metrics
+   * @returns Index of the next visible item, or null if no more are visible
    */
 
 
@@ -208,12 +280,12 @@ class GridUtils {
     return GridUtils.getNextShownItem(startIndex, modelRows, visibleRows, userRowHeights);
   }
   /**
-   * Gets the column index if the x/y coordinated provided are close enough
-   * @param {Number} x Mouse x coordinate
-   * @param {Number} y Mouse y coordinate
-   * @param {GridMetrics} metrics The GridMetricCalculator metrics
-   * @param {GridTheme} theme The grid theme with potantial user overrides
-   * @returns {Number|null} Column index or null
+   * Gets the column index if the x/y coordinates provided are close enough to the separator, otherwise null
+   * @param x Mouse x coordinate
+   * @param y Mouse y coordinate
+   * @param metrics The grid metrics
+   * @param theme The grid theme with potential user overrides
+   * @returns Index of the column separator at the coordinates provided, or null if none match
    */
 
 
@@ -222,16 +294,15 @@ class GridUtils {
       rowHeaderWidth,
       columnHeaderHeight,
       floatingColumns,
+      floatingLeftWidth,
       visibleColumns,
       visibleColumnXs,
-      visibleColumnWidths,
-      floatingLeftColumnCount
+      visibleColumnWidths
     } = metrics;
     var {
       allowColumnResize,
       headerSeparatorHandleSize
     } = theme;
-    var floatingLeftColumnsWidth = visibleColumnXs.get(floatingLeftColumnCount - 1) + visibleColumnWidths.get(floatingLeftColumnCount - 1);
 
     if (columnHeaderHeight < y || !allowColumnResize || headerSeparatorHandleSize <= 0) {
       return null;
@@ -243,9 +314,11 @@ class GridUtils {
     var isPreviousColumnHidden = false;
 
     for (var i = floatingColumns.length - 1; i >= 0; i -= 1) {
+      var _visibleColumnXs$get, _visibleColumnWidths$;
+
       var column = floatingColumns[i];
-      var columnX = visibleColumnXs.get(column);
-      var columnWidth = visibleColumnWidths.get(column);
+      var columnX = (_visibleColumnXs$get = visibleColumnXs.get(column)) !== null && _visibleColumnXs$get !== void 0 ? _visibleColumnXs$get : 0;
+      var columnWidth = (_visibleColumnWidths$ = visibleColumnWidths.get(column)) !== null && _visibleColumnWidths$ !== void 0 ? _visibleColumnWidths$ : 0;
       var isColumnHidden = columnWidth === 0;
 
       if (!isPreviousColumnHidden || !isColumnHidden) {
@@ -272,16 +345,18 @@ class GridUtils {
     isPreviousColumnHidden = false;
 
     for (var _i = visibleColumns.length - 1; _i >= 0; _i -= 1) {
+      var _visibleColumnXs$get2, _visibleColumnWidths$2;
+
       var _column = visibleColumns[_i];
 
-      var _columnX = visibleColumnXs.get(_column);
+      var _columnX = (_visibleColumnXs$get2 = visibleColumnXs.get(_column)) !== null && _visibleColumnXs$get2 !== void 0 ? _visibleColumnXs$get2 : 0;
 
-      var _columnWidth = visibleColumnWidths.get(_column);
+      var _columnWidth = (_visibleColumnWidths$2 = visibleColumnWidths.get(_column)) !== null && _visibleColumnWidths$2 !== void 0 ? _visibleColumnWidths$2 : 0;
 
       var _isColumnHidden = _columnWidth === 0; // If this column is under the floating columns "layer". Terminate early.
 
 
-      if (_columnX < floatingLeftColumnsWidth - _columnWidth) {
+      if (_columnX < floatingLeftWidth - _columnWidth) {
         return null;
       }
 
@@ -308,10 +383,24 @@ class GridUtils {
 
     return null;
   }
+  /**
+   * Check if the item specified is hidden
+   * @param itemIndex Index of the item to check
+   * @param visibleSizes Sizes of all visible items
+   * @returns True if the item is hidden, false otherwise
+   */
+
 
   static isItemHidden(itemIndex, visibleSizes) {
     return visibleSizes.get(itemIndex) === 0;
   }
+  /**
+   * Check if the column specified is hidden
+   * @param columnIndex Index of the column to check
+   * @param metrics Grid metrics
+   * @returns True if the column is hidden, false otherwise
+   */
+
 
   static isColumnHidden(columnIndex, metrics) {
     var {
@@ -321,8 +410,9 @@ class GridUtils {
   }
   /**
    * Check if the provided row is a floating row
-   * @param {number} row The row index to check
-   * @param {GridMetrics} metrics The grid metrics to check against
+   * @param row The row index to check
+   * @param metrics The grid metrics to check against
+   * @returns True if it's a floating row, false otherwise
    */
 
 
@@ -340,8 +430,9 @@ class GridUtils {
   }
   /**
    * Check if the provided column is a floating column
-   * @param {number} column The column index to check
-   * @param {GridMetrics} metrics The grid metrics to check against
+   * @param column The column index to check
+   * @param metrics The grid metrics to check against
+   * @returns True if it's a floating column, false otherwise
    */
 
 
@@ -357,6 +448,15 @@ class GridUtils {
     } = metrics;
     return column < floatingLeftColumnCount || column >= columnCount - floatingRightColumnCount;
   }
+  /**
+   * Get all the items that are hidden under the same Index
+   * E.g. If columns are 1, 2, 3, 4, 5, and column 2, 3, 4 are hidden, and we check for item 4, the return will be [2, 3, 4]
+   * @param itemIndex Index of the item to start at
+   * @param visibleSizes Visible size map
+   * @param visibleItems Visible items
+   * @returns Array of items that are hidden
+   */
+
 
   static getHiddenItems(itemIndex, visibleSizes, visibleItems) {
     if (!GridUtils.isItemHidden(itemIndex, visibleSizes)) {
@@ -378,6 +478,13 @@ class GridUtils {
 
     return hiddenItems;
   }
+  /**
+   * Get all the columns that are hidden under the same Index
+   * @param columnIndex Index of the item to start at
+   * @param metrics Grid metrics
+   * @returns Array of items that are hidden
+   */
+
 
   static getHiddenColumns(columnIndex, metrics) {
     var {
@@ -385,7 +492,15 @@ class GridUtils {
       visibleColumnWidths
     } = metrics;
     return GridUtils.getHiddenItems(columnIndex, visibleColumnWidths, visibleColumns);
-  } // Returns the row index if the x/y coordinates provided are close enough to the separator, otherwise false
+  }
+  /**
+   * Returns the row index if the x/y coordinates provided are close enough to the separator, otherwise null
+   * @param x X coordinate to check
+   * @param y Y coordinate to check
+   * @param metrics The grid metrics
+   * @param theme The grid theme
+   * @returns Index of the row separator at the coordinates provided, or null if none match
+   */
 
 
   static getRowSeparatorIndex(x, y, metrics, theme) {
@@ -411,9 +526,11 @@ class GridUtils {
     var isPreviousRowHidden = false;
 
     for (var i = visibleRows.length - 1; i >= 0; i -= 1) {
+      var _visibleRowYs$get, _visibleRowHeights$ge;
+
       var row = visibleRows[i];
-      var rowY = visibleRowYs.get(row);
-      var rowHeight = visibleRowHeights.get(row);
+      var rowY = (_visibleRowYs$get = visibleRowYs.get(row)) !== null && _visibleRowYs$get !== void 0 ? _visibleRowYs$get : 0;
+      var rowHeight = (_visibleRowHeights$ge = visibleRowHeights.get(row)) !== null && _visibleRowHeights$ge !== void 0 ? _visibleRowHeights$ge : 0;
       var isRowHidden = rowHeight === 0;
 
       if (!isPreviousRowHidden || !isRowHidden) {
@@ -438,6 +555,13 @@ class GridUtils {
 
     return null;
   }
+  /**
+   * Check if the row specified is hidden
+   * @param rowIndex Index of the row to check
+   * @param metrics Grid metrics
+   * @returns True if the row is hidden, false otherwise
+   */
+
 
   static isRowHidden(rowIndex, metrics) {
     var {
@@ -445,6 +569,13 @@ class GridUtils {
     } = metrics;
     return GridUtils.isItemHidden(rowIndex, visibleRowHeights);
   }
+  /**
+   * Get all the rows that are hidden under the same Index
+   * @param rowIndex Index of the item to start at
+   * @param metrics Grid metrics
+   * @returns Array of items that are hidden
+   */
+
 
   static getHiddenRows(rowIndex, metrics) {
     var {
@@ -455,10 +586,10 @@ class GridUtils {
   }
   /**
    * Set a new order for items in the grid
-   * @param {Number} from The visible index to move from
-   * @param {Number} to The visible index to move the itme to
-   * @param {Array} oldMovedItems The old reordered items
-   * @returns {Number} The new reordered items
+   * @param from The visible index to move from
+   * @param to The visible index to move the itme to
+   * @param oldMovedItems The old reordered items
+   * @returns The new reordered items
    */
 
 
@@ -469,7 +600,7 @@ class GridUtils {
       return oldMovedItems;
     }
 
-    var movedItems = [].concat(oldMovedItems);
+    var movedItems = [...oldMovedItems];
 
     if (movedItems.length > 0 && movedItems[movedItems.length - 1].to === from) {
       movedItems[movedItems.length - 1] = _objectSpread(_objectSpread({}, movedItems[movedItems.length - 1]), {}, {
@@ -486,9 +617,9 @@ class GridUtils {
   }
   /**
    * Retrieve the model index given the currently moved items
-   * @param {Number} visibleIndex The visible index of the item to get the model index for
-   * @param {Array} movedItems The moved items
-   * @returns {Number} The model index of the item
+   * @param visibleIndex The visible index of the item to get the model index for
+   * @param movedItems The moved items
+   * @returns The model index of the item
    */
 
 
@@ -516,14 +647,18 @@ class GridUtils {
    * Translate the provided UI start/end indexes to the model start/end indexes by applying the `movedItems` transformations.
    * Since moved items can split apart a range, multiple pairs of indexes are returned
    *
-   * @param {number} start Start item in one dimension
-   * @param {number} end End item in one dimension
-   * @param {MovedItem[]} movedItems Moved item pairs in this dimension
-   * @returns {AxisRange[]} Array of start/end pairs of the indexes after transformations applied.
+   * @param start Start item in one dimension
+   * @param end End item in one dimension
+   * @param movedItems Moved item pairs in this dimension
+   * @returns Array of start/end pairs of the indexes after transformations applied.
    */
 
 
   static getModelRangeIndexes(start, end, movedItems) {
+    if (start == null || end == null) {
+      return [[start, end]];
+    }
+
     var result = [[start, end]];
 
     if (start == null) {
@@ -614,10 +749,10 @@ class GridUtils {
    * Translate the provided UI range into model range, using the `movedColumns` and `movedRows` to apply the necessary transforms.
    * `movedColumns` and `movedRows` are array of operations done to the UI indexes to re-order items
    *
-   * @param {GridRange} uiRange The currently selected UI ranges
-   * @param {Array} movedColumns The moved column pairs
-   * @param {Array} movedRows The moved row pairs
-   * @returns {GridRange[]} The model ranges after translation.
+   * @param uiRange The currently selected UI ranges
+   * @param movedColumns The moved column pairs
+   * @param movedRows The moved row pairs
+   * @returns The model ranges after translation.
    */
 
 
@@ -643,10 +778,10 @@ class GridUtils {
    * Translate the provided UI range into model ranges, using the `movedColumns` and `movedRows` to apply the necessary transforms.
    * `movedColumns` and `movedRows` are array of operations done to the UI indexes to re-order items
    *
-   * @param {GridRange[]} uiRanges The currently selected UI ranges
-   * @param {Array} movedColumns The moved column pairs
-   * @param {Array} movedRows The moved row pairs
-   * @returns {GridRange[]} The model ranges after translation.
+   * @param uiRanges The currently selected UI ranges
+   * @param movedColumns The moved column pairs
+   * @param movedRows The moved row pairs
+   * @returns The model ranges after translation.
    */
 
 
@@ -663,9 +798,9 @@ class GridUtils {
   }
   /**
    * Retrieve the visible index given the currently moved items
-   * @param {Number} modelIndex The model index to get the visible index for
-   * @param {Array} movedItems Moved items
-   * @returns {Number} The visible index of the item
+   * @param modelIndex The model index to get the visible index for
+   * @param movedItems Moved items
+   * @returns The visible index of the item
    */
 
 
@@ -689,6 +824,11 @@ class GridUtils {
 
     return visibleIndex;
   }
+  /**
+   * Check if the current platform is Mac
+   * @returns True if this platform is a Mac, false otherwise
+   */
+
 
   static isMacPlatform() {
     var {
@@ -696,6 +836,11 @@ class GridUtils {
     } = window.navigator;
     return platform.startsWith('Mac');
   }
+  /**
+   * Get the modifier key for the current platform
+   * @returns The modifier key for the current platform
+   */
+
 
   static getModifierKey() {
     if (GridUtils.isMacPlatform()) {
@@ -704,15 +849,35 @@ class GridUtils {
 
     return 'ctrlKey';
   }
+  /**
+   * Check if the modifier key is down for the given event
+   * @param event The event to check
+   * @returns True if the modifier key is down, false otherwise
+   */
+
 
   static isModifierKeyDown(event) {
     var modifierKey = GridUtils.getModifierKey();
     return event[modifierKey];
   }
+  /**
+   * Check if the user has hidden the specified column
+   * @param modelIndex The model index to check
+   * @param userColumnWidths The user set column widths
+   * @returns True if the user has hidden the column
+   */
+
 
   static checkColumnHidden(modelIndex, userColumnWidths) {
     return userColumnWidths.get(modelIndex) === 0;
   }
+  /**
+   * Check if all the columns specified are hidden
+   * @param columns Columns to check
+   * @param userColumnWidths The user set column widths
+   * @returns True if the user has hidden all of the columns
+   */
+
 
   static checkAllColumnsHidden(columns, userColumnWidths) {
     if (userColumnWidths.size === 0) {
@@ -724,9 +889,9 @@ class GridUtils {
   /**
    * Get the bounds the mouse needs to be dragged outside of from an initial selection before scrolling occurs.
    * Taking into account any floating rows that may be covering the viewport.
-   * @param {GridMetrics} metrics Grid metrics
-   * @param {number} row The row they started dragging in
-   * @param {number} column The column they started the drag from
+   * @param metrics Grid metrics
+   * @param row The row they started dragging in
+   * @param column The column they started the drag from
    * @returns Dimensions of the drag area in relation to the canvas they need to drag outside of to start scrolling
    */
 
@@ -748,14 +913,14 @@ class GridUtils {
       columnCount,
       rowCount
     } = metrics;
-    var x = gridX;
-    var y = gridY;
+    var x1 = gridX;
+    var y1 = gridY;
     var x2 = width;
     var y2 = height;
 
     if (column != null) {
       if (column > floatingLeftColumnCount) {
-        x += floatingLeftWidth;
+        x1 += floatingLeftWidth;
       }
 
       if (column < columnCount - floatingRightColumnCount) {
@@ -765,7 +930,7 @@ class GridUtils {
 
     if (row != null) {
       if (row > floatingTopRowCount) {
-        y += floatingTopHeight;
+        y1 += floatingTopHeight;
       }
 
       if (row < rowCount - floatingBottomRowCount) {
@@ -774,8 +939,8 @@ class GridUtils {
     }
 
     return {
-      x,
-      y,
+      x1,
+      y1,
       x2,
       y2
     };
@@ -783,12 +948,12 @@ class GridUtils {
   /**
    * Converts the delta coordinates from the provided wheel event to pixels
    * Different platforms have different ways of providing the delta so this normalizes it
-   * @param {WheelEvent} wheelEvent The mouse wheel event to get the scrolling delta for
-   * @param {number?} pageWidth The width of the page that is scrolling
-   * @param {number?} pageHeight The height of the page that is scrolling
-   * @param {number?} lineWidth The width of the line scrolling in line mode
-   * @param {number?} lineHeight The height of the line scrolling in line mode
-   * @returns {{deltaX:number, deltaY: number}} The delta coordinates normalized to pixels
+   * @param wheelEvent The mouse wheel event to get the scrolling delta for
+   * @param pageWidth The width of the page that is scrolling
+   * @param pageHeight The height of the page that is scrolling
+   * @param lineWidth The width of the line scrolling in line mode
+   * @param lineHeight The height of the line scrolling in line mode
+   * @returns The delta coordinates normalized to pixels
    */