@deephaven/iris-grid 0.43.0 → 0.44.0

package/dist/IrisGridUtils.js

@@ -0,0 +1,1279 @@
+var _excluded = ["selectedValues"],
+  _excluded2 = ["selectedValues"];
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+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); }
+import { GridUtils } from '@deephaven/grid';
+import { DateUtils, TableUtils } from '@deephaven/jsapi-utils';
+import Log from '@deephaven/log';
+import { assertNotNull, EMPTY_ARRAY, EMPTY_MAP } from '@deephaven/utils';
+import AggregationUtils from "./sidebar/aggregations/AggregationUtils.js";
+import AggregationOperation from "./sidebar/aggregations/AggregationOperation.js";
+import AdvancedSettings from "./sidebar/AdvancedSettings.js";
+import ColumnHeaderGroup from "./ColumnHeaderGroup.js";
+var log = Log.module('IrisGridUtils');
+/**
+ * Checks if an index is valid for the given array
+ * @param x The index to check
+ * @param array The array
+ * @returns True if the index if valid within the array
+ */
+function isValidIndex(x, array) {
+  return x >= 0 && x < array.length;
+}
+function isDateWrapper(value) {
+  return value.asDate != null;
+}
+class IrisGridUtils {
+  /**
+   * Exports the state from Grid component to a JSON stringifiable object
+   * @param model The table model to export the Grid state for
+   * @param gridState The state of the Grid to export
+   * @returns An object that can be stringified and imported with {{@link hydrateGridState}}
+   */
+  static dehydrateGridState(model, gridState) {
+    var {
+      isStuckToBottom,
+      isStuckToRight,
+      movedColumns,
+      movedRows
+    } = gridState;
+    var {
+      columns
+    } = model;
+    return {
+      isStuckToBottom,
+      isStuckToRight,
+      movedColumns: [...movedColumns].filter(_ref => {
+        var {
+          to,
+          from
+        } = _ref;
+        return isValidIndex(to, columns) && (typeof from === 'number' && isValidIndex(from, columns) || Array.isArray(from) && isValidIndex(from[0], columns) && isValidIndex(from[1], columns));
+      }).map(_ref2 => {
+        var {
+          to,
+          from
+        } = _ref2;
+        return {
+          to: columns[to].name,
+          from: Array.isArray(from) ? [columns[from[0]].name, columns[from[1]].name] : columns[from].name
+        };
+      }),
+      movedRows: [...movedRows]
+    };
+  }
+
+  /**
+   * Import a state for Grid that was exported with {{@link dehydrateGridState}}
+   * @param model The table model to import the state for
+   * @param gridState The state of the panel that was saved
+   * @returns The gridState props to set on the Grid
+   */
+  static hydrateGridState(model, gridState) {
+    var customColumns = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+    var {
+      isStuckToBottom,
+      isStuckToRight,
+      movedColumns,
+      movedRows
+    } = gridState;
+    var {
+      columns
+    } = model;
+    var customColumnNames = IrisGridUtils.parseCustomColumnNames(customColumns);
+    var columnNames = columns.map(_ref3 => {
+      var {
+        name
+      } = _ref3;
+      return name;
+    }).concat(customColumnNames);
+    return {
+      isStuckToBottom,
+      isStuckToRight,
+      movedColumns: [...movedColumns].map(_ref4 => {
+        var {
+          to,
+          from
+        } = _ref4;
+        var getIndex = x => typeof x === 'string' ? columnNames.findIndex(name => name === x) : x;
+        return {
+          to: getIndex(to),
+          from: Array.isArray(from) ? [getIndex(from[0]), getIndex(from[1])] : getIndex(from)
+        };
+      }).filter(_ref5 => {
+        var {
+          to,
+          from
+        } = _ref5;
+        return isValidIndex(to, columnNames) && (typeof from === 'number' && isValidIndex(from, columnNames) || Array.isArray(from) && isValidIndex(from[0], columnNames) && isValidIndex(from[1], columnNames));
+      }),
+      movedRows: [...movedRows]
+    };
+  }
+
+  /**
+   * Export the IrisGridPanel state.
+   * @param model The table model the state is being dehydrated with
+   * @param irisGridPanelState The current IrisGridPanel state
+   * @returns The dehydrated IrisGridPanel state
+   */
+  static dehydrateIrisGridPanelState(model, irisGridPanelState) {
+    var {
+      isSelectingPartition,
+      partition,
+      partitionColumn,
+      advancedSettings
+    } = irisGridPanelState;
+
+    // Return value will be serialized, should not contain undefined
+    return {
+      isSelectingPartition,
+      partition,
+      partitionColumn: partitionColumn != null ? partitionColumn.name : null,
+      advancedSettings: [...advancedSettings]
+    };
+  }
+
+  /**
+   * Import the saved IrisGridPanel state.
+   * @param model The model the state is being hydrated with
+   * @param irisGridPanelState Exported IrisGridPanel state
+   * @returns The state to apply to the IrisGridPanel
+   */
+  static hydrateIrisGridPanelState(model, irisGridPanelState) {
+    var _IrisGridUtils$getCol;
+    var {
+      isSelectingPartition,
+      partition,
+      partitionColumn,
+      advancedSettings
+    } = irisGridPanelState;
+    var {
+      columns
+    } = model;
+    return {
+      isSelectingPartition,
+      partition: partition !== null && partition !== void 0 ? partition : null,
+      partitionColumn: partitionColumn != null ? (_IrisGridUtils$getCol = IrisGridUtils.getColumnByName(columns, partitionColumn)) !== null && _IrisGridUtils$getCol !== void 0 ? _IrisGridUtils$getCol : null : null,
+      advancedSettings: new Map([...AdvancedSettings.DEFAULTS, ...advancedSettings])
+    };
+  }
+
+  /**
+   * Export the quick filters to JSON striginfiable object
+   * @param quickFilters The quick filters to dehydrate
+   * @returns The dehydrated quick filters
+   */
+  static dehydrateQuickFilters(quickFilters) {
+    return [...quickFilters].map(_ref6 => {
+      var [columnIndex, quickFilter] = _ref6;
+      var {
+        text
+      } = quickFilter;
+      return [columnIndex, {
+        text
+      }];
+    });
+  }
+  static dehydrateLong(value) {
+    return value != null ? "".concat(value) : null;
+  }
+
+  /**
+   * Export the sorts from the provided table sorts to JSON stringifiable object
+   * @param  sorts The table sorts
+   * @returns The dehydrated sorts
+   */
+  static dehydrateSort(sorts) {
+    return sorts.map(sort => {
+      var {
+        column,
+        isAbs,
+        direction
+      } = sort;
+      return {
+        column: column.name,
+        isAbs,
+        direction
+      };
+    });
+  }
+
+  /**
+   * Pulls just the table settings from the panel state, eg. filters/sorts
+   * @param  panelState The dehydrated panel state
+   * @returns A dehydrated table settings object, { partition, partitionColumn, advancedFilters, quickFilters, sorts }
+   */
+  static extractTableSettings(panelState) {
+    var inputFilters = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    var {
+      irisGridPanelState,
+      irisGridState
+    } = panelState;
+    var {
+      partitionColumn,
+      partition
+    } = irisGridPanelState;
+    var {
+      advancedFilters,
+      quickFilters,
+      sorts
+    } = irisGridState;
+    return {
+      advancedFilters,
+      inputFilters,
+      partition,
+      partitionColumn,
+      quickFilters,
+      sorts
+    };
+  }
+  static getInputFiltersForColumns(columns) {
+    var inputFilters = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    return inputFilters.filter(_ref7 => {
+      var {
+        name,
+        type
+      } = _ref7;
+      return columns.find(_ref8 => {
+        var {
+          name: columnName,
+          type: columnType
+        } = _ref8;
+        return columnName === name && columnType === type;
+      });
+    });
+  }
+  static getFiltersFromFilterMap(filterMap) {
+    var filters = [];
+    var keys = Array.from(filterMap.keys());
+    for (var i = 0; i < keys.length; i += 1) {
+      var key = keys[i];
+      var item = filterMap.get(key);
+      if ((item === null || item === void 0 ? void 0 : item.filter) != null) {
+        filters.push(item.filter);
+      }
+    }
+    return filters;
+  }
+
+  /**
+   * Get array of hidden column indexes
+   * @param  userColumnWidths Map of user column widths
+   * @returns Array of hidden column indexes
+   */
+  static getHiddenColumns(userColumnWidths) {
+    return [...userColumnWidths.entries()].filter(_ref9 => {
+      var [, value] = _ref9;
+      return value === 0;
+    }).map(_ref10 => {
+      var [key] = _ref10;
+      return key;
+    });
+  }
+  static parseCustomColumnNames(customColumns) {
+    return customColumns.map(customColumn => customColumn.split('=')[0]);
+  }
+  static getRemovedCustomColumnNames(oldCustomColumns, customColumns) {
+    var oldCustomColumnsNames = IrisGridUtils.parseCustomColumnNames(oldCustomColumns);
+    var customColumnNames = IrisGridUtils.parseCustomColumnNames(customColumns);
+    return oldCustomColumnsNames.filter(oldCustomColumnName => !customColumnNames.includes(oldCustomColumnName));
+  }
+  static removeSortsInColumns(sorts, columnNames) {
+    return sorts.filter(sort => !columnNames.includes(sort.column.name));
+  }
+  static removeFiltersInColumns(columns, filters, removedColumnNames) {
+    var columnNames = columns.map(_ref11 => {
+      var {
+        name
+      } = _ref11;
+      return name;
+    });
+    var newFilter = new Map(filters);
+    removedColumnNames.forEach(columnName => newFilter.delete(columnNames.indexOf(columnName)));
+    return newFilter;
+  }
+  static removeColumnFromMovedColumns(columns, movedColumns, removedColumnNames) {
+    var columnNames = columns.map(_ref12 => {
+      var {
+        name
+      } = _ref12;
+      return name;
+    });
+    var newMoves = [...movedColumns];
+    var _loop = function _loop() {
+      var removedColumnName = removedColumnNames[i];
+      var removedColumnIndex = columnNames.findIndex(name => name === removedColumnName);
+      var moves = [];
+      for (var j = 0; j < newMoves.length; j += 1) {
+        var move = newMoves[j];
+        var newMove = _objectSpread({}, move);
+        var [fromStart, fromEnd] = Array.isArray(move.from) ? move.from : [move.from, move.from];
+        if (removedColumnIndex <= move.to) {
+          newMove.to -= 1;
+        }
+
+        // If equal to fromStart, the new fromStart would stay the same
+        // It's just the next element in the range which will have the same index after deletion
+        if (removedColumnIndex < fromStart) {
+          fromStart -= 1;
+        }
+        if (removedColumnIndex <= fromEnd) {
+          fromEnd -= 1;
+        }
+        if (fromStart <= fromEnd && fromStart !== newMove.to) {
+          if (fromStart === fromEnd) {
+            moves.push(_objectSpread(_objectSpread({}, newMove), {}, {
+              from: fromStart
+            }));
+          } else {
+            moves.push(_objectSpread(_objectSpread({}, newMove), {}, {
+              from: [fromStart, fromEnd]
+            }));
+          }
+        }
+
+        // get the next index of the removed column after the move is applied
+        // eslint-disable-next-line prefer-destructuring
+        removedColumnIndex = GridUtils.applyItemMoves(removedColumnIndex, removedColumnIndex, [move])[0][0];
+      }
+      newMoves = moves;
+      columnNames.splice(columnNames.findIndex(name => name === removedColumnName), 1);
+    };
+    for (var i = 0; i < removedColumnNames.length; i += 1) {
+      _loop();
+    }
+    return newMoves;
+  }
+  static removeColumnsFromSelectDistinctColumns(selectDistinctColumns, removedColumnNames) {
+    return selectDistinctColumns.filter(columnName => !removedColumnNames.includes(columnName));
+  }
+  static getVisibleColumnsInRange(tableColumns, left, right, movedColumns, hiddenColumns) {
+    var columns = [];
+    for (var i = left; i <= right; i += 1) {
+      var modelIndex = GridUtils.getModelIndex(i, movedColumns);
+      if (modelIndex >= 0 && modelIndex < tableColumns.length && !hiddenColumns.includes(modelIndex)) {
+        columns.push(tableColumns[modelIndex]);
+      }
+    }
+    return columns;
+  }
+  static getPrevVisibleColumns(tableColumns, startIndex, count, movedColumns, hiddenColumns) {
+    var columns = [];
+    var i = startIndex;
+    while (i >= 0 && columns.length < count) {
+      var modelIndex = GridUtils.getModelIndex(i, movedColumns);
+      if (modelIndex >= 0 && modelIndex < tableColumns.length && !hiddenColumns.includes(modelIndex)) {
+        columns.unshift(tableColumns[modelIndex]);
+      }
+      i -= 1;
+    }
+    return columns;
+  }
+  static getNextVisibleColumns(tableColumns, startIndex, count, movedColumns, hiddenColumns) {
+    var columns = [];
+    var i = startIndex;
+    while (i < tableColumns.length && columns.length < count) {
+      var modelIndex = GridUtils.getModelIndex(i, movedColumns);
+      if (modelIndex >= 0 && modelIndex < tableColumns.length && !hiddenColumns.includes(modelIndex)) {
+        columns.push(tableColumns[modelIndex]);
+      }
+      i += 1;
+    }
+    return columns;
+  }
+  static getColumnsToFetch(tableColumns, viewportColumns, alwaysFetchColumnNames) {
+    var columnsToFetch = [...viewportColumns];
+    alwaysFetchColumnNames.forEach(columnName => {
+      var column = tableColumns.find(_ref13 => {
+        var {
+          name
+        } = _ref13;
+        return name === columnName;
+      });
+      if (column != null && !viewportColumns.includes(column)) {
+        columnsToFetch.push(column);
+      }
+    });
+    return columnsToFetch;
+  }
+  static getModelViewportColumns(columns, left, right, movedColumns) {
+    var hiddenColumns = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : [];
+    var alwaysFetchColumnNames = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : [];
+    var bufferPages = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : 0;
+    if (left == null || right == null) {
+      return null;
+    }
+    var columnsCenter = IrisGridUtils.getVisibleColumnsInRange(columns, left, right, movedColumns, hiddenColumns);
+    var bufferWidth = columnsCenter.length * bufferPages;
+    var columnsLeft = IrisGridUtils.getPrevVisibleColumns(columns, left - 1, bufferWidth, movedColumns, hiddenColumns);
+    var columnsRight = IrisGridUtils.getNextVisibleColumns(columns, right + 1, bufferWidth, movedColumns, hiddenColumns);
+    var bufferedColumns = [...columnsLeft, ...columnsCenter, ...columnsRight];
+    return IrisGridUtils.getColumnsToFetch(columns, bufferedColumns, alwaysFetchColumnNames);
+  }
+
+  /**
+   * Validate whether the ranges passed in are valid to take a snapshot from.
+   * Multiple selections are valid if all of the selected rows have the same columns selected.
+   *
+   * @param ranges The ranges to validate
+   * @returns True if the ranges are valid, false otherwise
+   */
+  static isValidSnapshotRanges(ranges) {
+    if (ranges == null || ranges.length === 0) {
+      return false;
+    }
+
+    // To verify all the rows selected have the same set of columns selected, build a map with string representations
+    // of each range.
+    var rangeMap = new Map();
+    for (var i = 0; i < ranges.length; i += 1) {
+      var range = ranges[i];
+      var rowMapIndex = "".concat(range.startRow, ":").concat(range.endRow);
+      var columnMapIndex = "".concat(range.startColumn, ":").concat(range.endColumn);
+      if (!rangeMap.has(rowMapIndex)) {
+        rangeMap.set(rowMapIndex, []);
+      }
+      rangeMap.get(rowMapIndex).push(columnMapIndex);
+    }
+    var keys = [...rangeMap.keys()];
+    var matchColumnRanges = rangeMap.get(keys[0]).sort().join(',');
+    for (var _i = 1; _i < keys.length; _i += 1) {
+      if (rangeMap.get(keys[_i]).sort().join(',') !== matchColumnRanges) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * Check if the provided value is a valid table index
+   * @param  value A value to check if it's a valid table index
+   */
+  static isValidIndex(value) {
+    if (!Number.isInteger(value)) {
+      return false;
+    }
+    if (!(typeof value === 'number')) {
+      return false;
+    }
+    return value >= 0;
+  }
+
+  /**
+   * Returns all columns used in any of the ranges provided
+   * @param  ranges The model ranges to get columns for
+   * @param  allColumns All the columns to pull from
+   * @returns The columns selected in the range
+   */
+  static columnsFromRanges(ranges, allColumns) {
+    if (ranges == null || ranges.length === 0) {
+      return [];
+    }
+    if (ranges[0].startColumn === null && ranges[0].endColumn === null) {
+      // Snapshot of all the columns
+      return [...allColumns];
+    }
+    var columnSet = new Set();
+    for (var i = 0; i < ranges.length; i += 1) {
+      var range = ranges[i];
+      assertNotNull(range.startColumn);
+      assertNotNull(range.endColumn);
+      for (var c = (_range$startColumn = range.startColumn) !== null && _range$startColumn !== void 0 ? _range$startColumn : 0; c <= ((_range$endColumn = range.endColumn) !== null && _range$endColumn !== void 0 ? _range$endColumn : allColumns.length - 1); c += 1) {
+        var _range$startColumn, _range$endColumn;
+        columnSet.add(c);
+      }
+    }
+    return [...columnSet].map(c => allColumns[c]);
+  }
+
+  /**
+   * Transforms an iris data snapshot into a simple data matrix
+   * @param  data The Iris formatted table data
+   * @returns A matrix of the values of the data
+   */
+  static snapshotDataToMatrix(data) {
+    var {
+      columns,
+      rows
+    } = data;
+    var result = [];
+    for (var r = 0; r < rows.length; r += 1) {
+      var row = rows[r];
+      var rowData = [];
+      for (var c = 0; c < columns.length; c += 1) {
+        var column = columns[c];
+        var value = row.get(column);
+        rowData.push(value);
+      }
+      result.push(rowData);
+    }
+    return result;
+  }
+
+  /**
+   * Hydrate model rollup config
+   * @param  originalColumns Original model columns
+   * @param  config Dehydrated rollup config
+   * @param  aggregationSettings Aggregation settings
+   * @returns Rollup config for the model
+   */
+  static getModelRollupConfig(originalColumns, config, aggregationSettings) {
+    var _config$columns$lengt, _config$columns;
+    if (((_config$columns$lengt = config === null || config === void 0 ? void 0 : (_config$columns = config.columns) === null || _config$columns === void 0 ? void 0 : _config$columns.length) !== null && _config$columns$lengt !== void 0 ? _config$columns$lengt : 0) === 0) {
+      return null;
+    }
+    var {
+      columns: groupingColumns = [],
+      showConstituents: includeConstituents = true,
+      showNonAggregatedColumns = true,
+      includeDescriptions = true
+    } = config !== null && config !== void 0 ? config : {};
+    var {
+      aggregations = []
+    } = aggregationSettings !== null && aggregationSettings !== void 0 ? aggregationSettings : {};
+    var aggregationColumns = aggregations.map(_ref14 => {
+      var {
+        operation,
+        selected,
+        invert
+      } = _ref14;
+      return AggregationUtils.isRollupOperation(operation) ? [] : AggregationUtils.getOperationColumnNames(originalColumns, operation, selected, invert);
+    });
+    var aggregationMap = {};
+    // Aggregation columns should show first, add them first
+    for (var i = 0; i < aggregations.length; i += 1) {
+      aggregationMap[aggregations[i].operation] = aggregationColumns[i];
+    }
+    if (showNonAggregatedColumns) {
+      // Filter out any column that already has an aggregation or grouping
+      var nonAggregatedColumnSet = new Set(originalColumns.map(c => c.name).filter(name => !groupingColumns.includes(name)));
+      aggregationColumns.forEach(columns => {
+        columns.forEach(name => nonAggregatedColumnSet.delete(name));
+      });
+      if (nonAggregatedColumnSet.size > 0) {
+        var _aggregationMap$Aggre;
+        var existingColumns = (_aggregationMap$Aggre = aggregationMap[AggregationOperation.FIRST]) !== null && _aggregationMap$Aggre !== void 0 ? _aggregationMap$Aggre : [];
+        aggregationMap[AggregationOperation.FIRST] = [...existingColumns, ...nonAggregatedColumnSet];
+      }
+    }
+    return {
+      groupingColumns,
+      includeConstituents,
+      includeDescriptions,
+      aggregations: aggregationMap
+    };
+  }
+
+  /**
+   * @param  pendingDataMap Map of pending data
+   * @returns A map with the errors in the pending data
+   */
+  static getPendingErrors(pendingDataMap) {
+    pendingDataMap.forEach((row, rowIndex) => {
+      if (!IrisGridUtils.isValidIndex(rowIndex)) {
+        throw new Error("Invalid rowIndex ".concat(rowIndex));
+      }
+      var {
+        data
+      } = row;
+      data.forEach((value, columnIndex) => {
+        if (!IrisGridUtils.isValidIndex(columnIndex)) {
+          throw new Error("Invalid columnIndex ".concat(columnIndex));
+        }
+      });
+    });
+  }
+
+  /**
+   * Retrieves a column from the provided array at the index, or `null` and logs an error if it's invalid
+   *
+   * @param  columns The columns to get the column from
+   * @param  columnIndex The column index to get
+   */
+  static getColumn(columns, columnIndex) {
+    if (columnIndex < columns.length) {
+      return columns[columnIndex];
+    }
+    log.error('Unable to retrieve column', columnIndex, '>=', columns.length);
+    return null;
+  }
+
+  /**
+   * Retrieves a column from the provided array matching the name, or `null` and logs an error if not found
+   * @param  columns The columns to get the column from
+   * @param  columnName The column name to retrieve
+   */
+  static getColumnByName(columns, columnName) {
+    var column = columns.find(_ref15 => {
+      var {
+        name
+      } = _ref15;
+      return name === columnName;
+    });
+    if (column == null) {
+      log.error('Unable to retrieve column by name', columnName, columns.map(_ref16 => {
+        var {
+          name
+        } = _ref16;
+        return name;
+      }));
+    }
+    return column;
+  }
+
+  /**
+   * Get filter configs with column names changed to indexes, exclude missing columns
+   * @param  columns The columns to get column indexes from
+   * @param  filters Filter configs
+   * @returns Updated filter configs with column names changed to indexes
+   */
+  static changeFilterColumnNamesToIndexes(columns, filters) {
+    return filters.map(_ref17 => {
+      var {
+        name,
+        filter
+      } = _ref17;
+      var index = columns.findIndex(column => column.name === name);
+      return index < 0 ? null : [index, filter];
+    }).filter(filterConfig => filterConfig != null);
+  }
+
+  /**
+   * @param columnType The column type that the filters will be applied to.
+   * @param filterList The list of filters to be combined.
+   * @returns The combination of the filters in filterList as text.
+   */
+  static combineFiltersFromList(columnType, filterList) {
+    filterList.sort((a, b) => {
+      // move all 'equals' comparisons to end of list
+      if (a.operator === 'eq' && b.operator !== 'eq') {
+        return 1;
+      }
+      if (a.operator !== 'eq' && b.operator === 'eq') {
+        return -1;
+      }
+      return a.startColumnIndex - b.startColumnIndex;
+    });
+    var combinedText = '';
+    for (var i = 0; i < filterList.length; i += 1) {
+      var {
+        text,
+        value,
+        operator
+      } = filterList[i];
+      if (value !== undefined) {
+        var symbol = '';
+        if (operator !== undefined) {
+          if (value == null && operator === 'eq') {
+            symbol = '=';
+          } else if (operator !== 'eq') {
+            if (operator === 'startsWith' || operator === 'endsWith') {
+              symbol = '*';
+            } else {
+              symbol = TableUtils.getFilterOperatorString(operator);
+            }
+          }
+        }
+        var filterText = "".concat(symbol).concat(text);
+        if (operator === 'startsWith') {
+          filterText = "".concat(text).concat(symbol);
+        }
+        if (columnType != null && value !== null && TableUtils.isCharType(columnType)) {
+          filterText = "".concat(symbol).concat(String.fromCharCode(parseInt(text, 10)));
+        }
+        if (i !== 0) {
+          combinedText += operator === 'eq' ? ' || ' : ' && ';
+        }
+        combinedText += filterText;
+      }
+    }
+    return combinedText;
+  }
+
+  /**
+   * Parses the column header groups provided.
+   * If undefined, should provide default groups such as from layoutHints
+   *
+   * @returns Object containing groups array, max depth, map of name to parent group, and map of name to group
+   */
+  static parseColumnHeaderGroups(model, groupsParam) {
+    var maxDepth = 1;
+    var parentMap = new Map();
+    var groupMap = new Map();
+
+    // Remove any empty groups before parsing
+    var groups = groupsParam === null || groupsParam === void 0 ? void 0 : groupsParam.filter(_ref18 => {
+      var {
+        children
+      } = _ref18;
+      return children.length > 0;
+    });
+    if (groups.length === 0) {
+      return {
+        groups: [],
+        maxDepth,
+        parentMap,
+        groupMap
+      };
+    }
+    var originalGroupMap = new Map(groups.map(group => [group.name, group]));
+    var seenChildren = new Set();
+    var addGroup = group => {
+      var {
+        name
+      } = group;
+      if (model.getColumnIndexByName(name) != null) {
+        throw new Error("Column header group has same name as column: ".concat(name));
+      }
+      var existingGroup = groupMap.get(name);
+      if (existingGroup) {
+        return existingGroup;
+      }
+      var childIndexes = [];
+      var depth = 1;
+      group.children.forEach(childName => {
+        if (seenChildren.has(childName)) {
+          throw new Error("Column group child ".concat(childName, " specified in multiple groups"));
+        }
+        seenChildren.add(childName);
+        var childGroup = originalGroupMap.get(childName);
+        var childIndex = model.getColumnIndexByName(childName);
+        if (childGroup) {
+          // Adding another column header group
+          var addedGroup = addGroup(childGroup);
+          childIndexes.push(...addedGroup.childIndexes);
+          depth = Math.max(depth, addedGroup.depth + 1);
+        } else if (childIndex != null) {
+          // Adding a base column
+          childIndexes.push(childIndex);
+          depth = Math.max(depth, 1);
+        } else {
+          throw new Error("Unknown child ".concat(childName, " in group ").concat(name));
+        }
+      });
+      var columnHeaderGroup = new ColumnHeaderGroup(_objectSpread(_objectSpread({}, group), {}, {
+        depth,
+        childIndexes: childIndexes.flat()
+      }));
+      groupMap.set(name, columnHeaderGroup);
+      group.children.forEach(childName => parentMap.set(childName, columnHeaderGroup));
+      maxDepth = Math.max(maxDepth, columnHeaderGroup.depth + 1);
+      return columnHeaderGroup;
+    };
+    var groupNames = new Set();
+    groups.forEach(group => {
+      var {
+        name
+      } = group;
+      if (groupNames.has(name)) {
+        throw new Error("Duplicate column group name: ".concat(name));
+      }
+      groupNames.add(name);
+      addGroup(group);
+    });
+    groupMap.forEach(group => {
+      var _parentMap$get;
+      group.setParent((_parentMap$get = parentMap.get(group.name)) === null || _parentMap$get === void 0 ? void 0 : _parentMap$get.name);
+    });
+    return {
+      groups: [...groupMap.values()],
+      maxDepth,
+      groupMap,
+      parentMap
+    };
+  }
+
+  /**
+   * @param value The value of the cell in a column
+   * @param columnType The type of the column
+   * @returns The value of the cell converted to text
+   */
+  static convertValueToText(value, columnType) {
+    if (columnType != null && TableUtils.isCharType(columnType) && value != null && typeof value === 'number') {
+      return String.fromCharCode(value);
+    }
+    if (TableUtils.isDateType(columnType) && isDateWrapper(value)) {
+      var date = new Date(value.asDate());
+      var offset = date.getTimezoneOffset();
+      var offsetDate = new Date(date.getTime() - offset * 60 * 1000);
+      var dateText = offsetDate.toISOString();
+      var formattedText = dateText.replace('T', ' ').substring(0, 23);
+      return formattedText;
+    }
+    if (value == null) {
+      return '';
+    }
+    return "".concat(value);
+  }
+  constructor(dh) {
+    _defineProperty(this, "dh", void 0);
+    _defineProperty(this, "tableUtils", void 0);
+    this.dh = dh;
+    this.tableUtils = new TableUtils(dh);
+  }
+
+  /**
+   * Exports the state from IrisGrid to a JSON stringifiable object
+   * @param model The table model to export the state for
+   * @param irisGridState The current state of the IrisGrid
+   */
+  dehydrateIrisGridState(model, irisGridState) {
+    var {
+      aggregationSettings = {
+        aggregations: EMPTY_ARRAY,
+        showOnTop: false
+      },
+      advancedFilters,
+      customColumnFormatMap,
+      isFilterBarShown,
+      metrics,
+      quickFilters,
+      customColumns,
+      conditionalFormats = EMPTY_ARRAY,
+      reverseType,
+      rollupConfig = undefined,
+      showSearchBar,
+      searchValue,
+      selectDistinctColumns = EMPTY_ARRAY,
+      selectedSearchColumns,
+      sorts,
+      invertSearchColumns,
+      pendingDataMap = EMPTY_MAP,
+      frozenColumns,
+      columnHeaderGroups
+    } = irisGridState;
+    assertNotNull(metrics);
+    var {
+      userColumnWidths,
+      userRowHeights
+    } = metrics;
+    var {
+      columns
+    } = model;
+    // Return value will be serialized, should not contain undefined
+    return {
+      advancedFilters: this.dehydrateAdvancedFilters(columns, advancedFilters),
+      aggregationSettings,
+      customColumnFormatMap: [...customColumnFormatMap],
+      isFilterBarShown,
+      quickFilters: IrisGridUtils.dehydrateQuickFilters(quickFilters),
+      sorts: IrisGridUtils.dehydrateSort(sorts),
+      userColumnWidths: [...userColumnWidths].filter(_ref19 => {
+        var [columnIndex] = _ref19;
+        return columnIndex != null && columnIndex >= 0 && columnIndex < columns.length;
+      }).map(_ref20 => {
+        var [columnIndex, width] = _ref20;
+        return [columns[columnIndex].name, width];
+      }),
+      userRowHeights: [...userRowHeights],
+      customColumns: [...customColumns],
+      conditionalFormats: [...conditionalFormats],
+      reverseType,
+      rollupConfig,
+      showSearchBar,
+      searchValue,
+      selectDistinctColumns: [...selectDistinctColumns],
+      selectedSearchColumns,
+      invertSearchColumns,
+      pendingDataMap: this.dehydratePendingDataMap(columns, pendingDataMap),
+      frozenColumns,
+      columnHeaderGroups: columnHeaderGroups === null || columnHeaderGroups === void 0 ? void 0 : columnHeaderGroups.map(item => ({
+        name: item.name,
+        children: item.children,
+        color: item.color
+      }))
+    };
+  }
+
+  /**
+   * Import a state for IrisGrid that was exported with {{@link dehydrateIrisGridState}}
+   * @param model The table model to import the state with
+   * @param irisGridState The saved IrisGrid state
+   */
+  hydrateIrisGridState(model, irisGridState) {
+    var _ref24, _model$layoutHints;
+    var {
+      advancedFilters,
+      aggregationSettings = {
+        aggregations: [],
+        showOnTop: false
+      },
+      customColumnFormatMap,
+      isFilterBarShown,
+      quickFilters,
+      sorts,
+      customColumns,
+      conditionalFormats,
+      userColumnWidths,
+      userRowHeights,
+      reverseType,
+      rollupConfig = undefined,
+      showSearchBar,
+      searchValue,
+      selectDistinctColumns,
+      selectedSearchColumns,
+      invertSearchColumns = true,
+      pendingDataMap = [],
+      frozenColumns,
+      columnHeaderGroups
+    } = irisGridState;
+    var {
+      columns,
+      formatter
+    } = model;
+    return {
+      advancedFilters: this.hydrateAdvancedFilters(columns, advancedFilters, formatter.timeZone),
+      aggregationSettings,
+      customColumnFormatMap: new Map(customColumnFormatMap),
+      isFilterBarShown,
+      quickFilters: this.hydrateQuickFilters(columns, quickFilters, formatter.timeZone),
+      sorts: this.hydrateSort(columns, sorts),
+      userColumnWidths: new Map(userColumnWidths.map(_ref21 => {
+        var [column, width] = _ref21;
+        if (typeof column === 'string' || column instanceof String) {
+          return [columns.findIndex(_ref22 => {
+            var {
+              name
+            } = _ref22;
+            return name === column;
+          }), width];
+        }
+        return [column, width];
+      }).filter(_ref23 => {
+        var [column] = _ref23;
+        return column != null && column >= 0 && column < columns.length;
+      })),
+      customColumns,
+      conditionalFormats,
+      userRowHeights: new Map(userRowHeights),
+      reverseType,
+      rollupConfig,
+      showSearchBar,
+      searchValue,
+      selectDistinctColumns,
+      selectedSearchColumns,
+      invertSearchColumns,
+      pendingDataMap: this.hydratePendingDataMap(columns, pendingDataMap),
+      frozenColumns,
+      columnHeaderGroups: IrisGridUtils.parseColumnHeaderGroups(model, (_ref24 = columnHeaderGroups !== null && columnHeaderGroups !== void 0 ? columnHeaderGroups : (_model$layoutHints = model.layoutHints) === null || _model$layoutHints === void 0 ? void 0 : _model$layoutHints.columnGroups) !== null && _ref24 !== void 0 ? _ref24 : []).groups
+    };
+  }
+
+  /**
+   * Import the saved quick filters to apply to the columns. Does not actually apply the filters.
+   * @param  columns The columns the filters will be applied to
+   * @param  savedQuickFilters Exported quick filters definitions
+   * @param  timeZone The time zone to make this value in if it is a date type. E.g. America/New_York
+   * @returns The quick filters to apply to the columns
+   */
+  hydrateQuickFilters(columns, savedQuickFilters, timeZone) {
+    var importedFilters = savedQuickFilters.map(_ref25 => {
+      var [columnIndex, quickFilter] = _ref25;
+      var {
+        text
+      } = quickFilter;
+      var filter = null;
+      try {
+        var column = IrisGridUtils.getColumn(columns, columnIndex);
+        if (column != null) {
+          filter = this.tableUtils.makeQuickFilter(column, text, timeZone);
+        }
+      } catch (error) {
+        log.error('hydrateQuickFilters error with', text, error);
+      }
+      return [columnIndex, {
+        text,
+        filter
+      }];
+    });
+    return new Map(importedFilters);
+  }
+
+  /**
+   * Export the advanced filters from the provided columns to JSON striginfiable object
+   * @param columns The columns for the filters
+   * @param advancedFilters The advanced filters to dehydrate
+   * @returns The dehydrated advanced filters
+   */
+  dehydrateAdvancedFilters(columns, advancedFilters) {
+    return [...advancedFilters].map(_ref26 => {
+      var [columnIndex, advancedFilter] = _ref26;
+      var column = IrisGridUtils.getColumn(columns, columnIndex);
+      assertNotNull(column);
+      var options = this.dehydrateAdvancedFilterOptions(column, advancedFilter.options);
+      return [columnIndex, {
+        options
+      }];
+    });
+  }
+
+  /**
+   * Import the saved advanced filters to apply to the columns. Does not actually apply the filters.
+   * @param  columns The columns the filters will be applied to
+   * @param  savedAdvancedFilters Exported advanced filters definitions
+   * @param  timeZone The time zone to make this filter in if it is a date type. E.g. America/New_York
+   * @returns The advanced filters to apply to the columns
+   */
+  hydrateAdvancedFilters(columns, savedAdvancedFilters, timeZone) {
+    var importedFilters = savedAdvancedFilters.map(_ref27 => {
+      var [columnIndex, advancedFilter] = _ref27;
+      var column = IrisGridUtils.getColumn(columns, columnIndex);
+      assertNotNull(column);
+      var options = this.hydrateAdvancedFilterOptions(column, advancedFilter.options);
+      var filter = null;
+      try {
+        var columnRetrieved = IrisGridUtils.getColumn(columns, columnIndex);
+        if (columnRetrieved != null) {
+          filter = this.tableUtils.makeAdvancedFilter(column, options, timeZone);
+        }
+      } catch (error) {
+        log.error('hydrateAdvancedFilters error with', options, error);
+      }
+      return [columnIndex, {
+        options,
+        filter
+      }];
+    });
+    return new Map(importedFilters);
+  }
+  dehydrateAdvancedFilterOptions(column, options) {
+    var {
+        selectedValues
+      } = options,
+      otherOptions = _objectWithoutProperties(options, _excluded);
+    return _objectSpread({
+      selectedValues: selectedValues === null || selectedValues === void 0 ? void 0 : selectedValues.map(value => this.dehydrateValue(value, column === null || column === void 0 ? void 0 : column.type))
+    }, otherOptions);
+  }
+  hydrateAdvancedFilterOptions(column, options) {
+    var {
+        selectedValues
+      } = options,
+      otherOptions = _objectWithoutProperties(options, _excluded2);
+    return _objectSpread({
+      selectedValues: selectedValues === null || selectedValues === void 0 ? void 0 : selectedValues.map(value => this.hydrateValue(value, column === null || column === void 0 ? void 0 : column.type))
+    }, otherOptions);
+  }
+  dehydratePendingDataMap(columns, pendingDataMap) {
+    return [...pendingDataMap].map(_ref28 => {
+      var [rowIndex, {
+        data
+      }] = _ref28;
+      return [rowIndex, {
+        data: [...data].map(_ref29 => {
+          var [c, value] = _ref29;
+          return [columns[c].name, this.dehydrateValue(value, columns[c].type)];
+        })
+      }];
+    });
+  }
+  hydratePendingDataMap(columns, pendingDataMap) {
+    var columnMap = new Map();
+    var getColumnIndex = columnName => {
+      if (!columnMap.has(columnName)) {
+        columnMap.set(columnName, columns.findIndex(_ref30 => {
+          var {
+            name
+          } = _ref30;
+          return name === columnName;
+        }));
+      }
+      return columnMap.get(columnName);
+    };
+    return new Map(pendingDataMap.map(_ref31 => {
+      var [rowIndex, {
+        data
+      }] = _ref31;
+      return [rowIndex, {
+        data: new Map(data.map(_ref32 => {
+          var _getColumnIndex;
+          var [columnName, value] = _ref32;
+          var index = getColumnIndex(columnName);
+          assertNotNull(index);
+          return [(_getColumnIndex = getColumnIndex(columnName)) !== null && _getColumnIndex !== void 0 ? _getColumnIndex : null, this.hydrateValue(value, columns[index].type)];
+        }))
+      }];
+    }));
+  }
+
+  /**
+   * Dehydrates/serializes a value for storage.
+   * @param  value The value to dehydrate
+   * @param  columnType The column type
+   */
+  dehydrateValue(value, columnType) {
+    if (TableUtils.isDateType(columnType)) {
+      return this.dehydrateDateTime(value);
+    }
+    if (TableUtils.isLongType(columnType)) {
+      return IrisGridUtils.dehydrateLong(value);
+    }
+    return value;
+  }
+
+  /**
+   * Hydrate a value from it's serialized state
+   * @param  value The dehydrated value that needs to be hydrated
+   * @param  columnType The type of column
+   */
+  hydrateValue(value, columnType) {
+    if (TableUtils.isDateType(columnType)) {
+      return this.hydrateDateTime(value);
+    }
+    if (TableUtils.isLongType(columnType)) {
+      return this.hydrateLong(value);
+    }
+    return value;
+  }
+  dehydrateDateTime(value) {
+    return value != null ? this.dh.i18n.DateTimeFormat.format(DateUtils.FULL_DATE_FORMAT, value) : null;
+  }
+  hydrateDateTime(value) {
+    return value != null ? this.dh.i18n.DateTimeFormat.parse(DateUtils.FULL_DATE_FORMAT, value) : null;
+  }
+  hydrateLong(value) {
+    return value != null ? this.dh.LongWrapper.ofString(value) : null;
+  }
+
+  /**
+   * Import the saved sorts to apply to the table. Does not actually apply the sort.
+   * @param  columns The columns the sorts will be applied to
+   * @param  sorts Exported sort definitions
+   * @returns The sorts to apply to the table
+   */
+  hydrateSort(columns, sorts) {
+    var {
+      dh
+    } = this;
+    return sorts.map(sort => {
+      var {
+        column: columnIndexOrName,
+        isAbs,
+        direction
+      } = sort;
+      if (direction === TableUtils.sortDirection.reverse) {
+        return dh.Table.reverse();
+      }
+      var column = typeof columnIndexOrName === 'string' ? IrisGridUtils.getColumnByName(columns, columnIndexOrName) : IrisGridUtils.getColumn(columns, columnIndexOrName);
+      if (column != null) {
+        var columnSort = column.sort();
+        if (isAbs) {
+          columnSort = columnSort.abs();
+        }
+        if (direction === TableUtils.sortDirection.descending) {
+          columnSort = columnSort.desc();
+        } else {
+          columnSort = columnSort.asc();
+        }
+        return columnSort;
+      }
+      return null;
+    })
+    // If we can't find the column any more, it's null, filter it out
+    // If the item is a reverse sort item, filter it out - it will get applied with the `reverseType` property
+    // This should only happen when loading a legacy dashboard
+    .filter(item => item != null && item.direction !== TableUtils.sortDirection.reverse);
+  }
+
+  /**
+   * Applies the passed in table settings directly to the provided table
+   * @param  table The table to apply the settings to
+   * @param  tableSettings Dehydrated table settings extracted with `extractTableSettings`
+   * @param  timeZone The time zone to make this value in if it is a date type. E.g. America/New_York
+   */
+  applyTableSettings(table, tableSettings, timeZone) {
+    var {
+      columns
+    } = table;
+    var quickFilters = [];
+    if (tableSettings.quickFilters) {
+      quickFilters = IrisGridUtils.getFiltersFromFilterMap(this.hydrateQuickFilters(columns, tableSettings.quickFilters, timeZone));
+    }
+    var advancedFilters = [];
+    if (tableSettings.advancedFilters) {
+      advancedFilters = IrisGridUtils.getFiltersFromFilterMap(this.hydrateAdvancedFilters(columns, tableSettings.advancedFilters, timeZone));
+    }
+    var inputFilters = this.getFiltersFromInputFilters(columns, tableSettings.inputFilters, timeZone);
+    var sorts = [];
+    if (tableSettings.sorts) {
+      sorts = this.hydrateSort(columns, tableSettings.sorts);
+    }
+    var filters = [...quickFilters, ...advancedFilters];
+    var {
+      partition,
+      partitionColumn: partitionColumnName
+    } = tableSettings;
+    if (partition != null && partitionColumnName != null) {
+      var partitionColumn = IrisGridUtils.getColumnByName(columns, partitionColumnName);
+      if (partitionColumn) {
+        var partitionFilter = partitionColumn.filter().eq(this.dh.FilterValue.ofString(partition));
+        filters = [partitionFilter, ...filters];
+      }
+    }
+    filters = [...inputFilters, ...filters];
+    table.applyFilter(filters);
+    table.applySort(sorts);
+  }
+  getFiltersFromInputFilters(columns) {
+    var inputFilters = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    var timeZone = arguments.length > 2 ? arguments[2] : undefined;
+    return inputFilters.map(_ref33 => {
+      var {
+        name,
+        type,
+        value
+      } = _ref33;
+      var column = columns.find(_ref34 => {
+        var {
+          name: columnName,
+          type: columnType
+        } = _ref34;
+        return columnName === name && columnType === type;
+      });
+      if (column) {
+        try {
+          return this.tableUtils.makeQuickFilter(column, value, timeZone);
+        } catch (e) {
+          // It may be unable to create it because user hasn't completed their input
+          log.debug('Unable to create input filter', e);
+        }
+      }
+      return null;
+    }).filter(filter => filter != null);
+  }
+
+  /**
+   * Get the dh.RangeSet representation of the provided ranges.
+   * Ranges are sorted prior to creating the RangeSet. Only the rows are taken into account,
+   * RangeSet does not have an option for columns.
+   * @param  ranges The ranges to get the range set for
+   * @returns The rangeset for the provided ranges
+   */
+  rangeSetFromRanges(ranges) {
+    var {
+      dh
+    } = this;
+    var rangeSets = ranges.slice().sort((a, b) => {
+      assertNotNull(a.startRow);
+      assertNotNull(b.startRow);
+      return a.startRow - b.startRow;
+    }).map(range => {
+      var {
+        startRow,
+        endRow
+      } = range;
+      assertNotNull(startRow);
+      assertNotNull(endRow);
+      return dh.RangeSet.ofRange(startRow, endRow);
+    });
+    return dh.RangeSet.ofRanges(rangeSets);
+  }
+}
+export default IrisGridUtils;
+//# sourceMappingURL=IrisGridUtils.js.map