@deephaven/console 0.42.1-beta.4 → 0.43.0

package/dist/Console.js

@@ -1,875 +0,0 @@
-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