@theia/plugin-ext 1.53.2 → 1.55.0-next.4

package/src/main/browser/text-editor-main.ts

@@ -33,11 +33,14 @@ import { Range } from '../../common/plugin-api-rpc-model';
 import { Emitter, Event } from '@theia/core';
 import { TextEditorCursorStyle, cursorStyleToString } from '../../common/editor-options';
 import { TextEditorLineNumbersStyle, EndOfLine } from '../../plugin/types-impl';
+import { SimpleMonacoEditor } from '@theia/monaco/lib/browser/simple-monaco-editor';
+import { EndOfLineSequence, ITextModel } from '@theia/monaco-editor-core/esm/vs/editor/common/model';
+import { EditorOption, RenderLineNumbersType } from '@theia/monaco-editor-core/esm/vs/editor/common/config/editorOptions';
 
 export class TextEditorMain implements Disposable {
 
     private properties: TextEditorPropertiesMain | undefined;
-    private editor: MonacoEditor | undefined;
+    private editor: MonacoEditor | SimpleMonacoEditor | undefined;
 
     private readonly onPropertiesChangedEmitter = new Emitter<EditorChangedPropertiesData>();
 
@@ -48,8 +51,8 @@ export class TextEditorMain implements Disposable {
 
     constructor(
         private id: string,
-        private model: monaco.editor.IModel,
-        editor: MonacoEditor
+        private model: monaco.editor.IModel | ITextModel,
+        editor: MonacoEditor | SimpleMonacoEditor
     ) {
         this.toDispose.push(this.model.onDidChangeOptions(() =>
             this.updateProperties(undefined)
@@ -76,7 +79,7 @@ export class TextEditorMain implements Disposable {
 
     protected readonly toDisposeOnEditor = new DisposableCollection();
 
-    private setEditor(editor?: MonacoEditor): void {
+    private setEditor(editor?: MonacoEditor | SimpleMonacoEditor): void {
         if (this.editor === editor) {
             return;
         }
@@ -115,7 +118,7 @@ export class TextEditorMain implements Disposable {
         return this.id;
     }
 
-    getModel(): monaco.editor.IModel {
+    getModel(): monaco.editor.IModel | ITextModel {
         return this.model;
     }
 
@@ -208,7 +211,7 @@ export class TextEditorMain implements Disposable {
     }
 
     revealRange(range: monaco.Range, revealType: TextEditorRevealType): void {
-        if (!this.editor) {
+        if (!this.editor || this.editor instanceof SimpleMonacoEditor) {
             return;
         }
         switch (revealType) {
@@ -240,10 +243,14 @@ export class TextEditorMain implements Disposable {
             return false;
         }
 
-        if (opts.setEndOfLine === EndOfLine.CRLF) {
+        if (opts.setEndOfLine === EndOfLine.CRLF && !this.isSimpleWidget(this.model)) {
             this.model.setEOL(monaco.editor.EndOfLineSequence.CRLF);
-        } else if (opts.setEndOfLine === EndOfLine.LF) {
+        } else if (opts.setEndOfLine === EndOfLine.LF && !this.isSimpleWidget(this.model)) {
             this.model.setEOL(monaco.editor.EndOfLineSequence.LF);
+        } else if (opts.setEndOfLine === EndOfLine.CRLF && this.isSimpleWidget(this.model)) {
+            this.model.setEOL(EndOfLineSequence.CRLF);
+        } else if (opts.setEndOfLine === EndOfLine.LF && this.isSimpleWidget(this.model)) {
+            this.model.setEOL(EndOfLineSequence.CRLF);
         }
 
         const editOperations: monaco.editor.IIdentifiedSingleEditOperation[] = [];
@@ -311,6 +318,10 @@ export class TextEditorMain implements Disposable {
     private static toMonacoSelections(selection: Selection): monaco.Selection {
         return new monaco.Selection(selection.selectionStartLineNumber, selection.selectionStartColumn, selection.positionLineNumber, selection.positionColumn);
     }
+
+    private isSimpleWidget(model: monaco.editor.IModel | ITextModel): model is ITextModel {
+        return !!(model as ITextModel).isForSimpleWidget;
+    }
 }
 
 // TODO move to monaco typings!
@@ -362,17 +373,26 @@ export class TextEditorPropertiesMain {
         return undefined;
     }
 
-    static readFromEditor(prevProperties: TextEditorPropertiesMain | undefined, model: monaco.editor.IModel, editor: MonacoEditor): TextEditorPropertiesMain {
+    static readFromEditor(prevProperties: TextEditorPropertiesMain | undefined,
+        model: monaco.editor.IModel | ITextModel,
+        editor: MonacoEditor | SimpleMonacoEditor): TextEditorPropertiesMain {
+
         const selections = TextEditorPropertiesMain.getSelectionsFromEditor(prevProperties, editor);
         const options = TextEditorPropertiesMain.getOptionsFromEditor(prevProperties, model, editor);
         const visibleRanges = TextEditorPropertiesMain.getVisibleRangesFromEditor(prevProperties, editor);
         return new TextEditorPropertiesMain(selections, options, visibleRanges);
     }
 
-    private static getSelectionsFromEditor(prevProperties: TextEditorPropertiesMain | undefined, editor: MonacoEditor): monaco.Selection[] {
+    private static getSelectionsFromEditor(prevProperties: TextEditorPropertiesMain | undefined, editor: MonacoEditor | SimpleMonacoEditor): monaco.Selection[] {
         let result: monaco.Selection[] | undefined = undefined;
-        if (editor) {
+        if (editor && editor instanceof MonacoEditor) {
             result = editor.getControl().getSelections() || undefined;
+        } else if (editor && editor instanceof SimpleMonacoEditor) {
+            result = editor.getControl().getSelections()?.map(selection => new monaco.Selection(
+                selection.startLineNumber,
+                selection.startColumn,
+                selection.positionLineNumber,
+                selection.positionColumn));
         }
 
         if (!result && prevProperties) {
@@ -385,14 +405,16 @@ export class TextEditorPropertiesMain {
         return result;
     }
 
-    private static getOptionsFromEditor(prevProperties: TextEditorPropertiesMain | undefined, model: monaco.editor.IModel, editor: MonacoEditor): TextEditorConfiguration {
+    private static getOptionsFromEditor(prevProperties: TextEditorPropertiesMain | undefined,
+        model: monaco.editor.IModel | ITextModel,
+        editor: MonacoEditor | SimpleMonacoEditor): TextEditorConfiguration {
         if (model.isDisposed()) {
             return prevProperties!.options;
         }
 
         let cursorStyle: TextEditorCursorStyle;
         let lineNumbers: TextEditorLineNumbersStyle;
-        if (editor) {
+        if (editor && editor instanceof MonacoEditor) {
             const editorOptions = editor.getControl().getOptions();
             const lineNumbersOpts = editorOptions.get(monaco.editor.EditorOption.lineNumbers);
             cursorStyle = editorOptions.get(monaco.editor.EditorOption.cursorStyle);
@@ -410,6 +432,25 @@ export class TextEditorPropertiesMain {
                     lineNumbers = TextEditorLineNumbersStyle.On;
                     break;
             }
+        } else if (editor && editor instanceof SimpleMonacoEditor) {
+            const editorOptions = editor.getControl().getOptions();
+            const lineNumbersOpts = editorOptions.get(EditorOption.lineNumbers);
+            cursorStyle = editorOptions.get(EditorOption.cursorStyle);
+            switch (lineNumbersOpts.renderType) {
+                case RenderLineNumbersType.Off:
+                    lineNumbers = TextEditorLineNumbersStyle.Off;
+                    break;
+                case RenderLineNumbersType.Relative:
+                    lineNumbers = TextEditorLineNumbersStyle.Relative;
+                    break;
+                case RenderLineNumbersType.Interval:
+                    lineNumbers = TextEditorLineNumbersStyle.Interval;
+                    break;
+                default:
+                    lineNumbers = TextEditorLineNumbersStyle.On;
+                    break;
+            }
+
         } else if (prevProperties) {
             cursorStyle = prevProperties.options.cursorStyle;
             lineNumbers = prevProperties.options.lineNumbers;
@@ -428,7 +469,7 @@ export class TextEditorPropertiesMain {
         };
     }
 
-    private static getVisibleRangesFromEditor(prevProperties: TextEditorPropertiesMain | undefined, editor: MonacoEditor): monaco.Range[] {
+    private static getVisibleRangesFromEditor(prevProperties: TextEditorPropertiesMain | undefined, editor: MonacoEditor | SimpleMonacoEditor): monaco.Range[] {
         if (editor) {
             return editor.getControl().getVisibleRanges();
         }

package/src/plugin/authentication-ext.ts

@@ -57,6 +57,10 @@ export class AuthenticationExtImpl implements AuthenticationExt {
         return this.proxy.$getSession(providerId, scopes, extensionId, extensionName, options);
     }
 
+    getAccounts(providerId: string): Thenable<readonly theia.AuthenticationSessionAccountInformation[]> {
+        return this.proxy.$getAccounts(providerId);
+    }
+
     registerAuthenticationProvider(id: string, label: string, provider: theia.AuthenticationProvider, options?: theia.AuthenticationProviderOptions): theia.Disposable {
         if (this.authenticationProviders.get(id)) {
             throw new Error(`An authentication provider with id '${id}' is already registered.`);
@@ -64,7 +68,7 @@ export class AuthenticationExtImpl implements AuthenticationExt {
 
         this.authenticationProviders.set(id, provider);
 
-        provider.getSessions().then(sessions => { // sessions might have been restored from secret storage
+        provider.getSessions(undefined, {}).then(sessions => { // sessions might have been restored from secret storage
             if (sessions.length > 0) {
                 this.proxy.$onDidChangeSessions(id, {
                     added: sessions,
@@ -87,10 +91,10 @@ export class AuthenticationExtImpl implements AuthenticationExt {
         });
     }
 
-    $createSession(providerId: string, scopes: string[]): Promise<theia.AuthenticationSession> {
+    $createSession(providerId: string, scopes: string[], options: theia.AuthenticationProviderSessionOptions): Promise<theia.AuthenticationSession> {
         const authProvider = this.authenticationProviders.get(providerId);
         if (authProvider) {
-            return Promise.resolve(authProvider.createSession(scopes));
+            return Promise.resolve(authProvider.createSession(scopes, options));
         }
 
         throw new Error(`Unable to find authentication provider with handle: ${providerId}`);
@@ -105,10 +109,10 @@ export class AuthenticationExtImpl implements AuthenticationExt {
         throw new Error(`Unable to find authentication provider with handle: ${providerId}`);
     }
 
-    async $getSessions(providerId: string, scopes?: string[]): Promise<ReadonlyArray<theia.AuthenticationSession>> {
+    async $getSessions(providerId: string, scopes: string[] | undefined, options: theia.AuthenticationProviderSessionOptions): Promise<ReadonlyArray<theia.AuthenticationSession>> {
         const authProvider = this.authenticationProviders.get(providerId);
         if (authProvider) {
-            const sessions = await authProvider.getSessions(scopes);
+            const sessions = await authProvider.getSessions(scopes, options);
 
             /* Wrap the session object received from the plugin to prevent serialization mismatches
             e.g. if the plugin object is constructed with the help of getters they won't be serialized:

package/src/plugin/notebook/notebooks.ts

@@ -97,6 +97,13 @@ export class NotebooksExtImpl implements NotebooksExt {
                 }
             }
         });
+
+        textDocumentsAndEditors.onDidChangeActiveTextEditor(e => {
+            if (e && e?.document.uri.scheme !== CellUri.cellUriScheme && this.activeNotebookEditor) {
+                this.activeNotebookEditor = undefined;
+                this.onDidChangeActiveNotebookEditorEmitter.fire(undefined);
+            }
+        });
     }
 
     async $provideNotebookCellStatusBarItems(handle: number, uri: UriComponents, index: number, token: CancellationToken): Promise<NotebookCellStatusBarListDto | undefined> {
@@ -131,6 +138,15 @@ export class NotebooksExtImpl implements NotebooksExt {
         this.statusBarRegistry.delete(cacheId);
     }
 
+    $acceptActiveCellEditorChange(newActiveEditor: string | null): void {
+        const newActiveEditorId = this.textDocumentsAndEditors.allEditors().find(editor => editor.document.uri.toString() === newActiveEditor)?.id;
+        if (newActiveEditorId || newActiveEditor === null) {
+            this.textDocumentsAndEditors.acceptEditorsAndDocumentsDelta({
+                newActiveEditor: newActiveEditorId ?? null
+            });
+        }
+    }
+
     // --- serialize/deserialize
 
     private currentSerializerHandle = 0;
@@ -319,6 +335,11 @@ export class NotebooksExtImpl implements NotebooksExt {
                 console.error(`FAILED to find active notebook editor ${delta.newActiveEditor}`);
             }
             this.activeNotebookEditor = this.editors.get(delta.newActiveEditor);
+            if (this.textDocumentsAndEditors.activeEditor()?.document.uri.path !== this.activeNotebookEditor?.notebookData.uri.path) {
+                this.textDocumentsAndEditors.acceptEditorsAndDocumentsDelta({
+                    newActiveEditor: null
+                });
+            }
         }
         if (delta.newActiveEditor !== undefined) {
             this.onDidChangeActiveNotebookEditorEmitter.fire(this.activeNotebookEditor?.apiEditor);

package/src/plugin/plugin-context.ts

@@ -187,6 +187,7 @@ import {
     TestTag,
     TestRunRequest,
     TestMessage,
+    TestMessageStackFrame,
     ExtensionKind,
     InlineCompletionItem,
     InlineCompletionList,
@@ -338,6 +339,9 @@ export function createAPIFactory(
             },
             get onDidChangeSessions(): theia.Event<theia.AuthenticationSessionsChangeEvent> {
                 return authenticationExt.onDidChangeSessions;
+            },
+            getAccounts(providerId: string): Thenable<readonly theia.AuthenticationSessionAccountInformation[]> {
+                return authenticationExt.getAccounts(providerId);
             }
         };
         function commandIsDeclaredInPackage(id: string, model: PluginPackage): boolean {
@@ -881,7 +885,7 @@ export function createAPIFactory(
 
         const extensions: typeof theia.extensions = Object.freeze({
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            getExtension<T = any>(extensionId: string, includeFromDifferentExtensionHosts: boolean = false): theia.Extension<T> | undefined {
+            getExtension<T = any>(extensionId: string, includeFromDifferentExtensionHosts: boolean = false): theia.Extension<T | undefined> | undefined {
                 includeFromDifferentExtensionHosts = false;
                 const plg = pluginManager.getPluginById(extensionId.toLowerCase());
                 if (plg) {
@@ -1460,6 +1464,7 @@ export function createAPIFactory(
             TestTag,
             TestRunRequest,
             TestMessage,
+            TestMessageStackFrame,
             ExtensionKind,
             InlineCompletionItem,
             InlineCompletionList,

package/src/plugin/terminal-ext.ts

@@ -478,6 +478,7 @@ export class TerminalExtImpl implements theia.Terminal {
         this.creationOptions = this.options;
     }
 
+    /** @stubbed Terminal Shell Ingration */
     shellIntegration: theia.TerminalShellIntegration | undefined = undefined;
 
     sendText(text: string, shouldExecute: boolean = true): void {

package/src/plugin/tests.ts

@@ -40,10 +40,12 @@ 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, TestMessageArg, TestMessageDTO
+    TestRunProfileKind, TestRunRequestDTO, TestStateChangeDTO, TestItemReference, TestMessageArg, TestMessageDTO,
+    TestMessageStackFrameDTO
 } from '../common/test-types';
+import * as protocol from '@theia/core/shared/vscode-languageserver-protocol';
 import { ChangeBatcher, observableProperty } from '@theia/test/lib/common/collections';
-import { TestRunRequest } from './types-impl';
+import { Location, Position, Range, TestRunRequest, URI } from './types-impl';
 import { MarkdownString } from '../common/plugin-api-rpc-model';
 
 type RefreshHandler = (token: theia.CancellationToken) => void | theia.Thenable<void>;
@@ -374,7 +376,36 @@ export class TestingExtImpl implements TestingExt {
             actualOutput: testMessage.actual,
             expectedOutput: testMessage.expected,
             contextValue: testMessage.contextValue,
-            location: testMessage.location ? Convert.toLocation(testMessage.location) : undefined
+            location: this.toLocation(testMessage.location),
+            stackTrace: testMessage.stackTrace ? testMessage.stackTrace.map(frame => this.toStackFrame(frame)) : undefined
+        };
+    }
+
+    toLocation(location: protocol.Location | undefined): Location | undefined {
+        if (!location) {
+            return undefined;
+        }
+        return new Location(URI.parse(location.uri), this.toRange(location.range));
+    }
+
+    toRange(range: protocol.Range): Range {
+        return new Range(this.toPosition(range.start), this.toPosition(range.end));
+    }
+
+    toPosition(position: protocol.Position): Position;
+    toPosition(position: protocol.Position | undefined): Position | undefined;
+    toPosition(position: protocol.Position | undefined): Position | undefined {
+        if (!position) {
+            return undefined;
+        }
+        return new Position(position.line, position.character);
+    }
+
+    toStackFrame(stackFrame: TestMessageStackFrameDTO): theia.TestMessageStackFrame {
+        return {
+            label: stackFrame.label,
+            position: this.toPosition(stackFrame.position),
+            uri: stackFrame.uri ? URI.parse(stackFrame.uri) : undefined
         };
     }
 

package/src/plugin/text-editor.ts

@@ -30,7 +30,7 @@ export class TextEditorExt implements theia.TextEditor {
     private disposed = false;
     constructor(
         private readonly proxy: TextEditorsMain,
-        private readonly id: string,
+        readonly id: string,
         document: DocumentDataExt,
         private _selections: Selection[],
         options: TextEditorConfiguration,

package/src/plugin/type-converters.ts

@@ -34,7 +34,7 @@ import { BinaryBuffer } from '@theia/core/lib/common/buffer';
 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';
+import { TestItemDTO, TestMessageDTO, TestMessageStackFrameDTO } from '../common/test-types';
 import { PluginIconPath } from './plugin-icon-path';
 
 const SIDE_GROUP = -2;
@@ -134,12 +134,21 @@ export function fromRange(range: theia.Range | undefined): model.Range | undefin
         endColumn: end.character + 1
     };
 }
-
-export function fromPosition(position: types.Position | theia.Position): Position {
+export function fromPosition(position: types.Position | theia.Position): Position;
+export function fromPosition(position: types.Position | theia.Position | undefined): Position | undefined;
+export function fromPosition(position: types.Position | theia.Position | undefined): Position | undefined {
+    if (!position) {
+        return undefined;
+    }
     return { lineNumber: position.line + 1, column: position.character + 1 };
 }
 
-export function toPosition(position: Position): types.Position {
+export function toPosition(position: Position): types.Position;
+export function toPosition(position: Position | undefined): types.Position | undefined;
+export function toPosition(position: Position | undefined): types.Position | undefined {
+    if (!position) {
+        return undefined;
+    }
     return new types.Position(position.lineNumber - 1, position.column - 1);
 }
 
@@ -474,6 +483,18 @@ export function fromLocation(location: theia.Location | undefined): model.Locati
     };
 }
 
+export function fromLocationToLanguageServerLocation(location: theia.Location): lstypes.Location;
+export function fromLocationToLanguageServerLocation(location: theia.Location | undefined): lstypes.Location | undefined;
+export function fromLocationToLanguageServerLocation(location: theia.Location | undefined): lstypes.Location | undefined {
+    if (!location) {
+        return undefined;
+    }
+    return <lstypes.Location>{
+        uri: location.uri.toString(),
+        range: location.range
+    };
+}
+
 export function fromTextDocumentShowOptions(options: theia.TextDocumentShowOptions): model.TextDocumentShowOptions {
     if (options.selection) {
         return {
@@ -731,6 +752,26 @@ export function toSymbolTag(kind: model.SymbolTag): types.SymbolTag {
     }
 }
 
+/**
+ * Creates a merged symbol of type theia.SymbolInformation & theia.DocumentSymbol.
+ * Is only used as the result type of the `vscode.executeDocumentSymbolProvider` command.
+ */
+export function toMergedSymbol(uri: UriComponents, symbol: model.DocumentSymbol): theia.SymbolInformation & theia.DocumentSymbol {
+    const uriValue = URI.revive(uri);
+    const location = new types.Location(uriValue, toRange(symbol.range));
+    return {
+        name: symbol.name,
+        containerName: symbol.containerName ?? '',
+        kind: SymbolKind.toSymbolKind(symbol.kind),
+        tags: [],
+        location,
+        detail: symbol.detail,
+        range: location.range,
+        selectionRange: toRange(symbol.selectionRange),
+        children: symbol.children?.map(child => toMergedSymbol(uri, child)) ?? []
+    };
+}
+
 export function isModelLocation(arg: unknown): arg is model.Location {
     return isObject<model.Location>(arg) &&
         isModelRange(arg.range) &&
@@ -1677,15 +1718,26 @@ export namespace TestMessage {
             return message.map(msg => TestMessage.from(msg)[0]);
         }
         return [{
-            location: fromLocation(message.location),
+            location: fromLocationToLanguageServerLocation(message.location),
             message: fromMarkdown(message.message)!,
             expected: message.expectedOutput,
             actual: message.actualOutput,
-            contextValue: message.contextValue
+            contextValue: message.contextValue,
+            stackTrace: message.stackTrace && message.stackTrace.map(frame => TestMessageStackFrame.from(frame))
         }];
     }
 }
 
+export namespace TestMessageStackFrame {
+    export function from(stackTrace: theia.TestMessageStackFrame): TestMessageStackFrameDTO {
+        return {
+            label: stackTrace.label,
+            position: stackTrace.position,
+            uri: stackTrace?.uri?.toString()
+        };
+    }
+}
+
 export namespace TestItem {
     export function from(test: theia.TestItem): TestItemDTO {
         return <TestItemDTO>TestItem.fromPartial(test);

package/src/plugin/types-impl.ts

@@ -3036,7 +3036,7 @@ export class DebugThread implements theia.DebugThread {
 }
 
 export class DebugStackFrame implements theia.DebugStackFrame {
-      constructor(readonly session: theia.DebugSession, readonly threadId: number, readonly frameId: number) { }
+    constructor(readonly session: theia.DebugSession, readonly threadId: number, readonly frameId: number) { }
 }
 
 @es5ClassCompat
@@ -3350,6 +3350,7 @@ export class TestMessage implements theia.TestMessage {
     public actualOutput?: string;
     public location?: theia.Location;
     public contextValue?: string;
+    public stackTrace?: theia.TestMessageStackFrame[] | undefined;
 
     public static diff(message: string | theia.MarkdownString, expected: string, actual: string): theia.TestMessage {
         const msg = new TestMessage(message);
@@ -3366,6 +3367,14 @@ export class TestCoverageCount {
     constructor(public covered: number, public total: number) { }
 }
 
+export class TestMessageStackFrame implements theia.TestMessageStackFrame {
+    constructor(
+        public label: string,
+        public uri?: theia.Uri,
+        public position?: Position
+    ) { }
+}
+
 @es5ClassCompat
 export class FileCoverage {