@deephaven/dashboard-core-plugins 0.43.0 → 0.44.1-beta.0

package/dist/panels/DropdownFilterPanel.js

@@ -0,0 +1,685 @@
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+import React, { Component } from 'react';
+import { connect } from 'react-redux';
+import debounce from 'lodash.debounce';
+import deepEqual from 'deep-equal';
+import memoize from 'memoizee';
+import { LayoutUtils } from '@deephaven/dashboard';
+import { DateTimeColumnFormatter, Formatter, FormatterUtils, TableUtils } from '@deephaven/jsapi-utils';
+import Log from '@deephaven/log';
+import { getActiveTool, getApi, getSettings } from '@deephaven/redux';
+import { Pending, PromiseUtils } from '@deephaven/utils';
+import DropdownFilter from "../controls/dropdown-filter/DropdownFilter.js";
+import { InputFilterEvent } from "../events/index.js";
+import { getColumnsForDashboard, getColumnSelectionValidatorForDashboard, getIsolatedLinkerPanelIdForDashboard, getLinksForDashboard, getTableMapForDashboard } from "../redux/index.js";
+import "./DropdownFilterPanel.css";
+import ToolType from "../linker/ToolType.js";
+import WidgetPanel from "./WidgetPanel.js";
+var log = Log.module('DropdownFilterPanel');
+var DROPDOWN_FILTER_DEBOUNCE = 250;
+var mapStateToProps = (state, ownProps) => {
+  var {
+    localDashboardId
+  } = ownProps;
+  var panelId = LayoutUtils.getIdFromPanel({
+    props: ownProps
+  });
+  var panelTableMap = getTableMapForDashboard(state, localDashboardId);
+  var dashboardLinks = getLinksForDashboard(state, localDashboardId);
+  var activeTool = getActiveTool(state);
+  var isolatedLinkerPanelId = getIsolatedLinkerPanelIdForDashboard(state, localDashboardId);
+  var isLinkerActive = activeTool === ToolType.LINKER && (isolatedLinkerPanelId === undefined || isolatedLinkerPanelId === panelId);
+  // Disable linking if linker is in isolated mode for a different panel
+  var disableLinking = activeTool === ToolType.LINKER && isolatedLinkerPanelId !== undefined && isolatedLinkerPanelId !== panelId;
+  return {
+    columns: getColumnsForDashboard(state, localDashboardId),
+    columnSelectionValidator: getColumnSelectionValidatorForDashboard(state, localDashboardId),
+    dh: getApi(state),
+    isLinkerActive,
+    disableLinking,
+    settings: getSettings(state),
+    panelTableMap,
+    dashboardLinks
+  };
+};
+var connector = connect(mapStateToProps, null, null, {
+  forwardRef: true
+});
+export class DropdownFilterPanel extends Component {
+  constructor(props) {
+    super(props);
+    _defineProperty(this, "dateTimeFormatter", void 0);
+    _defineProperty(this, "dropdownFilterRef", void 0);
+    _defineProperty(this, "panelContainer", void 0);
+    _defineProperty(this, "pending", void 0);
+    _defineProperty(this, "cleanup", void 0);
+    _defineProperty(this, "columnFormats", void 0);
+    _defineProperty(this, "getCachedValues", memoize((rawValues, _ref, formatter) => {
+      var {
+        type,
+        name
+      } = _ref;
+      if (type !== undefined && TableUtils.isDateType(type)) {
+        return rawValues.map(value => this.dateTimeFormatter.format(value));
+      }
+      return rawValues.map(value =>
+      // Skip formatting for nulls so they don't get converted to ''
+      value != null && type != null ? formatter.getFormattedString(value, type, name) : null);
+    }));
+    _defineProperty(this, "getCachedPanelLinks", memoize((dashboardLinks, panel) => {
+      var panelId = LayoutUtils.getIdFromPanel(panel);
+      log.debug('getCachedPanelLinks', dashboardLinks, panelId);
+      return dashboardLinks.filter(link => {
+        var _link$end;
+        return ((_link$end = link.end) === null || _link$end === void 0 ? void 0 : _link$end.panelId) === panelId;
+      });
+    }));
+    _defineProperty(this, "getCachedSource", memoize(links => {
+      log.debug('getCachedSource', links);
+      var source;
+      if (links.length > 0) {
+        var [link] = links;
+        source = link.start;
+        if (links.length > 1) {
+          log.error('Filter has more that one link', links);
+        }
+      }
+      return source;
+    }));
+    _defineProperty(this, "getCachedSourceTable", memoize((panelTableMap, source) => {
+      var _panelTableMap$get;
+      log.debug('getCachedSourceTable', panelTableMap, source);
+      if (source == null) {
+        return null;
+      }
+      var {
+        panelId
+      } = source;
+      return (_panelTableMap$get = panelTableMap.get(panelId)) !== null && _panelTableMap$get !== void 0 ? _panelTableMap$get : null;
+    }));
+    _defineProperty(this, "getCachedSourceColumn", memoize((table, source) => {
+      var _table$columns$find;
+      log.debug('getCachedSourceColumn', table, source);
+      if (table == null || source == null) {
+        return null;
+      }
+      return (_table$columns$find = table.columns.find(_ref2 => {
+        var {
+          name,
+          type
+        } = _ref2;
+        return name === source.columnName && type === source.columnType;
+      })) !== null && _table$columns$find !== void 0 ? _table$columns$find : null;
+    }));
+    this.handleChange = debounce(this.handleChange.bind(this), DROPDOWN_FILTER_DEBOUNCE);
+    this.handleClearAllFilters = this.handleClearAllFilters.bind(this);
+    this.handleDisconnect = this.handleDisconnect.bind(this);
+    this.handleReconnect = this.handleReconnect.bind(this);
+    this.handleColumnSelected = this.handleColumnSelected.bind(this);
+    this.handleSourceFilterChange = this.handleSourceFilterChange.bind(this);
+    this.handleSourceSortChange = this.handleSourceSortChange.bind(this);
+    this.handleSourceSizeChange = this.handleSourceSizeChange.bind(this);
+    this.handleSourceMouseEnter = this.handleSourceMouseEnter.bind(this);
+    this.handleSourceMouseLeave = this.handleSourceMouseLeave.bind(this);
+    this.handleValuesTableUpdate = this.handleValuesTableUpdate.bind(this);
+    this.dropdownFilterRef = /*#__PURE__*/React.createRef();
+    this.panelContainer = /*#__PURE__*/React.createRef();
+    this.pending = new Pending();
+    var {
+      dh,
+      panelState,
+      settings
+    } = props;
+    this.columnFormats = FormatterUtils.getColumnFormats(settings);
+    // Filter dropdown needs to show and send full timestamp format with nanoseconds
+    this.dateTimeFormatter = new DateTimeColumnFormatter(dh, {
+      showTimeZone: false,
+      showTSeparator: true,
+      defaultDateTimeFormatString: "yyyy-MM-dd HH:mm:ss.SSSSSSSSS"
+    });
+    var {
+      value: _value = '',
+      isValueShown = false,
+      name: _name,
+      type: _type,
+      timestamp
+    } = panelState !== null && panelState !== void 0 ? panelState : {};
+    var column = _name != null && _type != null ? {
+      name: _name,
+      type: _type
+    } : undefined;
+    this.state = {
+      column,
+      formatter: new Formatter(dh, this.columnFormats),
+      valuesTable: undefined,
+      valuesColumn: undefined,
+      sourceSize: 0,
+      value: _value,
+      timestamp,
+      values: [],
+      isValueShown,
+      wasFlipped: false,
+      skipUpdate: false,
+      // eslint-disable-next-line react/no-unused-state
+      panelState,
+      // Dehydrated panel state that can load this panel
+
+      isDisconnected: false,
+      isLoading: false,
+      isLoaded: false,
+      error: null
+    };
+  }
+  componentDidMount() {
+    this.updateValuesTable();
+    var {
+      dashboardLinks,
+      panelTableMap
+    } = this.props;
+    var {
+      column,
+      value,
+      timestamp
+    } = this.state;
+    var sourceTable = this.getSourceTable(panelTableMap, dashboardLinks);
+    if (sourceTable !== null) {
+      this.startListeningToSource(sourceTable);
+    }
+    if (column != null) {
+      var {
+        name,
+        type
+      } = column;
+      this.sendUpdate(name, type, value, timestamp);
+    }
+  }
+  componentDidUpdate(prevProps, prevState) {
+    var {
+      dashboardLinks,
+      panelTableMap,
+      settings
+    } = this.props;
+    var {
+      valuesTable
+    } = this.state;
+    var source = this.getSource(dashboardLinks);
+    var sourceTable = this.getSourceTable(panelTableMap, dashboardLinks);
+    var prevSource = this.getSource(prevProps.dashboardLinks);
+    var prevSourceTable = this.getSourceTable(prevProps.panelTableMap, prevProps.dashboardLinks);
+    if (settings !== prevProps.settings && settings !== undefined) {
+      this.updateFormatterSettings(settings);
+    }
+    if (valuesTable !== prevState.valuesTable && prevState.valuesTable != null) {
+      log.debug('Table in state modified, closing the old table.');
+      prevState.valuesTable.close();
+    }
+
+    // Checking source change in addition to table change
+    // in case a different column is selected in the same table
+    if (sourceTable !== prevSourceTable || source !== prevSource) {
+      this.updateValuesTable();
+    }
+    if (sourceTable !== prevSourceTable) {
+      if (prevSourceTable !== null) {
+        this.stopListeningToSource(prevSourceTable);
+      }
+      if (sourceTable !== null) {
+        this.startListeningToSource(sourceTable);
+      }
+    }
+  }
+  componentWillUnmount() {
+    var {
+      dashboardLinks,
+      panelTableMap
+    } = this.props;
+    var {
+      valuesTable
+    } = this.state;
+    var sourceTable = this.getSourceTable(panelTableMap, dashboardLinks);
+    this.pending.cancel();
+    if (sourceTable !== null) {
+      this.stopListeningToSource(sourceTable);
+    }
+    if (this.cleanup) {
+      this.cleanup();
+    }
+    if (valuesTable != null) {
+      valuesTable.close();
+    }
+  }
+  getCoordinateForColumn() {
+    var _element$getBoundingC;
+    if (this.panelContainer.current == null) {
+      return null;
+    }
+    var element = this.panelContainer.current.querySelector(".".concat(DropdownFilter.SOURCE_BUTTON_CLASS_NAME));
+    var rect = (_element$getBoundingC = element === null || element === void 0 ? void 0 : element.getBoundingClientRect()) !== null && _element$getBoundingC !== void 0 ? _element$getBoundingC : null;
+    if (rect == null || rect.width <= 0 || rect.height <= 0) {
+      return null;
+    }
+    var x = rect.left + rect.width / 2;
+    var y = rect.bottom;
+    return [x, y];
+  }
+  getSettingsErrorMessage() {
+    var {
+      sourceSize
+    } = this.state;
+    if (sourceSize > DropdownFilterPanel.MAX_TABLE_SIZE) {
+      return "Table too large, must have fewer than ".concat(DropdownFilterPanel.MAX_TABLE_SIZE, " options.");
+    }
+    return undefined;
+  }
+  getPanelErrorMessage() {
+    var {
+      error
+    } = this.state;
+    return error != null ? "".concat(error) : undefined;
+  }
+  getSource(links) {
+    var panelLinks = this.getCachedPanelLinks(links, this);
+    return this.getCachedSource(panelLinks);
+  }
+  getSourceTable(panelTableMap, links) {
+    var source = this.getSource(links);
+    return this.getCachedSourceTable(panelTableMap, source);
+  }
+  getValuesColumn(valuesTable, links) {
+    var source = this.getSource(links);
+    return this.getCachedSourceColumn(valuesTable, source);
+  }
+  startListeningToSource(sourceTable) {
+    var {
+      dh
+    } = this.props;
+    log.debug('startListeningToSource');
+    sourceTable.addEventListener(dh.Table.EVENT_FILTERCHANGED, this.handleSourceFilterChange);
+    sourceTable.addEventListener(dh.Table.EVENT_SORTCHANGED, this.handleSourceSortChange);
+    sourceTable.addEventListener(dh.Table.EVENT_SIZECHANGED, this.handleSourceSizeChange);
+    sourceTable.addEventListener(dh.Table.EVENT_DISCONNECT, this.handleDisconnect);
+    sourceTable.addEventListener(dh.Table.EVENT_RECONNECT, this.handleReconnect);
+  }
+  stopListeningToSource(sourceTable) {
+    var {
+      dh
+    } = this.props;
+    log.debug('stopListeningToSource');
+    sourceTable.removeEventListener(dh.Table.EVENT_FILTERCHANGED, this.handleSourceFilterChange);
+    sourceTable.removeEventListener(dh.Table.EVENT_SORTCHANGED, this.handleSourceSortChange);
+    sourceTable.removeEventListener(dh.Table.EVENT_SIZECHANGED, this.handleSourceSizeChange);
+    sourceTable.removeEventListener(dh.Table.EVENT_DISCONNECT, this.handleDisconnect);
+    sourceTable.removeEventListener(dh.Table.EVENT_RECONNECT, this.handleReconnect);
+  }
+  handleChange(_ref3) {
+    var {
+      column,
+      isValueShown = false,
+      value
+    } = _ref3;
+    var {
+      name = undefined,
+      type = undefined
+    } = column !== null && column !== void 0 ? column : {};
+    var sendUpdate = true;
+    var timestamp = Date.now();
+    this.setState(_ref4 => {
+      var _ref5, _timestamp;
+      var {
+        panelState,
+        timestamp: prevTimestamp,
+        wasFlipped,
+        skipUpdate
+      } = _ref4;
+      // If the user had a value set, and they flip the card over and flip it back without changing any settings, ignore it
+      var isFlip = panelState != null && isValueShown !== panelState.isValueShown && name === panelState.name && type === panelState.type && value === panelState.value;
+      sendUpdate = (_ref5 = !skipUpdate && isValueShown && (!isFlip || !wasFlipped)) !== null && _ref5 !== void 0 ? _ref5 : false;
+      if (!sendUpdate) {
+        timestamp = prevTimestamp;
+      }
+      return {
+        panelState: {
+          isValueShown,
+          name,
+          type,
+          value,
+          timestamp: (_timestamp = timestamp) !== null && _timestamp !== void 0 ? _timestamp : undefined
+        },
+        timestamp,
+        wasFlipped: isFlip,
+        skipUpdate: false
+      };
+    }, () => {
+      if (sendUpdate) {
+        this.sendUpdate(name !== null && name !== void 0 ? name : null, type, value, timestamp);
+      }
+    });
+  }
+  handleDisconnect() {
+    this.setState({
+      error: new Error('Table disconnected'),
+      isDisconnected: true,
+      isLoading: false
+    });
+  }
+  handleReconnect() {
+    this.setState({
+      isDisconnected: false,
+      error: null
+    });
+  }
+  handleSourceFilterChange() {
+    this.applySourceFilters();
+  }
+  handleSourceSortChange() {
+    this.applySourceSorts();
+  }
+  handleSourceSizeChange(_ref6) {
+    var {
+      detail
+    } = _ref6;
+    this.setState({
+      sourceSize: detail
+    });
+  }
+  handleColumnSelected() {
+    log.debug('handleColumnSelected');
+    var {
+      glEventHub
+    } = this.props;
+    glEventHub.emit(InputFilterEvent.COLUMN_SELECTED, this, DropdownFilterPanel.SOURCE_COLUMN);
+  }
+  handleClearAllFilters() {
+    var _this$dropdownFilterR, _this$dropdownFilterR2;
+    (_this$dropdownFilterR = this.dropdownFilterRef) === null || _this$dropdownFilterR === void 0 ? void 0 : (_this$dropdownFilterR2 = _this$dropdownFilterR.current) === null || _this$dropdownFilterR2 === void 0 ? void 0 : _this$dropdownFilterR2.clearFilter();
+  }
+
+  /**
+   * Set the filter value, card side, selected column
+   * @param state Filter state to set
+   * @param sendUpdate Emit filters changed event if true
+   */
+  setPanelState(state) {
+    var _this$dropdownFilterR3, _this$dropdownFilterR4;
+    var sendUpdate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    var {
+      dashboardLinks
+    } = this.props;
+    if (this.getSource(dashboardLinks) == null) {
+      log.debug('Ignore state update for unlinked filter', state);
+      return;
+    }
+    // Set the skipUpdate flag so the next onChange handler call doesn't emit the FILTERS_CHANGED event
+    this.setState({
+      skipUpdate: !sendUpdate
+    });
+
+    // Changing the inputFilter state via props doesn't quite work because of the delays on manual input changes
+    // Setting the ref state directly triggers the onChange handler and updates the panelState
+    (_this$dropdownFilterR3 = this.dropdownFilterRef) === null || _this$dropdownFilterR3 === void 0 ? void 0 : (_this$dropdownFilterR4 = _this$dropdownFilterR3.current) === null || _this$dropdownFilterR4 === void 0 ? void 0 : _this$dropdownFilterR4.setFilterState(state);
+  }
+  sendUpdate(name, type, value, timestamp) {
+    var _this$getSource;
+    var {
+      dashboardLinks,
+      glEventHub
+    } = this.props;
+    var sourcePanelId = (_this$getSource = this.getSource(dashboardLinks)) === null || _this$getSource === void 0 ? void 0 : _this$getSource.panelId;
+    var excludePanelIds = sourcePanelId === null ? [] : [sourcePanelId];
+    log.debug('sendUpdate', {
+      name,
+      type,
+      value,
+      timestamp,
+      excludePanelIds
+    });
+    glEventHub.emit(InputFilterEvent.FILTERS_CHANGED, this, {
+      name,
+      type,
+      value: value != null ? value : '=null',
+      timestamp,
+      excludePanelIds
+    });
+  }
+  updateValuesTable() {
+    var {
+      dashboardLinks,
+      panelTableMap
+    } = this.props;
+    var source = this.getSource(dashboardLinks);
+    var sourceTable = this.getSourceTable(panelTableMap, dashboardLinks);
+    log.debug('updateValuesTable', source, sourceTable);
+    this.setState({
+      values: [],
+      valuesTable: undefined,
+      error: null
+    });
+    if (source == null) {
+      log.debug('Filter unlinked.');
+      this.setState({
+        isLoading: false,
+        isLoaded: true,
+        isValueShown: false,
+        sourceSize: 0
+      });
+      return;
+    }
+    this.setState({
+      isLoading: true
+    });
+    if (sourceTable == null) {
+      return;
+    }
+    this.setState({
+      isLoaded: false,
+      sourceSize: sourceTable.size
+    });
+    this.pending.add(sourceTable.copy(), resolved => resolved.close()).then(valuesTable => {
+      // Loading/loaded will be set when values array is actually populated
+      this.updateViewportListener(valuesTable);
+      this.setState({
+        valuesTable
+      });
+    }).catch(error => {
+      if (PromiseUtils.isCanceled(error)) {
+        return;
+      }
+      log.error(error);
+      this.setState({
+        isLoading: false,
+        error
+      });
+    });
+  }
+  applySourceSorts() {
+    var {
+      dashboardLinks,
+      panelTableMap
+    } = this.props;
+    var {
+      valuesTable
+    } = this.state;
+    var sourceTable = this.getSourceTable(panelTableMap, dashboardLinks);
+    log.debug('applySourceSorts', sourceTable === null || sourceTable === void 0 ? void 0 : sourceTable.sort);
+    if (valuesTable == null || sourceTable == null) {
+      log.debug('Table not initialized');
+      return;
+    }
+    var sorts = [...sourceTable.sort];
+    valuesTable.applySort(sorts);
+    this.setViewport(valuesTable);
+  }
+  applySourceFilters() {
+    var {
+      dashboardLinks,
+      panelTableMap
+    } = this.props;
+    var {
+      valuesTable
+    } = this.state;
+    var sourceTable = this.getSourceTable(panelTableMap, dashboardLinks);
+    log.debug('applySourceFilters', sourceTable === null || sourceTable === void 0 ? void 0 : sourceTable.filter);
+    if (valuesTable == null || sourceTable == null) {
+      log.debug('Table not initialized');
+      return;
+    }
+    var filters = [...sourceTable.filter];
+    valuesTable.applyFilter(filters);
+    this.setViewport(valuesTable);
+  }
+  updateViewportListener(valuesTable) {
+    var {
+      dh
+    } = this.props;
+    log.debug('updateViewportListener', valuesTable === null || valuesTable === void 0 ? void 0 : valuesTable.size);
+    if (this.cleanup) {
+      this.cleanup();
+    }
+    if (valuesTable == null) {
+      this.cleanup = undefined;
+      return;
+    }
+    this.cleanup = valuesTable.addEventListener(dh.Table.EVENT_UPDATED, this.handleValuesTableUpdate);
+    this.setViewport(valuesTable);
+  }
+  setViewport(valuesTable) {
+    var {
+      dashboardLinks
+    } = this.props;
+    var valuesColumn = this.getValuesColumn(valuesTable, dashboardLinks);
+    if (!valuesColumn) {
+      log.error('values column is null');
+      return;
+    }
+    valuesTable.setViewport(0, DropdownFilterPanel.MAX_TABLE_SIZE - 1, [valuesColumn]);
+  }
+  updateFormatterSettings(settings) {
+    var {
+      dh
+    } = this.props;
+    var columnFormats = FormatterUtils.getColumnFormats(settings);
+    if (!deepEqual(this.columnFormats, columnFormats)) {
+      this.columnFormats = columnFormats;
+      this.setState({
+        formatter: new Formatter(dh, columnFormats)
+      });
+    }
+  }
+  handleValuesTableUpdate(_ref7) {
+    var {
+      detail
+    } = _ref7;
+    var {
+      rows
+    } = detail;
+    var {
+      dashboardLinks
+    } = this.props;
+    var {
+      valuesTable
+    } = this.state;
+    if (!valuesTable) {
+      log.error('valuesTable is null');
+      return;
+    }
+    var valuesColumn = this.getValuesColumn(valuesTable, dashboardLinks);
+    if (!valuesColumn) {
+      log.error('Values column not found');
+      return;
+    }
+    var values = rows.map(row => row.get(valuesColumn));
+    this.setState({
+      values,
+      isLoading: false,
+      isLoaded: true,
+      valuesColumn
+    });
+  }
+  handleSourceMouseEnter() {
+    var {
+      columnSelectionValidator
+    } = this.props;
+    if (!columnSelectionValidator) {
+      return;
+    }
+    columnSelectionValidator(this, DropdownFilterPanel.SOURCE_COLUMN);
+  }
+  handleSourceMouseLeave() {
+    var {
+      columnSelectionValidator
+    } = this.props;
+    if (!columnSelectionValidator) {
+      return;
+    }
+    columnSelectionValidator(this, undefined);
+  }
+  render() {
+    var {
+      columns,
+      dashboardLinks,
+      disableLinking,
+      glContainer,
+      glEventHub,
+      isLinkerActive
+    } = this.props;
+    var {
+      column,
+      formatter,
+      isDisconnected,
+      isValueShown,
+      value,
+      values,
+      valuesColumn,
+      isLoading,
+      isLoaded
+    } = this.state;
+    var source = this.getSource(dashboardLinks);
+    var settingsErrorMessage = this.getSettingsErrorMessage();
+    var panelErrorMessage = this.getPanelErrorMessage();
+    var formattedValues = isLoaded && valuesColumn != null ? this.getCachedValues(values, valuesColumn, formatter) : [];
+    return /*#__PURE__*/React.createElement(WidgetPanel, {
+      errorMessage: panelErrorMessage,
+      isLoading: isLoading,
+      isLoaded: isLoaded,
+      isDisconnected: isDisconnected,
+      className: "iris-dropdown-filter-panel",
+      componentPanel: this,
+      glContainer: glContainer,
+      glEventHub: glEventHub,
+      onClearAllFilters: this.handleClearAllFilters,
+      widgetName: "Dropdown Filter",
+      widgetType: "DropdownFilter"
+    }, /*#__PURE__*/React.createElement("div", {
+      ref: this.panelContainer,
+      className: "dropdown-filter-container h-100 w-100 container"
+    }, /*#__PURE__*/React.createElement(DropdownFilter, {
+      ref: this.dropdownFilterRef,
+      column: column,
+      columns: columns,
+      isValueShown: isValueShown,
+      isLinkerActive: isLinkerActive,
+      disableLinking: disableLinking,
+      isLoaded: isLoaded,
+      settingsError: settingsErrorMessage,
+      source: source,
+      value: value,
+      values: formattedValues,
+      onChange: this.handleChange,
+      onColumnSelected: this.handleColumnSelected,
+      onSourceMouseEnter: this.handleSourceMouseEnter,
+      onSourceMouseLeave: this.handleSourceMouseLeave
+    })));
+  }
+}
+_defineProperty(DropdownFilterPanel, "displayName", 'DropdownFilterPanel');
+_defineProperty(DropdownFilterPanel, "COMPONENT", 'DropdownFilterPanel');
+_defineProperty(DropdownFilterPanel, "MAX_TABLE_SIZE", 256);
+_defineProperty(DropdownFilterPanel, "SOURCE_COLUMN", Object.freeze({
+  name: 'FilterSource',
+  type: null
+}));
+var ConnectedDropdownFilterPanel = connector(DropdownFilterPanel);
+export default ConnectedDropdownFilterPanel;
+//# sourceMappingURL=DropdownFilterPanel.js.map