@deephaven/console 0.5.2-matplotlib.2 → 0.6.1-demo.8

package/dist/ConsoleInput.js

@@ -1,54 +1,18 @@
-function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
-function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
-
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
 
 function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-
-function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
 import React, { PureComponent } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
-import { connect } from 'react-redux';
 import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
 import Log from '@deephaven/log';
 import { PromiseUtils } from '@deephaven/utils';
-import { getCommandHistoryStorage } from '@deephaven/redux';
-import { MonacoCompletionProvider, MonacoTheme, MonacoUtils } from './monaco';
+import { MonacoCompletionProvider, MonacoTheme, MonacoUtils } from "./monaco/index.js";
 import "./ConsoleInput.css";
-import StoragePropTypes from './StoragePropTypes';
+import StoragePropTypes from "./StoragePropTypes.js";
 var log = Log.module('ConsoleInput');
 var LINE_HEIGHT = parseInt(MonacoTheme['line-height'], 10);
 var TOP_PADDING = 6;
@@ -59,437 +23,377 @@ var BUFFER_SIZE = 100;
  * Component for input in a console session. Handles loading the recent command history
  */
 
-export var ConsoleInput = /*#__PURE__*/function (_PureComponent) {
-  _inherits(ConsoleInput, _PureComponent);
-
-  var _super = _createSuper(ConsoleInput);
-
-  function ConsoleInput(props) {
-    var _this;
-
-    _classCallCheck(this, ConsoleInput);
-
-    _this = _super.call(this, props);
-    _this.handleWindowResize = _this.handleWindowResize.bind(_assertThisInitialized(_this));
-    _this.cancelListener = null;
-    _this.commandContainer = /*#__PURE__*/React.createRef();
-    _this.commandEditor = null;
-    _this.commandHistoryIndex = null;
-    _this.commandSuggestionContainer = null;
-    _this.isCommandModified = false;
-    _this.loadingPromise = null;
-    _this.timestamp = Date.now();
-    _this.bufferIndex = 0;
-    _this.history = [];
-    _this.state = {
+export class ConsoleInput extends PureComponent {
+  constructor(props) {
+    super(props);
+    this.handleWindowResize = this.handleWindowResize.bind(this);
+    this.cancelListener = null;
+    this.commandContainer = /*#__PURE__*/React.createRef();
+    this.commandEditor = null;
+    this.commandHistoryIndex = null;
+    this.commandSuggestionContainer = null;
+    this.isCommandModified = false;
+    this.loadingPromise = null;
+    this.timestamp = Date.now();
+    this.bufferIndex = 0;
+    this.history = [];
+    this.state = {
       commandEditorHeight: LINE_HEIGHT,
       isFocused: false,
       model: null
     };
-    return _this;
   }
 
-  _createClass(ConsoleInput, [{
-    key: "componentDidMount",
-    value: function componentDidMount() {
-      this.initCommandEditor();
-      window.addEventListener('resize', this.handleWindowResize);
-      this.loadMoreHistory();
-    }
-  }, {
-    key: "componentDidUpdate",
-    value: function componentDidUpdate() {
-      this.layoutEditor();
+  componentDidMount() {
+    this.initCommandEditor();
+    window.addEventListener('resize', this.handleWindowResize);
+    this.loadMoreHistory();
+  }
+
+  componentDidUpdate() {
+    this.layoutEditor();
+  }
+
+  componentWillUnmount() {
+    window.removeEventListener('resize', this.handleWindowResize);
+
+    if (this.loadingPromise != null) {
+      this.loadingPromise.cancel();
     }
-  }, {
-    key: "componentWillUnmount",
-    value: function componentWillUnmount() {
-      window.removeEventListener('resize', this.handleWindowResize);
 
-      if (this.loadingPromise != null) {
-        this.loadingPromise.cancel();
-      }
+    this.destroyCommandEditor();
+  }
 
-      this.destroyCommandEditor();
+  setConsoleText(text) {
+    var focus = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    var execute = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+
+    if (!text) {
+      return;
     }
-  }, {
-    key: "setConsoleText",
-    value: function setConsoleText(text) {
-      var focus = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-      var execute = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-
-      if (!text) {
-        return;
-      }
 
-      log.debug('Command received: ', text);
-      this.commandEditor.setValue(text);
+    log.debug('Command received: ', text);
+    this.commandEditor.setValue(text);
 
-      if (focus) {
-        this.focusEnd();
-      }
+    if (focus) {
+      this.focusEnd();
+    }
 
-      this.updateDimensions();
+    this.updateDimensions();
 
-      if (execute) {
-        this.processCommand();
-      }
+    if (execute) {
+      this.processCommand();
     }
-  }, {
-    key: "initCommandEditor",
-    value: function initCommandEditor() {
-      var _this2 = this;
-
-      var _this$props = this.props,
-          language = _this$props.language,
-          session = _this$props.session;
-      var commandSettings = {
-        copyWithSyntaxHighlighting: 'false',
-        cursorStyle: 'block',
-        fixedOverflowWidgets: true,
-        folding: false,
-        fontFamily: 'Fira Mono',
-        glyphMargin: false,
-        language: language,
-        lineHeight: LINE_HEIGHT,
-        lineDecorationsWidth: 3,
-        lineNumbers: 'off',
-        minimap: {
-          enabled: false
-        },
-        renderLineHighlight: 'none',
-        scrollBeyondLastLine: false,
-        scrollbar: {
-          arrowSize: 0,
-          horizontal: 'hidden',
-          horizontalScrollbarSize: 0
-        },
-        padding: {
-          top: TOP_PADDING,
-          bottom: BOTTOM_PADDING
-        },
-        tabCompletion: 'on',
-        value: '',
-        wordWrap: 'on'
-      };
-      this.commandEditor = monaco.editor.create(this.commandContainer.current, commandSettings);
-      MonacoUtils.setEOL(this.commandEditor);
-      MonacoUtils.openDocument(this.commandEditor, session);
-      this.commandEditor.onDidChangeModelContent(function () {
-        _this2.isCommandModified = true;
-
-        _this2.updateDimensions();
-      });
-      this.commandEditor.onDidFocusEditorText(function () {
-        _this2.setState({
-          isFocused: true
-        });
+  }
+
+  initCommandEditor() {
+    var {
+      language,
+      session
+    } = this.props;
+    var commandSettings = {
+      copyWithSyntaxHighlighting: 'false',
+      cursorStyle: 'block',
+      fixedOverflowWidgets: true,
+      folding: false,
+      fontFamily: 'Fira Mono',
+      glyphMargin: false,
+      language,
+      lineHeight: LINE_HEIGHT,
+      lineDecorationsWidth: 3,
+      lineNumbers: 'off',
+      minimap: {
+        enabled: false
+      },
+      renderLineHighlight: 'none',
+      scrollBeyondLastLine: false,
+      scrollbar: {
+        arrowSize: 0,
+        horizontal: 'hidden',
+        horizontalScrollbarSize: 0
+      },
+      padding: {
+        top: TOP_PADDING,
+        bottom: BOTTOM_PADDING
+      },
+      tabCompletion: 'on',
+      value: '',
+      wordWrap: 'on'
+    };
+    this.commandEditor = monaco.editor.create(this.commandContainer.current, commandSettings);
+    MonacoUtils.setEOL(this.commandEditor);
+    MonacoUtils.openDocument(this.commandEditor, session);
+    this.commandEditor.onDidChangeModelContent(() => {
+      this.isCommandModified = true;
+      this.updateDimensions();
+    });
+    this.commandEditor.onDidFocusEditorText(() => {
+      this.setState({
+        isFocused: true
       });
-      this.commandEditor.onDidBlurEditorText(function () {
-        _this2.setState({
-          isFocused: false
-        });
+    });
+    this.commandEditor.onDidBlurEditorText(() => {
+      this.setState({
+        isFocused: false
       });
-      /**
-       * Register for keydown events to capture the `Enter` key.
-       * Need to do it this way instead of using `addCommand`, because that would eat the Enter key in all situations, which is not what we want.
-       * Can't do it in `onDidChangeModelContent` either, since we want to stop the Enter action from modifying the command.
-       */
-
-      this.commandEditor.onKeyDown(function (keyEvent) {
-        if (!_this2.isCommandModified || _this2.commandEditor.getModel().getValueLength() === 0) {
-          if (keyEvent.keyCode === monaco.KeyCode.UpArrow) {
-            var commandHistoryIndex = _this2.commandHistoryIndex;
-
-            if (commandHistoryIndex != null) {
-              _this2.loadCommand(commandHistoryIndex + 1);
-            } else {
-              _this2.loadCommand(0);
-            }
-
-            keyEvent.stopPropagation();
-            keyEvent.preventDefault();
-            return;
+    });
+    /**
+     * Register for keydown events to capture the `Enter` key.
+     * Need to do it this way instead of using `addCommand`, because that would eat the Enter key in all situations, which is not what we want.
+     * Can't do it in `onDidChangeModelContent` either, since we want to stop the Enter action from modifying the command.
+     */
+
+    this.commandEditor.onKeyDown(keyEvent => {
+      if (!this.isCommandModified || this.commandEditor.getModel().getValueLength() === 0) {
+        if (keyEvent.keyCode === monaco.KeyCode.UpArrow) {
+          var {
+            commandHistoryIndex
+          } = this;
+
+          if (commandHistoryIndex != null) {
+            this.loadCommand(commandHistoryIndex + 1);
+          } else {
+            this.loadCommand(0);
           }
 
-          if (keyEvent.keyCode === monaco.KeyCode.DownArrow) {
-            var _commandHistoryIndex = _this2.commandHistoryIndex;
+          keyEvent.stopPropagation();
+          keyEvent.preventDefault();
+          return;
+        }
+
+        if (keyEvent.keyCode === monaco.KeyCode.DownArrow) {
+          var {
+            commandHistoryIndex: _commandHistoryIndex
+          } = this;
+
+          if (_commandHistoryIndex != null && _commandHistoryIndex >= 0) {
+            this.loadCommand(_commandHistoryIndex - 1);
+          } else {
+            this.commandHistoryIndex = null;
+          }
 
-            if (_commandHistoryIndex != null && _commandHistoryIndex >= 0) {
-              _this2.loadCommand(_commandHistoryIndex - 1);
-            } else {
-              _this2.commandHistoryIndex = null;
-            }
+          keyEvent.stopPropagation();
+          keyEvent.preventDefault();
+          return;
+        }
+      }
 
+      if (!keyEvent.altKey && !keyEvent.shiftKey && !keyEvent.metaKey) {
+        if (keyEvent.keyCode === monaco.KeyCode.Enter) {
+          if (!this.isSuggestionMenuPopulated()) {
             keyEvent.stopPropagation();
             keyEvent.preventDefault();
-            return;
+            this.processCommand();
           }
-        }
-
-        if (!keyEvent.altKey && !keyEvent.shiftKey && !keyEvent.metaKey) {
-          if (keyEvent.keyCode === monaco.KeyCode.Enter) {
-            if (!_this2.isSuggestionMenuPopulated()) {
-              keyEvent.stopPropagation();
-              keyEvent.preventDefault();
-
-              _this2.processCommand();
-            }
-          } else if (keyEvent.keyCode === monaco.KeyCode.Tab) {
-            if (!_this2.isSuggestionMenuActive()) {
-              keyEvent.stopPropagation();
-              keyEvent.preventDefault();
-
-              _this2.commandEditor.trigger('Tab key trigger suggestions', 'editor.action.triggerSuggest', {});
-            } else if (!_this2.isSuggestionMenuPopulated()) {
-              keyEvent.stopPropagation();
-              keyEvent.preventDefault();
-            }
+        } else if (keyEvent.keyCode === monaco.KeyCode.Tab) {
+          if (!this.isSuggestionMenuActive()) {
+            keyEvent.stopPropagation();
+            keyEvent.preventDefault();
+            this.commandEditor.trigger('Tab key trigger suggestions', 'editor.action.triggerSuggest', {});
+          } else if (!this.isSuggestionMenuPopulated()) {
+            keyEvent.stopPropagation();
+            keyEvent.preventDefault();
           }
         }
-      }); // Override the Ctrl+F functionality so that the find window doesn't appear
-
-      this.commandEditor.addCommand(monaco.KeyMod.CtrlCmd | monaco.KeyCode.KEY_F, // eslint-disable-line no-bitwise
-      function () {});
-      MonacoUtils.removeConflictingKeybindings(this.commandEditor);
-      MonacoUtils.registerPasteHandler(this.commandEditor);
-      this.commandEditor.focus();
-      this.updateDimensions();
-      this.setState({
-        model: this.commandEditor.getModel()
-      });
-    }
-  }, {
-    key: "destroyCommandEditor",
-    value: function destroyCommandEditor() {
-      var session = this.props.session;
-
-      if (this.commandEditor) {
-        MonacoUtils.closeDocument(this.commandEditor, session);
-        this.commandEditor.dispose();
-        this.commandEditor = null;
-      }
-    }
-  }, {
-    key: "handleWindowResize",
-    value: function handleWindowResize() {
-      this.updateDimensions();
-    }
-  }, {
-    key: "isSuggestionMenuActive",
-    value: function isSuggestionMenuActive() {
-      if (!this.commandSuggestionContainer) {
-        this.commandSuggestionContainer = this.commandEditor.getDomNode().querySelector('.suggest-widget');
       }
+    }); // Override the Ctrl+F functionality so that the find window doesn't appear
+
+    this.commandEditor.addCommand(monaco.KeyMod.CtrlCmd | monaco.KeyCode.KEY_F, // eslint-disable-line no-bitwise
+    () => {});
+    MonacoUtils.removeConflictingKeybindings(this.commandEditor);
+    MonacoUtils.registerPasteHandler(this.commandEditor);
+    this.commandEditor.focus();
+    this.updateDimensions();
+    this.setState({
+      model: this.commandEditor.getModel()
+    });
+  }
 
-      return this.commandSuggestionContainer && this.commandSuggestionContainer.classList.contains('visible');
-    }
-  }, {
-    key: "isSuggestionMenuPopulated",
-    value: function isSuggestionMenuPopulated() {
-      return this.isSuggestionMenuActive() && this.commandSuggestionContainer.querySelector('.monaco-list-rows').childElementCount > 0;
+  destroyCommandEditor() {
+    var {
+      session
+    } = this.props;
+
+    if (this.commandEditor) {
+      MonacoUtils.closeDocument(this.commandEditor, session);
+      this.commandEditor.dispose();
+      this.commandEditor = null;
     }
-  }, {
-    key: "focus",
-    value: function focus() {
-      this.commandEditor.focus();
+  }
+
+  handleWindowResize() {
+    this.updateDimensions();
+  }
+
+  isSuggestionMenuActive() {
+    if (!this.commandSuggestionContainer) {
+      this.commandSuggestionContainer = this.commandEditor.getDomNode().querySelector('.suggest-widget');
     }
-  }, {
-    key: "focusEnd",
-    value: function focusEnd() {
-      var model = this.commandEditor.getModel();
-      var lastLine = model.getLineCount();
-      var column = model.getLineLength(lastLine) + 1;
-      var lastCharTop = this.commandEditor.getTopForPosition(lastLine, column);
-      this.commandEditor.setPosition({
-        lineNumber: lastLine,
-        column: column
-      });
-      this.commandEditor.setScrollTop(lastCharTop);
-      this.commandEditor.focus();
+
+    return this.commandSuggestionContainer && this.commandSuggestionContainer.classList.contains('visible');
+  }
+
+  isSuggestionMenuPopulated() {
+    return this.isSuggestionMenuActive() && this.commandSuggestionContainer.querySelector('.monaco-list-rows').childElementCount > 0;
+  }
+
+  focus() {
+    this.commandEditor.focus();
+  }
+
+  focusEnd() {
+    var model = this.commandEditor.getModel();
+    var lastLine = model.getLineCount();
+    var column = model.getLineLength(lastLine) + 1;
+    var lastCharTop = this.commandEditor.getTopForPosition(lastLine, column);
+    this.commandEditor.setPosition({
+      lineNumber: lastLine,
+      column
+    });
+    this.commandEditor.setScrollTop(lastCharTop);
+    this.commandEditor.focus();
+  }
+
+  clear() {
+    this.commandEditor.focus();
+    this.commandEditor.getModel().setValue('');
+    this.commandHistoryIndex = null;
+  }
+
+  layoutEditor() {
+    if (this.commandEditor) {
+      this.commandEditor.layout();
     }
-  }, {
-    key: "clear",
-    value: function clear() {
-      this.commandEditor.focus();
-      this.commandEditor.getModel().setValue('');
+  }
+
+  loadCommand(index) {
+    if (index < 0) {
       this.commandHistoryIndex = null;
-    }
-  }, {
-    key: "layoutEditor",
-    value: function layoutEditor() {
-      if (this.commandEditor) {
-        this.commandEditor.layout();
+      this.commandEditor.getModel().setValue('');
+    } else if (index < this.history.length) {
+      this.commandHistoryIndex = index;
+      this.commandEditor.getModel().setValue(this.history[this.history.length - index - 1]);
+
+      if (index > this.history.length - BUFFER_SIZE) {
+        this.loadMoreHistory();
       }
     }
-  }, {
-    key: "loadCommand",
-    value: function loadCommand(index) {
-      if (index < 0) {
-        this.commandHistoryIndex = null;
-        this.commandEditor.getModel().setValue('');
-      } else if (index < this.history.length) {
-        this.commandHistoryIndex = index;
-        this.commandEditor.getModel().setValue(this.history[this.history.length - index - 1]);
-
-        if (index > this.history.length - BUFFER_SIZE) {
-          this.loadMoreHistory();
+
+    this.isCommandModified = false;
+    this.focusEnd();
+  }
+
+  loadMoreHistory() {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      try {
+        if (_this.loadingPromise != null || _this.bufferIndex == null) {
+          return;
         }
-      }
 
-      this.isCommandModified = false;
-      this.focusEnd();
-    }
-  }, {
-    key: "loadMoreHistory",
-    value: function () {
-      var _loadMoreHistory = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
-        var _this$props2, commandHistoryStorage, language, scope, table, viewportData;
-
-        return regeneratorRuntime.wrap(function _callee$(_context) {
-          while (1) {
-            switch (_context.prev = _context.next) {
-              case 0:
-                _context.prev = 0;
-
-                if (!(this.loadingPromise != null || this.bufferIndex == null)) {
-                  _context.next = 3;
-                  break;
-                }
-
-                return _context.abrupt("return");
-
-              case 3:
-                _this$props2 = this.props, commandHistoryStorage = _this$props2.commandHistoryStorage, language = _this$props2.language, scope = _this$props2.scope;
-                this.loadingPromise = PromiseUtils.makeCancelable(commandHistoryStorage.getTable(language, scope, this.timestamp), function (resolved) {
-                  return resolved.close();
-                });
-                _context.next = 7;
-                return this.loadingPromise;
-
-              case 7:
-                table = _context.sent;
-                table.setReversed(true);
-                table.setViewport({
-                  top: this.bufferIndex,
-                  bottom: this.bufferIndex + BUFFER_SIZE - 1
-                });
-                this.loadingPromise = PromiseUtils.makeCancelable(table.getViewportData(), function () {
-                  return table.close();
-                });
-                _context.next = 13;
-                return this.loadingPromise;
-
-              case 13:
-                viewportData = _context.sent;
-                this.bufferIndex += BUFFER_SIZE;
-
-                if (this.bufferIndex >= table.size) {
-                  // We've loaded the full history, no need to load any more
-                  this.bufferIndex = null;
-                }
-
-                this.history = [].concat(_toConsumableArray(viewportData.items.map(function (_ref) {
-                  var name = _ref.name;
-                  return name;
-                }).reverse()), _toConsumableArray(this.history));
-                this.loadingPromise = null;
-                table.close();
-                _context.next = 28;
-                break;
-
-              case 21:
-                _context.prev = 21;
-                _context.t0 = _context["catch"](0);
-                this.loadingPromise = null;
-
-                if (!PromiseUtils.isCanceled(_context.t0)) {
-                  _context.next = 27;
-                  break;
-                }
-
-                log.debug2('Promise canceled, not loading history');
-                return _context.abrupt("return");
-
-              case 27:
-                log.error('Error fetching history', _context.t0);
-
-              case 28:
-              case "end":
-                return _context.stop();
-            }
-          }
-        }, _callee, this, [[0, 21]]);
-      }));
+        var {
+          commandHistoryStorage,
+          language,
+          scope
+        } = _this.props;
+        _this.loadingPromise = PromiseUtils.makeCancelable(commandHistoryStorage.getTable(language, scope, _this.timestamp), resolved => resolved.close());
+        var table = yield _this.loadingPromise;
+        table.setReversed(true);
+        table.setViewport({
+          top: _this.bufferIndex,
+          bottom: _this.bufferIndex + BUFFER_SIZE - 1
+        });
+        _this.loadingPromise = PromiseUtils.makeCancelable(table.getViewportData(), () => table.close());
+        var viewportData = yield _this.loadingPromise;
+        _this.bufferIndex += BUFFER_SIZE;
 
-      function loadMoreHistory() {
-        return _loadMoreHistory.apply(this, arguments);
-      }
+        if (_this.bufferIndex >= table.size) {
+          // We've loaded the full history, no need to load any more
+          _this.bufferIndex = null;
+        }
 
-      return loadMoreHistory;
-    }()
-  }, {
-    key: "processCommand",
-    value: function processCommand() {
-      this.isCommandModified = false;
-      this.commandHistoryIndex = null;
-      var command = this.commandEditor.getValue().trim();
-      this.history.push(command);
-      this.commandEditor.setValue('');
-      this.updateDimensions();
-      var onSubmit = this.props.onSubmit;
-      onSubmit(command);
-    }
-  }, {
-    key: "updateDimensions",
-    value: function updateDimensions() {
-      var _this3 = this;
+        _this.history = [...viewportData.items.map((_ref) => {
+          var {
+            name
+          } = _ref;
+          return name;
+        }).reverse(), ..._this.history];
+        _this.loadingPromise = null;
+        table.close();
+      } catch (err) {
+        _this.loadingPromise = null;
+
+        if (PromiseUtils.isCanceled(err)) {
+          log.debug2('Promise canceled, not loading history');
+          return;
+        }
 
-      if (!this.commandEditor) {
-        return;
+        log.error('Error fetching history', err);
       }
+    })();
+  }
 
-      var maxHeight = this.props.maxHeight;
-      var contentHeight = this.commandEditor.getContentHeight();
-      var commandEditorHeight = Math.max(Math.min(contentHeight, maxHeight), MIN_INPUT_HEIGHT);
-      this.setState({
-        commandEditorHeight: commandEditorHeight
-      }, function () {
-        _this3.commandEditor.layout();
-      });
-    }
-  }, {
-    key: "render",
-    value: function render() {
-      var _this$props3 = this.props,
-          language = _this$props3.language,
-          session = _this$props3.session;
-      var _this$state = this.state,
-          commandEditorHeight = _this$state.commandEditorHeight,
-          isFocused = _this$state.isFocused,
-          model = _this$state.model;
-      return /*#__PURE__*/React.createElement("div", {
-        className: "console-input-wrapper"
-      }, /*#__PURE__*/React.createElement("div", {
-        className: classNames('console-input-inner-wrapper', {
-          focus: isFocused
-        })
-      }, /*#__PURE__*/React.createElement("div", {
-        className: ConsoleInput.INPUT_CLASS_NAME,
-        ref: this.commandContainer,
-        style: {
-          height: commandEditorHeight
-        }
-      }), model && /*#__PURE__*/React.createElement(MonacoCompletionProvider, {
-        model: model,
-        language: language,
-        session: session
-      })));
+  processCommand() {
+    this.isCommandModified = false;
+    this.commandHistoryIndex = null;
+    var command = this.commandEditor.getValue().trim();
+    this.history.push(command);
+    this.commandEditor.setValue('');
+    this.updateDimensions();
+    var {
+      onSubmit
+    } = this.props;
+    onSubmit(command);
+  }
+
+  updateDimensions() {
+    if (!this.commandEditor) {
+      return;
     }
-  }]);
 
-  return ConsoleInput;
-}(PureComponent);
+    var {
+      maxHeight
+    } = this.props;
+    var contentHeight = this.commandEditor.getContentHeight();
+    var commandEditorHeight = Math.max(Math.min(contentHeight, maxHeight), MIN_INPUT_HEIGHT);
+    this.setState({
+      commandEditorHeight
+    }, () => {
+      this.commandEditor.layout();
+    });
+  }
+
+  render() {
+    var {
+      language,
+      session
+    } = this.props;
+    var {
+      commandEditorHeight,
+      isFocused,
+      model
+    } = this.state;
+    return /*#__PURE__*/React.createElement("div", {
+      className: "console-input-wrapper"
+    }, /*#__PURE__*/React.createElement("div", {
+      className: classNames('console-input-inner-wrapper', {
+        focus: isFocused
+      })
+    }, /*#__PURE__*/React.createElement("div", {
+      className: ConsoleInput.INPUT_CLASS_NAME,
+      ref: this.commandContainer,
+      style: {
+        height: commandEditorHeight
+      }
+    }), model && /*#__PURE__*/React.createElement(MonacoCompletionProvider, {
+      model: model,
+      language: language,
+      session: session
+    })));
+  }
+
+}
 
 _defineProperty(ConsoleInput, "INPUT_CLASS_NAME", 'console-input');
 
@@ -505,14 +409,5 @@ ConsoleInput.defaultProps = {
   maxHeight: LINE_HEIGHT * 10,
   scope: null
 };
-
-var mapStateToProps = function mapStateToProps(state) {
-  return {
-    commandHistoryStorage: getCommandHistoryStorage(state)
-  };
-};
-
-export default connect(mapStateToProps, null, null, {
-  forwardRef: true
-})(ConsoleInput);
+export default ConsoleInput;
 //# sourceMappingURL=ConsoleInput.js.map