@theia/plugin-ext 1.46.1 → 1.47.0

package/src/main/browser/notebooks/renderers/output-webview-internal.ts

@@ -58,6 +58,16 @@ export interface PreloadContext {
     readonly isWorkspaceTrusted: boolean;
     readonly rendererData: readonly webviewCommunication.RendererMetadata[];
     readonly renderOptions: RenderOptions;
+    readonly staticPreloadsData: readonly string[];
+}
+
+interface KernelPreloadContext {
+    readonly onDidReceiveKernelMessage: Event<unknown>;
+    postKernelMessage(data: unknown): void;
+}
+
+interface KernelPreloadModule {
+    activate(ctx: KernelPreloadContext): Promise<void> | void;
 }
 
 export async function outputWebviewPreload(ctx: PreloadContext): Promise<void> {
@@ -98,6 +108,36 @@ export async function outputWebviewPreload(ctx: PreloadContext): Promise<void> {
 
     const settingChange: EmitterLike<RenderOptions> = createEmitter<RenderOptions>();
 
+    const onDidReceiveKernelMessage = createEmitter<unknown>();
+
+    function createKernelContext(): KernelPreloadContext {
+        return Object.freeze({
+            onDidReceiveKernelMessage: onDidReceiveKernelMessage.event,
+            postKernelMessage: (data: unknown) => {
+                theia.postMessage({ type: 'customKernelMessage', message: data });
+            }
+        });
+    }
+
+    async function runKernelPreload(url: string): Promise<void> {
+        try {
+            return activateModuleKernelPreload(url);
+        } catch (e) {
+            console.error(e);
+            throw e;
+        }
+    }
+
+    async function activateModuleKernelPreload(url: string): Promise<void> {
+        const baseUri = window.location.href.replace(/\/webview\/index\.html.*/, '');
+        const module: KernelPreloadModule = (await __import(`${baseUri}/${url}`)) as KernelPreloadModule;
+        if (!module.activate) {
+            console.error(`Notebook preload '${url}' was expected to be a module but it does not export an 'activate' function`);
+            return;
+        }
+        return module.activate(createKernelContext());
+    }
+
     class Output {
         readonly outputId: string;
         renderedItem?: rendererApi.OutputItem;
@@ -160,6 +200,10 @@ export async function outputWebviewPreload(ctx: PreloadContext): Promise<void> {
             if (this.rendererApi) {
                 return this.rendererApi;
             }
+
+            // Preloads need to be loaded before loading renderers.
+            await kernelPreloads.waitForAllCurrent();
+
             const baseUri = window.location.href.replace(/\/webview\/index\.html.*/, '');
             const rendererModule = await __import(`${baseUri}/${this.data.entrypoint.uri}`) as { activate: rendererApi.ActivationFunction };
             this.rendererApi = await rendererModule.activate(this.createRendererContext());
@@ -196,7 +240,9 @@ export async function outputWebviewPreload(ctx: PreloadContext): Promise<void> {
 
             if (this.data.requiresMessaging) {
                 context.onDidReceiveMessage = this.onMessageEvent.event;
-                context.postMessage = message => theia.postMessage({ type: 'customRendererMessage', rendererId: this.data.id, message });
+                context.postMessage = message => {
+                    theia.postMessage({ type: 'customRendererMessage', rendererId: this.data.id, message });
+                };
             }
 
             return Object.freeze(context);
@@ -385,6 +431,42 @@ export async function outputWebviewPreload(ctx: PreloadContext): Promise<void> {
         }
     }();
 
+    const kernelPreloads = new class {
+        private readonly preloads = new Map<string /* uri */, Promise<unknown>>();
+
+        /**
+         * Returns a promise that resolves when the given preload is activated.
+         */
+        public waitFor(uri: string): Promise<unknown> {
+            return this.preloads.get(uri) || Promise.resolve(new Error(`Preload not ready: ${uri}`));
+        }
+
+        /**
+         * Loads a preload.
+         * @param uri URI to load from
+         * @param originalUri URI to show in an error message if the preload is invalid.
+         */
+        public load(uri: string): Promise<unknown> {
+            const promise = Promise.all([
+                runKernelPreload(uri),
+                this.waitForAllCurrent(),
+            ]);
+
+            this.preloads.set(uri, promise);
+            return promise;
+        }
+
+        /**
+         * Returns a promise that waits for all currently-registered preloads to
+         * activate before resolving.
+         */
+        public waitForAllCurrent(): Promise<unknown[]> {
+            return Promise.all([...this.preloads.values()].map(p => p.catch(err => err)));
+        }
+    };
+
+    await Promise.all(ctx.staticPreloadsData.map(preload => kernelPreloads.load(preload)));
+
     function clearOutput(output: Output): void {
         output.clear();
         output.element.remove();
@@ -460,7 +542,6 @@ export async function outputWebviewPreload(ctx: PreloadContext): Promise<void> {
 
     window.addEventListener('message', async rawEvent => {
         const event = rawEvent as ({ data: webviewCommunication.ToWebviewMessage });
-
         switch (event.data.type) {
             case 'updateRenderers':
                 renderers.updateRendererData(event.data.rendererData);
@@ -478,6 +559,16 @@ export async function outputWebviewPreload(ctx: PreloadContext): Promise<void> {
                 clearOutput(outputs.splice(index, 1)[0]);
                 renderers.render(outputs[index], event.data.mimeType, undefined, new AbortController().signal);
                 break;
+            case 'customKernelMessage':
+                onDidReceiveKernelMessage.fire(event.data.message);
+                break;
+            case 'preload': {
+                const resources = event.data.resources;
+                for (const uri of resources) {
+                    kernelPreloads.load(uri);
+                }
+                break;
+            }
         }
     });
     window.addEventListener('wheel', handleWheel);

package/src/main/browser/notebooks/renderers/webview-communication.ts

@@ -49,7 +49,17 @@ export interface ChangePreferredMimetypeMessage {
     readonly mimeType: string;
 }
 
-export type ToWebviewMessage = UpdateRenderersMessage | OutputChangedMessage | ChangePreferredMimetypeMessage | CustomRendererMessage;
+export interface KernelMessage {
+    readonly type: 'customKernelMessage';
+    readonly message: unknown;
+}
+
+export interface PreloadMessage {
+    readonly type: 'preload';
+    readonly resources: string[];
+}
+
+export type ToWebviewMessage = UpdateRenderersMessage | OutputChangedMessage | ChangePreferredMimetypeMessage | CustomRendererMessage | KernelMessage | PreloadMessage;
 
 export interface WebviewInitialized {
     readonly type: 'initialized';
@@ -66,7 +76,7 @@ export interface WheelMessage {
     readonly deltaX: number;
 }
 
-export type FromWebviewMessage = WebviewInitialized | OnDidRenderOutput | WheelMessage | CustomRendererMessage;
+export type FromWebviewMessage = WebviewInitialized | OnDidRenderOutput | WheelMessage | CustomRendererMessage | KernelMessage;
 
 export interface Output {
     id: string

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

@@ -47,13 +47,13 @@ import { PluginIconService } from './plugin-icon-service';
 import { PluginIconThemeService } from './plugin-icon-theme-service';
 import { ContributionProvider } from '@theia/core/lib/common';
 import * as monaco from '@theia/monaco-editor-core';
-import { ThemeIcon } from '@theia/monaco-editor-core/esm/vs/platform/theme/common/themeService';
 import { ContributedTerminalProfileStore, TerminalProfileStore } from '@theia/terminal/lib/browser/terminal-profile-service';
 import { TerminalWidget } from '@theia/terminal/lib/browser/base/terminal-widget';
 import { TerminalService } from '@theia/terminal/lib/browser/base/terminal-service';
 import { PluginTerminalRegistry } from './plugin-terminal-registry';
 import { ContextKeyService } from '@theia/core/lib/browser/context-key-service';
 import { LanguageService } from '@theia/core/lib/browser/language-service';
+import { ThemeIcon } from '@theia/monaco-editor-core/esm/vs/base/common/themables';
 
 @injectable()
 export class PluginContributionHandler {
@@ -447,6 +447,14 @@ export class PluginContributionHandler {
             }
         }
 
+        if (contributions.notebookPreload) {
+            for (const preload of contributions.notebookPreload) {
+                pushContribution(`notebookPreloads.${preload.type}:${preload.entrypoint}`,
+                    () => this.notebookRendererRegistry.registerStaticNotebookPreload(preload.type, preload.entrypoint, PluginPackage.toPluginUrl(plugin.metadata.model, ''))
+                );
+            }
+        }
+
         return toDispose;
     }
 

package/src/main/browser/plugin-ext-frontend-module.ts

@@ -88,6 +88,8 @@ import { TabBarToolbarContribution } from '@theia/core/lib/browser/shell/tab-bar
 import { CellOutputWebviewFactory } from '@theia/notebook/lib/browser';
 import { CellOutputWebviewImpl, createCellOutputWebviewContainer } from './notebooks/renderers/cell-output-webview';
 import { NotebookCellModel } from '@theia/notebook/lib/browser/view-model/notebook-cell-model';
+import { NotebookModel } from '@theia/notebook/lib/browser/view-model/notebook-model';
+import { ArgumentProcessorContribution } from './command-registry-main';
 
 export default new ContainerModule((bind, unbind, isBound, rebind) => {
 
@@ -262,7 +264,9 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
         return provider.createProxy<LanguagePackService>(languagePackServicePath);
     }).inSingletonScope();
 
-    bind(CellOutputWebviewFactory).toFactory(ctx => async (cell: NotebookCellModel) =>
-        createCellOutputWebviewContainer(ctx.container, cell).getAsync(CellOutputWebviewImpl)
+    bind(CellOutputWebviewFactory).toFactory(ctx => async (cell: NotebookCellModel, notebook: NotebookModel) =>
+        createCellOutputWebviewContainer(ctx.container, cell, notebook).getAsync(CellOutputWebviewImpl)
     );
+
+    bindContributionProvider(bind, ArgumentProcessorContribution);
 });

package/src/main/browser/plugin-icon-service.ts

@@ -14,18 +14,13 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { asCSSPropertyValue } from '@theia/monaco-editor-core/esm/vs/base/browser/dom';
 import { Endpoint } from '@theia/core/lib/browser';
 import { Disposable, DisposableCollection } from '@theia/core/lib/common/disposable';
-import { getIconRegistry } from '@theia/monaco-editor-core/esm/vs/platform/theme/common/iconRegistry';
 import { inject, injectable } from '@theia/core/shared/inversify';
 import { URI } from '@theia/core/shared/vscode-uri';
-import { IconFontDefinition, IconContribution as Icon } from '@theia/core/lib/browser/icon-registry';
 import { MonacoIconRegistry } from '@theia/monaco/lib/browser/monaco-icon-registry';
 import * as path from 'path';
 import { IconContribution, DeployedPlugin, IconDefinition } from '../../common/plugin-protocol';
-import { IThemeService } from '@theia/monaco-editor-core/esm/vs/platform/theme/common/themeService';
-import { UnthemedProductIconTheme } from '@theia/monaco-editor-core/esm/vs/platform/theme/browser/iconsStyleSheet';
 
 @injectable()
 export class PluginIconService implements Disposable {
@@ -45,29 +40,19 @@ export class PluginIconService implements Disposable {
         } else {
             this.registerRegularIcon(contribution, defaultIcon.id);
         }
-        this.updateStyle(contribution);
         return Disposable.NULL;
     }
 
-    updateStyle(contribution: IconContribution): void {
-        this.updateStyleElement();
-        const css = this.getCSS(contribution);
-        if (css) {
-            this.styleElement.innerText = css;
-        }
-        const toRemoveStyleElement = Disposable.create(() => this.styleElement.remove());
-        this.toDispose.push(toRemoveStyleElement);
-    }
-
     dispose(): void {
         this.toDispose.dispose();
     }
 
     protected registerFontIcon(contribution: IconContribution, defaultIcon: IconDefinition): void {
-        const location = defaultIcon.location;
-        const format = getFileExtension(location);
-        const fontId = getFontId(contribution.extensionId, location);
-        const definition = this.iconRegistry.registerIconFont(fontId, { src: [{ location: URI.file(location), format }] });
+        const location = this.toPluginUrl(contribution.extensionId, getIconRelativePath(URI.parse(defaultIcon.location).path));
+        const format = getFileExtension(location.path);
+        const fontId = getFontId(contribution.extensionId, location.path);
+
+        const definition = this.iconRegistry.registerIconFont(fontId, { src: [{ location: location, format }] });
         this.iconRegistry.registerIcon(contribution.id, {
             fontCharacter: defaultIcon.fontCharacter,
             font: {
@@ -81,59 +66,10 @@ export class PluginIconService implements Disposable {
         this.iconRegistry.registerIcon(contribution.id, { id: defaultIconId }, contribution.description);
     }
 
-    protected updateStyleElement(): void {
-        if (!this.styleElement) {
-            const styleElement = document.createElement('style');
-            styleElement.type = 'text/css';
-            styleElement.media = 'screen';
-            styleElement.id = 'contributedIconsStyles';
-            document.head.appendChild(styleElement);
-            this.styleElement = styleElement;
-        }
-    }
-    protected getCSS(iconContribution: IconContribution, themeService?: IThemeService): string | undefined {
-        const iconRegistry = getIconRegistry();
-        const productIconTheme = themeService ? themeService.getProductIconTheme() : new UnthemedProductIconTheme();
-        const usedFontIds: { [id: string]: IconFontDefinition } = {};
-        const formatIconRule = (contribution: Icon): string | undefined => {
-            const definition = productIconTheme.getIcon(contribution);
-            if (!definition) {
-                return undefined;
-            }
-            const fontContribution = definition.font;
-            if (fontContribution) {
-                usedFontIds[fontContribution.id] = fontContribution.definition;
-                return `.codicon-${contribution.id}:before { content: '${definition.fontCharacter}'; font-family: ${asCSSPropertyValue(iconContribution.extensionId)}; }`;
-            }
-            // default font (codicon)
-            return `.codicon-${contribution.id}:before { content: '${definition.fontCharacter}'; }`;
-        };
-
-        const rules = [];
-        for (const contribution of iconRegistry.getIcons()) {
-            const rule = formatIconRule(contribution);
-            if (rule) {
-                rules.push(rule);
-            }
-        }
-        for (const id in usedFontIds) {
-            if (id) {
-                const definition = usedFontIds[id];
-                const fontWeight = definition.weight ? `font-weight: ${definition.weight};` : '';
-                const fontStyle = definition.style ? `font-style: ${definition.style};` : '';
-                const src = definition.src.map(icon =>
-                    `${this.toPluginUrl(iconContribution.extensionId, getIconRelativePath(icon.location.path))} format('${icon.format}')`)
-                    .join(', ');
-                rules.push(`@font-face { src: ${src}; font-family: ${asCSSPropertyValue(iconContribution.extensionId)};${fontWeight}${fontStyle} font-display: block; }`);
-            }
-        }
-        return rules.join('\n');
-    }
-
-    protected toPluginUrl(id: string, relativePath: string): string {
-        return `url('${new Endpoint({
+    protected toPluginUrl(id: string, relativePath: string): URI {
+        return URI.from(new Endpoint({
             path: `hostedPlugin/${this.formatExtensionId(id)}/${encodeURIComponent(relativePath)}`
-        }).getRestUrl().toString()}')`;
+        }).getRestUrl().toComponents());
     }
 
     protected formatExtensionId(id: string): string {

package/src/main/browser/quick-open-main.ts

@@ -23,39 +23,47 @@ import {
     QuickOpenMain,
     MAIN_RPC_CONTEXT,
     TransferInputBox,
-    TransferQuickPickItems,
+    TransferQuickPickItem,
     TransferQuickInput,
     TransferQuickInputButton,
-    TransferQuickPickItemValue
+    TransferQuickPickOptions
 } from '../../common/plugin-api-rpc';
 import {
     InputOptions,
-    PickOptions,
+    QuickInput,
     QuickInputButton,
     QuickInputButtonHandle,
-    QuickInputService
+    QuickInputService,
+    QuickPickItem,
+    codiconArray
 } from '@theia/core/lib/browser';
 import { DisposableCollection, Disposable } from '@theia/core/lib/common/disposable';
 import { CancellationToken } from '@theia/core/lib/common/cancellation';
 import { MonacoQuickInputService } from '@theia/monaco/lib/browser/monaco-quick-input-service';
 import { QuickInputButtons } from '../../plugin/types-impl';
-import { getIconPathOrClass } from '../../plugin/quick-open';
 import * as monaco from '@theia/monaco-editor-core';
-import { IQuickPickItem, IQuickInput } from '@theia/monaco-editor-core/esm/vs/base/parts/quickinput/common/quickInput';
-import { ThemeIcon } from '@theia/monaco-editor-core/esm/vs/platform/theme/common/themeService';
+import { UriComponents } from '../../common/uri-components';
+import { URI } from '@theia/core/shared/vscode-uri';
+import { ThemeIcon } from '@theia/monaco-editor-core/esm/vs/base/common/themables';
+import { isUriComponents } from '@theia/monaco-editor-core/esm/vs/base/common/uri';
 
 export interface QuickInputSession {
-    input: IQuickInput;
-    handlesToItems: Map<number, TransferQuickPickItems>;
+    input: QuickInput;
+    handlesToItems: Map<number, TransferQuickPickItem>;
 }
 
+interface IconPath {
+    dark: URI,
+    light?: URI
+};
+
 export class QuickOpenMainImpl implements QuickOpenMain, Disposable {
 
     private quickInputService: QuickInputService;
     private proxy: QuickOpenExt;
     private delegate: MonacoQuickInputService;
     private readonly items: Record<number, {
-        resolve(items: TransferQuickPickItems[]): void;
+        resolve(items: QuickPickItem[]): void;
         reject(error: Error): void;
     }> = {};
 
@@ -71,33 +79,74 @@ export class QuickOpenMainImpl implements QuickOpenMain, Disposable {
         this.toDispose.dispose();
     }
 
-    async $show(instance: number, options: PickOptions<TransferQuickPickItemValue>, token: CancellationToken): Promise<number | number[] | undefined> {
-        const contents = new Promise<TransferQuickPickItems[]>((resolve, reject) => {
+    async $show(instance: number, options: TransferQuickPickOptions<TransferQuickPickItem>, token: CancellationToken): Promise<number | number[] | undefined> {
+        const contents = new Promise<QuickPickItem[]>((resolve, reject) => {
             this.items[instance] = { resolve, reject };
         });
 
-        options = {
+        const activeItem = await options.activeItem;
+        const transformedOptions = {
             ...options,
             onDidFocus: (el: any) => {
                 if (el) {
-                    this.proxy.$onItemSelected((<TransferQuickPickItems>el).handle);
+                    this.proxy.$onItemSelected(Number.parseInt((<QuickPickItem>el).id!));
                 }
-            }
+            },
+            activeItem: activeItem ? this.toQuickPickItem(activeItem) : undefined
         };
 
-        const result = await this.delegate.pick<TransferQuickPickItemValue>(contents, options, token);
+        const result = await this.delegate.pick(contents, transformedOptions, token);
 
         if (Array.isArray(result)) {
-            return result.map(({ handle }) => handle);
+            return result.map(({ id }) => Number.parseInt(id!));
         } else if (result) {
-            return result.handle;
+            return Number.parseInt(result.id!);
         }
         return undefined;
     }
 
-    $setItems(instance: number, items: TransferQuickPickItems[]): Promise<any> {
+    private normalizeIconPath(path: UriComponents | { light: UriComponents; dark: UriComponents } | ThemeIcon | undefined): {
+        iconPath?: IconPath
+        iconClasses?: string[]
+    } {
+        let iconClasses;
+        if (ThemeIcon.isThemeIcon(path)) {
+            const codicon = codiconArray(path.id);
+            iconClasses = codicon;
+        }
+        let iconPath;
+        if (isUriComponents(path)) {
+            iconPath = { dark: URI.from(path) };
+        } else if (path && 'dark' in path) {
+            iconPath = { dark: URI.from(path.dark), light: URI.from(path.light) };
+        }
+        return {
+            iconPath,
+            iconClasses
+        };
+    }
+
+    private toQuickPickItem(item: undefined): undefined;
+    private toQuickPickItem(item: TransferQuickPickItem): QuickPickItem
+    private toQuickPickItem(item: TransferQuickPickItem | undefined): QuickPickItem | undefined {
+        if (!item) {
+            return undefined;
+        }
+        return {
+            ...this.normalizeIconPath(item.iconPath),
+            type: 'item',
+            id: item.handle.toString(),
+            label: item.label,
+            description: item.description,
+            detail: item.detail,
+            alwaysShow: item.alwaysShow,
+            buttons: item.buttons ? this.convertToQuickInputButtons(item.buttons) : undefined
+        };
+    }
+
+    $setItems(instance: number, items: TransferQuickPickItem[]): Promise<any> {
         if (this.items[instance]) {
-            this.items[instance].resolve(items);
+            this.items[instance].resolve(items.map(item => this.toQuickPickItem(item)));
             delete this.items[instance];
         }
         return Promise.resolve();
@@ -201,17 +250,17 @@ export class QuickOpenMainImpl implements QuickOpenMain, Disposable {
                 quickPick.onDidAccept(() => {
                     this.proxy.$acceptOnDidAccept(sessionId);
                 });
-                quickPick.onDidChangeActive((items: Array<IQuickPickItem>) => {
-                    this.proxy.$onDidChangeActive(sessionId, items.map(item => (item as TransferQuickPickItems).handle));
+                quickPick.onDidChangeActive((items: QuickPickItem[]) => {
+                    this.proxy.$onDidChangeActive(sessionId, items.map(item => Number.parseInt(item.id!)));
                 });
-                quickPick.onDidChangeSelection((items: Array<IQuickPickItem>) => {
-                    this.proxy.$onDidChangeSelection(sessionId, items.map(item => (item as TransferQuickPickItems).handle));
+                quickPick.onDidChangeSelection((items: QuickPickItem[]) => {
+                    this.proxy.$onDidChangeSelection(sessionId, items.map(item => Number.parseInt(item.id!)));
                 });
                 quickPick.onDidTriggerButton((button: QuickInputButtonHandle) => {
                     this.proxy.$acceptOnDidTriggerButton(sessionId, button);
                 });
                 quickPick.onDidTriggerItemButton(e => {
-                    this.proxy.$onDidTriggerItemButton(sessionId, (e.item as TransferQuickPickItems).handle, (e.button as TransferQuickPickItems).handle);
+                    this.proxy.$onDidTriggerItemButton(sessionId, Number.parseInt(e.item.id!), (e.button as TransferQuickPickItem).handle);
                 });
                 quickPick.onDidChangeValue((value: string) => {
                     this.proxy.$acceptDidChangeValue(sessionId, value);
@@ -260,7 +309,7 @@ export class QuickOpenMainImpl implements QuickOpenMain, Disposable {
                     }
                 } else if (param === 'items') {
                     handlesToItems.clear();
-                    params[param].forEach((item: TransferQuickPickItems) => {
+                    params[param].forEach((item: TransferQuickPickItem) => {
                         handlesToItems.set(item.handle, item);
                     });
                     (input as any)[param] = params[param];
@@ -314,9 +363,9 @@ export class QuickOpenMainImpl implements QuickOpenMain, Disposable {
         return Promise.resolve(undefined);
     }
 
-    private convertToQuickInputButtons(buttons: Array<TransferQuickInputButton>): Array<QuickInputButton> {
+    private convertToQuickInputButtons(buttons: readonly TransferQuickInputButton[]): QuickInputButton[] {
         return buttons.map((button, i) => ({
-            ...getIconPathOrClass(button),
+            ...this.normalizeIconPath(button.iconPath),
             tooltip: button.tooltip,
             handle: button === QuickInputButtons.Back ? -1 : i,
         } as QuickInputButton));

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

@@ -41,8 +41,8 @@ import { Splice } from '../../common/arrays';
 import { UriComponents } from '../../common/uri-components';
 import { ColorRegistry } from '@theia/core/lib/browser/color-registry';
 import { PluginSharedStyle } from './plugin-shared-style';
-import { ThemeIcon } from '@theia/monaco-editor-core/esm/vs/platform/theme/common/themeService';
 import { IconUrl } from '../../common';
+import { ThemeIcon } from '@theia/monaco-editor-core/esm/vs/base/common/themables';
 
 export class PluginScmResourceGroup implements ScmResourceGroup {
 

package/src/main/browser/selection-provider-command.ts

@@ -19,7 +19,6 @@ import { inject, injectable } from '@theia/core/shared/inversify';
 import { UriAwareCommandHandler, UriCommandHandler } from '@theia/core/lib/common/uri-command-handler';
 import URI from '@theia/core/lib/common/uri';
 import { SelectionService } from '@theia/core';
-import { theiaUritoUriComponents } from '../../common/uri-components';
 
 export namespace SelectionProviderCommands {
     export const GET_SELECTED_CONTEXT: Command = {
@@ -36,7 +35,7 @@ export class SelectionProviderCommandContribution implements CommandContribution
         commands.registerCommand(SelectionProviderCommands.GET_SELECTED_CONTEXT, this.newMultiUriAwareCommandHandler({
             isEnabled: () => true,
             isVisible: () => false,
-            execute: (selectedUris: URI[]) => selectedUris.map(uri => theiaUritoUriComponents(uri))
+            execute: (selectedUris: URI[]) => selectedUris.map(uri => uri.toComponents())
         }));
     }
 

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

@@ -195,7 +195,16 @@ function itemToPath(item: TestItem): string[] {
 class TestRunProfileImpl implements TestRunProfile {
 
     label: string;
-    isDefault: boolean;
+
+    private _isDefault: boolean;
+    set isDefault(isDefault: boolean) {
+        this._isDefault = isDefault;
+        this.proxy.$onDidChangeDefault(this.controllerId, this.id, isDefault);
+    }
+    get isDefault(): boolean {
+        return this._isDefault;
+    }
+
     tag: string;
     canConfigure: boolean;
 
@@ -205,7 +214,7 @@ class TestRunProfileImpl implements TestRunProfile {
         }
 
         if ('isDefault' in update) {
-            this.isDefault = update.isDefault!;
+            this._isDefault = update.isDefault!;
         }
 
         if ('tag' in update) {