@deephaven/grid 1.22.1-alpha-pivot-builder.0 → 1.22.2-alpha-pivot-builder.0

package/dist/GridUtils.js

@@ -1,3 +1,9 @@
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
@@ -33,18 +39,15 @@ export class GridUtils {
     };
   }
   static getCellInfoFromXY(x, y, metrics) {
-    var {
-      row,
-      column
-    } = GridUtils.getGridPointFromXY(x, y, metrics);
-    var {
-      allColumnWidths,
-      allRowHeights,
-      allColumnXs,
-      allRowYs,
-      modelColumns,
-      modelRows
-    } = metrics;
+    var _GridUtils$getGridPoi = GridUtils.getGridPointFromXY(x, y, metrics),
+      row = _GridUtils$getGridPoi.row,
+      column = _GridUtils$getGridPoi.column;
+    var allColumnWidths = metrics.allColumnWidths,
+      allRowHeights = metrics.allRowHeights,
+      allColumnXs = metrics.allColumnXs,
+      allRowYs = metrics.allRowYs,
+      modelColumns = metrics.modelColumns,
+      modelRows = metrics.modelRows;
     var modelRow = row !== null ? modelRows.get(row) : null;
     var modelColumn = column !== null ? modelColumns.get(column) : null;
     var left = column !== null ? allColumnXs.get(column) : null;
@@ -64,10 +67,8 @@ export class GridUtils {
   }
   static getColumnHeaderDepthAtY(y, metrics) {
     var row = GridUtils.getRowAtY(y, metrics);
-    var {
-      columnHeaderHeight,
-      columnHeaderMaxDepth
-    } = metrics;
+    var columnHeaderHeight = metrics.columnHeaderHeight,
+      columnHeaderMaxDepth = metrics.columnHeaderMaxDepth;
     if (row === null && y <= columnHeaderHeight * columnHeaderMaxDepth) {
       return clamp(columnHeaderMaxDepth - Math.ceil(y / columnHeaderHeight), 0, columnHeaderMaxDepth - 1);
     }
@@ -204,15 +205,13 @@ export class GridUtils {
    */
   static getColumnAtX(x, metrics) {
     var ignoreFloating = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-    var {
-      columnCount,
-      floatingLeftColumnCount,
-      floatingRightColumnCount,
-      visibleColumns,
-      allColumnXs,
-      allColumnWidths,
-      gridX
-    } = metrics;
+    var columnCount = metrics.columnCount,
+      floatingLeftColumnCount = metrics.floatingLeftColumnCount,
+      floatingRightColumnCount = metrics.floatingRightColumnCount,
+      visibleColumns = metrics.visibleColumns,
+      allColumnXs = metrics.allColumnXs,
+      allColumnWidths = metrics.allColumnWidths,
+      gridX = metrics.gridX;
     if (x < gridX) {
       return null;
     }
@@ -226,15 +225,13 @@ export class GridUtils {
    * @returns Index of the row at that coordinate, or null if no row matches
    */
   static getRowAtY(y, metrics) {
-    var {
-      floatingTopRowCount,
-      floatingBottomRowCount,
-      rowCount,
-      visibleRows,
-      allRowYs,
-      allRowHeights,
-      gridY
-    } = metrics;
+    var floatingTopRowCount = metrics.floatingTopRowCount,
+      floatingBottomRowCount = metrics.floatingBottomRowCount,
+      rowCount = metrics.rowCount,
+      visibleRows = metrics.visibleRows,
+      allRowYs = metrics.allRowYs,
+      allRowHeights = metrics.allRowHeights,
+      gridY = metrics.gridY;
     if (y < gridY) {
       return null;
     }
@@ -270,11 +267,9 @@ export class GridUtils {
    * @returns Index of the next visible item, or null if no more are visible
    */
   static getNextShownColumn(startIndex, metrics) {
-    var {
-      modelColumns,
-      visibleColumns,
-      userColumnWidths
-    } = metrics;
+    var modelColumns = metrics.modelColumns,
+      visibleColumns = metrics.visibleColumns,
+      userColumnWidths = metrics.userColumnWidths;
     return GridUtils.getNextShownItem(startIndex, modelColumns, visibleColumns, userColumnWidths);
   }
 
@@ -285,81 +280,81 @@ export class GridUtils {
    * @returns Index of the next visible item, or null if no more are visible
    */
   static getNextShownRow(startIndex, metrics) {
-    var {
-      modelRows,
-      visibleRows,
-      userRowHeights
-    } = metrics;
+    var modelRows = metrics.modelRows,
+      visibleRows = metrics.visibleRows,
+      userRowHeights = metrics.userRowHeights;
     return GridUtils.getNextShownItem(startIndex, modelRows, visibleRows, userRowHeights);
   }
 
   /**
-   * Check if a separator exists between a column and the next column at a given depth.
+   * Determine whether two adjacent columns belong to the same column-header group
+   * at the given depth.
    *
-   * - At leaf depth (0), every model column is separated from the rest.
-   * - At deeper depths, separator existence follows column-header-group identity when
-   *   the model exposes groups via `getColumnHeaderGroup`. Distinct group instances
-   *   that happen to share a display name (e.g. pivot Totals groups) are correctly
-   *   treated as separate.
-   * - When neither side has a declared group, fall back to header-text inequality so
-   *   plain grouped-header models (which express grouping only through repeated text)
-   *   keep their existing behavior.
-   * - The check is symmetric across the boundary: a separator is drawn at either
-   *   outer edge of a group cell, including the left edge of a group that is preceded
-   *   by an ungrouped column (empty band). Only a boundary with an empty band on
-   *   both sides has no separator.
+   * - When the model exposes group instances via `getColumnHeaderGroup`, identity
+   *   decides: two distinct group instances that happen to share a display name
+   *   (e.g. pivot Totals groups) are treated as different groups.
+   * - When only one side has a declared group, they are different groups.
+   * - When neither side has a declared group, fall back to header-text equality so
+   *   plain grouped-header models (which express grouping only through repeated
+   *   text) keep their existing behavior.
    *
    * @param model The grid model
    * @param depth The header depth to check at
-   * @param columnIndex The current model column index
-   * @param nextColumnIndex The next model column index (undefined for last column)
-   * @returns true if a separator should be shown, false otherwise
+   * @param columnIndex The first model column index
+   * @param otherColumnIndex The second model column index
+   * @returns true if both columns are part of the same group at this depth
    */
-  static hasColumnSeparatorAtDepth(model, depth, columnIndex, nextColumnIndex) {
-    if (depth == null || columnIndex == null) {
-      return false;
+  static isSameColumnGroupAtDepth(model, depth, columnIndex, otherColumnIndex) {
+    var groupA = model.getColumnHeaderGroup(columnIndex, depth);
+    var groupB = model.getColumnHeaderGroup(otherColumnIndex, depth);
+    if (groupA != null && groupB != null) {
+      return groupA === groupB;
     }
-
-    // Leaf depth: every distinct model column is a physical boundary
-    if (depth === 0) {
-      return true;
+    if (groupA != null || groupB != null) {
+      return false;
     }
 
-    // A header cell is drawn above a column at this depth when the column has a
-    // declared group or header text. Where no cell is drawn the band is empty.
-    var groupA = model.getColumnHeaderGroup(columnIndex, depth);
-    var hasHeaderCellA = groupA != null || model.textForColumnHeader(columnIndex, depth) != null;
-
-    // Right edge of the last column: a separator exists only if a cell is drawn
-    // above it (otherwise it is the right edge of an empty band).
-    if (nextColumnIndex == null) {
-      return hasHeaderCellA;
-    }
-    var groupB = model.getColumnHeaderGroup(nextColumnIndex, depth);
-    var hasHeaderCellB = groupB != null || model.textForColumnHeader(nextColumnIndex, depth) != null;
+    // Neither side has a declared group; fall back to text equality
+    return model.textForColumnHeader(columnIndex, depth) === model.textForColumnHeader(otherColumnIndex, depth);
+  }
 
-    // Empty band on both sides: nothing to separate
-    if (!hasHeaderCellA && !hasHeaderCellB) {
+  /**
+   * Check if a separator exists between the column at `visibleIndex` and the
+   * column immediately after it at a given header depth.
+   *
+   * - At leaf depth (0), every model column has a separator on its trailing edge.
+   * - At deeper depths, separator existence follows column-header-group identity
+   *   (see {@link isSameColumnGroupAtDepth}). Distinct group instances that share a
+   *   display name (e.g. pivot Totals groups) are correctly treated as separate.
+   * - The true trailing edge of the table (the last column) always has a separator.
+   *
+   * The next model column is resolved from `visibleIndex + 1` so that an off-screen
+   * neighbor is handled correctly and is not mistaken for the table's trailing edge.
+   *
+   * @param model The grid model
+   * @param depth The header depth to check at
+   * @param visibleIndex The visible index of the current column
+   * @param columnCount The total number of columns in the model
+   * @param movedColumns The current column-move operations
+   * @returns true if a separator should be shown, false otherwise
+   */
+  static hasColumnSeparatorAtDepth(model, depth, visibleIndex, columnCount, movedColumns) {
+    if (depth == null || visibleIndex == null) {
       return false;
     }
 
-    // Exactly one side has a header cell: this is an outer edge of a group cell
-    // (the left edge of a group preceded by an empty band, or the right edge of
-    // a group followed by one).
-    if (hasHeaderCellA !== hasHeaderCellB) {
+    // True trailing edge of the table
+    if (visibleIndex >= columnCount - 1) {
       return true;
     }
 
-    // Both sides have header cells
-    if (groupA != null && groupB != null) {
-      return groupA !== groupB;
-    }
-    if (groupA != null || groupB != null) {
+    // Leaf depth: every distinct model column is a physical boundary
+    if (depth === 0) {
       return true;
     }
-
-    // Neither side has a declared group; fall back to text inequality
-    return model.textForColumnHeader(columnIndex, depth) !== model.textForColumnHeader(nextColumnIndex, depth);
+    var columnIndex = GridUtils.getModelIndex(visibleIndex, movedColumns);
+    var nextColumnIndex = GridUtils.getModelIndex(visibleIndex + 1, movedColumns);
+    return !GridUtils.isSameColumnGroupAtDepth(model, depth, columnIndex, nextColumnIndex);
   }
 
   /**
@@ -372,21 +367,18 @@ export class GridUtils {
    * @returns Index of the column separator at the coordinates provided, or null if none match
    */
   static getColumnSeparatorIndex(x, y, metrics, theme, model) {
-    var {
-      rowHeaderWidth,
-      columnHeaderHeight,
-      floatingColumns,
-      floatingLeftWidth,
-      visibleColumns,
-      allColumnXs,
-      allColumnWidths,
-      columnHeaderMaxDepth,
-      modelColumns
-    } = metrics;
-    var {
-      allowColumnResize,
-      headerSeparatorHandleSize
-    } = theme;
+    var rowHeaderWidth = metrics.rowHeaderWidth,
+      columnHeaderHeight = metrics.columnHeaderHeight,
+      floatingColumns = metrics.floatingColumns,
+      floatingLeftWidth = metrics.floatingLeftWidth,
+      visibleColumns = metrics.visibleColumns,
+      allColumnXs = metrics.allColumnXs,
+      allColumnWidths = metrics.allColumnWidths,
+      columnHeaderMaxDepth = metrics.columnHeaderMaxDepth,
+      columnCount = metrics.columnCount,
+      movedColumns = metrics.movedColumns;
+    var allowColumnResize = theme.allowColumnResize,
+      headerSeparatorHandleSize = theme.headerSeparatorHandleSize;
     if (columnHeaderMaxDepth * columnHeaderHeight < y || !allowColumnResize || headerSeparatorHandleSize <= 0) {
       return null;
     }
@@ -411,7 +403,7 @@ export class GridUtils {
         }
         var minX = midX - halfSeparatorSize;
         var maxX = midX + halfSeparatorSize;
-        if (minX <= gridX && gridX <= maxX && GridUtils.hasColumnSeparatorAtDepth(model, depth, modelColumns.get(column), modelColumns.get(column + 1))) {
+        if (minX <= gridX && gridX <= maxX && GridUtils.hasColumnSeparatorAtDepth(model, depth, column, columnCount, movedColumns)) {
           return column;
         }
         isPreviousColumnHidden = isColumnHidden;
@@ -440,7 +432,7 @@ export class GridUtils {
         }
         var _minX = _midX - halfSeparatorSize;
         var _maxX = _midX + halfSeparatorSize;
-        if (_minX <= gridX && gridX <= _maxX && GridUtils.hasColumnSeparatorAtDepth(model, depth, modelColumns.get(_column), modelColumns.get(_column + 1))) {
+        if (_minX <= gridX && gridX <= _maxX && GridUtils.hasColumnSeparatorAtDepth(model, depth, _column, columnCount, movedColumns)) {
           return _column;
         }
         isPreviousColumnHidden = _isColumnHidden;
@@ -466,9 +458,7 @@ export class GridUtils {
    * @returns True if the column is hidden, false otherwise
    */
   static isColumnHidden(columnIndex, metrics) {
-    var {
-      allColumnWidths
-    } = metrics;
+    var allColumnWidths = metrics.allColumnWidths;
     return GridUtils.isItemHidden(columnIndex, allColumnWidths);
   }
 
@@ -482,11 +472,9 @@ export class GridUtils {
     if (row == null) {
       return false;
     }
-    var {
-      floatingTopRowCount,
-      floatingBottomRowCount,
-      rowCount
-    } = metrics;
+    var floatingTopRowCount = metrics.floatingTopRowCount,
+      floatingBottomRowCount = metrics.floatingBottomRowCount,
+      rowCount = metrics.rowCount;
     return row < floatingTopRowCount || row >= rowCount - floatingBottomRowCount;
   }
 
@@ -500,11 +488,9 @@ export class GridUtils {
     if (column == null) {
       return false;
     }
-    var {
-      floatingLeftColumnCount,
-      floatingRightColumnCount,
-      columnCount
-    } = metrics;
+    var floatingLeftColumnCount = metrics.floatingLeftColumnCount,
+      floatingRightColumnCount = metrics.floatingRightColumnCount,
+      columnCount = metrics.columnCount;
     return column < floatingLeftColumnCount || column >= columnCount - floatingRightColumnCount;
   }
 
@@ -539,10 +525,8 @@ export class GridUtils {
    * @returns Array of items that are hidden
    */
   static getHiddenColumns(columnIndex, metrics) {
-    var {
-      visibleColumns,
-      allColumnWidths
-    } = metrics;
+    var visibleColumns = metrics.visibleColumns,
+      allColumnWidths = metrics.allColumnWidths;
     return GridUtils.getHiddenItems(columnIndex, allColumnWidths, visibleColumns);
   }
 
@@ -555,17 +539,13 @@ export class GridUtils {
    * @returns Index of the row separator at the coordinates provided, or null if none match
    */
   static getRowSeparatorIndex(x, y, metrics, theme) {
-    var {
-      rowHeaderWidth,
-      columnHeaderHeight,
-      visibleRows,
-      allRowYs,
-      allRowHeights
-    } = metrics;
-    var {
-      allowRowResize,
-      headerSeparatorHandleSize
-    } = theme;
+    var rowHeaderWidth = metrics.rowHeaderWidth,
+      columnHeaderHeight = metrics.columnHeaderHeight,
+      visibleRows = metrics.visibleRows,
+      allRowYs = metrics.allRowYs,
+      allRowHeights = metrics.allRowHeights;
+    var allowRowResize = theme.allowRowResize,
+      headerSeparatorHandleSize = theme.headerSeparatorHandleSize;
     if (rowHeaderWidth < x || !allowRowResize || headerSeparatorHandleSize <= 0) {
       return null;
     }
@@ -605,9 +585,7 @@ export class GridUtils {
    * @returns True if the row is hidden, false otherwise
    */
   static isRowHidden(rowIndex, metrics) {
-    var {
-      allRowHeights
-    } = metrics;
+    var allRowHeights = metrics.allRowHeights;
     return GridUtils.isItemHidden(rowIndex, allRowHeights);
   }
 
@@ -618,10 +596,8 @@ export class GridUtils {
    * @returns Array of items that are hidden
    */
   static getHiddenRows(rowIndex, metrics) {
-    var {
-      visibleRows,
-      allRowHeights
-    } = metrics;
+    var visibleRows = metrics.visibleRows,
+      allRowHeights = metrics.allRowHeights;
     return GridUtils.getHiddenItems(rowIndex, allRowHeights, visibleRows);
   }
 
@@ -733,15 +709,15 @@ export class GridUtils {
     var reverse = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
     var result = [[start, end]];
     var _loop = function _loop() {
-      var {
-        from: fromItemOrRange,
-        to: toItem
-      } = movedItems[i];
+      var _movedItems$i = movedItems[i],
+        fromItemOrRange = _movedItems$i.from,
+        toItem = _movedItems$i.to;
       var length = 1;
       var fromItem;
       if (isBoundedAxisRange(fromItemOrRange)) {
         length = fromItemOrRange[1] - fromItemOrRange[0] + 1; // Ranges are inclusive
-        [fromItem] = fromItemOrRange;
+        var _fromItemOrRange = _slicedToArray(fromItemOrRange, 1);
+        fromItem = _fromItemOrRange[0];
       } else {
         fromItem = fromItemOrRange;
       }
@@ -755,17 +731,23 @@ export class GridUtils {
         var currentStart = (_result$j$ = result[j][0]) !== null && _result$j$ !== void 0 ? _result$j$ : Number.NEGATIVE_INFINITY;
         var currentEnd = (_result$j$2 = result[j][1]) !== null && _result$j$2 !== void 0 ? _result$j$2 : Number.POSITIVE_INFINITY;
         var movedRange;
-        var currentResult = [[currentStart, fromStart - 1], [fromStart, fromEnd], [fromEnd + 1, currentEnd]].map(_ref2 => {
-          var [s, e] = _ref2;
+        var currentResult = [[currentStart, fromStart - 1], [fromStart, fromEnd], [fromEnd + 1, currentEnd]].map(_ref3 => {
+          var _ref4 = _slicedToArray(_ref3, 2),
+            s = _ref4[0],
+            e = _ref4[1];
           return [
           // Cap the ranges to within the current range bounds
           Math.max(s, currentStart), Math.min(e, currentEnd)];
-        }).filter(_ref3 => {
-          var [s, e] = _ref3;
+        }).filter(_ref5 => {
+          var _ref6 = _slicedToArray(_ref5, 2),
+            s = _ref6[0],
+            e = _ref6[1];
           return s <= e;
         }) // Remove invalid ranges
         .map(range => {
-          var [s, e] = range;
+          var _range = _slicedToArray(range, 2),
+            s = _range[0],
+            e = _range[1];
           if (fromStart <= s && fromEnd >= e) {
             // Current range in moved range
             movedRange = [s + moveDistance, e + moveDistance];
@@ -777,7 +759,9 @@ export class GridUtils {
           }
           return range;
         }).map(range => {
-          var [s, e] = range;
+          var _range2 = _slicedToArray(range, 2),
+            s = _range2[0],
+            e = _range2[1];
           if (toStart > s && toStart <= e) {
             // Moved range splits this range
             return [[s, toStart - 1], [toStart + length, e + length]];
@@ -800,7 +784,9 @@ export class GridUtils {
 
       // Return infinity values back to null
       result = nextResult.map(_ref => {
-        var [s, e] = _ref;
+        var _ref2 = _slicedToArray(_ref, 2),
+          s = _ref2[0],
+          e = _ref2[1];
         return [Number.isFinite(s) ? s : null, Number.isFinite(e) ? e : null];
       });
     };
@@ -973,9 +959,7 @@ export class GridUtils {
    * @returns True if this platform is a Mac, false otherwise
    */
   static isMacPlatform() {
-    var {
-      platform
-    } = window.navigator;
+    var platform = window.navigator.platform;
     return platform.startsWith('Mac');
   }
 
@@ -1032,22 +1016,20 @@ export class GridUtils {
    * @returns Dimensions of the drag area in relation to the canvas they need to drag outside of to start scrolling
    */
   static getScrollDragBounds(metrics, row, column) {
-    var {
-      gridX,
-      gridY,
-      width,
-      height,
-      floatingTopRowCount,
-      floatingBottomRowCount,
-      floatingLeftColumnCount,
-      floatingRightColumnCount,
-      floatingLeftWidth,
-      floatingRightWidth,
-      floatingTopHeight,
-      floatingBottomHeight,
-      columnCount,
-      rowCount
-    } = metrics;
+    var gridX = metrics.gridX,
+      gridY = metrics.gridY,
+      width = metrics.width,
+      height = metrics.height,
+      floatingTopRowCount = metrics.floatingTopRowCount,
+      floatingBottomRowCount = metrics.floatingBottomRowCount,
+      floatingLeftColumnCount = metrics.floatingLeftColumnCount,
+      floatingRightColumnCount = metrics.floatingRightColumnCount,
+      floatingLeftWidth = metrics.floatingLeftWidth,
+      floatingRightWidth = metrics.floatingRightWidth,
+      floatingTopHeight = metrics.floatingTopHeight,
+      floatingBottomHeight = metrics.floatingBottomHeight,
+      columnCount = metrics.columnCount,
+      rowCount = metrics.rowCount;
     var x1 = gridX;
     var y1 = gridY;
     var x2 = width;
@@ -1091,10 +1073,8 @@ export class GridUtils {
     var pageHeight = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 768;
     var lineWidth = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 20;
     var lineHeight = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 20;
-    var {
-      deltaX,
-      deltaY
-    } = wheelEvent;
+    var deltaX = wheelEvent.deltaX,
+      deltaY = wheelEvent.deltaY;
 
     // Flip scroll direction if shiftKey is held on windows/linux.
     // On mac, deltaX/Y values are switched at the event level when shiftKey=true.
@@ -1165,20 +1145,16 @@ export class GridUtils {
    * @returns The token box with translated coordinates
    */
   static translateTokenBox(tokenBox, metrics) {
-    var {
-      x1: left,
-      y1: top,
-      x2: right,
-      y2: bottom
-    } = tokenBox;
-    var {
-      gridX,
-      gridY,
-      width: gridWidth,
-      height: gridHeight,
-      verticalBarWidth,
-      horizontalBarHeight
-    } = metrics;
+    var left = tokenBox.x1,
+      top = tokenBox.y1,
+      right = tokenBox.x2,
+      bottom = tokenBox.y2;
+    var gridX = metrics.gridX,
+      gridY = metrics.gridY,
+      gridWidth = metrics.width,
+      gridHeight = metrics.height,
+      verticalBarWidth = metrics.verticalBarWidth,
+      horizontalBarHeight = metrics.horizontalBarHeight;
 
     // Clamp the values within the grid
     var newLeft = clamp(gridX + left, gridX, gridWidth - verticalBarWidth);
@@ -1205,25 +1181,19 @@ export class GridUtils {
    * @returns Object with width, x, and y of the text
    */
   static getTextRenderMetrics(state, column, row) {
-    var {
-      metrics,
-      model,
-      theme
-    } = state;
-    var {
-      firstColumn,
-      allColumnXs,
-      allColumnWidths,
-      allRowYs,
-      allRowHeights,
-      modelRows,
-      modelColumns
-    } = metrics;
-    var {
-      cellHorizontalPadding,
-      treeDepthIndent,
-      treeHorizontalPadding
-    } = theme;
+    var metrics = state.metrics,
+      model = state.model,
+      theme = state.theme;
+    var firstColumn = metrics.firstColumn,
+      allColumnXs = metrics.allColumnXs,
+      allColumnWidths = metrics.allColumnWidths,
+      allRowYs = metrics.allRowYs,
+      allRowHeights = metrics.allRowHeights,
+      modelRows = metrics.modelRows,
+      modelColumns = metrics.modelColumns;
+    var cellHorizontalPadding = theme.cellHorizontalPadding,
+      treeDepthIndent = theme.treeDepthIndent,
+      treeHorizontalPadding = theme.treeHorizontalPadding;
     var modelRow = getOrThrow(modelRows, row);
     var modelColumn = getOrThrow(modelColumns, column);
     var textAlign = model.textAlignForCell(modelColumn, modelRow);