@deephaven/iris-grid 0.22.3-deep-bot-test.14 → 0.23.0

package/dist/IrisGridProxyModel.js

@@ -1,5 +1,4 @@
 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 deepEqual from 'deep-equal';
 import { Formatter, TableUtils } from '@deephaven/jsapi-utils';
@@ -11,214 +10,163 @@ import IrisGridTreeTableModel from "./IrisGridTreeTableModel.js";
 import IrisGridModel from "./IrisGridModel.js";
 import { isIrisGridTableModelTemplate } from "./IrisGridTableModelTemplate.js";
 var log = Log.module('IrisGridProxyModel');
-
 function makeModel(table, formatter, inputTable) {
   if (TableUtils.isTreeTable(table)) {
     return new IrisGridTreeTableModel(table, formatter);
   }
-
   return new IrisGridTableModel(table, formatter, inputTable);
 }
+
 /**
  * Model which proxies calls to other IrisGridModels.
  * This allows for operations that generate new tables, like rollups.
  */
-
-
 class IrisGridProxyModel extends IrisGridModel {
   /**
    * @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 _this;
-
     var formatter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Formatter();
     var inputTable = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
     super();
     _this = this;
-
     _defineProperty(this, "originalModel", void 0);
-
     _defineProperty(this, "model", void 0);
-
     _defineProperty(this, "modelPromise", void 0);
-
     _defineProperty(this, "rollup", void 0);
-
     _defineProperty(this, "selectDistinct", void 0);
-
     _defineProperty(this, "textForCell", function () {
       return _this.model.textForCell(...arguments);
     });
-
     _defineProperty(this, "truncationCharForCell", function () {
       return _this.model.truncationCharForCell(...arguments);
     });
-
     _defineProperty(this, "textAlignForCell", function () {
       return _this.model.textAlignForCell(...arguments);
     });
-
     _defineProperty(this, "colorForCell", function () {
       return _this.model.colorForCell(...arguments);
     });
-
     _defineProperty(this, "backgroundColorForCell", function () {
       return _this.model.backgroundColorForCell(...arguments);
     });
-
     _defineProperty(this, "textForColumnHeader", function () {
       return _this.model.textForColumnHeader(...arguments);
     });
-
     _defineProperty(this, "colorForColumnHeader", function () {
       return _this.model.colorForColumnHeader(...arguments);
     });
-
     _defineProperty(this, "textForRowHeader", function () {
       return _this.model.textForRowHeader(...arguments);
     });
-
     _defineProperty(this, "textForRowFooter", function () {
       return _this.model.textForRowFooter(...arguments);
     });
-
     _defineProperty(this, "isRowMovable", function () {
       return _this.model.isRowMovable(...arguments);
     });
-
     _defineProperty(this, "isColumnMovable", function () {
       return _this.model.isColumnMovable(...arguments);
     });
-
     _defineProperty(this, "isRowExpandable", function () {
       if (isExpandableGridModel(_this.model)) {
         return _this.model.isRowExpandable(...arguments);
       }
-
       return false;
     });
-
     _defineProperty(this, "isRowExpanded", function () {
       if (isExpandableGridModel(_this.model)) {
         return _this.model.isRowExpanded(...arguments);
       }
-
       return false;
     });
-
     _defineProperty(this, "setRowExpanded", function () {
       if (isExpandableGridModel(_this.model)) {
         return _this.model.setRowExpanded(...arguments);
       }
-
       throw Error('Function setRowExpanded does not exist on IrisGridTableModel');
     });
-
     _defineProperty(this, "depthForRow", function () {
       if (isExpandableGridModel(_this.model)) {
         return _this.model.depthForRow(...arguments);
       }
-
-      return 0; // throw Error('Function depthForRow does not exist on IrisGridTableModel');
+      return 0;
+      // throw Error('Function depthForRow does not exist on IrisGridTableModel');
     });
-
     _defineProperty(this, "getColumnHeaderGroup", function () {
       return _this.model.getColumnHeaderGroup(...arguments);
     });
-
     _defineProperty(this, "getColumnHeaderParentGroup", function () {
       return _this.model.getColumnHeaderParentGroup(...arguments);
     });
-
     _defineProperty(this, "formatForCell", function () {
       return _this.model.formatForCell(...arguments);
     });
-
     _defineProperty(this, "valueForCell", function () {
       return _this.model.valueForCell(...arguments);
     });
-
     _defineProperty(this, "displayString", function () {
       return _this.model.displayString(...arguments);
     });
-
     _defineProperty(this, "isEditableRange", function () {
       if (isEditableGridModel(_this.model)) {
         return _this.model.isEditableRange(...arguments);
       }
-
       return false;
     });
-
     _defineProperty(this, "isFilterable", function () {
       return _this.model.isFilterable(...arguments);
     });
-
     _defineProperty(this, "setViewport", (top, bottom, columns) => this.model.setViewport(top, bottom, columns));
-
     _defineProperty(this, "snapshot", function () {
       return _this.model.snapshot(...arguments);
     });
-
     _defineProperty(this, "textSnapshot", function () {
       return _this.model.textSnapshot(...arguments);
     });
-
     _defineProperty(this, "valuesTable", function () {
       return _this.model.valuesTable(...arguments);
     });
-
     _defineProperty(this, "editValueForCell", function () {
       if (isEditableGridModel(_this.model)) {
         _this.model.editValueForCell(...arguments);
       }
-
       return '';
     });
-
     _defineProperty(this, "setValueForCell", function () {
       if (isEditableGridModel(_this.model)) {
         return _this.model.setValueForCell(...arguments);
       }
-
       return Promise.reject(new Error('Model is not editable'));
     });
-
     _defineProperty(this, "setValueForRanges", function () {
       if (isEditableGridModel(_this.model)) {
         return _this.model.setValueForRanges(...arguments);
       }
-
       return Promise.reject(new Error('Model is not editable'));
     });
-
     _defineProperty(this, "setValues", function () {
       if (isEditableGridModel(_this.model)) {
         return _this.model.setValues(...arguments);
       }
-
       return Promise.resolve();
     });
-
     _defineProperty(this, "isValidForCell", function () {
       if (isEditableGridModel(_this.model)) {
         return _this.model.isValidForCell(...arguments);
       }
-
       return false;
     });
-
     _defineProperty(this, "delete", function () {
       return _this.model.delete(...arguments);
     });
-
     _defineProperty(this, "commitPending", function () {
       return _this.model.commitPending(...arguments);
     });
-
     this.handleModelEvent = this.handleModelEvent.bind(this);
     var model = makeModel(table, formatter, inputTable);
     this.originalModel = model;
@@ -227,19 +175,15 @@ class IrisGridProxyModel extends IrisGridModel {
     this.rollup = null;
     this.selectDistinct = [];
   }
-
   close() {
     this.originalModel.close();
-
     if (this.model !== this.originalModel) {
       this.model.close();
     }
-
     if (this.modelPromise != null) {
       this.modelPromise.cancel();
     }
   }
-
   handleModelEvent(event) {
     log.debug2('handleModelEvent', event);
     var {
@@ -250,43 +194,33 @@ class IrisGridProxyModel extends IrisGridModel {
       detail
     }));
   }
-
   setModel(model) {
     log.debug('setModel', model);
     var oldModel = this.model;
-
     if (oldModel !== this.originalModel) {
       oldModel.close();
     }
-
     this.model = model;
-
     if (this.listenerCount > 0) {
       this.addListeners(model);
     }
-
     this.dispatchEvent(new EventShimCustomEvent(IrisGridModel.EVENT.COLUMNS_CHANGED, {
       detail: model.columns
     }));
-
     if (isIrisGridTableModelTemplate(model)) {
       this.dispatchEvent(new EventShimCustomEvent(IrisGridModel.EVENT.TABLE_CHANGED, {
         detail: model.table
       }));
     }
   }
-
   setNextModel(modelPromise) {
     log.debug2('setNextModel');
-
     if (this.modelPromise) {
       this.modelPromise.cancel();
     }
-
     if (this.listenerCount > 0) {
       this.removeListeners(this.model);
     }
-
     this.modelPromise = PromiseUtils.makeCancelable(modelPromise, model => model.close());
     this.modelPromise.then(model => {
       this.modelPromise = null;
@@ -296,7 +230,6 @@ class IrisGridProxyModel extends IrisGridModel {
         log.debug2('setNextModel cancelled');
         return;
       }
-
       log.error('Unable to set next model', err);
       this.modelPromise = null;
       this.dispatchEvent(new EventShimCustomEvent(IrisGridModel.EVENT.REQUEST_FAILED, {
@@ -304,321 +237,244 @@ class IrisGridProxyModel extends IrisGridModel {
       }));
     });
   }
-
   startListening() {
     super.startListening();
     this.addListeners(this.model);
   }
-
   stopListening() {
     super.stopListening();
     this.removeListeners(this.model);
   }
-
   addListeners(model) {
     var events = Object.keys(IrisGridModel.EVENT);
-
     for (var i = 0; i < events.length; i += 1) {
       // eslint-disable-next-line @typescript-eslint/ban-ts-comment
       // @ts-ignore
       model.addEventListener(events[i], this.handleModelEvent);
     }
   }
-
   removeListeners(model) {
     var events = Object.keys(IrisGridModel.EVENT);
-
     for (var i = 0; i < events.length; i += 1) {
       // eslint-disable-next-line @typescript-eslint/ban-ts-comment
       // @ts-ignore
       model.removeEventListener(events[i], this.handleModelEvent);
     }
   }
-
   get rowCount() {
     return this.model.rowCount;
   }
-
   get columnCount() {
     return this.model.columnCount;
   }
-
   get floatingTopRowCount() {
     return this.model.floatingTopRowCount;
   }
-
   get floatingBottomRowCount() {
     return this.model.floatingBottomRowCount;
   }
-
   get floatingLeftColumnCount() {
     return this.model.floatingLeftColumnCount;
   }
-
   get floatingRightColumnCount() {
     return this.model.floatingRightColumnCount;
   }
-
   isColumnFrozen(x) {
     return this.model.isColumnFrozen(x);
   }
-
   get hasExpandableRows() {
     if (isExpandableGridModel(this.model)) {
       return this.model.hasExpandableRows;
     }
-
     return false;
   }
-
   get isExportAvailable() {
     return this.model.isExportAvailable;
   }
-
   get isColumnStatisticsAvailable() {
     return this.model.isColumnStatisticsAvailable;
   }
-
   get isValuesTableAvailable() {
     return this.model.isValuesTableAvailable;
   }
-
   get isCustomColumnsAvailable() {
-    return this.model.isCustomColumnsAvailable && // Disable for selectDistinct tables
+    return this.model.isCustomColumnsAvailable &&
+    // Disable for selectDistinct tables
     !(this.isSelectDistinctAvailable && this.selectDistinctColumns.length > 0);
   }
-
   get isFormatColumnsAvailable() {
     return this.model.isFormatColumnsAvailable;
   }
-
   get isChartBuilderAvailable() {
     return this.model.isChartBuilderAvailable;
   }
-
   get isRollupAvailable() {
     return (this.originalModel.isRollupAvailable || this.rollup != null) && this.selectDistinct.length === 0;
   }
-
   get isSelectDistinctAvailable() {
     return (this.originalModel.isSelectDistinctAvailable || this.selectDistinct.length > 0) && this.rollup == null;
   }
-
   get isTotalsAvailable() {
     return this.model.isTotalsAvailable;
   }
-
   get isReversible() {
     return this.model.isReversible;
   }
-
   get columns() {
     return this.model.columns;
   }
-
   get movedColumns() {
     return this.model.movedColumns;
   }
-
   get movedRows() {
     return this.model.movedRows;
   }
-
   get layoutHints() {
     return this.model.layoutHints;
   }
-
   get frontColumns() {
     return this.model.frontColumns;
   }
-
   get backColumns() {
     return this.model.backColumns;
   }
-
   get frozenColumns() {
     return this.model.frozenColumns;
   }
-
   get columnHeaderMaxDepth() {
     return this.model.columnHeaderMaxDepth;
   }
-
   updateFrozenColumns(columns) {
     return this.model.updateFrozenColumns(columns);
   }
-
   get originalColumns() {
     return this.originalModel.columns;
   }
-
   get groupedColumns() {
     return this.model.groupedColumns;
   }
-
   get description() {
     return this.model.description;
   }
-
   get filter() {
     return this.model.filter;
   }
-
   set filter(filter) {
     this.model.filter = filter;
   }
-
   get formatter() {
     return this.model.formatter;
   }
-
   set formatter(formatter) {
     this.model.formatter = formatter;
   }
-
   get sort() {
     return this.model.sort;
   }
-
   set sort(sort) {
     this.model.sort = sort;
   }
-
   get customColumns() {
     return this.model.customColumns;
   }
-
   set customColumns(customColumns) {
     this.model.customColumns = customColumns;
   }
-
   get formatColumns() {
     return this.model.formatColumns;
   }
-
   set formatColumns(formatColumns) {
     this.model.formatColumns = formatColumns;
   }
-
   get rollupConfig() {
     return this.rollup;
   }
-
   set rollupConfig(rollupConfig) {
     log.debug('set rollupConfig', rollupConfig);
-
     if (!this.isRollupAvailable) {
       throw new Error('Rollup Rows are not available');
-    } // Prevent model update when IrisGridModelUpdater is mounted
-    // if rollup is already initialized in IrisGridPanel
-
+    }
 
+    // Prevent model update when IrisGridModelUpdater is mounted
+    // if rollup is already initialized in IrisGridPanel
     if (deepEqual(rollupConfig, this.rollup)) {
       return;
     }
-
     this.rollup = rollupConfig;
     var modelPromise = Promise.resolve(this.originalModel);
-
     if (isIrisGridTableModelTemplate(this.originalModel) && rollupConfig != null) {
       modelPromise = this.originalModel.table.rollup(rollupConfig).then(table => makeModel(table, this.formatter));
     }
-
     this.setNextModel(modelPromise);
   }
-
   get selectDistinctColumns() {
     return this.selectDistinct;
   }
-
   set selectDistinctColumns(columnNames) {
     log.debug('set selectDistinctColumns', columnNames);
-
     if (!this.isSelectDistinctAvailable) {
       throw new Error('Select distinct is not available');
     }
-
     if (columnNames === this.selectDistinctColumns || columnNames.length === 0 && this.selectDistinctColumns.length === 0) {
       log.debug('Ignore same selectDistinctColumns', columnNames);
       return;
     }
-
     this.selectDistinct = columnNames;
     var selectDistinctColumns = columnNames.map(name => this.originalColumns.find(column => column.name === name)).filter(column => column != null);
     var modelPromise = Promise.resolve(this.originalModel);
-
     if (isIrisGridTableModelTemplate(this.originalModel) && selectDistinctColumns.length > 0) {
       modelPromise = this.originalModel.table.selectDistinct(selectDistinctColumns).then(table => makeModel(table, this.formatter));
     }
-
     this.setNextModel(modelPromise);
   }
-
   get table() {
     if (isIrisGridTableModelTemplate(this.model)) {
       return this.model.table;
     }
-
     return undefined;
   }
-
   get totalsConfig() {
     return this.model.totalsConfig;
   }
-
   set totalsConfig(totalsConfig) {
     this.model.totalsConfig = totalsConfig;
   }
-
   get isFilterRequired() {
     return this.model.isFilterRequired;
   }
-
   get isEditable() {
     return isEditableGridModel(this.model) && this.model.isEditable;
   }
-
   export() {
     if (TableUtils.isTreeTable(this.model)) {
       throw new Error("TreeTable has no 'export' property");
     }
-
     return this.model.export();
   }
-
   columnStatistics(column) {
     if (TableUtils.isTreeTable(this.model)) {
       throw new Error("TreeTable has no 'columnStatistics' function");
     }
-
     return this.model.columnStatistics(column);
   }
-
   get pendingDataMap() {
     return this.model.pendingDataMap;
   }
-
   set pendingDataMap(map) {
     this.model.pendingDataMap = map;
   }
-
   get pendingRowCount() {
     return this.model.pendingRowCount;
   }
-
   set pendingRowCount(count) {
     this.model.pendingRowCount = count;
   }
-
   get pendingDataErrors() {
     return this.model.pendingDataErrors;
   }
-
   getColumnIndexByName(name) {
     return this.model.getColumnIndexByName(name);
   }
-
 }
-
 export default IrisGridProxyModel;
 //# sourceMappingURL=IrisGridProxyModel.js.map