@theia/plugin-ext 1.46.1 → 1.47.0

package/src/main/browser/data-transfer/data-transfer-type-converters.ts

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { IDataTransferItem, VSDataTransfer } from '@theia/monaco-editor-core/esm/vs/base/common/dataTransfer';
+import { IDataTransferItem, IReadonlyVSDataTransfer } from '@theia/monaco-editor-core/esm/vs/base/common/dataTransfer';
 import { DataTransferDTO, DataTransferItemDTO } from '../../../common/plugin-api-rpc-model';
 import { URI } from '../../../plugin/types-impl';
 
@@ -24,7 +24,6 @@ export namespace DataTransferItem {
 
         if (mime === 'text/uri-list') {
             return {
-                id: item.id,
                 asString: '',
                 fileData: undefined,
                 uriListData: serializeUriList(stringValue),
@@ -33,9 +32,8 @@ export namespace DataTransferItem {
 
         const fileValue = item.asFile();
         return {
-            id: item.id,
             asString: stringValue,
-            fileData: fileValue ? { name: fileValue.name, uri: fileValue.uri } : undefined,
+            fileData: fileValue ? { id: fileValue.id, name: fileValue.name, uri: fileValue.uri } : undefined,
         };
     }
 
@@ -57,10 +55,10 @@ export namespace DataTransferItem {
 }
 
 export namespace DataTransfer {
-    export async function toDataTransferDTO(value: VSDataTransfer): Promise<DataTransferDTO> {
+    export async function toDataTransferDTO(value: IReadonlyVSDataTransfer): Promise<DataTransferDTO> {
         return {
             items: await Promise.all(
-                Array.from(value.entries())
+                Array.from(value)
                     .map(
                         async ([mime, item]) => [mime, await DataTransferItem.from(mime, item)]
                     )

package/src/main/browser/editors-and-documents-main.ts

@@ -30,8 +30,9 @@ import { EditorModelService } from './text-editor-model-service';
 import { MonacoEditorModel } from '@theia/monaco/lib/browser/monaco-editor-model';
 import { MonacoEditor } from '@theia/monaco/lib/browser/monaco-editor';
 import { TextEditorMain } from './text-editor-main';
-import { DisposableCollection, Emitter } from '@theia/core';
+import { DisposableCollection, Emitter, URI } from '@theia/core';
 import { EditorManager, EditorWidget } from '@theia/editor/lib/browser';
+import { SaveResourceService } from '@theia/core/lib/browser/save-resource-service';
 
 export class EditorsAndDocumentsMain implements Disposable {
 
@@ -41,7 +42,8 @@ export class EditorsAndDocumentsMain implements Disposable {
     private readonly textEditors = new Map<string, TextEditorMain>();
 
     private readonly modelService: EditorModelService;
-    private readonly editorService: EditorManager;
+    private readonly editorManager: EditorManager;
+    private readonly saveResourceService: SaveResourceService;
 
     private readonly onTextEditorAddEmitter = new Emitter<TextEditorMain[]>();
     private readonly onTextEditorRemoveEmitter = new Emitter<string[]>();
@@ -60,10 +62,11 @@ export class EditorsAndDocumentsMain implements Disposable {
     constructor(rpc: RPCProtocol, container: interfaces.Container) {
         this.proxy = rpc.getProxy(MAIN_RPC_CONTEXT.EDITORS_AND_DOCUMENTS_EXT);
 
-        this.editorService = container.get(EditorManager);
+        this.editorManager = container.get(EditorManager);
         this.modelService = container.get(EditorModelService);
+        this.saveResourceService = container.get(SaveResourceService);
 
-        this.stateComputer = new EditorAndDocumentStateComputer(d => this.onDelta(d), this.editorService, this.modelService);
+        this.stateComputer = new EditorAndDocumentStateComputer(d => this.onDelta(d), this.editorManager, this.modelService);
         this.toDispose.push(this.stateComputer);
         this.toDispose.push(this.onTextEditorAddEmitter);
         this.toDispose.push(this.onTextEditorRemoveEmitter);
@@ -167,12 +170,31 @@ export class EditorsAndDocumentsMain implements Disposable {
         return this.textEditors.get(id);
     }
 
+    async save(uri: URI): Promise<URI | undefined> {
+        const editor = await this.editorManager.getByUri(uri);
+        if (!editor) {
+            return undefined;
+        }
+        return this.saveResourceService.save(editor);
+    }
+
+    async saveAs(uri: URI): Promise<URI | undefined> {
+        const editor = await this.editorManager.getByUri(uri);
+        if (!editor) {
+            return undefined;
+        }
+        if (!this.saveResourceService.canSaveAs(editor)) {
+            return undefined;
+        }
+        return this.saveResourceService.saveAs(editor);
+    }
+
     saveAll(includeUntitled?: boolean): Promise<boolean> {
         return this.modelService.saveAll(includeUntitled);
     }
 
     hideEditor(id: string): Promise<void> {
-        for (const editorWidget of this.editorService.all) {
+        for (const editorWidget of this.editorManager.all) {
             const monacoEditor = MonacoEditor.get(editorWidget);
             if (monacoEditor) {
                 if (id === new EditorSnapshot(monacoEditor).id) {

package/src/main/browser/file-system-main-impl.ts

@@ -35,9 +35,10 @@ import { UriComponents } from '../../common/uri-components';
 import {
     FileSystemProviderCapabilities, Stat, FileType, FileSystemProviderErrorCode, FileOverwriteOptions, FileDeleteOptions, FileOpenOptions, FileWriteOptions, WatchOptions,
     FileSystemProviderWithFileReadWriteCapability, FileSystemProviderWithOpenReadWriteCloseCapability, FileSystemProviderWithFileFolderCopyCapability,
-    FileStat, FileChange, FileOperationError, FileOperationResult
+    FileStat, FileChange, FileOperationError, FileOperationResult, ReadOnlyMessageFileSystemProvider
 } from '@theia/filesystem/lib/common/files';
 import { FileService } from '@theia/filesystem/lib/browser/file-service';
+import { MarkdownString } from '../../common/plugin-api-rpc-model';
 
 type IDisposable = Disposable;
 
@@ -66,8 +67,8 @@ export class FileSystemMainImpl implements FileSystemMain, Disposable {
         this._disposables.dispose();
     }
 
-    $registerFileSystemProvider(handle: number, scheme: string, capabilities: FileSystemProviderCapabilities): void {
-        this._fileProvider.set(handle, new RemoteFileSystemProvider(this._fileService, scheme, capabilities, handle, this._proxy));
+    $registerFileSystemProvider(handle: number, scheme: string, capabilities: FileSystemProviderCapabilities, readonlyMessage?: MarkdownString): void {
+        this._fileProvider.set(handle, new RemoteFileSystemProvider(this._fileService, scheme, capabilities, handle, this._proxy, readonlyMessage));
     }
 
     $unregisterProvider(handle: number): void {
@@ -163,7 +164,7 @@ export class FileSystemMainImpl implements FileSystemMain, Disposable {
 
 }
 
-class RemoteFileSystemProvider implements FileSystemProviderWithFileReadWriteCapability, FileSystemProviderWithOpenReadWriteCloseCapability, FileSystemProviderWithFileFolderCopyCapability {
+class RemoteFileSystemProvider implements FileSystemProviderWithFileReadWriteCapability, FileSystemProviderWithOpenReadWriteCloseCapability, FileSystemProviderWithFileFolderCopyCapability, ReadOnlyMessageFileSystemProvider {
 
     private readonly _onDidChange = new Emitter<readonly FileChange[]>();
     private readonly _registration: IDisposable;
@@ -174,12 +175,15 @@ class RemoteFileSystemProvider implements FileSystemProviderWithFileReadWriteCap
     readonly capabilities: FileSystemProviderCapabilities;
     readonly onDidChangeCapabilities: Event<void> = Event.None;
 
+    readonly onDidChangeReadOnlyMessage: Event<MarkdownString | undefined> = Event.None;
+
     constructor(
         fileService: FileService,
         scheme: string,
         capabilities: FileSystemProviderCapabilities,
         private readonly _handle: number,
-        private readonly _proxy: FileSystemExt
+        private readonly _proxy: FileSystemExt,
+        public readonly readOnlyMessage: MarkdownString | undefined = undefined
     ) {
         this.capabilities = capabilities;
         this._registration = fileService.registerProvider(scheme, this);

package/src/main/browser/languages-main.ts

@@ -42,7 +42,7 @@ import { injectable, inject } from '@theia/core/shared/inversify';
 import {
     SerializedDocumentFilter, MarkerData, Range, RelatedInformation,
     MarkerSeverity, DocumentLink, WorkspaceSymbolParams, CodeAction, CompletionDto,
-    CodeActionProviderDocumentation, InlayHint, InlayHintLabelPart, CodeActionContext, DocumentDropEditProviderMetadata
+    CodeActionProviderDocumentation, InlayHint, InlayHintLabelPart, CodeActionContext, DocumentDropEditProviderMetadata, SignatureHelpContext
 } from '../../common/plugin-api-rpc-model';
 import { RPCProtocol } from '../../common/rpc-protocol';
 import { MonacoLanguages, WorkspaceSymbolProvider } from '@theia/monaco/lib/browser/monaco-languages';
@@ -84,7 +84,7 @@ import {
 import { ITextModel } from '@theia/monaco-editor-core/esm/vs/editor/common/model';
 import { CodeActionTriggerKind, SnippetString } from '../../plugin/types-impl';
 import { DataTransfer } from './data-transfer/data-transfer-type-converters';
-import { VSDataTransfer } from '@theia/monaco-editor-core/esm/vs/base/common/dataTransfer';
+import { IReadonlyVSDataTransfer } from '@theia/monaco-editor-core/esm/vs/base/common/dataTransfer';
 import { FileUploadService } from '@theia/filesystem/lib/browser/file-upload-service';
 
 /**
@@ -647,7 +647,9 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
     protected async provideSignatureHelp(handle: number, model: monaco.editor.ITextModel,
         position: monaco.Position, token: monaco.CancellationToken,
         context: monaco.languages.SignatureHelpContext): Promise<monaco.languages.ProviderResult<monaco.languages.SignatureHelpResult>> {
-        const value = await this.proxy.$provideSignatureHelp(handle, model.uri, position, context, token);
+
+        // need to cast because of vscode issue https://github.com/microsoft/vscode/issues/190584
+        const value = await this.proxy.$provideSignatureHelp(handle, model.uri, position, context as SignatureHelpContext, token);
         if (!value) {
             return undefined;
         }
@@ -749,7 +751,7 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
     }
 
     protected async provideDocumentDropEdits(handle: number, model: ITextModel, position: monaco.IPosition,
-        dataTransfer: VSDataTransfer, token: CancellationToken): Promise<DocumentOnDropEdit | undefined> {
+        dataTransfer: IReadonlyVSDataTransfer, token: CancellationToken): Promise<DocumentOnDropEdit | undefined> {
         await this.fileUploadService.upload(new URI(), { source: dataTransfer, leaveInTemp: true });
         const edit = await this.proxy.$provideDocumentDropEdits(handle, model.uri, position, await DataTransfer.toDataTransferDTO(dataTransfer), token);
         if (edit) {
@@ -759,6 +761,7 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
                 // yieldTo: edit.yieldTo?.map(yTo => {
                 //      return 'mimeType' in yTo ? yTo : { providerId: DocumentOnDropEditAdapter.toInternalProviderId(yTo.extensionId, yTo.providerId) };
                 // }),
+                label: 'no label',
                 insertText: edit.insertText instanceof SnippetString ? { snippet: edit.insertText.value } : edit.insertText,
                 additionalEdit: toMonacoWorkspaceEdit(edit?.additionalEdit)
             };
@@ -888,7 +891,8 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
                 };
             },
             resolveInlayHint: async (hint, token): Promise<monaco.languages.InlayHint | undefined> => {
-                const dto: InlayHintDto = hint;
+                // need to cast because of vscode issue https://github.com/microsoft/vscode/issues/190584
+                const dto: InlayHintDto = hint as InlayHintDto;
                 if (typeof dto.cacheId !== 'number') {
                     return hint;
                 }

package/src/main/browser/main-context.ts

@@ -45,7 +45,6 @@ import { EditorModelService } from './text-editor-model-service';
 import { OpenerService } from '@theia/core/lib/browser/opener-service';
 import { ApplicationShell } from '@theia/core/lib/browser/shell/application-shell';
 import { MonacoBulkEditService } from '@theia/monaco/lib/browser/monaco-bulk-edit-service';
-import { MonacoEditorService } from '@theia/monaco/lib/browser/monaco-editor-service';
 import { MainFileSystemEventService } from './main-file-system-event-service';
 import { LabelServiceMainImpl } from './label-service-main';
 import { TimelineMainImpl } from './timeline-main';
@@ -115,8 +114,7 @@ export function setUpPluginApi(rpc: RPCProtocol, container: interfaces.Container
     rpc.set(PLUGIN_RPC_CONTEXT.NOTEBOOK_KERNELS_MAIN, new NotebookKernelsMainImpl(rpc, container));
 
     const bulkEditService = container.get(MonacoBulkEditService);
-    const monacoEditorService = container.get(MonacoEditorService);
-    const editorsMain = new TextEditorsMainImpl(editorsAndDocuments, documentsMain, rpc, bulkEditService, monacoEditorService);
+    const editorsMain = new TextEditorsMainImpl(editorsAndDocuments, documentsMain, rpc, bulkEditService);
     rpc.set(PLUGIN_RPC_CONTEXT.TEXT_EDITORS_MAIN, editorsMain);
 
     // start listening only after all clients are subscribed to events

package/src/main/browser/menus/menus-contribution-handler.ts

@@ -31,7 +31,7 @@ import { PluginMenuCommandAdapter, ReferenceCountingSet } from './plugin-menu-co
 import { ContextKeyExpr } from '@theia/monaco-editor-core/esm/vs/platform/contextkey/common/contextkey';
 import { ContextKeyService } from '@theia/core/lib/browser/context-key-service';
 import { PluginSharedStyle } from '../plugin-shared-style';
-import { ThemeIcon } from '@theia/monaco-editor-core/esm/vs/platform/theme/common/themeService';
+import { ThemeIcon } from '@theia/monaco-editor-core/esm/vs/base/common/themables';
 
 @injectable()
 export class MenusContributionPointHandler {

package/src/main/browser/menus/plugin-menu-command-adapter.ts

@@ -108,7 +108,10 @@ export class PluginMenuCommandAdapter implements MenuCommandAdapter {
             ['timeline/item/context', (...args) => this.toTimelineArgs(...args)],
             ['view/item/context', (...args) => this.toTreeArgs(...args)],
             ['view/title', noArgs],
-            ['webview/context', firstArgOnly]
+            ['webview/context', firstArgOnly],
+            ['extension/context', noArgs],
+            ['terminal/context', noArgs],
+            ['terminal/title/context', noArgs],
         ]).forEach(([contributionPoint, adapter]) => {
             if (adapter) {
                 const paths = codeToTheiaMappings.get(contributionPoint);

package/src/main/browser/menus/vscode-theia-menu-mappings.ts

@@ -33,6 +33,7 @@ import { WEBVIEW_CONTEXT_MENU, WebviewWidget } from '../webview/webview';
 import { EDITOR_LINENUMBER_CONTEXT_MENU } from '@theia/editor/lib/browser/editor-linenumber-contribution';
 import { TEST_VIEW_CONTEXT_MENU } from '@theia/test/lib/browser/view/test-view-contribution';
 import { TEST_RUNS_CONTEXT_MENU } from '@theia/test/lib/browser/view/test-run-view-contribution';
+import { TerminalMenus } from '@theia/terminal/lib/browser/terminal-frontend-contribution';
 
 export const PLUGIN_EDITOR_TITLE_MENU = ['plugin_editor/title'];
 export const PLUGIN_EDITOR_TITLE_RUN_MENU = ['plugin_editor/title/run'];
@@ -61,7 +62,10 @@ export const implementedVSCodeContributionPoints = [
     'testing/message/context',
     'view/item/context',
     'view/title',
-    'webview/context'
+    'webview/context',
+    'extension/context',
+    'terminal/context',
+    'terminal/title/context'
 ] as const;
 
 export type ContributionPoint = (typeof implementedVSCodeContributionPoints)[number];
@@ -89,7 +93,11 @@ export const codeToTheiaMappings = new Map<ContributionPoint, MenuPath[]>([
     ['timeline/item/context', [TIMELINE_ITEM_CONTEXT_MENU]],
     ['view/item/context', [VIEW_ITEM_CONTEXT_MENU]],
     ['view/title', [PLUGIN_VIEW_TITLE_MENU]],
-    ['webview/context', [WEBVIEW_CONTEXT_MENU]]
+    ['webview/context', [WEBVIEW_CONTEXT_MENU]],
+    ['extension/context', [['extensions_context_menu', '3_contribution']]],
+    ['terminal/context', [TerminalMenus.TERMINAL_CONTRIBUTIONS]],
+    ['terminal/title/context', [TerminalMenus.TERMINAL_TITLE_CONTRIBUTIONS]]
+
 ]);
 
 type CodeEditorWidget = EditorWidget | WebviewWidget;

package/src/main/browser/notebooks/notebook-documents-and-editors-main.ts

@@ -31,7 +31,6 @@ import { NotebookEditorsMainImpl } from './notebook-editors-main';
 import { NotebookDocumentsMainImpl } from './notebook-documents-main';
 import { diffMaps, diffSets } from '../../../common/collections';
 import { Mutex } from 'async-mutex';
-import throttle = require('@theia/core/shared/lodash.throttle');
 
 interface NotebookAndEditorDelta {
     removedDocuments: UriComponents[];
@@ -107,12 +106,12 @@ export class NotebooksAndEditorsMain implements NotebookDocumentsAndEditorsMain
         this.notebookEditorService = container.get(NotebookEditorWidgetService);
         this.WidgetManager = container.get(WidgetManager);
 
-        this.notebookService.onDidAddNotebookDocument(async () => this.throttleStateUpdate(), this, this.disposables);
-        this.notebookService.onDidRemoveNotebookDocument(async () => this.throttleStateUpdate(), this, this.disposables);
+        this.notebookService.onDidAddNotebookDocument(async () => this.updateState(), this, this.disposables);
+        this.notebookService.onDidRemoveNotebookDocument(async () => this.updateState(), this, this.disposables);
         // this.WidgetManager.onActiveEditorChanged(() => this.updateState(), this, this.disposables);
         this.notebookEditorService.onDidAddNotebookEditor(async editor => this.handleEditorAdd(editor), this, this.disposables);
         this.notebookEditorService.onDidRemoveNotebookEditor(async editor => this.handleEditorRemove(editor), this, this.disposables);
-        this.notebookEditorService.onDidChangeFocusedEditor(async editor => this.throttleStateUpdate(editor), this, this.disposables);
+        this.notebookEditorService.onDidChangeFocusedEditor(async editor => this.updateState(editor), this, this.disposables);
     }
 
     dispose(): void {
@@ -130,18 +129,16 @@ export class NotebooksAndEditorsMain implements NotebookDocumentsAndEditorsMain
         } else {
             this.editorListeners.set(editor.id, [disposable]);
         }
-        await this.throttleStateUpdate();
+        await this.updateState();
     }
 
     private handleEditorRemove(editor: NotebookEditorWidget): void {
         const listeners = this.editorListeners.get(editor.id);
         listeners?.forEach(listener => listener.dispose());
         this.editorListeners.delete(editor.id);
-        this.throttleStateUpdate();
+        this.updateState();
     }
 
-    private throttleStateUpdate = throttle((focusedEditor?: NotebookEditorWidget) => this.updateState(focusedEditor), 100);
-
     private async updateState(focusedEditor?: NotebookEditorWidget): Promise<void> {
         await this.updateMutex.runExclusive(async () => this.doUpdateState(focusedEditor));
     }

package/src/main/browser/notebooks/notebook-kernels-main.ts

@@ -23,7 +23,10 @@ import { UriComponents } from '@theia/core/lib/common/uri';
 import { LanguageService } from '@theia/core/lib/browser/language-service';
 import { CellExecuteUpdateDto, CellExecutionCompleteDto, MAIN_RPC_CONTEXT, NotebookKernelDto, NotebookKernelsExt, NotebookKernelsMain } from '../../../common';
 import { RPCProtocol } from '../../../common/rpc-protocol';
-import { CellExecution, NotebookExecutionStateService, NotebookKernelChangeEvent, NotebookKernelService, NotebookService } from '@theia/notebook/lib/browser';
+import {
+    CellExecution, NotebookEditorWidgetService, NotebookExecutionStateService,
+    NotebookKernelChangeEvent, NotebookKernelService, NotebookService
+} from '@theia/notebook/lib/browser';
 import { combinedDisposable } from '@theia/monaco-editor-core/esm/vs/base/common/lifecycle';
 import { interfaces } from '@theia/core/shared/inversify';
 import { NotebookKernelSourceAction } from '@theia/notebook/lib/common';
@@ -54,7 +57,7 @@ abstract class NotebookKernel {
         return this.preloads.map(p => p.provides).flat();
     }
 
-    constructor(data: NotebookKernelDto, private languageService: LanguageService) {
+    constructor(public readonly handle: number, data: NotebookKernelDto, private languageService: LanguageService) {
         this.id = data.id;
         this.viewType = data.notebookType;
         this.extensionId = data.extensionId;
@@ -65,6 +68,7 @@ abstract class NotebookKernel {
         this.detail = data.detail;
         this.supportedLanguages = (data.supportedLanguages && data.supportedLanguages.length > 0) ? data.supportedLanguages : languageService.languages.map(lang => lang.id);
         this.implementsExecutionOrder = data.supportsExecutionOrder ?? false;
+        this.localResourceRoot = URI.fromComponents(data.extensionLocation);
         this.preloads = data.preloads?.map(u => ({ uri: URI.fromComponents(u.uri), provides: u.provides })) ?? [];
     }
 
@@ -125,6 +129,7 @@ export class NotebookKernelsMainImpl implements NotebookKernelsMain {
     private notebookService: NotebookService;
     private languageService: LanguageService;
     private notebookExecutionStateService: NotebookExecutionStateService;
+    private notebookEditorWidgetService: NotebookEditorWidgetService;
 
     private readonly executions = new Map<number, CellExecution>();
 
@@ -138,10 +143,46 @@ export class NotebookKernelsMainImpl implements NotebookKernelsMain {
         this.notebookExecutionStateService = container.get(NotebookExecutionStateService);
         this.notebookService = container.get(NotebookService);
         this.languageService = container.get(LanguageService);
+        this.notebookEditorWidgetService = container.get(NotebookEditorWidgetService);
+
+        this.notebookEditorWidgetService.onDidAddNotebookEditor(editor => {
+            editor.onDidRecieveKernelMessage(async message => {
+                const kernel = this.notebookKernelService.getSelectedOrSuggestedKernel(editor.model!);
+                if (kernel) {
+                    this.proxy.$acceptKernelMessageFromRenderer(kernel.handle, editor.id, message);
+                }
+            });
+        });
     }
 
-    $postMessage(handle: number, editorId: string | undefined, message: unknown): Promise<boolean> {
-        throw new Error('Method not implemented.');
+    async $postMessage(handle: number, editorId: string | undefined, message: unknown): Promise<boolean> {
+        const tuple = this.kernels.get(handle);
+        if (!tuple) {
+            throw new Error('kernel already disposed');
+        }
+        const [kernel] = tuple;
+        let didSend = false;
+        for (const editor of this.notebookEditorWidgetService.getNotebookEditors()) {
+            if (!editor.model) {
+                continue;
+            }
+            if (this.notebookKernelService.getMatchingKernel(editor.model).selected !== kernel) {
+                // different kernel
+                continue;
+            }
+            if (editorId === undefined) {
+                // all editors
+                editor.postKernelMessage(message);
+                didSend = true;
+            } else if (editor.id === editorId) {
+                // selected editors
+                editor.postKernelMessage(message);
+                didSend = true;
+                break;
+            }
+        }
+        return didSend;
+
     }
 
     async $addKernel(handle: number, data: NotebookKernelDto): Promise<void> {
@@ -153,7 +194,7 @@ export class NotebookKernelsMainImpl implements NotebookKernelsMain {
             async cancelNotebookCellExecution(uri: URI, handles: number[]): Promise<void> {
                 await that.proxy.$cancelCells(handle, uri.toComponents(), handles);
             }
-        }(data, this.languageService);
+        }(handle, data, this.languageService);
 
         const listener = this.notebookKernelService.onDidChangeSelectedKernel(e => {
             if (e.oldKernel === kernel.id) {

package/src/main/browser/notebooks/renderers/cell-output-webview.tsx

@@ -20,8 +20,11 @@
 
 import * as React from '@theia/core/shared/react';
 import { inject, injectable, interfaces, postConstruct } from '@theia/core/shared/inversify';
-import { NotebookRendererMessagingService, CellOutputWebview, NotebookRendererRegistry, NotebookEditorWidgetService, NotebookCellOutputsSplice } from '@theia/notebook/lib/browser';
-import { v4 } from 'uuid';
+import { generateUuid } from '@theia/core/lib/common/uuid';
+import {
+    NotebookRendererMessagingService, CellOutputWebview, NotebookRendererRegistry,
+    NotebookEditorWidgetService, NotebookCellOutputsSplice, NOTEBOOK_EDITOR_ID_PREFIX, NotebookKernelService, NotebookEditorWidget
+} from '@theia/notebook/lib/browser';
 import { NotebookCellModel } from '@theia/notebook/lib/browser/view-model/notebook-cell-model';
 import { WebviewWidget } from '../../webview/webview';
 import { Message, WidgetManager } from '@theia/core/lib/browser';
@@ -31,12 +34,15 @@ import { ChangePreferredMimetypeMessage, FromWebviewMessage, OutputChangedMessag
 import { CellUri } from '@theia/notebook/lib/common';
 import { Disposable, DisposableCollection, nls, QuickPickService } from '@theia/core';
 import { NotebookCellOutputModel } from '@theia/notebook/lib/browser/view-model/notebook-cell-output-model';
+import { NotebookModel } from '@theia/notebook/lib/browser/view-model/notebook-model';
 
 const CellModel = Symbol('CellModel');
+const Notebook = Symbol('NotebookModel');
 
-export function createCellOutputWebviewContainer(ctx: interfaces.Container, cell: NotebookCellModel): interfaces.Container {
+export function createCellOutputWebviewContainer(ctx: interfaces.Container, cell: NotebookCellModel, notebook: NotebookModel): interfaces.Container {
     const child = ctx.createChild();
     child.bind(CellModel).toConstantValue(cell);
+    child.bind(Notebook).toConstantValue(notebook);
     child.bind(CellOutputWebviewImpl).toSelf().inSingletonScope();
     return child;
 }
@@ -50,6 +56,9 @@ export class CellOutputWebviewImpl implements CellOutputWebview, Disposable {
     @inject(CellModel)
     protected readonly cell: NotebookCellModel;
 
+    @inject(Notebook)
+    protected readonly notebook: NotebookModel;
+
     @inject(WidgetManager)
     protected readonly widgetManager: WidgetManager;
 
@@ -62,10 +71,15 @@ export class CellOutputWebviewImpl implements CellOutputWebview, Disposable {
     @inject(NotebookEditorWidgetService)
     protected readonly notebookEditorWidgetService: NotebookEditorWidgetService;
 
+    @inject(NotebookKernelService)
+    protected readonly notebookKernelService: NotebookKernelService;
+
     @inject(QuickPickService)
     protected readonly quickPickService: QuickPickService;
 
-    readonly id = v4();
+    readonly id = generateUuid();
+
+    protected editor: NotebookEditorWidget | undefined;
 
     protected readonly elementRef = React.createRef<HTMLDivElement>();
     protected outputPresentationListeners: DisposableCollection = new DisposableCollection();
@@ -76,11 +90,30 @@ export class CellOutputWebviewImpl implements CellOutputWebview, Disposable {
 
     @postConstruct()
     protected async init(): Promise<void> {
+        this.editor = this.notebookEditorWidgetService.getNotebookEditor(NOTEBOOK_EDITOR_ID_PREFIX + CellUri.parse(this.cell.uri)?.notebook);
+
         this.toDispose.push(this.cell.onDidChangeOutputs(outputChange => this.updateOutput(outputChange)));
         this.toDispose.push(this.cell.onDidChangeOutputItems(output => {
-            this.updateOutput({start: this.cell.outputs.findIndex(o => o.outputId === output.outputId), deleteCount: 1, newOutputs: [output]});
+            this.updateOutput({ start: this.cell.outputs.findIndex(o => o.outputId === output.outputId), deleteCount: 1, newOutputs: [output] });
         }));
 
+        if (this.editor) {
+            this.toDispose.push(this.editor.onDidPostKernelMessage(message => {
+                this.webviewWidget.sendMessage({
+                    type: 'customKernelMessage',
+                    message
+                });
+            }));
+
+            this.toDispose.push(this.editor.onPostRendererMessage(messageObj => {
+                this.webviewWidget.sendMessage({
+                    type: 'customRendererMessage',
+                    ...messageObj
+                });
+            }));
+
+        }
+
         this.webviewWidget = await this.widgetManager.getOrCreateWidget(WebviewWidget.FACTORY_ID, { id: this.id });
         this.webviewWidget.setContentOptions({ allowScripts: true });
         this.webviewWidget.setHTML(await this.createWebviewContent());
@@ -134,8 +167,8 @@ export class CellOutputWebviewImpl implements CellOutputWebview, Disposable {
 
     private async requestOutputPresentationUpdate(output: NotebookCellOutputModel): Promise<void> {
         const selectedMime = await this.quickPickService.show(
-            output.outputs.map(item => ({label: item.mime})),
-            {description: nls.localizeByDefault('Select mimetype to render for current output' )});
+            output.outputs.map(item => ({ label: item.mime })),
+            { description: nls.localizeByDefault('Select mimetype to render for current output') });
         if (selectedMime) {
             this.webviewWidget.sendMessage({
                 type: 'changePreferredMimetype',
@@ -146,35 +179,52 @@ export class CellOutputWebviewImpl implements CellOutputWebview, Disposable {
     }
 
     private handleWebviewMessage(message: FromWebviewMessage): void {
+        if (!this.editor) {
+            throw new Error('No editor found for cell output webview');
+        }
+
         switch (message.type) {
             case 'initialized':
-                this.updateOutput({newOutputs: this.cell.outputs, start: 0, deleteCount: 0});
+                this.updateOutput({ newOutputs: this.cell.outputs, start: 0, deleteCount: 0 });
                 break;
             case 'customRendererMessage':
-                this.messagingService.getScoped('').postMessage(message.rendererId, message.message);
+                this.messagingService.getScoped(this.editor.id).postMessage(message.rendererId, message.message);
                 break;
             case 'didRenderOutput':
                 this.webviewWidget.setIframeHeight(message.contentHeight + 5);
                 break;
             case 'did-scroll-wheel':
-                this.notebookEditorWidgetService.getNotebookEditor(`notebook:${CellUri.parse(this.cell.uri)?.notebook}`)?.node.scrollBy(message.deltaX, message.deltaY);
+                this.editor.node.children[0].children[1].scrollBy(message.deltaX, message.deltaY);
+                break;
+            case 'customKernelMessage':
+                this.editor.recieveKernelMessage(message.message);
                 break;
         }
     }
 
+    getPreloads(): string[] {
+        const kernel = this.notebookKernelService.getSelectedOrSuggestedKernel(this.notebook);
+        const kernelPreloads = kernel?.preloadUris.map(uri => uri.toString()) ?? [];
+
+        const staticPreloads = this.notebookRendererRegistry.staticNotebookPreloads
+            .filter(preload => preload.type === this.notebook.viewType)
+            .map(preload => preload.entrypoint);
+        return kernelPreloads.concat(staticPreloads);
+    }
+
     private async createWebviewContent(): Promise<string> {
         const isWorkspaceTrusted = await this.workspaceTrustService.getWorkspaceTrust();
         const preloads = this.preloadsScriptString(isWorkspaceTrusted);
         const content = `
-            <html>
-                <head>
-                    <meta charset="UTF-8">
-                </head>
-                <body>
-                    <script type="module">${preloads}</script>
-                </body>
-            </html>
-        `;
+                <html>
+                    <head>
+                        <meta charset="UTF-8">
+                    </head>
+                    <body>
+                        <script type="module">${preloads}</script>
+                    </body>
+                </html>
+                `;
         return content;
     }
 
@@ -186,13 +236,14 @@ export class CellOutputWebviewImpl implements CellOutputWebview, Disposable {
                 lineLimit: 30,
                 outputScrolling: false,
                 outputWordWrap: false,
-            }
+            },
+            staticPreloadsData: this.getPreloads()
         };
         // TS will try compiling `import()` in webviewPreloads, so use a helper function instead
         // of using `import(...)` directly
         return `
             const __import = (x) => import(x);
-            (${outputWebviewPreload})(JSON.parse(decodeURIComponent("${encodeURIComponent(JSON.stringify(ctx))}")))`;
+                (${outputWebviewPreload})(JSON.parse(decodeURIComponent("${encodeURIComponent(JSON.stringify(ctx))}")))`;
     }
 
     dispose(): void {