@codingame/monaco-vscode-extensions-service-override 1.83.7 → 1.83.9

package/vscode/src/vs/workbench/api/browser/mainThreadChatProvider.js

@@ -0,0 +1,61 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { Progress } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { IChatProviderService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatProvider';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+
+let MainThreadChatProvider = class MainThreadChatProvider {
+    constructor(extHostContext, _chatProviderService, _logService) {
+        this._chatProviderService = _chatProviderService;
+        this._logService = _logService;
+        this._providerRegistrations = ( new DisposableMap());
+        this._pendingProgress = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostChatProvider));
+    }
+    dispose() {
+        this._providerRegistrations.dispose();
+    }
+    $registerProvider(handle, identifier, metadata) {
+        const registration = this._chatProviderService.registerChatResponseProvider(identifier, {
+            metadata,
+            provideChatResponse: async (messages, options, progress, token) => {
+                const requestId = (Math.random() * 1e6) | 0;
+                this._pendingProgress.set(requestId, progress);
+                try {
+                    await this._proxy.$provideChatResponse(handle, requestId, messages, options, token);
+                }
+                finally {
+                    this._pendingProgress.delete(requestId);
+                }
+            }
+        });
+        this._providerRegistrations.set(handle, registration);
+    }
+    async $handleProgressChunk(requestId, chunk) {
+        this._pendingProgress.get(requestId)?.report(chunk);
+    }
+    $unregisterProvider(handle) {
+        this._providerRegistrations.deleteAndDispose(handle);
+    }
+    async $fetchResponse(extension, providerId, requestId, messages, options, token) {
+        this._logService.debug('[CHAT] extension request STARTED', extension.value, requestId);
+        const task = this._chatProviderService.fetchChatResponse(providerId, messages, options, ( new Progress(value => {
+            this._proxy.$handleResponseFragment(requestId, value);
+        })), token);
+        task.catch(err => {
+            this._logService.error('[CHAT] extension request ERRORED', err, extension.value, requestId);
+        }).finally(() => {
+            this._logService.debug('[CHAT] extension request DONE', extension.value, requestId);
+        });
+        return task;
+    }
+};
+MainThreadChatProvider = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadChatProvider),
+    ( __param(1, IChatProviderService)),
+    ( __param(2, ILogService))
+], MainThreadChatProvider);
+
+export { MainThreadChatProvider };

package/vscode/src/vs/workbench/api/browser/mainThreadChatSlashCommands.js

@@ -0,0 +1,49 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { revive } from 'monaco-editor/esm/vs/base/common/marshalling.js';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { IChatSlashCommandService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatSlashCommands';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+
+let MainThreadChatSlashCommands = class MainThreadChatSlashCommands {
+    constructor(extHostContext, _chatSlashCommandService) {
+        this._chatSlashCommandService = _chatSlashCommandService;
+        this._commands = ( new DisposableMap());
+        this._pendingProgress = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostChatSlashCommands));
+    }
+    dispose() {
+        this._commands.clearAndDisposeAll();
+    }
+    $registerCommand(handle, name, detail) {
+        if (!this._chatSlashCommandService.hasCommand(name)) {
+            this._chatSlashCommandService.registerSlashData({
+                command: name,
+                detail
+            });
+        }
+        const d = this._chatSlashCommandService.registerSlashCallback(name, async (prompt, progress, history, token) => {
+            const requestId = Math.random();
+            this._pendingProgress.set(requestId, progress);
+            try {
+                return await this._proxy.$executeCommand(handle, requestId, prompt, { history }, token);
+            }
+            finally {
+                this._pendingProgress.delete(requestId);
+            }
+        });
+        this._commands.set(handle, d);
+    }
+    async $handleProgressChunk(requestId, chunk) {
+        this._pendingProgress.get(requestId)?.report(revive(chunk));
+    }
+    $unregisterCommand(handle) {
+        this._commands.deleteAndDispose(handle);
+    }
+};
+MainThreadChatSlashCommands = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadChatSlashCommands),
+    ( __param(1, IChatSlashCommandService))
+], MainThreadChatSlashCommands);
+
+export { MainThreadChatSlashCommands };

package/vscode/src/vs/workbench/api/browser/mainThreadChatVariables.js

@@ -0,0 +1,31 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { IChatVariablesService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatVariables';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+
+let MainThreadChatSlashCommands = class MainThreadChatSlashCommands {
+    constructor(extHostContext, _chatVariablesService) {
+        this._chatVariablesService = _chatVariablesService;
+        this._variables = ( new DisposableMap());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostChatVariables));
+    }
+    dispose() {
+        this._variables.clearAndDisposeAll();
+    }
+    $registerVariable(handle, data) {
+        const registration = this._chatVariablesService.registerVariable(data, (messageText, _arg, _model, token) => {
+            return this._proxy.$resolveVariable(handle, messageText, token);
+        });
+        this._variables.set(handle, registration);
+    }
+    $unregisterVariable(handle) {
+        this._variables.deleteAndDispose(handle);
+    }
+};
+MainThreadChatSlashCommands = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadChatVariables),
+    ( __param(1, IChatVariablesService))
+], MainThreadChatSlashCommands);
+
+export { MainThreadChatSlashCommands };

package/vscode/src/vs/workbench/api/browser/mainThreadClipboard.js

@@ -0,0 +1,24 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
+
+let MainThreadClipboard = class MainThreadClipboard {
+    constructor(_context, _clipboardService) {
+        this._clipboardService = _clipboardService;
+    }
+    dispose() {
+    }
+    $readText() {
+        return this._clipboardService.readText();
+    }
+    $writeText(value) {
+        return this._clipboardService.writeText(value);
+    }
+};
+MainThreadClipboard = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadClipboard),
+    ( __param(1, IClipboardService))
+], MainThreadClipboard);
+
+export { MainThreadClipboard };

package/vscode/src/vs/workbench/api/browser/mainThreadCodeInsets.js

@@ -0,0 +1,107 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
+import { reviveWebviewContentOptions } from './mainThreadWebviews.js';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { IWebviewService } from 'vscode/vscode/vs/workbench/contrib/webview/browser/webview';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+
+class EditorWebviewZone {
+    constructor(editor, line, height, webview) {
+        this.editor = editor;
+        this.line = line;
+        this.height = height;
+        this.webview = webview;
+        this.domNode = document.createElement('div');
+        this.domNode.style.zIndex = '10';
+        this.afterLineNumber = line;
+        this.afterColumn = 1;
+        this.heightInLines = height;
+        editor.changeViewZones(accessor => this._id = accessor.addZone(this));
+        webview.mountTo(this.domNode);
+    }
+    dispose() {
+        this.editor.changeViewZones(accessor => this._id && accessor.removeZone(this._id));
+    }
+}
+let MainThreadEditorInsets = class MainThreadEditorInsets {
+    constructor(context, _editorService, _webviewService) {
+        this._editorService = _editorService;
+        this._webviewService = _webviewService;
+        this._disposables = ( new DisposableStore());
+        this._insets = ( new Map());
+        this._proxy = ( context.getProxy(ExtHostContext.ExtHostEditorInsets));
+    }
+    dispose() {
+        this._disposables.dispose();
+    }
+    async $createEditorInset(handle, id, uri, line, height, options, extensionId, extensionLocation) {
+        let editor;
+        id = id.substr(0, id.indexOf(','));
+        for (const candidate of this._editorService.listCodeEditors()) {
+            if (candidate.getId() === id && candidate.hasModel() && isEqual(candidate.getModel().uri, URI.revive(uri))) {
+                editor = candidate;
+                break;
+            }
+        }
+        if (!editor) {
+            setTimeout(() => this._proxy.$onDidDispose(handle));
+            return;
+        }
+        const disposables = ( new DisposableStore());
+        const webview = this._webviewService.createWebviewElement({
+            title: undefined,
+            options: {
+                enableFindWidget: false,
+            },
+            contentOptions: reviveWebviewContentOptions(options),
+            extension: { id: extensionId, location: URI.revive(extensionLocation) }
+        });
+        const webviewZone = ( new EditorWebviewZone(editor, line, height, webview));
+        const remove = () => {
+            disposables.dispose();
+            this._proxy.$onDidDispose(handle);
+            this._insets.delete(handle);
+        };
+        disposables.add(editor.onDidChangeModel(remove));
+        disposables.add(editor.onDidDispose(remove));
+        disposables.add(webviewZone);
+        disposables.add(webview);
+        disposables.add(webview.onMessage(msg => this._proxy.$onDidReceiveMessage(handle, msg.message)));
+        this._insets.set(handle, webviewZone);
+    }
+    $disposeEditorInset(handle) {
+        const inset = this.getInset(handle);
+        this._insets.delete(handle);
+        inset.dispose();
+    }
+    $setHtml(handle, value) {
+        const inset = this.getInset(handle);
+        inset.webview.setHtml(value);
+    }
+    $setOptions(handle, options) {
+        const inset = this.getInset(handle);
+        inset.webview.contentOptions = reviveWebviewContentOptions(options);
+    }
+    async $postMessage(handle, value) {
+        const inset = this.getInset(handle);
+        inset.webview.postMessage(value);
+        return true;
+    }
+    getInset(handle) {
+        const inset = this._insets.get(handle);
+        if (!inset) {
+            throw new Error('Unknown inset');
+        }
+        return inset;
+    }
+};
+MainThreadEditorInsets = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadEditorInsets),
+    ( __param(1, ICodeEditorService)),
+    ( __param(2, IWebviewService))
+], MainThreadEditorInsets);
+
+export { MainThreadEditorInsets };

package/vscode/src/vs/workbench/api/browser/mainThreadCommands.js

@@ -0,0 +1,94 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { revive } from 'monaco-editor/esm/vs/base/common/marshalling.js';
+import { ICommandService, CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { SerializableObjectWithBuffers } from 'vscode/vscode/vs/workbench/services/extensions/common/proxyIdentifier';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+
+let MainThreadCommands = class MainThreadCommands {
+    constructor(extHostContext, _commandService, _extensionService) {
+        this._commandService = _commandService;
+        this._extensionService = _extensionService;
+        this._commandRegistrations = ( new DisposableMap());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostCommands));
+        this._generateCommandsDocumentationRegistration = CommandsRegistry.registerCommand('_generateCommandsDocumentation', () => this._generateCommandsDocumentation());
+    }
+    dispose() {
+        this._commandRegistrations.dispose();
+        this._generateCommandsDocumentationRegistration.dispose();
+    }
+    async _generateCommandsDocumentation() {
+        const result = await this._proxy.$getContributedCommandHandlerDescriptions();
+        const commands = CommandsRegistry.getCommands();
+        for (const [id, command] of commands) {
+            if (command.description) {
+                result[id] = command.description;
+            }
+        }
+        const all = [];
+        for (const id in result) {
+            all.push('`' + id + '` - ' + _generateMarkdown(result[id]));
+        }
+        console.log(all.join('\n'));
+    }
+    $registerCommand(id) {
+        this._commandRegistrations.set(id, CommandsRegistry.registerCommand(id, (accessor, ...args) => {
+            return this._proxy.$executeContributedCommand(id, ...args).then(result => {
+                return revive(result);
+            });
+        }));
+    }
+    $unregisterCommand(id) {
+        this._commandRegistrations.deleteAndDispose(id);
+    }
+    $fireCommandActivationEvent(id) {
+        const activationEvent = `onCommand:${id}`;
+        if (!this._extensionService.activationEventIsDone(activationEvent)) {
+            this._extensionService.activateByEvent(activationEvent);
+        }
+    }
+    async $executeCommand(id, args, retry) {
+        if (args instanceof SerializableObjectWithBuffers) {
+            args = args.value;
+        }
+        for (let i = 0; i < args.length; i++) {
+            args[i] = revive(args[i]);
+        }
+        if (retry && args.length > 0 && !CommandsRegistry.getCommand(id)) {
+            await this._extensionService.activateByEvent(`onCommand:${id}`);
+            throw new Error('$executeCommand:retry');
+        }
+        return this._commandService.executeCommand(id, ...args);
+    }
+    $getCommands() {
+        return Promise.resolve([...( CommandsRegistry.getCommands().keys())]);
+    }
+};
+MainThreadCommands = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadCommands),
+    ( __param(1, ICommandService)),
+    ( __param(2, IExtensionService))
+], MainThreadCommands);
+function _generateMarkdown(description) {
+    if (typeof description === 'string') {
+        return description;
+    }
+    else {
+        const parts = [description.description];
+        parts.push('\n\n');
+        if (description.args) {
+            for (const arg of description.args) {
+                parts.push(`* _${arg.name}_ - ${arg.description || ''}\n`);
+            }
+        }
+        if (description.returns) {
+            parts.push(`* _(returns)_ - ${description.returns}`);
+        }
+        parts.push('\n\n');
+        return parts.join('');
+    }
+}
+
+export { MainThreadCommands };