@deephaven/dashboard-core-plugins 0.43.0 → 0.44.0

package/dist/panels/NotebookPanel.js

@@ -0,0 +1,1224 @@
+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); }
+// Wrapper for the Notebook for use in a golden layout container
+import React, { Component } from 'react';
+import ReactDOM from 'react-dom';
+import memoize from 'memoize-one';
+import { connect } from 'react-redux';
+import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
+import { BasicModal, ContextActions, DropdownMenu, Tooltip, GLOBAL_SHORTCUTS, Button } from '@deephaven/components';
+import { ScriptEditor, ScriptEditorUtils, SHORTCUTS } from '@deephaven/console';
+import { FileUtils, NewItemModal } from '@deephaven/file-explorer';
+import { vsSave, vsKebabVertical, dhFileSearch, vsPlay, dhRunSelection, vsCheck } from '@deephaven/icons';
+import { getFileStorage, saveSettings as saveSettingsAction, getSettings, getDefaultNotebookSettings } from '@deephaven/redux';
+import classNames from 'classnames';
+import debounce from 'lodash.debounce';
+import Log from '@deephaven/log';
+import { assertNotNull, Pending, PromiseUtils } from '@deephaven/utils';
+import { PanelEvent } from '@deephaven/dashboard';
+import { ConsoleEvent, NotebookEvent } from "../events/index.js";
+import { getDashboardSessionWrapper } from "../redux/index.js";
+import Panel from "./Panel.js";
+import MarkdownNotebook from "./MarkdownNotebook.js";
+import "./NotebookPanel.css";
+var log = Log.module('NotebookPanel');
+var DEBOUNCE_PANEL_STATE_UPDATE = 400;
+class NotebookPanel extends Component {
+  static handleError(error) {
+    if (PromiseUtils.isCanceled(error)) {
+      return;
+    }
+    log.error(error);
+  }
+  static languageFromFileName(fileName) {
+    var extension = FileUtils.getExtension(fileName).toLowerCase();
+    switch (extension) {
+      case 'py':
+      case 'python':
+        return 'python';
+      case 'groovy':
+        return 'groovy';
+      case 'scala':
+        return 'scala';
+      default:
+        return null;
+    }
+  }
+  constructor(props) {
+    super(props);
+    _defineProperty(this, "pending", void 0);
+    _defineProperty(this, "debouncedSavePanelState", void 0);
+    _defineProperty(this, "debouncedLoad", void 0);
+    _defineProperty(this, "notebook", void 0);
+    _defineProperty(this, "tabTitleElement", void 0);
+    _defineProperty(this, "tabInitOnce", void 0);
+    _defineProperty(this, "editor", void 0);
+    _defineProperty(this, "getSettings", memoize((initialSettings, isMinimapEnabled) => _objectSpread(_objectSpread({}, initialSettings), {}, {
+      minimap: {
+        enabled: isMinimapEnabled
+      }
+    })));
+    _defineProperty(this, "getOverflowActions", memoize((isMinimapEnabled, isWordWrapEnabled) => [{
+      title: 'Find',
+      icon: dhFileSearch,
+      action: this.handleFind,
+      group: ContextActions.groups.high,
+      shortcut: SHORTCUTS.NOTEBOOK.FIND,
+      order: 10
+    }, {
+      title: 'Show Minimap',
+      icon: isMinimapEnabled ? vsCheck : undefined,
+      action: this.handleMinimapChange,
+      group: ContextActions.groups.medium,
+      shortcut: SHORTCUTS.NOTEBOOK.MINIMAP,
+      order: 20
+    }, {
+      title: 'Word Wrap',
+      icon: isWordWrapEnabled ? vsCheck : undefined,
+      action: this.handleWordWrapChange,
+      group: ContextActions.groups.medium,
+      shortcut: SHORTCUTS.NOTEBOOK.WORDWRAP,
+      order: 30
+    }]));
+    this.handleBlur = this.handleBlur.bind(this);
+    this.handleCloseCancel = this.handleCloseCancel.bind(this);
+    this.handleCloseDiscard = this.handleCloseDiscard.bind(this);
+    this.handleCloseSave = this.handleCloseSave.bind(this);
+    this.handleCopy = this.handleCopy.bind(this);
+    this.handleEditorInitialized = this.handleEditorInitialized.bind(this);
+    this.handleEditorWillDestroy = this.handleEditorWillDestroy.bind(this);
+    this.handleEditorChange = this.handleEditorChange.bind(this);
+    this.handleFind = this.handleFind.bind(this);
+    this.handleMinimapChange = this.handleMinimapChange.bind(this);
+    this.handleWordWrapChange = this.handleWordWrapChange.bind(this);
+    this.handleFocus = this.handleFocus.bind(this);
+    this.handleLinkClick = this.handleLinkClick.bind(this);
+    this.handleLoadSuccess = this.handleLoadSuccess.bind(this);
+    this.handleLoadError = this.handleLoadError.bind(this);
+    this.handlePanelDropped = this.handlePanelDropped.bind(this);
+    this.handleRenameFile = this.handleRenameFile.bind(this);
+    this.handleResize = this.handleResize.bind(this);
+    this.handleRunCommand = this.handleRunCommand.bind(this);
+    this.handleRunAll = this.handleRunAll.bind(this);
+    this.handleRunSelected = this.handleRunSelected.bind(this);
+    this.handleSave = this.handleSave.bind(this);
+    this.handleSaveAsCancel = this.handleSaveAsCancel.bind(this);
+    this.handleSaveAsSubmit = this.handleSaveAsSubmit.bind(this);
+    this.handleSaveError = this.handleSaveError.bind(this);
+    this.handleSaveSuccess = this.handleSaveSuccess.bind(this);
+    this.handleSessionOpened = this.handleSessionOpened.bind(this);
+    this.handleSessionClosed = this.handleSessionClosed.bind(this);
+    this.handleShow = this.handleShow.bind(this);
+    this.handleShowRename = this.handleShowRename.bind(this);
+    this.handleTab = this.handleTab.bind(this);
+    this.handleTabBlur = this.handleTabBlur.bind(this);
+    this.handleTabClick = this.handleTabClick.bind(this);
+    this.handleTabFocus = this.handleTabFocus.bind(this);
+    this.handleTransformLinkUri = this.handleTransformLinkUri.bind(this);
+    this.handleOverwrite = this.handleOverwrite.bind(this);
+    this.handlePreviewPromotion = this.handlePreviewPromotion.bind(this);
+    this.getDropdownOverflowActions = this.getDropdownOverflowActions.bind(this);
+    this.pending = new Pending();
+    this.debouncedSavePanelState = debounce(this.savePanelState.bind(this), DEBOUNCE_PANEL_STATE_UPDATE);
+    this.debouncedLoad = debounce(this.load.bind(this), DEBOUNCE_PANEL_STATE_UPDATE);
+    this.notebook = null;
+    this.tabTitleElement = null;
+    this.tabInitOnce = false;
+    var {
+      isDashboardActive,
+      session,
+      sessionLanguage,
+      panelState
+    } = props;
+    var settings = {
+      value: '',
+      language: '',
+      wordWrap: 'off'
+    };
+    var fileMetadata = null;
+    var {
+      isPreview
+    } = props;
+    if (panelState != null) {
+      ({
+        fileMetadata = fileMetadata,
+        isPreview = isPreview,
+        settings = settings
+      } = panelState);
+    }
+
+    // Not showing the unsaved indicator for null file id and editor content === '',
+    // may need to implement some other indication that this notebook has never been saved
+    var hasFileId = fileMetadata != null && FileUtils.hasPath(fileMetadata.itemName);
+
+    // Unsaved if file id != null and content != null
+    // OR file id is null AND content is not null or ''
+    var isUnsaved = hasFileId === true && settings.value != null || !hasFileId && settings.value != null && settings.value.length > 0;
+    var changeCount = isUnsaved ? 1 : 0;
+    this.state = {
+      error: undefined,
+      isDashboardActive,
+      isFocused: false,
+      isLoading: true,
+      isLoaded: false,
+      isPreview,
+      savedChangeCount: 0,
+      changeCount,
+      fileMetadata,
+      settings,
+      session,
+      sessionLanguage,
+      // eslint-disable-next-line react/no-unused-state
+      panelState: {
+        fileMetadata,
+        settings
+      },
+      showCloseModal: false,
+      showSaveAsModal: false,
+      scriptCode: ''
+    };
+    log.debug('constructor', props, this.state);
+  }
+  componentDidMount() {
+    var {
+      glContainer,
+      glEventHub
+    } = this.props;
+    var {
+      tab
+    } = glContainer;
+    if (tab != null) this.initTab(tab);
+    this.initNotebookContent();
+    glEventHub.on(NotebookEvent.RENAME_FILE, this.handleRenameFile);
+    glEventHub.on(PanelEvent.DROPPED, this.handlePanelDropped);
+    glContainer.on(NotebookEvent.PROMOTE_FROM_PREVIEW, this.handlePreviewPromotion);
+  }
+  componentDidUpdate(prevProps, prevState) {
+    var {
+      isPreview,
+      settings
+    } = this.state;
+    var {
+      wordWrap
+    } = settings;
+    var {
+      defaultNotebookSettings
+    } = this.props;
+    if (isPreview !== prevState.isPreview) {
+      this.setPreviewStatus();
+    }
+    if (wordWrap !== prevState.settings.wordWrap) {
+      this.updateEditorWordWrap();
+      this.debouncedSavePanelState();
+    }
+    if (defaultNotebookSettings.isMinimapEnabled !== prevProps.defaultNotebookSettings.isMinimapEnabled) {
+      this.updateEditorMinimap();
+    }
+  }
+  componentWillUnmount() {
+    this.debouncedSavePanelState.flush();
+    this.pending.cancel();
+    var {
+      glEventHub,
+      glContainer
+    } = this.props;
+    var {
+      fileMetadata,
+      isPreview
+    } = this.state;
+    glEventHub.off(NotebookEvent.RENAME_FILE, this.handleRenameFile);
+    glEventHub.off(PanelEvent.DROPPED, this.handlePanelDropped);
+    glContainer.off(NotebookEvent.PROMOTE_FROM_PREVIEW, this.handlePreviewPromotion);
+    glEventHub.emit(NotebookEvent.UNREGISTER_FILE, fileMetadata, isPreview);
+  }
+  // Called by TabEvent. Happens once when created, but also each time its moved.
+  // when moved, need to re-init the unsaved indicators on title elements
+  initTab(tab) {
+    if (!this.tabInitOnce) {
+      this.tabInitOnce = true;
+      this.initTabCloseOverride();
+    }
+    this.initTabClasses(tab);
+  }
+
+  /**
+   * Adds a beforeClose handler to check if a notebook needs to be saved
+   * Call panel close with force if the check can be skipped
+   *
+   * Note that firing a close event manually may trigger before state update occurs
+   * In those instances, use force
+   */
+  initTabCloseOverride() {
+    var {
+      glContainer
+    } = this.props;
+    glContainer.beforeClose(options => {
+      if ((options === null || options === void 0 ? void 0 : options.force) === true) {
+        return true;
+      }
+      var {
+        changeCount,
+        savedChangeCount
+      } = this.state;
+      if (changeCount !== savedChangeCount) {
+        this.setState({
+          showCloseModal: true
+        });
+        return false;
+      }
+      return true;
+    });
+  }
+  initTabClasses(tab) {
+    var tabElement = tab.element.get(0);
+    assertNotNull(tabElement);
+    var titleElement = tabElement.querySelector('.lm_title');
+    this.tabTitleElement = titleElement;
+    titleElement === null || titleElement === void 0 ? void 0 : titleElement.classList.add('notebook-title');
+    this.setPreviewStatus();
+  }
+  getNotebookValue() {
+    var {
+      changeCount,
+      savedChangeCount,
+      settings
+    } = this.state;
+    var {
+      value
+    } = settings;
+    if (changeCount !== savedChangeCount && this.notebook) {
+      var notebookValue = this.notebook.getValue();
+      return notebookValue != null ? notebookValue : value;
+    }
+    return value;
+  }
+  initNotebookContent() {
+    // Init from file,
+    // fallback to content from settings for unsaved notebook
+    var {
+      fileMetadata,
+      settings,
+      isPreview
+    } = this.state;
+    if (fileMetadata && fileMetadata.id) {
+      log.debug('Init content from file');
+      this.registerFileMetadata(fileMetadata, isPreview);
+      this.load();
+      return;
+    }
+    if (settings.value != null) {
+      log.debug('Use content passed in the settings prop');
+      this.handleLoadSuccess();
+      return;
+    }
+    // No settings, no metadata
+    this.handleLoadError(new Error('Missing file metadata'));
+  }
+  closeFileTabById(id) {
+    var {
+      glEventHub
+    } = this.props;
+    glEventHub.emit(NotebookEvent.CLOSE_FILE, {
+      id
+    });
+  }
+
+  // Associate file id with the current tab
+  // so the next time the file is opened this tab can be focused instead of opening a new tab
+  registerFileMetadata(fileMetadata, isPreview) {
+    var {
+      glEventHub,
+      metadata
+    } = this.props;
+    var {
+      id: tabId
+    } = metadata;
+    glEventHub.emit(NotebookEvent.REGISTER_FILE, tabId, fileMetadata, isPreview);
+  }
+  renameTab(id, title) {
+    var {
+      glEventHub
+    } = this.props;
+    glEventHub.emit(NotebookEvent.RENAME, id, title);
+  }
+  load() {
+    var {
+      fileMetadata,
+      settings
+    } = this.state;
+    assertNotNull(fileMetadata);
+    var {
+      id
+    } = fileMetadata;
+    var {
+      fileStorage
+    } = this.props;
+    this.pending.add(fileStorage.loadFile(id)).then(loadedFile => {
+      var _NotebookPanel$langua;
+      log.debug('Loaded file', loadedFile);
+      var {
+        filename: itemName
+      } = loadedFile;
+      var {
+        itemName: prevItemName
+      } = this.state;
+      if (itemName !== prevItemName) {
+        var {
+          metadata
+        } = this.props;
+        var {
+          id: tabId
+        } = metadata;
+        this.renameTab(tabId, FileUtils.getBaseName(itemName));
+      }
+      var updatedSettings = _objectSpread(_objectSpread({}, settings), {}, {
+        language: (_NotebookPanel$langua = NotebookPanel.languageFromFileName(itemName)) !== null && _NotebookPanel$langua !== void 0 ? _NotebookPanel$langua : ''
+      });
+      if (settings.value == null) {
+        updatedSettings.value = loadedFile.content;
+      }
+      if (settings.wordWrap === undefined) {
+        settings.wordWrap = 'off';
+      }
+      this.setState({
+        fileMetadata: {
+          id: itemName,
+          itemName
+        },
+        settings: updatedSettings
+      });
+      this.debouncedSavePanelState();
+    }).then(this.handleLoadSuccess).catch(this.handleLoadError);
+  }
+
+  /**
+   * Attempts to save the notebook.
+   * @returns Returns true if save has begun, false if user needed to be prompted
+   */
+  save() {
+    var {
+      fileMetadata
+    } = this.state;
+    if (fileMetadata && FileUtils.hasPath(fileMetadata.itemName)) {
+      var content = this.getNotebookValue();
+      if (content !== undefined) {
+        this.saveContent(fileMetadata.itemName, content);
+        return true;
+      }
+      return false;
+    }
+    this.setState({
+      showSaveAsModal: true
+    });
+    return false;
+  }
+
+  /**
+   * Update existing file content
+   * @param filename The name of the file
+   * @param content New file content
+   */
+  saveContent(filename, content) {
+    log.debug('saveContent', filename, content);
+    this.updateSavedChangeCount();
+    var {
+      fileStorage
+    } = this.props;
+    this.pending.add(fileStorage.saveFile({
+      filename,
+      content,
+      basename: filename
+    })).then(this.handleSaveSuccess).catch(this.handleSaveError);
+  }
+  updateSavedChangeCount() {
+    this.setState(_ref => {
+      var {
+        changeCount
+      } = _ref;
+      return {
+        savedChangeCount: changeCount
+      };
+    });
+  }
+  setPreviewStatus() {
+    if (!this.tabTitleElement) {
+      return;
+    }
+    var {
+      isPreview
+    } = this.state;
+    log.debug('setPreviewStatus', this.tabTitleElement, isPreview);
+    if (isPreview) {
+      this.tabTitleElement.classList.add('is-preview');
+    } else {
+      this.tabTitleElement.classList.remove('is-preview');
+    }
+  }
+  handlePreviewPromotion() {
+    this.removePreviewStatus();
+  }
+  savePanelState() {
+    this.setState(state => {
+      var {
+        changeCount,
+        savedChangeCount,
+        fileMetadata,
+        isPreview,
+        settings: initialSettings
+      } = state;
+      var value = this.getNotebookValue();
+      // notebooks with no unsaved changes have value === null in dehydrated state
+      // content will be loaded from file when hydrating
+      var dehydratedValue = changeCount !== savedChangeCount ? value : undefined;
+      var settings = _objectSpread(_objectSpread({}, initialSettings), {}, {
+        value
+      });
+      var dehydratedSettings = _objectSpread(_objectSpread({}, initialSettings), {}, {
+        value: dehydratedValue
+      });
+      var panelState = {
+        settings: dehydratedSettings,
+        fileMetadata,
+        isPreview
+      };
+      log.debug('Saving panel state', panelState);
+      return {
+        settings,
+        // eslint-disable-next-line react/no-unused-state
+        panelState
+      };
+    });
+  }
+  handleCloseDiscard() {
+    this.setState({
+      showCloseModal: false
+    });
+    var {
+      glContainer
+    } = this.props;
+    glContainer.close({
+      force: true
+    });
+  }
+  handleCloseSave() {
+    this.setState({
+      showCloseModal: false
+    });
+    if (this.save()) {
+      var {
+        glContainer
+      } = this.props;
+      glContainer.close({
+        force: true
+      });
+    }
+  }
+  handleCloseCancel() {
+    this.setState({
+      showCloseModal: false
+    });
+  }
+
+  /**
+   * Closes overwritten tabs
+   * @param fileName The name of the file to be overwritten
+   */
+  handleOverwrite(fileName) {
+    var {
+      glEventHub
+    } = this.props;
+    glEventHub.emit(NotebookEvent.CLOSE_FILE, {
+      id: fileName,
+      itemName: fileName
+    }, {
+      force: true
+    });
+    this.focus();
+  }
+  handleCopy() {
+    var {
+      fileMetadata,
+      settings
+    } = this.state;
+    assertNotNull(fileMetadata);
+    var content = this.getNotebookValue();
+    var {
+      language
+    } = settings;
+    var {
+      itemName
+    } = fileMetadata;
+    var copyName = FileUtils.getCopyFileName(itemName);
+    log.debug('handleCopy', fileMetadata, itemName, copyName);
+    this.createNotebook(copyName, language, content);
+  }
+  handleEditorInitialized(innerEditor) {
+    this.editor = innerEditor;
+  }
+  handleEditorWillDestroy() {
+    this.editor = undefined;
+  }
+  handleEditorChange(e) {
+    log.debug2('handleEditorChanged', e);
+    this.removePreviewStatus();
+    this.setState(state => {
+      var {
+        changeCount,
+        savedChangeCount
+      } = state;
+      var {
+        isUndoing,
+        isRedoing
+      } = e;
+      if (isUndoing) {
+        // Note that it's possible to undo past where the user last saved, if they save and then undo for example
+        return {
+          changeCount: changeCount - 1,
+          savedChangeCount
+        };
+      }
+      if (!isRedoing && changeCount < savedChangeCount) {
+        // We made another change after undoing some changes from the previous save
+        // Just reset the saved counter to zero and increase the unchanged saves
+        // It'll be set correctly on the next save
+        return {
+          changeCount: changeCount + 1,
+          savedChangeCount: 0
+        };
+      }
+      return {
+        changeCount: changeCount + 1,
+        savedChangeCount
+      };
+    });
+    this.debouncedSavePanelState();
+  }
+  handleFind() {
+    if (this.notebook) {
+      this.notebook.toggleFind();
+    }
+  }
+  updateEditorMinimap() {
+    if (this.editor) {
+      var {
+        defaultNotebookSettings
+      } = this.props;
+      this.editor.updateOptions({
+        minimap: {
+          enabled: defaultNotebookSettings.isMinimapEnabled
+        }
+      });
+    }
+  }
+  handleMinimapChange() {
+    var {
+      settings,
+      defaultNotebookSettings,
+      saveSettings
+    } = this.props;
+    var newSettings = _objectSpread(_objectSpread({}, settings), {}, {
+      defaultNotebookSettings: {
+        isMinimapEnabled: !defaultNotebookSettings.isMinimapEnabled
+      }
+    });
+    saveSettings(newSettings);
+  }
+  updateEditorWordWrap() {
+    if (this.editor) {
+      var {
+        settings: _settings
+      } = this.state;
+      var {
+        wordWrap
+      } = _settings;
+      this.editor.updateOptions({
+        wordWrap
+      });
+    }
+  }
+  handleWordWrapChange() {
+    if (this.editor) {
+      this.setState(prevState => {
+        var {
+          settings
+        } = prevState;
+        var wordWrap = settings.wordWrap === 'on' ? 'off' : 'on';
+        return {
+          settings: _objectSpread(_objectSpread({}, settings), {}, {
+            wordWrap
+          })
+        };
+      });
+    }
+  }
+  handleBlur() {
+    log.debug('handleBlur');
+    this.setState({
+      isFocused: false
+    });
+  }
+  handleFocus() {
+    log.debug('handleFocus');
+    this.setState({
+      isFocused: true
+    });
+  }
+
+  /**
+   * @param event The click event from clicking on the link
+   */
+  handleLinkClick(event) {
+    var {
+      notebooksUrl,
+      session,
+      sessionLanguage
+    } = this.props;
+    var {
+      href
+    } = event.currentTarget;
+    if (!href || !href.startsWith(notebooksUrl)) {
+      return;
+    }
+    event.stopPropagation();
+    event.preventDefault();
+    var notebookPath = "/".concat(href.substring(notebooksUrl.length)).replace(/%20/g, ' ');
+    if (notebookPath === '/') {
+      log.debug('Ignoring invalid notebook link', notebookPath);
+      return;
+    }
+    log.debug('Notebook link clicked, opening', notebookPath);
+    var {
+      glEventHub
+    } = this.props;
+    var notebookSettings = {
+      value: null,
+      language: sessionLanguage
+    };
+    var fileMetadata = {
+      id: notebookPath,
+      itemName: notebookPath
+    };
+    glEventHub.emit(NotebookEvent.SELECT_NOTEBOOK, session, sessionLanguage, notebookSettings, fileMetadata);
+  }
+  handleLoadSuccess() {
+    this.setState({
+      error: undefined,
+      isLoaded: true,
+      isLoading: false
+    });
+  }
+  handleLoadError(errorParam) {
+    var error = errorParam;
+    if (PromiseUtils.isCanceled(error)) {
+      return;
+    }
+    if (PromiseUtils.isTimedOut(error)) {
+      error = new Error('File not found.');
+    }
+    log.error(error);
+    this.setState({
+      error,
+      isLoading: false
+    });
+  }
+  handleSave() {
+    log.debug('handleSave');
+    this.save();
+  }
+  handleSaveSuccess(file) {
+    var _NotebookPanel$langua2;
+    var {
+      fileStorage
+    } = this.props;
+    var fileMetadata = {
+      id: file.filename,
+      itemName: file.filename
+    };
+    var language = (_NotebookPanel$langua2 = NotebookPanel.languageFromFileName(file.filename)) !== null && _NotebookPanel$langua2 !== void 0 ? _NotebookPanel$langua2 : '';
+    this.setState(state => {
+      var {
+        fileMetadata: oldMetadata
+      } = state;
+      var settings = _objectSpread(_objectSpread({}, state.settings), {}, {
+        language
+      });
+      log.debug('handleSaveSuccess', fileMetadata, oldMetadata, settings);
+      if (oldMetadata && FileUtils.hasPath(oldMetadata.itemName) && oldMetadata.itemName !== fileMetadata.itemName) {
+        log.debug('handleSaveSuccess deleting old file', oldMetadata.itemName);
+        fileStorage.deleteFile(oldMetadata.itemName).catch(NotebookPanel.handleError);
+      }
+      return {
+        fileMetadata,
+        settings,
+        isPreview: false
+      };
+    });
+    this.debouncedSavePanelState();
+    this.registerFileMetadata(fileMetadata, false);
+  }
+  handleSaveError(error) {
+    if (PromiseUtils.isCanceled(error)) {
+      return;
+    }
+    // There was an error saving, just reset the savedChangeCount
+    // It's possible if they undo changes they'll be back at the spot where it was last saved successfully,
+    // But we may as well continue showing the error until they actually save again
+    this.setState({
+      savedChangeCount: 0
+    });
+    log.error(error);
+  }
+  handleSaveAsCancel() {
+    this.setState({
+      showSaveAsModal: false
+    });
+  }
+  handleSaveAsSubmit(name) {
+    var _this$getNotebookValu;
+    var isOverwrite = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    if (isOverwrite) {
+      this.handleOverwrite(name);
+    }
+    log.debug('handleSaveAsSubmit', name);
+    var {
+      fileMetadata
+    } = this.state;
+    if (!fileMetadata) {
+      return;
+    }
+    var {
+      itemName: prevItemName
+    } = fileMetadata;
+    var content = (_this$getNotebookValu = this.getNotebookValue()) !== null && _this$getNotebookValu !== void 0 ? _this$getNotebookValu : '';
+    this.setState({
+      showSaveAsModal: false
+    });
+    if (FileUtils.getBaseName(prevItemName) !== FileUtils.getBaseName(name)) {
+      var {
+        metadata
+      } = this.props;
+      var {
+        id: tabId
+      } = metadata;
+      this.renameTab(tabId, FileUtils.getBaseName(name));
+    }
+    this.saveContent(name, content);
+  }
+  handleRenameFile(oldName, newName, panelState) {
+    var {
+      fileMetadata,
+      panelState: curPanelState
+    } = this.state;
+    var {
+      glContainer
+    } = this.props;
+    if ((fileMetadata === null || fileMetadata === void 0 ? void 0 : fileMetadata.itemName) === "/".concat(newName) && panelState && JSON.stringify(curPanelState) !== JSON.stringify(panelState)) {
+      glContainer.close();
+      return;
+    }
+    if (fileMetadata && fileMetadata.id === oldName) {
+      this.setState({
+        fileMetadata: {
+          id: newName,
+          itemName: newName
+        }
+      });
+      this.debouncedSavePanelState();
+    }
+  }
+  handleResize() {
+    var _this$notebook;
+    (_this$notebook = this.notebook) === null || _this$notebook === void 0 ? void 0 : _this$notebook.updateDimensions();
+  }
+  handleRunCommand(command) {
+    this.runCommand(command);
+  }
+  handleRunAll() {
+    var _this$notebook$getVal;
+    if (!this.notebook) {
+      log.error('Editor is not initialized.');
+      return;
+    }
+    this.runCommand((_this$notebook$getVal = this.notebook.getValue()) !== null && _this$notebook$getVal !== void 0 ? _this$notebook$getVal : undefined);
+  }
+  handleRunSelected() {
+    if (!this.notebook) {
+      log.error('Editor is not initialized.');
+      return;
+    }
+    this.runCommand(this.notebook.getSelectedCommand());
+  }
+  handleSessionOpened(session, _ref2) {
+    var {
+      language
+    } = _ref2;
+    this.setState({
+      session,
+      sessionLanguage: language
+    });
+  }
+  handleSessionClosed() {
+    this.setState({
+      session: undefined,
+      sessionLanguage: undefined
+    });
+  }
+  handleShow() {
+    var _this$notebook2;
+    log.debug('handleShow');
+    (_this$notebook2 = this.notebook) === null || _this$notebook2 === void 0 ? void 0 : _this$notebook2.updateDimensions();
+  }
+  handlePanelDropped(droppedId) {
+    var {
+      metadata: {
+        id
+      }
+    } = this.props;
+    // re-render necessary for portal after being dropped
+    if (droppedId === id) this.forceUpdate();
+  }
+  handleShowRename() {
+    this.setState({
+      showSaveAsModal: true
+    });
+  }
+  handleTab(tab) {
+    log.debug('NotebookPanel tab event', tab);
+    this.initTab(tab);
+  }
+  handleTabFocus() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    log.debug('handleTabFocus', ...args);
+    var {
+      glContainer
+    } = this.props;
+    this.setState({
+      isDashboardActive: true
+    });
+    if (this.notebook && !glContainer.isHidden) {
+      this.notebook.updateDimensions();
+    }
+  }
+  handleTabBlur() {
+    log.debug('handleTabBlur');
+    this.setState({
+      isDashboardActive: false
+    });
+  }
+  handleTabClick(e) {
+    log.debug('handle NotebookPanel tab click');
+    this.focus();
+    if (e.detail === 2) {
+      this.removePreviewStatus();
+    }
+  }
+
+  /**
+   * Transform the link URI to load from where the notebook is if it's relative
+   * @param src The link to transform
+   * @returns String the transformed link
+   */
+  handleTransformLinkUri(src) {
+    var {
+      notebooksUrl
+    } = this.props;
+    var {
+      fileMetadata
+    } = this.state;
+    if (src.endsWith('/')) {
+      return src;
+    }
+    if (src.startsWith('/')) {
+      return "".concat(notebooksUrl).concat(src.substring(1));
+    }
+    var itemName = fileMetadata === null || fileMetadata === void 0 ? void 0 : fileMetadata.itemName;
+    if (itemName === undefined) {
+      return src;
+    }
+    if (itemName.charAt(0) === '/') {
+      itemName = itemName.substring(1);
+    }
+    var itemUri = new URL(itemName, notebooksUrl);
+    return new URL(src, itemUri).href;
+  }
+  focus() {
+    requestAnimationFrame(() => {
+      if (this.notebook) {
+        this.notebook.focus();
+      }
+    });
+  }
+  createNotebook(itemName, language) {
+    var content = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+    var {
+      glEventHub
+    } = this.props;
+    var {
+      session,
+      sessionLanguage,
+      settings
+    } = this.state;
+    var notebookSettings = _objectSpread(_objectSpread({}, settings), {}, {
+      language,
+      value: content
+    });
+    var fileMetadata = {
+      id: null,
+      itemName
+    };
+    log.debug('handleCreateNotebook', session, sessionLanguage, notebookSettings, fileMetadata);
+    glEventHub.emit(NotebookEvent.CREATE_NOTEBOOK, session, sessionLanguage, notebookSettings, fileMetadata);
+  }
+  runCommand(command) {
+    if (command === undefined || command === '') {
+      log.debug('Ignoring empty command.');
+      return;
+    }
+    this.removePreviewStatus();
+    var {
+      glEventHub
+    } = this.props;
+    glEventHub.emit(ConsoleEvent.SEND_COMMAND, command, false, true);
+  }
+  removePreviewStatus() {
+    this.setState(_ref3 => {
+      var {
+        isPreview
+      } = _ref3;
+      if (isPreview) {
+        var {
+          fileMetadata
+        } = this.state;
+        if (fileMetadata) {
+          this.registerFileMetadata(fileMetadata, false);
+        }
+        return {
+          isPreview: false
+        };
+      }
+      return null;
+    });
+  }
+  getDropdownOverflowActions() {
+    var {
+      defaultNotebookSettings
+    } = this.props;
+    var {
+      settings: initialSettings
+    } = this.state;
+    return this.getOverflowActions(defaultNotebookSettings.isMinimapEnabled, this.getSettings(initialSettings, defaultNotebookSettings.isMinimapEnabled).wordWrap === 'on');
+  }
+  render() {
+    var _fileMetadata$itemNam, _settings$value;
+    var {
+      fileStorage,
+      glContainer,
+      glContainer: {
+        tab
+      },
+      glEventHub,
+      defaultNotebookSettings
+    } = this.props;
+    var {
+      changeCount,
+      savedChangeCount,
+      error,
+      isDashboardActive,
+      isLoaded,
+      isLoading,
+      isPreview,
+      fileMetadata,
+      session,
+      sessionLanguage,
+      settings: initialSettings,
+      showCloseModal,
+      showSaveAsModal
+    } = this.state;
+    // We don't want to steal focus if this isn't shown or it's just a preview
+    var focusOnMount = isDashboardActive && !glContainer.isHidden && !isPreview;
+    var itemName = (_fileMetadata$itemNam = fileMetadata === null || fileMetadata === void 0 ? void 0 : fileMetadata.itemName) !== null && _fileMetadata$itemNam !== void 0 ? _fileMetadata$itemNam : NotebookPanel.DEFAULT_NAME;
+    var isMarkdown = itemName.endsWith('.md');
+    var isExistingItem = (fileMetadata === null || fileMetadata === void 0 ? void 0 : fileMetadata.id) != null;
+    var settings = this.getSettings(initialSettings, defaultNotebookSettings.isMinimapEnabled);
+    var isSessionConnected = session != null;
+    var isLanguageMatching = sessionLanguage === settings.language;
+    var runButtonsDisabled = !isLoaded || !isSessionConnected || !isLanguageMatching;
+    var toolbarDisabled = !isLoaded;
+    var contextActions = [{
+      action: this.handleSave,
+      shortcut: GLOBAL_SHORTCUTS.SAVE
+    }, {
+      action: this.handleMinimapChange,
+      shortcut: SHORTCUTS.NOTEBOOK.MINIMAP
+    }, {
+      action: this.handleWordWrapChange,
+      shortcut: SHORTCUTS.NOTEBOOK.WORDWRAP
+    }];
+    var disabledRunButtonTooltip = ScriptEditorUtils.getDisabledRunTooltip(isSessionConnected, isLanguageMatching, 'Notebook extension', 'Run');
+    var disabledRunSelectedButtonTooltip = ScriptEditorUtils.getDisabledRunTooltip(isSessionConnected, isLanguageMatching, 'Notebook extension', 'Run Selected');
+    var additionalActions = [{
+      title: isExistingItem ? 'Rename' : 'Save As…',
+      order: 10,
+      group: ContextActions.groups.high,
+      action: this.handleShowRename
+    }, {
+      title: 'Copy File',
+      action: this.handleCopy,
+      group: ContextActions.groups.high,
+      order: 20
+    }];
+    var portal = tab === null || tab === void 0 ? void 0 : tab.element.find('.lm_title_before').get(0);
+    return /*#__PURE__*/React.createElement(React.Fragment, null, portal && /*#__PURE__*/ReactDOM.createPortal( /*#__PURE__*/React.createElement("span", {
+      className: classNames('editor-unsaved-indicator', {
+        'is-unsaved': changeCount !== savedChangeCount
+      })
+    }), portal // tab.element is jquery element, we want a dom element
+    ), /*#__PURE__*/React.createElement(Panel, {
+      className: "notebook-container",
+      componentPanel: this,
+      glContainer: glContainer,
+      glEventHub: glEventHub,
+      onTab: this.handleTab,
+      onResize: this.handleResize,
+      onShow: this.handleShow,
+      onTabClicked: this.handleTabClick,
+      onTabFocus: this.handleTabFocus,
+      onTabBlur: this.handleTabBlur,
+      onSessionOpen: this.handleSessionOpened,
+      onSessionClose: this.handleSessionClosed,
+      onFocus: this.handleFocus,
+      onBlur: this.handleBlur,
+      additionalActions: additionalActions,
+      renderTabTooltip: () => itemName
+    }, !isMarkdown && /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("div", {
+      className: "notebook-toolbar"
+    }, /*#__PURE__*/React.createElement("span", null, /*#__PURE__*/React.createElement(Button, {
+      kind: "ghost",
+      className: "btn-play",
+      onClick: this.handleRunAll,
+      disabled: runButtonsDisabled,
+      icon: /*#__PURE__*/React.createElement(FontAwesomeIcon, {
+        icon: vsPlay,
+        transform: "grow-4"
+      }),
+      tooltip: "Run ".concat(SHORTCUTS.NOTEBOOK.RUN.getDisplayText()),
+      "aria-label": "Run"
+    }), disabledRunButtonTooltip != null && /*#__PURE__*/React.createElement(Tooltip, null, disabledRunButtonTooltip)), /*#__PURE__*/React.createElement("span", null, /*#__PURE__*/React.createElement(Button, {
+      kind: "ghost",
+      className: "btn-play",
+      onClick: this.handleRunSelected,
+      disabled: runButtonsDisabled,
+      icon: /*#__PURE__*/React.createElement(FontAwesomeIcon, {
+        icon: dhRunSelection,
+        transform: "grow-4"
+      }),
+      tooltip: "Run Selected ".concat(SHORTCUTS.NOTEBOOK.RUN_SELECTED.getDisplayText()),
+      "aria-label": "Run Selected"
+    }), disabledRunSelectedButtonTooltip != null && /*#__PURE__*/React.createElement(Tooltip, null, disabledRunSelectedButtonTooltip)), /*#__PURE__*/React.createElement(Button, {
+      kind: "ghost",
+      className: "mr-auto",
+      disabled: toolbarDisabled,
+      onClick: this.handleSave,
+      icon: vsSave,
+      tooltip: "Save ".concat(GLOBAL_SHORTCUTS.SAVE.getDisplayText()),
+      "aria-label": "Save"
+    }), /*#__PURE__*/React.createElement(Button, {
+      kind: "ghost",
+      className: "btn-overflow btn-link-icon",
+      disabled: toolbarDisabled,
+      icon: vsKebabVertical,
+      tooltip: "More Actions...",
+      onClick: () => {
+        // no-op: click is handled in `DropdownMenu`
+      }
+    }, /*#__PURE__*/React.createElement(DropdownMenu, {
+      actions: this.getDropdownOverflowActions,
+      popperOptions: NotebookPanel.POPPER_OPTIONS
+    }))), /*#__PURE__*/React.createElement(ScriptEditor, {
+      isLoaded: isLoaded,
+      isLoading: isLoading,
+      error: error,
+      onChange: this.handleEditorChange,
+      onRunCommand: this.handleRunCommand,
+      session: session,
+      sessionLanguage: sessionLanguage,
+      onEditorInitialized: this.handleEditorInitialized,
+      onEditorWillDestroy: this.handleEditorWillDestroy,
+      settings: settings,
+      focusOnMount: focusOnMount,
+      ref: notebook => {
+        this.notebook = notebook;
+      }
+    })), isMarkdown && /*#__PURE__*/React.createElement(MarkdownNotebook, {
+      content: (_settings$value = settings.value) !== null && _settings$value !== void 0 ? _settings$value : '',
+      onLinkClick: this.handleLinkClick,
+      onRunCode: this.handleRunCommand,
+      transformImageUri: this.handleTransformLinkUri,
+      transformLinkUri: this.handleTransformLinkUri
+    }), /*#__PURE__*/React.createElement(NewItemModal, {
+      isOpen: showSaveAsModal,
+      type: "file",
+      defaultValue: itemName,
+      title: isExistingItem ? 'Rename' : 'Save file as',
+      onSubmit: this.handleSaveAsSubmit,
+      onCancel: this.handleSaveAsCancel,
+      notifyOnExtensionChange: true,
+      storage: fileStorage
+    }), /*#__PURE__*/React.createElement(BasicModal, {
+      isOpen: showCloseModal,
+      headerText: "Do you want to save the changes you made to ".concat(itemName, "?"),
+      bodyText: "Your changes will be lost if you don't save them.",
+      onCancel: this.handleCloseCancel,
+      onDiscard: this.handleCloseDiscard,
+      onConfirm: this.handleCloseSave,
+      discardButtonText: "Discard Changes",
+      confirmButtonText: "Save"
+    }), /*#__PURE__*/React.createElement(ContextActions, {
+      actions: contextActions
+    })));
+  }
+}
+_defineProperty(NotebookPanel, "COMPONENT", 'NotebookPanel');
+_defineProperty(NotebookPanel, "POPPER_OPTIONS", {
+  placement: 'bottom-end'
+});
+_defineProperty(NotebookPanel, "DEFAULT_NAME", 'Untitled');
+_defineProperty(NotebookPanel, "defaultProps", {
+  isDashboardActive: true,
+  isPreview: false,
+  session: null,
+  sessionLanguage: null,
+  defaultNotebookSettings: null
+});
+var mapStateToProps = (state, ownProps) => {
+  var fileStorage = getFileStorage(state);
+  var settings = getSettings(state);
+  var defaultNotebookSettings = getDefaultNotebookSettings(state);
+  var sessionWrapper = getDashboardSessionWrapper(state, ownProps.localDashboardId);
+  var {
+    session,
+    config: sessionConfig
+  } = sessionWrapper !== null && sessionWrapper !== void 0 ? sessionWrapper : {};
+  var {
+    type: sessionLanguage
+  } = sessionConfig !== null && sessionConfig !== void 0 ? sessionConfig : {};
+  return {
+    fileStorage,
+    settings,
+    defaultNotebookSettings,
+    session,
+    sessionLanguage
+  };
+};
+var ConnectedNotebookPanel = connect(mapStateToProps, {
+  saveSettings: saveSettingsAction
+}, null, {
+  forwardRef: true
+})(NotebookPanel);
+export default ConnectedNotebookPanel;
+//# sourceMappingURL=NotebookPanel.js.map