@codingame/monaco-vscode-api 1.83.8 → 1.83.9

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

@@ -1,59 +0,0 @@
-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 { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
-import { IChatProviderService } from '../../contrib/chat/common/chatProvider.js';
-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

@@ -1,47 +0,0 @@
-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 { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
-import { IChatSlashCommandService } from '../../contrib/chat/common/chatSlashCommands.js';
-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

@@ -1,29 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
-import { IChatVariablesService } from '../../contrib/chat/common/chatVariables.js';
-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

@@ -1,22 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { MainContext } from '../common/extHost.protocol.js';
-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

@@ -1,105 +0,0 @@
-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 { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
-import { IWebviewService } from '../../contrib/webview/browser/webview.js';
-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

@@ -1,92 +0,0 @@
-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 { CommandsRegistry, ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { IExtensionService } from '../../services/extensions/common/extensions.js';
-import { SerializableObjectWithBuffers } from '../../services/extensions/common/proxyIdentifier.js';
-import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
-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 };