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

package/dist/panels/ConsolePanel.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 _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 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 _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; }
 
 // Wrapper for the Console for use in a golden layout container
@@ -53,12 +19,11 @@ import { GLPropTypes, PanelEvent } from '@deephaven/dashboard';
 import { IrisGridModelFactory } from '@deephaven/iris-grid';
 import { PropTypes as APIPropTypes } from '@deephaven/jsapi-shim';
 import Log from '@deephaven/log';
-import { getCommandHistoryStorage } from '@deephaven/redux';
-import { ChartEvent, ConsoleEvent, ControlEvent, IrisGridEvent, PandasEvent } from '../events';
+import { getCommandHistoryStorage, getTimeZone } from '@deephaven/redux';
+import { ChartEvent, ConsoleEvent, ControlEvent, IrisGridEvent, PandasEvent } from "../events/index.js";
 import "./ConsolePanel.css";
-import Panel from './Panel';
-import { getDashboardSessionWrapper } from '../redux';
-import { MatPlotLibEvent } from '../../dist/events';
+import Panel from "./Panel.js";
+import { getDashboardSessionWrapper } from "../redux/index.js";
 var log = Log.module('ConsolePanel');
 var DEBOUNCE_PANEL_STATE_UPDATE = 500;
 var DEFAULT_PANEL_STATE = Object.freeze({
@@ -66,366 +31,354 @@ var DEFAULT_PANEL_STATE = Object.freeze({
   itemIds: []
 });
 
-var ConsolePanel = /*#__PURE__*/function (_PureComponent) {
-  _inherits(ConsolePanel, _PureComponent);
-
-  var _super = _createSuper(ConsolePanel);
-
-  function ConsolePanel(props) {
-    var _this;
-
-    _classCallCheck(this, ConsolePanel);
-
-    _this = _super.call(this, props);
-    _this.handleFocusCommandHistory = _this.handleFocusCommandHistory.bind(_assertThisInitialized(_this));
-    _this.handleOpenObject = _this.handleOpenObject.bind(_assertThisInitialized(_this));
-    _this.handleCloseObject = _this.handleCloseObject.bind(_assertThisInitialized(_this));
-    _this.handleResize = _this.handleResize.bind(_assertThisInitialized(_this));
-    _this.handleSettingsChange = _this.handleSettingsChange.bind(_assertThisInitialized(_this));
-    _this.handleShow = _this.handleShow.bind(_assertThisInitialized(_this));
-    _this.handleTabBlur = _this.handleTabBlur.bind(_assertThisInitialized(_this));
-    _this.handleTabFocus = _this.handleTabFocus.bind(_assertThisInitialized(_this));
-    _this.handlePanelMount = _this.handlePanelMount.bind(_assertThisInitialized(_this));
-    _this.savePanelState = debounce(_this.savePanelState.bind(_assertThisInitialized(_this)), DEBOUNCE_PANEL_STATE_UPDATE);
-    _this.consoleRef = /*#__PURE__*/React.createRef();
-    var initialPanelState = props.panelState;
+class ConsolePanel extends PureComponent {
+  constructor(props) {
+    super(props);
+    this.handleFocusCommandHistory = this.handleFocusCommandHistory.bind(this);
+    this.handleOpenObject = this.handleOpenObject.bind(this);
+    this.handleCloseObject = this.handleCloseObject.bind(this);
+    this.handleResize = this.handleResize.bind(this);
+    this.handleSettingsChange = this.handleSettingsChange.bind(this);
+    this.handleShow = this.handleShow.bind(this);
+    this.handleTabBlur = this.handleTabBlur.bind(this);
+    this.handleTabFocus = this.handleTabFocus.bind(this);
+    this.handlePanelMount = this.handlePanelMount.bind(this);
+    this.savePanelState = debounce(this.savePanelState.bind(this), DEBOUNCE_PANEL_STATE_UPDATE);
+    this.consoleRef = /*#__PURE__*/React.createRef();
+    var {
+      panelState: initialPanelState
+    } = props;
 
     var panelState = _objectSpread(_objectSpread({}, DEFAULT_PANEL_STATE), initialPanelState || {});
 
-    var consoleSettings = panelState.consoleSettings,
-        itemIds = panelState.itemIds;
-    _this.state = {
-      consoleSettings: consoleSettings,
+    var {
+      consoleSettings,
+      itemIds
+    } = panelState;
+    this.state = {
+      consoleSettings,
       itemIds: new Map(itemIds),
       // eslint-disable-next-line react/no-unused-state
-      panelState: panelState // Dehydrated panel state that can load this panel
+      panelState // Dehydrated panel state that can load this panel
 
     };
-    return _this;
   }
 
-  _createClass(ConsolePanel, [{
-    key: "componentDidMount",
-    value: function componentDidMount() {
-      var glEventHub = this.props.glEventHub; // Need to close the disconnected panels when we're first loaded,
-      // as they may have been saved with the dashboard
+  componentDidMount() {
+    var {
+      glEventHub
+    } = this.props; // Need to close the disconnected panels when we're first loaded,
+    // as they may have been saved with the dashboard
 
-      this.closeDisconnectedPanels();
-      glEventHub.on(PanelEvent.MOUNT, this.handlePanelMount);
-    }
-  }, {
-    key: "componentDidUpdate",
-    value: function componentDidUpdate(prevProps, prevState) {
-      var _this$state = this.state,
-          consoleSettings = _this$state.consoleSettings,
-          itemIds = _this$state.itemIds;
-
-      if (prevState.consoleSettings !== consoleSettings || prevState.itemIds !== itemIds) {
-        this.savePanelState();
-      }
-    }
-  }, {
-    key: "componentWillUnmount",
-    value: function componentWillUnmount() {
-      var glEventHub = this.props.glEventHub;
-      this.savePanelState.flush();
-      glEventHub.off(PanelEvent.MOUNT, this.handlePanelMount);
-    }
-  }, {
-    key: "setItemId",
-    value: function setItemId(name, id) {
-      this.setState(function (_ref) {
-        var itemIds = _ref.itemIds;
-        var newItemIds = new Map(itemIds);
-        newItemIds.set(name, id);
-        return {
-          itemIds: newItemIds
-        };
-      });
-    }
-  }, {
-    key: "getItemId",
-    value: function getItemId(name) {
-      var createIfNecessary = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-      var itemIds = this.state.itemIds;
-      var id = itemIds.get(name);
-
-      if (id == null && createIfNecessary) {
-        id = shortid.generate();
-        this.setItemId(name, id);
-      }
+    this.closeDisconnectedPanels();
+    glEventHub.on(PanelEvent.MOUNT, this.handlePanelMount);
+  }
 
-      return id;
-    }
-  }, {
-    key: "handleTabBlur",
-    value: function handleTabBlur() {
-      if (this.consoleRef) {
-        this.consoleRef.blur();
-      }
-    }
-  }, {
-    key: "handleTabFocus",
-    value: function handleTabFocus() {
-      if (this.consoleRef) {
-        this.consoleRef.focus();
-      }
-    }
-  }, {
-    key: "handlePanelMount",
-    value: function handlePanelMount(panel) {
-      var _panel$props, _panel$props2, _panel$props2$metadat;
-
-      var itemIds = this.state.itemIds;
-      var panelId = panel === null || panel === void 0 ? void 0 : (_panel$props = panel.props) === null || _panel$props === void 0 ? void 0 : _panel$props.id;
-      var sourceId = panel === null || panel === void 0 ? void 0 : (_panel$props2 = panel.props) === null || _panel$props2 === void 0 ? void 0 : (_panel$props2$metadat = _panel$props2.metadata) === null || _panel$props2$metadat === void 0 ? void 0 : _panel$props2$metadat.sourcePanelId;
-
-      if (panelId && sourceId) {
-        // Check if the panel was created from a panel in this console
-        var pandelIds = new Set(itemIds.values());
-
-        if (pandelIds.has(sourceId)) {
-          // The Chart Panel does not have name so map panelId to panelId
-          this.setItemId(panelId, panelId);
-        }
-      }
+  componentDidUpdate(prevProps, prevState) {
+    var {
+      consoleSettings,
+      itemIds
+    } = this.state;
+
+    if (prevState.consoleSettings !== consoleSettings || prevState.itemIds !== itemIds) {
+      this.savePanelState();
     }
-  }, {
-    key: "handleFocusCommandHistory",
-    value: function handleFocusCommandHistory() {
-      var glEventHub = this.props.glEventHub;
-      glEventHub.emit(ConsoleEvent.FOCUS_HISTORY);
+  }
+
+  componentWillUnmount() {
+    var {
+      glEventHub
+    } = this.props;
+    this.savePanelState.flush();
+    glEventHub.off(PanelEvent.MOUNT, this.handlePanelMount);
+  }
+
+  setItemId(name, id) {
+    this.setState((_ref) => {
+      var {
+        itemIds
+      } = _ref;
+      var newItemIds = new Map(itemIds);
+      newItemIds.set(name, id);
+      return {
+        itemIds: newItemIds
+      };
+    });
+  }
+
+  getItemId(name) {
+    var createIfNecessary = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    var {
+      itemIds
+    } = this.state;
+    var id = itemIds.get(name);
+
+    if (id == null && createIfNecessary) {
+      id = shortid.generate();
+      this.setItemId(name, id);
     }
-  }, {
-    key: "handleResize",
-    value: function handleResize() {
-      this.updateDimensions();
+
+    return id;
+  }
+
+  handleTabBlur() {
+    if (this.consoleRef) {
+      this.consoleRef.blur();
     }
-  }, {
-    key: "handleShow",
-    value: function handleShow() {
-      this.updateDimensions();
+  }
+
+  handleTabFocus() {
+    if (this.consoleRef) {
+      this.consoleRef.focus();
     }
-  }, {
-    key: "handleOpenObject",
-    value: function handleOpenObject(object) {
-      var sessionWrapper = this.props.sessionWrapper;
-      var session = sessionWrapper.session;
-      var type = object.type;
-
-      if (ConsoleUtils.isTableType(type)) {
-        this.openTable(object, session);
-      } else if (ConsoleUtils.isFigureType(type)) {
-        this.openFigure(object, session);
-      } else if (ConsoleUtils.isPandas(type)) {
-        this.openPandas(object, session);
-      } else if (ConsoleUtils.isMatPlotLib(type)) {
-        this.openDataString(object, session);
-      } else {
-        log.error('Unknown object', object);
+  }
+
+  handlePanelMount(panel) {
+    var _panel$props, _panel$props2, _panel$props2$metadat;
+
+    var {
+      itemIds
+    } = this.state;
+    var panelId = panel === null || panel === void 0 ? void 0 : (_panel$props = panel.props) === null || _panel$props === void 0 ? void 0 : _panel$props.id;
+    var sourceId = panel === null || panel === void 0 ? void 0 : (_panel$props2 = panel.props) === null || _panel$props2 === void 0 ? void 0 : (_panel$props2$metadat = _panel$props2.metadata) === null || _panel$props2$metadat === void 0 ? void 0 : _panel$props2$metadat.sourcePanelId;
+
+    if (panelId && sourceId) {
+      // Check if the panel was created from a panel in this console
+      var pandelIds = new Set(itemIds.values());
+
+      if (pandelIds.has(sourceId)) {
+        // The Chart Panel does not have name so map panelId to panelId
+        this.setItemId(panelId, panelId);
       }
     }
-  }, {
-    key: "handleCloseObject",
-    value: function handleCloseObject(object) {
-      var name = object.name;
-      var id = this.getItemId(name, false);
-      var glEventHub = this.props.glEventHub;
-      glEventHub.emit(ControlEvent.CLOSE, id);
-    }
-  }, {
-    key: "handleSettingsChange",
-    value: function handleSettingsChange(consoleSettings) {
-      var glEventHub = this.props.glEventHub;
-      log.debug('handleSettingsChange', consoleSettings);
-      this.setState({
-        consoleSettings: consoleSettings
-      });
-      glEventHub.emit(ConsoleEvent.SETTINGS_CHANGED, consoleSettings);
-    }
-  }, {
-    key: "openTable",
-    value: function openTable(object, session) {
-      var name = object.name;
-      var id = this.getItemId(name);
-      var metadata = {
-        table: name
-      };
-      var glEventHub = this.props.glEventHub;
+  }
 
-      var makeModel = function makeModel() {
-        return session.getObject(object).then(function (table) {
-          return IrisGridModelFactory.makeModel(table, true);
-        });
-      };
+  handleFocusCommandHistory() {
+    var {
+      glEventHub
+    } = this.props;
+    glEventHub.emit(ConsoleEvent.FOCUS_HISTORY);
+  }
 
-      log.debug('openTable', id);
-      glEventHub.emit(IrisGridEvent.OPEN_GRID, name, makeModel, metadata, id);
-    }
-  }, {
-    key: "openFigure",
-    value: function openFigure(object, session) {
-      var name = object.name;
-      var id = this.getItemId(name);
-      var metadata = {
-        figure: name
-      };
+  handleResize() {
+    this.updateDimensions();
+  }
 
-      var makeModel = function makeModel() {
-        return session.getObject(object).then(function (result) {
-          return new FigureChartModel(result);
-        });
-      };
+  handleShow() {
+    this.updateDimensions();
+  }
 
-      var glEventHub = this.props.glEventHub;
-      glEventHub.emit(ChartEvent.OPEN, name, makeModel, metadata, id);
+  handleOpenObject(object) {
+    var {
+      sessionWrapper
+    } = this.props;
+    var {
+      session
+    } = sessionWrapper;
+    var {
+      type
+    } = object;
+
+    if (ConsoleUtils.isTableType(type)) {
+      this.openTable(object, session);
+    } else if (ConsoleUtils.isFigureType(type)) {
+      this.openFigure(object, session);
+    } else if (ConsoleUtils.isPandas(type)) {
+      this.openPandas(object, session);
+    } else {
+      log.error('Unknown object', object);
     }
-  }, {
-    key: "openPandas",
-    value: function openPandas(object, session) {
-      var name = object.name;
-      var id = this.getItemId(name);
-      var metadata = {
-        table: name
-      };
-      var glEventHub = this.props.glEventHub;
+  }
 
-      var makeModel = function makeModel() {
-        return session.getObject(object).then(function (table) {
-          return IrisGridModelFactory.makeModel(table, true);
-        });
-      };
+  handleCloseObject(object) {
+    var {
+      name
+    } = object;
+    var id = this.getItemId(name, false);
+    var {
+      glEventHub
+    } = this.props;
+    glEventHub.emit(ControlEvent.CLOSE, id);
+  }
 
-      log.debug('openPandas', id);
-      glEventHub.emit(PandasEvent.OPEN, name, makeModel, metadata, id);
-    }
-  }, {
-    key: "openDataString",
-    value: function openDataString(object, session) {
-      var name = object.name;
-      var id = this.getItemId(name);
-      var metadata = {
-        name: name
-      };
-      var glEventHub = this.props.glEventHub;
+  handleSettingsChange(consoleSettings) {
+    var {
+      glEventHub
+    } = this.props;
+    log.debug('handleSettingsChange', consoleSettings);
+    this.setState({
+      consoleSettings
+    });
+    glEventHub.emit(ConsoleEvent.SETTINGS_CHANGED, consoleSettings);
+  }
 
-      var makeModel = function makeModel() {
-        return session.getObject(object);
-      };
+  openTable(object, session) {
+    var {
+      name
+    } = object;
+    var id = this.getItemId(name);
+    var metadata = {
+      table: name
+    };
+    var {
+      glEventHub
+    } = this.props;
 
-      log.debug('openDataString', id);
-      glEventHub.emit(MatPlotLibEvent.OPEN, name, makeModel, metadata, id);
-    }
-  }, {
-    key: "addCommand",
-    value: function addCommand(command) {
-      var _this$consoleRef$curr;
-
-      var focus = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-      var execute = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-      (_this$consoleRef$curr = this.consoleRef.current) === null || _this$consoleRef$curr === void 0 ? void 0 : _this$consoleRef$curr.addCommand(command, focus, execute);
-    }
-    /**
-     * Close the disconnected panels from this session
-     * @param {boolean} force True to force the panels closed regardless of the current setting
-     */
-
-  }, {
-    key: "closeDisconnectedPanels",
-    value: function closeDisconnectedPanels() {
-      var force = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-      var _this$state2 = this.state,
-          consoleSettings = _this$state2.consoleSettings,
-          itemIds = _this$state2.itemIds;
-      var _consoleSettings$isCl = consoleSettings.isClosePanelsOnDisconnectEnabled,
-          isClosePanelsOnDisconnectEnabled = _consoleSettings$isCl === void 0 ? true : _consoleSettings$isCl;
-
-      if (!isClosePanelsOnDisconnectEnabled && !force) {
-        return;
-      }
+    var makeModel = () => session.getObject(object).then(table => IrisGridModelFactory.makeModel(table, true));
 
-      var panelIdsToClose = _toConsumableArray(itemIds.values());
+    log.debug('handleOpenTable', id);
+    glEventHub.emit(IrisGridEvent.OPEN_GRID, name, makeModel, metadata, id);
+  }
 
-      var glEventHub = this.props.glEventHub;
-      panelIdsToClose.forEach(function (panelId) {
-        glEventHub.emit(ControlEvent.CLOSE, panelId);
-      });
-      this.setState({
-        itemIds: new Map()
-      });
-    }
-  }, {
-    key: "savePanelState",
-    value: function savePanelState() {
-      var _this$state3 = this.state,
-          consoleSettings = _this$state3.consoleSettings,
-          itemIds = _this$state3.itemIds;
-      var panelState = {
-        consoleSettings: consoleSettings,
-        itemIds: _toConsumableArray(itemIds)
-      };
-      log.debug('Saving panel state', panelState); // eslint-disable-next-line react/no-unused-state
+  openFigure(object, session) {
+    var {
+      name
+    } = object;
+    var id = this.getItemId(name);
+    var metadata = {
+      figure: name
+    };
 
-      this.setState({
-        panelState: panelState
-      });
-    }
-  }, {
-    key: "updateDimensions",
-    value: function updateDimensions() {
-      var _this$consoleRef$curr2;
+    var makeModel = () => session.getObject(object).then(result => new FigureChartModel(result));
 
-      (_this$consoleRef$curr2 = this.consoleRef.current) === null || _this$consoleRef$curr2 === void 0 ? void 0 : _this$consoleRef$curr2.updateDimensions();
-    }
-  }, {
-    key: "render",
-    value: function render() {
-      var _this$props = this.props,
-          commandHistoryStorage = _this$props.commandHistoryStorage,
-          glContainer = _this$props.glContainer,
-          glEventHub = _this$props.glEventHub,
-          sessionWrapper = _this$props.sessionWrapper;
-      var _this$state4 = this.state,
-          consoleSettings = _this$state4.consoleSettings,
-          error = _this$state4.error;
-      var config = sessionWrapper.config,
-          session = sessionWrapper.session;
-      var sessionId = config.id,
-          language = config.type;
-      return /*#__PURE__*/React.createElement(Panel, {
-        componentPanel: this,
-        glContainer: glContainer,
-        glEventHub: glEventHub,
-        onResize: this.handleResize,
-        onShow: this.handleShow,
-        onTabFocus: this.handleTabFocus,
-        onTabBlur: this.handleTabBlur,
-        isLoaded: session != null,
-        errorMessage: error != null ? "".concat(error) : null
-      }, /*#__PURE__*/React.createElement(CSSTransition, {
-        "in": session != null,
-        timeout: ThemeExport.transitionMidMs,
-        classNames: "fade",
-        mountOnEnter: true,
-        unmountOnExit: true
-      }, /*#__PURE__*/React.createElement(React.Fragment, null, session && /*#__PURE__*/React.createElement(Console, {
-        ref: this.consoleRef,
-        settings: consoleSettings,
-        session: session,
-        focusCommandHistory: this.handleFocusCommandHistory,
-        openObject: this.handleOpenObject,
-        closeObject: this.handleCloseObject,
-        commandHistoryStorage: commandHistoryStorage,
-        onSettingsChange: this.handleSettingsChange,
-        language: language,
-        statusBarChildren: /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("div", null, "\xA0"), /*#__PURE__*/React.createElement("div", null, ConsoleConstants.LANGUAGE_MAP.get(language))),
-        scope: sessionId
-      }))));
+    var {
+      glEventHub
+    } = this.props;
+    glEventHub.emit(ChartEvent.OPEN, name, makeModel, metadata, id);
+  }
+
+  openPandas(object, session) {
+    var {
+      name
+    } = object;
+    var id = this.getItemId(name);
+    var metadata = {
+      table: name
+    };
+    var {
+      glEventHub
+    } = this.props;
+
+    var makeModel = () => session.getObject(object).then(table => IrisGridModelFactory.makeModel(table, true));
+
+    log.debug('handleOpenTable', id);
+    glEventHub.emit(PandasEvent.OPEN, name, makeModel, metadata, id);
+  }
+
+  addCommand(command) {
+    var _this$consoleRef$curr;
+
+    var focus = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    var execute = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    (_this$consoleRef$curr = this.consoleRef.current) === null || _this$consoleRef$curr === void 0 ? void 0 : _this$consoleRef$curr.addCommand(command, focus, execute);
+  }
+  /**
+   * Close the disconnected panels from this session
+   * @param {boolean} force True to force the panels closed regardless of the current setting
+   */
+
+
+  closeDisconnectedPanels() {
+    var force = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    var {
+      consoleSettings,
+      itemIds
+    } = this.state;
+    var {
+      isClosePanelsOnDisconnectEnabled = true
+    } = consoleSettings;
+
+    if (!isClosePanelsOnDisconnectEnabled && !force) {
+      return;
     }
-  }]);
 
-  return ConsolePanel;
-}(PureComponent);
+    var panelIdsToClose = [...itemIds.values()];
+    var {
+      glEventHub
+    } = this.props;
+    panelIdsToClose.forEach(panelId => {
+      glEventHub.emit(ControlEvent.CLOSE, panelId);
+    });
+    this.setState({
+      itemIds: new Map()
+    });
+  }
+
+  savePanelState() {
+    var {
+      consoleSettings,
+      itemIds
+    } = this.state;
+    var panelState = {
+      consoleSettings,
+      itemIds: [...itemIds]
+    };
+    log.debug('Saving panel state', panelState); // eslint-disable-next-line react/no-unused-state
+
+    this.setState({
+      panelState
+    });
+  }
+
+  updateDimensions() {
+    var _this$consoleRef$curr2;
+
+    (_this$consoleRef$curr2 = this.consoleRef.current) === null || _this$consoleRef$curr2 === void 0 ? void 0 : _this$consoleRef$curr2.updateDimensions();
+  }
+
+  render() {
+    var {
+      commandHistoryStorage,
+      glContainer,
+      glEventHub,
+      sessionWrapper,
+      timeZone
+    } = this.props;
+    var {
+      consoleSettings,
+      error
+    } = this.state;
+    var {
+      config,
+      session
+    } = sessionWrapper;
+    var {
+      id: sessionId,
+      type: language
+    } = config;
+    return /*#__PURE__*/React.createElement(Panel, {
+      componentPanel: this,
+      glContainer: glContainer,
+      glEventHub: glEventHub,
+      onResize: this.handleResize,
+      onShow: this.handleShow,
+      onTabFocus: this.handleTabFocus,
+      onTabBlur: this.handleTabBlur,
+      isLoaded: session != null,
+      errorMessage: error != null ? "".concat(error) : null
+    }, /*#__PURE__*/React.createElement(CSSTransition, {
+      in: session != null,
+      timeout: ThemeExport.transitionMidMs,
+      classNames: "fade",
+      mountOnEnter: true,
+      unmountOnExit: true
+    }, /*#__PURE__*/React.createElement(React.Fragment, null, session && /*#__PURE__*/React.createElement(Console, {
+      ref: this.consoleRef,
+      settings: consoleSettings,
+      session: session,
+      focusCommandHistory: this.handleFocusCommandHistory,
+      openObject: this.handleOpenObject,
+      closeObject: this.handleCloseObject,
+      commandHistoryStorage: commandHistoryStorage,
+      onSettingsChange: this.handleSettingsChange,
+      language: language,
+      statusBarChildren: /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("div", null, "\xA0"), /*#__PURE__*/React.createElement("div", null, ConsoleConstants.LANGUAGE_MAP.get(language))),
+      scope: sessionId,
+      timeZone: timeZone
+    }))));
+  }
+
+}
 
 _defineProperty(ConsolePanel, "COMPONENT", 'ConsolePanel');
 
@@ -446,18 +399,18 @@ ConsolePanel.propTypes = {
       type: PropTypes.string,
       id: PropTypes.string
     })
-  }).isRequired
+  }).isRequired,
+  timeZone: PropTypes.string.isRequired
 };
 ConsolePanel.defaultProps = {
   panelState: null
 };
 
-var mapStateToProps = function mapStateToProps(state, ownProps) {
-  return {
-    commandHistoryStorage: getCommandHistoryStorage(state),
-    sessionWrapper: getDashboardSessionWrapper(state, ownProps.localDashboardId)
-  };
-};
+var mapStateToProps = (state, ownProps) => ({
+  commandHistoryStorage: getCommandHistoryStorage(state),
+  sessionWrapper: getDashboardSessionWrapper(state, ownProps.localDashboardId),
+  timeZone: getTimeZone(state)
+});
 
 export default connect(mapStateToProps, null, null, {
   forwardRef: true