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

package/dist/notebook/ScriptEditor.js

@@ -1,25 +1,3 @@
-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 _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); }
-
 /**
  * Script editor for large blocks of code
  */
@@ -28,325 +6,307 @@ import PropTypes from 'prop-types';
 import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
 import { LoadingOverlay } from '@deephaven/components';
 import Log from '@deephaven/log';
-import Editor from './Editor';
-import { MonacoCompletionProvider, MonacoUtils } from '../monaco';
+import Editor from "./Editor.js";
+import { MonacoCompletionProvider, MonacoUtils } from "../monaco/index.js";
 import "./ScriptEditor.css";
 var log = Log.module('ScriptEditor');
 
-var ScriptEditor = /*#__PURE__*/function (_Component) {
-  _inherits(ScriptEditor, _Component);
-
-  var _super = _createSuper(ScriptEditor);
-
-  function ScriptEditor(props) {
-    var _this;
-
-    _classCallCheck(this, ScriptEditor);
-
-    _this = _super.call(this, props);
-    _this.handleEditorInitialized = _this.handleEditorInitialized.bind(_assertThisInitialized(_this));
-    _this.handleEditorWillDestroy = _this.handleEditorWillDestroy.bind(_assertThisInitialized(_this));
-    _this.handleRun = _this.handleRun.bind(_assertThisInitialized(_this));
-    _this.handleRunSelected = _this.handleRunSelected.bind(_assertThisInitialized(_this));
-    _this.contextActionCleanups = [];
-    _this.completionCleanup = null;
-    _this.editor = null;
-    _this.editorComponent = /*#__PURE__*/React.createRef();
-    _this.state = {
+class ScriptEditor extends Component {
+  constructor(props) {
+    super(props);
+    this.handleEditorInitialized = this.handleEditorInitialized.bind(this);
+    this.handleEditorWillDestroy = this.handleEditorWillDestroy.bind(this);
+    this.handleRun = this.handleRun.bind(this);
+    this.handleRunSelected = this.handleRunSelected.bind(this);
+    this.contextActionCleanups = [];
+    this.completionCleanup = null;
+    this.editor = null;
+    this.editorComponent = /*#__PURE__*/React.createRef();
+    this.state = {
       model: null
     };
-    return _this;
   }
 
-  _createClass(ScriptEditor, [{
-    key: "componentDidUpdate",
-    value: function componentDidUpdate(prevProps) {
-      var _this$props = this.props,
-          sessionLanguage = _this$props.sessionLanguage,
-          settings = _this$props.settings;
-      var language = settings.language;
-      var languageChanged = language !== prevProps.settings.language;
-
-      if (languageChanged) {
-        log.debug('Set language', language);
-        this.setLanguage(language);
-      }
+  componentDidUpdate(prevProps) {
+    var {
+      sessionLanguage,
+      settings
+    } = this.props;
+    var {
+      language
+    } = settings;
+    var languageChanged = language !== prevProps.settings.language;
+
+    if (languageChanged) {
+      log.debug('Set language', language);
+      this.setLanguage(language);
+    }
 
-      var sessionDisconnected = sessionLanguage == null && prevProps.sessionLanguage != null;
-      var languageMatch = language === sessionLanguage;
-      var prevLanguageMatch = prevProps.settings.language === prevProps.sessionLanguage;
+    var sessionDisconnected = sessionLanguage == null && prevProps.sessionLanguage != null;
+    var languageMatch = language === sessionLanguage;
+    var prevLanguageMatch = prevProps.settings.language === prevProps.sessionLanguage;
 
-      if (sessionDisconnected || sessionLanguage && prevLanguageMatch && !languageMatch) {
-        // Session disconnected or language changed from matching the session language to non-matching
-        log.debug('De-init completion and context actions');
-        this.deInitContextActions();
-        this.deInitCodeCompletion();
-      }
+    if (sessionDisconnected || sessionLanguage && prevLanguageMatch && !languageMatch) {
+      // Session disconnected or language changed from matching the session language to non-matching
+      log.debug('De-init completion and context actions');
+      this.deInitContextActions();
+      this.deInitCodeCompletion();
+    }
 
-      var sessionConnected = sessionLanguage != null && prevProps.sessionLanguage == null;
+    var sessionConnected = sessionLanguage != null && prevProps.sessionLanguage == null;
 
-      if (sessionConnected && languageMatch || sessionLanguage && !prevLanguageMatch && languageMatch) {
-        // Session connected with a matching language or notebook language changed to matching
-        log.debug('Init completion and context actions');
-        this.initContextActions();
-        this.initCodeCompletion();
-      }
+    if (sessionConnected && languageMatch || sessionLanguage && !prevLanguageMatch && languageMatch) {
+      // Session connected with a matching language or notebook language changed to matching
+      log.debug('Init completion and context actions');
+      this.initContextActions();
+      this.initCodeCompletion();
     }
-  }, {
-    key: "getValue",
-    value: function getValue() {
-      if (this.editor) {
-        return this.editor.getValue();
-      }
+  }
 
-      log.error('Editor not initialized');
-      return null;
-    }
-  }, {
-    key: "getSelectedCommand",
-    value: function getSelectedCommand() {
-      var range = this.editor.getSelection();
-      var model = this.editor.getModel();
-      var startLineNumber = range.startLineNumber,
-          endLineNumber = range.endLineNumber;
-      var startLineMinColumn = model.getLineMinColumn(startLineNumber);
-      var endLineMaxColumn = model.getLineMaxColumn(endLineNumber);
-      var wholeLineRange = range.setStartPosition(startLineNumber, startLineMinColumn).setEndPosition(endLineNumber, endLineMaxColumn);
-      return model.getValueInRange(wholeLineRange);
+  getValue() {
+    if (this.editor) {
+      return this.editor.getValue();
     }
-  }, {
-    key: "handleEditorInitialized",
-    value: function handleEditorInitialized(editor) {
-      var _this$props2 = this.props,
-          focusOnMount = _this$props2.focusOnMount,
-          onChange = _this$props2.onChange,
-          settings = _this$props2.settings,
-          session = _this$props2.session,
-          sessionLanguage = _this$props2.sessionLanguage;
-      log.debug('handleEditorInitialized', sessionLanguage, session, settings);
-      this.editor = editor;
-      this.setState({
-        model: this.editor.getModel()
-      });
-      MonacoUtils.setEOL(editor);
-      MonacoUtils.registerPasteHandler(editor);
-
-      if (session && settings && sessionLanguage === settings.language) {
-        this.initContextActions();
-        this.initCodeCompletion();
-      }
 
-      editor.onDidChangeModelContent(onChange);
+    log.error('Editor not initialized');
+    return null;
+  }
 
-      if (focusOnMount) {
-        editor.focus();
-      }
+  getSelectedCommand() {
+    var range = this.editor.getSelection();
+    var model = this.editor.getModel();
+    var {
+      startLineNumber,
+      endLineNumber
+    } = range;
+    var startLineMinColumn = model.getLineMinColumn(startLineNumber);
+    var endLineMaxColumn = model.getLineMaxColumn(endLineNumber);
+    var wholeLineRange = range.setStartPosition(startLineNumber, startLineMinColumn).setEndPosition(endLineNumber, endLineMaxColumn);
+    return model.getValueInRange(wholeLineRange);
+  }
+
+  handleEditorInitialized(editor) {
+    var {
+      focusOnMount,
+      onChange,
+      settings,
+      session,
+      sessionLanguage
+    } = this.props;
+    log.debug('handleEditorInitialized', sessionLanguage, session, settings);
+    this.editor = editor;
+    this.setState({
+      model: this.editor.getModel()
+    });
+    MonacoUtils.setEOL(editor);
+    MonacoUtils.registerPasteHandler(editor);
+
+    if (session && settings && sessionLanguage === settings.language) {
+      this.initContextActions();
+      this.initCodeCompletion();
     }
-  }, {
-    key: "handleEditorWillDestroy",
-    value: function handleEditorWillDestroy() {
-      log.debug('handleEditorWillDestroy');
-      this.deInitContextActions();
-      this.deInitCodeCompletion();
-      this.setState({
-        model: null
-      });
-      this.editor = null;
+
+    editor.onDidChangeModelContent(onChange);
+
+    if (focusOnMount) {
+      editor.focus();
     }
-  }, {
-    key: "handleRun",
-    value: function handleRun() {
-      var onRunCommand = this.props.onRunCommand;
-      var command = this.getValue();
-      onRunCommand(command);
+  }
+
+  handleEditorWillDestroy() {
+    log.debug('handleEditorWillDestroy');
+    this.deInitContextActions();
+    this.deInitCodeCompletion();
+    this.setState({
+      model: null
+    });
+    this.editor = null;
+  }
+
+  handleRun() {
+    var {
+      onRunCommand
+    } = this.props;
+    var command = this.getValue();
+    onRunCommand(command);
+  }
+
+  handleRunSelected() {
+    var {
+      onRunCommand
+    } = this.props;
+    var command = this.getSelectedCommand();
+    onRunCommand(command);
+  }
+
+  initContextActions() {
+    if (this.contextActionCleanups.length > 0) {
+      log.error('Context actions already initialized.');
+      return;
     }
-  }, {
-    key: "handleRunSelected",
-    value: function handleRunSelected() {
-      var onRunCommand = this.props.onRunCommand;
-      var command = this.getSelectedCommand();
-      onRunCommand(command);
+
+    if (!this.editor) {
+      return;
     }
-  }, {
-    key: "initContextActions",
-    value: function initContextActions() {
-      var _this2 = this;
-
-      if (this.contextActionCleanups.length > 0) {
-        log.error('Context actions already initialized.');
-        return;
-      }
 
-      if (!this.editor) {
-        return;
+    var cleanups = [];
+    cleanups.push(this.editor.addAction({
+      id: 'run-code',
+      label: 'Run',
+      // eslint-disable-next-line no-bitwise
+      keybindings: [monaco.KeyMod.Alt | monaco.KeyCode.KEY_R],
+      precondition: null,
+      keybindingContext: null,
+      contextMenuGroupId: 'navigation',
+      contextMenuOrder: 1.5,
+      run: () => {
+        this.handleRun();
+        return null;
+      }
+    }));
+    cleanups.push(this.editor.addAction({
+      id: 'run-selected-code',
+      label: 'Run Selected',
+      keybindings: [// eslint-disable-next-line no-bitwise
+      monaco.KeyMod.Alt | monaco.KeyMod.Shift | monaco.KeyCode.KEY_R],
+      precondition: null,
+      keybindingContext: null,
+      contextMenuGroupId: 'navigation',
+      contextMenuOrder: 1.5,
+      run: () => {
+        this.handleRunSelected();
+        return null;
       }
+    }));
+    this.contextActionCleanups = cleanups;
+  }
 
-      var cleanups = [];
-      cleanups.push(this.editor.addAction({
-        id: 'run-code',
-        label: 'Run',
-        // eslint-disable-next-line no-bitwise
-        keybindings: [monaco.KeyMod.Alt | monaco.KeyCode.KEY_R],
-        precondition: null,
-        keybindingContext: null,
-        contextMenuGroupId: 'navigation',
-        contextMenuOrder: 1.5,
-        run: function run() {
-          _this2.handleRun();
-
-          return null;
-        }
-      }));
-      cleanups.push(this.editor.addAction({
-        id: 'run-selected-code',
-        label: 'Run Selected',
-        keybindings: [// eslint-disable-next-line no-bitwise
-        monaco.KeyMod.Alt | monaco.KeyMod.Shift | monaco.KeyCode.KEY_R],
-        precondition: null,
-        keybindingContext: null,
-        contextMenuGroupId: 'navigation',
-        contextMenuOrder: 1.5,
-        run: function run() {
-          _this2.handleRunSelected();
-
-          return null;
-        }
-      }));
-      this.contextActionCleanups = cleanups;
+  deInitContextActions() {
+    if (this.contextActionCleanups.length > 0) {
+      this.contextActionCleanups.forEach(cleanup => cleanup.dispose());
+      this.contextActionCleanups = [];
     }
-  }, {
-    key: "deInitContextActions",
-    value: function deInitContextActions() {
-      if (this.contextActionCleanups.length > 0) {
-        this.contextActionCleanups.forEach(function (cleanup) {
-          return cleanup.dispose();
-        });
-        this.contextActionCleanups = [];
-      }
+  }
+
+  initCodeCompletion() {
+    if (this.completionCleanup != null) {
+      log.error('Code completion already initialized.');
+      return;
     }
-  }, {
-    key: "initCodeCompletion",
-    value: function initCodeCompletion() {
-      if (this.completionCleanup != null) {
-        log.error('Code completion already initialized.');
-        return;
-      }
 
-      var session = this.props.session;
-      log.debug('initCodeCompletion', this.editor, session);
+    var {
+      session
+    } = this.props;
+    log.debug('initCodeCompletion', this.editor, session);
 
-      if (this.editor && session) {
-        this.completionCleanup = MonacoUtils.openDocument(this.editor, session);
-      }
+    if (this.editor && session) {
+      this.completionCleanup = MonacoUtils.openDocument(this.editor, session);
     }
-  }, {
-    key: "deInitCodeCompletion",
-    value: function deInitCodeCompletion() {
-      var session = this.props.session;
-      log.debug('deInitCodeCompletion', this.editor, session);
-
-      if (this.completionCleanup) {
-        this.completionCleanup.dispose();
-        this.completionCleanup = null;
-      }
+  }
 
-      if (this.editor && session) {
-        MonacoUtils.closeDocument(this.editor, session);
-      }
+  deInitCodeCompletion() {
+    var {
+      session
+    } = this.props;
+    log.debug('deInitCodeCompletion', this.editor, session);
+
+    if (this.completionCleanup) {
+      this.completionCleanup.dispose();
+      this.completionCleanup = null;
     }
-  }, {
-    key: "append",
-    value: function append(text) {
-      var focus = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-      var model = this.editor.getModel();
-      var currentText = model.getValue();
-
-      if (currentText) {
-        model.setValue("".concat(currentText, "\n").concat(text));
-      } else {
-        model.setValue("".concat(text));
-      }
 
-      var lastLine = model.getLineCount();
-      var column = model.getLineLength(lastLine) + 1;
-      this.editor.setPosition({
-        lineNumber: lastLine,
-        column: column
-      });
+    if (this.editor && session) {
+      MonacoUtils.closeDocument(this.editor, session);
+    }
+  }
 
-      if (focus) {
-        this.editor.focus();
-      }
+  append(text) {
+    var focus = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    var model = this.editor.getModel();
+    var currentText = model.getValue();
+
+    if (currentText) {
+      model.setValue("".concat(currentText, "\n").concat(text));
+    } else {
+      model.setValue("".concat(text));
     }
-  }, {
-    key: "updateDimensions",
-    value: function updateDimensions() {
-      log.debug('updateDimensions');
 
-      if (this.editor) {
-        this.editor.layout();
-      }
+    var lastLine = model.getLineCount();
+    var column = model.getLineLength(lastLine) + 1;
+    this.editor.setPosition({
+      lineNumber: lastLine,
+      column
+    });
+
+    if (focus) {
+      this.editor.focus();
     }
-  }, {
-    key: "focus",
-    value: function focus() {
-      log.debug('focus');
+  }
 
-      if (this.editor) {
-        this.editor.focus();
-      }
+  updateDimensions() {
+    log.debug('updateDimensions');
+
+    if (this.editor) {
+      this.editor.layout();
     }
-  }, {
-    key: "toggleFind",
-    value: function toggleFind() {
-      if (this.editorComponent.current) {
-        this.editorComponent.current.toggleFind();
-      }
+  }
+
+  focus() {
+    log.debug('focus');
+
+    if (this.editor) {
+      this.editor.focus();
     }
-  }, {
-    key: "setLanguage",
-    value: function setLanguage(language) {
-      if (this.editorComponent.current) {
-        this.editorComponent.current.setLanguage(language);
-      }
+  }
+
+  toggleFind() {
+    if (this.editorComponent.current) {
+      this.editorComponent.current.toggleFind();
     }
-  }, {
-    key: "render",
-    value: function render() {
-      var _this$props3 = this.props,
-          error = _this$props3.error,
-          isLoaded = _this$props3.isLoaded,
-          isLoading = _this$props3.isLoading,
-          session = _this$props3.session,
-          sessionLanguage = _this$props3.sessionLanguage,
-          settings = _this$props3.settings;
-      var model = this.state.model;
-      var errorMessage = error ? "Unable to open document. ".concat(error) : null;
-      var editorLanguage = settings ? settings.language : null;
-      var completionProviderEnabled = model && session && editorLanguage === sessionLanguage;
-      return /*#__PURE__*/React.createElement(React.Fragment, null, (error || isLoading) && /*#__PURE__*/React.createElement("div", {
-        className: "h-100 w-100 position-relative"
-      }, /*#__PURE__*/React.createElement(LoadingOverlay, {
-        errorMessage: errorMessage,
-        isLoading: isLoading,
-        isLoaded: isLoaded
-      })), isLoaded && /*#__PURE__*/React.createElement("div", {
-        className: "h-100 w-100 script-editor"
-      }, settings && /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Editor, {
-        ref: this.editorComponent,
-        settings: settings,
-        onEditorInitialized: this.handleEditorInitialized,
-        onEditorWillDestroy: this.handleEditorWillDestroy
-      }), completionProviderEnabled && /*#__PURE__*/React.createElement(MonacoCompletionProvider, {
-        model: model,
-        language: editorLanguage,
-        session: session
-      }))));
+  }
+
+  setLanguage(language) {
+    if (this.editorComponent.current) {
+      this.editorComponent.current.setLanguage(language);
     }
-  }]);
+  }
+
+  render() {
+    var {
+      error,
+      isLoaded,
+      isLoading,
+      session,
+      sessionLanguage,
+      settings
+    } = this.props;
+    var {
+      model
+    } = this.state;
+    var errorMessage = error ? "Unable to open document. ".concat(error) : null;
+    var editorLanguage = settings ? settings.language : null;
+    var completionProviderEnabled = model && session && editorLanguage === sessionLanguage;
+    return /*#__PURE__*/React.createElement(React.Fragment, null, (error || isLoading) && /*#__PURE__*/React.createElement("div", {
+      className: "h-100 w-100 position-relative"
+    }, /*#__PURE__*/React.createElement(LoadingOverlay, {
+      errorMessage: errorMessage,
+      isLoading: isLoading,
+      isLoaded: isLoaded
+    })), isLoaded && /*#__PURE__*/React.createElement("div", {
+      className: "h-100 w-100 script-editor"
+    }, settings && /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Editor, {
+      ref: this.editorComponent,
+      settings: settings,
+      onEditorInitialized: this.handleEditorInitialized,
+      onEditorWillDestroy: this.handleEditorWillDestroy
+    }), completionProviderEnabled && /*#__PURE__*/React.createElement(MonacoCompletionProvider, {
+      model: model,
+      language: editorLanguage,
+      session: session
+    }))));
+  }
 
-  return ScriptEditor;
-}(Component);
+}
 
 ScriptEditor.propTypes = {
   error: PropTypes.shape({
@@ -369,7 +329,7 @@ ScriptEditor.defaultProps = {
   isLoading: false,
   isLoaded: false,
   focusOnMount: true,
-  onChange: function onChange() {},
+  onChange: () => {},
   session: null,
   sessionLanguage: null,
   settings: null