@deephaven/console 0.43.0 → 0.44.0

package/dist/Console.js

@@ -0,0 +1,875 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+/**
+ * Console display for use in the Iris environment.
+ */
+import React, { PureComponent } from 'react';
+import { ContextActions } from '@deephaven/components';
+import { vsCheck } from '@deephaven/icons';
+import classNames from 'classnames';
+import memoize from 'memoize-one';
+import throttle from 'lodash.throttle';
+import Log from '@deephaven/log';
+import { assertNotNull, Pending, PromiseUtils } from '@deephaven/utils';
+import ConsoleHistory from "./console-history/ConsoleHistory.js";
+import SHORTCUTS from "./ConsoleShortcuts.js";
+import LogLevel from "./log/LogLevel.js";
+import ConsoleInput from "./ConsoleInput.js";
+import CsvOverlay from "./csv/CsvOverlay.js";
+import CsvInputBar from "./csv/CsvInputBar.js";
+import "./Console.css";
+import ConsoleStatusBar from "./ConsoleStatusBar.js";
+var log = Log.module('Console');
+var DEFAULT_SETTINGS = {
+  isAutoLaunchPanelsEnabled: true,
+  isPrintStdOutEnabled: true,
+  isClosePanelsOnDisconnectEnabled: true
+};
+export class Console extends PureComponent {
+  /**
+   * Check if the provided log level is an error type
+   * @param logLevel The LogLevel being checked
+   * @returns 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 The LogLevel being checked
+   * @returns true if the log level should be output to the console
+   */
+  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);
+  }
+  constructor(props) {
+    super(props);
+    _defineProperty(this, "cancelListener", void 0);
+    _defineProperty(this, "consolePane", void 0);
+    _defineProperty(this, "consoleInput", void 0);
+    _defineProperty(this, "consoleHistoryScrollPane", void 0);
+    _defineProperty(this, "pending", void 0);
+    _defineProperty(this, "queuedLogMessages", void 0);
+    _defineProperty(this, "processLogMessageQueue", throttle(() => {
+      this.scrollConsoleHistoryToBottom();
+      this.setState(state => {
+        log.debug2('processLogMessageQueue', this.queuedLogMessages.length, ' items');
+        var {
+          consoleHistory
+        } = state;
+        consoleHistory = consoleHistory.concat(this.queuedLogMessages);
+        this.queuedLogMessages = [];
+        return {
+          consoleHistory
+        };
+      });
+    }, Console.LOG_THROTTLE));
+    _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.handleUploadCsv = this.handleUploadCsv.bind(this);
+    this.handleHideCsv = this.handleHideCsv.bind(this);
+    this.handleCsvFileCanceled = this.handleCsvFileCanceled.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.consolePane = /*#__PURE__*/React.createRef();
+    this.consoleInput = /*#__PURE__*/React.createRef();
+    this.consoleHistoryScrollPane = /*#__PURE__*/React.createRef();
+    this.pending = new Pending();
+    this.queuedLogMessages = [];
+    var {
+      objectMap: _objectMap,
+      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
+      consoleHeight: 0,
+      isScrollDecorationShown: false,
+      // Location of objects in the console history
+      objectHistoryMap: new Map(),
+      // The object definitions, name/type
+      objectMap: new Map(_objectMap),
+      showCsvOverlay: false,
+      csvFile: null,
+      csvPaste: null,
+      dragError: null,
+      csvUploadInProgress: false
+    }, DEFAULT_SETTINGS), settings);
+  }
+  componentDidMount() {
+    this.initConsoleLogging();
+    var {
+      dh,
+      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.objectMap !== prevProps.objectMap) {
+      this.updateObjectMap();
+    }
+  }
+  componentWillUnmount() {
+    var {
+      dh,
+      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 = undefined;
+    }
+  }
+  handleClearShortcut(event) {
+    var _this$consoleInput$cu;
+    event.preventDefault();
+    event.stopPropagation();
+    (_this$consoleInput$cu = this.consoleInput.current) === null || _this$consoleInput$cu === void 0 ? void 0 : _this$consoleInput$cu.clear();
+  }
+  handleCommandStarted(event) {
+    var {
+      code,
+      result
+    } = event.detail;
+    var wrappedResult = this.pending.add(result);
+    var historyItem = {
+      command: code,
+      disabledObjects: [],
+      startTime: Date.now(),
+      cancelResult: () => {
+        result.cancel();
+      },
+      wrappedResult
+    };
+    var {
+      commandHistoryStorage,
+      language,
+      scope
+    } = this.props;
+    var workspaceItemPromise = commandHistoryStorage.addItem(language, scope, code, {
+      command: code,
+      startTime: new Date().toJSON()
+    });
+    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, historyItem, workspaceItemPromise) {
+    var newHistoryItem = _objectSpread(_objectSpread({}, historyItem), {}, {
+      wrappedResult: undefined,
+      cancelResult: undefined,
+      result: result !== null && result !== void 0 ? result : historyItem.result
+    });
+    this.setState(_ref => {
+      var {
+        consoleHistory
+      } = _ref;
+      var itemIndex = consoleHistory.lastIndexOf(historyItem);
+      if (itemIndex < 0) {
+        log.error("historyItem not found in consoleHistory");
+        return null;
+      }
+      var newHistory = consoleHistory.concat();
+      newHistory[itemIndex] = newHistoryItem;
+      return {
+        consoleHistory: newHistory
+      };
+    });
+    if (!result) {
+      return;
+    }
+    this.updateHistory(result, newHistoryItem);
+    this.updateKnownObjects(newHistoryItem);
+    this.updateWorkspaceHistoryItem({
+      error: result.error
+    }, workspaceItemPromise);
+    this.closeRemovedItems(result.changes);
+    this.openUpdatedItems(result.changes);
+  }
+  handleCommandError(error, historyItem, workspaceItemPromise) {
+    if (PromiseUtils.isCanceled(error)) {
+      log.debug('Called handleCommandError on a cancelled promise result');
+      return;
+    }
+    this.updateWorkspaceHistoryItem({
+      error: "".concat(error)
+    }, workspaceItemPromise);
+    this.setState(state => {
+      var history = state.consoleHistory.concat();
+      var index = history.lastIndexOf(historyItem);
+      var newHistoryItem = _objectSpread({}, historyItem);
+      newHistoryItem.wrappedResult = undefined;
+      newHistoryItem.cancelResult = undefined;
+      newHistoryItem.endTime = Date.now();
+      newHistoryItem.result = {
+        error
+      };
+      history[index] = newHistoryItem;
+      return {
+        consoleHistory: history
+      };
+    });
+  }
+  handleFocusHistory(event) {
+    event.preventDefault();
+    event.stopPropagation();
+    var {
+      focusCommandHistory
+    } = this.props;
+    focusCommandHistory();
+  }
+  handleLogMessage(message) {
+    var {
+      isPrintStdOutEnabled
+    } = this.state;
+    if (!isPrintStdOutEnabled) {
+      return;
+    }
+    if (Console.isOutputLevel(message.logLevel)) {
+      this.queueLogMessage(message.message, message.logLevel);
+    }
+  }
+  queueLogMessage(message, logLevel) {
+    var result = {};
+    if (Console.isErrorLevel(logLevel)) {
+      result.error = message;
+    } else {
+      result.message = message;
+    }
+    var historyItem = {
+      command: undefined,
+      result
+    };
+    this.queuedLogMessages.push(historyItem);
+    this.processLogMessageQueue();
+  }
+  openUpdatedItems(changes) {
+    var {
+      isAutoLaunchPanelsEnabled
+    } = this.state;
+    if (changes == null || !isAutoLaunchPanelsEnabled) {
+      return;
+    }
+    var {
+      openObject
+    } = this.props;
+    [...changes.created, ...changes.updated].forEach(object => openObject(object));
+  }
+  closeRemovedItems(changes) {
+    if (changes == null || changes.removed == null || changes.removed.length === 0) {
+      return;
+    }
+    var {
+      closeObject
+    } = this.props;
+    var {
+      removed
+    } = changes;
+    removed.forEach(object => closeObject(object));
+  }
+  updateHistory(result, historyItemParam) {
+    var historyItem = historyItemParam;
+    if (result == null || result.changes == null || historyItem == null) {
+      return;
+    }
+    historyItem.endTime = Date.now();
+    this.scrollConsoleHistoryToBottom();
+
+    // Update history to re-render items as necessary
+    this.setState(state => {
+      var consoleHistory = state.consoleHistory.concat();
+      return {
+        consoleHistory
+      };
+    });
+  }
+  updateKnownObjects(historyItem) {
+    var changes;
+    if (historyItem.result) {
+      changes = historyItem.result.changes;
+    }
+    if (!changes || (changes.created == null || changes.created.length === 0) && (changes.updated == null || changes.updated.length === 0) && (changes.removed == null || changes.removed.length === 0)) {
+      log.debug2('updateKnownObjects no changes');
+      return;
+    }
+    this.setState(state => {
+      var _changes, _changes2, _changes3;
+      var {
+        consoleHistory
+      } = state;
+      var itemIndex = consoleHistory.lastIndexOf(historyItem);
+      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 {
+          title
+        } = object;
+        assertNotNull(title);
+        var oldIndex = objectHistoryMap.get(title);
+        // 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 != null && oldIndex >= 0) {
+          var _consoleHistory$oldIn;
+          // disable outdated object variable in the old consoleHistory item
+          if (consoleHistory === state.consoleHistory) {
+            // First item in the history being updated,
+            consoleHistory = consoleHistory.concat();
+          }
+          var newHistoryItem = _objectSpread(_objectSpread({}, consoleHistory[oldIndex]), {}, {
+            disabledObjects: [...((_consoleHistory$oldIn = consoleHistory[oldIndex].disabledObjects) !== null && _consoleHistory$oldIn !== void 0 ? _consoleHistory$oldIn : []), title]
+          });
+          consoleHistory[oldIndex] = newHistoryItem;
+        }
+        objectHistoryMap.set(title, itemIndex);
+        if (isRemoved) {
+          objectMap.delete(title);
+        } else {
+          objectMap.set(title, object);
+        }
+      };
+      (_changes = changes) === null || _changes === void 0 ? void 0 : _changes.updated.forEach(object => disableOldObject(object));
+      (_changes2 = changes) === null || _changes2 === void 0 ? void 0 : _changes2.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
+      (_changes3 = changes) === null || _changes3 === void 0 ? void 0 : _changes3.created.forEach(object => {
+        var {
+          title
+        } = object;
+        assertNotNull(title);
+        objectHistoryMap.set(title, itemIndex);
+        objectMap.set(title, object);
+      });
+      return {
+        objectHistoryMap,
+        objectMap,
+        consoleHistory
+      };
+    });
+  }
+  updateObjectMap() {
+    var {
+      objectMap
+    } = this.props;
+    this.setState({
+      objectMap
+    });
+  }
+
+  /**
+   * Updates an existing workspace CommandHistoryItem
+   * @param result The result to store with the history item. Could be empty object for success
+   * @param 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
+        })
+      });
+      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;
+    assertNotNull(pane);
+    if (!force && pane.scrollTop < pane.scrollHeight - pane.offsetHeight) {
+      return;
+    }
+    window.requestAnimationFrame(() => {
+      pane.scrollTop = pane.scrollHeight;
+    });
+  }
+  handleScrollPaneScroll() {
+    var scrollPane = this.consoleHistoryScrollPane.current;
+    assertNotNull(scrollPane);
+    if (scrollPane.scrollTop > 0 && scrollPane.scrollHeight > scrollPane.clientHeight) {
+      this.setState({
+        isScrollDecorationShown: true
+      });
+    } else {
+      this.setState({
+        isScrollDecorationShown: false
+      });
+    }
+  }
+  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
+    });
+  }
+  handleCsvFileCanceled() {
+    this.setState({
+      csvFile: null,
+      csvPaste: null
+    });
+  }
+  handleCsvFileOpened(file) {
+    this.setState({
+      csvFile: file,
+      csvPaste: null
+    });
+  }
+  handleCsvPaste(value) {
+    this.setState({
+      csvFile: null,
+      csvPaste: value
+    });
+  }
+  handleDragEnter(e) {
+    if (e.dataTransfer == null || e.dataTransfer.items == null || e.dataTransfer.items.length === 0 || e.dataTransfer.items[0].kind === 'string') {
+      return;
+    }
+    e.preventDefault();
+    e.stopPropagation();
+    this.setState({
+      showCsvOverlay: true
+    });
+    var {
+      items
+    } = e.dataTransfer;
+    if (items.length > 1) {
+      this.setState({
+        dragError: CsvOverlay.MULTIPLE_FILE_ERROR
+      });
+      return;
+    }
+    var item = items[0];
+    if (CsvOverlay.isValidDropItem(item)) {
+      this.setState({
+        dragError: null
+      });
+    } else {
+      this.setState({
+        dragError: CsvOverlay.FILE_TYPE_ERROR
+      });
+    }
+  }
+  handleDragLeave(e) {
+    // DragLeave gets fired for every child element, so make sure we're actually leaving the drop zone
+    if (e.currentTarget == null || e.currentTarget instanceof Element && e.relatedTarget instanceof Element && e.currentTarget.contains(e.relatedTarget)) {
+      return;
+    }
+    e.preventDefault();
+    e.stopPropagation();
+    this.setState({
+      showCsvOverlay: false,
+      dragError: null
+    });
+  }
+  handleClearDragError() {
+    this.setState({
+      dragError: null
+    });
+  }
+  handleOpenCsvTable(title) {
+    var {
+      dh,
+      openObject,
+      commandHistoryStorage,
+      language,
+      scope
+    } = this.props;
+    var {
+      consoleHistory,
+      objectMap
+    } = this.state;
+    var object = {
+      name: title,
+      title,
+      type: dh.VariableType.TABLE
+    };
+    var isExistingObject = objectMap.has(title);
+    var historyItem = {
+      startTime: Date.now(),
+      endTime: Date.now(),
+      disabledObjects: [],
+      result: {
+        changes: {
+          created: [],
+          updated: [],
+          removed: [],
+          [isExistingObject ? 'updated' : 'created']: [object]
+        }
+      }
+    };
+    var history = consoleHistory.concat(historyItem);
+    this.setState({
+      consoleHistory: history
+    });
+    this.scrollConsoleHistoryToBottom(true);
+    this.updateKnownObjects(historyItem);
+    openObject({
+      name: title,
+      title,
+      type: dh.VariableType.TABLE
+    });
+    commandHistoryStorage.addItem(language, scope, title, {
+      command: title,
+      startTime: new Date().toJSON(),
+      endTime: new Date().toJSON()
+    });
+  }
+  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
+    });
+  }
+  handleCsvUpdate(message) {
+    this.addConsoleHistoryMessage(message);
+  }
+  handleCsvError(error) {
+    this.addConsoleHistoryMessage(undefined, error != null ? "".concat(error) : undefined);
+  }
+  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 : undefined,
+      order: 10
+    }, {
+      title: 'Auto Launch Panels',
+      action: this.handleToggleAutoLaunchPanels,
+      group: ContextActions.groups.high,
+      icon: isAutoLaunchPanelsEnabled ? vsCheck : undefined,
+      order: 20
+    }, {
+      title: 'Close Panels on Disconnect',
+      action: this.handleToggleClosePanelsOnDisconnect,
+      group: ContextActions.groups.high,
+      icon: isClosePanelsOnDisconnectEnabled ? vsCheck : undefined,
+      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);
+      });
+    } 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(state => ({
+        consoleHistory: state.consoleHistory.concat(historyItem)
+      }));
+    }
+  }
+  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
+      };
+    });
+  }
+  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);
+    if (focus) {
+      this.scrollConsoleHistoryToBottom(true);
+    }
+  }
+  focus() {
+    var _this$consoleInput$cu2;
+    (_this$consoleInput$cu2 = this.consoleInput.current) === null || _this$consoleInput$cu2 === void 0 ? void 0 : _this$consoleInput$cu2.focus();
+  }
+  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;
+      }
+      settings[key] = setting;
+    }
+    if (checkIfChanged && !hasChanges) {
+      return;
+    }
+    var {
+      onSettingsChange
+    } = this.props;
+    onSettingsChange(settings);
+  }
+  updateDimensions() {
+    if (this.consolePane.current) {
+      this.setState({
+        consoleHeight: this.consolePane.current.clientHeight
+      });
+    }
+    if (this.consoleInput.current) {
+      this.consoleInput.current.updateDimensions();
+    }
+  }
+  render() {
+    var {
+      actions,
+      dh,
+      historyChildren,
+      language,
+      statusBarChildren,
+      openObject,
+      session,
+      scope,
+      commandHistoryStorage,
+      timeZone,
+      disabled,
+      unzip
+    } = 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 contextActions = this.getContextActions(actions);
+    return /*#__PURE__*/React.createElement("div", {
+      role: "presentation",
+      className: classNames('iris-console', 'h-100', 'w-100', {
+        disabled
+      })
+    }, /*#__PURE__*/React.createElement("div", {
+      className: "console-pane",
+      ref: this.consolePane
+    }, /*#__PURE__*/React.createElement(ConsoleStatusBar, {
+      dh: dh,
+      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
+    }, showCsvOverlay && /*#__PURE__*/React.createElement(CsvOverlay, {
+      onCancel: this.handleCsvFileCanceled,
+      onFileOpened: this.handleCsvFileOpened,
+      onPaste: this.handleCsvPaste,
+      clearDragError: this.handleClearDragError,
+      dragError: dragError,
+      onError: this.handleCsvError,
+      uploadInProgress: csvUploadInProgress,
+      allowZip: unzip != null
+    }), /*#__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,
+      disabled: disabled
+    }), historyChildren)), !showCsvOverlay && /*#__PURE__*/React.createElement(ConsoleInput, {
+      ref: this.consoleInput,
+      session: session,
+      language: language,
+      scope: scope,
+      onSubmit: this.handleCommandSubmit,
+      maxHeight: inputMaxHeight,
+      commandHistoryStorage: commandHistoryStorage
+    }), showCsvOverlay && /*#__PURE__*/React.createElement(CsvInputBar, {
+      session: session,
+      onOpenTable: this.handleOpenCsvTable,
+      onClose: this.handleHideCsv,
+      onUpdate: this.handleCsvUpdate,
+      onError: this.handleCsvError,
+      file: csvFile !== null && csvFile !== void 0 ? csvFile : undefined,
+      paste: csvPaste !== null && csvPaste !== void 0 ? csvPaste : undefined,
+      onInProgress: this.handleCsvInProgress,
+      timeZone: timeZone,
+      unzip: unzip
+    })), /*#__PURE__*/React.createElement(ContextActions, {
+      actions: contextActions,
+      ignoreClassNames: [ConsoleInput.INPUT_CLASS_NAME]
+    }));
+  }
+}
+_defineProperty(Console, "defaultProps", {
+  statusBarChildren: null,
+  settings: {},
+  onSettingsChange: () => undefined,
+  scope: null,
+  actions: [],
+  historyChildren: null,
+  timeZone: 'America/New_York',
+  objectMap: new Map(),
+  disabled: false,
+  unzip: null
+});
+_defineProperty(Console, "LOG_THROTTLE", 500);
+export default Console;
+//# sourceMappingURL=Console.js.map