@deephaven/iris-grid 0.43.0 → 0.44.1-beta.0

package/dist/mousehandlers/IrisGridContextMenuHandler.js

@@ -0,0 +1,1220 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+/* eslint class-methods-use-this: "off" */
+import React from 'react';
+import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
+import { dhFilterFilled, vsRemove, vsCheck, vsFilter } from '@deephaven/icons';
+import debounce from 'lodash.debounce';
+import { ContextActions, ContextActionUtils, GLOBAL_SHORTCUTS } from '@deephaven/components';
+import { GridMouseHandler, GridRenderer, isEditableGridModel, isExpandableGridModel } from '@deephaven/grid';
+import { TableColumnFormatter, DateTimeColumnFormatter, TableUtils } from '@deephaven/jsapi-utils';
+import Log from '@deephaven/log';
+import { assertNotNull, copyToClipboard } from '@deephaven/utils';
+import { DateTimeFormatContextMenu, DecimalFormatContextMenu, IntegerFormatContextMenu } from "../format-context-menus/index.js";
+import "./IrisGridContextMenuHandler.css";
+import SHORTCUTS from "../IrisGridShortcuts.js";
+var log = Log.module('IrisGridContextMenuHandler');
+var DEBOUNCE_UPDATE_FORMAT = 150;
+var CONTEXT_MENU_DATE_FORMAT = 'yyyy-MM-dd HH:mm:ss.SSSSSSSSS';
+
+/**
+ * Used to eat the mouse event in the bottom right corner of the scroll bar
+ */
+class IrisGridContextMenuHandler extends GridMouseHandler {
+  /**
+   * Get filter condition for quick filter and combines with a new filter using the operator specified,
+   * returns new filter if no operator supplied.
+   * @param columnFilter
+   * @param newColumnFilter
+   * @param operator
+   */
+  static getQuickFilterCondition(columnFilter, newColumnFilter, operator) {
+    if (columnFilter && operator === '&&') {
+      return columnFilter.and(newColumnFilter);
+    }
+    if (columnFilter && operator === '||') {
+      return columnFilter.or(newColumnFilter);
+    }
+    return newColumnFilter;
+  }
+
+  /**
+   * combines filter text with operator if declared
+   * @param filterText
+   * @param newFilterText
+   * @param operator
+   */
+  static getQuickFilterText(filterText, newFilterText, operator) {
+    return operator && filterText != null ? "".concat(filterText, " ").concat(operator, " ").concat(newFilterText) : newFilterText;
+  }
+
+  /**
+   * Converts operator to text string,
+   */
+  static getOperatorAsText(operator) {
+    return operator === '&&' ? 'And' : 'Or';
+  }
+  static getRowOptionFormatted(command, cellValue) {
+    var len = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 30;
+    return "".concat(command, " \"").concat(GridRenderer.truncate(cellValue, len - command.length - 3), "\"");
+  }
+  constructor(irisGrid, dh) {
+    super();
+    _defineProperty(this, "irisGrid", void 0);
+    _defineProperty(this, "debouncedUpdateCustomFormat", void 0);
+    _defineProperty(this, "dh", void 0);
+    this.debouncedUpdateCustomFormat = debounce(irisGrid.handleFormatSelection, DEBOUNCE_UPDATE_FORMAT);
+    this.dh = dh;
+    this.irisGrid = irisGrid;
+  }
+  componentWillUnmount() {
+    this.debouncedUpdateCustomFormat.flush();
+  }
+  getHeaderActions(modelIndex, gridPoint) {
+    var {
+      irisGrid
+    } = this;
+    var {
+      column: visibleIndex
+    } = gridPoint;
+    assertNotNull(visibleIndex);
+    var {
+      model
+    } = irisGrid.props;
+    var {
+      columns
+    } = model;
+    var column = columns[modelIndex];
+    var actions = [];
+    var {
+      metrics,
+      reverseType,
+      quickFilters,
+      advancedFilters,
+      searchFilter
+    } = irisGrid.state;
+    var theme = irisGrid.getTheme();
+    assertNotNull(metrics);
+    var {
+      filterIconColor,
+      filterBarActiveColor,
+      contextMenuSortIconColor,
+      contextMenuReverseIconColor
+    } = theme;
+    var modelSort = model.sort;
+    var columnSort = TableUtils.getSortForColumn(modelSort, column.name);
+    var hasReverse = reverseType !== TableUtils.REVERSE_TYPE.NONE;
+    var {
+      userColumnWidths
+    } = metrics;
+    var isColumnHidden = [...userColumnWidths.values()].some(columnWidth => columnWidth === 0);
+    var isColumnFreezable = model.getColumnHeaderParentGroup(modelIndex, 0) === undefined && !(isExpandableGridModel(model) && model.hasExpandableRows);
+    var isColumnFrozen = model.isColumnFrozen(modelIndex);
+    var isColumnSortable = model.isColumnSortable(modelIndex);
+    actions.push({
+      title: 'Hide Column',
+      group: IrisGridContextMenuHandler.GROUP_HIDE_COLUMNS,
+      action: () => {
+        this.irisGrid.hideColumnByVisibleIndex(visibleIndex);
+      }
+    });
+    actions.push({
+      title: isColumnFrozen ? 'Unfreeze Column' : 'Freeze Column',
+      group: IrisGridContextMenuHandler.GROUP_HIDE_COLUMNS,
+      disabled: !isColumnFreezable,
+      action: () => {
+        if (isColumnFrozen) {
+          this.irisGrid.unFreezeColumnByColumnName(column.name);
+        } else {
+          this.irisGrid.freezeColumnByColumnName(column.name);
+        }
+      },
+      order: 10
+    });
+    actions.push({
+      title: 'Show All Columns',
+      group: IrisGridContextMenuHandler.GROUP_HIDE_COLUMNS,
+      action: () => {
+        this.irisGrid.showAllColumns();
+      },
+      disabled: !isColumnHidden
+    });
+    actions.push({
+      title: 'Quick Filters',
+      icon: vsRemove,
+      iconColor: filterBarActiveColor,
+      shortcut: SHORTCUTS.TABLE.TOGGLE_QUICK_FILTER,
+      group: IrisGridContextMenuHandler.GROUP_FILTER,
+      order: 10,
+      action: () => {
+        this.irisGrid.toggleFilterBar(visibleIndex);
+      }
+    });
+    actions.push({
+      title: 'Advanced Filters',
+      icon: advancedFilters.get(modelIndex) ? dhFilterFilled : vsFilter,
+      iconColor: filterIconColor,
+      group: IrisGridContextMenuHandler.GROUP_FILTER,
+      order: 20,
+      action: () => {
+        this.irisGrid.handleAdvancedMenuOpened(visibleIndex);
+      }
+    });
+    actions.push({
+      title: 'Clear Table Filters',
+      group: IrisGridContextMenuHandler.GROUP_FILTER,
+      order: 40,
+      // this just displays the shortcut, the actual listener is in irisgrid handleKeyDown
+      shortcut: SHORTCUTS.TABLE.CLEAR_FILTERS,
+      action: () => {
+        this.irisGrid.clearAllFilters();
+      },
+      disabled: !(quickFilters.size > 0 || advancedFilters.size > 0 || searchFilter != null)
+    });
+    actions.push({
+      title: 'Sort by',
+      icon: vsRemove,
+      iconColor: contextMenuSortIconColor,
+      group: IrisGridContextMenuHandler.GROUP_SORT,
+      order: 10,
+      actions: this.sortByActions(column, modelIndex, columnSort),
+      disabled: !isColumnSortable
+    });
+    actions.push({
+      title: 'Add Additional Sort',
+      /**
+       * disable conditions:
+       * 1. table is sorted only by this column
+       * 2. table is only reversed
+       * 3. 1 & 2 combined
+       * 4. table has no sort
+       * reverse is a type of sort, so needs to be accounted for in exclusions
+       * */
+      disabled: columnSort && modelSort.length === 1 || hasReverse && modelSort.length === 1 || columnSort && hasReverse && modelSort.length === 2 || modelSort.length === 0 || !isColumnSortable,
+      group: IrisGridContextMenuHandler.GROUP_SORT,
+      order: 20,
+      actions: this.additionalSortActions(column, modelIndex)
+    });
+    actions.push({
+      title: 'Clear Table Sorting',
+      disabled:
+      // reverse is a type of sort, but special and needs to be exluded despite being part of model.sort
+      modelSort.length === 0 || hasReverse && modelSort.length === 1,
+      group: IrisGridContextMenuHandler.GROUP_SORT,
+      action: () => {
+        this.irisGrid.sortColumn(visibleIndex, IrisGridContextMenuHandler.COLUMN_SORT_DIRECTION.none);
+      },
+      order: 30
+    });
+    actions.push({
+      title: reverseType === TableUtils.REVERSE_TYPE.NONE ? 'Reverse Table' : 'Clear Reverse Table',
+      icon: vsRemove,
+      iconColor: contextMenuReverseIconColor,
+      group: IrisGridContextMenuHandler.GROUP_SORT,
+      order: 40,
+      disabled: !model.isReversible,
+      // this just displays the shortcut, the actual listener is in irisgrid handleKeyDown
+      shortcut: SHORTCUTS.TABLE.REVERSE,
+      action: () => {
+        if (reverseType === TableUtils.REVERSE_TYPE.NONE) {
+          this.irisGrid.reverse(TableUtils.REVERSE_TYPE.POST_SORT);
+        } else {
+          this.irisGrid.reverse(TableUtils.REVERSE_TYPE.NONE);
+        }
+      }
+    });
+    actions.push({
+      title: 'Copy Column Name',
+      group: IrisGridContextMenuHandler.GROUP_COPY,
+      action: () => {
+        var _model$textForColumnH;
+        copyToClipboard((_model$textForColumnH = model.textForColumnHeader(modelIndex)) !== null && _model$textForColumnH !== void 0 ? _model$textForColumnH : '').catch(e => log.error('Unable to copy header', e));
+      }
+    });
+    if (TableUtils.isDateType(column.type)) {
+      actions.push({
+        title: 'Date/Time Format',
+        group: IrisGridContextMenuHandler.GROUP_FORMAT,
+        actions: this.dateFormatActions(column)
+      });
+    } else if (TableUtils.isNumberType(column.type)) {
+      var _this$numberFormatAct;
+      actions.push({
+        title: 'Number Format',
+        group: IrisGridContextMenuHandler.GROUP_FORMAT,
+        actions: (_this$numberFormatAct = this.numberFormatActions(column)) !== null && _this$numberFormatAct !== void 0 ? _this$numberFormatAct : undefined
+      });
+    }
+    return actions;
+  }
+  getCellActions(modelColumn, grid, gridPoint) {
+    assertNotNull(modelColumn);
+    var {
+      dh,
+      irisGrid
+    } = this;
+    var {
+      column: columnIndex,
+      row: rowIndex
+    } = gridPoint;
+    var {
+      model,
+      canCopy
+    } = irisGrid.props;
+    var {
+      columns
+    } = model;
+    var modelRow = irisGrid.getModelRow(rowIndex);
+    assertNotNull(modelRow);
+    var value = model.valueForCell(modelColumn, modelRow);
+    var valueText = model.textForCell(modelColumn, modelRow);
+    var column = columns[modelColumn];
+    var actions = [];
+    var {
+      quickFilters
+    } = irisGrid.state;
+    var theme = irisGrid.getTheme();
+    var {
+      filterIconColor
+    } = theme;
+    var {
+      settings
+    } = irisGrid.props;
+    var dateFilterFormatter = new DateTimeColumnFormatter(dh, {
+      timeZone: settings === null || settings === void 0 ? void 0 : settings.timeZone,
+      showTimeZone: false,
+      showTSeparator: true,
+      defaultDateTimeFormatString: CONTEXT_MENU_DATE_FORMAT
+    });
+    var previewFilterFormatter = new DateTimeColumnFormatter(dh, {
+      timeZone: settings === null || settings === void 0 ? void 0 : settings.timeZone,
+      showTimeZone: settings === null || settings === void 0 ? void 0 : settings.showTimeZone,
+      showTSeparator: settings === null || settings === void 0 ? void 0 : settings.showTSeparator,
+      defaultDateTimeFormatString: CONTEXT_MENU_DATE_FORMAT
+    });
+    if (column == null || rowIndex == null) return actions;
+
+    // grid data area context menu options
+    if (model.isFilterable(modelColumn)) {
+      // cell data area contextmenu options
+      var filterMenu = {
+        title: 'Filter by Value',
+        icon: vsRemove,
+        iconColor: filterIconColor,
+        group: IrisGridContextMenuHandler.GROUP_FILTER,
+        order: 10,
+        actions: []
+      };
+      if (value == null) {
+        // null gets a special menu
+        if (quickFilters.get(modelColumn)) {
+          filterMenu.actions.push({
+            title: 'And',
+            actions: this.nullFilterActions(column, quickFilters.get(modelColumn), '&&'),
+            order: 2,
+            group: ContextActions.groups.high
+          });
+        }
+        filterMenu.actions.push(...this.nullFilterActions(column));
+      } else if (value === '') {
+        // empty string gets a special menu
+        if (quickFilters.get(modelColumn)) {
+          filterMenu.actions.push({
+            title: 'And',
+            actions: this.emptyStringFilterActions(column, quickFilters.get(modelColumn), '&&'),
+            order: 2,
+            group: ContextActions.groups.high
+          });
+        }
+        filterMenu.actions.push(...this.emptyStringFilterActions(column));
+      } else if (TableUtils.isBooleanType(column.type)) {
+        // boolean should have OR condition, and handles it's own null menu options
+        if (quickFilters.get(modelColumn)) {
+          filterMenu.actions.push({
+            title: 'Or',
+            actions: this.booleanFilterActions(column, valueText, quickFilters.get(modelColumn), '||'),
+            order: 2,
+            group: ContextActions.groups.high
+          });
+        }
+        filterMenu.actions.push(...this.booleanFilterActions(column, valueText));
+      } else if (TableUtils.isNumberType(column.type) || TableUtils.isCharType(column.type)) {
+        // Chars get treated like numbers in terms of which filters are available
+        assertNotNull(modelColumn);
+        // We want to show the full unformatted value if it's a number, so user knows which value they are matching
+        // If it's a Char we just show the char
+        var numberValueText = TableUtils.isCharType(column.type) ? String.fromCharCode(value) : "".concat(value);
+        if (quickFilters.get(modelColumn)) {
+          filterMenu.actions.push({
+            title: 'And',
+            actions: this.numberFilterActions(column, numberValueText, value, quickFilters.get(modelColumn), '&&'),
+            order: 2,
+            group: ContextActions.groups.high
+          });
+        }
+        filterMenu.actions.push(...this.numberFilterActions(column, numberValueText, value, quickFilters.get(modelColumn)));
+      } else if (TableUtils.isDateType(column.type)) {
+        var dateValueText = dateFilterFormatter.format(value);
+        var previewValue = previewFilterFormatter.format(value);
+        if (quickFilters.get(modelColumn)) {
+          filterMenu.actions.push({
+            title: 'And',
+            actions: this.dateFilterActions(column, dateValueText, previewValue, value, quickFilters.get(modelColumn), '&&'),
+            order: 2,
+            group: ContextActions.groups.high
+          });
+        }
+        filterMenu.actions.push(...this.dateFilterActions(column, dateValueText, previewValue, value, quickFilters.get(modelColumn)));
+      } else {
+        if (quickFilters.get(modelColumn)) {
+          filterMenu.actions.push({
+            title: 'And',
+            actions: this.stringFilterActions(column, valueText, value, quickFilters.get(modelColumn), '&&'),
+            order: 2,
+            group: ContextActions.groups.high
+          });
+        }
+        filterMenu.actions.push(...this.stringFilterActions(column, valueText, value));
+      }
+      if (filterMenu.actions != null && filterMenu.actions.length > 0) {
+        actions.push(filterMenu);
+      }
+    }
+
+    // Expand/Collapse options
+    if (isExpandableGridModel(model) && model.isRowExpandable(modelRow)) {
+      // If there are grouped columns, then it is a rollup
+      // For rollups, the column number will be the depth minus one
+      var expandingColumn = model.groupedColumns.length > 0 ? model.depthForRow(modelRow) - 1 : 0;
+      var cellValue = model.valueForCell(expandingColumn, modelRow);
+      var cellText = cellValue == null ? 'null' : model.textForCell(expandingColumn, modelRow);
+      actions.push({
+        title: IrisGridContextMenuHandler.getRowOptionFormatted(model.isRowExpanded(modelRow) ? 'Collapse' : 'Expand', cellText),
+        group: IrisGridContextMenuHandler.GROUP_EXPAND_COLLAPSE,
+        order: 10,
+        action: () => {
+          model.setRowExpanded(modelRow, !model.isRowExpanded(modelRow));
+        }
+      });
+      if (model.isExpandAllAvailable === true) {
+        actions.push({
+          title: IrisGridContextMenuHandler.getRowOptionFormatted('Expand All in', cellText),
+          group: IrisGridContextMenuHandler.GROUP_EXPAND_COLLAPSE,
+          order: 20,
+          action: () => {
+            model.setRowExpanded(modelRow, true, true);
+          }
+        });
+      }
+    }
+    if (isExpandableGridModel(model) && model.hasExpandableRows && model.isExpandAllAvailable === true) {
+      actions.push({
+        title: 'Expand Entire Table',
+        group: IrisGridContextMenuHandler.GROUP_EXPAND_COLLAPSE,
+        order: 30,
+        action: () => {
+          model.expandAll();
+        }
+      });
+      actions.push({
+        title: 'Collapse Entire Table',
+        group: IrisGridContextMenuHandler.GROUP_EXPAND_COLLAPSE,
+        order: 40,
+        action: () => {
+          model.collapseAll();
+        }
+      });
+    }
+    var gotoRow = {
+      title: 'Go to',
+      iconColor: filterIconColor,
+      shortcut: SHORTCUTS.TABLE.GOTO_ROW,
+      group: IrisGridContextMenuHandler.GROUP_GOTO,
+      order: 10,
+      action: () => this.irisGrid.toggleGotoRow("".concat(rowIndex + 1), "".concat(value), column.name)
+    };
+    actions.push(gotoRow);
+    if (canCopy) {
+      actions.push({
+        title: 'Copy Cell',
+        group: IrisGridContextMenuHandler.GROUP_COPY,
+        order: 10,
+        action: () => {
+          irisGrid.copyCell(columnIndex, rowIndex);
+        }
+      });
+      actions.push({
+        title: 'Copy Cell Unformatted',
+        group: IrisGridContextMenuHandler.GROUP_COPY,
+        order: 20,
+        action: () => {
+          irisGrid.copyCell(columnIndex, rowIndex, true);
+        }
+      });
+    }
+    return actions;
+  }
+
+  /**
+   * Gets an equality filter for the provided numeric value
+   * @param column The column to make the filter for
+   * @param value The value to get the equality filter for
+   */
+  getNumberValueEqualsFilter(column, value) {
+    var {
+      dh
+    } = this;
+    var columnFilter = column.filter();
+    if (value === Number.POSITIVE_INFINITY) {
+      return dh.FilterCondition.invoke('isInf', columnFilter).and(columnFilter.greaterThan(dh.FilterValue.ofNumber(0)));
+    }
+    if (value === Number.NEGATIVE_INFINITY) {
+      return dh.FilterCondition.invoke('isInf', columnFilter).and(columnFilter.lessThan(dh.FilterValue.ofNumber(0)));
+    }
+    if (Number.isNaN(value)) {
+      return dh.FilterCondition.invoke('isNaN', columnFilter);
+    }
+    var filterValue = this.getFilterValueForNumberOrChar(column.type, value);
+    return columnFilter.eq(filterValue);
+  }
+  getFilterValueForNumberOrChar(columnType, value) {
+    var {
+      dh
+    } = this;
+    return TableUtils.isCharType(columnType) ? dh.FilterValue.ofString(String.fromCharCode(value)) : dh.FilterValue.ofNumber(value);
+  }
+  onContextMenu(gridPoint, grid, event) {
+    var {
+      irisGrid
+    } = this;
+    var {
+      y,
+      column: columnIndex,
+      row: rowIndex,
+      columnHeaderDepth
+    } = gridPoint;
+    var modelColumn = irisGrid.getModelColumn(columnIndex);
+    var modelRow = irisGrid.getModelRow(rowIndex);
+    var {
+      model,
+      canCopy
+    } = irisGrid.props;
+    var {
+      columns
+    } = model;
+    var {
+      metrics,
+      isFilterBarShown,
+      quickFilters,
+      advancedFilters,
+      selectedRanges
+    } = irisGrid.state;
+    assertNotNull(metrics);
+    var {
+      columnHeaderHeight,
+      gridY,
+      columnHeaderMaxDepth
+    } = metrics;
+    var actions = [];
+    if (modelColumn != null && modelRow != null) {
+      var value = model.valueForCell(modelColumn, modelRow);
+      var valueText = model.textForCell(modelColumn, modelRow);
+      var column = columns[modelColumn];
+      var {
+        onContextMenu
+      } = irisGrid.props;
+      if (column != null) {
+        actions.push(onContextMenu({
+          model,
+          value,
+          valueText,
+          column,
+          rowIndex,
+          columnIndex,
+          modelRow,
+          modelColumn
+        }));
+      }
+    }
+    if (modelColumn != null && model.isFilterable(modelColumn)) {
+      // Clear column filter should still be available after last row
+      // And should be available in both header and body context menus
+      actions.push({
+        title: 'Clear Column Filter',
+        group: IrisGridContextMenuHandler.GROUP_FILTER,
+        order: 30,
+        action: () => {
+          this.irisGrid.removeColumnFilter(modelColumn);
+        },
+        disabled: !(quickFilters.has(modelColumn) || advancedFilters.has(modelColumn))
+      });
+    }
+    if (isFilterBarShown ? y <= gridY : y <= columnHeaderHeight * columnHeaderMaxDepth && columnHeaderDepth === 0) {
+      // grid header context menu options
+      if (modelColumn != null) {
+        actions.push(...this.getHeaderActions(modelColumn, gridPoint));
+      }
+    } else {
+      // grid body context menu options
+      if (modelColumn != null && modelRow != null) {
+        actions.push(...this.getCellActions(modelColumn, grid, gridPoint));
+      }
+
+      // blank space context menu options
+      if (canCopy && selectedRanges.length > 0) {
+        actions.push({
+          title: 'Copy Selection',
+          shortcut: GLOBAL_SHORTCUTS.COPY,
+          group: IrisGridContextMenuHandler.GROUP_COPY,
+          order: 30,
+          action: () => {
+            irisGrid.copyRanges(selectedRanges);
+          }
+        });
+        actions.push({
+          title: 'Copy Selection w/ Headers',
+          group: IrisGridContextMenuHandler.GROUP_COPY,
+          order: 40,
+          action: () => {
+            irisGrid.copyRanges(selectedRanges, true);
+          }
+        });
+      }
+      if (isEditableGridModel(model) && model.isEditable && selectedRanges.length > 0) {
+        actions.push({
+          title: 'Delete Selected Rows',
+          group: IrisGridContextMenuHandler.GROUP_EDIT,
+          order: 50,
+          action: () => {
+            this.irisGrid.deleteRanges(selectedRanges);
+          }
+        });
+      }
+    }
+    if (actions.length === 0) {
+      return false;
+    }
+    assertNotNull(irisGrid.gridWrapper);
+    ContextActions.triggerMenu(irisGrid.gridWrapper, event.clientX, event.clientY, actions);
+    return true;
+  }
+  dateFormatActions(column) {
+    var _this = this;
+    var {
+      model
+    } = this.irisGrid.props;
+    var {
+      formatter
+    } = model;
+    var selectedFormat = formatter.getColumnFormat(column.type, column.name);
+    var formatOptions = DateTimeFormatContextMenu.getOptions(formatter, selectedFormat);
+    var actions = [];
+    var _loop = function _loop() {
+      var {
+        description,
+        format,
+        group,
+        isSelected,
+        title
+      } = formatOptions[i];
+      actions.push({
+        title,
+        description,
+        icon: isSelected ? vsCheck : undefined,
+        group,
+        order: i,
+        action: () => {
+          var modelIndex = model.getColumnIndexByName(column.name);
+          assertNotNull(modelIndex);
+          _this.irisGrid.handleFormatSelection(modelIndex, format);
+        }
+      });
+    };
+    for (var i = 0; i < formatOptions.length; i += 1) {
+      _loop();
+    }
+    return actions;
+  }
+  numberFormatActions(column) {
+    var _this2 = this;
+    var {
+      model
+    } = this.irisGrid.props;
+    var {
+      formatter
+    } = model;
+    var {
+      dh
+    } = this;
+    var selectedFormat = formatter.getColumnFormat(column.type, column.name);
+    var formatOptions;
+    var columnIndex = model.getColumnIndexByName(column.name);
+    if (TableUtils.isDecimalType(column.type)) {
+      formatOptions = DecimalFormatContextMenu.getOptions(dh, selectedFormat, format => {
+        assertNotNull(columnIndex);
+        this.debouncedUpdateCustomFormat(columnIndex, format);
+      });
+    } else if (TableUtils.isIntegerType(column.type)) {
+      formatOptions = IntegerFormatContextMenu.getOptions(dh, selectedFormat, format => {
+        assertNotNull(columnIndex);
+        this.debouncedUpdateCustomFormat(columnIndex, format);
+      });
+    } else {
+      log.error('Invalid column type in numberFormatActions');
+      return null;
+    }
+    var actions = [];
+    var _loop2 = function _loop2() {
+      var {
+        format,
+        isSelected
+      } = formatOptions[i];
+      actions.push(_objectSpread(_objectSpread({}, formatOptions[i]), {}, {
+        icon: isSelected ? vsCheck : undefined,
+        order: i,
+        action: () => {
+          if (columnIndex === undefined && format && format.type === TableColumnFormatter.TYPE_CONTEXT_CUSTOM) {
+            return;
+          }
+          assertNotNull(columnIndex);
+          _this2.irisGrid.handleFormatSelection(columnIndex, format);
+        }
+      }));
+    };
+    for (var i = 0; i < formatOptions.length; i += 1) {
+      _loop2();
+    }
+    return actions;
+  }
+  stringFilterActions(column, valueText, value, quickFilter, operator) {
+    var {
+      dh
+    } = this;
+    var filterValue = dh.FilterValue.ofString(value);
+    var newQuickFilter = quickFilter;
+    if (!newQuickFilter) {
+      newQuickFilter = {
+        filter: null,
+        text: null
+      };
+    }
+    var {
+      filter,
+      text: filterText
+    } = newQuickFilter;
+    var actions = [];
+    var {
+      model
+    } = this.irisGrid.props;
+    var columnIndex = model.getColumnIndexByName(column.name);
+    var quickFilterValueText = TableUtils.escapeQuickTextFilter(valueText);
+    assertNotNull(columnIndex);
+    actions.push({
+      menuElement: /*#__PURE__*/React.createElement("div", {
+        className: "iris-grid-filter-menu-item-value"
+      }, operator ? IrisGridContextMenuHandler.getOperatorAsText(operator) : '', ' ', "\"", valueText, "\""),
+      order: 1,
+      group: ContextActions.groups.high
+    });
+    actions.push({
+      title: 'text is exactly',
+      description: "Show only rows where ".concat(column.name, " is ").concat(value, " (case sensitive)"),
+      action: () => {
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().eq(filterValue), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, "".concat(quickFilterValueText), operator));
+      },
+      order: 10,
+      group: ContextActions.groups.low
+    });
+    actions.push({
+      title: 'text is not exactly',
+      description: "Show only rows where ".concat(column.name, " is not ").concat(valueText, " (case sensitive)"),
+      action: () => {
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().notEq(filterValue), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, "!=".concat(quickFilterValueText), operator));
+      },
+      order: 20,
+      group: ContextActions.groups.low
+    });
+    actions.push({
+      title: "text contains",
+      description: "Show only rows where ".concat(column.name, " contains ").concat(valueText),
+      action: () => {
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().isNull().not().and(column.filter().contains(filterValue)), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, "~".concat(quickFilterValueText), operator));
+      },
+      order: 30,
+      group: ContextActions.groups.low
+    });
+    actions.push({
+      title: 'text does not contain',
+      description: "Show only rows where ".concat(column.name, " does not contain ").concat(value),
+      action: () => {
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().isNull().or(column.filter().contains(filterValue).not()), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, "!~".concat(quickFilterValueText), operator));
+      },
+      order: 40,
+      group: ContextActions.groups.low
+    });
+    actions.push({
+      title: 'text starts with',
+      description: "Show only rows where ".concat(column.name, " starts with ").concat(valueText),
+      action: () => {
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().isNull().not().and(column.filter().invoke('startsWith', filterValue)), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, "".concat(quickFilterValueText, "*"), operator));
+      },
+      order: 50,
+      group: ContextActions.groups.low
+    });
+    actions.push({
+      title: 'text ends with',
+      description: "Show only rows where ".concat(column.name, " ends with ").concat(valueText),
+      action: () => {
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().isNull().not().and(column.filter().invoke('endsWith', filterValue)), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, "*".concat(quickFilterValueText), operator));
+      },
+      order: 60,
+      group: ContextActions.groups.low
+    });
+    return actions;
+  }
+  numberFilterActions(column, valueText, value, quickFilter, operator) {
+    var filterValue = this.getFilterValueForNumberOrChar(column.type, value);
+    var filter = null;
+    var filterText = null;
+    if (quickFilter) {
+      filter = quickFilter.filter;
+      filterText = quickFilter.text;
+    }
+    var actions = [];
+    var isFinite = value !== Number.POSITIVE_INFINITY && value !== Number.NEGATIVE_INFINITY && !Number.isNaN(value);
+    var {
+      model
+    } = this.irisGrid.props;
+    var columnIndex = model.getColumnIndexByName(column.name);
+    assertNotNull(columnIndex);
+    actions.push({
+      menuElement: /*#__PURE__*/React.createElement("div", {
+        className: "iris-grid-filter-menu-item-value"
+      }, operator ? IrisGridContextMenuHandler.getOperatorAsText(operator) : '', ' ', "\"", valueText, "\""),
+      order: 1,
+      group: ContextActions.groups.high
+    });
+    actions.push({
+      title: 'is equal to',
+      description: "Show only rows where ".concat(column.name, " is ").concat(valueText),
+      action: () => {
+        var valueFilter = this.getNumberValueEqualsFilter(column, value);
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, valueFilter, operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, "=".concat(valueText), operator));
+      },
+      order: 10,
+      group: ContextActions.groups.low
+    });
+    actions.push({
+      title: 'is not equal to',
+      description: "Show only rows where ".concat(column.name, " is not ").concat(valueText),
+      action: () => {
+        var valueFilter = this.getNumberValueEqualsFilter(column, value).not();
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, valueFilter, operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, "!=".concat(valueText), operator));
+      },
+      order: 20,
+      group: ContextActions.groups.low
+    });
+
+    // IDS-6092 Less/greater than filters don't make sense for Infinite/NaN
+    // TODO (DH-11799): These char filters should work in Bard, with the merge for DH-11040: https://gitlab.eng.illumon.com/illumon/iris/merge_requests/5801
+    // They do not work in Powell though, so disable them.
+    if (isFinite && !TableUtils.isCharType(column.type)) {
+      actions.push({
+        title: 'greater than',
+        description: "Show only rows where ".concat(column.name, " is greater than ").concat(valueText),
+        action: () => {
+          this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().greaterThan(filterValue), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, ">".concat(valueText), operator));
+        },
+        order: 30,
+        group: ContextActions.groups.low
+      });
+      actions.push({
+        title: 'greater than or equal to',
+        description: "Show only rows where ".concat(column.name, " is greater than or equal to ").concat(valueText),
+        action: () => {
+          this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().greaterThanOrEqualTo(filterValue), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, ">=".concat(valueText), operator));
+        },
+        order: 40,
+        group: ContextActions.groups.low
+      });
+      actions.push({
+        title: 'less than',
+        description: "Show only rows where ".concat(column.name, " is less than ").concat(valueText),
+        action: () => {
+          this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().lessThan(filterValue), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, "<".concat(valueText), operator));
+        },
+        order: 50,
+        group: ContextActions.groups.low
+      });
+      actions.push({
+        title: 'less than or equal to',
+        description: "Show only rows where ".concat(column.name, " is less than or equal to ").concat(valueText),
+        action: () => {
+          this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().lessThanOrEqualTo(filterValue), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, "<=".concat(valueText), operator));
+        },
+        order: 60,
+        group: ContextActions.groups.low
+      });
+    }
+    return actions;
+  }
+  booleanFilterActions(column, valueText, quickFilter, operator) {
+    var actions = [];
+    var {
+      model
+    } = this.irisGrid.props;
+    var {
+      filter,
+      text: filterText
+    } = quickFilter || {};
+    var columnIndex = model.getColumnIndexByName(column.name);
+    assertNotNull(columnIndex);
+    actions.push({
+      menuElement: /*#__PURE__*/React.createElement("div", {
+        className: "iris-grid-filter-menu-item-value"
+      }, operator ? IrisGridContextMenuHandler.getOperatorAsText(operator) : '', ' ', "\"", valueText !== null && valueText !== void 0 ? valueText : 'null', "\""),
+      order: 1,
+      group: ContextActions.groups.high
+    });
+    actions.push({
+      title: 'true',
+      description: "Show only rows where ".concat(column.name, " is true"),
+      action: () => {
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().isTrue(), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, 'true', operator));
+      },
+      order: 10,
+      group: ContextActions.groups.low
+    });
+    actions.push({
+      title: 'false',
+      description: "Show only rows where ".concat(column.name, " is false"),
+      action: () => {
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().isFalse(), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, 'false', operator));
+      },
+      order: 20,
+      group: ContextActions.groups.low
+    });
+    actions.push({
+      title: 'is null',
+      description: "Show only rows where ".concat(column.name, " is null"),
+      action: () => {
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().isNull(), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, 'null', operator));
+      },
+      order: 30,
+      group: ContextActions.groups.low
+    });
+    actions.push({
+      title: 'is not null',
+      description: "Show only rows where ".concat(column.name, " is not null"),
+      action: () => {
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().isNull().not(), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, '!null', operator));
+      },
+      order: 40,
+      group: ContextActions.groups.low
+    });
+    return actions;
+  }
+  dateFilterActions(column, valueText, previewValue, value, quickFilter, operator) {
+    var {
+      dh
+    } = this;
+    var filterValue = dh.FilterValue.ofNumber(value);
+    var filter = null;
+    var filterText = null;
+    if (quickFilter) {
+      filter = quickFilter.filter;
+      filterText = quickFilter.text;
+    }
+    var {
+      model
+    } = this.irisGrid.props;
+    var columnIndex = model.getColumnIndexByName(column.name);
+    assertNotNull(columnIndex);
+    var actions = [];
+    actions.push({
+      menuElement: /*#__PURE__*/React.createElement("div", {
+        className: "iris-grid-filter-menu-item-value"
+      }, operator ? IrisGridContextMenuHandler.getOperatorAsText(operator) : '', ' ', "\"", previewValue, "\""),
+      order: 1,
+      group: ContextActions.groups.high
+    });
+    actions.push({
+      title: 'date is',
+      description: "Show only rows where ".concat(column.name, " is ").concat(previewValue),
+      action: () => {
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().eq(filterValue), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, "=".concat(valueText), operator));
+      },
+      order: 10,
+      group: ContextActions.groups.low
+    });
+    actions.push({
+      title: 'date is not',
+      description: "Show only rows where ".concat(column.name, " is not ").concat(previewValue),
+      action: () => {
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().notEq(filterValue), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, "!=".concat(valueText), operator));
+      },
+      order: 20,
+      group: ContextActions.groups.low
+    });
+    actions.push({
+      title: 'date is before',
+      description: "Show only rows where ".concat(column.name, " is before ").concat(previewValue),
+      action: () => {
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().lessThan(filterValue), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, "<".concat(valueText), operator));
+      },
+      order: 30,
+      group: ContextActions.groups.low
+    });
+    actions.push({
+      title: 'date is before or equal',
+      description: "Show only rows where ".concat(column.name, " is before or equal to ").concat(previewValue),
+      action: () => {
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().lessThanOrEqualTo(filterValue), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, "<=".concat(valueText), operator));
+      },
+      order: 40,
+      group: ContextActions.groups.low
+    });
+    actions.push({
+      title: 'date is after',
+      description: "Show only rows where ".concat(column.name, " is greater than ").concat(previewValue),
+      action: () => {
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().greaterThan(filterValue), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, ">".concat(valueText), operator));
+      },
+      order: 50,
+      group: ContextActions.groups.low
+    });
+    actions.push({
+      title: 'date is after or equal',
+      description: "Show only rows where ".concat(column.name, " is after or equal to ").concat(previewValue),
+      action: () => {
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().greaterThanOrEqualTo(filterValue), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, ">=".concat(valueText), operator));
+      },
+      order: 60,
+      group: ContextActions.groups.low
+    });
+    return actions;
+  }
+  emptyStringFilterActions(column, quickFilter, operator) {
+    var {
+      dh
+    } = this;
+    var filterValue = dh.FilterValue.ofString('');
+    var newQuickFilter = quickFilter;
+    if (!newQuickFilter) {
+      newQuickFilter = {
+        filter: null,
+        text: null
+      };
+    }
+    var {
+      filter,
+      text: filterText
+    } = newQuickFilter;
+    var actions = [];
+    var {
+      model
+    } = this.irisGrid.props;
+    var columnIndex = model.getColumnIndexByName(column.name);
+    assertNotNull(columnIndex);
+    actions.push({
+      menuElement: /*#__PURE__*/React.createElement("div", {
+        className: "iris-grid-filter-menu-item-value"
+      }, operator ? IrisGridContextMenuHandler.getOperatorAsText(operator) : '', ' ', /*#__PURE__*/React.createElement("i", {
+        className: "text-muted"
+      }, "empty")),
+      order: 1,
+      group: ContextActions.groups.high
+    });
+    actions.push({
+      title: 'is empty string',
+      description: "Show only rows where ".concat(column.name, " is empty"),
+      action: () => {
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().eq(filterValue), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, "=", operator));
+      },
+      order: 10,
+      group: ContextActions.groups.low
+    });
+    actions.push({
+      title: 'is not empty string',
+      description: "Show only rows where ".concat(column.name, " is not empty"),
+      action: () => {
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().notEq(filterValue), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, "!=", operator));
+      },
+      order: 20,
+      group: ContextActions.groups.low
+    });
+    return actions;
+  }
+  nullFilterActions(column, quickFilter, operator) {
+    var filter = null;
+    var filterText = null;
+    if (quickFilter) {
+      filter = quickFilter.filter;
+      filterText = quickFilter.text;
+    }
+    var actions = [];
+    var {
+      model
+    } = this.irisGrid.props;
+    var columnIndex = model.getColumnIndexByName(column.name);
+    assertNotNull(columnIndex);
+    actions.push({
+      menuElement: /*#__PURE__*/React.createElement("div", {
+        className: "iris-grid-filter-menu-item-value"
+      }, operator ? IrisGridContextMenuHandler.getOperatorAsText(operator) : '', ' ', /*#__PURE__*/React.createElement("i", {
+        className: "text-muted"
+      }, "null")),
+      order: 1,
+      group: ContextActions.groups.high
+    });
+    actions.push({
+      title: 'is null',
+      description: "Show only rows where ".concat(column.name, " is null"),
+      action: () => {
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().isNull(), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, 'null', operator));
+      },
+      order: 10,
+      group: ContextActions.groups.low
+    });
+    actions.push({
+      title: 'is not null',
+      description: "Show only rows where ".concat(column.name, " is not null"),
+      action: () => {
+        this.irisGrid.setQuickFilter(columnIndex, IrisGridContextMenuHandler.getQuickFilterCondition(filter, column.filter().isNull().not(), operator), IrisGridContextMenuHandler.getQuickFilterText(filterText, '!null', operator));
+      },
+      order: 20,
+      group: ContextActions.groups.low
+    });
+    return actions;
+  }
+  sortByActions(column, modelColumn, columnSort) {
+    var theme = this.irisGrid.getTheme();
+    var {
+      contextMenuSortIconColor
+    } = theme;
+    var sortActions = [{
+      title: "".concat(column.name, " Ascending"),
+      order: 10,
+      action: () => {
+        this.irisGrid.sortColumn(modelColumn, IrisGridContextMenuHandler.COLUMN_SORT_DIRECTION.ascending);
+      },
+      icon: this.checkColumnSort(columnSort, IrisGridContextMenuHandler.COLUMN_SORT_DIRECTION.ascending) ? vsRemove : undefined,
+      iconColor: contextMenuSortIconColor
+    }, {
+      title: "".concat(column.name, " Descending"),
+      order: 20,
+      action: () => {
+        this.irisGrid.sortColumn(modelColumn, IrisGridContextMenuHandler.COLUMN_SORT_DIRECTION.descending);
+      },
+      icon: this.checkColumnSort(columnSort, IrisGridContextMenuHandler.COLUMN_SORT_DIRECTION.descending) ? vsRemove : undefined,
+      iconColor: contextMenuSortIconColor
+    }, {
+      title: "Remove Sort",
+      order: 50,
+      action: () => {
+        this.irisGrid.sortColumn(modelColumn, IrisGridContextMenuHandler.COLUMN_SORT_DIRECTION.none, false, true);
+      },
+      disabled: !columnSort
+    }];
+    if (TableUtils.isNumberType(column.type)) {
+      sortActions.push({
+        title: "ABS(".concat(column.name, ") Ascending"),
+        order: 30,
+        action: () => {
+          this.irisGrid.sortColumn(modelColumn, IrisGridContextMenuHandler.COLUMN_SORT_DIRECTION.ascending, true);
+        },
+        icon: this.checkColumnSort(columnSort, IrisGridContextMenuHandler.COLUMN_SORT_DIRECTION.ascending, true) ? vsRemove : undefined,
+        iconColor: contextMenuSortIconColor
+      });
+      sortActions.push({
+        title: "ABS(".concat(column.name, ")  Descending"),
+        order: 40,
+        action: () => {
+          this.irisGrid.sortColumn(modelColumn, IrisGridContextMenuHandler.COLUMN_SORT_DIRECTION.descending, true);
+        },
+        icon: this.checkColumnSort(columnSort, IrisGridContextMenuHandler.COLUMN_SORT_DIRECTION.descending, true) ? vsRemove : undefined,
+        iconColor: contextMenuSortIconColor
+      });
+    }
+    return sortActions;
+  }
+  additionalSortActions(column, columnIndex) {
+    var theme = this.irisGrid.getTheme();
+    var {
+      contextMenuSortIconColor
+    } = theme;
+    var additionalSortActions = [{
+      title: 'Add Sort By',
+      menuElement: /*#__PURE__*/React.createElement("div", {
+        className: "btn-context-menu menu-title"
+      }, /*#__PURE__*/React.createElement("span", {
+        className: "icon"
+      }, /*#__PURE__*/React.createElement(FontAwesomeIcon, {
+        icon: vsRemove,
+        style: {
+          color: contextMenuSortIconColor !== null && contextMenuSortIconColor !== void 0 ? contextMenuSortIconColor : undefined
+        }
+      })), /*#__PURE__*/React.createElement("span", {
+        className: "title"
+      }, "Add Additional Sort"), /*#__PURE__*/React.createElement("span", {
+        className: "shortcut"
+      }, ContextActionUtils.isMacPlatform() ? '⌘Click' : 'Ctrl+Click')),
+      order: 1
+    }, {
+      title: "".concat(column.name, " Ascending"),
+      order: 10,
+      action: () => {
+        this.irisGrid.sortColumn(columnIndex, IrisGridContextMenuHandler.COLUMN_SORT_DIRECTION.ascending, false, true);
+      }
+    }, {
+      title: "".concat(column.name, " Descending"),
+      order: 20,
+      action: () => {
+        this.irisGrid.sortColumn(columnIndex, IrisGridContextMenuHandler.COLUMN_SORT_DIRECTION.descending, false, true);
+      }
+    }];
+    if (TableUtils.isNumberType(column.type)) {
+      additionalSortActions.push({
+        title: "ABS(".concat(column.name, ") Ascending"),
+        order: 30,
+        action: () => {
+          this.irisGrid.sortColumn(columnIndex, IrisGridContextMenuHandler.COLUMN_SORT_DIRECTION.ascending, true, true);
+        }
+      });
+      additionalSortActions.push({
+        title: "ABS(".concat(column.name, ")  Descending"),
+        order: 40,
+        action: () => {
+          this.irisGrid.sortColumn(columnIndex, IrisGridContextMenuHandler.COLUMN_SORT_DIRECTION.descending, true, true);
+        }
+      });
+    }
+    return additionalSortActions;
+  }
+  checkColumnSort(columnSort) {
+    var direction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    var isAbs = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    if (!columnSort) {
+      return false;
+    }
+    return columnSort.direction === direction && columnSort.isAbs === isAbs;
+  }
+}
+_defineProperty(IrisGridContextMenuHandler, "GROUP_EDIT", ContextActions.groups.high + 10);
+_defineProperty(IrisGridContextMenuHandler, "GROUP_HIDE_COLUMNS", ContextActions.groups.high + 25);
+_defineProperty(IrisGridContextMenuHandler, "GROUP_FILTER", ContextActions.groups.high + 50);
+_defineProperty(IrisGridContextMenuHandler, "GROUP_EXPAND_COLLAPSE", ContextActions.groups.high + 55);
+_defineProperty(IrisGridContextMenuHandler, "GROUP_GOTO", ContextActions.groups.high + 60);
+_defineProperty(IrisGridContextMenuHandler, "GROUP_SORT", ContextActions.groups.high + 75);
+_defineProperty(IrisGridContextMenuHandler, "GROUP_COPY", ContextActions.groups.high + 100);
+_defineProperty(IrisGridContextMenuHandler, "GROUP_FORMAT", ContextActions.groups.high + 150);
+_defineProperty(IrisGridContextMenuHandler, "COLUMN_SORT_DIRECTION", {
+  ascending: 'ASC',
+  descending: 'DESC',
+  none: null
+});
+export default IrisGridContextMenuHandler;
+//# sourceMappingURL=IrisGridContextMenuHandler.js.map