@deephaven/dashboard-core-plugins 0.43.0 → 0.44.0

package/dist/panels/IrisGridPanel.js

@@ -0,0 +1,1018 @@
+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); }
+// Wrapper for the IrisGrid for use in a golden layout container
+// Will probably need to handle window popping out from golden layout here.
+import React, { PureComponent } from 'react';
+import memoize from 'memoize-one';
+import { connect } from 'react-redux';
+import debounce from 'lodash.debounce';
+import { DEFAULT_DASHBOARD_ID, LayoutUtils } from '@deephaven/dashboard';
+import { AdvancedSettings, IrisGrid, IrisGridModel, IrisGridUtils, IrisGridTableModel, isIrisGridTableModelTemplate } from '@deephaven/iris-grid';
+import { TableUtils } from '@deephaven/jsapi-utils';
+import Log from '@deephaven/log';
+import { getSettings, getUser, getWorkspace } from '@deephaven/redux';
+import { assertNotNull, PromiseUtils } from '@deephaven/utils';
+import { ContextMenuRoot } from '@deephaven/components';
+import { ConsoleEvent, InputFilterEvent, IrisGridEvent } from "../events/index.js";
+import { getInputFiltersForDashboard, getLinksForDashboard, getColumnSelectionValidatorForDashboard } from "../redux/index.js";
+import WidgetPanel from "./WidgetPanel.js";
+import "./IrisGridPanel.css";
+import IrisGridPanelTooltip from "./IrisGridPanelTooltip.js";
+var log = Log.module('IrisGridPanel');
+var DEBOUNCE_PANEL_STATE_UPDATE = 500;
+var PLUGIN_COMPONENTS = {
+  IrisGrid,
+  IrisGridTableModel,
+  ContextMenuRoot
+};
+export class IrisGridPanel extends PureComponent {
+  constructor(props) {
+    super(props);
+    _defineProperty(this, "irisGrid", void 0);
+    _defineProperty(this, "pluginRef", void 0);
+    _defineProperty(this, "modelPromise", void 0);
+    _defineProperty(this, "irisGridState", void 0);
+    _defineProperty(this, "gridState", void 0);
+    _defineProperty(this, "pluginState", void 0);
+    _defineProperty(this, "irisGridUtils", void 0);
+    _defineProperty(this, "getGridInputFilters", memoize((columns, inputFilters) => IrisGridUtils.getInputFiltersForColumns(columns,
+    // They may have picked a column, but not actually entered a value yet. In that case, don't need to update.
+    inputFilters.filter(_ref => {
+      var {
+        value,
+        excludePanelIds
+      } = _ref;
+      var id = LayoutUtils.getIdFromPanel(this);
+      return value != null && (excludePanelIds == null || id != null && !excludePanelIds.includes(id));
+    }))));
+    _defineProperty(this, "getAlwaysFetchColumns", memoize((dashboardLinks, pluginFetchColumns) => {
+      var id = LayoutUtils.getIdFromPanel(this);
+      // Always fetch columns which are the start/source of a link or columns specified by a plugin
+      var columnSet = new Set(pluginFetchColumns);
+      for (var i = 0; i < dashboardLinks.length; i += 1) {
+        var {
+          start
+        } = dashboardLinks[i];
+        if (start != null && start.panelId === id) {
+          columnSet.add(start.columnName);
+        }
+      }
+      return [...columnSet];
+    }));
+    _defineProperty(this, "getPluginContent", memoize((Plugin, model, user, workspace, pluginState) => {
+      if (!model || !isIrisGridTableModelTemplate(model) || Plugin == null || model.table == null) {
+        return null;
+      }
+      return /*#__PURE__*/React.createElement("div", {
+        className: "iris-grid-plugin"
+      }, /*#__PURE__*/React.createElement(Plugin, {
+        ref: this.pluginRef,
+        filter: this.handlePluginFilter
+        // onFilter is deprecated
+        ,
+        onFilter: this.handlePluginFilter,
+        fetchColumns: this.handlePluginFetchColumns
+        // onFetchColumns is deprecated
+        ,
+        onFetchColumns: this.handlePluginFetchColumns,
+        table: model.table,
+        user: user,
+        panel: this,
+        workspace: workspace,
+        components: PLUGIN_COMPONENTS,
+        onStateChange: this.handlePluginStateChange,
+        pluginState: pluginState
+      }));
+    }));
+    _defineProperty(this, "getDehydratedIrisGridPanelState", memoize((model, isSelectingPartition, partition, partitionColumn, advancedSettings) => IrisGridUtils.dehydrateIrisGridPanelState(model, {
+      isSelectingPartition,
+      partition,
+      partitionColumn,
+      advancedSettings
+    })));
+    _defineProperty(this, "getDehydratedIrisGridState", memoize((model, sorts, advancedFilters, customColumnFormatMap, isFilterBarShown, quickFilters, customColumns, reverseType, rollupConfig, showSearchBar, searchValue, selectDistinctColumns, selectedSearchColumns, invertSearchColumns, userColumnWidths, userRowHeights, aggregationSettings, pendingDataMap, frozenColumns, conditionalFormats, columnHeaderGroups) => {
+      assertNotNull(this.irisGridUtils);
+      return this.irisGridUtils.dehydrateIrisGridState(model, {
+        advancedFilters,
+        aggregationSettings,
+        customColumnFormatMap,
+        isFilterBarShown,
+        metrics: {
+          userColumnWidths,
+          userRowHeights
+        },
+        quickFilters,
+        customColumns,
+        reverseType,
+        rollupConfig,
+        showSearchBar,
+        searchValue,
+        selectDistinctColumns,
+        selectedSearchColumns,
+        sorts,
+        invertSearchColumns,
+        pendingDataMap,
+        frozenColumns,
+        conditionalFormats,
+        columnHeaderGroups
+      });
+    }));
+    _defineProperty(this, "getDehydratedGridState", memoize((model, movedColumns, movedRows, isStuckToBottom, isStuckToRight) => IrisGridUtils.dehydrateGridState(model, {
+      isStuckToBottom,
+      isStuckToRight,
+      movedColumns,
+      movedRows
+    })));
+    _defineProperty(this, "getCachedPanelState", memoize((irisGridPanelState, irisGridState, gridState, pluginState) => ({
+      irisGridPanelState,
+      irisGridState,
+      gridState,
+      pluginState
+    })));
+    _defineProperty(this, "savePanelState", debounce(() => {
+      var {
+        irisGridState,
+        gridState,
+        pluginState
+      } = this;
+      assertNotNull(irisGridState);
+      var {
+        onPanelStateUpdate
+      } = this.props;
+      var {
+        model,
+        panelState: oldPanelState,
+        isSelectingPartition,
+        partition,
+        partitionColumn,
+        advancedSettings
+      } = this.state;
+      var {
+        advancedFilters,
+        aggregationSettings,
+        customColumnFormatMap,
+        isFilterBarShown,
+        quickFilters,
+        customColumns,
+        reverseType,
+        rollupConfig,
+        showSearchBar,
+        searchValue,
+        selectDistinctColumns,
+        selectedSearchColumns,
+        sorts,
+        invertSearchColumns,
+        metrics,
+        pendingDataMap,
+        frozenColumns,
+        conditionalFormats,
+        columnHeaderGroups
+      } = irisGridState;
+      assertNotNull(model);
+      assertNotNull(metrics);
+      var {
+        userColumnWidths,
+        userRowHeights
+      } = metrics;
+      assertNotNull(gridState);
+      var {
+        isStuckToBottom,
+        isStuckToRight,
+        movedColumns,
+        movedRows
+      } = gridState;
+      var panelState = this.getCachedPanelState(this.getDehydratedIrisGridPanelState(model, isSelectingPartition, partition, partitionColumn, advancedSettings), this.getDehydratedIrisGridState(model, sorts, advancedFilters, customColumnFormatMap, isFilterBarShown, quickFilters, customColumns, reverseType, rollupConfig, showSearchBar, searchValue, selectDistinctColumns, selectedSearchColumns, invertSearchColumns, userColumnWidths, userRowHeights, aggregationSettings, pendingDataMap, frozenColumns, conditionalFormats, columnHeaderGroups), this.getDehydratedGridState(model, movedColumns, movedRows, isStuckToBottom, isStuckToRight), pluginState);
+      if (panelState !== oldPanelState) {
+        log.debug('Saving panel state', this, panelState);
+        this.setState({
+          panelState
+        });
+        onPanelStateUpdate === null || onPanelStateUpdate === void 0 ? void 0 : onPanelStateUpdate(panelState);
+      }
+    }, DEBOUNCE_PANEL_STATE_UPDATE));
+    this.handleAdvancedSettingsChange = this.handleAdvancedSettingsChange.bind(this);
+    this.handleColumnsChanged = this.handleColumnsChanged.bind(this);
+    this.handleTableChanged = this.handleTableChanged.bind(this);
+    this.handleColumnSelected = this.handleColumnSelected.bind(this);
+    this.handleDataSelected = this.handleDataSelected.bind(this);
+    this.handleError = this.handleError.bind(this);
+    this.handleGridStateChange = this.handleGridStateChange.bind(this);
+    this.handlePluginStateChange = this.handlePluginStateChange.bind(this);
+    this.handlePartitionAppend = this.handlePartitionAppend.bind(this);
+    this.handleCreateChart = this.handleCreateChart.bind(this);
+    this.handleResize = this.handleResize.bind(this);
+    this.handleShow = this.handleShow.bind(this);
+    this.handleTabClicked = this.handleTabClicked.bind(this);
+    this.handleDisconnect = this.handleDisconnect.bind(this);
+    this.handleReconnect = this.handleReconnect.bind(this);
+    this.handleLoadSuccess = this.handleLoadSuccess.bind(this);
+    this.handleLoadError = this.handleLoadError.bind(this);
+    this.isColumnSelectionValid = this.isColumnSelectionValid.bind(this);
+    this.handleContextMenu = this.handleContextMenu.bind(this);
+    this.handlePluginFilter = this.handlePluginFilter.bind(this);
+    this.handlePluginFetchColumns = this.handlePluginFetchColumns.bind(this);
+    this.handleClearAllFilters = this.handleClearAllFilters.bind(this);
+    this.irisGrid = /*#__PURE__*/React.createRef();
+    this.pluginRef = /*#__PURE__*/React.createRef();
+    var {
+      panelState: _panelState
+    } = props;
+    this.pluginState = null;
+    this.irisGridUtils = null;
+    this.state = {
+      error: null,
+      isDisconnected: false,
+      isLoaded: false,
+      isLoading: true,
+      isModelReady: false,
+      model: undefined,
+      // State is hydrated from panel state when table is loaded
+      advancedFilters: new Map(),
+      aggregationSettings: {
+        aggregations: [],
+        showOnTop: false
+      },
+      advancedSettings: new Map(AdvancedSettings.DEFAULTS),
+      customColumns: [],
+      customColumnFormatMap: new Map(),
+      isFilterBarShown: false,
+      quickFilters: new Map(),
+      sorts: [],
+      userColumnWidths: new Map(),
+      userRowHeights: new Map(),
+      reverseType: TableUtils.REVERSE_TYPE.NONE,
+      movedColumns: [],
+      movedRows: [],
+      isSelectingPartition: false,
+      partition: null,
+      partitionColumn: null,
+      rollupConfig: undefined,
+      showSearchBar: false,
+      searchValue: '',
+      selectedSearchColumns: undefined,
+      invertSearchColumns: true,
+      Plugin: undefined,
+      pluginFilters: [],
+      pluginFetchColumns: [],
+      modelQueue: [],
+      pendingDataMap: new Map(),
+      frozenColumns: undefined,
+      // eslint-disable-next-line react/no-unused-state
+      panelState: _panelState,
+      // Dehydrated panel state that can load this panel
+      irisGridStateOverrides: {},
+      gridStateOverrides: {},
+      isStuckToBottom: false,
+      isStuckToRight: false,
+      conditionalFormats: [],
+      selectDistinctColumns: []
+    };
+  }
+  componentDidMount() {
+    this.initModel();
+  }
+  componentDidUpdate(_, prevState) {
+    var {
+      model
+    } = this.state;
+    if (model !== prevState.model) {
+      if (prevState.model != null) {
+        this.stopModelListening(prevState.model);
+        prevState.model.close();
+      }
+      if (model != null) {
+        this.startModelListening(model);
+      }
+    }
+  }
+  componentWillUnmount() {
+    this.savePanelState.cancel();
+    if (this.modelPromise != null) {
+      this.modelPromise.cancel();
+      this.modelPromise = undefined;
+    }
+    var {
+      model
+    } = this.state;
+    if (model) {
+      this.stopModelListening(model);
+      model.close();
+    }
+  }
+  getTableName() {
+    var {
+      metadata
+    } = this.props;
+    return metadata.table;
+  }
+  initModel() {
+    this.setState({
+      isModelReady: false,
+      isLoading: true,
+      error: null
+    });
+    var {
+      makeModel
+    } = this.props;
+    if (this.modelPromise != null) {
+      this.modelPromise.cancel();
+    }
+    this.modelPromise = PromiseUtils.makeCancelable(makeModel(), resolved => resolved.close());
+    this.modelPromise.then(this.handleLoadSuccess).catch(this.handleLoadError);
+  }
+  handleLoadSuccess(modelParam) {
+    var model = modelParam;
+    var {
+      panelState,
+      irisGridStateOverrides
+    } = this.state;
+    var modelQueue = [];
+    this.irisGridUtils = new IrisGridUtils(model.dh);
+    if (panelState != null) {
+      var {
+        irisGridState: _irisGridState
+      } = panelState;
+      var {
+        aggregationSettings,
+        customColumns,
+        selectDistinctColumns = [],
+        rollupConfig
+      } = _objectSpread(_objectSpread({}, _irisGridState), irisGridStateOverrides);
+      if (customColumns.length > 0) {
+        modelQueue.push(m => {
+          // eslint-disable-next-line no-param-reassign
+          m.customColumns = customColumns;
+        });
+      }
+      if (rollupConfig != null && rollupConfig.columns.length > 0) {
+        // originalColumns might change by the time this model queue item is applied.
+        // Instead of pushing a static object, push the function
+        // that calculates the config based on the updated model state.
+        modelQueue.push(m => {
+          // eslint-disable-next-line no-param-reassign
+          m.rollupConfig = IrisGridUtils.getModelRollupConfig(m.originalColumns, rollupConfig, aggregationSettings);
+        });
+      }
+      if (selectDistinctColumns.length > 0) {
+        modelQueue.push(m => {
+          // eslint-disable-next-line no-param-reassign
+          m.selectDistinctColumns = selectDistinctColumns;
+        });
+      }
+    }
+    this.setState({
+      model,
+      modelQueue
+    });
+    this.initModelQueue(model, modelQueue);
+  }
+  initModelQueue(modelParam, modelQueue) {
+    var model = modelParam;
+    if (modelQueue.length === 0) {
+      this.modelInitialized(model);
+      return;
+    }
+    var modelChange = modelQueue.shift();
+    log.debug('initModelQueue', modelChange);
+    // Apply next model change. Triggers columnschanged event.
+    if (modelChange) {
+      modelChange(model);
+    }
+    this.setState({
+      modelQueue
+    });
+  }
+  handleAdvancedSettingsChange(key, value) {
+    log.debug('handleAdvancedSettingsChange', key, value);
+    this.setState(_ref2 => {
+      var {
+        advancedSettings
+      } = _ref2;
+      return advancedSettings.get(key) === value ? null : {
+        advancedSettings: new Map(advancedSettings).set(key, value)
+      };
+    });
+  }
+  handlePluginFilter(filters) {
+    var _this$irisGridUtils$g, _this$irisGridUtils;
+    var {
+      model
+    } = this.state;
+    assertNotNull(model);
+    var {
+      columns,
+      formatter
+    } = model;
+    var pluginFilters = (_this$irisGridUtils$g = (_this$irisGridUtils = this.irisGridUtils) === null || _this$irisGridUtils === void 0 ? void 0 : _this$irisGridUtils.getFiltersFromInputFilters(columns, filters, formatter.timeZone)) !== null && _this$irisGridUtils$g !== void 0 ? _this$irisGridUtils$g : [];
+    this.setState({
+      pluginFilters
+    });
+  }
+  handlePluginFetchColumns(pluginFetchColumns) {
+    this.setState({
+      pluginFetchColumns
+    });
+  }
+  handleContextMenu(obj) {
+    var _this$pluginRef$curre, _this$pluginRef$curre2, _this$pluginRef$curre3;
+    return (_this$pluginRef$curre = (_this$pluginRef$curre2 = this.pluginRef.current) === null || _this$pluginRef$curre2 === void 0 ? void 0 : (_this$pluginRef$curre3 = _this$pluginRef$curre2.getMenu) === null || _this$pluginRef$curre3 === void 0 ? void 0 : _this$pluginRef$curre3.call(_this$pluginRef$curre2, obj)) !== null && _this$pluginRef$curre !== void 0 ? _this$pluginRef$curre : [];
+  }
+  isColumnSelectionValid(tableColumn) {
+    var {
+      columnSelectionValidator
+    } = this.props;
+    if (columnSelectionValidator && tableColumn) {
+      return columnSelectionValidator(this, tableColumn);
+    }
+    return false;
+  }
+  handleGridStateChange(irisGridState, gridState) {
+    this.irisGridState = irisGridState;
+    this.gridState = gridState;
+
+    // Grid sends it's first state change after it's finished loading
+    this.setState({
+      isLoaded: true,
+      isLoading: false
+    });
+    this.savePanelState();
+    var {
+      glEventHub,
+      onStateChange
+    } = this.props;
+    glEventHub.emit(IrisGridEvent.STATE_CHANGED, this);
+    onStateChange === null || onStateChange === void 0 ? void 0 : onStateChange(irisGridState, gridState);
+  }
+  handlePluginStateChange(pluginState) {
+    var {
+      irisGridState,
+      gridState
+    } = this;
+    this.pluginState = pluginState;
+    // Do not save if there is null state
+    // The save will happen when the grid loads
+    if (irisGridState !== null && gridState !== null) {
+      this.savePanelState();
+    }
+  }
+  handleColumnsChanged(event) {
+    var {
+      isModelReady,
+      model,
+      modelQueue
+    } = this.state;
+    if (isModelReady) {
+      this.sendColumnsChange(event.detail);
+    } else {
+      assertNotNull(model);
+      this.initModelQueue(model, modelQueue);
+    }
+  }
+  handleTableChanged(event) {
+    log.debug('handleTableChanged', event);
+    var {
+      glEventHub
+    } = this.props;
+    var {
+      detail: table
+    } = event;
+    glEventHub.emit(InputFilterEvent.TABLE_CHANGED, this, table);
+  }
+  handlePartitionAppend(column, value) {
+    var {
+      glEventHub
+    } = this.props;
+    var {
+      name
+    } = column;
+    var tableName = this.getTableName();
+    var command = "".concat(tableName, " = ").concat(tableName, ".where(\"").concat(name, "=`").concat(value, "`\")");
+    glEventHub.emit(ConsoleEvent.SEND_COMMAND, command, false, true);
+  }
+
+  /**
+   * Create a chart with the specified settings
+   * @param settings The settings from the chart builder
+   * @param settings.type The settings from the chart builder
+   * @param settings.series The names of the series
+   * @param model The IrisGridModel object
+   */
+  handleCreateChart(settings, model) {
+    // Panel state is stored with the created chart, so flush it first
+    this.savePanelState.flush();
+    this.setState(() => null, () => {
+      var {
+        glEventHub,
+        inputFilters,
+        metadata
+      } = this.props;
+      var {
+        table
+      } = metadata;
+      var {
+        panelState
+      } = this.state;
+      var sourcePanelId = LayoutUtils.getIdFromPanel(this);
+      var tableSettings;
+      if (panelState) {
+        tableSettings = IrisGridUtils.extractTableSettings(panelState, inputFilters);
+      }
+      glEventHub.emit(IrisGridEvent.CREATE_CHART, {
+        metadata: {
+          settings,
+          sourcePanelId,
+          table,
+          tableSettings
+        },
+        table: isIrisGridTableModelTemplate(model) ? model.table : undefined
+      });
+    });
+  }
+  handleColumnSelected(column) {
+    var {
+      glEventHub
+    } = this.props;
+    glEventHub.emit(IrisGridEvent.COLUMN_SELECTED, this, column);
+  }
+  handleDataSelected(row, dataMap) {
+    var {
+      glEventHub
+    } = this.props;
+    glEventHub.emit(IrisGridEvent.DATA_SELECTED, this, dataMap);
+  }
+  handleResize() {
+    this.updateGrid();
+  }
+  handleShow() {
+    this.updateGrid();
+  }
+  handleTabClicked() {
+    if (this.irisGrid.current) {
+      this.irisGrid.current.focus();
+    }
+  }
+  handleError(error) {
+    log.error(error);
+    this.setState({
+      error,
+      isLoading: false
+    });
+  }
+  handleDisconnect() {
+    this.setState({
+      error: new Error('Table disconnected'),
+      isDisconnected: true,
+      isLoading: false
+    });
+  }
+  handleReconnect() {
+    this.setState({
+      isDisconnected: false,
+      error: null
+    });
+  }
+  handleLoadError(error) {
+    if (PromiseUtils.isCanceled(error)) {
+      return;
+    }
+    this.handleError(error);
+  }
+  modelInitialized(model) {
+    var {
+      glEventHub,
+      loadPlugin
+    } = this.props;
+    this.modelPromise = undefined;
+
+    // Custom columns at this point already initialized, can load state
+    this.loadPanelState(model);
+    this.setState({
+      isModelReady: true
+    });
+    if (isIrisGridTableModelTemplate(model)) {
+      var {
+        table
+      } = model;
+      var {
+        pluginName: _pluginName
+      } = table;
+      if (_pluginName !== '') {
+        if (loadPlugin != null && _pluginName != null) {
+          var _Plugin = loadPlugin(_pluginName);
+          this.setState({
+            Plugin: _Plugin
+          });
+        }
+      }
+      glEventHub.emit(InputFilterEvent.TABLE_CHANGED, this, table);
+    }
+    this.sendColumnsChange(model.columns);
+  }
+  handleClearAllFilters() {
+    var irisGrid = this.irisGrid.current;
+    var {
+      isDisconnected
+    } = this.state;
+    if (irisGrid != null && !isDisconnected) {
+      irisGrid.clearAllFilters();
+    }
+  }
+  sendColumnsChange(columns) {
+    log.debug2('sendColumnsChange', columns);
+    var {
+      glEventHub
+    } = this.props;
+    glEventHub.emit(InputFilterEvent.COLUMNS_CHANGED, this, columns);
+  }
+  startModelListening(model) {
+    model.addEventListener(IrisGridModel.EVENT.DISCONNECT, this.handleDisconnect);
+    model.addEventListener(IrisGridModel.EVENT.RECONNECT, this.handleReconnect);
+    model.addEventListener(IrisGridModel.EVENT.COLUMNS_CHANGED, this.handleColumnsChanged);
+    model.addEventListener(IrisGridModel.EVENT.TABLE_CHANGED, this.handleTableChanged);
+  }
+  stopModelListening(model) {
+    model.removeEventListener(IrisGridModel.EVENT.DISCONNECT, this.handleDisconnect);
+    model.removeEventListener(IrisGridModel.EVENT.RECONNECT, this.handleReconnect);
+    model.removeEventListener(IrisGridModel.EVENT.COLUMNS_CHANGED, this.handleColumnsChanged);
+    model.removeEventListener(IrisGridModel.EVENT.TABLE_CHANGED, this.handleTableChanged);
+  }
+  getCoordinateForColumn(columnName) {
+    var _gridWrapper$getBound, _allColumnXs$get, _allColumnWidths$get;
+    var {
+      model
+    } = this.state;
+    if (!model) {
+      return null;
+    }
+    var irisGrid = this.irisGrid.current;
+    var {
+      gridWrapper
+    } = irisGrid || {};
+    var rect = (_gridWrapper$getBound = gridWrapper === null || gridWrapper === void 0 ? void 0 : gridWrapper.getBoundingClientRect()) !== null && _gridWrapper$getBound !== void 0 ? _gridWrapper$getBound : null;
+    if (rect == null || rect.width <= 0 || rect.height <= 0) {
+      return null;
+    }
+    assertNotNull(irisGrid);
+    var {
+      metrics
+    } = irisGrid.state;
+    assertNotNull(metrics);
+    var {
+      columnHeaderHeight,
+      allColumnXs,
+      allColumnWidths,
+      right,
+      columnHeaderMaxDepth
+    } = metrics;
+    var columnIndex = model.getColumnIndexByName(columnName);
+    assertNotNull(columnIndex);
+    var visibleIndex = irisGrid.getVisibleColumn(columnIndex);
+    var columnX = (_allColumnXs$get = allColumnXs.get(visibleIndex)) !== null && _allColumnXs$get !== void 0 ? _allColumnXs$get : 0;
+    var columnWidth = (_allColumnWidths$get = allColumnWidths.get(visibleIndex)) !== null && _allColumnWidths$get !== void 0 ? _allColumnWidths$get : 0;
+    var x = Math.max(rect.left, Math.min(visibleIndex > right ? rect.right : rect.left + columnX + columnWidth * 0.5, rect.right));
+    var y = rect.top + columnHeaderHeight * columnHeaderMaxDepth;
+    return [x, y];
+  }
+  setFilterMap(filterMap) {
+    var irisGrid = this.irisGrid.current;
+    if (irisGrid != null) {
+      irisGrid.setFilterMap(filterMap);
+    }
+  }
+  setAdvancedFilterMap(filterMap) {
+    var irisGrid = this.irisGrid.current;
+    if (irisGrid != null) {
+      irisGrid.setAdvancedFilterMap(filterMap);
+    }
+  }
+  setFilters(_ref3) {
+    var {
+      quickFilters,
+      advancedFilters
+    } = _ref3;
+    log.debug('setFilters', quickFilters, advancedFilters);
+    var {
+      model,
+      isDisconnected
+    } = this.state;
+    var irisGrid = this.irisGrid.current;
+    if (irisGrid == null || isDisconnected) {
+      log.debug('Ignore setFilters, model disconnected');
+      return;
+    }
+    assertNotNull(model);
+    var {
+      columns,
+      formatter
+    } = model;
+    var indexedQuickFilters = IrisGridUtils.changeFilterColumnNamesToIndexes(model.columns, quickFilters).filter(_ref4 => {
+      var [columnIndex] = _ref4;
+      return model.isFilterable(columnIndex);
+    });
+    var indexedAdvancedFilters = IrisGridUtils.changeFilterColumnNamesToIndexes(model.columns, advancedFilters).filter(_ref5 => {
+      var [columnIndex] = _ref5;
+      return model.isFilterable(columnIndex);
+    });
+    assertNotNull(this.irisGridUtils);
+    irisGrid.clearAllFilters();
+    irisGrid.setFilters({
+      quickFilters: this.irisGridUtils.hydrateQuickFilters(columns, indexedQuickFilters, formatter.timeZone),
+      advancedFilters: this.irisGridUtils.hydrateAdvancedFilters(columns, indexedAdvancedFilters, formatter.timeZone)
+    });
+  }
+  setStateOverrides(overrides) {
+    log.debug('setStateOverrides', overrides);
+    var {
+      irisGridState: irisGridStateOverrides,
+      gridState: gridStateOverrides
+    } = overrides;
+    this.setState({
+      irisGridStateOverrides,
+      gridStateOverrides
+    }, () => {
+      this.initModel();
+    });
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  unsetFilterValue() {
+    // IrisGridPanel retains the set value after the link is broken
+  }
+  loadPanelState(model) {
+    var {
+      panelState,
+      irisGridStateOverrides: originalIrisGridStateOverrides,
+      gridStateOverrides
+    } = this.state;
+    if (panelState == null) {
+      return;
+    }
+    try {
+      var {
+        gridState: _gridState,
+        irisGridState: _irisGridState2,
+        irisGridPanelState
+      } = panelState;
+      var irisGridStateOverrides = _objectSpread({}, originalIrisGridStateOverrides);
+      var {
+        quickFilters: savedQuickFilters,
+        advancedFilters: savedAdvancedFilters
+      } = irisGridStateOverrides;
+      if (savedQuickFilters) {
+        irisGridStateOverrides.quickFilters = IrisGridUtils.changeFilterColumnNamesToIndexes(model.columns, savedQuickFilters);
+      }
+      if (savedAdvancedFilters) {
+        irisGridStateOverrides.advancedFilters = IrisGridUtils.changeFilterColumnNamesToIndexes(model.columns, savedAdvancedFilters);
+      }
+      var {
+        isSelectingPartition,
+        partition,
+        partitionColumn,
+        advancedSettings
+      } = IrisGridUtils.hydrateIrisGridPanelState(model, irisGridPanelState);
+      assertNotNull(this.irisGridUtils);
+      var {
+        advancedFilters,
+        customColumns,
+        customColumnFormatMap,
+        isFilterBarShown,
+        quickFilters,
+        reverseType,
+        rollupConfig,
+        aggregationSettings,
+        sorts,
+        userColumnWidths,
+        userRowHeights,
+        showSearchBar,
+        searchValue,
+        selectDistinctColumns,
+        selectedSearchColumns,
+        invertSearchColumns,
+        pendingDataMap,
+        frozenColumns,
+        conditionalFormats,
+        columnHeaderGroups
+      } = this.irisGridUtils.hydrateIrisGridState(model, _objectSpread(_objectSpread({}, _irisGridState2), irisGridStateOverrides));
+      var {
+        isStuckToBottom,
+        isStuckToRight,
+        movedColumns,
+        movedRows
+      } = IrisGridUtils.hydrateGridState(model, _objectSpread(_objectSpread({}, _gridState), gridStateOverrides), _irisGridState2.customColumns);
+      this.setState({
+        advancedFilters,
+        advancedSettings,
+        conditionalFormats,
+        customColumns,
+        customColumnFormatMap,
+        isFilterBarShown,
+        isSelectingPartition,
+        movedColumns,
+        movedRows,
+        partition,
+        partitionColumn,
+        quickFilters,
+        reverseType,
+        rollupConfig,
+        aggregationSettings,
+        sorts,
+        userColumnWidths,
+        userRowHeights,
+        showSearchBar,
+        searchValue,
+        selectDistinctColumns,
+        selectedSearchColumns,
+        invertSearchColumns,
+        pendingDataMap,
+        frozenColumns,
+        isStuckToBottom,
+        isStuckToRight,
+        columnHeaderGroups
+      });
+    } catch (error) {
+      log.error('loadPanelState failed to load panelState', panelState, error);
+    }
+  }
+  updateGrid() {
+    var _this$irisGrid$curren, _this$irisGrid$curren2;
+    var grid = (_this$irisGrid$curren = (_this$irisGrid$curren2 = this.irisGrid.current) === null || _this$irisGrid$curren2 === void 0 ? void 0 : _this$irisGrid$curren2.grid) !== null && _this$irisGrid$curren !== void 0 ? _this$irisGrid$curren : null;
+    if (!grid) return;
+
+    // handle resize will verify state and draw and update
+    grid.handleResize();
+  }
+  render() {
+    var _model$description, _panelState$pluginSta;
+    var {
+      children,
+      glContainer,
+      glEventHub,
+      columnSelectionValidator,
+      getDownloadWorker,
+      inputFilters,
+      links,
+      metadata,
+      panelState,
+      user,
+      workspace,
+      settings,
+      theme
+    } = this.props;
+    var {
+      advancedFilters,
+      aggregationSettings,
+      advancedSettings,
+      conditionalFormats,
+      customColumns,
+      customColumnFormatMap,
+      error,
+      isDisconnected,
+      isFilterBarShown,
+      isSelectingPartition,
+      isStuckToBottom,
+      isStuckToRight,
+      isLoaded,
+      isLoading,
+      isModelReady,
+      model,
+      movedColumns,
+      movedRows,
+      partition,
+      partitionColumn,
+      quickFilters,
+      reverseType,
+      rollupConfig,
+      sorts,
+      userColumnWidths,
+      userRowHeights,
+      showSearchBar,
+      searchValue,
+      selectDistinctColumns,
+      selectedSearchColumns,
+      invertSearchColumns,
+      Plugin,
+      pluginFilters,
+      pluginFetchColumns,
+      pendingDataMap,
+      frozenColumns,
+      columnHeaderGroups
+    } = this.state;
+    var errorMessage = error != null ? "Unable to open table. ".concat(error) : undefined;
+    var {
+      table: name
+    } = metadata;
+    var description = (_model$description = model === null || model === void 0 ? void 0 : model.description) !== null && _model$description !== void 0 ? _model$description : undefined;
+    var pluginState = (_panelState$pluginSta = panelState === null || panelState === void 0 ? void 0 : panelState.pluginState) !== null && _panelState$pluginSta !== void 0 ? _panelState$pluginSta : null;
+    var childrenContent = children !== null && children !== void 0 ? children : this.getPluginContent(Plugin, model, user, workspace, pluginState);
+    var {
+      permissions
+    } = user;
+    var {
+      canCopy,
+      canDownloadCsv
+    } = permissions;
+    return /*#__PURE__*/React.createElement(WidgetPanel, {
+      errorMessage: errorMessage,
+      isDisconnected: isDisconnected,
+      isLoading: isLoading,
+      isLoaded: isLoaded,
+      className: "iris-grid-panel",
+      glContainer: glContainer,
+      glEventHub: glEventHub,
+      onClearAllFilters: this.handleClearAllFilters,
+      onResize: this.handleResize,
+      onShow: this.handleShow,
+      onTabFocus: this.handleShow,
+      onTabClicked: this.handleTabClicked,
+      widgetName: name,
+      widgetType: "Table",
+      description: description,
+      componentPanel: this,
+      renderTabTooltip: () => /*#__PURE__*/React.createElement(IrisGridPanelTooltip, {
+        model: model,
+        widgetName: name,
+        glContainer: glContainer,
+        description: description
+      })
+    }, isModelReady && model && /*#__PURE__*/React.createElement(IrisGrid, {
+      advancedFilters: advancedFilters,
+      aggregationSettings: aggregationSettings,
+      advancedSettings: advancedSettings,
+      alwaysFetchColumns: this.getAlwaysFetchColumns(links, pluginFetchColumns),
+      columnAllowedCursor: "linker",
+      columnNotAllowedCursor: "linker-not-allowed",
+      customColumns: customColumns,
+      customColumnFormatMap: customColumnFormatMap,
+      columnSelectionValidator: this.isColumnSelectionValid,
+      conditionalFormats: conditionalFormats,
+      inputFilters: this.getGridInputFilters(model.columns, inputFilters),
+      applyInputFiltersOnInit: panelState == null,
+      isFilterBarShown: isFilterBarShown,
+      isSelectingColumn: columnSelectionValidator != null,
+      isSelectingPartition: isSelectingPartition,
+      isStuckToBottom: isStuckToBottom,
+      isStuckToRight: isStuckToRight,
+      movedColumns: movedColumns,
+      movedRows: movedRows,
+      partition: partition,
+      partitionColumn: partitionColumn,
+      quickFilters: quickFilters,
+      reverseType: reverseType,
+      rollupConfig: rollupConfig,
+      settings: settings,
+      sorts: sorts,
+      userColumnWidths: userColumnWidths,
+      userRowHeights: userRowHeights,
+      model: model,
+      showSearchBar: showSearchBar,
+      searchValue: searchValue,
+      selectedSearchColumns: selectedSearchColumns,
+      selectDistinctColumns: selectDistinctColumns,
+      invertSearchColumns: invertSearchColumns,
+      onColumnSelected: this.handleColumnSelected,
+      onCreateChart: this.handleCreateChart,
+      onDataSelected: this.handleDataSelected,
+      onError: this.handleError,
+      onPartitionAppend: this.handlePartitionAppend,
+      onStateChange: this.handleGridStateChange,
+      onContextMenu: this.handleContextMenu,
+      onAdvancedSettingsChange: this.handleAdvancedSettingsChange,
+      customFilters: pluginFilters,
+      pendingDataMap: pendingDataMap,
+      canCopy: canCopy,
+      canDownloadCsv: canDownloadCsv,
+      ref: this.irisGrid,
+      getDownloadWorker: getDownloadWorker,
+      frozenColumns: frozenColumns,
+      theme: theme,
+      columnHeaderGroups: columnHeaderGroups
+    }, childrenContent));
+  }
+}
+_defineProperty(IrisGridPanel, "defaultProps", {
+  onStateChange: () => undefined,
+  onPanelStateUpdate: () => undefined
+});
+_defineProperty(IrisGridPanel, "displayName", 'IrisGridPanel');
+_defineProperty(IrisGridPanel, "COMPONENT", 'IrisGridPanel');
+var mapStateToProps = (state, _ref6) => {
+  var {
+    localDashboardId = DEFAULT_DASHBOARD_ID
+  } = _ref6;
+  return {
+    inputFilters: getInputFiltersForDashboard(state, localDashboardId),
+    links: getLinksForDashboard(state, localDashboardId),
+    columnSelectionValidator: getColumnSelectionValidatorForDashboard(state, localDashboardId),
+    user: getUser(state),
+    workspace: getWorkspace(state),
+    settings: getSettings(state)
+  };
+};
+var ConnectedIrisGridPanel = connect(mapStateToProps, null, null, {
+  forwardRef: true
+})(IrisGridPanel);
+export default ConnectedIrisGridPanel;
+//# sourceMappingURL=IrisGridPanel.js.map