@deephaven/iris-grid 0.13.3-treemap.2 → 0.14.1-beta.6

package/dist/IrisGridTableModelTemplate.js

@@ -0,0 +1,1624 @@
+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 asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+/* eslint class-methods-use-this: "off" */
+import memoize from 'memoize-one';
+import throttle from 'lodash.throttle';
+import { GridRange, memoizeClear } from '@deephaven/grid';
+import dh from '@deephaven/jsapi-shim';
+import Log from '@deephaven/log';
+import { EventShimCustomEvent, PromiseUtils, assertNotNull } from '@deephaven/utils';
+import { TableUtils, Formatter, FormatterUtils } from '@deephaven/jsapi-utils';
+import IrisGridModel from "./IrisGridModel.js";
+import AggregationOperation from "./sidebar/aggregations/AggregationOperation.js";
+import IrisGridUtils from "./IrisGridUtils.js";
+import MissingKeyError from "./MissingKeyError.js";
+var log = Log.module('IrisGridTableModel');
+var SET_VIEWPORT_THROTTLE = 150;
+var APPLY_VIEWPORT_THROTTLE = 0;
+export function isIrisGridTableModelTemplate(model) {
+  return model.table !== undefined;
+}
+/**
+ * Template model for a grid
+ */
+
+class IrisGridTableModelTemplate extends IrisGridModel {
+  export() {
+    throw new Error('Method not implemented.');
+  }
+
+  columnStatistics(column) {
+    throw new Error('Method not implemented.');
+  }
+
+  get customColumns() {
+    return [];
+  }
+
+  set customColumns(customColumns) {
+    throw new Error('Method not implemented.');
+  }
+
+  get formatColumns() {
+    return [];
+  }
+
+  set formatColumns(formatColumns) {
+    throw new Error('Method not implemented.');
+  }
+
+  updateFrozenColumns(columns) {
+    throw new Error('Method not implemented.');
+  }
+
+  get rollupConfig() {
+    throw new Error('Method not implemented.');
+  }
+
+  set rollupConfig(rollupConfig) {
+    throw new Error('Method not implemented.');
+  }
+
+  get selectDistinctColumns() {
+    throw new Error('Method not implemented.');
+  }
+
+  set selectDistinctColumns(names) {
+    throw new Error('Method not implemented.');
+  }
+
+  get columns() {
+    return this.table.columns;
+  }
+
+  /**
+   * @param table Iris data table to be used in the model
+   * @param formatter The formatter to use when getting formats
+   * @param inputTable Iris input table associated with this table
+   */
+  constructor(table) {
+    var _formatter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Formatter();
+
+    var inputTable = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+    super();
+
+    _defineProperty(this, "irisFormatter", void 0);
+
+    _defineProperty(this, "inputTable", void 0);
+
+    _defineProperty(this, "subscription", void 0);
+
+    _defineProperty(this, "table", void 0);
+
+    _defineProperty(this, "viewport", void 0);
+
+    _defineProperty(this, "viewportData", void 0);
+
+    _defineProperty(this, "formattedStringData", void 0);
+
+    _defineProperty(this, "pendingStringData", void 0);
+
+    _defineProperty(this, "isSaveInProgress", void 0);
+
+    _defineProperty(this, "totalsTable", void 0);
+
+    _defineProperty(this, "totalsTablePromise", void 0);
+
+    _defineProperty(this, "totals", void 0);
+
+    _defineProperty(this, "totalsDataMap", void 0);
+
+    _defineProperty(this, "pendingNewDataMap", void 0);
+
+    _defineProperty(this, "pendingNewRowCount", 0);
+
+    _defineProperty(this, "pendingNewDataErrors", void 0);
+
+    _defineProperty(this, "getMemoizedColumnMap", memoize(tableColumns => {
+      var columnMap = new Map();
+      tableColumns.forEach(col => columnMap.set(col.name, col));
+      return columnMap;
+    }));
+
+    _defineProperty(this, "getColumnIndicesByNameMap", memoize(columns => {
+      var indices = new Map();
+      columns.forEach((_ref, i) => {
+        var {
+          name
+        } = _ref;
+        return indices.set(name, i);
+      });
+      return indices;
+    }));
+
+    _defineProperty(this, "setViewport", throttle((top, bottom, columns) => {
+      if (bottom < top) {
+        log.error('Invalid viewport', top, bottom);
+        return;
+      }
+
+      var {
+        viewport
+      } = this;
+
+      if (viewport != null && viewport.top === top && viewport.bottom === bottom && viewport.columns === columns) {
+        log.debug2('Ignoring duplicate viewport', viewport);
+        return;
+      }
+
+      this.viewport = {
+        top,
+        bottom,
+        columns
+      };
+      log.debug2('setViewport', this.viewport);
+      this.applyViewport();
+    }, SET_VIEWPORT_THROTTLE));
+
+    _defineProperty(this, "applyViewport", throttle(() => {
+      if (!this.viewport) {
+        return;
+      }
+
+      log.debug2('applyViewport', this.viewport);
+      var {
+        top,
+        bottom,
+        columns
+      } = this.viewport;
+      var [viewportTop, viewportBottom] = this.getCachedViewportRowRange(top, bottom);
+      this.applyBufferedViewport(viewportTop, viewportBottom, columns);
+    }, APPLY_VIEWPORT_THROTTLE, {
+      leading: false
+    }));
+
+    _defineProperty(this, "getCachedFormattedString", memoizeClear((formatter, value, columnType, columnName, formatOverride) => formatter.getFormattedString(value, columnType, columnName, formatOverride), {
+      max: 10000
+    }));
+
+    _defineProperty(this, "getCachedCustomColumnFormatFlag", memoizeClear(FormatterUtils.isCustomColumnFormatDefined, {
+      max: 10000
+    }));
+
+    _defineProperty(this, "getCachedViewportRowRange", memoize((top, bottom) => {
+      var viewHeight = bottom - top;
+      var viewportTop = Math.max(0, top - viewHeight * IrisGridTableModelTemplate.ROW_BUFFER_PAGES);
+      var viewportBottom = bottom + viewHeight * IrisGridTableModelTemplate.ROW_BUFFER_PAGES;
+      return [viewportTop, viewportBottom];
+    }));
+
+    _defineProperty(this, "getCachedPendingErrors", memoize((pendingDataMap, columns, keyColumnCount) => {
+      var map = new Map();
+      pendingDataMap.forEach((row, rowIndex) => {
+        var {
+          data: rowData
+        } = row;
+
+        for (var i = 0; i < keyColumnCount; i += 1) {
+          if (!rowData.has(i)) {
+            var _map$get;
+
+            if (!map.has(rowIndex)) {
+              map.set(rowIndex, []);
+            }
+
+            (_map$get = map.get(rowIndex)) === null || _map$get === void 0 ? void 0 : _map$get.push(new MissingKeyError(rowIndex, columns[i].name));
+          }
+        }
+      });
+      return map;
+    }));
+
+    this.handleTableDisconnect = this.handleTableDisconnect.bind(this);
+    this.handleTableReconnect = this.handleTableReconnect.bind(this);
+    this.handleTableUpdate = this.handleTableUpdate.bind(this);
+    this.handleTotalsUpdate = this.handleTotalsUpdate.bind(this);
+    this.handleRequestFailed = this.handleRequestFailed.bind(this);
+    this.handleCustomColumnsChanged = this.handleCustomColumnsChanged.bind(this);
+    this.irisFormatter = _formatter;
+    this.inputTable = inputTable;
+    this.subscription = null;
+    this.table = table;
+    this.viewport = null;
+    this.viewportData = null;
+    this.formattedStringData = [];
+    this.pendingStringData = [];
+    this.isSaveInProgress = false;
+    this.totalsTable = null;
+    this.totalsTablePromise = null;
+    this.totals = null;
+    this.totalsDataMap = null; // Map from new row index to their values. Only for input tables that can have new rows added.
+    // The index of these rows start at 0, and they are appended at the end of the regular table data.
+    // These rows can be sparse, so using a map instead of an array.
+
+    this.pendingNewDataMap = new Map();
+    this.pendingNewDataErrors = null;
+    this.pendingNewRowCount = 0;
+  }
+
+  close() {
+    this.table.close();
+
+    if (this.totalsTable !== null) {
+      this.totalsTable.close();
+    }
+
+    if (this.totalsTablePromise !== null) {
+      this.totalsTablePromise.cancel();
+    }
+  }
+
+  startListening() {
+    super.startListening();
+    this.table.addEventListener(dh.Table.EVENT_DISCONNECT, this.handleTableDisconnect);
+    this.table.addEventListener(dh.Table.EVENT_RECONNECT, this.handleTableReconnect);
+    this.table.addEventListener(dh.Table.EVENT_UPDATED, this.handleTableUpdate);
+    this.table.addEventListener(dh.Client.EVENT_REQUEST_FAILED, this.handleRequestFailed);
+    this.table.addEventListener(dh.Table.EVENT_CUSTOMCOLUMNSCHANGED, this.handleCustomColumnsChanged);
+
+    if (this.totalsTable != null) {
+      this.addTotalsListeners(this.totalsTable);
+    }
+
+    this.applyViewport();
+  }
+
+  stopListening() {
+    super.stopListening();
+    this.table.removeEventListener(dh.Table.EVENT_DISCONNECT, this.handleTableDisconnect);
+    this.table.removeEventListener(dh.Table.EVENT_RECONNECT, this.handleTableReconnect);
+    this.table.removeEventListener(dh.Table.EVENT_UPDATED, this.handleTableUpdate);
+    this.table.removeEventListener(dh.Client.EVENT_REQUEST_FAILED, this.handleRequestFailed);
+    this.table.removeEventListener(dh.Table.EVENT_CUSTOMCOLUMNSCHANGED, this.handleCustomColumnsChanged);
+
+    if (this.totalsTable != null) {
+      this.removeTotalsListeners(this.totalsTable);
+    }
+
+    this.closeSubscription();
+  }
+
+  addTotalsListeners(totalsTable) {
+    totalsTable.addEventListener(dh.Table.EVENT_UPDATED, this.handleTotalsUpdate); // Totals table only has one row of data
+
+    totalsTable.setViewport(0, 0);
+  }
+
+  removeTotalsListeners(totalsTable) {
+    totalsTable.removeEventListener(dh.Table.EVENT_UPDATED, this.handleTotalsUpdate);
+  }
+
+  handleTableDisconnect() {
+    this.dispatchEvent(new EventShimCustomEvent(IrisGridModel.EVENT.DISCONNECT));
+  }
+
+  handleTableReconnect() {
+    this.dispatchEvent(new EventShimCustomEvent(IrisGridModel.EVENT.RECONNECT));
+  }
+
+  handleTableUpdate(event) {
+    this.copyViewportData(event.detail);
+    this.dispatchEvent(new EventShimCustomEvent(IrisGridModel.EVENT.UPDATED));
+  }
+
+  handleTotalsUpdate(event) {
+    this.copyTotalsData(event.detail);
+    this.dispatchEvent(new EventShimCustomEvent(IrisGridModel.EVENT.UPDATED));
+  }
+
+  handleRequestFailed(event) {
+    this.dispatchEvent(new EventShimCustomEvent(IrisGridModel.EVENT.REQUEST_FAILED, event));
+  }
+
+  handleCustomColumnsChanged() {
+    this.dispatchEvent(new EventShimCustomEvent(IrisGridModel.EVENT.COLUMNS_CHANGED, {
+      detail: this.columns
+    }));
+  }
+
+  get rowCount() {
+    var _this$totals$operatio, _this$totals, _this$totals$operatio2;
+
+    return this.table.size + this.pendingNewRowCount + ((_this$totals$operatio = (_this$totals = this.totals) === null || _this$totals === void 0 ? void 0 : (_this$totals$operatio2 = _this$totals.operationOrder) === null || _this$totals$operatio2 === void 0 ? void 0 : _this$totals$operatio2.length) !== null && _this$totals$operatio !== void 0 ? _this$totals$operatio : 0);
+  }
+
+  get pendingDataErrors() {
+    var _this$inputTable$keyC, _this$inputTable;
+
+    return this.getCachedPendingErrors(this.pendingNewDataMap, this.columns, (_this$inputTable$keyC = (_this$inputTable = this.inputTable) === null || _this$inputTable === void 0 ? void 0 : _this$inputTable.keyColumns.length) !== null && _this$inputTable$keyC !== void 0 ? _this$inputTable$keyC : 0);
+  }
+
+  get pendingDataMap() {
+    return this.pendingNewDataMap;
+  }
+
+  set pendingDataMap(map) {
+    if (map === this.pendingNewDataMap) {
+      return;
+    }
+
+    map.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));
+        }
+      });
+    });
+    this.pendingNewDataMap = map;
+    this.pendingNewRowCount = Math.max(this.pendingNewRowCount, this.maxPendingDataRow);
+    this.formattedStringData = [];
+    this.dispatchEvent(new EventShimCustomEvent(IrisGridModel.EVENT.PENDING_DATA_UPDATED));
+  }
+
+  get pendingRowCount() {
+    return this.pendingNewRowCount;
+  }
+
+  set pendingRowCount(count) {
+    if (count === this.pendingNewRowCount) {
+      return;
+    }
+
+    this.pendingNewRowCount = Math.max(0, count, this.maxPendingDataRow);
+    this.dispatchEvent(new EventShimCustomEvent(IrisGridModel.EVENT.UPDATED));
+  }
+
+  get maxPendingDataRow() {
+    return this.pendingNewDataMap.size > 0 ? Math.max(...this.pendingNewDataMap.keys()) + 1 : 0;
+  }
+
+  get columnCount() {
+    return this.columns.length;
+  }
+
+  get floatingBottomRowCount() {
+    var _this$totals2, _this$totals$operatio3, _this$totals3, _this$totals3$operati;
+
+    return (_this$totals2 = this.totals) !== null && _this$totals2 !== void 0 && _this$totals2.showOnTop ? 0 : (_this$totals$operatio3 = (_this$totals3 = this.totals) === null || _this$totals3 === void 0 ? void 0 : (_this$totals3$operati = _this$totals3.operationOrder) === null || _this$totals3$operati === void 0 ? void 0 : _this$totals3$operati.length) !== null && _this$totals$operatio3 !== void 0 ? _this$totals$operatio3 : 0;
+  }
+
+  get floatingTopRowCount() {
+    var _this$totals4, _this$totals$operatio4, _this$totals5, _this$totals5$operati;
+
+    return (_this$totals4 = this.totals) !== null && _this$totals4 !== void 0 && _this$totals4.showOnTop ? (_this$totals$operatio4 = (_this$totals5 = this.totals) === null || _this$totals5 === void 0 ? void 0 : (_this$totals5$operati = _this$totals5.operationOrder) === null || _this$totals5$operati === void 0 ? void 0 : _this$totals5$operati.length) !== null && _this$totals$operatio4 !== void 0 ? _this$totals$operatio4 : 0 : 0;
+  }
+
+  get isChartBuilderAvailable() {
+    return true;
+  }
+
+  get isTotalsAvailable() {
+    return this.table.getTotalsTable != null;
+  }
+
+  get isEditable() {
+    return !this.isSaveInProgress && this.inputTable != null;
+  }
+
+  cacheFormattedValue(x, y, text) {
+    if (this.formattedStringData[x] == null) {
+      this.formattedStringData[x] = [];
+    }
+
+    this.formattedStringData[x][y] = text;
+  }
+
+  cachePendingValue(x, y, text) {
+    if (this.pendingStringData[x] == null) {
+      this.pendingStringData[x] = [];
+    }
+
+    this.pendingStringData[x][y] = text;
+  }
+
+  clearPendingValue(x, y) {
+    var column = this.pendingStringData[x];
+
+    if (column != null) {
+      delete column[y];
+    }
+  }
+
+  textValueForCell(x, y) {
+    var _this$pendingStringDa, _this$formattedString;
+
+    // First check if there's any pending values we should read from
+    if (((_this$pendingStringDa = this.pendingStringData[x]) === null || _this$pendingStringDa === void 0 ? void 0 : _this$pendingStringDa[y]) !== undefined) {
+      return this.pendingStringData[x][y];
+    } // Use a separate cache from memoization just for the strings that are currently displayed
+
+
+    if (((_this$formattedString = this.formattedStringData[x]) === null || _this$formattedString === void 0 ? void 0 : _this$formattedString[y]) === undefined) {
+      var _this$totalsColumn;
+
+      var _value = this.valueForCell(x, y);
+
+      if (_value == null) {
+        return null;
+      }
+
+      var _column = (_this$totalsColumn = this.totalsColumn(x, y)) !== null && _this$totalsColumn !== void 0 ? _this$totalsColumn : this.columns[x];
+
+      var hasCustomColumnFormat = this.getCachedCustomColumnFormatFlag(this.formatter, _column.name, _column.type);
+      var formatOverride;
+
+      if (!hasCustomColumnFormat) {
+        var formatForCell = this.formatForCell(x, y);
+
+        if ((formatForCell === null || formatForCell === void 0 ? void 0 : formatForCell.formatString) != null) {
+          formatOverride = formatForCell;
+        }
+      }
+
+      var text = this.displayString(_value, _column.type, _column.name, formatOverride);
+      this.cacheFormattedValue(x, y, text);
+    }
+
+    return this.formattedStringData[x][y];
+  }
+
+  textForCell(x, y) {
+    var text = this.textValueForCell(x, y);
+
+    if (text == null && this.isKeyColumn(x)) {
+      var pendingRow = this.pendingRow(y);
+
+      if (pendingRow != null && this.pendingDataMap.has(pendingRow)) {
+        // Asterisk to show a value is required for a key column on a row that has some data entered
+        return '*';
+      }
+    }
+
+    return text !== null && text !== void 0 ? text : '';
+  }
+
+  truncationCharForCell(x) {
+    var column = this.columns[x];
+    var {
+      type
+    } = column;
+
+    if (TableUtils.isNumberType(type) && this.formatter.truncateNumbersWithPound) {
+      return '#';
+    }
+
+    return undefined;
+  }
+
+  colorForCell(x, y, theme) {
+    var data = this.dataForCell(x, y);
+
+    if (data) {
+      var {
+        format,
+        value: _value2
+      } = data;
+
+      if (_value2 == null || _value2 === '') {
+        assertNotNull(theme.nullStringColor);
+        return theme.nullStringColor;
+      }
+
+      if (format && format.color) {
+        return format.color;
+      }
+
+      if (this.isPendingRow(y)) {
+        // Data entered in a pending row
+        assertNotNull(theme.pendingTextColor);
+        return theme.pendingTextColor;
+      } // Fallback to formatting based on the value/type of the cell
+
+
+      if (_value2 != null) {
+        var _this$totalsColumn2;
+
+        var _column2 = (_this$totalsColumn2 = this.totalsColumn(x, y)) !== null && _this$totalsColumn2 !== void 0 ? _this$totalsColumn2 : this.columns[x];
+
+        if (TableUtils.isDateType(_column2.type) || _column2.name === 'Date') {
+          assertNotNull(theme.dateColor);
+          return theme.dateColor;
+        }
+
+        if (TableUtils.isNumberType(_column2.type)) {
+          if (_value2 > 0) {
+            assertNotNull(theme.positiveNumberColor);
+            return theme.positiveNumberColor;
+          }
+
+          if (_value2 < 0) {
+            assertNotNull(theme.negativeNumberColor);
+            return theme.negativeNumberColor;
+          }
+
+          assertNotNull(theme.zeroNumberColor);
+          return theme.zeroNumberColor;
+        }
+      }
+    } else if (this.isPendingRow(y) && this.isKeyColumn(x)) {
+      assertNotNull(theme.errorTextColor);
+      return theme.errorTextColor;
+    }
+
+    return theme.textColor;
+  }
+
+  backgroundColorForCell(x, y) {
+    var _this$formatForCell$b, _this$formatForCell;
+
+    return (_this$formatForCell$b = (_this$formatForCell = this.formatForCell(x, y)) === null || _this$formatForCell === void 0 ? void 0 : _this$formatForCell.backgroundColor) !== null && _this$formatForCell$b !== void 0 ? _this$formatForCell$b : null;
+  }
+
+  textAlignForCell(x) {
+    var column = this.columns[x];
+    var {
+      type
+    } = column;
+
+    if (TableUtils.isNumberType(type)) {
+      return 'right';
+    }
+
+    if (TableUtils.isDateType(type) || column.name === 'Date') {
+      return 'center';
+    }
+
+    return 'left';
+  }
+
+  textForColumnHeader(x) {
+    var column = this.columns[x];
+    return "".concat(column.name);
+  }
+
+  textForRowFooter(y) {
+    var totalsRow = this.totalsRow(y);
+
+    if (totalsRow != null && this.totals) {
+      return this.totals.operationOrder[totalsRow];
+    }
+
+    return '';
+  }
+
+  get columnMap() {
+    return this.getMemoizedColumnMap(this.table.columns);
+  }
+
+  get groupedColumns() {
+    return [];
+  }
+
+  row(y) {
+    var _this$totals$operatio5, _this$totals6, _this$totals6$operati, _this$totals$showOnTo, _this$totals7, _this$viewportData$of, _this$viewportData, _this$viewportData$ro, _this$viewportData2, _this$viewportData2$r;
+
+    var totalsRowCount = (_this$totals$operatio5 = (_this$totals6 = this.totals) === null || _this$totals6 === void 0 ? void 0 : (_this$totals6$operati = _this$totals6.operationOrder) === null || _this$totals6$operati === void 0 ? void 0 : _this$totals6$operati.length) !== null && _this$totals$operatio5 !== void 0 ? _this$totals$operatio5 : 0;
+    var showOnTop = (_this$totals$showOnTo = (_this$totals7 = this.totals) === null || _this$totals7 === void 0 ? void 0 : _this$totals7.showOnTop) !== null && _this$totals$showOnTo !== void 0 ? _this$totals$showOnTo : false;
+    var totalsRow = this.totalsRow(y);
+
+    if (totalsRow != null) {
+      var _this$totals8, _this$totalsDataMap$g, _this$totalsDataMap;
+
+      var operation = (_this$totals8 = this.totals) === null || _this$totals8 === void 0 ? void 0 : _this$totals8.operationOrder[totalsRow];
+      assertNotNull(operation);
+      return (_this$totalsDataMap$g = (_this$totalsDataMap = this.totalsDataMap) === null || _this$totalsDataMap === void 0 ? void 0 : _this$totalsDataMap.get(operation)) !== null && _this$totalsDataMap$g !== void 0 ? _this$totalsDataMap$g : null;
+    }
+
+    var pendingRow = this.pendingRow(y);
+
+    if (pendingRow != null) {
+      var _this$pendingNewDataM;
+
+      return (_this$pendingNewDataM = this.pendingNewDataMap.get(pendingRow)) !== null && _this$pendingNewDataM !== void 0 ? _this$pendingNewDataM : null;
+    }
+
+    var offset = (_this$viewportData$of = (_this$viewportData = this.viewportData) === null || _this$viewportData === void 0 ? void 0 : _this$viewportData.offset) !== null && _this$viewportData$of !== void 0 ? _this$viewportData$of : 0;
+    var viewportY = (showOnTop ? y - totalsRowCount : y) - offset;
+    return (_this$viewportData$ro = (_this$viewportData2 = this.viewportData) === null || _this$viewportData2 === void 0 ? void 0 : (_this$viewportData2$r = _this$viewportData2.rows) === null || _this$viewportData2$r === void 0 ? void 0 : _this$viewportData2$r[viewportY]) !== null && _this$viewportData$ro !== void 0 ? _this$viewportData$ro : null;
+  }
+  /**
+   * Retrieve the totals column if this is a totals row, or null otherwise
+   * @param x Column index to get the totals column from
+   * @param y Row index to get the totals column from
+   */
+
+
+  totalsColumn(x, y) {
+    var _this$totals9, _this$totals$defaultO, _this$totals10, _this$totalsTable;
+
+    var totalsRow = this.totalsRow(y);
+    if (totalsRow == null) return null;
+    var operation = (_this$totals9 = this.totals) === null || _this$totals9 === void 0 ? void 0 : _this$totals9.operationOrder[totalsRow];
+    var defaultOperation = (_this$totals$defaultO = (_this$totals10 = this.totals) === null || _this$totals10 === void 0 ? void 0 : _this$totals10.defaultOperation) !== null && _this$totals$defaultO !== void 0 ? _this$totals$defaultO : AggregationOperation.SUM;
+    var tableColumn = this.columns[x]; // Find the matching totals table column for the operation
+    // When there are multiple aggregations, the column name will be the original name of the column with the operation appended afterward
+    // When the the operation is the default operation OR there is only one operation, then the totals column name is just the original column name
+
+    return (_this$totalsTable = this.totalsTable) === null || _this$totalsTable === void 0 ? void 0 : _this$totalsTable.columns.find(column => {
+      var _this$totals11;
+
+      return column.name === "".concat(tableColumn.name, "__").concat(operation) || (operation === defaultOperation || ((_this$totals11 = this.totals) === null || _this$totals11 === void 0 ? void 0 : _this$totals11.operationOrder.length) === 1) && column.name === tableColumn.name;
+    });
+  }
+  /**
+   * Translate from the row in the model to a row in the totals table.
+   * If the row is not a totals row, return null
+   * @param y The row in the model to get the totals row for
+   * @returns The row within the totals table if it's a totals row, null otherwise
+   */
+
+
+  totalsRow(y) {
+    var _this$totals$operatio6, _this$totals12, _this$totals12$operat, _this$totals$showOnTo2, _this$totals13;
+
+    var totalsRowCount = (_this$totals$operatio6 = (_this$totals12 = this.totals) === null || _this$totals12 === void 0 ? void 0 : (_this$totals12$operat = _this$totals12.operationOrder) === null || _this$totals12$operat === void 0 ? void 0 : _this$totals12$operat.length) !== null && _this$totals$operatio6 !== void 0 ? _this$totals$operatio6 : 0;
+    var showOnTop = (_this$totals$showOnTo2 = (_this$totals13 = this.totals) === null || _this$totals13 === void 0 ? void 0 : _this$totals13.showOnTop) !== null && _this$totals$showOnTo2 !== void 0 ? _this$totals$showOnTo2 : false;
+    var totalsRow = showOnTop ? y : y - this.table.size;
+
+    if (totalsRow >= 0 && totalsRow < totalsRowCount) {
+      return totalsRow;
+    }
+
+    return null;
+  }
+  /**
+   * Translate from the row in the model to a pending input row.
+   * If the row is not a pending input row, return null
+   * @param y The row in the model to get the pending row for
+   * @returns The row within the pending input rows if it's a pending row, null otherwise
+   */
+
+
+  pendingRow(y) {
+    var pendingRow = y - this.floatingTopRowCount - this.table.size;
+
+    if (pendingRow >= 0 && pendingRow < this.pendingNewRowCount) {
+      return pendingRow;
+    }
+
+    return null;
+  }
+  /**
+   * Check if a row is a totals table row
+   * @param y The row in the model to check if it's a totals table row
+   * @returns True if the row is a totals row, false if not
+   */
+
+
+  isTotalsRow(y) {
+    return this.totalsRow(y) != null;
+  }
+  /**
+   * Check if a row is a pending input row
+   * @param y The row in the model to check if it's a pending new row
+   * @returns True if the row is a pending new row, false if not
+   */
+
+
+  isPendingRow(y) {
+    return this.pendingRow(y) != null;
+  }
+
+  dataForCell(x, y) {
+    var _this$row;
+
+    return (_this$row = this.row(y)) === null || _this$row === void 0 ? void 0 : _this$row.data.get(x);
+  }
+
+  formatForCell(x, y) {
+    var _this$dataForCell;
+
+    return (_this$dataForCell = this.dataForCell(x, y)) === null || _this$dataForCell === void 0 ? void 0 : _this$dataForCell.format;
+  }
+
+  valueForCell(x, y) {
+    var data = this.dataForCell(x, y);
+    /* JS API current sets null values as undefined in some instances. This means 
+    we need to nullish coaelesce so all undefined values from the API return null 
+    since the data has been fetched. undefined is used to indicate the API has not 
+    fetched data yet */
+
+    if (data) {
+      var _data$value;
+
+      return (_data$value = data.value) !== null && _data$value !== void 0 ? _data$value : null;
+    }
+
+    return undefined;
+  }
+
+  copyViewportData(data) {
+    if (!data) {
+      log.warn('invalid data!');
+      return;
+    }
+
+    this.viewportData = this.extractViewportData(data);
+    this.formattedStringData = [];
+  }
+
+  copyTotalsData(totalsData) {
+    var _this$totals$defaultO2,
+        _this$totals14,
+        _this$totals15,
+        _this = this;
+
+    if (!totalsData) {
+      log.warn('invalid data!');
+      return;
+    }
+
+    var {
+      columns,
+      rows
+    } = totalsData;
+
+    if (rows.length !== 1) {
+      log.error('Unexpected number of rows received for totals table, ignoring update');
+      return;
+    }
+
+    var dataMap = new Map();
+    var row = rows[0];
+    var defaultOperation = (_this$totals$defaultO2 = (_this$totals14 = this.totals) === null || _this$totals14 === void 0 ? void 0 : _this$totals14.defaultOperation) !== null && _this$totals$defaultO2 !== void 0 ? _this$totals$defaultO2 : AggregationOperation.SUM;
+    var operationMap = (_this$totals15 = this.totals) === null || _this$totals15 === void 0 ? void 0 : _this$totals15.operationMap;
+
+    var _loop = function _loop(c) {
+      var _operationMap$name$, _operationMap$name;
+
+      var column = columns[c];
+      var [name, operation = (_operationMap$name$ = operationMap === null || operationMap === void 0 ? void 0 : (_operationMap$name = operationMap[name]) === null || _operationMap$name === void 0 ? void 0 : _operationMap$name[0]) !== null && _operationMap$name$ !== void 0 ? _operationMap$name$ : defaultOperation] = column.name.split('__');
+
+      if (!dataMap.has(operation)) {
+        dataMap.set(operation, {
+          data: new Map()
+        });
+      }
+
+      var {
+        data: rowData
+      } = dataMap.get(operation);
+
+      var columnIndex = _this.columns.findIndex(col => col.name === name);
+
+      rowData.set(columnIndex, {
+        value: row.get(column),
+        format: row.getFormat(column)
+      });
+    };
+
+    for (var c = 0; c < columns.length; c += 1) {
+      _loop(c);
+    }
+
+    log.debug2('copyTotalsData', dataMap);
+    this.totalsDataMap = dataMap;
+    this.formattedStringData = [];
+  }
+  /**
+   * Use this as the canonical column index since things like layoutHints could have
+   * changed the column order.
+   */
+
+
+  getColumnIndexByName(name) {
+    return this.getColumnIndicesByNameMap(this.columns).get(name);
+  }
+
+  /**
+   * Copies all the viewport data into an object that we can reference later.
+   * @param data The data to copy from
+   */
+  extractViewportData(data) {
+    var newData = {
+      offset: data.offset,
+      rows: []
+    };
+    var {
+      columns
+    } = data;
+
+    for (var r = 0; r < data.rows.length; r += 1) {
+      var _row = data.rows[r];
+      var newRow = this.extractViewportRow(_row, columns);
+      newData.rows.push(newRow);
+    }
+
+    return newData;
+  }
+
+  extractViewportRow(row, columns) {
+    var data = new Map();
+
+    for (var c = 0; c < columns.length; c += 1) {
+      var _column3 = columns[c];
+      var index = this.getColumnIndexByName(_column3.name);
+      assertNotNull(index);
+      data.set(index, {
+        value: row.get(_column3),
+        format: row.getFormat(_column3)
+      });
+    }
+
+    return {
+      data
+    };
+  }
+
+  closeSubscription() {
+    log.debug2('closeSubscription', this.subscription);
+
+    if (this.subscription) {
+      this.subscription.close();
+      this.subscription = null;
+    }
+
+    this.setViewport.cancel();
+    this.applyViewport.cancel();
+  }
+
+  get filter() {
+    return this.table.filter;
+  }
+
+  set filter(filter) {
+    this.closeSubscription();
+    this.table.applyFilter(filter);
+    this.applyViewport();
+  }
+
+  get formatter() {
+    return this.irisFormatter;
+  }
+
+  set formatter(formatter) {
+    this.irisFormatter = formatter;
+    this.formattedStringData = [];
+    this.dispatchEvent(new EventShimCustomEvent(IrisGridModel.EVENT.FORMATTER_UPDATED));
+  }
+
+  displayString(value, columnType) {
+    var columnName = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+    var formatOverride = arguments.length > 3 ? arguments[3] : undefined;
+    return this.getCachedFormattedString(this.formatter, value, columnType, columnName, formatOverride);
+  }
+
+  get sort() {
+    return this.table.sort;
+  }
+
+  set sort(sort) {
+    this.closeSubscription();
+    this.table.applySort(sort);
+    this.applyViewport();
+  }
+
+  set totalsConfig(totalsConfig) {
+    log.debug('set totalsConfig', totalsConfig);
+
+    if (totalsConfig === this.totals) {
+      // Totals already set, or it will be set when the next model actually gets set
+      return;
+    }
+
+    this.totals = totalsConfig;
+    this.formattedStringData = [];
+
+    if (this.totalsTablePromise != null) {
+      this.totalsTablePromise.cancel();
+    }
+
+    this.setTotalsTable(null);
+
+    if (totalsConfig == null) {
+      this.dispatchEvent(new EventShimCustomEvent(IrisGridModel.EVENT.UPDATED));
+      return;
+    }
+
+    this.totalsTablePromise = PromiseUtils.makeCancelable(this.table.getTotalsTable(totalsConfig), table => table.close());
+    this.totalsTablePromise.then(totalsTable => {
+      this.totalsTablePromise = null;
+      this.setTotalsTable(totalsTable);
+    }).catch(err => {
+      if (PromiseUtils.isCanceled(err)) {
+        return;
+      }
+
+      log.error('Unable to set next totalsTable', err);
+      this.totalsTablePromise = null;
+      this.dispatchEvent(new EventShimCustomEvent(IrisGridModel.EVENT.REQUEST_FAILED, {
+        detail: err
+      }));
+    });
+  }
+
+  setTotalsTable(totalsTable) {
+    log.debug('setTotalsTable', totalsTable);
+
+    if (this.totalsTable !== null) {
+      if (this.listenerCount > 0) {
+        this.removeTotalsListeners(this.totalsTable);
+      }
+
+      this.totalsTable.close();
+    }
+
+    this.totalsTable = totalsTable;
+    this.totalsDataMap = null;
+
+    if (this.listenerCount > 0 && this.totalsTable != null) {
+      this.addTotalsListeners(this.totalsTable);
+    }
+  }
+
+  applyBufferedViewport(viewportTop, viewportBottom, columns) {
+    log.debug2('applyBufferedViewport', viewportTop, viewportBottom, columns);
+
+    if (this.subscription == null) {
+      log.debug2('applyBufferedViewport creating new subscription');
+      this.subscription = this.table.setViewport(viewportTop, viewportBottom, columns);
+    } else {
+      log.debug2('applyBufferedViewport using existing subscription');
+      this.subscription.setViewport(viewportTop, viewportBottom, columns);
+    }
+  }
+
+  snapshot(ranges) {
+    var _arguments = arguments,
+        _this2 = this;
+
+    return _asyncToGenerator(function* () {
+      var includeHeaders = _arguments.length > 1 && _arguments[1] !== undefined ? _arguments[1] : false;
+      var formatValue = _arguments.length > 2 && _arguments[2] !== undefined ? _arguments[2] : value => value;
+
+      if (_this2.subscription == null) {
+        throw new Error('No subscription available');
+      }
+
+      var consolidated = GridRange.consolidate(ranges);
+
+      if (!IrisGridUtils.isValidSnapshotRanges(consolidated)) {
+        throw new Error("Invalid snapshot ranges ".concat(ranges));
+      } // Need to separate out the floating ranges as they're from a different source
+
+
+      var topFloatingRowsSet = new Set();
+      var tableRanges = [];
+      var bottomFloatingRowsSet = new Set();
+
+      for (var i = 0; i < consolidated.length; i += 1) {
+        var range = consolidated[i];
+        assertNotNull(range.endRow);
+        assertNotNull(range.startRow); // Get the rows that are in the top aggregations section
+
+        for (var r = range.startRow; r <= range.endRow && r < _this2.floatingTopRowCount; r += 1) {
+          topFloatingRowsSet.add(r);
+        } // Separate out the range that is part of the actual table (ie. not the floating ranges, not aggregations)
+
+
+        if (range.endRow >= _this2.floatingTopRowCount && range.startRow <= _this2.floatingTopRowCount + _this2.table.size) {
+          tableRanges.push(new GridRange(range.startColumn, Math.min(Math.max(0, range.startRow - _this2.floatingTopRowCount)), range.endColumn, Math.min(Math.max(0, range.endRow - _this2.floatingTopRowCount), _this2.table.size - _this2.floatingTopRowCount)));
+        } // Get the rows that are in the bottom aggregations section
+
+
+        for (var _r = Math.max(range.startRow, _this2.floatingTopRowCount + _this2.table.size); _r <= range.endRow && _r < _this2.floatingTopRowCount + _this2.table.size + _this2.floatingBottomRowCount; _r += 1) {
+          bottomFloatingRowsSet.add(_r);
+        }
+      }
+
+      var columns = IrisGridUtils.columnsFromRanges(consolidated, _this2.columns);
+      var result = [];
+
+      if (includeHeaders) {
+        result.push(columns.map(c => c.name));
+      }
+
+      var topFloatingRows = [...topFloatingRowsSet].sort();
+
+      var _loop2 = function _loop2(_i) {
+        var row = topFloatingRows[_i];
+        var rowData = columns.map(column => {
+          var index = _this2.getColumnIndexByName(column.name);
+
+          assertNotNull(index);
+          return formatValue(_this2.valueForCell(index, row), column);
+        });
+
+        if (includeHeaders) {
+          rowData.push(_this2.textForRowFooter(row));
+        }
+
+        result.push(rowData);
+      };
+
+      for (var _i = 0; _i < topFloatingRows.length; _i += 1) {
+        _loop2(_i);
+      }
+
+      if (tableRanges.length > 0) {
+        var rangeSet = IrisGridUtils.rangeSetFromRanges(tableRanges);
+        var snapshot = yield _this2.subscription.snapshot(rangeSet, columns);
+        result.push(...snapshot.rows.map(rowData => columns.map(column => formatValue(rowData.get(column), column))));
+      }
+
+      var bottomFloatingRows = [...bottomFloatingRowsSet].sort();
+
+      var _loop3 = function _loop3(_i2) {
+        var row = bottomFloatingRows[_i2];
+        var rowData = columns.map(column => {
+          var index = _this2.getColumnIndexByName(column.name);
+
+          assertNotNull(index);
+          return formatValue(_this2.valueForCell(index, row), column);
+        });
+
+        if (includeHeaders) {
+          rowData.push(_this2.textForRowFooter(row));
+        }
+
+        result.push(rowData);
+      };
+
+      for (var _i2 = 0; _i2 < bottomFloatingRows.length; _i2 += 1) {
+        _loop3(_i2);
+      }
+
+      return result;
+    })();
+  }
+  /**
+   * Get a text snapshot of the provided ranges
+   * @param ranges The ranges to get the snapshot for
+   * @param includeHeaders Whether to include the headers in the snapshot or not
+   * @param formatValue Function for formatting the raw value into a string
+   * @returns A formatted string of all the data, columns separated by `\t` and rows separated by `\n`
+   */
+
+
+  textSnapshot(ranges) {
+    var _arguments2 = arguments,
+        _this3 = this;
+
+    return _asyncToGenerator(function* () {
+      var includeHeaders = _arguments2.length > 1 && _arguments2[1] !== undefined ? _arguments2[1] : false;
+      var formatValue = _arguments2.length > 2 && _arguments2[2] !== undefined ? _arguments2[2] : value => "".concat(value);
+      log.debug2('textSnapshot', ranges, includeHeaders);
+      var data = yield _this3.snapshot(ranges, includeHeaders, formatValue);
+      return data.map(row => row.join('\t')).join('\n');
+    })();
+  }
+
+  valuesTable(column) {
+    var _this4 = this;
+
+    return _asyncToGenerator(function* () {
+      var table = null;
+
+      try {
+        table = yield _this4.table.copy();
+        table.applyFilter([]);
+        table.applySort([]);
+        return table.selectDistinct([column]);
+      } finally {
+        if (table != null) {
+          table.close();
+        }
+      }
+    })();
+  }
+
+  isKeyColumn(x) {
+    var _this$inputTable$keyC2, _this$inputTable2;
+
+    return x < ((_this$inputTable$keyC2 = (_this$inputTable2 = this.inputTable) === null || _this$inputTable2 === void 0 ? void 0 : _this$inputTable2.keyColumns.length) !== null && _this$inputTable$keyC2 !== void 0 ? _this$inputTable$keyC2 : 0);
+  }
+
+  isRowMovable() {
+    return false;
+  }
+
+  isEditableRange(range) {
+    return this.inputTable != null && GridRange.isBounded(range) && (this.isPendingRow(range.startRow) && this.isPendingRow(range.endRow) || range.startColumn >= this.inputTable.keyColumns.length && range.endColumn >= this.inputTable.keyColumns.length) && range.startRow >= this.floatingTopRowCount && range.startRow < this.floatingTopRowCount + this.table.size + this.pendingRowCount && range.endRow < this.floatingTopRowCount + this.table.size + this.pendingRowCount;
+  }
+
+  isDeletableRange(range) {
+    return this.inputTable != null && range.startRow != null && range.endRow != null && range.startRow >= this.floatingTopRowCount && range.startRow < this.floatingTopRowCount + this.table.size + this.pendingRowCount && range.endRow < this.floatingTopRowCount + this.table.size + this.pendingRowCount;
+  }
+
+  isEditableRanges(ranges) {
+    return ranges.every(range => this.isEditableRange(range));
+  }
+
+  isDeletableRanges(ranges) {
+    return ranges.every(range => this.isDeletableRange(range));
+  }
+  /**
+   * @returns A range corresponding to the underlying table
+   */
+
+
+  getTableAreaRange() {
+    return new GridRange(null, this.floatingTopRowCount, null, this.floatingTopRowCount + this.table.size - 1);
+  }
+  /**
+   * @returns {GridRange} A range corresponding to the pending new rows
+   */
+
+
+  getPendingAreaRange() {
+    return new GridRange(null, this.floatingTopRowCount + this.table.size, null, this.floatingTopRowCount + this.table.size + this.pendingNewRowCount - 1);
+  }
+  /**
+   * Set value in an editable table
+   * @param x The column to set
+   * @param y The row to set
+   * @param value The value to set
+   * @returns A promise that resolves successfully when the operation is complete, or rejects if there's an error
+   */
+
+
+  setValueForCell(x, y, text) {
+    var _this5 = this;
+
+    return _asyncToGenerator(function* () {
+      // Cache the value in our pending string cache so that it stays displayed until our edit has been completed
+      return _this5.setValueForRanges([new GridRange(x, y, x, y)], text);
+    })();
+  }
+  /**
+   * Set value in an editable table
+   * @param ranges The ranges to set
+   * @param value The values to set
+   * @returns A promise that resolves successfully when the operation is complete, or rejects if there's an error
+   */
+
+
+  setValueForRanges(ranges, text) {
+    var _this6 = this;
+
+    return _asyncToGenerator(function* () {
+      if (!_this6.isEditableRanges(ranges)) {
+        throw new Error("Uneditable ranges ".concat(ranges));
+      }
+
+      try {
+        // Cache the value in our pending string cache so that it stays displayed until our edit has been completed
+        var columnSet = new Set(); // Formatted text for each column
+        // Since there could be different formatting for each column, but the value will be the same across rows
+
+        var formattedText = [];
+        GridRange.forEachCell(ranges, (x, y) => {
+          var column = _this6.columns[x];
+          columnSet.add(column);
+
+          if (formattedText[x] === undefined) {
+            var _value3 = TableUtils.makeValue(column.type, text, _this6.formatter.timeZone);
+
+            formattedText[x] = _value3 != null ? _this6.displayString(_value3, column.type, column.name) : null;
+          }
+
+          _this6.cachePendingValue(x, y, formattedText[x]);
+        }); // Take care of updates to the pending new area first, as they can be updated synchronously
+
+        var pendingAreaRange = _this6.getPendingAreaRange();
+
+        var pendingRanges = ranges.map(range => GridRange.intersection(pendingAreaRange, range)).filter(range => range != null).map(range => {
+          assertNotNull(range);
+          return GridRange.offset(range, 0, -(_this6.floatingTopRowCount + _this6.table.size));
+        });
+
+        if (pendingRanges.length > 0) {
+          var newDataMap = new Map(_this6.pendingNewDataMap);
+          GridRange.forEachCell(pendingRanges, (columnIndex, rowIndex) => {
+            if (!newDataMap.has(rowIndex)) {
+              newDataMap.set(rowIndex, {
+                data: new Map()
+              });
+            }
+
+            var column = _this6.columns[columnIndex];
+            var row = newDataMap.get(rowIndex);
+            assertNotNull(row);
+            var {
+              data: rowData
+            } = row;
+            var newRowData = new Map(rowData);
+            var value = TableUtils.makeValue(column.type, text, _this6.formatter.timeZone);
+
+            if (value != null) {
+              newRowData.set(columnIndex, {
+                value
+              });
+            } else {
+              newRowData.delete(columnIndex);
+            }
+
+            if (newRowData.size > 0) {
+              newDataMap.set(rowIndex, _objectSpread(_objectSpread({}, row), {}, {
+                data: newRowData
+              }));
+            } else {
+              newDataMap.delete(rowIndex);
+            }
+          });
+          _this6.pendingDataMap = newDataMap;
+        }
+
+        _this6.dispatchEvent(new EventShimCustomEvent(IrisGridModel.EVENT.UPDATED));
+
+        var tableAreaRange = _this6.getTableAreaRange();
+
+        var tableRanges = ranges.map(range => GridRange.intersection(tableAreaRange, range)).filter(range => range != null);
+
+        if (tableRanges.length > 0) {
+          var _this6$inputTable;
+
+          // Get a snapshot of the full rows, as we need to write a full row when editing
+          var data = yield _this6.snapshot(tableRanges.map(range => {
+            var _range$startRow, _range$endRow;
+
+            return new GridRange(null, (_range$startRow = range === null || range === void 0 ? void 0 : range.startRow) !== null && _range$startRow !== void 0 ? _range$startRow : null, null, (_range$endRow = range === null || range === void 0 ? void 0 : range.endRow) !== null && _range$endRow !== void 0 ? _range$endRow : null);
+          }));
+          var newRows = data.map(row => {
+            var newRow = {};
+
+            for (var c = 0; c < _this6.columns.length; c += 1) {
+              newRow[_this6.columns[c].name] = row[c];
+            }
+
+            columnSet.forEach(column => {
+              newRow[column.name] = TableUtils.makeValue(column.type, text, _this6.formatter.timeZone);
+            });
+            return newRow;
+          });
+          var result = yield (_this6$inputTable = _this6.inputTable) === null || _this6$inputTable === void 0 ? void 0 : _this6$inputTable.addRows(newRows);
+          log.debug('setValueForRanges(', ranges, ',', text, ') set tableRanges', tableRanges, 'result', result);
+        } // Add the changes to the formatted cache so it's still displayed until the update event is received
+        // The update event could be received on the next tick, after the input rows have been committed,
+        // so make sure we don't display stale data
+
+
+        GridRange.forEachCell(ranges, (x, y) => {
+          var cellText = formattedText[x];
+          assertNotNull(cellText);
+
+          _this6.cacheFormattedValue(x, y, cellText);
+        });
+      } catch (err) {
+        log.error('Unable to set ranges', ranges, text, err);
+      } finally {
+        GridRange.forEachCell(ranges, (x, y) => {
+          _this6.clearPendingValue(x, y);
+        });
+      }
+    })();
+  }
+
+  setValues() {
+    var _arguments3 = arguments,
+        _this7 = this;
+
+    return _asyncToGenerator(function* () {
+      var edits = _arguments3.length > 0 && _arguments3[0] !== undefined ? _arguments3[0] : [];
+      log.debug('setValues(', edits, ')');
+
+      if (!edits.every(edit => {
+        var _edit$column, _edit$row;
+
+        return _this7.isEditableRange(GridRange.makeCell((_edit$column = edit.column) !== null && _edit$column !== void 0 ? _edit$column : edit.x, (_edit$row = edit.row) !== null && _edit$row !== void 0 ? _edit$row : edit.y));
+      })) {
+        throw new Error("Uneditable ranges ".concat(edits));
+      }
+
+      try {
+        var newDataMap = new Map(_this7.pendingNewDataMap); // Cache the display values
+
+        edits.forEach(edit => {
+          var _edit$column2, _edit$row2;
+
+          var {
+            text
+          } = edit;
+          var x = (_edit$column2 = edit.column) !== null && _edit$column2 !== void 0 ? _edit$column2 : edit.x;
+          var y = (_edit$row2 = edit.row) !== null && _edit$row2 !== void 0 ? _edit$row2 : edit.y;
+          var column = _this7.columns[x];
+          var value = TableUtils.makeValue(column.type, text, _this7.formatter.timeZone);
+          var formattedText = value != null ? _this7.displayString(value, column.type, column.name) : null;
+
+          _this7.cachePendingValue(x, y, formattedText); // Take care of updates to the pending new area as well, as that can be updated synchronously
+
+
+          var pendingRow = _this7.pendingRow(y);
+
+          if (pendingRow != null) {
+            if (!newDataMap.has(pendingRow)) {
+              newDataMap.set(pendingRow, {
+                data: new Map()
+              });
+            }
+
+            var _row2 = newDataMap.get(pendingRow);
+
+            assertNotNull(_row2);
+            var {
+              data: rowData
+            } = _row2;
+            var newRowData = new Map(rowData);
+
+            if (value != null) {
+              newRowData.set(x, {
+                value
+              });
+            } else {
+              newRowData.delete(x);
+            }
+
+            if (newRowData.size > 0) {
+              newDataMap.set(pendingRow, _objectSpread(_objectSpread({}, _row2), {}, {
+                data: newRowData
+              }));
+            } else {
+              newDataMap.delete(pendingRow);
+            }
+          }
+        });
+        _this7.pendingDataMap = newDataMap; // Send an update right after setting the pending map so the values are displayed immediately
+
+        _this7.dispatchEvent(new EventShimCustomEvent(IrisGridModel.EVENT.UPDATED)); // Need to group by row...
+
+
+        var rowEditMap = edits.reduce((rowMap, edit) => {
+          var _edit$row3, _rowMap$get;
+
+          var y = (_edit$row3 = edit.row) !== null && _edit$row3 !== void 0 ? _edit$row3 : edit.y;
+
+          if (!rowMap.has(y)) {
+            rowMap.set(y, []);
+          }
+
+          (_rowMap$get = rowMap.get(y)) === null || _rowMap$get === void 0 ? void 0 : _rowMap$get.push(edit);
+          return rowMap;
+        }, new Map());
+        var ranges = GridRange.consolidate(edits.map(edit => {
+          var _edit$column3, _edit$row4;
+
+          return GridRange.makeCell((_edit$column3 = edit.column) !== null && _edit$column3 !== void 0 ? _edit$column3 : edit.x, (_edit$row4 = edit.row) !== null && _edit$row4 !== void 0 ? _edit$row4 : edit.y);
+        }));
+
+        var tableAreaRange = _this7.getTableAreaRange();
+
+        var tableRanges = ranges.map(range => GridRange.intersection(tableAreaRange, range)).filter(range => range != null);
+
+        if (tableRanges.length > 0) {
+          var _this7$inputTable;
+
+          // Get a snapshot of the full rows, as we need to write a full row when editing
+          var data = yield _this7.snapshot(tableRanges.map(range => {
+            assertNotNull(range);
+            return new GridRange(null, range.startRow, null, range.endRow);
+          }));
+          var newRows = data.map((row, dataIndex) => {
+            var rowIndex = null;
+            var r = dataIndex;
+
+            for (var i = 0; i < tableRanges.length; i += 1) {
+              var range = tableRanges[i];
+              assertNotNull(range);
+              var rangeRowCount = GridRange.rowCount([range]);
+
+              if (r < rangeRowCount) {
+                assertNotNull(range.startRow);
+                rowIndex = range.startRow + r;
+                break;
+              }
+
+              r -= rangeRowCount;
+            }
+
+            var newRow = {};
+
+            for (var c = 0; c < _this7.columns.length; c += 1) {
+              newRow[_this7.columns[c].name] = row[c];
+            }
+
+            assertNotNull(rowIndex);
+            var rowEdits = rowEditMap.get(rowIndex);
+
+            if (rowEdits != null) {
+              rowEdits.forEach(edit => {
+                var _edit$column4;
+
+                var column = _this7.columns[(_edit$column4 = edit.column) !== null && _edit$column4 !== void 0 ? _edit$column4 : edit.x];
+                newRow[column.name] = TableUtils.makeValue(column.type, edit.text, _this7.formatter.timeZone);
+              });
+            }
+
+            return newRow;
+          });
+          log.info('setValues setting tableRanges', tableRanges);
+          var result = yield (_this7$inputTable = _this7.inputTable) === null || _this7$inputTable === void 0 ? void 0 : _this7$inputTable.addRows(newRows);
+          log.info('setValues set tableRanges', tableRanges, 'SUCCESS', result);
+        } // We've sent the changes to the server, but have not yet got an update with those changes committed
+        // Add the changes to the formatted cache so it's still displayed until the update event is received
+        // The update event could be received on the next tick, after the input rows have been committed,
+        // so make sure we don't display stale data
+
+
+        edits.forEach(edit => {
+          var _edit$column5, _edit$row5;
+
+          var {
+            text
+          } = edit;
+          var x = (_edit$column5 = edit.column) !== null && _edit$column5 !== void 0 ? _edit$column5 : edit.x;
+          var y = (_edit$row5 = edit.row) !== null && _edit$row5 !== void 0 ? _edit$row5 : edit.y;
+          var column = _this7.columns[x];
+          var value = TableUtils.makeValue(column.type, text, _this7.formatter.timeZone);
+          var formattedText = value != null ? _this7.displayString(value, column.type, column.name) : null;
+
+          _this7.cacheFormattedValue(x, y, formattedText);
+        });
+      } finally {
+        edits.forEach(edit => {
+          _this7.clearPendingValue(edit.column, edit.row);
+        });
+      }
+    })();
+  }
+
+  commitPending() {
+    var _this8 = this;
+
+    return _asyncToGenerator(function* () {
+      if (_this8.pendingNewDataMap.size <= 0) {
+        throw new Error('No pending changes to commit');
+      }
+
+      try {
+        var _this8$inputTable, _this8$viewport$botto, _this8$viewport;
+
+        _this8.isSaveInProgress = true;
+        var newRows = [];
+
+        _this8.pendingNewDataMap.forEach(row => {
+          var newRow = {};
+          row.data.forEach((_ref2, columnIndex) => {
+            var {
+              value
+            } = _ref2;
+            var column = _this8.columns[columnIndex];
+            newRow[column.name] = value;
+          });
+          newRows.push(newRow);
+        });
+
+        var result = yield (_this8$inputTable = _this8.inputTable) === null || _this8$inputTable === void 0 ? void 0 : _this8$inputTable.addRows(newRows);
+        log.debug('commitPending()', _this8.pendingNewDataMap, 'result', result);
+        _this8.pendingNewDataMap = new Map();
+        _this8.pendingNewDataErrors = new Map();
+        _this8.pendingNewRowCount = Math.max(0, ((_this8$viewport$botto = (_this8$viewport = _this8.viewport) === null || _this8$viewport === void 0 ? void 0 : _this8$viewport.bottom) !== null && _this8$viewport$botto !== void 0 ? _this8$viewport$botto : 0) - _this8.table.size);
+        _this8.formattedStringData = [];
+
+        _this8.dispatchEvent(new EventShimCustomEvent(IrisGridModel.EVENT.PENDING_DATA_UPDATED));
+      } finally {
+        _this8.isSaveInProgress = false;
+      }
+    })();
+  }
+
+  editValueForCell(x, y) {
+    return this.textValueForCell(x, y);
+  }
+
+  delete(ranges) {
+    var _this9 = this;
+
+    return _asyncToGenerator(function* () {
+      if (!_this9.isDeletableRanges(ranges)) {
+        throw new Error("Undeletable ranges ".concat(ranges));
+      }
+
+      assertNotNull(_this9.inputTable);
+      var {
+        keyColumns
+      } = _this9.inputTable;
+
+      if (keyColumns.length === 0) {
+        throw new Error('No key columns to allow deletion');
+      }
+
+      var pendingAreaRange = _this9.getPendingAreaRange();
+
+      var pendingRanges = ranges.map(range => GridRange.intersection(pendingAreaRange, range)).filter(range => range != null).map(range => {
+        assertNotNull(range);
+        return GridRange.offset(range, 0, -(_this9.floatingTopRowCount + _this9.table.size));
+      });
+
+      if (pendingRanges.length > 0) {
+        var newDataMap = new Map(_this9.pendingNewDataMap);
+
+        for (var i = 0; i < pendingRanges.length; i += 1) {
+          var pendingRange = pendingRanges[i];
+          assertNotNull(pendingRange.startRow);
+          assertNotNull(pendingRange.endRow);
+
+          for (var r = pendingRange.startRow; r <= pendingRange.endRow; r += 1) {
+            newDataMap.delete(r);
+          }
+        }
+
+        _this9.pendingNewDataMap = newDataMap;
+        _this9.formattedStringData = [];
+
+        _this9.dispatchEvent(new EventShimCustomEvent(IrisGridModel.EVENT.PENDING_DATA_UPDATED));
+
+        _this9.dispatchEvent(new EventShimCustomEvent(IrisGridModel.EVENT.UPDATED));
+      }
+
+      var tableAreaRange = _this9.getTableAreaRange();
+
+      var tableRanges = ranges.map(range => GridRange.intersection(tableAreaRange, range)).filter(range => range != null);
+
+      if (tableRanges.length <= 0) {
+        return;
+      }
+
+      var [data, deleteTable] = yield Promise.all([// Need to get the key values of each row
+      _this9.snapshot(tableRanges.map(range => {
+        assertNotNull(range);
+        return new GridRange(0, range.startRow, keyColumns.length - 1, range.endRow);
+      })), _this9.table.copy()]); // Now copy the existing table and filter it on the values in the snapshot for the key columns in the input table
+
+      var filters = data.map(row => {
+        var columnFilters = [];
+
+        for (var c = 0; c < keyColumns.length; c += 1) {
+          var _column4 = keyColumns[c];
+          var _value4 = row[c];
+          var filterValue = TableUtils.makeFilterRawValue(_column4.type, _value4);
+
+          var _filter = _column4.filter().eq(filterValue);
+
+          columnFilters.push(_filter);
+        }
+
+        return columnFilters.reduce((agg, curr) => agg ? agg.and(curr) : curr);
+      });
+      var filter = filters.reduce((agg, curr) => agg ? agg.or(curr) : curr);
+      deleteTable.applyFilter([filter]); // await this.inputTable?.deleteTable(deleteTable);
+
+      deleteTable.close();
+    })();
+  }
+
+  isValidForCell(x, y, value) {
+    try {
+      var _column5 = this.columns[x];
+      TableUtils.makeValue(_column5.type, value, this.formatter.timeZone);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+
+}
+
+_defineProperty(IrisGridTableModelTemplate, "ROW_BUFFER_PAGES", 1);
+
+export default IrisGridTableModelTemplate;
+//# sourceMappingURL=IrisGridTableModelTemplate.js.map