@theia/notebook 1.53.0-next.5 → 1.53.0

package/src/browser/contributions/notebook-cell-actions-contribution.ts

@@ -39,11 +39,13 @@ export namespace NotebookCellCommands {
     /** Parameters: notebookModel: NotebookModel | undefined, cell: NotebookCellModel */
     export const EDIT_COMMAND = Command.toDefaultLocalizedCommand({
         id: 'notebook.cell.edit',
+        category: 'Notebook',
         iconClass: codicon('edit')
     });
     /** Parameters: notebookModel: NotebookModel | undefined, cell: NotebookCellModel */
     export const STOP_EDIT_COMMAND = Command.toDefaultLocalizedCommand({
         id: 'notebook.cell.stop-edit',
+        category: 'Notebook',
         iconClass: codicon('check')
     });
     /** Parameters: notebookModel: NotebookModel, cell: NotebookCellModel */
@@ -59,11 +61,21 @@ export namespace NotebookCellCommands {
     /** Parameters: notebookModel: NotebookModel, cell: NotebookCellModel */
     export const EXECUTE_SINGLE_CELL_COMMAND = Command.toDefaultLocalizedCommand({
         id: 'notebook.cell.execute-cell',
+        category: 'Notebook',
+        label: nls.localizeByDefault('Execute Cell'),
         iconClass: codicon('play'),
     });
     /** Parameters: notebookModel: NotebookModel, cell: NotebookCellModel */
     export const EXECUTE_SINGLE_CELL_AND_FOCUS_NEXT_COMMAND = Command.toDefaultLocalizedCommand({
         id: 'notebook.cell.execute-cell-and-focus-next',
+        label: nls.localizeByDefault('Execute Notebook Cell and Select Below'),
+        category: 'Notebook',
+    });
+    /** Parameters: notebookModel: NotebookModel, cell: NotebookCellModel */
+    export const EXECUTE_SINGLE_CELL_AND_INSERT_BELOW_COMMAND = Command.toDefaultLocalizedCommand({
+        id: 'notebook.cell.execute-cell-and-insert-below',
+        label: nls.localizeByDefault('Execute Notebook Cell and Insert Below'),
+        category: 'Notebook',
     });
 
     export const EXECUTE_ABOVE_CELLS_COMMAND = Command.toDefaultLocalizedCommand({
@@ -85,11 +97,13 @@ export namespace NotebookCellCommands {
     /** Parameters: notebookModel: NotebookModel | undefined, cell: NotebookCellModel */
     export const CLEAR_OUTPUTS_COMMAND = Command.toDefaultLocalizedCommand({
         id: 'notebook.cell.clear-outputs',
+        category: 'Notebook',
         label: 'Clear Cell Outputs',
     });
     /** Parameters: notebookModel: NotebookModel | undefined, cell: NotebookCellModel | undefined, output: NotebookCellOutputModel */
     export const CHANGE_OUTPUT_PRESENTATION_COMMAND = Command.toDefaultLocalizedCommand({
         id: 'notebook.cell.change-presentation',
+        category: 'Notebook',
         label: 'Change Presentation',
     });
 
@@ -114,11 +128,13 @@ export namespace NotebookCellCommands {
 
     export const TO_CODE_CELL_COMMAND = Command.toLocalizedCommand({
         id: 'notebook.cell.changeToCode',
+        category: 'Notebook',
         label: 'Change Cell to Code'
     });
 
     export const TO_MARKDOWN_CELL_COMMAND = Command.toLocalizedCommand({
         id: 'notebook.cell.changeToMarkdown',
+        category: 'Notebook',
         label: 'Change Cell to Markdown'
     });
 
@@ -302,6 +318,23 @@ export class NotebookCellActionContribution implements MenuContribution, Command
                 }
             })
         );
+        commands.registerCommand(NotebookCellCommands.EXECUTE_SINGLE_CELL_AND_INSERT_BELOW_COMMAND, this.editableCellCommandHandler(
+            async (notebookModel, cell) => {
+                if (cell.cellKind === CellKind.Code) {
+                    await commands.executeCommand(NotebookCellCommands.EXECUTE_SINGLE_CELL_COMMAND.id, notebookModel, cell);
+                }
+                await commands.executeCommand(NotebookCellCommands.STOP_EDIT_COMMAND.id, notebookModel, cell);
+
+                if (cell.cellKind === CellKind.Code) {
+                    await commands.executeCommand(NotebookCellCommands.INSERT_NEW_CELL_BELOW_COMMAND.id);
+                } else {
+                    await commands.executeCommand(NotebookCellCommands.INSERT_MARKDOWN_CELL_BELOW_COMMAND.id);
+                }
+
+                const index = notebookModel.cells.indexOf(cell);
+                notebookModel.setSelectedCell(notebookModel.cells[index + 1]);
+            })
+        );
 
         commands.registerCommand(NotebookCellCommands.EXECUTE_ABOVE_CELLS_COMMAND, this.editableCellCommandHandler(
             (notebookModel, cell) => {
@@ -432,8 +465,8 @@ export class NotebookCellActionContribution implements MenuContribution, Command
             },
             {
                 command: NotebookCellCommands.STOP_EDIT_COMMAND.id,
-                keybinding: KeyCode.createKeyCode({ first: Key.ENTER, modifiers: [KeyModifier.Alt] }).toString(),
-                when: `editorTextFocus && !inputFocus && ${NOTEBOOK_EDITOR_FOCUSED}`,
+                keybinding: KeyCode.createKeyCode({ first: Key.ENTER, modifiers: [KeyModifier.Alt, KeyModifier.CtrlCmd] }).toString(),
+                when: `editorTextFocus && ${NOTEBOOK_EDITOR_FOCUSED} && ${NOTEBOOK_CELL_TYPE} == 'markdown'`,
             },
             {
                 command: NotebookCellCommands.STOP_EDIT_COMMAND.id,
@@ -450,6 +483,11 @@ export class NotebookCellActionContribution implements MenuContribution, Command
                 keybinding: KeyCode.createKeyCode({ first: Key.ENTER, modifiers: [KeyModifier.Shift] }).toString(),
                 when: `${NOTEBOOK_CELL_LIST_FOCUSED} && ${NOTEBOOK_EDITOR_FOCUSED} && ${NOTEBOOK_CELL_FOCUSED}`,
             },
+            {
+                command: NotebookCellCommands.EXECUTE_SINGLE_CELL_AND_INSERT_BELOW_COMMAND.id,
+                keybinding: KeyCode.createKeyCode({ first: Key.ENTER, modifiers: [KeyModifier.Alt] }).toString(),
+                when: `${NOTEBOOK_CELL_LIST_FOCUSED} && ${NOTEBOOK_EDITOR_FOCUSED} && ${NOTEBOOK_CELL_FOCUSED}`,
+            },
             {
                 command: NotebookCellCommands.CLEAR_OUTPUTS_COMMAND.id,
                 keybinding: KeyCode.createKeyCode({ first: Key.KEY_O, modifiers: [KeyModifier.Alt] }).toString(),

package/src/browser/contributions/notebook-status-bar-contribution.ts

@@ -0,0 +1,77 @@
+// *****************************************************************************
+// Copyright (C) 2024 TypeFox and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { FrontendApplicationContribution, StatusBar, StatusBarAlignment } from '@theia/core/lib/browser';
+import { Disposable } from '@theia/core/lib/common';
+import { NotebookEditorWidgetService } from '../service/notebook-editor-widget-service';
+import { NotebookEditorWidget } from '../notebook-editor-widget';
+import { nls } from '@theia/core';
+import { NotebookCommands } from './notebook-actions-contribution';
+
+export const NOTEBOOK_CELL_SELECTION_STATUS_BAR_ID = 'notebook-cell-selection-position';
+
+@injectable()
+export class NotebookStatusBarContribution implements FrontendApplicationContribution {
+
+    @inject(StatusBar) protected readonly statusBar: StatusBar;
+    @inject(NotebookEditorWidgetService) protected readonly editorWidgetService: NotebookEditorWidgetService;
+
+    protected currentCellSelectionListener: Disposable | undefined;
+    protected lastFocusedEditor: NotebookEditorWidget | undefined;
+
+    onStart(): void {
+        this.editorWidgetService.onDidChangeFocusedEditor(editor => {
+            this.currentCellSelectionListener?.dispose();
+            this.currentCellSelectionListener = editor?.model?.onDidChangeSelectedCell(() =>
+                this.updateStatusbar(editor)
+            );
+            editor?.onDidDispose(() => {
+                this.lastFocusedEditor = undefined;
+                this.updateStatusbar();
+            });
+            this.updateStatusbar(editor);
+            this.lastFocusedEditor = editor;
+        });
+        if (this.editorWidgetService.focusedEditor) {
+            this.updateStatusbar();
+        }
+    }
+
+    protected async updateStatusbar(editor?: NotebookEditorWidget): Promise<void> {
+        if ((!editor && !this.lastFocusedEditor?.isVisible) || editor?.model?.cells.length === 0) {
+            this.statusBar.removeElement(NOTEBOOK_CELL_SELECTION_STATUS_BAR_ID);
+            return;
+        }
+
+        await editor?.ready;
+        if (!editor?.model) {
+            return;
+        }
+
+        const selectedCellIndex = editor.model.selectedCell ? editor.model.cells.indexOf(editor.model.selectedCell) + 1 : '';
+
+        this.statusBar.setElement(NOTEBOOK_CELL_SELECTION_STATUS_BAR_ID, {
+            text: nls.localizeByDefault('Cell {0} of {1}', selectedCellIndex, editor.model.cells.length),
+            alignment: StatusBarAlignment.RIGHT,
+            priority: 100,
+            command: NotebookCommands.CENTER_ACTIVE_CELL.id,
+            arguments: [editor]
+        });
+
+    }
+
+}

package/src/browser/notebook-editor-widget.tsx

@@ -154,7 +154,6 @@ export class NotebookEditorWidget extends ReactWidget implements Navigatable, Sa
     @postConstruct()
     protected init(): void {
         this.id = NOTEBOOK_EDITOR_ID_PREFIX + this.props.uri.toString();
-        this.node.tabIndex = -1;
 
         this.scrollOptions = {
             suppressScrollY: true
@@ -174,8 +173,6 @@ export class NotebookEditorWidget extends ReactWidget implements Navigatable, Sa
                 this.commandRegistry.executeCommand(NotebookCellCommands.EDIT_COMMAND.id, model, model.cells[0]);
                 model.setSelectedCell(model.cells[0]);
             }
-            model.cells.forEach(cell => cell.onWillBlurCellEditor(() => this.node.focus()));
-            model.onDidAddOrRemoveCell(e => e.newCellIds?.forEach(cellId => model.cells.find(cell => cell.handle === cellId)?.onWillBlurCellEditor(() => this.node.focus())));
         });
     }
 
@@ -207,6 +204,7 @@ export class NotebookEditorWidget extends ReactWidget implements Navigatable, Sa
         }
         // Ensure that the model is loaded before adding the editor
         this.notebookEditorService.addNotebookEditor(this);
+        this._model.selectedCell = this._model.cells[0];
         this.update();
         this.notebookContextManager.init(this);
         return this._model;
@@ -267,7 +265,8 @@ export class NotebookEditorWidget extends ReactWidget implements Navigatable, Sa
                             notebookModel={this._model}
                             notebookContext={this.notebookContextManager}
                             toolbarRenderer={this.cellToolbarFactory}
-                            commandRegistry={this.commandRegistry} />
+                            commandRegistry={this.commandRegistry}
+                            menuRegistry={this.menuRegistry} />
                     </PerfectScrollbar>
                 </div>
             </div>;

package/src/browser/notebook-frontend-module.ts

@@ -47,6 +47,7 @@ import { NotebookClipboardService } from './service/notebook-clipboard-service';
 import { bindNotebookPreferences } from './contributions/notebook-preferences';
 import { NotebookOptionsService } from './service/notebook-options';
 import { NotebookUndoRedoHandler } from './contributions/notebook-undo-redo-handler';
+import { NotebookStatusBarContribution } from './contributions/notebook-status-bar-contribution';
 
 export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(NotebookColorContribution).toSelf().inSingletonScope();
@@ -112,4 +113,7 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
 
     bind(NotebookUndoRedoHandler).toSelf().inSingletonScope();
     bind(UndoRedoHandler).toService(NotebookUndoRedoHandler);
+
+    bind(NotebookStatusBarContribution).toSelf().inSingletonScope();
+    bind(FrontendApplicationContribution).toService(NotebookStatusBarContribution);
 });

package/src/browser/style/index.css

@@ -272,10 +272,10 @@
   border: 1px solid var(--theia-notebook-cellToolbarSeparator);
   background-color: var(--theia-editor-background);
   color: var(--theia-foreground);
-  vertical-align: middle;
-  text-align: center;
+  display: flex;
   height: 24px;
   margin: 0 8px;
+  padding: 2px 4px;
 }
 
 .theia-notebook-add-cell-button:hover {
@@ -286,10 +286,18 @@
   background-color: var(--theia-toolbar-active);
 }
 
-.theia-notebook-add-cell-button-icon {
+.theia-notebook-add-cell-button>* {
   vertical-align: middle;
 }
 
+.theia-notebook-add-cell-button-icon::before {
+  font: normal normal normal 14px/1 codicon;
+}
+
+.theia-notebook-add-cell-button-text {
+  margin: 1px 0 0 4px;
+}
+
 .theia-notebook-cell-output-webview {
   padding: 5px 0px;
   margin: 0px 15px 0px 9px;

package/src/browser/view/notebook-cell-editor.tsx

@@ -101,6 +101,16 @@ export class CellEditor extends React.Component<CellEditorProps, {}> {
             this.props.notebookContextManager.scopedStore.setContext(NOTEBOOK_CELL_CURSOR_LAST_LINE, currentLine === lineCount);
         }));
 
+        this.toDispose.push(this.props.cell.onWillBlurCellEditor(() => {
+            let parent = this.container?.parentElement;
+            while (parent && !parent.classList.contains('theia-notebook-cell')) {
+                parent = parent.parentElement;
+            }
+            if (parent) {
+                parent.focus();
+            }
+        }));
+
         this.toDispose.push(this.props.cell.onDidChangeEditorOptions(options => {
             this.editor?.getControl().updateOptions(options);
         }));
@@ -114,20 +124,7 @@ export class CellEditor extends React.Component<CellEditorProps, {}> {
             animationFrame().then(() => this.setMatches());
         }));
 
-        this.toDispose.push(this.props.cell.onDidSelectFindMatch(match => {
-            const editorDomNode = this.editor?.getControl().getDomNode();
-            if (editorDomNode) {
-                editorDomNode.scrollIntoView({
-                    behavior: 'instant',
-                    block: 'center'
-                });
-            } else {
-                this.container?.scrollIntoView({
-                    behavior: 'instant',
-                    block: 'center'
-                });
-            }
-        }));
+        this.toDispose.push(this.props.cell.onDidSelectFindMatch(match => this.centerEditorInView()));
 
         this.toDispose.push(this.props.notebookModel.onDidChangeSelectedCell(e => {
             if (e.cell !== this.props.cell && this.editor?.getControl().hasTextFocus()) {
@@ -145,6 +142,10 @@ export class CellEditor extends React.Component<CellEditorProps, {}> {
             });
             this.toDispose.push(disposable);
         }
+
+        this.toDispose.push(this.props.cell.onDidRequestCenterEditor(() => {
+            this.centerEditorInView();
+        }));
     }
 
     override componentWillUnmount(): void {
@@ -156,6 +157,21 @@ export class CellEditor extends React.Component<CellEditorProps, {}> {
         this.toDispose = new DisposableCollection();
     }
 
+    protected centerEditorInView(): void {
+        const editorDomNode = this.editor?.getControl().getDomNode();
+        if (editorDomNode) {
+            editorDomNode.scrollIntoView({
+                behavior: 'instant',
+                block: 'center'
+            });
+        } else {
+            this.container?.scrollIntoView({
+                behavior: 'instant',
+                block: 'center'
+            });
+        }
+    }
+
     protected async initEditor(): Promise<void> {
         const { cell, notebookModel, monacoServices } = this.props;
         if (this.container) {

package/src/browser/view/notebook-cell-list-view.tsx

@@ -18,9 +18,9 @@ import { CellEditType, CellKind, NotebookCellsChangeType } from '../../common';
 import { NotebookCellModel } from '../view-model/notebook-cell-model';
 import { NotebookModel } from '../view-model/notebook-model';
 import { NotebookCellToolbarFactory } from './notebook-cell-toolbar-factory';
-import { animationFrame, codicon, onDomEvent } from '@theia/core/lib/browser';
-import { CommandRegistry, DisposableCollection, nls } from '@theia/core';
-import { NotebookCommands } from '../contributions/notebook-actions-contribution';
+import { animationFrame, onDomEvent } from '@theia/core/lib/browser';
+import { CommandRegistry, DisposableCollection, MenuModelRegistry, MenuNode, nls } from '@theia/core';
+import { NotebookCommands, NotebookMenus } from '../contributions/notebook-actions-contribution';
 import { NotebookCellActionContribution } from '../contributions/notebook-cell-actions-contribution';
 import { NotebookContextManager } from '../service/notebook-context-manager';
 
@@ -34,7 +34,8 @@ interface CellListProps {
     notebookModel: NotebookModel;
     notebookContext: NotebookContextManager;
     toolbarRenderer: NotebookCellToolbarFactory;
-    commandRegistry: CommandRegistry
+    commandRegistry: CommandRegistry;
+    menuRegistry: MenuModelRegistry;
 }
 
 interface NotebookCellListState {
@@ -113,8 +114,9 @@ export class NotebookCellListView extends React.Component<CellListProps, Noteboo
                 .map((cell, index) =>
                     <React.Fragment key={'cell-' + cell.handle}>
                         <NotebookCellDivider
+                            menuRegistry={this.props.menuRegistry}
                             isVisible={() => this.isEnabled()}
-                            onAddNewCell={(kind: CellKind) => this.onAddNewCell(kind, index)}
+                            onAddNewCell={(commandId: string) => this.onAddNewCell(commandId, index)}
                             onDrop={e => this.onDrop(e, index)}
                             onDragOver={e => this.onDragOver(e, cell, 'top')} />
                         {this.shouldRenderDragOverIndicator(cell, 'top') && <CellDropIndicator />}
@@ -132,7 +134,14 @@ export class NotebookCellListView extends React.Component<CellListProps, Noteboo
                             onDrop={e => this.onDrop(e, index)}
                             draggable={true}
                             tabIndex={-1}
-                            ref={ref => cell === this.state.selectedCell && this.state.scrollIntoView && ref?.scrollIntoView({ block: 'nearest' })}>
+                            ref={ref => {
+                                if (ref && cell === this.state.selectedCell && this.state.scrollIntoView) {
+                                    ref.scrollIntoView({ block: 'nearest' });
+                                    if (cell.cellKind === CellKind.Markup && !cell.editing) {
+                                        ref.focus();
+                                    }
+                                }
+                            }}>
                             <div className={'theia-notebook-cell-marker' + (this.state.selectedCell === cell ? ' theia-notebook-cell-marker-selected' : '')}></div>
                             <div className='theia-notebook-cell-content'>
                                 {this.renderCellContent(cell, index)}
@@ -148,8 +157,9 @@ export class NotebookCellListView extends React.Component<CellListProps, Noteboo
                 )
             }
             <NotebookCellDivider
+                menuRegistry={this.props.menuRegistry}
                 isVisible={() => this.isEnabled()}
-                onAddNewCell={(kind: CellKind) => this.onAddNewCell(kind, this.props.notebookModel.cells.length)}
+                onAddNewCell={(commandId: string) => this.onAddNewCell(commandId, this.props.notebookModel.cells.length)}
                 onDrop={e => this.onDrop(e, this.props.notebookModel.cells.length - 1)}
                 onDragOver={e => this.onDragOver(e, this.props.notebookModel.cells[this.props.notebookModel.cells.length - 1], 'bottom')} />
         </ul>;
@@ -214,11 +224,11 @@ export class NotebookCellListView extends React.Component<CellListProps, Noteboo
         this.setState({ ...this.state, dragOverIndicator: undefined });
     }
 
-    protected onAddNewCell(kind: CellKind, index: number): void {
+    protected onAddNewCell(commandId: string, index: number): void {
         if (this.isEnabled()) {
-            this.props.commandRegistry.executeCommand(NotebookCommands.ADD_NEW_CELL_COMMAND.id,
+            this.props.commandRegistry.executeCommand(NotebookCommands.CHANGE_SELECTED_CELL.id, index - 1);
+            this.props.commandRegistry.executeCommand(commandId,
                 this.props.notebookModel,
-                kind,
                 index
             );
         }
@@ -235,24 +245,31 @@ export class NotebookCellListView extends React.Component<CellListProps, Noteboo
 
 export interface NotebookCellDividerProps {
     isVisible: () => boolean;
-    onAddNewCell: (type: CellKind) => void;
+    onAddNewCell: (commandId: string) => void;
     onDrop: (event: React.DragEvent<HTMLLIElement>) => void;
     onDragOver: (event: React.DragEvent<HTMLLIElement>) => void;
+    menuRegistry: MenuModelRegistry;
 }
 
-export function NotebookCellDivider({ isVisible, onAddNewCell, onDrop, onDragOver }: NotebookCellDividerProps): React.JSX.Element {
+export function NotebookCellDivider({ isVisible, onAddNewCell, onDrop, onDragOver, menuRegistry }: NotebookCellDividerProps): React.JSX.Element {
     const [hover, setHover] = React.useState(false);
 
+    const menuPath = NotebookMenus.NOTEBOOK_MAIN_TOOLBAR_CELL_ADD_GROUP;
+    const menuItems = menuRegistry.getMenuNode(menuPath).children;
+
+    const renderItem = (item: MenuNode): React.ReactNode => <button
+        key={item.id}
+        className='theia-notebook-add-cell-button'
+        onClick={() => onAddNewCell(item.command || '')}
+        title={nls.localizeByDefault(`Add ${item.label} Cell`)}
+    >
+        <div className={item.icon + ' theia-notebook-add-cell-button-icon'} />
+        <div className='theia-notebook-add-cell-button-text'>{item.label}</div>
+    </button>;
+
     return <li className='theia-notebook-cell-divider' onMouseEnter={() => setHover(true)} onMouseLeave={() => setHover(false)} onDrop={onDrop} onDragOver={onDragOver}>
         {hover && isVisible() && <div className='theia-notebook-add-cell-buttons'>
-            <button className='theia-notebook-add-cell-button' onClick={() => onAddNewCell(CellKind.Code)} title={nls.localizeByDefault('Add Code Cell')}>
-                <div className={codicon('add') + ' theia-notebook-add-cell-button-icon'} />
-                {nls.localizeByDefault('Code')}
-            </button>
-            <button className='theia-notebook-add-cell-button' onClick={() => onAddNewCell(CellKind.Markup)} title={nls.localizeByDefault('Add Markdown Cell')}>
-                <div className={codicon('add') + ' theia-notebook-add-cell-button-icon'} />
-                {nls.localizeByDefault('Markdown')}
-            </button>
+            {menuItems.map((item: MenuNode) => renderItem(item))}
         </div>}
     </li>;
 }

package/src/browser/view-model/notebook-cell-model.ts

@@ -126,6 +126,9 @@ export class NotebookCellModel implements NotebookCell, Disposable {
     protected readonly onDidSelectFindMatchEmitter = new Emitter<NotebookCodeEditorFindMatch>();
     readonly onDidSelectFindMatch: Event<NotebookCodeEditorFindMatch> = this.onDidSelectFindMatchEmitter.event;
 
+    protected onDidRequestCenterEditorEmitter = new Emitter<void>();
+    readonly onDidRequestCenterEditor = this.onDidRequestCenterEditorEmitter.event;
+
     @inject(NotebookCellModelProps)
     protected readonly props: NotebookCellModelProps;
 
@@ -299,6 +302,10 @@ export class NotebookCellModel implements NotebookCell, Disposable {
         this.onWillBlurCellEditorEmitter.fire();
     }
 
+    requestCenterEditor(): void {
+        this.onDidRequestCenterEditorEmitter.fire();
+    }
+
     spliceNotebookCellOutputs(splice: NotebookCellOutputsSplice): void {
         if (splice.deleteCount > 0 && splice.newOutputs.length > 0) {
             const commonLen = Math.min(splice.deleteCount, splice.newOutputs.length);