@deephaven/dashboard-core-plugins 0.5.2-matplotlib.3 → 0.6.1-demo.10

package/dist/linker/Linker.js

@@ -1,41 +1,7 @@
-function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
-function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
-
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-
-function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
 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; }
 
 import React, { Component } from 'react';
@@ -49,21 +15,19 @@ import { DateUtils, TableUtils } from '@deephaven/iris-grid';
 import { DateTimeColumnFormatter } from '@deephaven/iris-grid/dist/formatters';
 import Log from '@deephaven/log';
 import { getActiveTool, getTimeZone, setActiveTool as setActiveToolAction } from '@deephaven/redux';
-import { getIsolatedLinkerPanelIdForDashboard, getLinksForDashboard, setDashboardLinks as setDashboardLinksAction, addDashboardLinks as addDashboardLinksAction, deleteDashboardLinks as deleteDashboardLinksAction, setDashboardIsolatedLinkerPanelId as setDashboardIsolatedLinkerPanelIdAction, setDashboardColumnSelectionValidator as setDashboardColumnSelectionValidatorAction } from '../redux';
-import ToolType from './ToolType';
-import { ChartEvent, IrisGridEvent, InputFilterEvent } from '../events';
-import LinkerOverlayContent from './LinkerOverlayContent';
-import LinkerUtils, { isLinkablePanel } from './LinkerUtils';
+import { getIsolatedLinkerPanelIdForDashboard, getLinksForDashboard, setDashboardLinks as setDashboardLinksAction, addDashboardLinks as addDashboardLinksAction, deleteDashboardLinks as deleteDashboardLinksAction, setDashboardIsolatedLinkerPanelId as setDashboardIsolatedLinkerPanelIdAction, setDashboardColumnSelectionValidator as setDashboardColumnSelectionValidatorAction } from "../redux/index.js";
+import ToolType from "./ToolType.js";
+import { ChartEvent, IrisGridEvent, InputFilterEvent } from "../events/index.js";
+import LinkerOverlayContent from "./LinkerOverlayContent.js";
+import LinkerUtils, { isLinkablePanel } from "./LinkerUtils.js";
 var log = Log.module('Linker');
 
-var mapState = function mapState(state, ownProps) {
-  return {
-    activeTool: getActiveTool(state),
-    isolatedLinkerPanelId: getIsolatedLinkerPanelIdForDashboard(state, ownProps.localDashboardId),
-    links: getLinksForDashboard(state, ownProps.localDashboardId),
-    timeZone: getTimeZone(state)
-  };
-};
+var mapState = (state, ownProps) => ({
+  activeTool: getActiveTool(state),
+  isolatedLinkerPanelId: getIsolatedLinkerPanelIdForDashboard(state, ownProps.localDashboardId),
+  links: getLinksForDashboard(state, ownProps.localDashboardId),
+  timeZone: getTimeZone(state)
+});
 
 var connector = connect(mapState, {
   setActiveTool: setActiveToolAction,
@@ -73,27 +37,19 @@ var connector = connect(mapState, {
   setDashboardIsolatedLinkerPanelId: setDashboardIsolatedLinkerPanelIdAction,
   setDashboardColumnSelectionValidator: setDashboardColumnSelectionValidatorAction
 });
-export var Linker = /*#__PURE__*/function (_Component) {
-  _inherits(Linker, _Component);
-
-  var _super = _createSuper(Linker);
-
-  function Linker(props) {
-    var _this;
-
-    _classCallCheck(this, Linker);
+export class Linker extends Component {
+  constructor(props) {
+    super(props);
 
-    _this = _super.call(this, props);
-
-    _defineProperty(_assertThisInitialized(_this), "getCachedLinks", memoize(function (links, linkInProgress, isolateForPanelId) {
-      var combinedLinks = _toConsumableArray(links);
+    _defineProperty(this, "getCachedLinks", memoize((links, linkInProgress, isolateForPanelId) => {
+      var combinedLinks = [...links];
 
       if (linkInProgress && linkInProgress.start) {
         combinedLinks.push(linkInProgress);
       }
 
-      if (isolateForPanelId !== null) {
-        return combinedLinks.filter(function (link) {
+      if (isolateForPanelId != null) {
+        return combinedLinks.filter(link => {
           var _link$start, _link$end;
 
           return (link === null || link === void 0 ? void 0 : (_link$start = link.start) === null || _link$start === void 0 ? void 0 : _link$start.panelId) === isolateForPanelId || (link === null || link === void 0 ? void 0 : (_link$end = link.end) === null || _link$end === void 0 ? void 0 : _link$end.panelId) === isolateForPanelId || (link === null || link === void 0 ? void 0 : link.end) == null;
@@ -104,602 +60,634 @@ export var Linker = /*#__PURE__*/function (_Component) {
       return combinedLinks;
     }));
 
-    _this.handleCancel = _this.handleCancel.bind(_assertThisInitialized(_this));
-    _this.handleDone = _this.handleDone.bind(_assertThisInitialized(_this));
-    _this.handlePanelCloned = _this.handlePanelCloned.bind(_assertThisInitialized(_this));
-    _this.handleFilterColumnSelect = _this.handleFilterColumnSelect.bind(_assertThisInitialized(_this));
-    _this.handleColumnsChanged = _this.handleColumnsChanged.bind(_assertThisInitialized(_this));
-    _this.handlePanelClosed = _this.handlePanelClosed.bind(_assertThisInitialized(_this));
-    _this.handleLayoutStateChanged = _this.handleLayoutStateChanged.bind(_assertThisInitialized(_this));
-    _this.handleAllLinksDeleted = _this.handleAllLinksDeleted.bind(_assertThisInitialized(_this));
-    _this.handleLinkDeleted = _this.handleLinkDeleted.bind(_assertThisInitialized(_this));
-    _this.handleChartColumnSelect = _this.handleChartColumnSelect.bind(_assertThisInitialized(_this));
-    _this.handleGridColumnSelect = _this.handleGridColumnSelect.bind(_assertThisInitialized(_this));
-    _this.handleUpdateValues = _this.handleUpdateValues.bind(_assertThisInitialized(_this));
-    _this.handleStateChange = _this.handleStateChange.bind(_assertThisInitialized(_this));
-    _this.handleExited = _this.handleExited.bind(_assertThisInitialized(_this));
-    _this.isColumnSelectionValid = _this.isColumnSelectionValid.bind(_assertThisInitialized(_this));
-    _this.state = {
+    this.handleCancel = this.handleCancel.bind(this);
+    this.handleDone = this.handleDone.bind(this);
+    this.handlePanelCloned = this.handlePanelCloned.bind(this);
+    this.handleFilterColumnSelect = this.handleFilterColumnSelect.bind(this);
+    this.handleColumnsChanged = this.handleColumnsChanged.bind(this);
+    this.handlePanelClosed = this.handlePanelClosed.bind(this);
+    this.handleLayoutStateChanged = this.handleLayoutStateChanged.bind(this);
+    this.handleAllLinksDeleted = this.handleAllLinksDeleted.bind(this);
+    this.handleLinkDeleted = this.handleLinkDeleted.bind(this);
+    this.handleChartColumnSelect = this.handleChartColumnSelect.bind(this);
+    this.handleGridColumnSelect = this.handleGridColumnSelect.bind(this);
+    this.handleUpdateValues = this.handleUpdateValues.bind(this);
+    this.handleStateChange = this.handleStateChange.bind(this);
+    this.handleExited = this.handleExited.bind(this);
+    this.isColumnSelectionValid = this.isColumnSelectionValid.bind(this);
+    this.state = {
       linkInProgress: undefined
     };
-    return _this;
   }
 
-  _createClass(Linker, [{
-    key: "componentDidMount",
-    value: function componentDidMount() {
-      var layout = this.props.layout;
+  componentDidMount() {
+    var {
+      layout
+    } = this.props;
+    this.startListening(layout);
+    this.updateSelectionValidators();
+  }
+
+  componentDidUpdate(prevProps) {
+    var {
+      activeTool,
+      layout
+    } = this.props;
+
+    if (layout !== prevProps.layout) {
+      this.stopListening(prevProps.layout);
       this.startListening(layout);
-      this.updateSelectionValidators();
     }
-  }, {
-    key: "componentDidUpdate",
-    value: function componentDidUpdate(prevProps) {
-      var _this$props = this.props,
-          activeTool = _this$props.activeTool,
-          layout = _this$props.layout;
-
-      if (layout !== prevProps.layout) {
-        this.stopListening(prevProps.layout);
-        this.startListening(layout);
-      }
 
-      if (activeTool !== prevProps.activeTool) {
-        this.updateSelectionValidators();
-      }
-    }
-  }, {
-    key: "componentDidCatch",
-    value: function componentDidCatch(error, info) {
-      log.error('componentDidCatch', error, info);
-    }
-  }, {
-    key: "componentWillUnmount",
-    value: function componentWillUnmount() {
-      var layout = this.props.layout;
-      this.stopListening(layout);
-    }
-  }, {
-    key: "startListening",
-    value: function startListening(layout) {
-      layout.on('stateChanged', this.handleLayoutStateChanged);
-      var eventHub = layout.eventHub;
-      eventHub.on(IrisGridEvent.COLUMN_SELECTED, this.handleGridColumnSelect);
-      eventHub.on(IrisGridEvent.DATA_SELECTED, this.handleUpdateValues);
-      eventHub.on(IrisGridEvent.STATE_CHANGED, this.handleStateChange);
-      eventHub.on(ChartEvent.COLUMN_SELECTED, this.handleChartColumnSelect);
-      eventHub.on(PanelEvent.CLONED, this.handlePanelCloned);
-      eventHub.on(InputFilterEvent.COLUMN_SELECTED, this.handleFilterColumnSelect);
-      eventHub.on(InputFilterEvent.COLUMNS_CHANGED, this.handleColumnsChanged);
-      eventHub.on(PanelEvent.CLOSED, this.handlePanelClosed);
-    }
-  }, {
-    key: "stopListening",
-    value: function stopListening(layout) {
-      layout.off('stateChanged', this.handleLayoutStateChanged);
-      var eventHub = layout.eventHub;
-      eventHub.off(IrisGridEvent.COLUMN_SELECTED, this.handleGridColumnSelect);
-      eventHub.off(IrisGridEvent.DATA_SELECTED, this.handleUpdateValues);
-      eventHub.off(IrisGridEvent.STATE_CHANGED, this.handleStateChange);
-      eventHub.off(ChartEvent.COLUMN_SELECTED, this.handleChartColumnSelect);
-      eventHub.off(PanelEvent.CLONED, this.handlePanelCloned);
-      eventHub.off(InputFilterEvent.COLUMN_SELECTED, this.handleFilterColumnSelect);
-      eventHub.off(InputFilterEvent.COLUMNS_CHANGED, this.handleColumnsChanged);
-      eventHub.off(PanelEvent.CLOSED, this.handlePanelClosed);
+    if (activeTool !== prevProps.activeTool) {
+      this.updateSelectionValidators();
     }
-  }, {
-    key: "handleCancel",
-    value: function handleCancel() {
-      var linkInProgress = this.state.linkInProgress;
-
-      if (linkInProgress == null) {
-        var setActiveTool = this.props.setActiveTool;
-        setActiveTool(ToolType.DEFAULT);
-      }
+  }
 
-      this.setState({
-        linkInProgress: undefined
-      });
-    }
-  }, {
-    key: "handleDone",
-    value: function handleDone() {
-      var setActiveTool = this.props.setActiveTool;
+  componentDidCatch(error, info) {
+    log.error('componentDidCatch', error, info);
+  }
+
+  componentWillUnmount() {
+    var {
+      layout
+    } = this.props;
+    this.stopListening(layout);
+  }
+
+  startListening(layout) {
+    layout.on('stateChanged', this.handleLayoutStateChanged);
+    var {
+      eventHub
+    } = layout;
+    eventHub.on(IrisGridEvent.COLUMN_SELECTED, this.handleGridColumnSelect);
+    eventHub.on(IrisGridEvent.DATA_SELECTED, this.handleUpdateValues);
+    eventHub.on(IrisGridEvent.STATE_CHANGED, this.handleStateChange);
+    eventHub.on(ChartEvent.COLUMN_SELECTED, this.handleChartColumnSelect);
+    eventHub.on(PanelEvent.CLONED, this.handlePanelCloned);
+    eventHub.on(InputFilterEvent.COLUMN_SELECTED, this.handleFilterColumnSelect);
+    eventHub.on(InputFilterEvent.COLUMNS_CHANGED, this.handleColumnsChanged);
+    eventHub.on(PanelEvent.CLOSED, this.handlePanelClosed);
+  }
+
+  stopListening(layout) {
+    layout.off('stateChanged', this.handleLayoutStateChanged);
+    var {
+      eventHub
+    } = layout;
+    eventHub.off(IrisGridEvent.COLUMN_SELECTED, this.handleGridColumnSelect);
+    eventHub.off(IrisGridEvent.DATA_SELECTED, this.handleUpdateValues);
+    eventHub.off(IrisGridEvent.STATE_CHANGED, this.handleStateChange);
+    eventHub.off(ChartEvent.COLUMN_SELECTED, this.handleChartColumnSelect);
+    eventHub.off(PanelEvent.CLONED, this.handlePanelCloned);
+    eventHub.off(InputFilterEvent.COLUMN_SELECTED, this.handleFilterColumnSelect);
+    eventHub.off(InputFilterEvent.COLUMNS_CHANGED, this.handleColumnsChanged);
+    eventHub.off(PanelEvent.CLOSED, this.handlePanelClosed);
+  }
+
+  handleCancel() {
+    var {
+      linkInProgress
+    } = this.state;
+
+    if (linkInProgress == null) {
+      var {
+        setActiveTool
+      } = this.props;
       setActiveTool(ToolType.DEFAULT);
-      this.setState({
-        linkInProgress: undefined
-      });
     }
-  }, {
-    key: "handleChartColumnSelect",
-    value: function handleChartColumnSelect(panel, column) {
-      this.columnSelected(panel, column, true);
-    }
-  }, {
-    key: "handleFilterColumnSelect",
-    value: function handleFilterColumnSelect(panel, column) {
-      log.debug('handleFilterColumnSelect', this.isOverlayShown());
-      var _this$props2 = this.props,
-          links = _this$props2.links,
-          localDashboardId = _this$props2.localDashboardId,
-          setActiveTool = _this$props2.setActiveTool,
-          setDashboardIsolatedLinkerPanelId = _this$props2.setDashboardIsolatedLinkerPanelId;
-      var panelId = LayoutUtils.getIdFromPanel(panel);
-      var panelLinks = links.filter(function (link) {
-        var _link$start2, _link$end2;
-
-        return ((_link$start2 = link.start) === null || _link$start2 === void 0 ? void 0 : _link$start2.panelId) === panelId || ((_link$end2 = link.end) === null || _link$end2 === void 0 ? void 0 : _link$end2.panelId) === panelId;
-      });
 
-      if (!this.isOverlayShown() && panelId != null) {
-        // Initial click on the filter source button with linker inactive
-        // Show linker in isolated mode for panel
-        setActiveTool(ToolType.LINKER);
-        setDashboardIsolatedLinkerPanelId(localDashboardId, panelId);
-
-        if (panelLinks.length === 0) {
-          // Source not linked - start new link in isolated linker mode
-          // Need to pass panelId for overrideIsolatedLinkerPanelId
-          // as redux prop update at this point not yet propagated
-          this.columnSelected(panel, column, true, panelId);
-        }
+    this.setState({
+      linkInProgress: undefined
+    });
+  }
 
-        return;
-      } // Filter source clicked with linker active
+  handleDone() {
+    var {
+      setActiveTool
+    } = this.props;
+    setActiveTool(ToolType.DEFAULT);
+    this.setState({
+      linkInProgress: undefined
+    });
+  }
 
+  handleChartColumnSelect(panel, column) {
+    this.columnSelected(panel, column, true);
+  }
 
-      this.columnSelected(panel, column, true);
-    }
-  }, {
-    key: "handleColumnsChanged",
-    value: function handleColumnsChanged(panel, columns) {
-      log.debug('handleColumnsChanged', panel, columns);
-      var links = this.props.links;
-      var panelId = LayoutUtils.getIdFromPanel(panel);
-
-      if (panelId == null) {
-        log.error('Invalid panelId', panel);
-        return;
-      } // Delete links that start or end on non-existent column in the updated panel
-
-
-      var linksToDelete = links.filter(function (_ref) {
-        var start = _ref.start,
-            end = _ref.end;
-        return start.panelId === panelId && LinkerUtils.findColumn(columns, start) == null || end != null && end.panelId === panelId && LinkerUtils.findColumn(columns, end) == null;
-      });
-      this.deleteLinks(linksToDelete);
-    }
-  }, {
-    key: "handleGridColumnSelect",
-    value: function handleGridColumnSelect(panel, column) {
-      this.columnSelected(panel, column);
-    }
-    /**
-     * Track a column selection and build the link from it.
-     * @param panel The panel component that is the source for the column selection
-     * @param column The column that was selected
-     * @param isAlwaysEndPoint True if the selection is always the end point, even if it's the first column selected. Defaults to false.
-     * @param overrideIsolatedLinkerPanelId isolatedLinkerPanelId to use when method is called before prop changes propagate
-     */
-
-  }, {
-    key: "columnSelected",
-    value: function columnSelected(panel, column) {
-      var _this2 = this;
-
-      var isAlwaysEndPoint = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-      var overrideIsolatedLinkerPanelId = arguments.length > 3 ? arguments[3] : undefined;
-
-      if (overrideIsolatedLinkerPanelId == null && !this.isOverlayShown()) {
-        return;
+  handleFilterColumnSelect(panel, column) {
+    log.debug('handleFilterColumnSelect', this.isOverlayShown());
+    var {
+      links,
+      localDashboardId,
+      setActiveTool,
+      setDashboardIsolatedLinkerPanelId
+    } = this.props;
+    var panelId = LayoutUtils.getIdFromPanel(panel);
+    var panelLinks = links.filter(link => {
+      var _link$start2, _link$end2;
+
+      return ((_link$start2 = link.start) === null || _link$start2 === void 0 ? void 0 : _link$start2.panelId) === panelId || ((_link$end2 = link.end) === null || _link$end2 === void 0 ? void 0 : _link$end2.panelId) === panelId;
+    });
+
+    if (!this.isOverlayShown() && panelId != null) {
+      // Initial click on the filter source button with linker inactive
+      // Show linker in isolated mode for panel
+      setActiveTool(ToolType.LINKER);
+      setDashboardIsolatedLinkerPanelId(localDashboardId, panelId);
+
+      if (panelLinks.length === 0) {
+        // Source not linked - start new link in isolated linker mode
+        // Need to pass panelId for overrideIsolatedLinkerPanelId
+        // as redux prop update at this point not yet propagated
+        this.columnSelected(panel, column, true, panelId);
       }
 
-      var isolatedLinkerPanelId = this.props.isolatedLinkerPanelId;
-      var linkInProgress = this.state.linkInProgress;
-      var panelId = LayoutUtils.getIdFromPanel(panel);
+      return;
+    } // Filter source clicked with linker active
 
-      if (panelId == null) {
-        return;
-      }
 
-      var panelComponent = LayoutUtils.getComponentNameFromPanel(panel);
-      var columnName = column.name,
-          columnType = column.type;
-
-      if (linkInProgress == null || linkInProgress.start == null) {
-        var newLink = {
-          id: shortid.generate(),
-          start: {
-            panelId: panelId,
-            panelComponent: panelComponent,
-            columnName: columnName,
-            columnType: columnType
-          },
-          // Link starts with type Invalid as linking a source to itself is not allowed
-          type: 'invalid',
-          isReversed: isAlwaysEndPoint
-        };
-        log.debug('starting link', newLink);
-        this.setState({
-          linkInProgress: newLink
-        });
-      } else {
-        var start = linkInProgress.start,
-            id = linkInProgress.id,
-            isReversed = linkInProgress.isReversed;
-        var end = {
-          panelId: panelId,
-          panelComponent: panelComponent,
-          columnName: columnName,
-          columnType: columnType
-        };
-        var type = LinkerUtils.getLinkType(isReversed ? end : start, isReversed ? start : end, overrideIsolatedLinkerPanelId !== null && overrideIsolatedLinkerPanelId !== void 0 ? overrideIsolatedLinkerPanelId : isolatedLinkerPanelId);
-
-        switch (type) {
-          case 'invalid':
-            log.debug('Ignore invalid link connection', linkInProgress, end);
-            return;
-
-          case 'filterSource':
-            {
-              // filterSource links have a limit of 1 link per target
-              // New link validation passed, delete existing links before adding the new one
-              var _links = this.props.links;
-              var existingLinkPanelId = isReversed ? start.panelId : end.panelId; // In cases with multiple targets per panel (i.e. chart filters)
-              // links would have to be filtered by panelId and columnName and columnType
-
-              var linksToDelete = _links.filter(function (_ref2) {
-                var panelLinkEnd = _ref2.end;
-                return (panelLinkEnd === null || panelLinkEnd === void 0 ? void 0 : panelLinkEnd.panelId) === existingLinkPanelId;
-              });
-
-              this.deleteLinks(linksToDelete);
-              break;
-            }
-
-          case 'tableLink':
-            // No-op
-            break;
-        } // Create a completed link from link in progress
-
-
-        var _newLink = {
-          start: isReversed ? end : start,
-          end: isReversed ? start : end,
-          id: id,
-          type: type
-        };
-        log.info('creating link', _newLink);
-        this.setState({
-          linkInProgress: undefined
-        }, function () {
-          // Adding link after updating state
-          // otherwise both new link and linkInProgress could be rendered at the same time
-          // resulting in "multiple children with same key" error
-          _this2.addLinks([_newLink]);
-        });
-      }
-    }
-  }, {
-    key: "unsetFilterValueForLink",
-    value: function unsetFilterValueForLink(link) {
-      var panelManager = this.props.panelManager;
-
-      if (link.end) {
-        var end = link.end;
-        var _panelId = end.panelId,
-            columnName = end.columnName,
-            columnType = end.columnType;
-        var endPanel = panelManager.getOpenedPanelById(_panelId);
-
-        if (!endPanel) {
-          log.debug('endPanel no longer exists, ignoring unsetFilterValue', _panelId);
-        } else if (isLinkablePanel(endPanel)) {
-          endPanel.unsetFilterValue(columnName, columnType);
-        } else {
-          log.debug('endPanel.unsetFilterValue not implemented', endPanel);
-        }
-      }
-    }
-    /**
-     * Set filters for a given panel ID
-     * @param panelId ID of panel to set filters on
-     * @param filterMap Map of column name to column type, text, and value
-     */
-
-  }, {
-    key: "setPanelFilterMap",
-    value: function setPanelFilterMap(panelId, filterMap) {
-      log.debug('Set filter data for panel:', panelId, filterMap);
-      var panelManager = this.props.panelManager;
-      var panel = panelManager.getOpenedPanelById(panelId);
-
-      if (!panel) {
-        log.debug('panel no longer exists, ignoring setFilterMap', panelId);
-      } else if (isLinkablePanel(panel)) {
-        panel.setFilterMap(filterMap);
-      } else {
-        log.debug('panel.setFilterMap not implemented', panelId, panel);
-      }
+    this.columnSelected(panel, column, true);
+  }
+
+  handleColumnsChanged(panel, columns) {
+    log.debug('handleColumnsChanged', panel, columns);
+    var {
+      links
+    } = this.props;
+    var panelId = LayoutUtils.getIdFromPanel(panel);
+
+    if (panelId == null) {
+      log.error('Invalid panelId', panel);
+      return;
+    } // Delete links that start or end on non-existent column in the updated panel
+
+
+    var linksToDelete = links.filter((_ref) => {
+      var {
+        start,
+        end
+      } = _ref;
+      return start.panelId === panelId && LinkerUtils.findColumn(columns, start) == null || end != null && end.panelId === panelId && LinkerUtils.findColumn(columns, end) == null;
+    });
+    this.deleteLinks(linksToDelete);
+  }
+
+  handleGridColumnSelect(panel, column) {
+    this.columnSelected(panel, column);
+  }
+  /**
+   * Track a column selection and build the link from it.
+   * @param panel The panel component that is the source for the column selection
+   * @param column The column that was selected
+   * @param isAlwaysEndPoint True if the selection is always the end point, even if it's the first column selected. Defaults to false.
+   * @param overrideIsolatedLinkerPanelId isolatedLinkerPanelId to use when method is called before prop changes propagate
+   */
+
+
+  columnSelected(panel, column) {
+    var isAlwaysEndPoint = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    var overrideIsolatedLinkerPanelId = arguments.length > 3 ? arguments[3] : undefined;
+
+    if (overrideIsolatedLinkerPanelId == null && !this.isOverlayShown()) {
+      return;
     }
-  }, {
-    key: "addLinks",
-    value: function addLinks(links) {
-      var _this$props3 = this.props,
-          addDashboardLinks = _this$props3.addDashboardLinks,
-          localDashboardId = _this$props3.localDashboardId;
-      addDashboardLinks(localDashboardId, links);
+
+    var {
+      isolatedLinkerPanelId
+    } = this.props;
+    var {
+      linkInProgress
+    } = this.state;
+    var panelId = LayoutUtils.getIdFromPanel(panel);
+
+    if (panelId == null) {
+      return;
     }
-  }, {
-    key: "deleteLinks",
-    value: function deleteLinks(links) {
-      var _this3 = this;
-
-      var clearAll = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-      var localDashboardId = this.props.localDashboardId;
-      links.forEach(function (link) {
-        return _this3.unsetFilterValueForLink(link);
+
+    var panelComponent = LayoutUtils.getComponentNameFromPanel(panel);
+    var {
+      name: columnName,
+      type: columnType
+    } = column;
+
+    if (linkInProgress == null || linkInProgress.start == null) {
+      var newLink = {
+        id: shortid.generate(),
+        start: {
+          panelId,
+          panelComponent,
+          columnName,
+          columnType
+        },
+        // Link starts with type Invalid as linking a source to itself is not allowed
+        type: 'invalid',
+        isReversed: isAlwaysEndPoint
+      };
+      log.debug('starting link', newLink);
+      this.setState({
+        linkInProgress: newLink
       });
+    } else {
+      var {
+        start,
+        id,
+        isReversed
+      } = linkInProgress;
+      var end = {
+        panelId,
+        panelComponent,
+        columnName,
+        columnType
+      };
+      var type = LinkerUtils.getLinkType(isReversed ? end : start, isReversed ? start : end, overrideIsolatedLinkerPanelId !== null && overrideIsolatedLinkerPanelId !== void 0 ? overrideIsolatedLinkerPanelId : isolatedLinkerPanelId);
+
+      switch (type) {
+        case 'invalid':
+          log.debug('Ignore invalid link connection', linkInProgress, end);
+          return;
+
+        case 'filterSource':
+          {
+            // filterSource links have a limit of 1 link per target
+            // New link validation passed, delete existing links before adding the new one
+            var {
+              links: _links
+            } = this.props;
+            var existingLinkPanelId = isReversed ? start.panelId : end.panelId; // In cases with multiple targets per panel (i.e. chart filters)
+            // links would have to be filtered by panelId and columnName and columnType
+
+            var linksToDelete = _links.filter((_ref2) => {
+              var {
+                end: panelLinkEnd
+              } = _ref2;
+              return (panelLinkEnd === null || panelLinkEnd === void 0 ? void 0 : panelLinkEnd.panelId) === existingLinkPanelId;
+            });
 
-      if (clearAll) {
-        var setDashboardLinks = this.props.setDashboardLinks;
-        setDashboardLinks(localDashboardId, []);
-      } else if (links.length > 0) {
-        var deleteDashboardLinks = this.props.deleteDashboardLinks;
-        deleteDashboardLinks(localDashboardId, links.map(function (_ref3) {
-          var id = _ref3.id;
-          return id;
-        }));
-      }
-    }
-  }, {
-    key: "handleAllLinksDeleted",
-    value: function handleAllLinksDeleted() {
-      var _this$props4 = this.props,
-          links = _this$props4.links,
-          isolatedLinkerPanelId = _this$props4.isolatedLinkerPanelId;
-
-      if (isolatedLinkerPanelId == null) {
-        this.deleteLinks(links, true);
-      } else {
-        var isolatedLinks = links.filter(function (link) {
-          var _link$start3, _link$end3;
+            this.deleteLinks(linksToDelete);
+            break;
+          }
+
+        case 'tableLink':
+          // No-op
+          break;
+      } // Create a completed link from link in progress
 
-          return (link === null || link === void 0 ? void 0 : (_link$start3 = link.start) === null || _link$start3 === void 0 ? void 0 : _link$start3.panelId) === isolatedLinkerPanelId || (link === null || link === void 0 ? void 0 : (_link$end3 = link.end) === null || _link$end3 === void 0 ? void 0 : _link$end3.panelId) === isolatedLinkerPanelId;
-        });
-        this.deleteLinks(isolatedLinks);
-      }
 
+      var _newLink = {
+        start: isReversed ? end : start,
+        end: isReversed ? start : end,
+        id,
+        type
+      };
+      log.info('creating link', _newLink);
       this.setState({
         linkInProgress: undefined
+      }, () => {
+        // Adding link after updating state
+        // otherwise both new link and linkInProgress could be rendered at the same time
+        // resulting in "multiple children with same key" error
+        this.addLinks([_newLink]);
       });
     }
-  }, {
-    key: "handleLinkDeleted",
-    value: function handleLinkDeleted(linkId) {
-      var links = this.props.links;
-      var link = links.find(function (l) {
-        return l.id === linkId;
-      });
+  }
 
-      if (link) {
-        this.deleteLinks([link]);
+  unsetFilterValueForLink(link) {
+    var {
+      panelManager
+    } = this.props;
+
+    if (link.end) {
+      var {
+        end
+      } = link;
+      var {
+        panelId: _panelId,
+        columnName,
+        columnType
+      } = end;
+      var endPanel = panelManager.getOpenedPanelById(_panelId);
+
+      if (!endPanel) {
+        log.debug('endPanel no longer exists, ignoring unsetFilterValue', _panelId);
+      } else if (isLinkablePanel(endPanel)) {
+        endPanel.unsetFilterValue(columnName, columnType);
       } else {
-        log.error('Unable to find link to delete', linkId);
+        log.debug('endPanel.unsetFilterValue not implemented', endPanel);
       }
     }
-  }, {
-    key: "handleUpdateValues",
-    value: function handleUpdateValues(panel, dataMap) {
-      var _this4 = this;
-
-      var panelId = LayoutUtils.getIdFromPanel(panel);
-      var _this$props5 = this.props,
-          links = _this$props5.links,
-          timeZone = _this$props5.timeZone; // Map of panel ID to filterMap
-
-      var panelFilterMap = new Map(); // Instead of setting filters one by one for each link,
-      // combine them so they could be set in a single call per target panel
-
-      for (var i = 0; i < links.length; i += 1) {
-        var _links$i = links[i],
-            start = _links$i.start,
-            end = _links$i.end;
-
-        if (start.panelId === panelId && end != null) {
-          var endPanelId = end.panelId,
-              columnName = end.columnName,
-              columnType = end.columnType; // Map of column name to column type and filter value
-
-          var filterMap = panelFilterMap.has(endPanelId) ? panelFilterMap.get(endPanelId) : new Map();
-          var value = dataMap[start.columnName].value;
-          var text = "".concat(value);
-
-          if (TableUtils.isDateType(columnType)) {
-            var dateFilterFormatter = new DateTimeColumnFormatter({
-              timeZone: timeZone,
-              showTimeZone: false,
-              showTSeparator: true,
-              defaultDateTimeFormatString: DateUtils.FULL_DATE_FORMAT
-            });
-            text = dateFilterFormatter.format(value);
-          }
+  }
+  /**
+   * Set filters for a given panel ID
+   * @param panelId ID of panel to set filters on
+   * @param filterMap Map of column name to column type, text, and value
+   */
+
+
+  setPanelFilterMap(panelId, filterMap) {
+    log.debug('Set filter data for panel:', panelId, filterMap);
+    var {
+      panelManager
+    } = this.props;
+    var panel = panelManager.getOpenedPanelById(panelId);
+
+    if (!panel) {
+      log.debug('panel no longer exists, ignoring setFilterMap', panelId);
+    } else if (isLinkablePanel(panel)) {
+      panel.setFilterMap(filterMap);
+    } else {
+      log.debug('panel.setFilterMap not implemented', panelId, panel);
+    }
+  }
 
-          filterMap.set(columnName, {
-            columnType: columnType,
-            text: text,
-            value: value
-          });
-          panelFilterMap.set(endPanelId, filterMap);
-        }
-      } // Apply combined filters to all target panels
+  addLinks(links) {
+    var {
+      addDashboardLinks,
+      localDashboardId
+    } = this.props;
+    addDashboardLinks(localDashboardId, links);
+  }
 
+  deleteLinks(links) {
+    var clearAll = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    var {
+      localDashboardId
+    } = this.props;
+    links.forEach(link => this.unsetFilterValueForLink(link));
+
+    if (clearAll) {
+      var {
+        setDashboardLinks
+      } = this.props;
+      setDashboardLinks(localDashboardId, []);
+    } else if (links.length > 0) {
+      var {
+        deleteDashboardLinks
+      } = this.props;
+      deleteDashboardLinks(localDashboardId, links.map((_ref3) => {
+        var {
+          id
+        } = _ref3;
+        return id;
+      }));
+    }
+  }
+
+  handleAllLinksDeleted() {
+    var {
+      links,
+      isolatedLinkerPanelId
+    } = this.props;
 
-      panelFilterMap.forEach(function (filterMap, endPanelId) {
-        _this4.setPanelFilterMap(endPanelId, filterMap);
+    if (isolatedLinkerPanelId == null) {
+      this.deleteLinks(links, true);
+    } else {
+      var isolatedLinks = links.filter(link => {
+        var _link$start3, _link$end3;
+
+        return (link === null || link === void 0 ? void 0 : (_link$start3 = link.start) === null || _link$start3 === void 0 ? void 0 : _link$start3.panelId) === isolatedLinkerPanelId || (link === null || link === void 0 ? void 0 : (_link$end3 = link.end) === null || _link$end3 === void 0 ? void 0 : _link$end3.panelId) === isolatedLinkerPanelId;
       });
+      this.deleteLinks(isolatedLinks);
     }
-  }, {
-    key: "handlePanelCloned",
-    value: function handlePanelCloned(panel, cloneConfig) {
-      var links = this.props.links;
-      var panelId = LayoutUtils.getIdFromPanel(panel);
-      var cloneId = cloneConfig.id;
-
-      if (panelId != null) {
-        var linksToAdd = LinkerUtils.cloneLinksForPanel(links, panelId, cloneId);
-        this.addLinks(linksToAdd);
-      }
-    }
-  }, {
-    key: "handlePanelClosed",
-    value: function handlePanelClosed(panelId) {
-      // Delete links on PanelEvent.CLOSED instead of UNMOUNT
-      // because the panels can get unmounted on errors and we want to keep the links if that happens
-      log.debug("Panel ".concat(panelId, " closed, deleting links."));
-      this.deleteLinksForPanelId(panelId);
-    }
-  }, {
-    key: "handleLayoutStateChanged",
-    value: function handleLayoutStateChanged() {
-      this.forceUpdate();
-    }
-  }, {
-    key: "handleStateChange",
-    value: function handleStateChange() {
-      this.forceUpdate();
-    }
-  }, {
-    key: "handleExited",
-    value: function handleExited() {
-      // Has to be done after linker exit animation to avoid flashing non-isolated links
-      var _this$props6 = this.props,
-          localDashboardId = _this$props6.localDashboardId,
-          setDashboardIsolatedLinkerPanelId = _this$props6.setDashboardIsolatedLinkerPanelId;
-      setDashboardIsolatedLinkerPanelId(localDashboardId, undefined);
+
+    this.setState({
+      linkInProgress: undefined
+    });
+  }
+
+  handleLinkDeleted(linkId) {
+    var {
+      links
+    } = this.props;
+    var link = links.find(l => l.id === linkId);
+
+    if (link) {
+      this.deleteLinks([link]);
+    } else {
+      log.error('Unable to find link to delete', linkId);
     }
-    /**
-     * Delete all links for a provided panel ID. Needs to be done whenever a panel is closed or unmounted.
-     * @param panelId The panel ID to delete links for
-     */
-
-  }, {
-    key: "deleteLinksForPanelId",
-    value: function deleteLinksForPanelId(panelId) {
-      var links = this.props.links;
-
-      for (var i = 0; i < links.length; i += 1) {
-        var link = links[i];
-        var start = link.start,
-            end = link.end,
-            id = link.id;
-
-        if (start.panelId === panelId || (end === null || end === void 0 ? void 0 : end.panelId) === panelId) {
-          this.handleLinkDeleted(id);
+  }
+
+  handleUpdateValues(panel, dataMap) {
+    var panelId = LayoutUtils.getIdFromPanel(panel);
+    var {
+      links,
+      timeZone
+    } = this.props; // Map of panel ID to filterMap
+
+    var panelFilterMap = new Map(); // Instead of setting filters one by one for each link,
+    // combine them so they could be set in a single call per target panel
+
+    for (var i = 0; i < links.length; i += 1) {
+      var {
+        start,
+        end
+      } = links[i];
+
+      if (start.panelId === panelId && end != null) {
+        var {
+          panelId: endPanelId,
+          columnName,
+          columnType
+        } = end; // Map of column name to column type and filter value
+
+        var filterMap = panelFilterMap.has(endPanelId) ? panelFilterMap.get(endPanelId) : new Map();
+        var {
+          value
+        } = dataMap[start.columnName];
+        var text = "".concat(value);
+
+        if (TableUtils.isDateType(columnType)) {
+          var dateFilterFormatter = new DateTimeColumnFormatter({
+            timeZone,
+            showTimeZone: false,
+            showTSeparator: true,
+            defaultDateTimeFormatString: DateUtils.FULL_DATE_FORMAT
+          });
+          text = dateFilterFormatter.format(value);
         }
+
+        filterMap.set(columnName, {
+          columnType,
+          text,
+          value
+        });
+        panelFilterMap.set(endPanelId, filterMap);
       }
+    } // Apply combined filters to all target panels
+
+
+    panelFilterMap.forEach((filterMap, endPanelId) => {
+      this.setPanelFilterMap(endPanelId, filterMap);
+    });
+  }
+
+  handlePanelCloned(panel, cloneConfig) {
+    var {
+      links
+    } = this.props;
+    var panelId = LayoutUtils.getIdFromPanel(panel);
+    var cloneId = cloneConfig.id;
+
+    if (panelId != null) {
+      var linksToAdd = LinkerUtils.cloneLinksForPanel(links, panelId, cloneId);
+      this.addLinks(linksToAdd);
     }
-  }, {
-    key: "isOverlayShown",
-    value: function isOverlayShown() {
-      var activeTool = this.props.activeTool;
-      return activeTool === ToolType.LINKER;
-    }
-  }, {
-    key: "updateSelectionValidators",
-    value: function updateSelectionValidators() {
-      var _this$props7 = this.props,
-          activeTool = _this$props7.activeTool,
-          setDashboardColumnSelectionValidator = _this$props7.setDashboardColumnSelectionValidator,
-          localDashboardId = _this$props7.localDashboardId;
-
-      switch (activeTool) {
-        case ToolType.LINKER:
-          setDashboardColumnSelectionValidator(localDashboardId, this.isColumnSelectionValid);
-          break;
+  }
 
-        default:
-          setDashboardColumnSelectionValidator(localDashboardId, undefined);
-          break;
+  handlePanelClosed(panelId) {
+    // Delete links on PanelEvent.CLOSED instead of UNMOUNT
+    // because the panels can get unmounted on errors and we want to keep the links if that happens
+    log.debug("Panel ".concat(panelId, " closed, deleting links."));
+    this.deleteLinksForPanelId(panelId);
+  }
+
+  handleLayoutStateChanged() {
+    this.forceUpdate();
+  }
+
+  handleStateChange() {
+    this.forceUpdate();
+  }
+
+  handleExited() {
+    // Has to be done after linker exit animation to avoid flashing non-isolated links
+    var {
+      localDashboardId,
+      setDashboardIsolatedLinkerPanelId
+    } = this.props;
+    setDashboardIsolatedLinkerPanelId(localDashboardId, undefined);
+  }
+  /**
+   * Delete all links for a provided panel ID. Needs to be done whenever a panel is closed or unmounted.
+   * @param panelId The panel ID to delete links for
+   */
+
+
+  deleteLinksForPanelId(panelId) {
+    var {
+      links
+    } = this.props;
+
+    for (var i = 0; i < links.length; i += 1) {
+      var link = links[i];
+      var {
+        start,
+        end,
+        id
+      } = link;
+
+      if (start.panelId === panelId || (end === null || end === void 0 ? void 0 : end.panelId) === panelId) {
+        this.handleLinkDeleted(id);
       }
     }
-  }, {
-    key: "updateLinkInProgressType",
-    value: function updateLinkInProgressType(linkInProgress) {
-      var type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'invalid';
-      this.setState({
-        linkInProgress: _objectSpread(_objectSpread({}, linkInProgress), {}, {
-          type: type
-        })
-      });
+  }
+
+  isOverlayShown() {
+    var {
+      activeTool
+    } = this.props;
+    return activeTool === ToolType.LINKER;
+  }
+
+  updateSelectionValidators() {
+    var {
+      activeTool,
+      setDashboardColumnSelectionValidator,
+      localDashboardId
+    } = this.props;
+
+    switch (activeTool) {
+      case ToolType.LINKER:
+        setDashboardColumnSelectionValidator(localDashboardId, this.isColumnSelectionValid);
+        break;
+
+      default:
+        setDashboardColumnSelectionValidator(localDashboardId, undefined);
+        break;
     }
-  }, {
-    key: "isColumnSelectionValid",
-    value: function isColumnSelectionValid(panel, tableColumn) {
-      var linkInProgress = this.state.linkInProgress;
-      var isolatedLinkerPanelId = this.props.isolatedLinkerPanelId; // Link not started yet - no need to update type
-
-      if ((linkInProgress === null || linkInProgress === void 0 ? void 0 : linkInProgress.start) == null) {
-        return true;
-      }
+  }
 
-      if (tableColumn == null) {
-        // Link started, end point is not a valid target
-        this.updateLinkInProgressType(linkInProgress);
-        return false;
-      }
+  updateLinkInProgressType(linkInProgress) {
+    var type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'invalid';
+    this.setState({
+      linkInProgress: _objectSpread(_objectSpread({}, linkInProgress), {}, {
+        type
+      })
+    });
+  }
 
-      var isReversed = linkInProgress.isReversed,
-          start = linkInProgress.start;
-      var panelId = LayoutUtils.getIdFromPanel(panel);
+  isColumnSelectionValid(panel, tableColumn) {
+    var {
+      linkInProgress
+    } = this.state;
+    var {
+      isolatedLinkerPanelId
+    } = this.props; // Link not started yet - no need to update type
 
-      if (panelId == null) {
-        return false;
-      }
+    if ((linkInProgress === null || linkInProgress === void 0 ? void 0 : linkInProgress.start) == null) {
+      return true;
+    }
 
-      var end = {
-        panelId: panelId,
-        panelComponent: LayoutUtils.getComponentNameFromPanel(panel),
-        columnName: tableColumn.name,
-        columnType: tableColumn.type
-      };
-      var type = isReversed ? LinkerUtils.getLinkType(end, start, isolatedLinkerPanelId) : LinkerUtils.getLinkType(start, end, isolatedLinkerPanelId);
-      this.updateLinkInProgressType(linkInProgress, type);
-      return type !== 'invalid';
+    if (tableColumn == null) {
+      // Link started, end point is not a valid target
+      this.updateLinkInProgressType(linkInProgress);
+      return false;
     }
-  }, {
-    key: "render",
-    value: function render() {
-      var _this$props8 = this.props,
-          links = _this$props8.links,
-          isolatedLinkerPanelId = _this$props8.isolatedLinkerPanelId,
-          panelManager = _this$props8.panelManager;
-      var linkInProgress = this.state.linkInProgress;
-      var isLinkOverlayShown = this.isOverlayShown();
-      var disabled = linkInProgress != null && linkInProgress.start != null;
-      var linkerOverlayMessage = isolatedLinkerPanelId === null ? 'Click a column source, then click a column target to create a filter link. Remove a filter link by clicking again to erase. Click done when finished.' : 'Create a link between the source column button and a table column by clicking on one, then the other. Remove the link by clicking it directly. Click done when finished.';
-      return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(CSSTransition, {
-        "in": isLinkOverlayShown,
-        timeout: ThemeExport.transitionMs,
-        classNames: "fade",
-        mountOnEnter: true,
-        unmountOnExit: true,
-        onExited: this.handleExited
-      }, /*#__PURE__*/React.createElement(LinkerOverlayContent, {
-        disabled: disabled,
-        panelManager: panelManager,
-        links: this.getCachedLinks(links, linkInProgress, isolatedLinkerPanelId),
-        messageText: linkerOverlayMessage,
-        onLinkDeleted: this.handleLinkDeleted,
-        onAllLinksDeleted: this.handleAllLinksDeleted,
-        onDone: this.handleDone,
-        onCancel: this.handleCancel
-      })));
+
+    var {
+      isReversed,
+      start
+    } = linkInProgress;
+    var panelId = LayoutUtils.getIdFromPanel(panel);
+
+    if (panelId == null) {
+      return false;
     }
-  }]);
 
-  return Linker;
-}(Component);
+    var end = {
+      panelId,
+      panelComponent: LayoutUtils.getComponentNameFromPanel(panel),
+      columnName: tableColumn.name,
+      columnType: tableColumn.type
+    };
+    var type = isReversed ? LinkerUtils.getLinkType(end, start, isolatedLinkerPanelId) : LinkerUtils.getLinkType(start, end, isolatedLinkerPanelId);
+    this.updateLinkInProgressType(linkInProgress, type);
+    return type !== 'invalid';
+  }
+
+  render() {
+    var {
+      links,
+      isolatedLinkerPanelId,
+      panelManager
+    } = this.props;
+    var {
+      linkInProgress
+    } = this.state;
+    var isLinkOverlayShown = this.isOverlayShown();
+    var disabled = linkInProgress != null && linkInProgress.start != null;
+    var linkerOverlayMessage = isolatedLinkerPanelId === null ? 'Click a column source, then click a column target to create a filter link. Remove a filter link by clicking again to erase. Click done when finished.' : 'Create a link between the source column button and a table column by clicking on one, then the other. Remove the link by clicking it directly. Click done when finished.';
+    return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(CSSTransition, {
+      in: isLinkOverlayShown,
+      timeout: ThemeExport.transitionMs,
+      classNames: "fade",
+      mountOnEnter: true,
+      unmountOnExit: true,
+      onExited: this.handleExited
+    }, /*#__PURE__*/React.createElement(LinkerOverlayContent, {
+      disabled: disabled,
+      panelManager: panelManager,
+      links: this.getCachedLinks(links, linkInProgress, isolatedLinkerPanelId),
+      messageText: linkerOverlayMessage,
+      onLinkDeleted: this.handleLinkDeleted,
+      onAllLinksDeleted: this.handleAllLinksDeleted,
+      onDone: this.handleDone,
+      onCancel: this.handleCancel
+    })));
+  }
+
+}
 export default connector(Linker);
 //# sourceMappingURL=Linker.js.map