@theia/plugin-ext 1.50.1 → 1.52.0

package/src/plugin/tests.ts

@@ -135,21 +135,7 @@ export class TestControllerImpl implements theia.TestController {
     }
 
     createTestRun(request: theia.TestRunRequest, name?: string, persist: boolean = true): theia.TestRun {
-        return this.testRunStarted(request, name || '', persist, true);
-    }
-
-    dispose() {
-        this.proxy.$unregisterTestController(this.id);
-        this.onDispose();
-    }
-
-    protected testRunStarted(request: theia.TestRunRequest, name: string, persist: boolean, isRunning: boolean): TestRun {
-        const existing = this.activeRuns.get(request);
-        if (existing) {
-            return existing;
-        }
-
-        const run = new TestRun(this, this.proxy, name, persist, isRunning);
+        const run = new TestRun(this, this.proxy, name || '', persist, true, request.preserveFocus);
         const endListener = run.onWillFlush(() => {
             // make sure we notify the front end of test item changes before test run state is sent
             this.deltaBuilder.flush();
@@ -162,7 +148,12 @@ export class TestControllerImpl implements theia.TestController {
         return run;
     }
 
-    runTestsForUI(profileId: string, name: string, includedTests: string[][], excludedTests: string[][]): void {
+    dispose() {
+        this.proxy.$unregisterTestController(this.id);
+        this.onDispose();
+    }
+
+    runTestsForUI(profileId: string, name: string, includedTests: string[][], excludedTests: string[][], preserveFocus: boolean): void {
         const profile = this.getProfile(profileId);
         if (!profile) {
             console.error(`No test run profile found for controller ${this.id} with id ${profileId} `);
@@ -197,11 +188,11 @@ export class TestControllerImpl implements theia.TestController {
             .filter(isDefined);
 
         const request = new TestRunRequest(
-            includeTests, excludeTests, profile, false // don't support continuous run yet
+            includeTests, excludeTests, profile, false /* don't support continuous run yet */, preserveFocus
         );
 
-        const run = this.testRunStarted(request, name, false, false);
-        profile.runHandler(request, run.token);
+        // we do not cancel test runs via a cancellation token, but instead invoke "cancel" on the test runs
+        profile.runHandler(request, CancellationToken.None);
     }
 
     cancelRun(runId?: string): void {
@@ -235,7 +226,18 @@ function checkTestInstance(item?: theia.TestItem): TestItemImpl | undefined {
     return undefined;
 }
 
-class TestRun implements theia.TestRun {
+export function checkTestRunInstance(item: theia.TestRun): TestRun;
+export function checkTestRunInstance(item?: theia.TestRun): TestRun | undefined;
+export function checkTestRunInstance(item?: theia.TestRun): TestRun | undefined {
+    if (item instanceof TestRun) {
+        return <TestRun>item;
+    } else if (item) {
+        throw new Error('Not a TestRun instance');
+    }
+    return undefined;
+}
+
+export class TestRun implements theia.TestRun {
     private onDidEndEmitter = new Emitter<void>();
     onDidEnd: Event<void> = this.onDidEndEmitter.event;
     private onWillFlushEmitter = new Emitter<void>();
@@ -251,21 +253,25 @@ class TestRun implements theia.TestRun {
     }, 200);
     private ended: boolean;
     private tokenSource: CancellationTokenSource;
-    readonly token: CancellationToken;
 
     constructor(
-        private readonly controller: TestControllerImpl,
+        readonly controller: TestControllerImpl,
         private readonly proxy: TestingMain,
         readonly name: string,
         readonly isPersisted: boolean,
-        isRunning: boolean) {
+        isRunning: boolean,
+        preserveFocus: boolean) {
         this.id = generateUuid();
 
         this.tokenSource = new CancellationTokenSource();
-        this.token = this.tokenSource.token;
 
-        this.proxy.$notifyTestRunCreated(this.controller.id, { id: this.id, name: this.name, isRunning });
+        this.proxy.$notifyTestRunCreated(this.controller.id, { id: this.id, name: this.name, isRunning }, preserveFocus);
+    }
+
+    get token(): CancellationToken {
+        return this.tokenSource.token;
     }
+
     enqueued(test: theia.TestItem): void {
         this.updateTestState(test, { itemPath: checkTestInstance(test).path, state: TestExecutionState.Queued });
     }
@@ -444,7 +450,7 @@ export class TestingExtImpl implements TestingExt {
     }
 
     runTestsForUI(req: TestRunRequestDTO): void {
-        this.withController(req.controllerId).runTestsForUI(req.profileId, req.name, req.includedTests, req.excludedTests);
+        this.withController(req.controllerId).runTestsForUI(req.profileId, req.name, req.includedTests, req.excludedTests, req.preserveFocus);
     }
 
     /**
@@ -469,13 +475,7 @@ export class TestRunProfile implements theia.TestRunProfile {
         isDefault = false,
         tag: theia.TestTag | undefined = undefined,
     ) {
-        this.proxy = proxy;
-        this.label = label;
-        this.tag = tag;
-        this.label = label;
-        this.isDefault = isDefault;
-
-        this.proxy.$notifyTestRunProfileCreated(controllerId, {
+        proxy.$notifyTestRunProfileCreated(controllerId, {
             id: profileId,
             kind: kind,
             tag: tag ? tag.toString() : '',
@@ -483,6 +483,11 @@ export class TestRunProfile implements theia.TestRunProfile {
             isDefault: isDefault,
             canConfigure: false,
         });
+        this.proxy = proxy;
+        this.label = label;
+        this.tag = tag;
+        this.label = label;
+        this.isDefault = isDefault;
     }
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -509,7 +514,7 @@ export class TestRunProfile implements theia.TestRunProfile {
     }
 
     doSetDefault(isDefault: boolean): boolean {
-       if (this._isDefault !== isDefault) {
+        if (this._isDefault !== isDefault) {
             this._isDefault = isDefault;
             this.onDidChangeDefaultEmitter.fire(isDefault);
             return true;

package/src/plugin/tree/tree-views.ts

@@ -446,7 +446,7 @@ class TreeViewExtImpl<T> implements Disposable {
                 } else if (ThemeIcon.is(iconPath)) {
                     themeIcon = iconPath;
                 } else {
-                    iconUrl = PluginIconPath.toUrl(<PluginIconPath | undefined>iconPath, this.plugin);
+                    iconUrl = PluginIconPath.toUrl(iconPath, this.plugin);
                 }
 
                 let checkboxInfo;

package/src/plugin/type-converters.ts

@@ -16,7 +16,7 @@
 
 import * as theia from '@theia/plugin';
 import * as lstypes from '@theia/core/shared/vscode-languageserver-protocol';
-import { InlineValueEvaluatableExpression, InlineValueText, InlineValueVariableLookup, QuickPickItemKind, URI } from './types-impl';
+import { InlineValueEvaluatableExpression, InlineValueText, InlineValueVariableLookup, QuickPickItemKind, ThemeIcon, URI } from './types-impl';
 import * as rpc from '../common/plugin-api-rpc';
 import {
     DecorationOptions, EditorPosition, Plugin, Position, WorkspaceTextEditDto, WorkspaceFileEditDto, Selection, TaskDto, WorkspaceEditDto
@@ -35,7 +35,7 @@ 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 { ThemeIcon } from '@theia/monaco-editor-core/esm/vs/base/common/themables';
+import { PluginIconPath } from './plugin-icon-path';
 
 const SIDE_GROUP = -2;
 const ACTIVE_GROUP = -1;
@@ -1226,7 +1226,7 @@ export function convertIconPath(iconPath: types.URI | { light: types.URI; dark:
             dark: iconPath.dark.toJSON(),
             light: iconPath.light?.toJSON()
         };
-    } else if (ThemeIcon.isThemeIcon(iconPath)) {
+    } else if (ThemeIcon.is(iconPath)) {
         return {
             id: iconPath.id,
             color: iconPath.color ? { id: iconPath.color.id } : undefined
@@ -1236,19 +1236,19 @@ export function convertIconPath(iconPath: types.URI | { light: types.URI; dark:
     }
 }
 
-export function convertQuickInputButton(button: theia.QuickInputButton, index: number): rpc.TransferQuickInputButton {
+export function convertQuickInputButton(plugin: Plugin, button: theia.QuickInputButton, index: number): rpc.TransferQuickInputButton {
     const iconPath = convertIconPath(button.iconPath);
     if (!iconPath) {
         throw new Error(`Could not convert icon path: '${button.iconPath}'`);
     }
     return {
         handle: index,
-        iconPath: iconPath,
+        iconUrl: PluginIconPath.toUrl(iconPath, plugin) ?? ThemeIcon.get(iconPath),
         tooltip: button.tooltip
     };
 }
 
-export function convertToTransferQuickPickItems(items: (theia.QuickPickItem | string)[]): rpc.TransferQuickPickItem[] {
+export function convertToTransferQuickPickItems(plugin: Plugin, items: (theia.QuickPickItem | string)[]): rpc.TransferQuickPickItem[] {
     return items.map((item, index) => {
         if (typeof item === 'string') {
             return { kind: 'item', label: item, handle: index };
@@ -1260,11 +1260,11 @@ export function convertToTransferQuickPickItems(items: (theia.QuickPickItem | st
                 kind: 'item',
                 label,
                 description,
-                iconPath: convertIconPath(iconPath),
+                iconUrl: PluginIconPath.toUrl(iconPath, plugin) ?? ThemeIcon.get(iconPath),
                 detail,
                 picked,
                 alwaysShow,
-                buttons: buttons ? buttons.map(convertQuickInputButton) : undefined,
+                buttons: buttons ? buttons.map((button, i) => convertQuickInputButton(plugin, button, i)) : undefined,
                 handle: index,
             };
         }

package/src/plugin/types-impl.ts

@@ -744,6 +744,9 @@ export namespace ThemeIcon {
     export function is(item: unknown): item is ThemeIcon {
         return isObject(item) && 'id' in item;
     }
+    export function get(item: unknown): ThemeIcon | undefined {
+        return is(item) ? item : undefined;
+    }
 }
 
 export enum TextEditorRevealType {
@@ -3028,6 +3031,14 @@ export class FunctionBreakpoint extends Breakpoint {
     }
 }
 
+export class DebugThread implements theia.DebugThread {
+    constructor(readonly session: theia.DebugSession, readonly threadId: number) { }
+}
+
+export class DebugStackFrame implements theia.DebugStackFrame {
+      constructor(readonly session: theia.DebugSession, readonly threadId: number, readonly frameId: number) { }
+}
+
 @es5ClassCompat
 export class Color {
     readonly red: number;
@@ -3329,6 +3340,7 @@ export class TestRunRequest implements theia.TestRunRequest {
         public readonly exclude: theia.TestItem[] | undefined = undefined,
         public readonly profile: theia.TestRunProfile | undefined = undefined,
         public readonly continuous: boolean | undefined = undefined,
+        public readonly preserveFocus: boolean = true
     ) { }
 }
 
@@ -3351,7 +3363,7 @@ export class TestMessage implements theia.TestMessage {
 
 @es5ClassCompat
 export class TestCoverageCount {
-    constructor( public covered: number,  public total: number) { }
+    constructor(public covered: number, public total: number) { }
 }
 
 @es5ClassCompat
@@ -3846,3 +3858,144 @@ export class TerminalQuickFixOpener {
     constructor(uri: theia.Uri) { }
 }
 
+// #region Chat
+export class ChatRequestTurn {
+    readonly prompt: string;
+    readonly participant: string;
+    readonly command?: string;
+    readonly references: theia.ChatPromptReference[];
+    private constructor(prompt: string, command: string | undefined, references: theia.ChatPromptReference[], participant: string) {
+        this.prompt = prompt;
+        this.command = command;
+        this.participant = participant;
+        this.references = references;
+    };
+}
+
+export class ChatResponseTurn {
+    readonly command?: string;
+
+    private constructor(readonly response: ReadonlyArray<theia.ChatResponseMarkdownPart | theia.ChatResponseFileTreePart | theia.ChatResponseAnchorPart
+        | theia.ChatResponseCommandButtonPart>, readonly result: theia.ChatResult, readonly participant: string) { }
+}
+
+export class ChatResponseAnchorPart {
+    value: URI | Location;
+    title?: string;
+
+    constructor(value: URI | Location, title?: string) { }
+}
+
+export class ChatResponseProgressPart {
+    value: string;
+
+    constructor(value: string) { }
+}
+
+export class ChatResponseReferencePart {
+    value: URI | Location;
+    iconPath?: URI | ThemeIcon | { light: URI; dark: URI; };
+
+    constructor(value: URI | theia.Location, iconPath?: URI | ThemeIcon | {
+        light: URI;
+        dark: URI;
+    }) { }
+}
+export class ChatResponseCommandButtonPart {
+    value: theia.Command;
+
+    constructor(value: theia.Command) { }
+}
+
+export class ChatResponseMarkdownPart {
+    value: theia.MarkdownString;
+
+    constructor(value: string | theia.MarkdownString) {
+    }
+}
+
+export class ChatResponseFileTreePart {
+    value: theia.ChatResponseFileTree[];
+    baseUri: URI;
+
+    constructor(value: theia.ChatResponseFileTree[], baseUri: URI) { }
+}
+
+export type ChatResponsePart = ChatResponseMarkdownPart | ChatResponseFileTreePart | ChatResponseAnchorPart
+    | ChatResponseProgressPart | ChatResponseReferencePart | ChatResponseCommandButtonPart;
+
+export enum ChatResultFeedbackKind {
+    Unhelpful = 0,
+    Helpful = 1,
+}
+
+export enum LanguageModelChatMessageRole {
+    User = 1,
+    Assistant = 2
+}
+
+export class LanguageModelChatMessage {
+
+    static User(content: string, name?: string): LanguageModelChatMessage {
+        return new LanguageModelChatMessage(LanguageModelChatMessageRole.User, content, name);
+    }
+
+    static Assistant(content: string, name?: string): LanguageModelChatMessage {
+        return new LanguageModelChatMessage(LanguageModelChatMessageRole.Assistant, content, name);
+    }
+
+    constructor(public role: LanguageModelChatMessageRole, public content: string, public name?: string) { }
+}
+
+export class LanguageModelError extends Error {
+
+    static NoPermissions(message?: string): LanguageModelError {
+        return new LanguageModelError(message, LanguageModelError.NoPermissions.name);
+    }
+
+    static Blocked(message?: string): LanguageModelError {
+        return new LanguageModelError(message, LanguageModelError.Blocked.name);
+    }
+
+    static NotFound(message?: string): LanguageModelError {
+        return new LanguageModelError(message, LanguageModelError.NotFound.name);
+    }
+
+    readonly code: string;
+
+    constructor(message?: string, code?: string) {
+        super(message);
+        this.name = 'LanguageModelError';
+        this.code = code ?? '';
+    }
+}
+// #endregion
+
+// #region Port Attributes
+
+export enum PortAutoForwardAction {
+    Notify = 1,
+    OpenBrowser = 2,
+    OpenPreview = 3,
+    Silent = 4,
+    Ignore = 5
+}
+
+export class PortAttributes {
+    constructor(public autoForwardAction: PortAutoForwardAction) {
+    }
+}
+
+// #endregion
+
+// #region Debug Visualization
+
+export class DebugVisualization {
+    iconPath?: URI | { light: URI; dark: URI } | ThemeIcon;
+    visualization?: theia.Command | { treeId: string };
+
+    constructor(public name: string) {
+    }
+}
+
+// #endregion