@theia/plugin-ext 1.33.0-next.2 → 1.33.0-next.20

package/src/plugin/languages/inline-completion.ts

@@ -0,0 +1,126 @@
+// *****************************************************************************
+// Copyright (C) 2022 Ericsson and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+// *****************************************************************************
+
+// copied from https://github.com/microsoft/vscode/blob/6261075646f055b99068d3688932416f2346dd3b/src/vs/workbench/api/common/extHostLanguageFeatures.ts#L1069-L1185.
+
+import * as theia from '@theia/plugin';
+import * as Converter from '../type-converters';
+import { DocumentsExtImpl } from '../documents';
+import { URI } from '@theia/core/shared/vscode-uri';
+import { CommandRegistryImpl } from '../command-registry';
+import { ReferenceMap } from '../../common/reference-map';
+import { DisposableCollection } from '@theia/core/lib/common/disposable';
+import { InlineCompletionTriggerKind as TriggerKind } from '../../plugin/types-impl';
+import { Command, InlineCompletionContext, InlineCompletionTriggerKind } from '../../common/plugin-api-rpc-model';
+import { IdentifiableInlineCompletion, IdentifiableInlineCompletions, Position } from '../../common/plugin-api-rpc';
+
+export class InlineCompletionAdapterBase {
+
+    async provideInlineCompletions(
+        _resource: URI,
+        _position: Position,
+        _context: InlineCompletionContext,
+        _token: theia.CancellationToken
+    ): Promise<IdentifiableInlineCompletions | undefined> {
+        return undefined;
+    }
+
+    disposeCompletions(pid: number): void { return; };
+}
+
+export class InlineCompletionAdapter extends InlineCompletionAdapterBase {
+
+    private readonly references = new ReferenceMap<{
+        dispose(): void;
+        items: readonly theia.InlineCompletionItem[];
+    }>();
+
+    constructor(
+        private readonly documents: DocumentsExtImpl,
+        private readonly provider: theia.InlineCompletionItemProvider,
+        private readonly commands: CommandRegistryImpl,
+    ) {
+        super();
+    }
+
+    private readonly languageTriggerKindToVSCodeTriggerKind: Record<InlineCompletionTriggerKind, TriggerKind> = {
+        [InlineCompletionTriggerKind.Automatic]: TriggerKind.Automatic,
+        [InlineCompletionTriggerKind.Explicit]: TriggerKind.Invoke,
+    };
+
+    override async provideInlineCompletions(
+        resource: URI,
+        position: Position,
+        context: InlineCompletionContext,
+        token: theia.CancellationToken
+    ): Promise<IdentifiableInlineCompletions | undefined> {
+        const doc = this.documents.getDocument(resource);
+        const pos = Converter.toPosition(position);
+
+        const result = await this.provider.provideInlineCompletionItems(doc, pos, {
+            selectedCompletionInfo:
+                context.selectedSuggestionInfo
+                    ? {
+                        range: Converter.toRange(context.selectedSuggestionInfo.range),
+                        text: context.selectedSuggestionInfo.text
+                    }
+                    : undefined,
+            triggerKind: this.languageTriggerKindToVSCodeTriggerKind[context.triggerKind]
+        }, token);
+
+        if (!result || token.isCancellationRequested) {
+            return undefined;
+        }
+
+        const normalizedResult = Array.isArray(result) ? result : result.items;
+
+        let disposableCollection: DisposableCollection | undefined = undefined;
+        const pid = this.references.createReferenceId({
+            dispose(): void {
+                disposableCollection?.dispose();
+            },
+            items: normalizedResult
+        });
+
+        return {
+            pid,
+            items: normalizedResult.map<IdentifiableInlineCompletion>((item, idx) => {
+                let command: Command | undefined = undefined;
+                if (item.command) {
+                    if (!disposableCollection) {
+                        disposableCollection = new DisposableCollection();
+                    }
+                    command = this.commands.converter.toSafeCommand(item.command, disposableCollection);
+                }
+
+                const insertText = item.insertText;
+                return ({
+                    insertText: typeof insertText === 'string' ? insertText : { snippet: insertText.value },
+                    filterText: item.filterText,
+                    range: item.range ? Converter.fromRange(item.range) : undefined,
+                    command,
+                    idx: idx
+                });
+            })
+        };
+    }
+
+    override disposeCompletions(pid: number): void {
+        const data = this.references.disposeReferenceId(pid);
+        data?.dispose();
+    }
+
+}

package/src/plugin/languages.ts

@@ -27,6 +27,7 @@ import {
     Plugin,
     InlayHintsDto,
     InlayHintDto,
+    IdentifiableInlineCompletions,
 } from '../common/plugin-api-rpc';
 import { RPCProtocol } from '../common/rpc-protocol';
 import * as theia from '@theia/plugin';
@@ -67,7 +68,8 @@ import {
     EvaluatableExpression,
     InlineValue,
     InlineValueContext,
-    TypeHierarchyItem
+    TypeHierarchyItem,
+    InlineCompletionContext
 } from '../common/plugin-api-rpc-model';
 import { CompletionAdapter } from './languages/completion';
 import { Diagnostics } from './languages/diagnostics';
@@ -106,6 +108,7 @@ import { Severity } from '@theia/core/lib/common/severity';
 import { LinkedEditingRangeAdapter } from './languages/linked-editing-range';
 import { serializeEnterRules, serializeIndentation, serializeRegExp } from './languages-utils';
 import { InlayHintsAdapter } from './languages/inlay-hints';
+import { InlineCompletionAdapter, InlineCompletionAdapterBase } from './languages/inline-completion';
 
 type Adapter = CompletionAdapter |
     SignatureHelpAdapter |
@@ -135,7 +138,8 @@ type Adapter = CompletionAdapter |
     DocumentRangeSemanticTokensAdapter |
     DocumentSemanticTokensAdapter |
     LinkedEditingRangeAdapter |
-    TypeHierarchyAdapter;
+    TypeHierarchyAdapter |
+    InlineCompletionAdapter;
 
 export class LanguagesExtImpl implements LanguagesExt {
 
@@ -246,7 +250,8 @@ export class LanguagesExtImpl implements LanguagesExt {
                 $serialized: true,
                 language: selector.language,
                 scheme: selector.scheme,
-                pattern: selector.pattern
+                pattern: selector.pattern,
+                notebookType: selector.notebookType
             };
         }
 
@@ -275,6 +280,28 @@ export class LanguagesExtImpl implements LanguagesExt {
     }
     // ### Completion end
 
+    // ### Inline completion provider begin
+    registerInlineCompletionsProvider(selector: theia.DocumentSelector, provider: theia.InlineCompletionItemProvider): theia.Disposable {
+        const callId = this.addNewAdapter(new InlineCompletionAdapter(this.documents, provider, this.commands));
+        this.proxy.$registerInlineCompletionsSupport(callId, this.transformDocumentSelector(selector));
+        return this.createDisposable(callId);
+    }
+
+    $provideInlineCompletions(
+        handle: number,
+        resource: UriComponents,
+        position: Position,
+        context: InlineCompletionContext,
+        token: theia.CancellationToken
+    ): Promise<IdentifiableInlineCompletions | undefined> {
+        return this.withAdapter(handle, InlineCompletionAdapterBase, adapter => adapter.provideInlineCompletions(URI.revive(resource), position, context, token), undefined);
+    }
+
+    $freeInlineCompletionsList(handle: number, pid: number): void {
+        this.withAdapter(handle, InlineCompletionAdapterBase, async adapter => { adapter.disposeCompletions(pid); }, undefined);
+    }
+    // ### Inline completion provider end
+
     // ### Definition provider begin
     $provideDefinition(handle: number, resource: UriComponents, position: Position, token: theia.CancellationToken): Promise<Definition | undefined> {
         return this.withAdapter(handle, DefinitionAdapter, adapter => adapter.provideDefinition(URI.revive(resource), position, token), undefined);

package/src/plugin/plugin-context.ts

@@ -155,11 +155,27 @@ import {
     InlayHint,
     InlayHintKind,
     InlayHintLabelPart,
+    NotebookCell,
+    NotebookCellKind,
+    NotebookCellStatusBarAlignment,
+    NotebookEditorRevealType,
+    NotebookControllerAffinity,
+    NotebookCellData,
+    NotebookCellOutput,
+    NotebookCellOutputItem,
+    NotebookData,
+    NotebookDocument,
+    NotebookRange,
+    NotebookCellStatusBarItem,
+    NotebookEdit,
     TestRunProfileKind,
     TestTag,
     TestRunRequest,
     TestMessage,
-    ExtensionKind
+    ExtensionKind,
+    InlineCompletionItem,
+    InlineCompletionList,
+    InlineCompletionTriggerKind
 } from './types-impl';
 import { AuthenticationExtImpl } from './authentication-ext';
 import { SymbolKind } from '../common/plugin-api-rpc-model';
@@ -201,6 +217,7 @@ import { CustomEditorsExtImpl } from './custom-editors';
 import { WebviewViewsExtImpl } from './webview-views';
 import { PluginPackage } from '../common';
 import { Endpoint } from '@theia/core/lib/browser/endpoint';
+import { FilePermission } from '@theia/filesystem/lib/common/files';
 
 export function createAPIFactory(
     rpc: RPCProtocol,
@@ -381,6 +398,26 @@ export function createAPIFactory(
                     throw new Error(`Failed to show text document ${documentArg.toString()}`);
                 }
             },
+            get visibleNotebookEditors(): theia.NotebookEditor[] {
+                return [] as theia.NotebookEditor[];
+            },
+            onDidChangeVisibleNotebookEditors(listener, thisArg?, disposables?) {
+                return Disposable.NULL;
+            },
+            get activeNotebookEditor(): theia.NotebookEditor | undefined {
+                return undefined;
+            }, onDidChangeActiveNotebookEditor(listener, thisArg?, disposables?) {
+                return Disposable.NULL;
+            },
+            onDidChangeNotebookEditorSelection(listener, thisArg?, disposables?) {
+                return Disposable.NULL;
+            },
+            onDidChangeNotebookEditorVisibleRanges(listener, thisArg?, disposables?) {
+                return Disposable.NULL;
+            },
+            showNotebookDocument(document: NotebookDocument, options?: theia.NotebookDocumentShowOptions) {
+                return Promise.resolve({} as theia.NotebookEditor);
+            },
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             showQuickPick(items: any, options?: theia.QuickPickOptions, token?: theia.CancellationToken): any {
                 return quickOpenExt.showQuickPick(items, options, token);
@@ -528,6 +565,9 @@ export function createAPIFactory(
             onDidChangeWorkspaceFolders(listener, thisArg?, disposables?): theia.Disposable {
                 return workspaceExt.onDidChangeWorkspaceFolders(listener, thisArg, disposables);
             },
+            get notebookDocuments(): theia.NotebookDocument[] {
+                return [] as theia.NotebookDocument[];
+            },
             get textDocuments(): theia.TextDocument[] {
                 return documents.getAllDocumentData().map(data => data.document);
             },
@@ -537,6 +577,18 @@ export function createAPIFactory(
             onDidCloseTextDocument(listener, thisArg?, disposables?) {
                 return documents.onDidRemoveDocument(listener, thisArg, disposables);
             },
+            onDidOpenNotebookDocument(listener, thisArg?, disposables?) {
+                return Disposable.NULL;
+            },
+            onDidCloseNotebookDocument(listener, thisArg?, disposables?) {
+                return Disposable.NULL;
+            },
+            onDidChangeNotebookDocument(listener, thisArg?, disposables?) {
+                return Disposable.NULL;
+            },
+            onDidSaveNotebookDocument(listener, thisArg?, disposables?) {
+                return Disposable.NULL;
+            },
             onDidOpenTextDocument(listener, thisArg?, disposables?) {
                 return documents.onDidAddDocument(listener, thisArg, disposables);
             },
@@ -581,6 +633,9 @@ 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'));
+            },
             createFileSystemWatcher: (pattern, ignoreCreate, ignoreChange, ignoreDelete): theia.FileSystemWatcher =>
                 extHostFileSystemEvent.createFileSystemWatcher(fromGlobPattern(pattern), ignoreCreate, ignoreChange, ignoreDelete),
             findFiles(include: theia.GlobPattern, exclude?: theia.GlobPattern | null, maxResults?: number, token?: CancellationToken): PromiseLike<URI[]> {
@@ -599,8 +654,8 @@ export function createAPIFactory(
             registerTextDocumentContentProvider(scheme: string, provider: theia.TextDocumentContentProvider): theia.Disposable {
                 return workspaceExt.registerTextDocumentContentProvider(scheme, provider);
             },
-            registerFileSystemProvider(scheme: string, provider: theia.FileSystemProvider): theia.Disposable {
-                return fileSystemExt.registerFileSystemProvider(scheme, provider);
+            registerFileSystemProvider(scheme: string, provider: theia.FileSystemProvider, options?: { isCaseSensitive?: boolean, isReadonly?: boolean }): theia.Disposable {
+                return fileSystemExt.registerFileSystemProvider(scheme, provider, options);
             },
             getWorkspaceFolder(uri: theia.Uri): theia.WorkspaceFolder | undefined {
                 return workspaceExt.getWorkspaceFolder(uri);
@@ -620,6 +675,9 @@ export function createAPIFactory(
             registerTimelineProvider(scheme: string | string[], provider: theia.TimelineProvider): theia.Disposable {
                 return timelineExt.registerTimelineProvider(plugin, scheme, provider);
             },
+            registerNotebookSerializer(notebookType: string, serializer: theia.NotebookSerializer, options?: theia.NotebookDocumentContentOptions): theia.Disposable {
+                return Disposable.NULL;
+            },
             get isTrusted(): boolean {
                 return workspaceExt.trusted;
             },
@@ -715,6 +773,9 @@ export function createAPIFactory(
             registerCompletionItemProvider(selector: theia.DocumentSelector, provider: theia.CompletionItemProvider, ...triggerCharacters: string[]): theia.Disposable {
                 return languagesExt.registerCompletionItemProvider(selector, provider, triggerCharacters, pluginToPluginInfo(plugin));
             },
+            registerInlineCompletionItemProvider(selector: theia.DocumentSelector, provider: theia.InlineCompletionItemProvider): theia.Disposable {
+                return languagesExt.registerInlineCompletionsProvider(selector, provider);
+            },
             registerDefinitionProvider(selector: theia.DocumentSelector, provider: theia.DefinitionProvider): theia.Disposable {
                 return languagesExt.registerDefinitionProvider(selector, provider, pluginToPluginInfo(plugin));
             },
@@ -981,6 +1042,66 @@ export function createAPIFactory(
             }
         };
 
+        // notebooks API (@stubbed)
+        // The following implementation is temporarily `@stubbed` and marked as such under `theia.d.ts`
+        const notebooks: typeof theia.notebooks = {
+            createNotebookController(
+                id,
+                notebookType,
+                label,
+                handler?: (cells: theia.NotebookCell[],
+                    notebook: theia.NotebookDocument,
+                    controller: theia.NotebookController) => void | Thenable<void>
+            ) {
+                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: ({} as theia.Event<{ readonly notebook: theia.NotebookDocument; readonly selected: boolean }>),
+                    updateNotebookAffinity: (notebook: theia.NotebookDocument, affinity: theia.NotebookControllerAffinity) => undefined,
+                    dispose: () => undefined,
+                };
+
+            },
+            createRendererMessaging(
+                rendererId
+            ) {
+                return {
+                    rendererId,
+                    onDidReceiveMessage: ({} as theia.Event<{ readonly editor: theia.NotebookEditor; readonly message: any }>),
+                    postMessage: (message: any, editor?: theia.NotebookEditor) => ({} as Thenable<boolean>),
+                };
+            },
+            registerNotebookCellStatusBarItemProvider(
+                notebookType,
+                provider
+            ) {
+                return {
+                    notebookType,
+                    provider,
+                    dispose: () => undefined,
+                };
+            }
+        };
+
         return <typeof theia>{
             version: require('../../package.json').version,
             authentication,
@@ -995,6 +1116,7 @@ export function createAPIFactory(
             debug,
             tasks,
             scm,
+            notebooks,
             tests,
             // Types
             StatusBarAlignment: StatusBarAlignment,
@@ -1065,6 +1187,7 @@ export function createAPIFactory(
             WorkspaceEdit,
             SymbolInformation,
             FileType,
+            FilePermission,
             FileChangeType,
             ShellQuoting,
             ShellExecution,
@@ -1120,11 +1243,26 @@ export function createAPIFactory(
             InlayHint,
             InlayHintKind,
             InlayHintLabelPart,
+            NotebookCellData,
+            NotebookCellKind,
+            NotebookCellOutput,
+            NotebookCellOutputItem,
+            NotebookCellStatusBarAlignment,
+            NotebookCellStatusBarItem,
+            NotebookControllerAffinity,
+            NotebookData,
+            NotebookEditorRevealType,
+            NotebookDocument,
+            NotebookRange,
+            NotebookEdit,
             TestRunProfileKind,
             TestTag,
             TestRunRequest,
             TestMessage,
-            ExtensionKind
+            ExtensionKind,
+            InlineCompletionItem,
+            InlineCompletionList,
+            InlineCompletionTriggerKind
         };
     };
 }

package/src/plugin/theming.ts

@@ -59,6 +59,9 @@ export class ThemingExtImpl implements ThemingExt {
             case 'hc':
                 kind = ColorThemeKind.HighContrast;
                 break;
+            case 'hcLight':
+                kind = ColorThemeKind.HighContrastLight;
+                break;
         }
         return kind;
     }

package/src/plugin/type-converters.spec.ts

@@ -22,7 +22,6 @@ import * as model from '../common/plugin-api-rpc-model';
 import { MarkdownString } from './markdown-string';
 import { MarkdownString as MarkdownStringInterface } from '@theia/core/lib/common/markdown-rendering';
 import { TaskDto } from '../common/plugin-api-rpc';
-import { TaskGroup } from './types-impl';
 
 describe('Type converters:', () => {
 
@@ -185,8 +184,7 @@ describe('Type converters:', () => {
         const args = ['run', 'build'];
         const cwd = '/projects/theia';
         const additionalProperty = 'some property';
-        const groupDto = 'build';
-        const group = TaskGroup.Build;
+        const group = new types.TaskGroup('build', 'Build');
 
         const shellTaskDto: TaskDto = {
             type: shellType,
@@ -202,7 +200,10 @@ describe('Type converters:', () => {
                 reveal: 3,
                 focus: true
             },
-            group: groupDto,
+            group: {
+                kind: 'build',
+                isDefault: false
+            },
             runOptions: {
                 reevaluateOnRerun: false
             }

package/src/plugin/type-converters.ts

@@ -31,8 +31,6 @@ import { MarkdownString as MarkdownStringDTO } from '@theia/core/lib/common/mark
 
 const SIDE_GROUP = -2;
 const ACTIVE_GROUP = -1;
-const BUILD_GROUP = 'build';
-const TEST_GROUP = 'test';
 
 export function toViewColumn(ep?: EditorPosition): theia.ViewColumn | undefined {
     if (typeof ep !== 'number') {
@@ -846,11 +844,11 @@ export function fromTask(task: theia.Task): TaskDto | undefined {
         taskDto.presentation = task.presentationOptions;
     }
 
-    const group = task.group;
-    if (group === types.TaskGroup.Build) {
-        taskDto.group = BUILD_GROUP;
-    } else if (group === types.TaskGroup.Test) {
-        taskDto.group = TEST_GROUP;
+    if (task.group) {
+        taskDto.group = {
+            kind: <rpc.TaskGroupKind>task.group.id,
+            isDefault: !!task.group.isDefault
+        };
     }
 
     const taskDefinition = task.definition;
@@ -936,11 +934,11 @@ export function toTask(taskDto: TaskDto): theia.Task {
     }
 
     if (group) {
-        if (group === BUILD_GROUP) {
-            result.group = types.TaskGroup.Build;
-        } else if (group === TEST_GROUP) {
-            result.group = types.TaskGroup.Test;
-        }
+        result.group = new types.TaskGroup(
+            group.kind,
+            group.kind,
+            group.isDefault
+        );
     }
 
     if (presentation) {