@theia/plugin-ext 1.43.1 → 1.45.0

package/src/plugin/plugin-manager.ts

@@ -79,29 +79,6 @@ class ActivatedPlugin {
 
 export class PluginManagerExtImpl implements PluginManagerExt, PluginManager {
 
-    static SUPPORTED_ACTIVATION_EVENTS = new Set([
-        '*',
-        'onLanguage',
-        'onCommand',
-        'onDebug',
-        'onDebugInitialConfigurations',
-        'onDebugResolve',
-        'onDebugAdapterProtocolTracker',
-        'onDebugDynamicConfigurations',
-        'onTaskType',
-        'workspaceContains',
-        'onView',
-        'onUri',
-        'onTerminalProfile',
-        'onWebviewPanel',
-        'onFileSystem',
-        'onCustomEditor',
-        'onStartupFinished',
-        'onAuthenticationRequest',
-        'onNotebook',
-        'onNotebookSerializer'
-    ]);
-
     private configStorage: ConfigStorage | undefined;
     private readonly registry = new Map<string, Plugin>();
     private readonly activations = new Map<string, (() => Promise<void>)[] | undefined>();
@@ -113,6 +90,7 @@ export class PluginManagerExtImpl implements PluginManagerExt, PluginManager {
     private onDidChangeEmitter = new Emitter<void>();
     private messageRegistryProxy: MessageRegistryMain;
     private notificationMain: NotificationMain;
+    private supportedActivationEvents: Set<string>;
     protected fireOnDidChange(): void {
         this.onDidChangeEmitter.fire(undefined);
     }
@@ -206,7 +184,7 @@ export class PluginManagerExtImpl implements PluginManagerExt, PluginManager {
 
         this.envExt.setQueryParameters(params.env.queryParams);
         this.envExt.setLanguage(params.env.language);
-        this.envExt.setShell(params.env.shell);
+        this.terminalService.$setShell(params.env.shell);
         this.envExt.setUIKind(params.env.uiKind);
         this.envExt.setApplicationName(params.env.appName);
         this.envExt.setAppHost(params.env.appHost);
@@ -219,6 +197,8 @@ export class PluginManagerExtImpl implements PluginManagerExt, PluginManager {
 
         this.webview.init(params.webview);
         this.jsonValidation = params.jsonValidation;
+
+        this.supportedActivationEvents = new Set(params.supportedActivationEvents ?? []);
     }
 
     async $start(params: PluginManagerStartParams): Promise<void> {
@@ -263,7 +243,7 @@ export class PluginManagerExtImpl implements PluginManagerExt, PluginManager {
             const activation = () => this.$activatePlugin(plugin.model.id);
             // an internal activation event is a subject to change
             this.setActivation(`onPlugin:${plugin.model.id}`, activation);
-            const unsupportedActivationEvents = plugin.rawModel.activationEvents.filter(e => !PluginManagerExtImpl.SUPPORTED_ACTIVATION_EVENTS.has(e.split(':')[0]));
+            const unsupportedActivationEvents = plugin.rawModel.activationEvents.filter(e => !this.supportedActivationEvents.has(e.split(':')[0]));
             if (unsupportedActivationEvents.length) {
                 console.warn(`Unsupported activation events: ${unsupportedActivationEvents.join(', ')}, please open an issue: https://github.com/eclipse-theia/theia/issues/new`);
             }

package/src/plugin/status-bar/status-bar-item.ts

@@ -40,7 +40,7 @@ export class StatusBarItemImpl implements theia.StatusBarItem {
     private _accessibilityInformation: theia.AccessibilityInformation;
 
     private _isVisible: boolean;
-    private _timeoutHandle: NodeJS.Timer | undefined;
+    private _timeoutHandle: NodeJS.Timeout | undefined;
 
     _proxy: StatusBarMessageRegistryMain;
 

package/src/plugin/terminal-ext.ts

@@ -71,6 +71,10 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
 
     protected environmentVariableCollections: MultiKeyMap<string, EnvironmentVariableCollectionImpl> = new MultiKeyMap(2);
 
+    private shell: string;
+    private readonly onDidChangeShellEmitter = new Emitter<string>();
+    readonly onDidChangeShell: theia.Event<string> = this.onDidChangeShellEmitter.event;
+
     constructor(rpc: RPCProtocol) {
         this.proxy = rpc.getProxy(PLUGIN_RPC_CONTEXT.TERMINAL_MAIN);
     }
@@ -79,6 +83,17 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
         return [...this._terminals.values()];
     }
 
+    get defaultShell(): string {
+        return this.shell || '';
+    }
+
+    async $setShell(shell: string): Promise<void> {
+        if (this.shell !== shell) {
+            this.shell = shell;
+            this.onDidChangeShellEmitter.fire(shell);
+        }
+    }
+
     createTerminal(
         nameOrOptions: TerminalOptions | PseudoTerminalOptions | ExtensionTerminalOptions | (string | undefined),
         shellPath?: string, shellArgs?: string[] | string

package/src/plugin/tests.ts

@@ -40,10 +40,11 @@ import { TestItemImpl, TestItemCollection } from './test-item';
 import { AccumulatingTreeDeltaEmitter, TreeDelta } from '@theia/test/lib/common/tree-delta';
 import {
     TestItemDTO, TestOutputDTO, TestExecutionState, TestRunProfileDTO,
-    TestRunProfileKind, TestRunRequestDTO, TestStateChangeDTO, TestItemReference
+    TestRunProfileKind, TestRunRequestDTO, TestStateChangeDTO, TestItemReference, TestMessageArg, TestMessageDTO
 } from '../common/test-types';
 import { ChangeBatcher, observableProperty } from '@theia/test/lib/common/collections';
 import { TestRunRequest } from './types-impl';
+import { MarkdownString } from '../common/plugin-api-rpc-model';
 
 type RefreshHandler = (token: theia.CancellationToken) => void | theia.Thenable<void>;
 type ResolveHandler = (item: theia.TestItem | undefined) => theia.Thenable<void> | void;
@@ -335,6 +336,8 @@ export class TestingExtImpl implements TestingExt {
                     return this.toTestItem(arg);
                 } else if (Array.isArray(arg)) {
                     return arg.map(param => TestItemReference.is(param) ? this.toTestItem(param) : param);
+                } else if (TestMessageArg.is(arg)) {
+                    return this.fromTestMessageArg(arg);
                 } else {
                     return arg;
                 }
@@ -343,6 +346,27 @@ export class TestingExtImpl implements TestingExt {
 
     }
 
+    fromTestMessageArg(arg: TestMessageArg): { test?: theia.TestItem, message: theia.TestMessage } {
+        const testItem = arg.testItemReference ? this.toTestItem(arg.testItemReference) : undefined;
+        const message = this.toTestMessage(arg.testMessage);
+        return {
+            test: testItem,
+            message: message
+        };
+    }
+
+    toTestMessage(testMessage: TestMessageDTO): theia.TestMessage {
+        const message = MarkdownString.is(testMessage.message) ? Convert.toMarkdown(testMessage.message) : testMessage.message;
+
+        return {
+            message: message,
+            actualOutput: testMessage.actual,
+            expectedOutput: testMessage.expected,
+            contextValue: testMessage.contextValue,
+            location: testMessage.location ? Convert.toLocation(testMessage.location) : undefined
+        };
+    }
+
     toTestItem(ref: TestItemReference): theia.TestItem {
         const result = this.withController(ref.controllerId).items.find(ref.testPath);
         if (!result) {

package/src/plugin/text-editor.ts

@@ -277,7 +277,8 @@ export class TextEditorExt implements theia.TextEditor {
 }
 
 export class TextEditorOptionsExt implements theia.TextEditorOptions {
-    private _tabSize?: number;
+    private _tabSize: number;
+    private _indentSize: number | 'tabSize';
     private _insertSpace: boolean;
     private _cursorStyle: TextEditorCursorStyle;
     private _lineNumbers: TextEditorLineNumbersStyle;
@@ -289,12 +290,13 @@ export class TextEditorOptionsExt implements theia.TextEditorOptions {
 
     accept(source: TextEditorConfiguration): void {
         this._tabSize = source.tabSize;
+        this._indentSize = source.indentSize;
         this._insertSpace = source.insertSpaces;
         this._cursorStyle = source.cursorStyle;
         this._lineNumbers = source.lineNumbers;
     }
 
-    get tabSize(): number | string | undefined {
+    get tabSize(): number {
         return this._tabSize;
     }
 
@@ -305,10 +307,10 @@ export class TextEditorOptionsExt implements theia.TextEditorOptions {
         }
 
         if (typeof tabSize === 'number') {
-            if (this.tabSize === tabSize) {
+            if (this._tabSize === tabSize) {
                 return;
             }
-            this.tabSize = tabSize;
+            this._tabSize = tabSize;
         }
         warnOnError(this.proxy.$trySetOptions(this.id, {
             tabSize
@@ -334,6 +336,51 @@ export class TextEditorOptionsExt implements theia.TextEditorOptions {
         return undefined;
     }
 
+    get indentSize(): number {
+        if (this._indentSize === 'tabSize') {
+            return this.tabSize;
+        }
+        return this._indentSize;
+    }
+
+    set indentSize(val: number | string | undefined) {
+        const indentSize = this.validateIndentSize(val);
+        if (!indentSize) {
+            return; // ignore invalid values
+        }
+
+        if (typeof indentSize === 'number') {
+            if (this._indentSize === indentSize) {
+                return;
+            }
+            this._indentSize = indentSize;
+        } else if (val === 'tabSize') {
+            this._indentSize = val;
+        }
+        warnOnError(this.proxy.$trySetOptions(this.id, {
+            indentSize
+        }));
+    }
+
+    private validateIndentSize(val: number | string | undefined): number | 'tabSize' | undefined {
+        if (val === 'tabSize') {
+            return 'tabSize';
+        }
+
+        if (typeof val === 'number') {
+            const r = Math.floor(val);
+            return r > 0 ? r : undefined;
+        }
+        if (typeof val === 'string') {
+            const r = parseInt(val, undefined);
+            if (isNaN(r)) {
+                return undefined;
+            }
+            return r > 0 ? r : undefined;
+        }
+        return undefined;
+    }
+
     get insertSpaces(): boolean | string {
         return this._insertSpace;
     }
@@ -395,6 +442,19 @@ export class TextEditorOptionsExt implements theia.TextEditorOptions {
             }
         }
 
+        if (typeof newOptions.indentSize !== 'undefined') {
+            const indentSize = this.validateIndentSize(newOptions.indentSize);
+            if (indentSize === 'tabSize') {
+                hasUpdate = true;
+                configurationUpdate.indentSize = indentSize;
+            } else if (typeof indentSize === 'number' && this._indentSize !== indentSize) {
+                // reflect the new indentSize value immediately
+                this._indentSize = indentSize;
+                hasUpdate = true;
+                configurationUpdate.indentSize = indentSize;
+            }
+        }
+
         if (typeof newOptions.insertSpaces !== 'undefined') {
             const insertSpaces = this.validateInsertSpaces(newOptions.insertSpaces);
             if (insertSpaces === 'auto') {

package/src/plugin/type-converters.ts

@@ -31,8 +31,7 @@ import { DisposableCollection, Mutable, isEmptyObject, isObject } from '@theia/c
 import * as notebooks from '@theia/notebook/lib/common';
 import { CommandsConverter } from './command-registry';
 import { BinaryBuffer } from '@theia/core/lib/common/buffer';
-import { CellData, CellExecutionUpdateType, CellOutput, CellOutputItem, CellRange, isTextStreamMime } from '@theia/notebook/lib/common';
-import { CellExecuteUpdate, CellExecutionComplete } from '@theia/notebook/lib/browser';
+import { CellRange, isTextStreamMime } from '@theia/notebook/lib/common';
 import { MarkdownString as MarkdownStringDTO } from '@theia/core/lib/common/markdown-rendering';
 
 import { TestItemDTO, TestMessageDTO } from '../common/test-types';
@@ -1636,126 +1635,6 @@ export namespace NotebookKernelSourceAction {
     }
 }
 
-export namespace NotebookDto {
-
-    export function toNotebookOutputItemDto(item: CellOutputItem): rpc.NotebookOutputItemDto {
-        return {
-            mime: item.mime,
-            valueBytes: item.data
-        };
-    }
-
-    export function toNotebookOutputDto(output: CellOutput): rpc.NotebookOutputDto {
-        return {
-            outputId: output.outputId,
-            metadata: output.metadata,
-            items: output.outputs.map(toNotebookOutputItemDto)
-        };
-    }
-
-    export function toNotebookCellDataDto(cell: CellData): rpc.NotebookCellDataDto {
-        return {
-            cellKind: cell.cellKind,
-            language: cell.language,
-            source: cell.source,
-            internalMetadata: cell.internalMetadata,
-            metadata: cell.metadata,
-            outputs: cell.outputs.map(toNotebookOutputDto)
-        };
-    }
-
-    // export function toNotebookDataDto(data: NotebookData): rpc.NotebookDataDto {
-    //     return {
-    //         metadata: data.metadata,
-    //         cells: data.cells.map(toNotebookCellDataDto)
-    //     };
-    // }
-
-    export function fromNotebookOutputItemDto(item: rpc.NotebookOutputItemDto): CellOutputItem {
-        return {
-            mime: item.mime,
-            data: item.valueBytes
-        };
-    }
-
-    export function fromNotebookOutputDto(output: rpc.NotebookOutputDto): CellOutput {
-        return {
-            outputId: output.outputId,
-            metadata: output.metadata,
-            outputs: output.items.map(fromNotebookOutputItemDto)
-        };
-    }
-
-    export function fromNotebookCellDataDto(cell: rpc.NotebookCellDataDto): CellData {
-        return {
-            cellKind: cell.cellKind,
-            language: cell.language,
-            source: cell.source,
-            outputs: cell.outputs.map(fromNotebookOutputDto),
-            metadata: cell.metadata,
-            internalMetadata: cell.internalMetadata
-        };
-    }
-
-    // export function fromNotebookDataDto(data: rpc.NotebookDataDto): NotebookData {
-    //     return {
-    //         metadata: data.metadata,
-    //         cells: data.cells.map(fromNotebookCellDataDto)
-    //     };
-    // }
-
-    // export function toNotebookCellDto(cell: Cell): rpc.NotebookCellDto {
-    //     return {
-    //         handle: cell.handle,
-    //         uri: cell.uri,
-    //         source: cell.textBuffer.getLinesContent(),
-    //         eol: cell.textBuffer.getEOL(),
-    //         language: cell.language,
-    //         cellKind: cell.cellKind,
-    //         outputs: cell.outputs.map(toNotebookOutputDto),
-    //         metadata: cell.metadata,
-    //         internalMetadata: cell.internalMetadata,
-    //     };
-    // }
-
-    export function fromCellExecuteUpdateDto(data: rpc.CellExecuteUpdateDto): CellExecuteUpdate {
-        if (data.editType === CellExecutionUpdateType.Output) {
-            return {
-                editType: data.editType,
-                cellHandle: data.cellHandle,
-                append: data.append,
-                outputs: data.outputs.map(fromNotebookOutputDto)
-            };
-        } else if (data.editType === CellExecutionUpdateType.OutputItems) {
-            return {
-                editType: data.editType,
-                append: data.append,
-                outputId: data.outputId,
-                items: data.items.map(fromNotebookOutputItemDto)
-            };
-        } else {
-            return data;
-        }
-    }
-
-    export function fromCellExecuteCompleteDto(data: rpc.CellExecutionCompleteDto): CellExecutionComplete {
-        return data;
-    }
-
-    // export function fromCellEditOperationDto(edit: rpc.CellEditOperationDto): CellEditOperation {
-    //     if (edit.editType === CellEditType.Replace) {
-    //         return {
-    //             editType: edit.editType,
-    //             index: edit.index,
-    //             count: edit.count,
-    //             cells: edit.cells.map(fromNotebookCellDataDto)
-    //         };
-    //     } else {
-    //         return edit;
-    //     }
-    // }
-}
-
 export namespace TestMessage {
     export function from(message: theia.TestMessage | readonly theia.TestMessage[]): TestMessageDTO[] {
         if (isReadonlyArray(message)) {
@@ -1765,7 +1644,8 @@ export namespace TestMessage {
             location: fromLocation(message.location),
             message: fromMarkdown(message.message)!,
             expected: message.expectedOutput,
-            actual: message.actualOutput
+            actual: message.actualOutput,
+            contextValue: message.contextValue
         }];
     }
 }

package/src/plugin/types-impl.ts

@@ -845,6 +845,37 @@ export enum IndentAction {
     Outdent = 3
 }
 
+export namespace SyntaxTokenType {
+    export function toString(v: SyntaxTokenType | unknown): 'other' | 'comment' | 'string' | 'regex' {
+        switch (v) {
+            case SyntaxTokenType.Other: return 'other';
+            case SyntaxTokenType.Comment: return 'comment';
+            case SyntaxTokenType.String: return 'string';
+            case SyntaxTokenType.RegEx: return 'regex';
+        }
+        return 'other';
+    }
+}
+
+export enum SyntaxTokenType {
+    /**
+     * Everything except tokens that are part of comments, string literals and regular expressions.
+     */
+    Other = 0,
+    /**
+     * A comment.
+     */
+    Comment = 1,
+    /**
+     * A string literal.
+     */
+    String = 2,
+    /**
+     * A regular expression.
+     */
+    RegEx = 3
+}
+
 @es5ClassCompat
 export class TextEdit {
 
@@ -1657,6 +1688,7 @@ export class CodeActionKind {
     public static readonly Source = CodeActionKind.Empty.append('source');
     public static readonly SourceOrganizeImports = CodeActionKind.Source.append('organizeImports');
     public static readonly SourceFixAll = CodeActionKind.Source.append('fixAll');
+    public static readonly Notebook = CodeActionKind.Empty.append('notebook');
 
     constructor(
         public readonly value: string
@@ -3261,6 +3293,7 @@ export class TestMessage implements theia.TestMessage {
     public expectedOutput?: string;
     public actualOutput?: string;
     public location?: theia.Location;
+    public contextValue?: string;
 
     public static diff(message: string | theia.MarkdownString, expected: string, actual: string): theia.TestMessage {
         const msg = new TestMessage(message);

package/src/plugin/window-state.ts

@@ -19,7 +19,6 @@ import { WindowState } from '@theia/plugin';
 import { WindowStateExt, WindowMain, PLUGIN_RPC_CONTEXT } from '../common/plugin-api-rpc';
 import { Event, Emitter } from '@theia/core/lib/common/event';
 import { RPCProtocol } from '../common/rpc-protocol';
-import { Schemes } from '../common/uri-components';
 
 export class WindowStateExtImpl implements WindowStateExt {
 
@@ -50,6 +49,10 @@ export class WindowStateExtImpl implements WindowStateExt {
     }
 
     openUri(uri: URI): Promise<boolean> {
+        if (!uri.scheme.trim().length) {
+            throw new Error('Invalid scheme - cannot be empty');
+        }
+
         return this.proxy.$openUri(uri);
     }
 
@@ -57,9 +60,6 @@ export class WindowStateExtImpl implements WindowStateExt {
         if (!target.scheme.trim().length) {
             throw new Error('Invalid scheme - cannot be empty');
         }
-        if (Schemes.http !== target.scheme && Schemes.https !== target.scheme) {
-            throw new Error(`Invalid scheme '${target.scheme}'`);
-        }
 
         const uri = await this.proxy.$asExternalUri(target);
         return URI.revive(uri);