@deephaven/console 0.5.2-matplotlib.2 → 0.6.0

package/dist/Console.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; }
 
 /**
@@ -51,79 +17,90 @@ import throttle from 'lodash.throttle';
 import dh, { PropTypes as APIPropTypes } from '@deephaven/jsapi-shim';
 import Log from '@deephaven/log';
 import { Pending } from '@deephaven/utils';
-import ConsoleHistory from './console-history/ConsoleHistory';
-import SHORTCUTS from './ConsoleShortcuts';
-import LogLevel from './log/LogLevel';
-import ConsoleInput from './ConsoleInput';
-import ConsoleUtils from './common/ConsoleUtils';
-import CsvOverlay from './csv/CsvOverlay';
-import CsvInputBar from './csv/CsvInputBar';
+import ConsoleHistory from "./console-history/ConsoleHistory.js";
+import SHORTCUTS from "./ConsoleShortcuts.js";
+import LogLevel from "./log/LogLevel.js";
+import ConsoleInput from "./ConsoleInput.js";
+import ConsoleUtils from "./common/ConsoleUtils.js";
+import CsvOverlay from "./csv/CsvOverlay.js";
+import CsvInputBar from "./csv/CsvInputBar.js";
 import "./Console.css";
-import ConsoleStatusBar from './ConsoleStatusBar';
-import StoragePropTypes from './StoragePropTypes';
+import ConsoleStatusBar from "./ConsoleStatusBar.js";
+import StoragePropTypes from "./StoragePropTypes.js";
 var log = Log.module('Console');
 var DEFAULT_SETTINGS = {
   isAutoLaunchPanelsEnabled: true,
   isPrintStdOutEnabled: true,
   isClosePanelsOnDisconnectEnabled: true
 };
-export var Console = /*#__PURE__*/function (_PureComponent) {
-  _inherits(Console, _PureComponent);
-
-  var _super = _createSuper(Console);
-
-  function Console(props) {
-    var _this;
-
-    _classCallCheck(this, Console);
-
-    _this = _super.call(this, props);
+export class Console extends PureComponent {
+  /**
+   * Check if the provided log level is an error type
+   * @param {LogLevel} logLevel The LogLevel being checked
+   * @returns {boolean} true if the log level is an error level log
+   */
+  static isErrorLevel(logLevel) {
+    return logLevel === LogLevel.STDERR || logLevel === LogLevel.ERROR || logLevel === LogLevel.FATAL;
+  }
+  /**
+   * Check if the provided log level is output level
+   * @param {LogLevel} logLevel The LogLevel being checked
+   * @returns {boolean} true if the log level should be output to the console
+   */
 
-    _defineProperty(_assertThisInitialized(_this), "getObjects", memoize(function (objectMap) {
-      return _toConsumableArray(objectMap.values());
-    }));
 
-    _defineProperty(_assertThisInitialized(_this), "getContextActions", memoize(function (actions) {
-      return [].concat(_toConsumableArray(actions), [{
-        action: _this.handleClearShortcut,
-        shortcut: SHORTCUTS.CONSOLE.CLEAR
-      }, {
-        action: _this.handleFocusHistory,
-        shortcut: SHORTCUTS.CONSOLE.FOCUS_HISTORY
-      }]);
-    }));
+  static isOutputLevel(logLevel) {
+    // We want all errors to be output, in addition to STDOUT.
+    // That way the user is more likely to see them.
+    return logLevel === LogLevel.STDOUT || Console.isErrorLevel(logLevel);
+  }
 
-    _this.handleCommandResult = _this.handleCommandResult.bind(_assertThisInitialized(_this));
-    _this.handleCommandStarted = _this.handleCommandStarted.bind(_assertThisInitialized(_this));
-    _this.handleCommandSubmit = _this.handleCommandSubmit.bind(_assertThisInitialized(_this));
-    _this.handleClearShortcut = _this.handleClearShortcut.bind(_assertThisInitialized(_this));
-    _this.handleFocusHistory = _this.handleFocusHistory.bind(_assertThisInitialized(_this));
-    _this.handleLogMessage = _this.handleLogMessage.bind(_assertThisInitialized(_this));
-    _this.handleOverflowActions = _this.handleOverflowActions.bind(_assertThisInitialized(_this));
-    _this.handleScrollPaneScroll = _this.handleScrollPaneScroll.bind(_assertThisInitialized(_this));
-    _this.handleToggleAutoLaunchPanels = _this.handleToggleAutoLaunchPanels.bind(_assertThisInitialized(_this));
-    _this.handleToggleClosePanelsOnDisconnect = _this.handleToggleClosePanelsOnDisconnect.bind(_assertThisInitialized(_this));
-    _this.handleTogglePrintStdout = _this.handleTogglePrintStdout.bind(_assertThisInitialized(_this));
-    _this.processLogMessageQueue = throttle(_this.processLogMessageQueue.bind(_assertThisInitialized(_this)), Console.LOG_THROTTLE);
-    _this.handleUploadCsv = _this.handleUploadCsv.bind(_assertThisInitialized(_this));
-    _this.handleHideCsv = _this.handleHideCsv.bind(_assertThisInitialized(_this));
-    _this.handleCsvFileOpened = _this.handleCsvFileOpened.bind(_assertThisInitialized(_this));
-    _this.handleCsvPaste = _this.handleCsvPaste.bind(_assertThisInitialized(_this));
-    _this.handleDragEnter = _this.handleDragEnter.bind(_assertThisInitialized(_this));
-    _this.handleDragLeave = _this.handleDragLeave.bind(_assertThisInitialized(_this));
-    _this.handleClearDragError = _this.handleClearDragError.bind(_assertThisInitialized(_this));
-    _this.handleOpenCsvTable = _this.handleOpenCsvTable.bind(_assertThisInitialized(_this));
-    _this.handleCsvUpdate = _this.handleCsvUpdate.bind(_assertThisInitialized(_this));
-    _this.handleCsvError = _this.handleCsvError.bind(_assertThisInitialized(_this));
-    _this.handleCsvInProgress = _this.handleCsvInProgress.bind(_assertThisInitialized(_this));
-    _this.cancelListener = null;
-    _this.consolePane = /*#__PURE__*/React.createRef();
-    _this.consoleInput = /*#__PURE__*/React.createRef();
-    _this.consoleHistoryScrollPane = /*#__PURE__*/React.createRef();
-    _this.pending = new Pending();
-    _this.queuedLogMessages = [];
-    var settings = _this.props.settings;
-    _this.state = _objectSpread(_objectSpread({
+  constructor(props) {
+    super(props);
+
+    _defineProperty(this, "getObjects", memoize(objectMap => [...objectMap.values()]));
+
+    _defineProperty(this, "getContextActions", memoize(actions => [...actions, {
+      action: this.handleClearShortcut,
+      shortcut: SHORTCUTS.CONSOLE.CLEAR
+    }, {
+      action: this.handleFocusHistory,
+      shortcut: SHORTCUTS.CONSOLE.FOCUS_HISTORY
+    }]));
+
+    this.handleCommandResult = this.handleCommandResult.bind(this);
+    this.handleCommandStarted = this.handleCommandStarted.bind(this);
+    this.handleCommandSubmit = this.handleCommandSubmit.bind(this);
+    this.handleClearShortcut = this.handleClearShortcut.bind(this);
+    this.handleFocusHistory = this.handleFocusHistory.bind(this);
+    this.handleLogMessage = this.handleLogMessage.bind(this);
+    this.handleOverflowActions = this.handleOverflowActions.bind(this);
+    this.handleScrollPaneScroll = this.handleScrollPaneScroll.bind(this);
+    this.handleToggleAutoLaunchPanels = this.handleToggleAutoLaunchPanels.bind(this);
+    this.handleToggleClosePanelsOnDisconnect = this.handleToggleClosePanelsOnDisconnect.bind(this);
+    this.handleTogglePrintStdout = this.handleTogglePrintStdout.bind(this);
+    this.processLogMessageQueue = throttle(this.processLogMessageQueue.bind(this), Console.LOG_THROTTLE);
+    this.handleUploadCsv = this.handleUploadCsv.bind(this);
+    this.handleHideCsv = this.handleHideCsv.bind(this);
+    this.handleCsvFileOpened = this.handleCsvFileOpened.bind(this);
+    this.handleCsvPaste = this.handleCsvPaste.bind(this);
+    this.handleDragEnter = this.handleDragEnter.bind(this);
+    this.handleDragLeave = this.handleDragLeave.bind(this);
+    this.handleClearDragError = this.handleClearDragError.bind(this);
+    this.handleOpenCsvTable = this.handleOpenCsvTable.bind(this);
+    this.handleCsvUpdate = this.handleCsvUpdate.bind(this);
+    this.handleCsvError = this.handleCsvError.bind(this);
+    this.handleCsvInProgress = this.handleCsvInProgress.bind(this);
+    this.cancelListener = null;
+    this.consolePane = /*#__PURE__*/React.createRef();
+    this.consoleInput = /*#__PURE__*/React.createRef();
+    this.consoleHistoryScrollPane = /*#__PURE__*/React.createRef();
+    this.pending = new Pending();
+    this.queuedLogMessages = [];
+    var {
+      settings
+    } = this.props;
+    this.state = _objectSpread(_objectSpread({
       // Need separate histories as console history has stdout/stderr output
       consoleHistory: [],
       // Height of the viewport of the console input and history
@@ -139,857 +116,814 @@ export var Console = /*#__PURE__*/function (_PureComponent) {
       dragError: null,
       csvUploadInProgress: false
     }, DEFAULT_SETTINGS), settings);
-    return _this;
   }
 
-  _createClass(Console, [{
-    key: "componentDidMount",
-    value: function componentDidMount() {
-      this.initConsoleLogging();
-      var session = this.props.session;
-      session.addEventListener(dh.IdeSession.EVENT_COMMANDSTARTED, this.handleCommandStarted);
-      this.updateDimensions();
-    }
-  }, {
-    key: "componentDidUpdate",
-    value: function componentDidUpdate(prevProps, prevState) {
-      var props = this.props,
-          state = this.state;
-      this.sendSettingsChange(prevState, state);
-
-      if (props.disconnectedChildren != null && prevProps.disconnectedChildren == null) {
-        this.disconnect();
-      }
-    }
-  }, {
-    key: "componentWillUnmount",
-    value: function componentWillUnmount() {
-      var session = this.props.session;
-      session.removeEventListener(dh.IdeSession.EVENT_COMMANDSTARTED, this.handleCommandStarted);
-      this.pending.cancel();
-      this.processLogMessageQueue.cancel();
-      this.deinitConsoleLogging();
-    }
-  }, {
-    key: "initConsoleLogging",
-    value: function initConsoleLogging() {
-      var session = this.props.session;
-      this.cancelListener = session.onLogMessage(this.handleLogMessage);
-    }
-  }, {
-    key: "deinitConsoleLogging",
-    value: function deinitConsoleLogging() {
-      if (this.cancelListener != null) {
-        this.cancelListener();
-        this.cancelListener = null;
-      }
-    }
-  }, {
-    key: "disconnect",
-    value: function disconnect() {
-      this.setState(function (_ref) {
-        var consoleHistory = _ref.consoleHistory;
-        return {
-          // Reset any pending commands with an empty result, disable all tables/widgets
-          consoleHistory: consoleHistory.map(function (item) {
-            if (item.result == null) {
-              return _objectSpread(_objectSpread({}, item), {}, {
-                endTime: Date.now(),
-                result: {}
-              });
-            }
-
-            var result = item.result;
-
-            if (result.changes) {
-              var disabledItems = [].concat(result.changes.created).concat(result.changes.updated);
-              return _objectSpread(_objectSpread({}, item), {}, {
-                disabledItems: disabledItems
-              });
-            }
-
-            return item;
-          }),
-          objectHistoryMap: new Map(),
-          objectMap: new Map()
-        };
-      });
+  componentDidMount() {
+    this.initConsoleLogging();
+    var {
+      session
+    } = this.props;
+    session.addEventListener(dh.IdeSession.EVENT_COMMANDSTARTED, this.handleCommandStarted);
+    this.updateDimensions();
+  }
+
+  componentDidUpdate(prevProps, prevState) {
+    var {
+      props,
+      state
+    } = this;
+    this.sendSettingsChange(prevState, state);
+
+    if (props.disconnectedChildren != null && prevProps.disconnectedChildren == null) {
+      this.disconnect();
     }
-  }, {
-    key: "handleClearShortcut",
-    value: function handleClearShortcut(event) {
-      event.preventDefault();
-      event.stopPropagation();
-      this.consoleInput.current.clear();
+  }
+
+  componentWillUnmount() {
+    var {
+      session
+    } = this.props;
+    session.removeEventListener(dh.IdeSession.EVENT_COMMANDSTARTED, this.handleCommandStarted);
+    this.pending.cancel();
+    this.processLogMessageQueue.cancel();
+    this.deinitConsoleLogging();
+  }
+
+  initConsoleLogging() {
+    var {
+      session
+    } = this.props;
+    this.cancelListener = session.onLogMessage(this.handleLogMessage);
+  }
+
+  deinitConsoleLogging() {
+    if (this.cancelListener != null) {
+      this.cancelListener();
+      this.cancelListener = null;
     }
-  }, {
-    key: "handleCommandStarted",
-    value: function handleCommandStarted(event) {
-      var _this2 = this;
-
-      var _event$detail = event.detail,
-          code = _event$detail.code,
-          result = _event$detail.result;
-      var wrappedResult = this.pending.add(result);
-      var historyItem = {
-        command: code,
-        result: null,
-        disabledObjects: [],
-        startTime: Date.now(),
-        endTime: null,
-        cancelResult: function cancelResult() {
-          result.cancel();
-        },
-        wrappedResult: wrappedResult
+  }
+
+  disconnect() {
+    this.setState((_ref) => {
+      var {
+        consoleHistory
+      } = _ref;
+      return {
+        // Reset any pending commands with an empty result, disable all tables/widgets
+        consoleHistory: consoleHistory.map(item => {
+          if (item.result == null) {
+            return _objectSpread(_objectSpread({}, item), {}, {
+              endTime: Date.now(),
+              result: {}
+            });
+          }
+
+          var {
+            result
+          } = item;
+
+          if (result.changes) {
+            var disabledItems = [].concat(result.changes.created).concat(result.changes.updated);
+            return _objectSpread(_objectSpread({}, item), {}, {
+              disabledItems
+            });
+          }
+
+          return item;
+        }),
+        objectHistoryMap: new Map(),
+        objectMap: new Map()
       };
-      var _this$props = this.props,
-          commandHistoryStorage = _this$props.commandHistoryStorage,
-          language = _this$props.language,
-          scope = _this$props.scope;
-      var workspaceItemPromise = commandHistoryStorage.addItem(language, scope, code, {
-        command: code,
-        startTime: new Date().toJSON(),
-        endTime: null,
-        result: null
-      });
-      workspaceItemPromise["catch"](function (err) {
-        log.debug('Error adding workspace item', err);
-      });
-      this.setState(function (state) {
-        return {
-          consoleHistory: state.consoleHistory.concat(historyItem)
-        };
-      }, function () {
-        _this2.scrollConsoleHistoryToBottom(true);
-      });
-      wrappedResult.then(function (resolved) {
-        _this2.handleCommandResult(resolved, historyItem, workspaceItemPromise);
-      })["catch"](function (error) {
-        _this2.handleCommandError(error, historyItem, workspaceItemPromise);
-      });
+    });
+  }
+
+  handleClearShortcut(event) {
+    event.preventDefault();
+    event.stopPropagation();
+    this.consoleInput.current.clear();
+  }
+
+  handleCommandStarted(event) {
+    var {
+      code,
+      result
+    } = event.detail;
+    var wrappedResult = this.pending.add(result);
+    var historyItem = {
+      command: code,
+      result: null,
+      disabledObjects: [],
+      startTime: Date.now(),
+      endTime: null,
+      cancelResult: () => {
+        result.cancel();
+      },
+      wrappedResult
+    };
+    var {
+      commandHistoryStorage,
+      language,
+      scope
+    } = this.props;
+    var workspaceItemPromise = commandHistoryStorage.addItem(language, scope, code, {
+      command: code,
+      startTime: new Date().toJSON(),
+      endTime: null,
+      result: null
+    });
+    workspaceItemPromise.catch(err => {
+      log.debug('Error adding workspace item', err);
+    });
+    this.setState(state => ({
+      consoleHistory: state.consoleHistory.concat(historyItem)
+    }), () => {
+      this.scrollConsoleHistoryToBottom(true);
+    });
+    wrappedResult.then(resolved => {
+      this.handleCommandResult(resolved, historyItem, workspaceItemPromise);
+    }).catch(error => {
+      this.handleCommandError(error, historyItem, workspaceItemPromise);
+    });
+  }
+
+  handleCommandResult(result, historyItemParam, workspaceItemPromise) {
+    var historyItem = historyItemParam;
+    historyItem.wrappedResult = null;
+    historyItem.cancelResult = null;
+
+    if (!result) {
+      return;
     }
-  }, {
-    key: "handleCommandResult",
-    value: function handleCommandResult(result, historyItemParam, workspaceItemPromise) {
-      var historyItem = historyItemParam;
-      historyItem.wrappedResult = null;
-      historyItem.cancelResult = null;
-
-      if (!result) {
-        return;
-      }
 
-      historyItem.result = result;
-      this.updateHistory(result, historyItem);
-      this.updateKnownObjects(historyItem);
-      this.updateWorkspaceHistoryItem({
-        error: result.error
-      }, workspaceItemPromise);
-      this.closeRemovedItems(result.changes);
-      this.openUpdatedItems(result.changes);
+    historyItem.result = result;
+    this.updateHistory(result, historyItem);
+    this.updateKnownObjects(historyItem);
+    this.updateWorkspaceHistoryItem({
+      error: result.error
+    }, workspaceItemPromise);
+    this.closeRemovedItems(result.changes);
+    this.openUpdatedItems(result.changes);
+  }
+
+  handleCommandError(error, historyItemParam, workspaceItemPromise) {
+    var historyItem = historyItemParam;
+    historyItem.wrappedResult = null;
+    historyItem.cancelResult = null;
+
+    if (error && error.isCanceled) {
+      log.debug('Called handleCommandError on a cancelled promise result');
+      return;
     }
-  }, {
-    key: "handleCommandError",
-    value: function handleCommandError(error, historyItemParam, workspaceItemPromise) {
-      var historyItem = historyItemParam;
-      historyItem.wrappedResult = null;
-      historyItem.cancelResult = null;
-
-      if (error && error.isCanceled) {
-        log.debug('Called handleCommandError on a cancelled promise result');
-        return;
-      }
 
-      this.updateWorkspaceHistoryItem({
-        error: "".concat(error)
-      }, workspaceItemPromise);
-      this.setState(function (state) {
-        var history = state.consoleHistory.concat();
-        var index = history.lastIndexOf(historyItem);
-        historyItem.endTime = Date.now();
-        historyItem.result = {
-          error: error
-        };
-        history[index] = _objectSpread({}, historyItem);
-        return {
-          consoleHistory: history
-        };
-      });
+    this.updateWorkspaceHistoryItem({
+      error: "".concat(error)
+    }, workspaceItemPromise);
+    this.setState(state => {
+      var history = state.consoleHistory.concat();
+      var index = history.lastIndexOf(historyItem);
+      historyItem.endTime = Date.now();
+      historyItem.result = {
+        error
+      };
+      history[index] = _objectSpread({}, historyItem);
+      return {
+        consoleHistory: history
+      };
+    });
+  }
+
+  handleFocusHistory(event) {
+    event.preventDefault();
+    event.stopPropagation();
+    var {
+      focusCommandHistory
+    } = this.props;
+    focusCommandHistory();
+  }
+
+  handleLogMessage(message) {
+    var {
+      isPrintStdOutEnabled
+    } = this.state;
+
+    if (!isPrintStdOutEnabled) {
+      return;
     }
-  }, {
-    key: "handleFocusHistory",
-    value: function handleFocusHistory(event) {
-      event.preventDefault();
-      event.stopPropagation();
-      var focusCommandHistory = this.props.focusCommandHistory;
-      focusCommandHistory();
+
+    if (Console.isOutputLevel(message.logLevel)) {
+      this.queueLogMessage(message.message, message.logLevel);
     }
-  }, {
-    key: "handleLogMessage",
-    value: function handleLogMessage(message) {
-      var isPrintStdOutEnabled = this.state.isPrintStdOutEnabled;
+  }
 
-      if (!isPrintStdOutEnabled) {
-        return;
-      }
+  queueLogMessage(message, logLevel) {
+    var result = {};
 
-      if (Console.isOutputLevel(message.logLevel)) {
-        this.queueLogMessage(message.message, message.logLevel);
-      }
+    if (Console.isErrorLevel(logLevel)) {
+      result.error = message;
+    } else {
+      result.message = message;
     }
-  }, {
-    key: "queueLogMessage",
-    value: function queueLogMessage(message, logLevel) {
-      var result = {};
-
-      if (Console.isErrorLevel(logLevel)) {
-        result.error = message;
-      } else {
-        result.message = message;
-      }
 
-      var historyItem = {
-        command: null,
-        result: result
+    var historyItem = {
+      command: null,
+      result
+    };
+    this.queuedLogMessages.push(historyItem);
+    this.processLogMessageQueue();
+  }
+
+  processLogMessageQueue() {
+    this.scrollConsoleHistoryToBottom();
+    this.setState(state => {
+      log.debug2('processLogMessageQueue', this.queuedLogMessages.length, ' items');
+      var {
+        consoleHistory
+      } = state;
+      consoleHistory = consoleHistory.concat(this.queuedLogMessages);
+      this.queuedLogMessages = [];
+      return {
+        consoleHistory
       };
-      this.queuedLogMessages.push(historyItem);
-      this.processLogMessageQueue();
-    }
-  }, {
-    key: "processLogMessageQueue",
-    value: function processLogMessageQueue() {
-      var _this3 = this;
-
-      this.scrollConsoleHistoryToBottom();
-      this.setState(function (state) {
-        log.debug2('processLogMessageQueue', _this3.queuedLogMessages.length, ' items');
-        var consoleHistory = state.consoleHistory;
-        consoleHistory = consoleHistory.concat(_this3.queuedLogMessages);
-        _this3.queuedLogMessages = [];
-        return {
-          consoleHistory: consoleHistory
-        };
-      });
-    }
-  }, {
-    key: "openUpdatedItems",
-    value: function openUpdatedItems(changes) {
-      var isAutoLaunchPanelsEnabled = this.state.isAutoLaunchPanelsEnabled;
+    });
+  }
 
-      if (!changes || !isAutoLaunchPanelsEnabled) {
-        return;
-      }
+  openUpdatedItems(changes) {
+    var {
+      isAutoLaunchPanelsEnabled
+    } = this.state;
 
-      var openObject = this.props.openObject;
-      [].concat(_toConsumableArray(changes.created), _toConsumableArray(changes.updated)).filter(function (object) {
-        return ConsoleUtils.isOpenableType(object.type);
-      }).forEach(function (object) {
-        return openObject(object);
-      });
+    if (!changes || !isAutoLaunchPanelsEnabled) {
+      return;
     }
-  }, {
-    key: "closeRemovedItems",
-    value: function closeRemovedItems(changes) {
-      if (!changes || !changes.removed || changes.removed.length === 0) {
-        return;
-      }
 
-      var closeObject = this.props.closeObject;
-      var removed = changes.removed;
-      removed.filter(function (object) {
-        return ConsoleUtils.isOpenableType(object.type);
-      }).forEach(function (object) {
-        return closeObject(object);
-      });
+    var {
+      openObject
+    } = this.props;
+    [...changes.created, ...changes.updated].filter(object => ConsoleUtils.isOpenableType(object.type)).forEach(object => openObject(object));
+  }
+
+  closeRemovedItems(changes) {
+    if (!changes || !changes.removed || changes.removed.length === 0) {
+      return;
     }
-  }, {
-    key: "updateHistory",
-    value: function updateHistory(result, historyItemParam) {
-      var historyItem = historyItemParam;
 
-      if (!result || !result.changes || !historyItem) {
-        return;
-      }
+    var {
+      closeObject
+    } = this.props;
+    var {
+      removed
+    } = changes;
+    removed.filter(object => ConsoleUtils.isOpenableType(object.type)).forEach(object => closeObject(object));
+  }
 
-      historyItem.endTime = Date.now();
-      this.scrollConsoleHistoryToBottom(); // Update history to re-render items as necessary
+  updateHistory(result, historyItemParam) {
+    var historyItem = historyItemParam;
 
-      this.setState(function (state) {
-        var consoleHistory = state.consoleHistory.concat();
-        return {
-          consoleHistory: consoleHistory
-        };
-      });
+    if (!result || !result.changes || !historyItem) {
+      return;
     }
-  }, {
-    key: "updateKnownObjects",
-    value: function updateKnownObjects(historyItem) {
-      var changes = historyItem.result.changes;
-
-      if (!changes || (!changes.created || changes.created.length === 0) && (!changes.updated || changes.updated.length === 0) && (!changes.removed || changes.removed.length === 0)) {
-        log.debug2('updateKnownObjects no changes');
-        return;
-      }
 
-      this.setState(function (state) {
-        var history = state.consoleHistory.concat();
-        var itemIndex = history.lastIndexOf(historyItem);
+    historyItem.endTime = Date.now();
+    this.scrollConsoleHistoryToBottom(); // Update history to re-render items as necessary
 
-        if (itemIndex < 0) {
-          log.error("historyItem not found in state.consoleHistory");
-          return null;
-        }
+    this.setState(state => {
+      var consoleHistory = state.consoleHistory.concat();
+      return {
+        consoleHistory
+      };
+    });
+  }
+
+  updateKnownObjects(historyItem) {
+    var {
+      changes
+    } = historyItem.result;
 
-        var objectHistoryMap = new Map(state.objectHistoryMap);
-        var objectMap = new Map(state.objectMap);
+    if (!changes || (!changes.created || changes.created.length === 0) && (!changes.updated || changes.updated.length === 0) && (!changes.removed || changes.removed.length === 0)) {
+      log.debug2('updateKnownObjects no changes');
+      return;
+    }
 
-        var disableOldObject = function disableOldObject(object) {
-          var isRemoved = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-          var name = object.name;
-          var oldIndex = objectHistoryMap.get(name); // oldIndex can be -1 if a object is active but doesn't have a command in consoleHistory
-          // this can happen after clearing the console using 'clear' or 'cls' command
+    this.setState(state => {
+      var history = state.consoleHistory.concat();
+      var itemIndex = history.lastIndexOf(historyItem);
 
-          if (oldIndex >= 0) {
-            // disable outdated object variable in the old consoleHistory item
-            history[oldIndex].disabledObjects = history[oldIndex].disabledObjects.concat(name);
-            history[oldIndex] = _objectSpread({}, history[oldIndex]);
-          }
+      if (itemIndex < 0) {
+        log.error("historyItem not found in state.consoleHistory");
+        return null;
+      }
+
+      var objectHistoryMap = new Map(state.objectHistoryMap);
+      var objectMap = new Map(state.objectMap);
+
+      var disableOldObject = function disableOldObject(object) {
+        var isRemoved = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+        var {
+          name
+        } = object;
+        var oldIndex = objectHistoryMap.get(name); // oldIndex can be -1 if a object is active but doesn't have a command in consoleHistory
+        // this can happen after clearing the console using 'clear' or 'cls' command
+
+        if (oldIndex >= 0) {
+          // disable outdated object variable in the old consoleHistory item
+          history[oldIndex].disabledObjects = history[oldIndex].disabledObjects.concat(name);
+          history[oldIndex] = _objectSpread({}, history[oldIndex]);
+        }
 
-          objectHistoryMap.set(name, itemIndex);
+        objectHistoryMap.set(name, itemIndex);
 
-          if (isRemoved) {
-            objectMap["delete"](name);
-          } else {
-            objectMap.set(name, object);
-          }
-        };
-
-        changes.updated.forEach(function (object) {
-          return disableOldObject(object);
-        });
-        changes.removed.forEach(function (object) {
-          return disableOldObject(object, true);
-        }); // Created objects have to be processed after removed
-        // in case the same object name is present in both removed and created
-
-        changes.created.forEach(function (object) {
-          var name = object.name;
-          objectHistoryMap.set(name, itemIndex);
+        if (isRemoved) {
+          objectMap.delete(name);
+        } else {
           objectMap.set(name, object);
-        });
-        return {
-          objectHistoryMap: objectHistoryMap,
-          objectMap: objectMap,
-          consoleHistory: history
-        };
-      });
-    }
-    /**
-     * Updates an existing workspace CommandHistoryItem
-     * @param {object} result The result to store with the history item. Could be empty object for success
-     * @param {Promise<object>} workspaceItemPromise The workspace data row promise for the workspace item to be updated
-     */
-
-  }, {
-    key: "updateWorkspaceHistoryItem",
-    value: function updateWorkspaceHistoryItem(result, workspaceItemPromise) {
-      var _this4 = this;
-
-      var promise = this.pending.add(workspaceItemPromise);
-      var endTime = new Date().toJSON();
-      promise.then(function (workspaceItem) {
-        var updatedItem = _objectSpread(_objectSpread({}, workspaceItem), {}, {
-          data: _objectSpread(_objectSpread({}, workspaceItem.data), {}, {
-            endTime: endTime,
-            result: result
-          })
-        });
-
-        var _this4$props = _this4.props,
-            commandHistoryStorage = _this4$props.commandHistoryStorage,
-            language = _this4$props.language;
-        commandHistoryStorage.updateItem(language, updatedItem)["catch"](function (err) {
-          log.warn('Error updating command history storage', err);
-        });
-      })["catch"](function (err) {
-        log.debug('Error updating workspace history item', err);
-      });
-    }
-  }, {
-    key: "scrollConsoleHistoryToBottom",
-    value: function scrollConsoleHistoryToBottom() {
-      var force = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-      var pane = this.consoleHistoryScrollPane.current;
-
-      if (!force && pane.scrollTop < pane.scrollHeight - pane.offsetHeight) {
-        return;
-      }
+        }
+      };
+
+      changes.updated.forEach(object => disableOldObject(object));
+      changes.removed.forEach(object => disableOldObject(object, true)); // Created objects have to be processed after removed
+      // in case the same object name is present in both removed and created
 
-      window.requestAnimationFrame(function () {
-        pane.scrollTop = pane.scrollHeight;
+      changes.created.forEach(object => {
+        var {
+          name
+        } = object;
+        objectHistoryMap.set(name, itemIndex);
+        objectMap.set(name, object);
       });
-    }
-  }, {
-    key: "handleScrollPaneScroll",
-    value: function handleScrollPaneScroll() {
-      var scrollPane = this.consoleHistoryScrollPane.current;
-
-      if (scrollPane.scrollTop > 0 && scrollPane.scrollHeight > scrollPane.clientHeight) {
-        this.setState({
-          isScrollDecorationShown: true
-        });
-      } else {
-        this.setState({
-          isScrollDecorationShown: false
-        });
-      }
-    }
-  }, {
-    key: "handleToggleAutoLaunchPanels",
-    value: function handleToggleAutoLaunchPanels() {
-      this.setState(function (state) {
-        return {
-          isAutoLaunchPanelsEnabled: !state.isAutoLaunchPanelsEnabled
-        };
+      return {
+        objectHistoryMap,
+        objectMap,
+        consoleHistory: history
+      };
+    });
+  }
+  /**
+   * Updates an existing workspace CommandHistoryItem
+   * @param {object} result The result to store with the history item. Could be empty object for success
+   * @param {Promise<object>} workspaceItemPromise The workspace data row promise for the workspace item to be updated
+   */
+
+
+  updateWorkspaceHistoryItem(result, workspaceItemPromise) {
+    var promise = this.pending.add(workspaceItemPromise);
+    var endTime = new Date().toJSON();
+    promise.then(workspaceItem => {
+      var updatedItem = _objectSpread(_objectSpread({}, workspaceItem), {}, {
+        data: _objectSpread(_objectSpread({}, workspaceItem.data), {}, {
+          endTime,
+          result
+        })
       });
-    }
-  }, {
-    key: "handleToggleClosePanelsOnDisconnect",
-    value: function handleToggleClosePanelsOnDisconnect() {
-      this.setState(function (state) {
-        return {
-          isClosePanelsOnDisconnectEnabled: !state.isClosePanelsOnDisconnectEnabled
-        };
+
+      var {
+        commandHistoryStorage,
+        language
+      } = this.props;
+      commandHistoryStorage.updateItem(language, updatedItem).catch(err => {
+        log.warn('Error updating command history storage', err);
       });
+    }).catch(err => {
+      log.debug('Error updating workspace history item', err);
+    });
+  }
+
+  scrollConsoleHistoryToBottom() {
+    var force = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    var pane = this.consoleHistoryScrollPane.current;
+
+    if (!force && pane.scrollTop < pane.scrollHeight - pane.offsetHeight) {
+      return;
     }
-  }, {
-    key: "handleTogglePrintStdout",
-    value: function handleTogglePrintStdout() {
-      this.setState(function (state) {
-        return {
-          isPrintStdOutEnabled: !state.isPrintStdOutEnabled
-        };
+
+    window.requestAnimationFrame(() => {
+      pane.scrollTop = pane.scrollHeight;
+    });
+  }
+
+  handleScrollPaneScroll() {
+    var scrollPane = this.consoleHistoryScrollPane.current;
+
+    if (scrollPane.scrollTop > 0 && scrollPane.scrollHeight > scrollPane.clientHeight) {
+      this.setState({
+        isScrollDecorationShown: true
       });
-    }
-  }, {
-    key: "handleUploadCsv",
-    value: function handleUploadCsv() {
+    } else {
       this.setState({
-        showCsvOverlay: true,
-        dragError: null,
-        csvUploadInProgress: false
+        isScrollDecorationShown: false
       });
     }
-  }, {
-    key: "handleHideCsv",
-    value: function handleHideCsv() {
+  }
+
+  handleToggleAutoLaunchPanels() {
+    this.setState(state => ({
+      isAutoLaunchPanelsEnabled: !state.isAutoLaunchPanelsEnabled
+    }));
+  }
+
+  handleToggleClosePanelsOnDisconnect() {
+    this.setState(state => ({
+      isClosePanelsOnDisconnectEnabled: !state.isClosePanelsOnDisconnectEnabled
+    }));
+  }
+
+  handleTogglePrintStdout() {
+    this.setState(state => ({
+      isPrintStdOutEnabled: !state.isPrintStdOutEnabled
+    }));
+  }
+
+  handleUploadCsv() {
+    this.setState({
+      showCsvOverlay: true,
+      dragError: null,
+      csvUploadInProgress: false
+    });
+  }
+
+  handleHideCsv() {
+    this.setState({
+      showCsvOverlay: false,
+      csvFile: null,
+      csvPaste: null,
+      dragError: null,
+      csvUploadInProgress: false
+    });
+  }
+
+  handleCsvFileOpened(file) {
+    this.setState({
+      csvFile: file,
+      csvPaste: null
+    });
+  }
+
+  handleCsvPaste(value) {
+    this.setState({
+      csvFile: null,
+      csvPaste: value
+    });
+  }
+
+  handleDragEnter(e) {
+    if (!e.dataTransfer || !e.dataTransfer.items || e.dataTransfer.items.length === 0) {
+      return;
+    }
+
+    e.preventDefault();
+    e.stopPropagation();
+    this.setState({
+      showCsvOverlay: true
+    });
+    var {
+      items
+    } = e.dataTransfer;
+
+    if (items.length > 1) {
       this.setState({
-        showCsvOverlay: false,
-        csvFile: null,
-        csvPaste: null,
-        dragError: null,
-        csvUploadInProgress: false
+        dragError: CsvOverlay.MULTIPLE_FILE_ERROR
       });
     }
-  }, {
-    key: "handleCsvFileOpened",
-    value: function handleCsvFileOpened(file) {
+
+    var item = items[0];
+
+    if (CsvOverlay.isValidDropItem(item)) {
       this.setState({
-        csvFile: file,
-        csvPaste: null
+        dragError: null
       });
-    }
-  }, {
-    key: "handleCsvPaste",
-    value: function handleCsvPaste(value) {
+    } else {
       this.setState({
-        csvFile: null,
-        csvPaste: value
+        dragError: CsvOverlay.FILE_TYPE_ERROR
       });
     }
-  }, {
-    key: "handleDragEnter",
-    value: function handleDragEnter(e) {
-      if (!e.dataTransfer || !e.dataTransfer.items || e.dataTransfer.items.length === 0) {
-        return;
-      }
+  }
 
-      e.preventDefault();
-      e.stopPropagation();
-      this.setState({
-        showCsvOverlay: true
-      });
-      var items = e.dataTransfer.items;
+  handleDragLeave(e) {
+    // DragLeave gets fired for every child element, so make sure we're actually leaving the drop zone
+    if (!e.currentTarget || e.currentTarget.contains(e.relatedTarget)) {
+      return;
+    }
 
-      if (items.length > 1) {
-        this.setState({
-          dragError: CsvOverlay.MULTIPLE_FILE_ERROR
-        });
-      }
+    e.preventDefault();
+    e.stopPropagation();
+    this.setState({
+      showCsvOverlay: false,
+      dragError: null
+    });
+  }
 
-      var item = items[0];
+  handleClearDragError() {
+    this.setState({
+      dragError: null
+    });
+  }
 
-      if (CsvOverlay.isValidDropItem(item)) {
-        this.setState({
-          dragError: null
-        });
-      } else {
-        this.setState({
-          dragError: CsvOverlay.FILE_TYPE_ERROR
-        });
+  handleOpenCsvTable(name) {
+    var {
+      openObject,
+      commandHistoryStorage,
+      language,
+      scope
+    } = this.props;
+    var {
+      consoleHistory,
+      objectMap
+    } = this.state;
+    var object = {
+      name,
+      type: dh.VariableType.TABLE
+    };
+    var isExistingObject = objectMap.has(name);
+    var historyItem = {
+      startTime: Date.now(),
+      endTime: Date.now(),
+      disabledObjects: [],
+      result: {
+        changes: {
+          created: [],
+          updated: [],
+          removed: [],
+          [isExistingObject ? 'updated' : 'created']: [object]
+        }
       }
-    }
-  }, {
-    key: "handleDragLeave",
-    value: function handleDragLeave(e) {
-      // DragLeave gets fired for every child element, so make sure we're actually leaving the drop zone
-      if (!e.currentTarget || e.currentTarget.contains(e.relatedTarget)) {
-        return;
+    };
+    var history = consoleHistory.concat(historyItem);
+    this.setState({
+      consoleHistory: history
+    });
+    this.scrollConsoleHistoryToBottom(true);
+    this.updateKnownObjects(historyItem);
+    openObject({
+      name,
+      type: dh.VariableType.TABLE
+    });
+    commandHistoryStorage.addItem(language, scope, name, {
+      command: name,
+      startTime: new Date().toJSON(),
+      endTime: new Date().toJSON(),
+      result: null
+    });
+  }
+
+  addConsoleHistoryMessage(message, error) {
+    var {
+      consoleHistory
+    } = this.state;
+    var historyItem = {
+      command: '',
+      startTime: Date.now(),
+      endTime: Date.now(),
+      result: {
+        message,
+        error
       }
+    };
+    var history = consoleHistory.concat(historyItem);
+    this.setState({
+      consoleHistory: history
+    });
+  }
 
-      e.preventDefault();
-      e.stopPropagation();
-      this.setState({
-        showCsvOverlay: false,
-        dragError: null
-      });
-    }
-  }, {
-    key: "handleClearDragError",
-    value: function handleClearDragError() {
-      this.setState({
-        dragError: null
+  handleCsvUpdate(message) {
+    this.addConsoleHistoryMessage(message);
+  }
+
+  handleCsvError(error) {
+    this.addConsoleHistoryMessage(null, error);
+  }
+
+  handleCsvInProgress(csvUploadInProgress) {
+    this.setState({
+      csvUploadInProgress
+    });
+  }
+
+  handleOverflowActions() {
+    var {
+      isAutoLaunchPanelsEnabled,
+      isClosePanelsOnDisconnectEnabled,
+      isPrintStdOutEnabled
+    } = this.state;
+    var {
+      actions
+    } = this.props;
+    return [...actions, {
+      title: 'Print Stdout',
+      action: this.handleTogglePrintStdout,
+      group: ContextActions.groups.high,
+      icon: isPrintStdOutEnabled ? vsCheck : null,
+      order: 10
+    }, {
+      title: 'Auto Launch Panels',
+      action: this.handleToggleAutoLaunchPanels,
+      group: ContextActions.groups.high,
+      icon: isAutoLaunchPanelsEnabled ? vsCheck : null,
+      order: 20
+    }, {
+      title: 'Close Panels on Disconnect',
+      action: this.handleToggleClosePanelsOnDisconnect,
+      group: ContextActions.groups.high,
+      icon: isClosePanelsOnDisconnectEnabled ? vsCheck : null,
+      order: 30
+    }, {
+      title: 'Upload Table from File',
+      action: this.handleUploadCsv,
+      group: ContextActions.groups.high + 10,
+      order: 40
+    }];
+  }
+
+  handleCommandSubmit(command) {
+    if (command === 'clear' || command === 'cls') {
+      this.clearConsoleHistory();
+    } else if (command.length > 0) {
+      // Result is handled in this.handleCommandStarted
+      var {
+        session
+      } = this.props;
+      session.runCode(command).catch(error => {
+        log.error('There was an error initiating the command', error);
       });
-    }
-  }, {
-    key: "handleOpenCsvTable",
-    value: function handleOpenCsvTable(name) {
-      var _this$props2 = this.props,
-          openObject = _this$props2.openObject,
-          commandHistoryStorage = _this$props2.commandHistoryStorage,
-          language = _this$props2.language,
-          scope = _this$props2.scope;
-      var _this$state = this.state,
-          consoleHistory = _this$state.consoleHistory,
-          objectMap = _this$state.objectMap;
-      var object = {
-        name: name,
-        type: dh.VariableType.TABLE
-      };
-      var isExistingObject = objectMap.has(name);
+    } else {
+      // Empty command, just pump a blank line out to history
       var historyItem = {
+        command: ' ',
+        result: {},
         startTime: Date.now(),
-        endTime: Date.now(),
-        disabledObjects: [],
-        result: {
-          changes: _defineProperty({
-            created: [],
-            updated: [],
-            removed: []
-          }, isExistingObject ? 'updated' : 'created', [object])
-        }
+        endTime: Date.now()
       };
-      var history = consoleHistory.concat(historyItem);
-      this.setState({
-        consoleHistory: history
-      });
       this.scrollConsoleHistoryToBottom(true);
-      this.updateKnownObjects(historyItem);
-      openObject({
-        name: name,
-        type: dh.VariableType.TABLE
-      });
-      commandHistoryStorage.addItem(language, scope, name, {
-        command: name,
-        startTime: new Date().toJSON(),
-        endTime: new Date().toJSON(),
-        result: null
-      });
+      this.setState(state => ({
+        consoleHistory: state.consoleHistory.concat(historyItem)
+      }));
     }
-  }, {
-    key: "addConsoleHistoryMessage",
-    value: function addConsoleHistoryMessage(message, error) {
-      var consoleHistory = this.state.consoleHistory;
-      var historyItem = {
-        command: '',
-        startTime: Date.now(),
-        endTime: Date.now(),
-        result: {
-          message: message,
-          error: error
-        }
+  }
+
+  clearConsoleHistory() {
+    this.pending.cancel();
+    this.setState(state => {
+      // Replace all values with -1 to indicate that table references are still active
+      // but don't have corresponding command indexes in consoleHistory
+      var objectHistoryMap = new Map([...state.objectHistoryMap.keys()].map(name => [name, -1]));
+      return {
+        consoleHistory: [],
+        objectHistoryMap
       };
-      var history = consoleHistory.concat(historyItem);
-      this.setState({
-        consoleHistory: history
-      });
-    }
-  }, {
-    key: "handleCsvUpdate",
-    value: function handleCsvUpdate(message) {
-      this.addConsoleHistoryMessage(message);
-    }
-  }, {
-    key: "handleCsvError",
-    value: function handleCsvError(error) {
-      this.addConsoleHistoryMessage(null, error);
-    }
-  }, {
-    key: "handleCsvInProgress",
-    value: function handleCsvInProgress(csvUploadInProgress) {
-      this.setState({
-        csvUploadInProgress: csvUploadInProgress
-      });
-    }
-  }, {
-    key: "handleOverflowActions",
-    value: function handleOverflowActions() {
-      var _this$state2 = this.state,
-          isAutoLaunchPanelsEnabled = _this$state2.isAutoLaunchPanelsEnabled,
-          isClosePanelsOnDisconnectEnabled = _this$state2.isClosePanelsOnDisconnectEnabled,
-          isPrintStdOutEnabled = _this$state2.isPrintStdOutEnabled;
-      var actions = this.props.actions;
-      return [].concat(_toConsumableArray(actions), [{
-        title: 'Print Stdout',
-        action: this.handleTogglePrintStdout,
-        group: ContextActions.groups.high,
-        icon: isPrintStdOutEnabled ? vsCheck : null,
-        order: 10
-      }, {
-        title: 'Auto Launch Panels',
-        action: this.handleToggleAutoLaunchPanels,
-        group: ContextActions.groups.high,
-        icon: isAutoLaunchPanelsEnabled ? vsCheck : null,
-        order: 20
-      }, {
-        title: 'Close Panels on Disconnect',
-        action: this.handleToggleClosePanelsOnDisconnect,
-        group: ContextActions.groups.high,
-        icon: isClosePanelsOnDisconnectEnabled ? vsCheck : null,
-        order: 30
-      }, {
-        title: 'Upload Table from File',
-        action: this.handleUploadCsv,
-        group: ContextActions.groups.high + 10,
-        order: 40
-      }]);
-    }
-  }, {
-    key: "handleCommandSubmit",
-    value: function handleCommandSubmit(command) {
-      if (command === 'clear' || command === 'cls') {
-        this.clearConsoleHistory();
-      } else if (command.length > 0) {
-        // Result is handled in this.handleCommandStarted
-        var session = this.props.session;
-        session.runCode(command)["catch"](function (error) {
-          log.error('There was an error initiating the command', error);
-        });
-      } else {
-        // Empty command, just pump a blank line out to history
-        var historyItem = {
-          command: ' ',
-          result: {},
-          startTime: Date.now(),
-          endTime: Date.now()
-        };
-        this.scrollConsoleHistoryToBottom(true);
-        this.setState(function (state) {
-          return {
-            consoleHistory: state.consoleHistory.concat(historyItem)
-          };
-        });
-      }
-    }
-  }, {
-    key: "clearConsoleHistory",
-    value: function clearConsoleHistory() {
-      this.pending.cancel();
-      this.setState(function (state) {
-        // Replace all values with -1 to indicate that table references are still active
-        // but don't have corresponding command indexes in consoleHistory
-        var objectHistoryMap = new Map(_toConsumableArray(state.objectHistoryMap.keys()).map(function (name) {
-          return [name, -1];
-        }));
-        return {
-          consoleHistory: [],
-          objectHistoryMap: objectHistoryMap
-        };
-      });
-    }
-  }, {
-    key: "addCommand",
-    value: function addCommand(command) {
-      var focus = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-      var execute = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-
-      if (!this.consoleInput.current) {
-        return;
-      }
+    });
+  }
 
-      this.consoleInput.current.setConsoleText(command, focus, execute);
+  addCommand(command) {
+    var focus = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    var execute = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
 
-      if (focus) {
-        this.scrollConsoleHistoryToBottom(true);
-      }
+    if (!this.consoleInput.current) {
+      return;
     }
-  }, {
-    key: "focus",
-    value: function focus() {
-      var _this$consoleInput$cu;
 
-      (_this$consoleInput$cu = this.consoleInput.current) === null || _this$consoleInput$cu === void 0 ? void 0 : _this$consoleInput$cu.focus();
+    this.consoleInput.current.setConsoleText(command, focus, execute);
+
+    if (focus) {
+      this.scrollConsoleHistoryToBottom(true);
     }
-  }, {
-    key: "sendSettingsChange",
-    value: function sendSettingsChange(prevState, state) {
-      var checkIfChanged = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-      var keys = Object.keys(DEFAULT_SETTINGS);
-      var settings = {};
-      var hasChanges = false;
-
-      for (var i = 0; i < keys.length; i += 1) {
-        var key = keys[i];
-        var setting = state[key];
-        var prevSetting = prevState[key];
-
-        if (setting !== prevSetting) {
-          hasChanges = true;
-        }
+  }
 
-        settings[key] = setting;
-      }
+  focus() {
+    var _this$consoleInput$cu;
 
-      if (checkIfChanged && !hasChanges) {
-        return;
-      }
+    (_this$consoleInput$cu = this.consoleInput.current) === null || _this$consoleInput$cu === void 0 ? void 0 : _this$consoleInput$cu.focus();
+  }
 
-      var onSettingsChange = this.props.onSettingsChange;
-      onSettingsChange(settings);
-    }
-  }, {
-    key: "updateDimensions",
-    value: function updateDimensions() {
-      if (this.consolePane.current) {
-        this.setState({
-          consoleHeight: this.consolePane.current.clientHeight
-        });
+  sendSettingsChange(prevState, state) {
+    var checkIfChanged = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+    var keys = Object.keys(DEFAULT_SETTINGS);
+    var settings = {};
+    var hasChanges = false;
+
+    for (var i = 0; i < keys.length; i += 1) {
+      var key = keys[i];
+      var {
+        [key]: setting
+      } = state;
+      var {
+        [key]: prevSetting
+      } = prevState;
+
+      if (setting !== prevSetting) {
+        hasChanges = true;
       }
 
-      if (this.consoleInput.current) {
-        this.consoleInput.current.updateDimensions();
-      }
+      settings[key] = setting;
     }
-  }, {
-    key: "render",
-    value: function render() {
-      var _this$props3 = this.props,
-          actions = _this$props3.actions,
-          disconnectedChildren = _this$props3.disconnectedChildren,
-          language = _this$props3.language,
-          statusBarChildren = _this$props3.statusBarChildren,
-          openObject = _this$props3.openObject,
-          session = _this$props3.session,
-          scope = _this$props3.scope;
-      var _this$state3 = this.state,
-          consoleHeight = _this$state3.consoleHeight,
-          consoleHistory = _this$state3.consoleHistory,
-          isScrollDecorationShown = _this$state3.isScrollDecorationShown,
-          objectMap = _this$state3.objectMap,
-          showCsvOverlay = _this$state3.showCsvOverlay,
-          csvFile = _this$state3.csvFile,
-          csvPaste = _this$state3.csvPaste,
-          dragError = _this$state3.dragError,
-          csvUploadInProgress = _this$state3.csvUploadInProgress;
-      var consoleMenuObjects = this.getObjects(objectMap);
-      var inputMaxHeight = Math.round(consoleHeight * 0.7);
-      var isDisconnected = disconnectedChildren != null;
-      var contextActions = this.getContextActions(actions);
-      return /*#__PURE__*/React.createElement("div", {
-        role: "presentation",
-        className: classNames('iris-console h-100 w-100', {
-          disconnected: isDisconnected
-        })
-      }, /*#__PURE__*/React.createElement("div", {
-        className: "console-pane",
-        ref: this.consolePane
-      }, /*#__PURE__*/React.createElement(ConsoleStatusBar, {
-        session: session,
-        overflowActions: this.handleOverflowActions,
-        openObject: openObject,
-        objects: consoleMenuObjects
-      }, statusBarChildren), /*#__PURE__*/React.createElement("div", {
-        className: "console-csv-container",
-        onDragOver: CsvOverlay.handleDragOver,
-        onDragEnter: this.handleDragEnter,
-        onDragLeave: this.handleDragLeave
-      }, !isDisconnected && showCsvOverlay && /*#__PURE__*/React.createElement(CsvOverlay, {
-        onFileOpened: this.handleCsvFileOpened,
-        onPaste: this.handleCsvPaste,
-        clearDragError: this.handleClearDragError,
-        dragError: dragError,
-        onError: this.handleCsvError,
-        uploadInProgress: csvUploadInProgress
-      }), /*#__PURE__*/React.createElement("div", {
-        role: "presentation",
-        className: classNames('scroll-pane no-scroll-x', {
-          'scroll-decoration': isScrollDecorationShown
-        }),
-        onScroll: this.handleScrollPaneScroll,
-        ref: this.consoleHistoryScrollPane
-      }, /*#__PURE__*/React.createElement(ConsoleHistory, {
-        items: consoleHistory,
-        openObject: openObject,
-        language: language
-      }), isDisconnected && disconnectedChildren)), !isDisconnected && !showCsvOverlay && /*#__PURE__*/React.createElement(ConsoleInput, {
-        ref: this.consoleInput,
-        session: session,
-        language: language,
-        scope: scope,
-        onSubmit: this.handleCommandSubmit,
-        maxHeight: inputMaxHeight
-      }), !isDisconnected && showCsvOverlay && /*#__PURE__*/React.createElement(CsvInputBar, {
-        session: session,
-        onOpenTable: this.handleOpenCsvTable,
-        onClose: this.handleHideCsv,
-        onUpdate: this.handleCsvUpdate,
-        onError: this.handleCsvError,
-        file: csvFile,
-        paste: csvPaste,
-        onInProgress: this.handleCsvInProgress
-      })), /*#__PURE__*/React.createElement(ContextActions, {
-        actions: contextActions,
-        ignoreClassNames: [ConsoleInput.INPUT_CLASS_NAME]
-      }));
+
+    if (checkIfChanged && !hasChanges) {
+      return;
     }
-  }], [{
-    key: "isErrorLevel",
-    value:
-    /**
-     * Check if the provided log level is an error type
-     * @param {LogLevel} logLevel The LogLevel being checked
-     * @returns {boolean} true if the log level is an error level log
-     */
-    function isErrorLevel(logLevel) {
-      return logLevel === LogLevel.STDERR || logLevel === LogLevel.ERROR || logLevel === LogLevel.FATAL;
+
+    var {
+      onSettingsChange
+    } = this.props;
+    onSettingsChange(settings);
+  }
+
+  updateDimensions() {
+    if (this.consolePane.current) {
+      this.setState({
+        consoleHeight: this.consolePane.current.clientHeight
+      });
     }
-    /**
-     * Check if the provided log level is output level
-     * @param {LogLevel} logLevel The LogLevel being checked
-     * @returns {boolean} true if the log level should be output to the console
-     */
-
-  }, {
-    key: "isOutputLevel",
-    value: function isOutputLevel(logLevel) {
-      // We want all errors to be output, in addition to STDOUT.
-      // That way the user is more likely to see them.
-      return logLevel === LogLevel.STDOUT || Console.isErrorLevel(logLevel);
+
+    if (this.consoleInput.current) {
+      this.consoleInput.current.updateDimensions();
     }
-  }]);
+  }
+
+  render() {
+    var {
+      actions,
+      disconnectedChildren,
+      language,
+      statusBarChildren,
+      openObject,
+      session,
+      scope,
+      commandHistoryStorage,
+      timeZone
+    } = this.props;
+    var {
+      consoleHeight,
+      consoleHistory,
+      isScrollDecorationShown,
+      objectMap,
+      showCsvOverlay,
+      csvFile,
+      csvPaste,
+      dragError,
+      csvUploadInProgress
+    } = this.state;
+    var consoleMenuObjects = this.getObjects(objectMap);
+    var inputMaxHeight = Math.round(consoleHeight * 0.7);
+    var isDisconnected = disconnectedChildren != null;
+    var contextActions = this.getContextActions(actions);
+    return /*#__PURE__*/React.createElement("div", {
+      role: "presentation",
+      className: classNames('iris-console h-100 w-100', {
+        disconnected: isDisconnected
+      })
+    }, /*#__PURE__*/React.createElement("div", {
+      className: "console-pane",
+      ref: this.consolePane
+    }, /*#__PURE__*/React.createElement(ConsoleStatusBar, {
+      session: session,
+      overflowActions: this.handleOverflowActions,
+      openObject: openObject,
+      objects: consoleMenuObjects
+    }, statusBarChildren), /*#__PURE__*/React.createElement("div", {
+      className: "console-csv-container",
+      onDragOver: CsvOverlay.handleDragOver,
+      onDragEnter: this.handleDragEnter,
+      onDragLeave: this.handleDragLeave
+    }, !isDisconnected && showCsvOverlay && /*#__PURE__*/React.createElement(CsvOverlay, {
+      onFileOpened: this.handleCsvFileOpened,
+      onPaste: this.handleCsvPaste,
+      clearDragError: this.handleClearDragError,
+      dragError: dragError,
+      onError: this.handleCsvError,
+      uploadInProgress: csvUploadInProgress
+    }), /*#__PURE__*/React.createElement("div", {
+      role: "presentation",
+      className: classNames('scroll-pane no-scroll-x', {
+        'scroll-decoration': isScrollDecorationShown
+      }),
+      onScroll: this.handleScrollPaneScroll,
+      ref: this.consoleHistoryScrollPane
+    }, /*#__PURE__*/React.createElement(ConsoleHistory, {
+      items: consoleHistory,
+      openObject: openObject,
+      language: language
+    }), isDisconnected && disconnectedChildren)), !isDisconnected && !showCsvOverlay && /*#__PURE__*/React.createElement(ConsoleInput, {
+      ref: this.consoleInput,
+      session: session,
+      language: language,
+      scope: scope,
+      onSubmit: this.handleCommandSubmit,
+      maxHeight: inputMaxHeight,
+      commandHistoryStorage: commandHistoryStorage
+    }), !isDisconnected && showCsvOverlay && /*#__PURE__*/React.createElement(CsvInputBar, {
+      session: session,
+      onOpenTable: this.handleOpenCsvTable,
+      onClose: this.handleHideCsv,
+      onUpdate: this.handleCsvUpdate,
+      onError: this.handleCsvError,
+      file: csvFile,
+      paste: csvPaste,
+      onInProgress: this.handleCsvInProgress,
+      timeZone: timeZone
+    })), /*#__PURE__*/React.createElement(ContextActions, {
+      actions: contextActions,
+      ignoreClassNames: [ConsoleInput.INPUT_CLASS_NAME]
+    }));
+  }
 
-  return Console;
-}(PureComponent);
+}
 
 _defineProperty(Console, "LOG_THROTTLE", 500);
 
@@ -1005,16 +939,18 @@ Console.propTypes = {
   onSettingsChange: PropTypes.func,
   scope: PropTypes.string,
   actions: PropTypes.arrayOf(PropTypes.shape({})),
+  timeZone: PropTypes.string,
   // Message shown when the session has disconnected. Setting this value removes the input bar and disables old tables
   disconnectedChildren: PropTypes.node
 };
 Console.defaultProps = {
   statusBarChildren: null,
   settings: {},
-  onSettingsChange: function onSettingsChange() {},
+  onSettingsChange: () => {},
   scope: null,
   actions: [],
-  disconnectedChildren: null
+  disconnectedChildren: null,
+  timeZone: 'America/New_York'
 };
 export default Console;
 //# sourceMappingURL=Console.js.map