@theia/plugin-ext 1.53.0-next.6 → 1.53.0

package/src/main/browser/custom-editors/custom-editor-opener.tsx

@@ -14,13 +14,13 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { inject } from '@theia/core/shared/inversify';
 import URI from '@theia/core/lib/common/uri';
-import { ApplicationShell, OpenHandler, Widget, WidgetManager, WidgetOpenerOptions } from '@theia/core/lib/browser';
+import { ApplicationShell, DiffUris, OpenHandler, SplitWidget, Widget, WidgetManager, WidgetOpenerOptions } from '@theia/core/lib/browser';
 import { CustomEditor, CustomEditorPriority, CustomEditorSelector } from '../../../common';
 import { CustomEditorWidget } from './custom-editor-widget';
+import { PluginCustomEditorRegistry } from './plugin-custom-editor-registry';
 import { generateUuid } from '@theia/core/lib/common/uuid';
-import { Emitter } from '@theia/core';
+import { DisposableCollection, Emitter } from '@theia/core';
 import { match } from '@theia/core/lib/common/glob';
 
 export class CustomEditorOpener implements OpenHandler {
@@ -33,8 +33,9 @@ export class CustomEditorOpener implements OpenHandler {
 
     constructor(
         private readonly editor: CustomEditor,
-        @inject(ApplicationShell) protected readonly shell: ApplicationShell,
-        @inject(WidgetManager) protected readonly widgetManager: WidgetManager
+        protected readonly shell: ApplicationShell,
+        protected readonly widgetManager: WidgetManager,
+        protected readonly editorRegistry: PluginCustomEditorRegistry
     ) {
         this.id = CustomEditorOpener.toCustomEditorId(this.editor.viewType);
         this.label = this.editor.displayName;
@@ -45,7 +46,13 @@ export class CustomEditorOpener implements OpenHandler {
     }
 
     canHandle(uri: URI): number {
-        if (this.matches(this.editor.selector, uri)) {
+        const { selector } = this.editor;
+        if (DiffUris.isDiffUri(uri)) {
+            const [left, right] = DiffUris.decode(uri);
+            if (this.matches(selector, right) && this.matches(selector, left)) {
+                return this.getPriority();
+            }
+        } else if (this.matches(selector, uri)) {
             return this.getPriority();
         }
         return 0;
@@ -62,34 +69,112 @@ export class CustomEditorOpener implements OpenHandler {
     }
 
     protected readonly pendingWidgetPromises = new Map<string, Promise<CustomEditorWidget>>();
-    async open(uri: URI, options?: WidgetOpenerOptions): Promise<Widget | undefined> {
+    protected async openCustomEditor(uri: URI, options?: WidgetOpenerOptions): Promise<CustomEditorWidget> {
         let widget: CustomEditorWidget | undefined;
-        const widgets = this.widgetManager.getWidgets(CustomEditorWidget.FACTORY_ID) as CustomEditorWidget[];
-        widget = widgets.find(w => w.viewType === this.editor.viewType && w.resource.toString() === uri.toString());
-
-        if (widget?.isVisible) {
-            return this.shell.revealWidget(widget.id);
-        }
-        if (widget?.isAttached) {
-            return this.shell.activateWidget(widget.id);
-        }
-        if (!widget) {
-            const uriString = uri.toString();
-            let widgetPromise = this.pendingWidgetPromises.get(uriString);
-            if (!widgetPromise) {
+        let isNewWidget = false;
+        const uriString = uri.toString();
+        let widgetPromise = this.pendingWidgetPromises.get(uriString);
+        if (widgetPromise) {
+            widget = await widgetPromise;
+        } else {
+            const widgets = this.widgetManager.getWidgets(CustomEditorWidget.FACTORY_ID) as CustomEditorWidget[];
+            widget = widgets.find(w => w.viewType === this.editor.viewType && w.resource.toString() === uriString);
+            if (!widget) {
+                isNewWidget = true;
                 const id = generateUuid();
-                widgetPromise = this.widgetManager.getOrCreateWidget<CustomEditorWidget>(CustomEditorWidget.FACTORY_ID, { id });
+                widgetPromise = this.widgetManager.getOrCreateWidget<CustomEditorWidget>(CustomEditorWidget.FACTORY_ID, { id }).then(async w => {
+                    try {
+                        w.viewType = this.editor.viewType;
+                        w.resource = uri;
+                        await this.editorRegistry.resolveWidget(w);
+                        if (options?.widgetOptions) {
+                            await this.shell.addWidget(w, options.widgetOptions);
+                        }
+                        return w;
+                    } catch (e) {
+                        w.dispose();
+                        throw e;
+                    }
+                }).finally(() => this.pendingWidgetPromises.delete(uriString));
                 this.pendingWidgetPromises.set(uriString, widgetPromise);
                 widget = await widgetPromise;
-                this.pendingWidgetPromises.delete(uriString);
-                widget.viewType = this.editor.viewType;
-                widget.resource = uri;
-                this.onDidOpenCustomEditorEmitter.fire([widget, options]);
             }
         }
+        if (options?.mode === 'activate') {
+            await this.shell.activateWidget(widget.id);
+        } else if (options?.mode === 'reveal') {
+            await this.shell.revealWidget(widget.id);
+        }
+        if (isNewWidget) {
+            this.onDidOpenCustomEditorEmitter.fire([widget, options]);
+        }
         return widget;
     }
 
+    protected async openSideBySide(uri: URI, options?: WidgetOpenerOptions): Promise<Widget | undefined> {
+        const [leftUri, rightUri] = DiffUris.decode(uri);
+        const widget = await this.widgetManager.getOrCreateWidget<SplitWidget>(
+            CustomEditorWidget.SIDE_BY_SIDE_FACTORY_ID, { uri: uri.toString(), viewType: this.editor.viewType });
+        if (!widget.panes.length) { // a new widget
+            const trackedDisposables = new DisposableCollection(widget);
+            try {
+                const createPane = async (paneUri: URI) => {
+                    let pane = await this.openCustomEditor(paneUri);
+                    if (pane.isAttached) {
+                        await this.shell.closeWidget(pane.id);
+                        if (!pane.isDisposed) { // user canceled
+                            return undefined;
+                        }
+                        pane = await this.openCustomEditor(paneUri);
+                    }
+                    return pane;
+                };
+
+                const rightPane = await createPane(rightUri);
+                if (!rightPane) {
+                    trackedDisposables.dispose();
+                    return undefined;
+                }
+                trackedDisposables.push(rightPane);
+
+                const leftPane = await createPane(leftUri);
+                if (!leftPane) {
+                    trackedDisposables.dispose();
+                    return undefined;
+                }
+                trackedDisposables.push(leftPane);
+
+                widget.addPane(leftPane);
+                widget.addPane(rightPane);
+
+                // dispose the widget if either of its panes gets externally disposed
+                leftPane.disposed.connect(() => widget.dispose());
+                rightPane.disposed.connect(() => widget.dispose());
+
+                if (options?.widgetOptions) {
+                    await this.shell.addWidget(widget, options.widgetOptions);
+                }
+            } catch (e) {
+                trackedDisposables.dispose();
+                console.error(e);
+                throw e;
+            }
+        }
+        if (options?.mode === 'activate') {
+            await this.shell.activateWidget(widget.id);
+        } else if (options?.mode === 'reveal') {
+            await this.shell.revealWidget(widget.id);
+        }
+        return widget;
+    }
+
+    async open(uri: URI, options?: WidgetOpenerOptions): Promise<Widget | undefined> {
+        options = { ...options };
+        options.mode ??= 'activate';
+        options.widgetOptions ??= { area: 'main' };
+        return DiffUris.isDiffUri(uri) ? this.openSideBySide(uri, options) : this.openCustomEditor(uri, options);
+    }
+
     matches(selectors: CustomEditorSelector[], resource: URI): boolean {
         return selectors.some(selector => this.selectorMatches(selector, resource));
     }

package/src/main/browser/custom-editors/custom-editor-widget.ts

@@ -17,29 +17,36 @@
 import { injectable, inject, postConstruct } from '@theia/core/shared/inversify';
 import URI from '@theia/core/lib/common/uri';
 import { FileOperation } from '@theia/filesystem/lib/common/files';
-import { ApplicationShell, NavigatableWidget, Saveable, SaveableSource, SaveOptions } from '@theia/core/lib/browser';
+import { ApplicationShell, DelegatingSaveable, NavigatableWidget, Saveable, SaveableSource, SaveOptions } from '@theia/core/lib/browser';
 import { SaveableService } from '@theia/core/lib/browser/saveable-service';
 import { Reference } from '@theia/core/lib/common/reference';
 import { WebviewWidget } from '../webview/webview';
 import { CustomEditorModel } from './custom-editors-main';
+import { CustomEditorWidget as CustomEditorWidgetShape } from '@theia/editor/lib/browser';
 
 @injectable()
-export class CustomEditorWidget extends WebviewWidget implements SaveableSource, NavigatableWidget {
+export class CustomEditorWidget extends WebviewWidget implements CustomEditorWidgetShape, SaveableSource, NavigatableWidget {
     static override FACTORY_ID = 'plugin-custom-editor';
+    static readonly SIDE_BY_SIDE_FACTORY_ID = CustomEditorWidget.FACTORY_ID + '.side-by-side';
 
     override id: string;
     resource: URI;
 
-    protected _modelRef: Reference<CustomEditorModel>;
-    get modelRef(): Reference<CustomEditorModel> {
+    protected _modelRef: Reference<CustomEditorModel | undefined> = { object: undefined, dispose: () => { } };
+    get modelRef(): Reference<CustomEditorModel | undefined> {
         return this._modelRef;
     }
     set modelRef(modelRef: Reference<CustomEditorModel>) {
+        this._modelRef.dispose();
         this._modelRef = modelRef;
+        this.delegatingSaveable.delegate = modelRef.object;
         this.doUpdateContent();
     }
+
+    // ensures that saveable is available even if modelRef.object is undefined
+    protected readonly delegatingSaveable = new DelegatingSaveable();
     get saveable(): Saveable {
-        return this._modelRef.object;
+        return this.delegatingSaveable;
     }
 
     @inject(ApplicationShell)
@@ -60,21 +67,23 @@ export class CustomEditorWidget extends WebviewWidget implements SaveableSource,
     }
 
     undo(): void {
-        this._modelRef.object.undo();
+        this._modelRef.object?.undo();
     }
 
     redo(): void {
-        this._modelRef.object.redo();
+        this._modelRef.object?.redo();
     }
 
     async save(options?: SaveOptions): Promise<void> {
-        await this._modelRef.object.saveCustomEditor(options);
+        await this._modelRef.object?.saveCustomEditor(options);
     }
 
     async saveAs(source: URI, target: URI, options?: SaveOptions): Promise<void> {
-        const result = await this._modelRef.object.saveCustomEditorAs(source, target, options);
-        this.doMove(target);
-        return result;
+        if (this._modelRef.object) {
+            const result = await this._modelRef.object.saveCustomEditorAs(source, target, options);
+            this.doMove(target);
+            return result;
+        }
     }
 
     getResourceUri(): URI | undefined {

package/src/main/browser/custom-editors/custom-editors-main.ts

@@ -24,7 +24,6 @@ import { MAIN_RPC_CONTEXT, CustomEditorsMain, CustomEditorsExt, CustomTextEditor
 import { RPCProtocol } from '../../../common/rpc-protocol';
 import { HostedPluginSupport } from '../../../hosted/browser/hosted-plugin';
 import { PluginCustomEditorRegistry } from './plugin-custom-editor-registry';
-import { CustomEditorWidget } from './custom-editor-widget';
 import { Emitter } from '@theia/core';
 import { UriComponents } from '../../../common/uri-components';
 import { URI } from '@theia/core/shared/vscode-uri';
@@ -39,11 +38,9 @@ import { FileService } from '@theia/filesystem/lib/browser/file-service';
 import { UndoRedoService } from '@theia/editor/lib/browser/undo-redo-service';
 import { WebviewsMainImpl } from '../webviews-main';
 import { WidgetManager } from '@theia/core/lib/browser/widget-manager';
-import { ApplicationShell, DefaultUriLabelProviderContribution, Saveable, SaveOptions, WidgetOpenerOptions } from '@theia/core/lib/browser';
-import { WebviewOptions, WebviewPanelOptions, WebviewPanelShowOptions } from '@theia/plugin';
-import { WebviewWidgetIdentifier } from '../webview/webview';
+import { ApplicationShell, LabelProvider, Saveable, SaveOptions } from '@theia/core/lib/browser';
+import { WebviewPanelOptions } from '@theia/plugin';
 import { EditorPreferences } from '@theia/editor/lib/browser';
-import { ViewColumn, WebviewPanelTargetArea } from '../../../plugin/types-impl';
 
 const enum CustomEditorModelType {
     Custom,
@@ -58,7 +55,7 @@ export class CustomEditorsMainImpl implements CustomEditorsMain, Disposable {
     protected readonly customEditorService: CustomEditorService;
     protected readonly undoRedoService: UndoRedoService;
     protected readonly customEditorRegistry: PluginCustomEditorRegistry;
-    protected readonly labelProvider: DefaultUriLabelProviderContribution;
+    protected readonly labelProvider: LabelProvider;
     protected readonly widgetManager: WidgetManager;
     protected readonly editorPreferences: EditorPreferences;
     private readonly proxy: CustomEditorsExt;
@@ -75,7 +72,7 @@ export class CustomEditorsMainImpl implements CustomEditorsMain, Disposable {
         this.customEditorService = container.get(CustomEditorService);
         this.undoRedoService = container.get(UndoRedoService);
         this.customEditorRegistry = container.get(PluginCustomEditorRegistry);
-        this.labelProvider = container.get(DefaultUriLabelProviderContribution);
+        this.labelProvider = container.get(LabelProvider);
         this.editorPreferences = container.get(EditorPreferences);
         this.widgetManager = container.get(WidgetManager);
         this.proxy = rpc.getProxy(MAIN_RPC_CONTEXT.CUSTOM_EDITORS_EXT);
@@ -111,7 +108,8 @@ export class CustomEditorsMainImpl implements CustomEditorsMain, Disposable {
         const disposables = new DisposableCollection();
 
         disposables.push(
-            this.customEditorRegistry.registerResolver(viewType, async (widget, widgetOpenerOptions) => {
+            this.customEditorRegistry.registerResolver(viewType, async widget => {
+
                 const { resource, identifier } = widget;
                 widget.options = options;
 
@@ -144,13 +142,16 @@ export class CustomEditorsMainImpl implements CustomEditorsMain, Disposable {
                     });
                 }
 
+                this.webviewsMain.hookWebview(widget);
+                widget.title.label = this.labelProvider.getName(resource);
+
                 const _cancellationSource = new CancellationTokenSource();
                 await this.proxy.$resolveWebviewEditor(
                     resource.toComponents(),
                     identifier.id,
                     viewType,
-                    this.labelProvider.getName(resource)!,
-                    widgetOpenerOptions,
+                    widget.title.label,
+                    widget.viewState.position,
                     options,
                     _cancellationSource.token
                 );
@@ -213,66 +214,6 @@ export class CustomEditorsMainImpl implements CustomEditorsMain, Disposable {
         const model = await this.getCustomEditorModel(resourceComponents, viewType);
         model.changeContent();
     }
-
-    async $createCustomEditorPanel(
-        panelId: string,
-        title: string,
-        widgetOpenerOptions: WidgetOpenerOptions | undefined,
-        options: WebviewPanelOptions & WebviewOptions
-    ): Promise<void> {
-        const view = await this.widgetManager.getOrCreateWidget<CustomEditorWidget>(CustomEditorWidget.FACTORY_ID, <WebviewWidgetIdentifier>{ id: panelId });
-        this.webviewsMain.hookWebview(view);
-        view.title.label = title;
-        const { enableFindWidget, retainContextWhenHidden, enableScripts, enableForms, localResourceRoots, ...contentOptions } = options;
-        view.viewColumn = ViewColumn.One; // behaviour might be overridden later using widgetOpenerOptions (if available)
-        view.options = { enableFindWidget, retainContextWhenHidden };
-        view.setContentOptions({
-            allowScripts: enableScripts,
-            allowForms: enableForms,
-            localResourceRoots: localResourceRoots && localResourceRoots.map(root => root.toString()),
-            ...contentOptions,
-            ...view.contentOptions
-        });
-        if (view.isAttached) {
-            if (view.isVisible) {
-                this.shell.revealWidget(view.id);
-            }
-            return;
-        }
-        const showOptions: WebviewPanelShowOptions = {
-            preserveFocus: true
-        };
-
-        if (widgetOpenerOptions) {
-            if (widgetOpenerOptions.mode === 'reveal') {
-                showOptions.preserveFocus = false;
-            }
-
-            if (widgetOpenerOptions.widgetOptions) {
-                let area: WebviewPanelTargetArea;
-                switch (widgetOpenerOptions.widgetOptions.area) {
-                    case 'main':
-                        area = WebviewPanelTargetArea.Main;
-                    case 'left':
-                        area = WebviewPanelTargetArea.Left;
-                    case 'right':
-                        area = WebviewPanelTargetArea.Right;
-                    case 'bottom':
-                        area = WebviewPanelTargetArea.Bottom;
-                    default: // includes 'top' and 'secondaryWindow'
-                        area = WebviewPanelTargetArea.Main;
-                }
-                showOptions.area = area;
-
-                if (widgetOpenerOptions.widgetOptions.mode === 'split-right' ||
-                    widgetOpenerOptions.widgetOptions.mode === 'open-to-right') {
-                    showOptions.viewColumn = ViewColumn.Beside;
-                }
-            }
-        }
-
-        this.webviewsMain.addOrReattachWidget(view, showOptions);
-    }
 }
 
 export interface CustomEditorModel extends Saveable, Disposable {

package/src/main/browser/custom-editors/plugin-custom-editor-registry.ts

@@ -17,16 +17,17 @@
 import { injectable, inject, postConstruct } from '@theia/core/shared/inversify';
 import { CustomEditor, DeployedPlugin } from '../../../common';
 import { Disposable, DisposableCollection } from '@theia/core/lib/common/disposable';
+import { Deferred } from '@theia/core/lib/common/promise-util';
 import { CustomEditorOpener } from './custom-editor-opener';
 import { Emitter } from '@theia/core';
-import { ApplicationShell, DefaultOpenerService, OpenWithService, WidgetManager, WidgetOpenerOptions } from '@theia/core/lib/browser';
+import { ApplicationShell, DefaultOpenerService, OpenWithService, WidgetManager } from '@theia/core/lib/browser';
 import { CustomEditorWidget } from './custom-editor-widget';
 
 @injectable()
 export class PluginCustomEditorRegistry {
     private readonly editors = new Map<string, CustomEditor>();
-    private readonly pendingEditors = new Set<CustomEditorWidget>();
-    private readonly resolvers = new Map<string, (widget: CustomEditorWidget, options?: WidgetOpenerOptions) => void>();
+    private readonly pendingEditors = new Map<CustomEditorWidget, { deferred: Deferred<void>, disposable: Disposable }>();
+    private readonly resolvers = new Map<string, (widget: CustomEditorWidget) => Promise<void>>();
 
     private readonly onWillOpenCustomEditorEmitter = new Emitter<string>();
     readonly onWillOpenCustomEditor = this.onWillOpenCustomEditorEmitter.event;
@@ -74,7 +75,8 @@ export class PluginCustomEditorRegistry {
         const editorOpenHandler = new CustomEditorOpener(
             editor,
             this.shell,
-            this.widgetManager
+            this.widgetManager,
+            this
         );
         toDispose.push(this.defaultOpenerService.addHandler(editorOpenHandler));
         toDispose.push(
@@ -86,30 +88,30 @@ export class PluginCustomEditorRegistry {
                 open: uri => editorOpenHandler.open(uri)
             })
         );
-        toDispose.push(
-            editorOpenHandler.onDidOpenCustomEditor(event => this.resolveWidget(event[0], event[1]))
-        );
         return toDispose;
     }
 
-    resolveWidget = (widget: CustomEditorWidget, options?: WidgetOpenerOptions) => {
+    async resolveWidget(widget: CustomEditorWidget): Promise<void> {
         const resolver = this.resolvers.get(widget.viewType);
         if (resolver) {
-            resolver(widget, options);
+            await resolver(widget);
         } else {
-            this.pendingEditors.add(widget);
+            const deferred = new Deferred<void>();
+            const disposable = widget.onDidDispose(() => this.pendingEditors.delete(widget));
+            this.pendingEditors.set(widget, { deferred, disposable });
             this.onWillOpenCustomEditorEmitter.fire(widget.viewType);
+            return deferred.promise;
         }
     };
 
-    registerResolver(viewType: string, resolver: (widget: CustomEditorWidget, options?: WidgetOpenerOptions) => void): Disposable {
+    registerResolver(viewType: string, resolver: (widget: CustomEditorWidget) => Promise<void>): Disposable {
         if (this.resolvers.has(viewType)) {
             throw new Error(`Resolver for ${viewType} already registered`);
         }
 
-        for (const editorWidget of this.pendingEditors) {
+        for (const [editorWidget, { deferred, disposable }] of this.pendingEditors.entries()) {
             if (editorWidget.viewType === viewType) {
-                resolver(editorWidget);
+                resolver(editorWidget).then(() => deferred.resolve(), err => deferred.reject(err)).finally(() => disposable.dispose());
                 this.pendingEditors.delete(editorWidget);
             }
         }

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

@@ -64,6 +64,7 @@ import { NotebookDocumentsMainImpl } from './notebooks/notebook-documents-main';
 import { NotebookKernelsMainImpl } from './notebooks/notebook-kernels-main';
 import { NotebooksAndEditorsMain } from './notebooks/notebook-documents-and-editors-main';
 import { TestingMainImpl } from './test-main';
+import { UriMainImpl } from './uri-main';
 
 export function setUpPluginApi(rpc: RPCProtocol, container: interfaces.Container): void {
     const authenticationMain = new AuthenticationMainImpl(rpc, container);
@@ -203,4 +204,7 @@ export function setUpPluginApi(rpc: RPCProtocol, container: interfaces.Container
 
     const localizationMain = new LocalizationMainImpl(container);
     rpc.set(PLUGIN_RPC_CONTEXT.LOCALIZATION_MAIN, localizationMain);
+
+    const uriMain = new UriMainImpl(rpc, container);
+    rpc.set(PLUGIN_RPC_CONTEXT.URI_MAIN, uriMain);
 }

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

@@ -107,10 +107,11 @@ export class MenusContributionPointHandler {
                         if (command) {
                             toDispose.push(this.commandAdapter.addCommand(command));
                             targets.forEach(target => {
+
                                 const node = new ActionMenuNode({
                                     commandId: command,
                                     when: item.when,
-                                    order,
+                                    order
                                 }, this.commands);
                                 const parent = this.menuRegistry.getMenuNode(target, group);
                                 toDispose.push(parent.addNode(node));

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

@@ -108,6 +108,7 @@ export class PluginMenuCommandAdapter implements MenuCommandAdapter {
             ['scm/resourceState/context', toScmArgs],
             ['scm/title', () => [this.toScmArg(this.scmService.selectedRepository)]],
             ['testing/message/context', toTestMessageArgs],
+            ['testing/profiles/context', noArgs],
             ['scm/change/title', (...args) => this.toScmChangeArgs(...args)],
             ['timeline/item/context', (...args) => this.toTimelineArgs(...args)],
             ['view/item/context', (...args) => this.toTreeArgs(...args)],

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

@@ -32,7 +32,7 @@ import { COMMENT_CONTEXT, COMMENT_THREAD_CONTEXT, COMMENT_TITLE } from '../comme
 import { VIEW_ITEM_CONTEXT_MENU } from '../view/tree-view-widget';
 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 { PLUGIN_TEST_VIEW_TITLE_MENU, 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';
 
@@ -62,6 +62,7 @@ export const implementedVSCodeContributionPoints = [
     'timeline/item/context',
     'testing/item/context',
     'testing/message/context',
+    'testing/profiles/context',
     'view/item/context',
     'view/title',
     'webview/context',
@@ -93,6 +94,7 @@ export const codeToTheiaMappings = new Map<ContributionPoint, MenuPath[]>([
     ['scm/title', [PLUGIN_SCM_TITLE_MENU]],
     ['testing/item/context', [TEST_VIEW_CONTEXT_MENU]],
     ['testing/message/context', [TEST_RUNS_CONTEXT_MENU]],
+    ['testing/profiles/context', [PLUGIN_TEST_VIEW_TITLE_MENU]],
     ['timeline/item/context', [TIMELINE_ITEM_CONTEXT_MENU]],
     ['view/item/context', [VIEW_ITEM_CONTEXT_MENU]],
     ['view/title', [PLUGIN_VIEW_TITLE_MENU]],

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

@@ -242,7 +242,7 @@ export class NotebooksAndEditorsMain implements NotebookDocumentsAndEditorsMain
         return {
             id: notebookEditor.id,
             documentUri: uri.toComponents(),
-            selections: [],
+            selections: [{ start: 0, end: 0 }],
             visibleRanges: []
         };
     }

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

@@ -21,7 +21,7 @@ import { NotebookModelResolverService } from '@theia/notebook/lib/browser';
 import { NotebookModel } from '@theia/notebook/lib/browser/view-model/notebook-model';
 import { NotebookCellsChangeType } from '@theia/notebook/lib/common';
 import { NotebookMonacoTextModelService } from '@theia/notebook/lib/browser/service/notebook-monaco-text-model-service';
-import { MAIN_RPC_CONTEXT, NotebookCellsChangedEventDto, NotebookDataDto, NotebookDocumentsExt, NotebookDocumentsMain } from '../../../common';
+import { MAIN_RPC_CONTEXT, NotebookCellsChangedEventDto, NotebookDataDto, NotebookDocumentsExt, NotebookDocumentsMain, NotebookRawContentEventDto } from '../../../common';
 import { RPCProtocol } from '../../../common/rpc-protocol';
 import { NotebookDto } from './notebook-dto';
 import { MonacoEditorModel } from '@theia/monaco/lib/browser/monaco-editor-model';
@@ -156,19 +156,39 @@ export class NotebookDocumentsMainImpl implements NotebookDocumentsMain {
         //     ref.dispose();
         // });
 
+        const uriComponents = ref.uri.toComponents();
         // untitled notebooks are dirty by default
-        this.proxy.$acceptDirtyStateChanged(ref.uri.toComponents(), true);
+        this.proxy.$acceptDirtyStateChanged(uriComponents, true);
 
-        // apply content changes... slightly HACKY -> this triggers a change event
+        // apply content changes...
         if (options.content) {
             const data = NotebookDto.fromNotebookDataDto(options.content);
             ref.setData(data);
+
+            // Create and send a change events
+            const rawEvents: NotebookRawContentEventDto[] = [];
+            if (options.content.cells && options.content.cells.length > 0) {
+                rawEvents.push({
+                    kind: NotebookCellsChangeType.ModelChange,
+                    changes: [{ start: 0, deleteCount: 0, newItems: ref.cells.map(NotebookDto.toNotebookCellDto) }]
+                });
+            }
+            if (options.content.metadata) {
+                rawEvents.push({
+                    kind: NotebookCellsChangeType.ChangeDocumentMetadata,
+                    metadata: options.content.metadata
+                });
+            }
+            if (rawEvents.length > 0) {
+                this.proxy.$acceptModelChanged(uriComponents, { versionId: 1, rawEvents }, true);
+            }
         }
-        return ref.uri.toComponents();
+        return uriComponents;
     }
 
     async $tryOpenNotebook(uriComponents: UriComponents): Promise<UriComponents> {
         const uri = URI.fromComponents(uriComponents);
+        await this.notebookModelResolverService.resolve(uri);
         return uri.toComponents();
     }
 

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

@@ -54,12 +54,25 @@ export class NotebookEditorsMainImpl implements NotebookEditorsMain {
         throw new Error('Method not implemented.');
     }
     $trySetSelections(id: string, range: CellRange[]): void {
-        throw new Error('Method not implemented.');
+        if (!this.mainThreadEditors.has(id)) {
+            throw new Error('Editor not found');
+        }
+        const editor = this.mainThreadEditors.get(id);
+        editor?.model?.setSelectedCell(editor.model.cells[range[0].start]);
     }
 
-    handleEditorsAdded(editors: readonly NotebookEditorWidget[]): void {
+    async handleEditorsAdded(editors: readonly NotebookEditorWidget[]): Promise<void> {
         for (const editor of editors) {
             this.mainThreadEditors.set(editor.id, editor);
+            const model = await editor.ready;
+            model.onDidChangeSelectedCell(e => {
+                const newCellIndex = e.cell ? model.cells.indexOf(e.cell) : -1;
+                this.proxy.$acceptEditorPropertiesChanged(editor.id, {
+                    selections: {
+                        selections: newCellIndex >= 0 ? [{ start: newCellIndex, end: newCellIndex }] : []
+                    }
+                });
+            });
         }
     }