@theia/notebook 1.49.1 → 1.50.1

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

@@ -24,8 +24,9 @@ import { NotebookKernelQuickPickService } from '../service/notebook-kernel-quick
 import { NotebookExecutionService } from '../service/notebook-execution-service';
 import { NotebookEditorWidget } from '../notebook-editor-widget';
 import { NotebookEditorWidgetService } from '../service/notebook-editor-widget-service';
-import { NOTEBOOK_CELL_FOCUSED, NOTEBOOK_EDITOR_FOCUSED, NOTEBOOK_HAS_OUTPUTS } from './notebook-context-keys';
+import { NOTEBOOK_CELL_CURSOR_FIRST_LINE, NOTEBOOK_CELL_CURSOR_LAST_LINE, NOTEBOOK_CELL_FOCUSED, NOTEBOOK_EDITOR_FOCUSED, NOTEBOOK_HAS_OUTPUTS } from './notebook-context-keys';
 import { NotebookClipboardService } from '../service/notebook-clipboard-service';
+import { ContextKeyService } from '@theia/core/lib/browser/context-key-service';
 
 export namespace NotebookCommands {
     export const ADD_NEW_CELL_COMMAND = Command.toDefaultLocalizedCommand({
@@ -69,17 +70,17 @@ export namespace NotebookCommands {
     });
 
     export const CUT_SELECTED_CELL = Command.toDefaultLocalizedCommand({
-        id: 'notebook.cut-selected-cell',
+        id: 'notebook.cell.cut',
         category: 'Notebook',
     });
 
     export const COPY_SELECTED_CELL = Command.toDefaultLocalizedCommand({
-        id: 'notebook.copy-selected-cell',
+        id: 'notebook.cell.copy',
         category: 'Notebook',
     });
 
     export const PASTE_CELL = Command.toDefaultLocalizedCommand({
-        id: 'notebook.paste-cell',
+        id: 'notebook.cell.paste',
         category: 'Notebook',
     });
 }
@@ -110,22 +111,26 @@ export class NotebookActionsContribution implements CommandContribution, MenuCon
     @inject(NotebookClipboardService)
     protected notebookClipboardService: NotebookClipboardService;
 
+    @inject(ContextKeyService)
+    protected contextKeyService: ContextKeyService;
+
     registerCommands(commands: CommandRegistry): void {
         commands.registerCommand(NotebookCommands.ADD_NEW_CELL_COMMAND, {
             execute: (notebookModel: NotebookModel, cellKind: CellKind = CellKind.Markup, index?: number | 'above' | 'below') => {
                 notebookModel = notebookModel ?? this.notebookEditorWidgetService.focusedEditor?.model;
 
                 let insertIndex: number = 0;
-                if (index && index >= 0) {
-                    insertIndex = index as number;
+                if (typeof index === 'number' && index >= 0) {
+                    insertIndex = index;
                 } else if (notebookModel.selectedCell && typeof index === 'string') {
                     // if index is -1 insert below otherwise at the index of the selected cell which is above the selected.
                     insertIndex = notebookModel.cells.indexOf(notebookModel.selectedCell) + (index === 'below' ? 1 : 0);
                 }
 
-                let firstCodeCell;
+                let cellLanguage: string = 'markdown';
                 if (cellKind === CellKind.Code) {
-                    firstCodeCell = notebookModel.cells.find(cell => cell.cellKind === CellKind.Code);
+                    const firstCodeCell = notebookModel.cells.find(cell => cell.cellKind === CellKind.Code);
+                    cellLanguage = firstCodeCell?.language ?? 'plaintext';
                 }
 
                 notebookModel.applyEdits([{
@@ -134,7 +139,7 @@ export class NotebookActionsContribution implements CommandContribution, MenuCon
                     count: 0,
                     cells: [{
                         cellKind,
-                        language: firstCodeCell?.language ?? 'markdown',
+                        language: cellLanguage,
                         source: '',
                         outputs: [],
                         metadata: {},
@@ -169,15 +174,29 @@ export class NotebookActionsContribution implements CommandContribution, MenuCon
         commands.registerCommand(NotebookCommands.CHANGE_SELECTED_CELL,
             {
                 execute: (change: number | CellChangeDirection) => {
-                    const model = this.notebookEditorWidgetService.focusedEditor?.model;
+                    const focusedEditor = this.notebookEditorWidgetService.focusedEditor;
+                    const model = focusedEditor?.model;
                     if (model && typeof change === 'number') {
                         model.setSelectedCell(model.cells[change]);
                     } else if (model && model.selectedCell) {
                         const currentIndex = model.cells.indexOf(model.selectedCell);
+                        const shouldFocusEditor = this.contextKeyService.match('editorTextFocus');
+
                         if (change === CellChangeDirection.Up && currentIndex > 0) {
                             model.setSelectedCell(model.cells[currentIndex - 1]);
+                            if (model.selectedCell?.cellKind === CellKind.Code && shouldFocusEditor) {
+                                model.selectedCell.requestFocusEditor('lastLine');
+                            }
                         } else if (change === CellChangeDirection.Down && currentIndex < model.cells.length - 1) {
                             model.setSelectedCell(model.cells[currentIndex + 1]);
+                            if (model.selectedCell?.cellKind === CellKind.Code && shouldFocusEditor) {
+                                model.selectedCell.requestFocusEditor();
+                            }
+                        }
+
+                        if (model.selectedCell.cellKind === CellKind.Markup) {
+                            // since were losing focus from the cell editor, we need to focus the notebook editor again
+                            focusedEditor?.node.focus();
                         }
                     }
                 }
@@ -286,6 +305,8 @@ export class NotebookActionsContribution implements CommandContribution, MenuCon
             order: '30',
             when: NOTEBOOK_HAS_OUTPUTS
         });
+
+        menus.registerIndependentSubmenu(NotebookMenus.NOTEBOOK_MAIN_TOOLBAR_HIDDEN_ITEMS_CONTEXT_MENU, '');
     }
 
     registerKeybindings(keybindings: KeybindingRegistry): void {
@@ -294,13 +315,13 @@ export class NotebookActionsContribution implements CommandContribution, MenuCon
                 command: NotebookCommands.CHANGE_SELECTED_CELL.id,
                 keybinding: 'up',
                 args: CellChangeDirection.Up,
-                when: `!editorTextFocus && ${NOTEBOOK_EDITOR_FOCUSED} && ${NOTEBOOK_CELL_FOCUSED}`
+                when: `(!editorTextFocus || ${NOTEBOOK_CELL_CURSOR_FIRST_LINE}) && ${NOTEBOOK_EDITOR_FOCUSED} && ${NOTEBOOK_CELL_FOCUSED}`
             },
             {
                 command: NotebookCommands.CHANGE_SELECTED_CELL.id,
                 keybinding: 'down',
                 args: CellChangeDirection.Down,
-                when: `!editorTextFocus && ${NOTEBOOK_EDITOR_FOCUSED} && ${NOTEBOOK_CELL_FOCUSED}`
+                when: `(!editorTextFocus || ${NOTEBOOK_CELL_CURSOR_LAST_LINE})  && ${NOTEBOOK_EDITOR_FOCUSED} && ${NOTEBOOK_CELL_FOCUSED}`
             },
             {
                 command: NotebookCommands.CUT_SELECTED_CELL.id,
@@ -326,4 +347,5 @@ export namespace NotebookMenus {
     export const NOTEBOOK_MAIN_TOOLBAR = 'notebook/toolbar';
     export const NOTEBOOK_MAIN_TOOLBAR_CELL_ADD_GROUP = [NOTEBOOK_MAIN_TOOLBAR, 'cell-add-group'];
     export const NOTEBOOK_MAIN_TOOLBAR_EXECUTION_GROUP = [NOTEBOOK_MAIN_TOOLBAR, 'cell-execution-group'];
+    export const NOTEBOOK_MAIN_TOOLBAR_HIDDEN_ITEMS_CONTEXT_MENU = 'notebook-main-toolbar-hidden-items-context-menu';
 }

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

@@ -120,24 +120,24 @@ export namespace NotebookCellCommands {
         label: 'Change Cell to Mardown'
     });
 
-    export const COLLAPSE_CELL_OUTPUT = Command.toDefaultLocalizedCommand({
-        id: 'notebook.cell.collapseCellOutput',
+    export const TOGGLE_CELL_OUTPUT = Command.toDefaultLocalizedCommand({
+        id: 'notebook.cell.toggleOutputs',
         category: 'Notebook',
         label: 'Collapse Cell Output',
     });
 
-    export const EXPAND_CELL_OUTPUT = Command.toDefaultLocalizedCommand({
-        id: 'notebook.cell.expandCellOutput',
-        category: 'Notebook',
-        label: 'Expand Cell Output',
-    });
-
     export const CHANGE_CELL_LANGUAGE = Command.toDefaultLocalizedCommand({
         id: 'notebook.cell.changeLanguage',
         category: 'Notebook',
         label: 'Change Cell Language',
     });
 
+    export const TOGGLE_LINE_NUMBERS = Command.toDefaultLocalizedCommand({
+        id: 'notebook.cell.toggleLineNumbers',
+        category: 'Notebook',
+        label: 'Show Cell Line Numbers',
+    });
+
 }
 
 @injectable()
@@ -351,20 +351,11 @@ export class NotebookCellActionContribution implements MenuContribution, Command
             changeCellType(notebookModel, cell, CellKind.Markup);
         }));
 
-        commands.registerCommand(NotebookCellCommands.COLLAPSE_CELL_OUTPUT, {
-            execute: () => {
-                const selectedCell = this.notebookEditorWidgetService.focusedEditor?.model?.selectedCell;
-                if (selectedCell) {
-                    selectedCell.outputVisible = false;
-                }
-            }
-        });
-
-        commands.registerCommand(NotebookCellCommands.EXPAND_CELL_OUTPUT, {
+        commands.registerCommand(NotebookCellCommands.TOGGLE_CELL_OUTPUT, {
             execute: () => {
                 const selectedCell = this.notebookEditorWidgetService.focusedEditor?.model?.selectedCell;
                 if (selectedCell) {
-                    selectedCell.outputVisible = true;
+                    selectedCell.outputVisible = !selectedCell.outputVisible;
                 }
             }
         });
@@ -387,6 +378,16 @@ export class NotebookCellActionContribution implements MenuContribution, Command
             }
         });
 
+        commands.registerCommand(NotebookCellCommands.TOGGLE_LINE_NUMBERS, {
+            execute: () => {
+                const selectedCell = this.notebookEditorWidgetService.focusedEditor?.model?.selectedCell;
+                if (selectedCell) {
+                    const currentLineNumber = selectedCell.editorOptions?.lineNumbers;
+                    selectedCell.editorOptions = { ...selectedCell.editorOptions, lineNumbers: !currentLineNumber || currentLineNumber === 'off' ? 'on' : 'off' };
+                }
+            }
+        });
+
     }
 
     protected editableCellCommandHandler(execute: (notebookModel: NotebookModel, cell: NotebookCellModel, output?: NotebookCellOutputModel) => void): CommandHandler {

package/src/browser/contributions/notebook-context-keys.ts

@@ -30,6 +30,7 @@ export const KEYBINDING_CONTEXT_NOTEBOOK_FIND_WIDGET_FOCUSED = 'notebookFindWidg
 export const NOTEBOOK_EDITOR_FOCUSED = 'notebookEditorFocused';
 export const NOTEBOOK_CELL_LIST_FOCUSED = 'notebookCellListFocused';
 export const NOTEBOOK_OUTPUT_FOCUSED = 'notebookOutputFocused';
+export const NOTEBOOK_OUTPUT_INPUT_FOCUSED = 'notebookOutputInputFocused';
 export const NOTEBOOK_EDITOR_EDITABLE = 'notebookEditable';
 export const NOTEBOOK_HAS_RUNNING_CELL = 'notebookHasRunningCell';
 export const NOTEBOOK_USE_CONSOLIDATED_OUTPUT_BUTTON = 'notebookUseConsolidatedOutputButton';
@@ -58,6 +59,9 @@ export const NOTEBOOK_INTERRUPTIBLE_KERNEL = 'notebookInterruptibleKernel';
 export const NOTEBOOK_MISSING_KERNEL_EXTENSION = 'notebookMissingKernelExtension';
 export const NOTEBOOK_HAS_OUTPUTS = 'notebookHasOutputs';
 
+export const NOTEBOOK_CELL_CURSOR_FIRST_LINE = 'cellEditorCursorPositionFirstLine';
+export const NOTEBOOK_CELL_CURSOR_LAST_LINE = 'cellEditorCursorPositionLastLine';
+
 export namespace NotebookContextKeys {
     export function initNotebookContextKeys(service: ContextKeyService): void {
         service.createKey(HAS_OPENED_NOTEBOOK, false);
@@ -71,6 +75,7 @@ export namespace NotebookContextKeys {
         service.createKey(NOTEBOOK_EDITOR_FOCUSED, false);
         service.createKey(NOTEBOOK_CELL_LIST_FOCUSED, false);
         service.createKey(NOTEBOOK_OUTPUT_FOCUSED, false);
+        service.createKey(NOTEBOOK_OUTPUT_INPUT_FOCUSED, false);
         service.createKey(NOTEBOOK_EDITOR_EDITABLE, true);
         service.createKey(NOTEBOOK_HAS_RUNNING_CELL, false);
         service.createKey(NOTEBOOK_USE_CONSOLIDATED_OUTPUT_BUTTON, false);
@@ -93,6 +98,8 @@ export namespace NotebookContextKeys {
         service.createKey(NOTEBOOK_CELL_INPUT_COLLAPSED, false);
         service.createKey(NOTEBOOK_CELL_OUTPUT_COLLAPSED, false);
         service.createKey(NOTEBOOK_CELL_RESOURCE, '');
+        service.createKey(NOTEBOOK_CELL_CURSOR_FIRST_LINE, false);
+        service.createKey(NOTEBOOK_CELL_CURSOR_LAST_LINE, false);
 
         // Kernels
         service.createKey(NOTEBOOK_KERNEL, undefined);

package/src/browser/contributions/notebook-label-provider-contribution.ts

@@ -16,11 +16,13 @@
 
 import { codicon, LabelProvider, LabelProviderContribution } from '@theia/core/lib/browser';
 import { inject, injectable } from '@theia/core/shared/inversify';
-import { CellKind } from '../../common';
+import { CellKind, CellUri } from '../../common';
 import { NotebookService } from '../service/notebook-service';
 import { NotebookCellOutlineNode } from './notebook-outline-contribution';
 import type Token = require('markdown-it/lib/token');
 import markdownit = require('@theia/core/shared/markdown-it');
+import { NotebookCellModel } from '../view-model/notebook-cell-model';
+import { URI } from '@theia/core';
 
 @injectable()
 export class NotebookLabelProviderContribution implements LabelProviderContribution {
@@ -41,23 +43,43 @@ export class NotebookLabelProviderContribution implements LabelProviderContribut
     }
 
     getIcon(element: NotebookCellOutlineNode): string {
-        return element.notebookCell.cellKind === CellKind.Markup ? codicon('markdown') : codicon('code');
+        const cell = this.findCellByUri(element.uri);
+        if (cell) {
+            return cell.cellKind === CellKind.Markup ? codicon('markdown') : codicon('code');
+        }
+        return '';
     }
 
     getName(element: NotebookCellOutlineNode): string {
-        return element.notebookCell.cellKind === CellKind.Code ?
-            element.notebookCell.text.split('\n')[0] :
-            this.extractPlaintext(this.markdownIt.parse(element.notebookCell.text.split('\n')[0], {}));
+        const cell = this.findCellByUri(element.uri);
+        if (cell) {
+            return cell.cellKind === CellKind.Code ?
+                cell.text.split('\n')[0] :
+                this.extractPlaintext(this.markdownIt.parse(cell.text.split('\n')[0], {}));
+        }
+        return '';
     }
 
     getLongName(element: NotebookCellOutlineNode): string {
-        return element.notebookCell.cellKind === CellKind.Code ?
-            element.notebookCell.text.split('\n')[0] :
-            this.extractPlaintext(this.markdownIt.parse(element.notebookCell.text.split('\n')[0], {}));
+        const cell = this.findCellByUri(element.uri);
+        if (cell) {
+            return cell.cellKind === CellKind.Code ?
+                cell.text.split('\n')[0] :
+                this.extractPlaintext(this.markdownIt.parse(cell.text.split('\n')[0], {}));
+        }
+        return '';
     }
 
     extractPlaintext(parsedMarkdown: Token[]): string {
         return parsedMarkdown.map(token => token.children ? this.extractPlaintext(token.children) : token.content).join('');
     }
 
+    findCellByUri(uri: URI): NotebookCellModel | undefined {
+        const parsed = CellUri.parse(uri);
+        if (parsed) {
+            return this.notebookService.getNotebookEditorModel(parsed.notebook)?.cells.find(cell => cell.handle === parsed?.handle);
+        }
+        return undefined;
+    }
+
 }

package/src/browser/contributions/notebook-outline-contribution.ts

@@ -21,18 +21,20 @@ import { OutlineViewService } from '@theia/outline-view/lib/browser/outline-view
 import { NotebookModel } from '../view-model/notebook-model';
 import { OutlineSymbolInformationNode } from '@theia/outline-view/lib/browser/outline-view-widget';
 import { NotebookEditorWidget } from '../notebook-editor-widget';
-import { NotebookCellModel } from '../view-model/notebook-cell-model';
-import { DisposableCollection, URI } from '@theia/core';
+import { DisposableCollection, isObject, URI } from '@theia/core';
 import { CellKind, CellUri } from '../../common';
 import { NotebookService } from '../service/notebook-service';
 export interface NotebookCellOutlineNode extends OutlineSymbolInformationNode {
-    notebookCell: NotebookCellModel;
     uri: URI;
 }
 
 export namespace NotebookCellOutlineNode {
     export function is(element: object): element is NotebookCellOutlineNode {
-        return TreeNode.is(element) && OutlineSymbolInformationNode.is(element) && 'notebookCell' in element;
+        return TreeNode.is(element)
+            && OutlineSymbolInformationNode.is(element)
+            && isObject<NotebookCellOutlineNode>(element)
+            && element.uri instanceof URI
+            && element.uri.scheme === CellUri.cellUriScheme;
     }
 }
 
@@ -94,17 +96,17 @@ export class NotebookOutlineContribution implements FrontendApplicationContribut
             children: [],
             selected: model.selectedCell === cell,
             expanded: false,
-            notebookCell: cell,
-            uri: model.uri,
+            uri: cell.uri,
         } as NotebookCellOutlineNode));
     }
 
     selectCell(node: object): void {
         if (NotebookCellOutlineNode.is(node)) {
-            const parsed = CellUri.parse(node.notebookCell.uri);
+            const parsed = CellUri.parse(node.uri);
             const model = parsed && this.notebookService.getNotebookEditorModel(parsed.notebook);
-            if (model) {
-                model.setSelectedCell(node.notebookCell);
+            const cell = model?.cells.find(c => c.handle === parsed?.handle);
+            if (model && cell) {
+                model.setSelectedCell(cell);
             }
         }
     }

package/src/browser/notebook-editor-widget-factory.ts

@@ -61,8 +61,7 @@ export class NotebookEditorWidgetFactory implements WidgetFactory {
         return editor;
     }
 
-    private async createEditor(uri: URI, notebookType: string): Promise<NotebookEditorWidget> {
-
+    protected async createEditor(uri: URI, notebookType: string): Promise<NotebookEditorWidget> {
         return this.createNotebookEditorWidget({
             uri,
             notebookType,
@@ -70,7 +69,7 @@ export class NotebookEditorWidgetFactory implements WidgetFactory {
         });
     }
 
-    private setLabels(editor: NotebookEditorWidget, uri: URI): void {
+    protected setLabels(editor: NotebookEditorWidget, uri: URI): void {
         editor.title.caption = uri.path.fsPath();
         if (editor.model?.readOnly) {
             editor.title.caption += ` • ${nls.localizeByDefault('Read-only')}`;

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

@@ -120,6 +120,9 @@ export class NotebookEditorWidget extends ReactWidget implements Navigatable, Sa
     protected readonly onDidReceiveKernelMessageEmitter = new Emitter<unknown>();
     readonly onDidReceiveKernelMessage = this.onDidReceiveKernelMessageEmitter.event;
 
+    protected readonly onDidChangeOutputInputFocusEmitter = new Emitter<boolean>();
+    readonly onDidChangeOutputInputFocus = this.onDidChangeOutputInputFocusEmitter.event;
+
     protected readonly renderers = new Map<CellKind, CellRenderer>();
     protected _model?: NotebookModel;
     protected _ready: Deferred<NotebookModel> = new Deferred();
@@ -251,12 +254,17 @@ export class NotebookEditorWidget extends ReactWidget implements Navigatable, Sa
         this.onDidReceiveKernelMessageEmitter.fire(message);
     }
 
+    outputInputFocusChanged(focused: boolean): void {
+        this.onDidChangeOutputInputFocusEmitter.fire(focused);
+    }
+
     override dispose(): void {
         this.notebookContextManager.dispose();
         this.onDidChangeModelEmitter.dispose();
         this.onDidPostKernelMessageEmitter.dispose();
         this.onDidReceiveKernelMessageEmitter.dispose();
         this.onPostRendererMessageEmitter.dispose();
+        this.onDidChangeOutputInputFocusEmitter.dispose();
         this.viewportService.dispose();
         this._model?.dispose();
         super.dispose();

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

@@ -27,7 +27,7 @@ import { NotebookEditorWidgetFactory } from './notebook-editor-widget-factory';
 import { NotebookCellResourceResolver, NotebookOutputResourceResolver } from './notebook-cell-resource-resolver';
 import { NotebookModelResolverService } from './service/notebook-model-resolver-service';
 import { NotebookCellActionContribution } from './contributions/notebook-cell-actions-contribution';
-import { createNotebookModelContainer, NotebookModel, NotebookModelFactory, NotebookModelProps } from './view-model/notebook-model';
+import { createNotebookModelContainer, NotebookModel, NotebookModelFactory, NotebookModelProps, NotebookModelResolverServiceProxy } from './view-model/notebook-model';
 import { createNotebookCellModelContainer, NotebookCellModel, NotebookCellModelFactory, NotebookCellModelProps } from './view-model/notebook-cell-model';
 import { createNotebookEditorWidgetContainer, NotebookEditorWidgetContainerFactory, NotebookEditorProps, NotebookEditorWidget } from './notebook-editor-widget';
 import { NotebookActionsContribution } from './contributions/notebook-actions-contribution';
@@ -71,6 +71,7 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(NotebookCellResourceResolver).toSelf().inSingletonScope();
     bind(ResourceResolver).toService(NotebookCellResourceResolver);
     bind(NotebookModelResolverService).toSelf().inSingletonScope();
+    bind(NotebookModelResolverServiceProxy).toService(NotebookModelResolverService);
     bind(NotebookOutputResourceResolver).toSelf().inSingletonScope();
     bind(ResourceResolver).toService(NotebookOutputResourceResolver);
 

package/src/browser/service/notebook-context-manager.ts

@@ -23,6 +23,7 @@ import {
     NOTEBOOK_CELL_EXECUTING, NOTEBOOK_CELL_EXECUTION_STATE,
     NOTEBOOK_CELL_FOCUSED, NOTEBOOK_CELL_MARKDOWN_EDIT_MODE,
     NOTEBOOK_CELL_TYPE, NOTEBOOK_HAS_OUTPUTS, NOTEBOOK_KERNEL, NOTEBOOK_KERNEL_SELECTED,
+    NOTEBOOK_OUTPUT_INPUT_FOCUSED,
     NOTEBOOK_VIEW_TYPE
 } from '../contributions/notebook-context-keys';
 import { NotebookEditorWidget } from '../notebook-editor-widget';
@@ -87,6 +88,7 @@ export class NotebookContextManager {
         // Cell Selection realted keys
         this.scopedStore.setContext(NOTEBOOK_CELL_FOCUSED, !!widget.model?.selectedCell);
         widget.model?.onDidChangeSelectedCell(e => {
+            this.selectedCellChanged(e.cell);
             this.scopedStore.setContext(NOTEBOOK_CELL_FOCUSED, !!e);
             this.onDidChangeContextEmitter.fire(this.createContextKeyChangedEvent([NOTEBOOK_CELL_FOCUSED]));
         });
@@ -99,7 +101,10 @@ export class NotebookContextManager {
             }
         }));
 
-        widget.model?.onDidChangeSelectedCell(e => this.selectedCellChanged(e));
+        widget.onDidChangeOutputInputFocus(focus => {
+            this.scopedStore.setContext(NOTEBOOK_OUTPUT_INPUT_FOCUSED, focus);
+            this.onDidChangeContextEmitter.fire(this.createContextKeyChangedEvent([NOTEBOOK_OUTPUT_INPUT_FOCUSED]));
+        });
 
         this.onDidChangeContextEmitter.fire(this.createContextKeyChangedEvent([NOTEBOOK_VIEW_TYPE, NOTEBOOK_KERNEL_SELECTED, NOTEBOOK_KERNEL]));
     }

package/src/browser/service/notebook-execution-service.ts

@@ -88,6 +88,15 @@ export class NotebookExecutionService {
 
         // request execution
         if (validCellExecutions.length > 0) {
+            const cellRemoveListener = notebook.onDidAddOrRemoveCell(e => {
+                if (e.rawEvent.changes.some(c => c.deleteCount > 0)) {
+                    const executionsToCancel = validCellExecutions.filter(exec => !notebook.cells.find(cell => cell.handle === exec.cellHandle));
+                    if (executionsToCancel.length > 0) {
+                        kernel.cancelNotebookCellExecution(notebook.uri, executionsToCancel.map(c => c.cellHandle));
+                        executionsToCancel.forEach(exec => exec.complete({}));
+                    }
+                }
+            });
             await this.runExecutionParticipants(validCellExecutions);
 
             this.notebookKernelService.selectKernelForNotebook(kernel, notebook);
@@ -97,6 +106,9 @@ export class NotebookExecutionService {
             if (unconfirmed.length) {
                 unconfirmed.forEach(exe => exe.complete({}));
             }
+
+            cellRemoveListener.dispose();
+
         }
     }
 

package/src/browser/service/notebook-model-resolver-service.ts

@@ -14,11 +14,11 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { Emitter, Resource, ResourceProvider, URI } from '@theia/core';
+import { Emitter, Resource, ResourceProvider, UNTITLED_SCHEME, URI } from '@theia/core';
 import { inject, injectable } from '@theia/core/shared/inversify';
 import { UriComponents } from '@theia/core/lib/common/uri';
 import { FileService } from '@theia/filesystem/lib/browser/file-service';
-import { CellKind, NotebookData } from '../../common';
+import { NotebookData } from '../../common';
 import { NotebookModel } from '../view-model/notebook-model';
 import { NotebookService } from './notebook-service';
 import { NotebookTypeRegistry } from '../notebook-type-registry';
@@ -28,6 +28,7 @@ import { match } from '@theia/core/lib/common/glob';
 export interface UntitledResource {
     untitledResource: URI | undefined
 }
+
 @injectable()
 export class NotebookModelResolverService {
 
@@ -49,14 +50,15 @@ export class NotebookModelResolverService {
     readonly onDidSaveNotebook = this.onDidSaveNotebookEmitter.event;
 
     async resolve(resource: URI, viewType?: string): Promise<NotebookModel> {
-
+        const existingModel = this.notebookService.getNotebookEditorModel(resource);
         if (!viewType) {
-            const existingViewType = this.notebookService.getNotebookEditorModel(resource)?.viewType;
-            if (existingViewType) {
-                viewType = existingViewType;
+            if (existingModel) {
+                return existingModel;
             } else {
                 viewType = this.findViewTypeForResource(resource);
             }
+        } else if (existingModel?.viewType === viewType) {
+            return existingModel;
         }
 
         if (!viewType) {
@@ -86,7 +88,7 @@ export class NotebookModelResolverService {
             const suffix = this.getPossibleFileEnding(notebookTypeInfo.selector ?? []) ?? '';
             for (let counter = 1; ; counter++) {
                 const candidate = new URI()
-                    .withScheme('untitled')
+                    .withScheme(UNTITLED_SCHEME)
                     .withPath(`Untitled-notebook-${counter}${suffix}`)
                     .withQuery(viewType);
                 if (!this.notebookService.getNotebookEditorModel(candidate)) {
@@ -94,7 +96,7 @@ export class NotebookModelResolverService {
                     break;
                 }
             }
-        } else if (arg.untitledResource.scheme === 'untitled') {
+        } else if (arg.untitledResource.scheme === UNTITLED_SCHEME) {
             resource = arg.untitledResource;
         } else {
             throw new Error('Invalid untitled resource: ' + arg.untitledResource.toString() + ' untitled resources with associated file path are not supported yet');
@@ -106,18 +108,10 @@ export class NotebookModelResolverService {
         return this.resolve(resource, viewType);
     }
 
-    protected async resolveExistingNotebookData(resource: Resource, viewType: string): Promise<NotebookData> {
+    async resolveExistingNotebookData(resource: Resource, viewType: string): Promise<NotebookData> {
         if (resource.uri.scheme === 'untitled') {
-
             return {
-                cells: [
-                    {
-                        cellKind: CellKind.Markup,
-                        language: 'markdown',
-                        outputs: [],
-                        source: ''
-                    }
-                ],
+                cells: [],
                 metadata: {}
             };
         } else {

package/src/browser/service/notebook-monaco-text-model-service.ts

@@ -31,7 +31,7 @@ export class NotebookMonacoTextModelService {
     protected readonly monacoTextModelService: MonacoTextModelService;
 
     protected readonly cellmodels = new ReferenceCollection<string, MonacoEditorModel>(
-        uri => this.monacoTextModelService.createUnmangedModel(new URI(uri))
+        uri => this.monacoTextModelService.createUnmanagedModel(new URI(uri))
     );
 
     getOrCreateNotebookCellModelReference(uri: URI): Promise<Reference<MonacoEditorModel>> {
@@ -39,7 +39,7 @@ export class NotebookMonacoTextModelService {
     }
 
     async createTextModelsForNotebook(notebook: NotebookModel): Promise<void> {
-        await Promise.all(notebook.cells.map(cell => this.getOrCreateNotebookCellModelReference(cell.uri)));
+        await Promise.all(notebook.cells.map(cell => cell.resolveTextModel()));
     }
 
     get onDidCreateNotebookCellModel(): Event<MonacoEditorModel> {

package/src/browser/service/notebook-service.ts

@@ -110,16 +110,13 @@ export class NotebookService implements Disposable {
     }
 
     async createNotebookModel(data: NotebookData, viewType: string, resource: Resource): Promise<NotebookModel> {
-        const serializer = this.notebookProviders.get(viewType)?.serializer;
-        if (!serializer) {
-            throw new Error('no notebook serializer for ' + viewType);
-        }
-
+        const dataProvider = await this.getNotebookDataProvider(viewType);
+        const serializer = dataProvider.serializer;
         const model = this.notebookModelFactory({ data, resource, viewType, serializer });
         this.notebookModels.set(resource.uri.toString(), model);
         // Resolve cell text models right after creating the notebook model
         // This ensures that all text models are available in the plugin host
-        this.textModelService.createTextModelsForNotebook(model);
+        await this.textModelService.createTextModelsForNotebook(model);
         this.didAddNotebookDocumentEmitter.fire(model);
         model.onDidDispose(() => {
             this.notebookModels.delete(resource.uri.toString());
@@ -129,13 +126,11 @@ export class NotebookService implements Disposable {
     }
 
     async getNotebookDataProvider(viewType: string): Promise<NotebookProviderInfo> {
-        await this.ready.promise;
-
-        const result = await this.waitForNotebookProvider(viewType);
-        if (!result) {
+        try {
+            return await this.waitForNotebookProvider(viewType);
+        } catch {
             throw new Error(`No provider registered for view type: '${viewType}'`);
         }
-        return result;
     }
 
     /**
@@ -143,11 +138,12 @@ export class NotebookService implements Disposable {
      * It takes a few seconds for the plugin host to start so that notebook data providers can be registered.
      * This methods waits until the notebook provider is registered.
      */
-    protected async waitForNotebookProvider(type: string): Promise<NotebookProviderInfo | undefined> {
-        if (this.notebookProviders.has(type)) {
-            return this.notebookProviders.get(type);
+    protected waitForNotebookProvider(type: string): Promise<NotebookProviderInfo> {
+        const existing = this.notebookProviders.get(type);
+        if (existing) {
+            return Promise.resolve(existing);
         }
-        const deferred = new Deferred<NotebookProviderInfo | undefined>();
+        const deferred = new Deferred<NotebookProviderInfo>();
         // 20 seconds of timeout
         const timeoutDuration = 20_000;
 
@@ -161,7 +157,12 @@ export class NotebookService implements Disposable {
             if (viewType === type) {
                 clearTimeout(timeout);
                 disposable.dispose();
-                deferred.resolve(this.notebookProviders.get(type));
+                const newProvider = this.notebookProviders.get(type);
+                if (!newProvider) {
+                    deferred.reject(new Error(`Notebook provider for type ${type} is invalid`));
+                } else {
+                    deferred.resolve(newProvider);
+                }
             }
         });
         timeout = setTimeout(() => {
@@ -170,7 +171,9 @@ export class NotebookService implements Disposable {
             deferred.reject(new Error(`Timed out while waiting for notebook serializer for type ${type} to be registered`));
         }, timeoutDuration);
 
-        await Promise.all(this.willUseNotebookSerializerEmitter.fire(type));
+        this.ready.promise.then(() => {
+            this.willUseNotebookSerializerEmitter.fire(type);
+        });
 
         return deferred.promise;
     }