@theia/plugin-ext 1.40.1 → 1.42.0

package/src/plugin/plugin-context.ts

@@ -98,6 +98,7 @@ import {
     DataTransfer,
     TreeItem,
     TreeItemCollapsibleState,
+    TreeItemCheckboxState,
     DocumentSymbol,
     SymbolTag,
     WorkspaceEdit,
@@ -165,8 +166,8 @@ import {
     InlayHintKind,
     InlayHintLabelPart,
     TelemetryTrustedValue,
-    NotebookCell,
     NotebookCellKind,
+    NotebookCellExecutionState,
     NotebookCellStatusBarAlignment,
     NotebookEditorRevealType,
     NotebookControllerAffinity,
@@ -174,10 +175,11 @@ import {
     NotebookCellOutput,
     NotebookCellOutputItem,
     NotebookData,
-    NotebookDocument,
     NotebookRange,
     NotebookCellStatusBarItem,
     NotebookEdit,
+    NotebookKernelSourceAction,
+    NotebookRendererScript,
     TestRunProfileKind,
     TestTag,
     TestRunRequest,
@@ -230,7 +232,8 @@ import {
     createRunProfile,
     createTestRun,
     testItemCollection,
-    createTestItem
+    createTestItem,
+    invalidateTestResults
 } from './stubs/tests-api';
 import { TimelineExtImpl } from './timeline';
 import { ThemingExtImpl } from './theming';
@@ -242,7 +245,13 @@ import { Endpoint } from '@theia/core/lib/browser/endpoint';
 import { FilePermission } from '@theia/filesystem/lib/common/files';
 import { TabsExtImpl } from './tabs';
 import { LocalizationExtImpl } from './localization-ext';
+import { NotebooksExtImpl } from './notebook/notebooks';
 import { TelemetryExtImpl } from './telemetry-ext';
+import { NotebookDocument } from './notebook/notebook-document';
+import { NotebookRenderersExtImpl } from './notebook/notebook-renderers';
+import { NotebookKernelsExtImpl } from './notebook/notebook-kernels';
+import { NotebookDocumentsExtImpl } from './notebook/notebook-documents';
+import { NotebookEditorsExtImpl } from './notebook/notebook-editors';
 
 export function createAPIFactory(
     rpc: RPCProtocol,
@@ -266,6 +275,11 @@ export function createAPIFactory(
     const notificationExt = rpc.set(MAIN_RPC_CONTEXT.NOTIFICATION_EXT, new NotificationExtImpl(rpc));
     const editors = rpc.set(MAIN_RPC_CONTEXT.TEXT_EDITORS_EXT, new TextEditorsExtImpl(rpc, editorsAndDocumentsExt));
     const documents = rpc.set(MAIN_RPC_CONTEXT.DOCUMENTS_EXT, new DocumentsExtImpl(rpc, editorsAndDocumentsExt));
+    const notebooksExt = rpc.set(MAIN_RPC_CONTEXT.NOTEBOOKS_EXT, new NotebooksExtImpl(rpc, commandRegistry, editorsAndDocumentsExt, documents));
+    const notebookEditors = rpc.set(MAIN_RPC_CONTEXT.NOTEBOOK_EDITORS_EXT, new NotebookEditorsExtImpl(notebooksExt));
+    const notebookRenderers = rpc.set(MAIN_RPC_CONTEXT.NOTEBOOK_RENDERERS_EXT, new NotebookRenderersExtImpl(rpc, notebooksExt));
+    const notebookKernels = rpc.set(MAIN_RPC_CONTEXT.NOTEBOOK_KERNELS_EXT, new NotebookKernelsExtImpl(rpc, notebooksExt, commandRegistry));
+    const notebookDocuments = rpc.set(MAIN_RPC_CONTEXT.NOTEBOOK_DOCUMENTS_EXT, new NotebookDocumentsExtImpl(notebooksExt));
     const statusBarMessageRegistryExt = new StatusBarMessageRegistryExt(rpc);
     const terminalExt = rpc.set(MAIN_RPC_CONTEXT.TERMINAL_EXT, new TerminalServiceExtImpl(rpc));
     const outputChannelRegistryExt = rpc.set(MAIN_RPC_CONTEXT.OUTPUT_CHANNEL_REGISTRY_EXT, new OutputChannelRegistryExtImpl(rpc));
@@ -427,24 +441,24 @@ export function createAPIFactory(
                 }
             },
             get visibleNotebookEditors(): theia.NotebookEditor[] {
-                return [] as theia.NotebookEditor[];
+                return notebooksExt.visibleApiNotebookEditors;
             },
             onDidChangeVisibleNotebookEditors(listener, thisArg?, disposables?) {
-                return Disposable.NULL;
+                return notebooksExt.onDidChangeVisibleNotebookEditors(listener, thisArg, disposables);
             },
             get activeNotebookEditor(): theia.NotebookEditor | undefined {
-                return undefined;
+                return notebooksExt.activeApiNotebookEditor;
             }, onDidChangeActiveNotebookEditor(listener, thisArg?, disposables?) {
-                return Disposable.NULL;
+                return notebooksExt.onDidChangeActiveNotebookEditor(listener, thisArg, disposables);
             },
             onDidChangeNotebookEditorSelection(listener, thisArg?, disposables?) {
-                return Disposable.NULL;
+                return notebookEditors.onDidChangeNotebookEditorSelection(listener, thisArg, disposables);
             },
             onDidChangeNotebookEditorVisibleRanges(listener, thisArg?, disposables?) {
-                return Disposable.NULL;
+                return notebookEditors.onDidChangeNotebookEditorVisibleRanges(listener, thisArg, disposables);
             },
-            showNotebookDocument(document: NotebookDocument, options?: theia.NotebookDocumentShowOptions) {
-                return Promise.resolve({} as theia.NotebookEditor);
+            showNotebookDocument(document: theia.NotebookDocument, options?: theia.NotebookDocumentShowOptions) {
+                return notebooksExt.showNotebookDocument(document, options);
             },
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             showQuickPick(items: any, options?: theia.QuickPickOptions, token?: theia.CancellationToken): any {
@@ -616,7 +630,7 @@ export function createAPIFactory(
                 return workspaceExt.onDidChangeWorkspaceFolders(listener, thisArg, disposables);
             },
             get notebookDocuments(): theia.NotebookDocument[] {
-                return [] as theia.NotebookDocument[];
+                return notebooksExt.getAllApiDocuments();
             },
             get textDocuments(): theia.TextDocument[] {
                 return documents.getAllDocumentData().map(data => data.document);
@@ -628,19 +642,19 @@ export function createAPIFactory(
                 return documents.onDidRemoveDocument(listener, thisArg, disposables);
             },
             onDidOpenNotebookDocument(listener, thisArg?, disposables?) {
-                return Disposable.NULL;
+                return notebooksExt.onDidOpenNotebookDocument(listener, thisArg, disposables);
             },
             onDidCloseNotebookDocument(listener, thisArg?, disposables?) {
-                return Disposable.NULL;
-            },
-            onDidChangeNotebookDocument(listener, thisArg?, disposables?) {
-                return Disposable.NULL;
+                return notebooksExt.onDidCloseNotebookDocument(listener, thisArg, disposables);
             },
             onWillSaveNotebookDocument(listener, thisArg?, disposables?) {
                 return Disposable.NULL;
             },
-            onDidSaveNotebookDocument(listener, thisArg?, disposables?) {
-                return Disposable.NULL;
+            onDidSaveNotebookDocument(listener, thisArg, disposables) {
+                return notebookDocuments.onDidSaveNotebookDocument(listener, thisArg, disposables);
+            },
+            onDidChangeNotebookDocument(listener, thisArg, disposables) {
+                return notebookDocuments.onDidChangeNotebookDocument(listener, thisArg, disposables);
             },
             onDidOpenTextDocument(listener, thisArg?, disposables?) {
                 return documents.onDidAddDocument(listener, thisArg, disposables);
@@ -686,8 +700,18 @@ export function createAPIFactory(
                 const data = await documents.openDocument(uri);
                 return data && data.document;
             },
-            openNotebookDocument(uriOrString: theia.Uri | string, content?: NotebookData): Promise<theia.NotebookDocument | undefined> {
-                return Promise.reject(new Error('Notebook API is stubbed'));
+            async openNotebookDocument(uriOrType: theia.Uri | string, content?: NotebookData): Promise<theia.NotebookDocument | undefined> {
+                let uri: URI;
+                if (URI.isUri(uriOrType)) {
+                    uri = uriOrType;
+                    await notebooksExt.openNotebookDocument(uriOrType as URI);
+                } else if (typeof uriOrType === 'string') {
+                    uri = URI.revive(await notebooksExt.createNotebookDocument({ viewType: uriOrType, content }));
+                } else {
+                    throw new Error('Invalid arguments');
+                }
+                return notebooksExt.getNotebookDocument(uri).apiNotebook;
+
             },
             createFileSystemWatcher: (pattern, ignoreCreate, ignoreChange, ignoreDelete): theia.FileSystemWatcher =>
                 extHostFileSystemEvent.createFileSystemWatcher(fromGlobPattern(pattern), ignoreCreate, ignoreChange, ignoreDelete),
@@ -729,7 +753,7 @@ export function createAPIFactory(
                 return timelineExt.registerTimelineProvider(plugin, scheme, provider);
             },
             registerNotebookSerializer(notebookType: string, serializer: theia.NotebookSerializer, options?: theia.NotebookDocumentContentOptions): theia.Disposable {
-                return Disposable.NULL;
+                return notebooksExt.registerNotebookSerializer(plugin, notebookType, serializer, options);
             },
             get isTrusted(): boolean {
                 return workspaceExt.trusted;
@@ -987,6 +1011,7 @@ export function createAPIFactory(
                     createRunProfile,
                     createTestRun,
                     createTestItem,
+                    invalidateTestResults,
                     dispose: () => undefined,
                 };
             },
@@ -1156,54 +1181,27 @@ export function createAPIFactory(
                 label,
                 handler?: (cells: theia.NotebookCell[],
                     notebook: theia.NotebookDocument,
-                    controller: theia.NotebookController) => void | Thenable<void>
+                    controller: theia.NotebookController) => void | Thenable<void>,
+                rendererScripts?: NotebookRendererScript[]
             ) {
-                return {
-                    id,
-                    notebookType,
-                    label,
-                    handler,
-                    createNotebookCellExecution: (cell: NotebookCell) => ({
-                        cell,
-                        token: CancellationToken.None,
-                        executionOrder: undefined,
-                        start: () => undefined,
-                        end: () => undefined,
-                        clearOutput: () => ({} as Thenable<void>),
-                        replaceOutput: () => ({} as Thenable<void>),
-                        appendOutput: () => ({} as Thenable<void>),
-                        replaceOutputItems: () => ({} as Thenable<void>),
-                        appendOutputItems: () => ({} as Thenable<void>)
-                    }),
-                    executeHandler(
-                        cells: theia.NotebookCell[],
-                        notebook: theia.NotebookDocument,
-                        controller: theia.NotebookController
-                    ): (void | Thenable<void>) { },
-                    onDidChangeSelectedNotebooks: () => Disposable.create(() => { }),
-                    updateNotebookAffinity: (notebook: theia.NotebookDocument, affinity: theia.NotebookControllerAffinity) => undefined,
-                    dispose: () => undefined,
-                };
-
+                return notebookKernels.createNotebookController(plugin.model.id, id, notebookType, label, handler, rendererScripts);
             },
-            createRendererMessaging(
-                rendererId
-            ) {
-                return {
-                    rendererId,
-                    onDidReceiveMessage: () => Disposable.create(() => { }),
-                    postMessage: () => Promise.resolve({}),
-                };
+            createRendererMessaging(rendererId) {
+                return notebookRenderers.createRendererMessaging(rendererId);
             },
             registerNotebookCellStatusBarItemProvider(
                 notebookType,
                 provider
             ) {
-                return {
-                    notebookType,
-                    provider,
-                    dispose: () => undefined,
-                };
+                return notebooksExt.registerNotebookCellStatusBarItemProvider(notebookType, provider);
+            },
+            onDidChangeNotebookCellExecutionState: notebookKernels.onDidChangeNotebookCellExecutionState,
+
+            createNotebookControllerDetectionTask(notebookType: string) {
+                return notebookKernels.createNotebookControllerDetectionTask(notebookType);
+            },
+            registerKernelSourceActionProvider(notebookType: string, provider: theia.NotebookKernelSourceActionProvider) {
+                return notebookKernels.registerKernelSourceActionProvider(notebookType, provider);
             }
         };
 
@@ -1291,6 +1289,7 @@ export function createAPIFactory(
             DataTransfer,
             TreeItem,
             TreeItemCollapsibleState,
+            TreeItemCheckboxState,
             SymbolKind,
             SymbolTag,
             DocumentSymbol,
@@ -1357,6 +1356,7 @@ export function createAPIFactory(
             InlayHintLabelPart,
             TelemetryTrustedValue,
             NotebookCellData,
+            NotebookCellExecutionState,
             NotebookCellKind,
             NotebookCellOutput,
             NotebookCellOutputItem,
@@ -1368,6 +1368,8 @@ export function createAPIFactory(
             NotebookDocument,
             NotebookRange,
             NotebookEdit,
+            NotebookKernelSourceAction,
+            NotebookRendererScript,
             TestRunProfileKind,
             TestTag,
             TestRunRequest,
@@ -1420,6 +1422,8 @@ export interface ExtensionPlugin<T> extends theia.Plugin<T> {
 }
 
 export class Plugin<T> implements theia.Plugin<T> {
+    #pluginManager: PluginManager;
+
     id: string;
     pluginPath: string;
     pluginUri: theia.Uri;
@@ -1427,7 +1431,9 @@ export class Plugin<T> implements theia.Plugin<T> {
     packageJSON: any;
     pluginType: theia.PluginType;
 
-    constructor(protected readonly pluginManager: PluginManager, plugin: InternalPlugin) {
+    constructor(pluginManager: PluginManager, plugin: InternalPlugin) {
+        this.#pluginManager = pluginManager;
+
         this.id = plugin.model.id;
         this.pluginPath = plugin.pluginFolder;
         this.packageJSON = plugin.rawModel;
@@ -1442,26 +1448,29 @@ export class Plugin<T> implements theia.Plugin<T> {
     }
 
     get isActive(): boolean {
-        return this.pluginManager.isActive(this.id);
+        return this.#pluginManager.isActive(this.id);
     }
 
     get exports(): T {
-        return <T>this.pluginManager.getPluginExport(this.id);
+        return <T>this.#pluginManager.getPluginExport(this.id);
     }
 
     activate(): PromiseLike<T> {
-        return this.pluginManager.activatePlugin(this.id).then(() => this.exports);
+        return this.#pluginManager.activatePlugin(this.id).then(() => this.exports);
     }
 }
 
 export class PluginExt<T> extends Plugin<T> implements ExtensionPlugin<T> {
+    #pluginManager: PluginManager;
+
     extensionPath: string;
     extensionUri: theia.Uri;
     extensionKind: ExtensionKind;
     isFromDifferentExtensionHost: boolean;
 
-    constructor(protected override readonly pluginManager: PluginManager, plugin: InternalPlugin, isFromDifferentExtensionHost = false) {
+    constructor(pluginManager: PluginManager, plugin: InternalPlugin, isFromDifferentExtensionHost = false) {
         super(pluginManager, plugin);
+        this.#pluginManager = pluginManager;
 
         this.extensionPath = this.pluginPath;
         this.extensionUri = this.pluginUri;
@@ -1470,14 +1479,14 @@ export class PluginExt<T> extends Plugin<T> implements ExtensionPlugin<T> {
     }
 
     override get isActive(): boolean {
-        return this.pluginManager.isActive(this.id);
+        return this.#pluginManager.isActive(this.id);
     }
 
     override get exports(): T {
-        return <T>this.pluginManager.getPluginExport(this.id);
+        return <T>this.#pluginManager.getPluginExport(this.id);
     }
 
     override activate(): PromiseLike<T> {
-        return this.pluginManager.activatePlugin(this.id).then(() => this.exports);
+        return this.#pluginManager.activatePlugin(this.id).then(() => this.exports);
     }
 }

package/src/plugin/plugin-manager.ts

@@ -43,6 +43,7 @@ import { WebviewsExtImpl } from './webviews';
 import { URI as Uri } from './types-impl';
 import { SecretsExtImpl, SecretStorageExt } from '../plugin/secrets-ext';
 import { PluginExt } from './plugin-context';
+import { Deferred } from '@theia/core/lib/common/promise-util';
 
 export interface PluginHost {
 
@@ -96,7 +97,9 @@ export class PluginManagerExtImpl implements PluginManagerExt, PluginManager {
         'onFileSystem',
         'onCustomEditor',
         'onStartupFinished',
-        'onAuthenticationRequest'
+        'onAuthenticationRequest',
+        'onNotebook',
+        'onNotebookSerializer'
     ]);
 
     private configStorage: ConfigStorage | undefined;
@@ -115,6 +118,7 @@ export class PluginManagerExtImpl implements PluginManagerExt, PluginManager {
     }
 
     protected jsonValidation: PluginJsonValidationContribution[] = [];
+    protected ready = new Deferred();
 
     constructor(
         private readonly host: PluginHost,
@@ -230,6 +234,8 @@ export class PluginManagerExtImpl implements PluginManagerExt, PluginManager {
             this.registerPlugin(plugin);
         }
 
+        // ensure plugins are registered before running activation events
+        this.ready.resolve();
         // run eager plugins
         await this.$activateByEvent('*');
         for (const activationEvent of params.activationEvents) {
@@ -333,6 +339,8 @@ export class PluginManagerExtImpl implements PluginManagerExt, PluginManager {
     }
 
     async $activateByEvent(activationEvent: string): Promise<void> {
+        // Prevent the plugin manager from performing activations before plugins are registered
+        await this.ready.promise;
         if (activationEvent.endsWith(':*')) {
             const baseEvent = activationEvent.substring(0, activationEvent.length - 2);
             await this.activateByBaseEvent(baseEvent);

package/src/plugin/quick-open.ts

@@ -655,6 +655,7 @@ export class QuickPickExt<T extends theia.QuickPickItem> extends QuickInputExt i
                 pickItems.push({
                     kind: item.kind,
                     label: item.label,
+                    iconPath: item.iconPath ? getIconUris(item.iconPath) : undefined,
                     description: item.description,
                     handle,
                     detail: item.detail,

package/src/plugin/stubs/tests-api.ts

@@ -96,3 +96,7 @@ export const createTestItem = (
     range: undefined,
     error: undefined,
 });
+
+export const invalidateTestResults = (
+    items?: theia.TestItem | readonly theia.TestItem[]
+): void => undefined;

package/src/plugin/tasks/task-provider.ts

@@ -15,17 +15,17 @@
 // *****************************************************************************
 
 import * as theia from '@theia/plugin';
-import * as Converter from '../type-converters';
 import { TaskDto } from '../../common';
+import * as Converter from '../type-converters';
 
 export class TaskProviderAdapter {
 
     constructor(private readonly provider: theia.TaskProvider) { }
 
-    provideTasks(token: theia.CancellationToken): Promise<TaskDto[] | undefined> {
+    provideTasks(token: theia.CancellationToken): Promise<TaskDto[]> {
         return Promise.resolve(this.provider.provideTasks(token)).then(tasks => {
             if (!Array.isArray(tasks)) {
-                return undefined;
+                return [];
             }
             const result: TaskDto[] = [];
             for (const task of tasks) {
@@ -40,21 +40,18 @@ export class TaskProviderAdapter {
         });
     }
 
-    resolveTask(task: TaskDto, token: theia.CancellationToken): Promise<TaskDto | undefined> {
+    async resolveTask(task: TaskDto, token: theia.CancellationToken): Promise<TaskDto> {
         if (typeof this.provider.resolveTask !== 'function') {
-            return Promise.resolve(undefined);
+            return task;
         }
 
         const item = Converter.toTask(task);
         if (!item) {
-            return Promise.resolve(undefined);
+            return task;
         }
 
-        return Promise.resolve(this.provider.resolveTask(item, token)).then(value => {
-            if (value) {
-                return Converter.fromTask(value);
-            }
-            return undefined;
-        });
+        const resolved = await this.provider.resolveTask(item, token);
+        const converted = resolved ? Converter.fromTask(resolved) : Converter.fromTask(item);
+        return converted ?? task;
     }
 }

package/src/plugin/tasks/tasks.ts

@@ -158,37 +158,42 @@ export class TasksExtImpl implements TasksExt {
         throw new Error('Task was not successfully transformed into a task config');
     }
 
-    $provideTasks(handle: number): Promise<TaskDto[] | undefined> {
+    async $provideTasks(handle: number): Promise<TaskDto[]> {
         const adapter = this.adaptersMap.get(handle);
         if (adapter) {
             return adapter.provideTasks(CancellationToken.None).then(tasks => {
-                if (tasks) {
-                    for (const task of tasks) {
-                        if (task.taskType === 'customExecution') {
-                            task.executionId = this.addCustomExecution(task.callback);
-                            task.callback = undefined;
-                        }
+                for (const task of tasks) {
+                    if (task.taskType === 'customExecution') {
+                        this.applyCustomExecution(task);
                     }
                 }
                 return tasks;
             });
         } else {
-            return Promise.reject(new Error('No adapter found to provide tasks'));
+            throw new Error('No adapter found to provide tasks');
         }
     }
 
-    $resolveTask(handle: number, task: TaskDto, token: theia.CancellationToken): Promise<TaskDto | undefined> {
+    async $resolveTask(handle: number, task: TaskDto, token: theia.CancellationToken): Promise<TaskDto> {
         const adapter = this.adaptersMap.get(handle);
         if (adapter) {
             return adapter.resolveTask(task, token).then(resolvedTask => {
-                if (resolvedTask && resolvedTask.taskType === 'customExecution') {
-                    resolvedTask.executionId = this.addCustomExecution(resolvedTask.callback);
-                    resolvedTask.callback = undefined;
+                // ensure we do not lose task type and execution id during resolution as we need it for custom execution
+                resolvedTask.taskType = resolvedTask.taskType ?? task.taskType;
+                if (resolvedTask.taskType === 'customExecution') {
+                    this.applyCustomExecution(resolvedTask);
                 }
                 return resolvedTask;
             });
         } else {
-            return Promise.reject(new Error('No adapter found to resolve task'));
+            throw new Error('No adapter found to resolve task');
+        }
+    }
+
+    private applyCustomExecution(task: TaskDto): void {
+        if (task.callback) {
+            task.executionId = this.addCustomExecution(task.callback);
+            task.callback = undefined;
         }
     }
 

package/src/plugin/terminal-ext.ts

@@ -20,6 +20,7 @@ import { RPCProtocol } from '../common/rpc-protocol';
 import { Event, Emitter } from '@theia/core/lib/common/event';
 import { Deferred } from '@theia/core/lib/common/promise-util';
 import * as theia from '@theia/plugin';
+import * as Converter from './type-converters';
 import { Disposable, EnvironmentVariableMutatorType, TerminalExitReason, ThemeIcon } from './types-impl';
 import { SerializableEnvironmentVariableCollection } from '@theia/terminal/lib/common/base-terminal-protocol';
 import { ProvidedTerminalLink } from '../common/plugin-api-rpc-model';
@@ -313,7 +314,11 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
 
     private syncEnvironmentVariableCollection(extensionIdentifier: string, collection: EnvironmentVariableCollection): void {
         const serialized = [...collection.map.entries()];
-        this.proxy.$setEnvironmentVariableCollection(extensionIdentifier, collection.persistent, serialized.length === 0 ? undefined : serialized);
+        this.proxy.$setEnvironmentVariableCollection(collection.persistent, {
+            extensionIdentifier,
+            collection: serialized.length === 0 ? undefined : serialized,
+            description: Converter.fromMarkdownOrString(collection.description)
+        });
     }
 
     private setEnvironmentVariableCollection(extensionIdentifier: string, collection: EnvironmentVariableCollection): void {
@@ -339,8 +344,15 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
 
 export class EnvironmentVariableCollection implements theia.EnvironmentVariableCollection {
     readonly map: Map<string, theia.EnvironmentVariableMutator> = new Map();
+    private _description?: string | theia.MarkdownString;
     private _persistent: boolean = true;
 
+    public get description(): string | theia.MarkdownString | undefined { return this._description; }
+    public set description(value: string | theia.MarkdownString | undefined) {
+        this._description = value;
+        this.onDidChangeCollectionEmitter.fire();
+    }
+
     public get persistent(): boolean { return this._persistent; }
     public set persistent(value: boolean) {
         this._persistent = value;