@codingame/monaco-vscode-api 1.83.16 → 1.85.0-next.1

package/vscode/src/vs/workbench/api/common/extHostChatProvider.js

@@ -1,8 +1,65 @@
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
 import { toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { MainContext } from './extHost.protocol.js';
 import { ChatMessage } from './extHostTypeConverters.js';
 import { Progress } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
 import { ExtensionIdentifierMap } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
+import { AsyncIterableSource } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+class ChatResponseStream {
+    constructor(option, stream) {
+        this.stream = ( new AsyncIterableSource());
+        this.stream = stream ?? ( new AsyncIterableSource());
+        const that = this;
+        this.apiObj = {
+            option: option,
+            response: that.stream.asyncIterable
+        };
+    }
+}
+class ChatRequest {
+    constructor(promise, cts) {
+        this._onDidStart = ( new Emitter());
+        this._responseStreams = ( new Map());
+        this._defaultStream = ( new AsyncIterableSource());
+        this._isDone = false;
+        const that = this;
+        this.apiObject = {
+            result: promise,
+            response: that._defaultStream.asyncIterable,
+            onDidStartResponseStream: that._onDidStart.event,
+            cancel() { cts.cancel(); },
+        };
+        promise.finally(() => {
+            this._isDone = true;
+            if (this._responseStreams.size > 0) {
+                for (const [, value] of this._responseStreams) {
+                    value.stream.resolve();
+                }
+            }
+            else {
+                this._defaultStream.resolve();
+            }
+        });
+    }
+    handleFragment(fragment) {
+        if (this._isDone) {
+            return;
+        }
+        let res = this._responseStreams.get(fragment.index);
+        if (!res) {
+            if (this._responseStreams.size === 0) {
+                res = ( new ChatResponseStream(fragment.index, this._defaultStream));
+            }
+            else {
+                res = ( new ChatResponseStream(fragment.index));
+            }
+            this._responseStreams.set(fragment.index, res);
+            this._onDidStart.fire(res.apiObj);
+        }
+        res.stream.emitOne(fragment.part);
+    }
+}
 class ExtHostChatProvider {
     static { this._idPool = 1; }
     constructor(mainContext, _logService) {
@@ -15,7 +72,7 @@ class ExtHostChatProvider {
     registerProvider(extension, identifier, provider, metadata) {
         const handle = ExtHostChatProvider._idPool++;
         this._providers.set(handle, { extension, provider });
-        this._proxy.$registerProvider(handle, identifier, { extension, displayName: metadata.name ?? extension.value });
+        this._proxy.$registerProvider(handle, identifier, { extension, model: metadata.name ?? '' });
         return toDisposable(() => {
             this._proxy.$unregisterProvider(handle);
             this._providers.delete(handle);
@@ -31,8 +88,8 @@ class ExtHostChatProvider {
                 this._logService.warn(`[CHAT](${data.extension.value}) CANNOT send progress because the REQUEST IS CANCELLED`);
                 return;
             }
-            await this._proxy.$handleProgressChunk(requestId, { index: fragment.index, part: fragment.part });
-        }, { async: true }));
+            this._proxy.$handleProgressChunk(requestId, { index: fragment.index, part: fragment.part });
+        }));
         return data.provider.provideChatResponse(( messages.map(ChatMessage.to)), options, progress, token);
     }
     allowListExtensionWhile(extension, promise) {
@@ -43,28 +100,39 @@ class ExtHostChatProvider {
         if (!( this._chatAccessAllowList.has(from))) {
             throw new Error('Extension is NOT allowed to make chat requests');
         }
+        const metadata = await this._proxy.$prepareChatAccess(identifier);
+        if (!metadata) {
+            throw new Error(`ChatAccess '${identifier}' NOT found`);
+        }
         const that = this;
         return {
+            get model() {
+                return metadata.model;
+            },
             get isRevoked() {
                 return !( that._chatAccessAllowList.has(from));
             },
-            async makeRequest(messages, options, progress, token) {
+            makeRequest(messages, options, token) {
                 if (!( that._chatAccessAllowList.has(from))) {
                     throw new Error('Access to chat has been revoked');
                 }
+                const cts = ( new CancellationTokenSource(token));
                 const requestId = (Math.random() * 1e6) | 0;
-                that._pendingRequest.set(requestId, progress);
-                try {
-                    await that._proxy.$fetchResponse(from, identifier, requestId, ( messages.map(ChatMessage.from)), options, token);
-                }
-                finally {
+                const requestPromise = that._proxy.$fetchResponse(from, identifier, requestId, ( messages.map(ChatMessage.from)), options ?? {}, cts.token);
+                const res = ( new ChatRequest(requestPromise, cts));
+                that._pendingRequest.set(requestId, { res });
+                requestPromise.finally(() => {
                     that._pendingRequest.delete(requestId);
-                }
+                });
+                return res.apiObject;
             },
         };
     }
     async $handleResponseFragment(requestId, chunk) {
-        this._pendingRequest.get(requestId)?.report(chunk);
+        const data = this._pendingRequest.get(requestId);
+        if (data) {
+            data.res.handleFragment(chunk);
+        }
     }
 }
 export { ExtHostChatProvider };

package/vscode/src/vs/workbench/api/common/extHostCommands.js

@@ -20,6 +20,7 @@ import { toErrorMessage } from 'monaco-editor/esm/vs/base/common/errorMessage.js
 import { StopWatch } from 'monaco-editor/esm/vs/base/common/stopwatch.js';
 import { TelemetryTrustedValue } from '../../../platform/telemetry/common/telemetryUtils.js';
 import { IExtHostTelemetry } from './extHostTelemetry.js';
+import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
 let ExtHostCommands = class ExtHostCommands {
     #proxy;
     #telemetry;
@@ -89,7 +90,7 @@ let ExtHostCommands = class ExtHostCommands {
             this._apiCommands.delete(apiCommand.id);
         });
     }
-    registerCommand(global, id, callback, thisArg, description, extension) {
+    registerCommand(global, id, callback, thisArg, metadata, extension) {
         this._logService.trace('ExtHostCommands#registerCommand', id);
         if (!id.trim().length) {
             throw new Error('invalid id');
@@ -97,7 +98,7 @@ let ExtHostCommands = class ExtHostCommands {
         if (( this._commands.has(id))) {
             throw new Error(`command '${id}' already exists`);
         }
-        this._commands.set(id, { callback, thisArg, description, extension });
+        this._commands.set(id, { callback, thisArg, metadata, extension });
         if (global) {
             this.#proxy.$registerCommand(id);
         }
@@ -168,14 +169,14 @@ let ExtHostCommands = class ExtHostCommands {
         if (!command) {
             throw new Error('Unknown command');
         }
-        const { callback, thisArg, description } = command;
-        if (description) {
-            for (let i = 0; i < description.args.length; i++) {
+        const { callback, thisArg, metadata } = command;
+        if (metadata?.args) {
+            for (let i = 0; i < metadata.args.length; i++) {
                 try {
-                    validateConstraint(args[i], description.args[i].constraint);
+                    validateConstraint(args[i], metadata.args[i].constraint);
                 }
                 catch (err) {
-                    throw new Error(`Running the contributed command: '${id}' failed.Illegal argument '${description.args[i].name}' - ${description.args[i].description} `);
+                    throw new Error(`Running the contributed command: '${id}' failed. Illegal argument '${metadata.args[i].name}' - ${metadata.args[i].description}`);
                 }
             }
         }
@@ -242,12 +243,12 @@ let ExtHostCommands = class ExtHostCommands {
             return result;
         });
     }
-    $getContributedCommandHandlerDescriptions() {
+    $getContributedCommandMetadata() {
         const result = Object.create(null);
         for (const [id, command] of this._commands) {
-            const { description } = command;
-            if (description) {
-                result[id] = description;
+            const { metadata } = command;
+            if (metadata) {
+                result[id] = metadata;
             }
         }
         return Promise.resolve(result);
@@ -264,7 +265,7 @@ class CommandsConverter {
         this._commands = _commands;
         this._lookupApiCommand = _lookupApiCommand;
         this._logService = _logService;
-        this.delegatingCommandId = `__vsc${( Date.now().toString(36))} `;
+        this.delegatingCommandId = `__vsc${generateUuid()}`;
         this._cache = ( new Map());
         this._cachIdPool = 0;
         this._commands.registerCommand(true, this.delegatingCommandId, this._executeConvertedCommand, this);

package/vscode/src/vs/workbench/api/common/extHostComments.js

@@ -106,7 +106,7 @@ function createExtHostComments(mainContext, commands, documents) {
             this._commentControllersByExtension.set(extension.identifier, commentControllers);
             return commentController.value;
         }
-        $createCommentThreadTemplate(commentControllerHandle, uriComponents, range) {
+        async $createCommentThreadTemplate(commentControllerHandle, uriComponents, range) {
             const commentController = this._commentControllers.get(commentControllerHandle);
             if (!commentController) {
                 return;

package/vscode/src/vs/workbench/api/common/extHostEditorTabs.js

@@ -1,13 +1,13 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { ViewColumn } from './extHostTypeConverters.js';
-import { MainContext } from './extHost.protocol.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { diffSets } from 'monaco-editor/esm/vs/base/common/collections.js';
 import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { InteractiveWindowInput, TerminalEditorTabInput, NotebookDiffEditorTabInput, NotebookEditorTabInput, WebviewEditorTabInput, CustomEditorTabInput, TextMergeTabInput, TextDiffTabInput, TextTabInput } from './extHostTypes.js';
+import { MainContext } from './extHost.protocol.js';
 import { IExtHostRpcService } from './extHostRpcService.js';
-import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
-import { diffSets } from 'monaco-editor/esm/vs/base/common/collections.js';
+import { ViewColumn } from './extHostTypeConverters.js';
+import { ChatEditorTabInput, InteractiveWindowInput, TerminalEditorTabInput, NotebookDiffEditorTabInput, NotebookEditorTabInput, WebviewEditorTabInput, CustomEditorTabInput, TextMergeTabInput, TextDiffTabInput, TextTabInput } from './extHostTypes.js';
 const IExtHostEditorTabs = ( createDecorator('IExtHostEditorTabs'));
 class ExtHostEditorTab {
     constructor(dto, parentGroup, activeTabIdGetter) {
@@ -81,6 +81,8 @@ class ExtHostEditorTab {
                 return ( new TerminalEditorTabInput());
             case 9 :
                 return ( new InteractiveWindowInput(URI.revive(this._dto.input.uri), URI.revive(this._dto.input.inputBoxUri)));
+            case 10 :
+                return ( new ChatEditorTabInput(this._dto.input.providerId));
             default:
                 return undefined;
         }

package/vscode/src/vs/workbench/api/common/extHostExtensionService.js

@@ -891,7 +891,7 @@ class SyncedActivationEventsReader {
         this.addActivationEvents(activationEvents);
     }
     readActivationEvents(extensionDescription) {
-        return this._map.get(extensionDescription.identifier);
+        return this._map.get(extensionDescription.identifier) ?? [];
     }
     addActivationEvents(activationEvents) {
         for (const extensionId of ( Object.keys(activationEvents))) {

package/vscode/src/vs/workbench/api/common/extHostFileSystemEventService.js

@@ -4,6 +4,7 @@ import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { MainContext } from './extHost.protocol.js';
 import { GlobPattern, WorkspaceEdit as WorkspaceEdit$1 } from './extHostTypeConverters.js';
 import { WorkspaceEdit, Disposable } from './extHostTypes.js';
+import { Lazy } from 'monaco-editor/esm/vs/base/common/lazy.js';
 class FileSystemWatcher {
     get ignoreCreateEvents() {
         return Boolean(this._config & 0b001);
@@ -14,25 +15,32 @@ class FileSystemWatcher {
     get ignoreDeleteEvents() {
         return Boolean(this._config & 0b100);
     }
-    constructor(mainContext, workspace, extension, dispatcher, globPattern, ignoreCreateEvents, ignoreChangeEvents, ignoreDeleteEvents) {
+    constructor(mainContext, workspace, extension, dispatcher, globPattern, options) {
+        this.session = Math.random();
         this._onDidCreate = ( new Emitter());
         this._onDidChange = ( new Emitter());
         this._onDidDelete = ( new Emitter());
-        const watcherDisposable = this.ensureWatching(mainContext, extension, globPattern);
         this._config = 0;
-        if (ignoreCreateEvents) {
+        if (options?.ignoreCreateEvents) {
             this._config += 0b001;
         }
-        if (ignoreChangeEvents) {
+        if (options?.ignoreChangeEvents) {
             this._config += 0b010;
         }
-        if (ignoreDeleteEvents) {
+        if (options?.ignoreDeleteEvents) {
             this._config += 0b100;
         }
         const parsedPattern = parse(globPattern);
         const excludeOutOfWorkspaceEvents = typeof globPattern === 'string';
+        const excludeUncorrelatedEvents = options?.correlate;
         const subscription = dispatcher(events => {
-            if (!ignoreCreateEvents) {
+            if (typeof events.session === 'number' && events.session !== this.session) {
+                return;
+            }
+            if (excludeUncorrelatedEvents && typeof events.session === 'undefined') {
+                return;
+            }
+            if (!options?.ignoreCreateEvents) {
                 for (const created of events.created) {
                     const uri = URI.revive(created);
                     if (parsedPattern(uri.fsPath) && (!excludeOutOfWorkspaceEvents || workspace.getWorkspaceFolder(uri))) {
@@ -40,7 +48,7 @@ class FileSystemWatcher {
                     }
                 }
             }
-            if (!ignoreChangeEvents) {
+            if (!options?.ignoreChangeEvents) {
                 for (const changed of events.changed) {
                     const uri = URI.revive(changed);
                     if (parsedPattern(uri.fsPath) && (!excludeOutOfWorkspaceEvents || workspace.getWorkspaceFolder(uri))) {
@@ -48,7 +56,7 @@ class FileSystemWatcher {
                     }
                 }
             }
-            if (!ignoreDeleteEvents) {
+            if (!options?.ignoreDeleteEvents) {
                 for (const deleted of events.deleted) {
                     const uri = URI.revive(deleted);
                     if (parsedPattern(uri.fsPath) && (!excludeOutOfWorkspaceEvents || workspace.getWorkspaceFolder(uri))) {
@@ -57,21 +65,20 @@ class FileSystemWatcher {
                 }
             }
         });
-        this._disposable = Disposable.from(watcherDisposable, this._onDidCreate, this._onDidChange, this._onDidDelete, subscription);
+        this._disposable = Disposable.from(this.ensureWatching(mainContext, extension, globPattern, options, options?.correlate), this._onDidCreate, this._onDidChange, this._onDidDelete, subscription);
     }
-    ensureWatching(mainContext, extension, globPattern) {
+    ensureWatching(mainContext, extension, globPattern, options, correlate) {
         const disposable = Disposable.from();
         if (typeof globPattern === 'string') {
             return disposable;
         }
-        const proxy = ( mainContext.getProxy(MainContext.MainThreadFileSystem));
+        const proxy = ( mainContext.getProxy(MainContext.MainThreadFileSystemEventService));
         let recursive = false;
         if (globPattern.pattern.includes(GLOBSTAR) || globPattern.pattern.includes(GLOB_SPLIT)) {
             recursive = true;
         }
-        const session = Math.random();
-        proxy.$watch(extension.identifier.value, session, globPattern.baseUri, { recursive, excludes: []  });
-        return Disposable.from({ dispose: () => proxy.$unwatch(session) });
+        proxy.$watch(extension.identifier.value, this.session, globPattern.baseUri, { recursive, excludes: options?.excludes ?? [] }, Boolean(correlate));
+        return Disposable.from({ dispose: () => proxy.$unwatch(this.session) });
     }
     dispose() {
         this._disposable.dispose();
@@ -86,6 +93,18 @@ class FileSystemWatcher {
         return this._onDidDelete.event;
     }
 }
+class LazyRevivedFileSystemEvents {
+    constructor(_events) {
+        this._events = _events;
+        this.session = this._events.session;
+        this._created = ( new Lazy(() => ( this._events.created.map(URI.revive))));
+        this._changed = ( new Lazy(() => ( this._events.changed.map(URI.revive))));
+        this._deleted = ( new Lazy(() => ( this._events.deleted.map(URI.revive))));
+    }
+    get created() { return this._created.value; }
+    get changed() { return this._changed.value; }
+    get deleted() { return this._deleted.value; }
+}
 class ExtHostFileSystemEventService {
     constructor(_mainContext, _logService, _extHostDocumentsAndEditors) {
         this._mainContext = _mainContext;
@@ -102,20 +121,18 @@ class ExtHostFileSystemEventService {
         this.onDidCreateFile = this._onDidCreateFile.event;
         this.onDidDeleteFile = this._onDidDeleteFile.event;
     }
-    createFileSystemWatcher(workspace, extension, globPattern, ignoreCreateEvents, ignoreChangeEvents, ignoreDeleteEvents) {
+    createFileSystemWatcher(workspace, extension, globPattern, options) {
         return ( new FileSystemWatcher(
             this._mainContext,
             workspace,
             extension,
             this._onFileSystemEvent.event,
             GlobPattern.from(globPattern),
-            ignoreCreateEvents,
-            ignoreChangeEvents,
-            ignoreDeleteEvents
+            options
         ));
     }
     $onFileEvent(events) {
-        this._onFileSystemEvent.fire(events);
+        this._onFileSystemEvent.fire(( new LazyRevivedFileSystemEvents(events)));
     }
     $onDidRunFileOperation(operation, files) {
         switch (operation) {

package/vscode/src/vs/workbench/api/common/extHostInlineChat.js

@@ -1,9 +1,10 @@
 import { toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { MainContext } from './extHost.protocol.js';
-import { Range, Selection, Position, MarkdownString, WorkspaceEdit as WorkspaceEdit$1, TextEdit, InteractiveEditorResponseFeedbackKind } from './extHostTypeConverters.js';
-import { WorkspaceEdit } from './extHostTypes.js';
+import { Range, Selection, Position, MarkdownString, WorkspaceEdit as WorkspaceEdit$1, TextEdit, ChatReplyFollowup, InteractiveEditorResponseFeedbackKind } from './extHostTypeConverters.js';
+import { WorkspaceEdit, MarkdownString as MarkdownString$1 } from './extHostTypes.js';
 import { ApiCommand, ApiCommandArgument, ApiCommandResult } from './extHostCommands.js';
+import { raceCancellation } from 'monaco-editor/esm/vs/base/common/async.js';
 class ProviderWrapper {
     static { this._pool = 0; }
     constructor(extension, provider) {
@@ -48,7 +49,7 @@ class ExtHostInteractiveEditor {
     registerProvider(extension, provider, metadata) {
         const wrapper = ( new ProviderWrapper(extension, provider));
         this._inputProvider.set(wrapper.handle, wrapper);
-        this._proxy.$registerInteractiveEditorProvider(wrapper.handle, metadata.label, extension.identifier.value, typeof provider.handleInteractiveEditorResponseFeedback === 'function');
+        this._proxy.$registerInteractiveEditorProvider(wrapper.handle, metadata?.label ?? extension.displayName ?? extension.name, extension.identifier.value, typeof provider.handleInteractiveEditorResponseFeedback === 'function', typeof provider.provideFollowups === 'function', metadata?.supportReportIssue ?? false);
         return toDisposable(() => {
             this._proxy.$unregisterInteractiveEditorProvider(wrapper.handle);
             this._inputProvider.delete(wrapper.handle);
@@ -74,6 +75,7 @@ class ExtHostInteractiveEditor {
         return {
             id,
             placeholder: session.placeholder,
+            input: session.input,
             slashCommands: session.slashCommands?.map(c => ({ command: c.command, detail: c.detail, refer: c.refer, executeImmediately: c.executeImmediately })),
             wholeRange: Range.from(session.wholeRange),
             message: session.message
@@ -97,57 +99,76 @@ class ExtHostInteractiveEditor {
         };
         let done = false;
         const progress = {
-            report: value => {
-                if (!request.live) {
+            report: async (value) => {
+                if (!request.live && value.edits?.length) {
                     throw new Error('Progress reporting is only supported for live sessions');
                 }
                 if (done || token.isCancellationRequested) {
                     return;
                 }
-                if (!value.message && !value.edits) {
-                    return;
-                }
-                this._proxy.$handleProgressChunk(request.requestId, {
+                await this._proxy.$handleProgressChunk(request.requestId, {
                     message: value.message,
-                    edits: value.edits?.map(TextEdit.from)
+                    edits: value.edits?.map(TextEdit.from),
+                    editsShouldBeInstant: value.editsShouldBeInstant,
+                    slashCommand: value.slashCommand?.command,
+                    markdownFragment: MarkdownString$1.isMarkdownString(value.content) ? value.content.value : value.content
                 });
             }
         };
-        const task = entry.provider.provideInteractiveEditorResponse(sessionData.session, apiRequest, progress, token);
-        Promise.resolve(task).finally(() => done = true);
-        const res = await task;
-        if (res) {
-            const id = sessionData.responses.push(res) - 1;
-            const stub = {
-                wholeRange: Range.from(res.wholeRange),
-                placeholder: res.placeholder,
-            };
-            if (ExtHostInteractiveEditor._isMessageResponse(res)) {
-                return {
-                    ...stub,
-                    id,
-                    type: "message" ,
-                    message: MarkdownString.from(res.contents),
-                };
-            }
-            const { edits } = res;
+        const task = Promise.resolve(entry.provider.provideInteractiveEditorResponse(sessionData.session, apiRequest, progress, token));
+        let res;
+        try {
+            res = await raceCancellation(task, token);
+        }
+        finally {
+            done = true;
+        }
+        if (!res) {
+            return undefined;
+        }
+        const id = sessionData.responses.push(res) - 1;
+        const stub = {
+            wholeRange: Range.from(res.wholeRange),
+            placeholder: res.placeholder,
+        };
+        if (ExtHostInteractiveEditor._isEditResponse(res)) {
+            const { edits, contents } = res;
+            const message = contents !== undefined ? MarkdownString.from(contents) : undefined;
             if (edits instanceof WorkspaceEdit) {
                 return {
                     ...stub,
                     id,
                     type: "bulkEdit" ,
                     edits: WorkspaceEdit$1.from(edits),
+                    message
                 };
             }
-            else if (Array.isArray(edits)) {
+            else {
                 return {
                     ...stub,
                     id,
                     type: "editorEdit" ,
                     edits: ( edits.map(TextEdit.from)),
+                    message
                 };
             }
         }
+        return {
+            ...stub,
+            id,
+            type: "message" ,
+            message: MarkdownString.from(res.contents),
+        };
+    }
+    async $provideFollowups(handle, sessionId, responseId, token) {
+        const entry = this._inputProvider.get(handle);
+        const sessionData = this._inputSessions.get(sessionId);
+        const response = sessionData?.responses[responseId];
+        if (entry && response && entry.provider.provideFollowups) {
+            const task = Promise.resolve(entry.provider.provideFollowups(sessionData.session, response, token));
+            const followups = await raceCancellation(task, token);
+            return followups?.map(ChatReplyFollowup.from);
+        }
         return undefined;
     }
     $handleFeedback(handle, sessionId, responseId, kind) {
@@ -161,8 +182,8 @@ class ExtHostInteractiveEditor {
     }
     $releaseSession(handle, sessionId) {
     }
-    static _isMessageResponse(thing) {
-        return typeof thing === 'object' && typeof thing.contents === 'object';
+    static _isEditResponse(thing) {
+        return typeof thing === 'object' && typeof thing.edits === 'object';
     }
 }
 export { ExtHostInteractiveEditor };

package/vscode/src/vs/workbench/api/common/extHostIssueReporter.js

@@ -3,6 +3,7 @@ import { Disposable } from './extHostTypes.js';
 class ExtHostIssueReporter {
     constructor(mainContext) {
         this._IssueUriRequestHandlers = ( new Map());
+        this._IssueDataProviders = ( new Map());
         this._proxy = ( mainContext.getProxy(MainContext.MainThreadIssueReporter));
     }
     async $getIssueReporterUri(extensionId, token) {
@@ -19,6 +20,34 @@ class ExtHostIssueReporter {
         }
         return result;
     }
+    async $getIssueReporterData(extensionId, token) {
+        if (this._IssueDataProviders.size === 0) {
+            throw new Error('No issue request handlers registered');
+        }
+        const provider = this._IssueDataProviders.get(extensionId);
+        if (!provider) {
+            throw new Error('Issue data provider not found');
+        }
+        const result = await provider.provideIssueData(token);
+        if (!result) {
+            throw new Error('Issue data provider returned no result');
+        }
+        return result;
+    }
+    async $getIssueReporterTemplate(extensionId, token) {
+        if (this._IssueDataProviders.size === 0) {
+            throw new Error('No issue request handlers registered');
+        }
+        const provider = this._IssueDataProviders.get(extensionId);
+        if (!provider) {
+            throw new Error('Issue data provider not found');
+        }
+        const result = await provider.provideIssueTemplate(token);
+        if (!result) {
+            throw new Error('Issue template provider returned no result');
+        }
+        return result;
+    }
     registerIssueUriRequestHandler(extension, provider) {
         const extensionId = extension.identifier.value;
         this._IssueUriRequestHandlers.set(extensionId, provider);
@@ -28,5 +57,14 @@ class ExtHostIssueReporter {
             this._IssueUriRequestHandlers.delete(extensionId);
         }));
     }
+    registerIssueDataProvider(extension, provider) {
+        const extensionId = extension.identifier.value;
+        this._IssueDataProviders.set(extensionId, provider);
+        this._proxy.$registerIssueDataProvider(extensionId);
+        return ( new Disposable(() => {
+            this._proxy.$unregisterIssueDataProvider(extensionId);
+            this._IssueDataProviders.delete(extensionId);
+        }));
+    }
 }
 export { ExtHostIssueReporter };