@codingame/monaco-vscode-extensions-service-override 3.2.3 → 4.1.0

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

@@ -1,203 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { Disposable, DisposableMap } from 'vscode/vscode/vs/base/common/lifecycle';
-import { revive } from 'vscode/vscode/vs/base/common/marshalling';
-import { escapeRegExpCharacters } from 'vscode/vscode/vs/base/common/strings';
-import { Range } from 'vscode/vscode/vs/editor/common/core/range';
-import { getWordAtText } from 'vscode/vscode/vs/editor/common/core/wordHelper';
-import { ILanguageFeaturesService } from 'vscode/vscode/vs/editor/common/services/languageFeatures';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
-import { IChatWidgetService } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chat';
-import { ChatInputPart } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chatInputPart';
-import { AddDynamicVariableAction } from 'vscode/vscode/vs/workbench/contrib/chat/browser/contrib/chatDynamicVariables';
-import { IChatAgentService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents';
-import { ChatRequestAgentPart } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
-import { ChatRequestParser } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatRequestParser';
-import { IChatService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatService';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-
-let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
-    constructor(extHostContext, _chatAgentService, _chatService, _languageFeaturesService, _chatWidgetService, _instantiationService) {
-        super();
-        this._chatAgentService = _chatAgentService;
-        this._chatService = _chatService;
-        this._languageFeaturesService = _languageFeaturesService;
-        this._chatWidgetService = _chatWidgetService;
-        this._instantiationService = _instantiationService;
-        this._agents = this._register(( new DisposableMap()));
-        this._agentCompletionProviders = this._register(( new DisposableMap()));
-        this._pendingProgress = ( new Map());
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostChatAgents2));
-        this._register(this._chatService.onDidDisposeSession(e => {
-            this._proxy.$releaseSession(e.sessionId);
-        }));
-        this._register(this._chatService.onDidPerformUserAction(e => {
-            if (typeof e.agentId === 'string') {
-                for (const [handle, agent] of this._agents) {
-                    if (agent.name === e.agentId) {
-                        if (e.action.kind === 'vote') {
-                            this._proxy.$acceptFeedback(handle, e.result ?? {}, e.action.direction);
-                        }
-                        else {
-                            this._proxy.$acceptAction(handle, e.result || {}, e);
-                        }
-                        break;
-                    }
-                }
-            }
-        }));
-    }
-    $unregisterAgent(handle) {
-        this._agents.deleteAndDispose(handle);
-    }
-    $registerAgent(handle, extension, name, metadata) {
-        const lastSlashCommands = ( new WeakMap());
-        const d = this._chatAgentService.registerAgent({
-            id: name,
-            extensionId: extension,
-            metadata: revive(metadata),
-            invoke: async (request, progress, history, token) => {
-                this._pendingProgress.set(request.requestId, progress);
-                try {
-                    return (await this._proxy.$invokeAgent(handle, request, { history }, token)) ?? {};
-                }
-                finally {
-                    this._pendingProgress.delete(request.requestId);
-                }
-            },
-            provideFollowups: async (request, result, token) => {
-                if (!this._agents.get(handle)?.hasFollowups) {
-                    return [];
-                }
-                return this._proxy.$provideFollowups(request, handle, result, token);
-            },
-            getLastSlashCommands: (model) => {
-                return lastSlashCommands.get(model);
-            },
-            provideSlashCommands: async (model, history, token) => {
-                if (!this._agents.get(handle)?.hasSlashCommands) {
-                    return [];
-                }
-                const commands = await this._proxy.$provideSlashCommands(handle, { history }, token);
-                if (model) {
-                    lastSlashCommands.set(model, commands);
-                }
-                return commands;
-            },
-            provideWelcomeMessage: (token) => {
-                return this._proxy.$provideWelcomeMessage(handle, token);
-            },
-            provideSampleQuestions: (token) => {
-                return this._proxy.$provideSampleQuestions(handle, token);
-            }
-        });
-        this._agents.set(handle, {
-            name,
-            dispose: d.dispose,
-            hasSlashCommands: metadata.hasSlashCommands,
-            hasFollowups: metadata.hasFollowups
-        });
-    }
-    $updateAgent(handle, metadataUpdate) {
-        const data = this._agents.get(handle);
-        if (!data) {
-            throw new Error(`No agent with handle ${handle} registered`);
-        }
-        data.hasSlashCommands = metadataUpdate.hasSlashCommands;
-        data.hasFollowups = metadataUpdate.hasFollowups;
-        this._chatAgentService.updateAgent(data.name, revive(metadataUpdate));
-    }
-    async $handleProgressChunk(requestId, progress) {
-        const revivedProgress = revive(progress);
-        this._pendingProgress.get(requestId)?.(revivedProgress);
-    }
-    $registerAgentCompletionsProvider(handle, triggerCharacters) {
-        this._agentCompletionProviders.set(handle, this._languageFeaturesService.completionProvider.register({ scheme: ChatInputPart.INPUT_SCHEME, hasAccessToAllModels: true }, {
-            _debugDisplayName: 'chatAgentCompletions:' + handle,
-            triggerCharacters,
-            provideCompletionItems: async (model, position, _context, token) => {
-                const widget = this._chatWidgetService.getWidgetByInputUri(model.uri);
-                if (!widget || !widget.viewModel) {
-                    return;
-                }
-                const triggerCharsPart = ( triggerCharacters.map(c => escapeRegExpCharacters(c))).join('');
-                const wordRegex = ( new RegExp(`[${triggerCharsPart}]\\S*`, 'g'));
-                const query = getWordAtText(position.column, wordRegex, model.getLineContent(position.lineNumber), 0)?.word ?? '';
-                if (query && !( triggerCharacters.some(c => query.startsWith(c)))) {
-                    return;
-                }
-                const parsedRequest = this._instantiationService.createInstance(ChatRequestParser).parseChatRequest(widget.viewModel.sessionId, model.getValue()).parts;
-                const agentPart = parsedRequest.find((part) => part instanceof ChatRequestAgentPart);
-                const thisAgentName = this._agents.get(handle)?.name;
-                if (agentPart?.agent.id !== thisAgentName) {
-                    return;
-                }
-                const range = computeCompletionRanges(model, position, wordRegex);
-                if (!range) {
-                    return null;
-                }
-                const result = await this._proxy.$invokeCompletionProvider(handle, query, token);
-                const variableItems = ( result.map(v => {
-                    const insertText = v.insertText ?? (typeof v.label === 'string' ? v.label : v.label.label);
-                    const rangeAfterInsert = ( new Range(
-                        range.insert.startLineNumber,
-                        range.insert.startColumn,
-                        range.insert.endLineNumber,
-                        range.insert.startColumn + insertText.length
-                    ));
-                    return {
-                        label: v.label,
-                        range,
-                        insertText: insertText + ' ',
-                        kind: 18 ,
-                        detail: v.detail,
-                        documentation: v.documentation,
-                        command: { id: AddDynamicVariableAction.ID, title: '', arguments: [{ widget, range: rangeAfterInsert, variableData: revive(v.values) }] }
-                    };
-                }));
-                return {
-                    suggestions: variableItems
-                };
-            }
-        }));
-    }
-    $unregisterAgentCompletionsProvider(handle) {
-        this._agentCompletionProviders.deleteAndDispose(handle);
-    }
-};
-MainThreadChatAgents2 = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadChatAgents2),
-    ( __param(1, IChatAgentService)),
-    ( __param(2, IChatService)),
-    ( __param(3, ILanguageFeaturesService)),
-    ( __param(4, IChatWidgetService)),
-    ( __param(5, IInstantiationService))
-], MainThreadChatAgents2);
-function computeCompletionRanges(model, position, reg) {
-    const varWord = getWordAtText(position.column, reg, model.getLineContent(position.lineNumber), 0);
-    if (!varWord && model.getWordUntilPosition(position).word) {
-        return;
-    }
-    let insert;
-    let replace;
-    if (!varWord) {
-        insert = replace = Range.fromPositions(position);
-    }
-    else {
-        insert = ( new Range(
-            position.lineNumber,
-            varWord.startColumn,
-            position.lineNumber,
-            position.column
-        ));
-        replace = ( new Range(
-            position.lineNumber,
-            varWord.startColumn,
-            position.lineNumber,
-            varWord.endColumn
-        ));
-    }
-    return { insert, replace };
-}
-
-export { MainThreadChatAgents2 };

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

@@ -1,201 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { Event, Emitter } from 'vscode/vscode/vs/base/common/event';
-import { DisposableStore, DisposableMap, Disposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-import { Progress } from 'vscode/vscode/vs/platform/progress/common/progress';
-import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
-import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
-import { IChatProviderService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatProvider';
-import { IAuthenticationService, INTERNAL_AUTH_PROVIDER_PREFIX } from 'vscode/vscode/vs/workbench/services/authentication/common/authentication';
-import { IExtensionFeaturesManagementService, Extensions } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionFeatures';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
-
-let MainThreadChatProvider = class MainThreadChatProvider {
-    constructor(extHostContext, _chatProviderService, _extensionFeaturesManagementService, _logService, _authenticationService, _extensionService) {
-        this._chatProviderService = _chatProviderService;
-        this._extensionFeaturesManagementService = _extensionFeaturesManagementService;
-        this._logService = _logService;
-        this._authenticationService = _authenticationService;
-        this._extensionService = _extensionService;
-        this._store = ( new DisposableStore());
-        this._providerRegistrations = ( new DisposableMap());
-        this._pendingProgress = ( new Map());
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostChatProvider));
-        this._proxy.$updateLanguageModels({ added: _chatProviderService.getProviders() });
-        this._store.add(_chatProviderService.onDidChangeProviders(this._proxy.$updateLanguageModels, this._proxy));
-    }
-    dispose() {
-        this._providerRegistrations.dispose();
-        this._store.dispose();
-    }
-    $registerProvider(handle, identifier, metadata) {
-        const dipsosables = ( new DisposableStore());
-        dipsosables.add(this._chatProviderService.registerChatResponseProvider(identifier, {
-            metadata,
-            provideChatResponse: async (messages, from, options, progress, token) => {
-                const requestId = (Math.random() * 1e6) | 0;
-                this._pendingProgress.set(requestId, progress);
-                try {
-                    await this._proxy.$provideLanguageModelResponse(handle, requestId, from, messages, options, token);
-                }
-                finally {
-                    this._pendingProgress.delete(requestId);
-                }
-            }
-        }));
-        if (metadata.auth) {
-            dipsosables.add(this._registerAuthenticationProvider(metadata.extension, metadata.auth));
-        }
-        dipsosables.add(( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
-            id: `lm-${identifier}`,
-            label: ( localizeWithPath(
-                'vs/workbench/api/browser/mainThreadChatProvider',
-                'languageModels',
-                "Language Model ({0})",
-                `${identifier}`
-            )),
-            access: {
-                canToggle: false,
-            },
-        }));
-        this._providerRegistrations.set(handle, dipsosables);
-    }
-    async $handleProgressChunk(requestId, chunk) {
-        this._pendingProgress.get(requestId)?.report(chunk);
-    }
-    $unregisterProvider(handle) {
-        this._providerRegistrations.deleteAndDispose(handle);
-    }
-    async $prepareChatAccess(extension, providerId, justification) {
-        const activate = this._extensionService.activateByEvent(`onLanguageModelAccess:${providerId}`);
-        const metadata = this._chatProviderService.lookupChatResponseProvider(providerId);
-        if (metadata) {
-            return metadata;
-        }
-        await Promise.race([
-            activate,
-            Event.toPromise(Event.filter(this._chatProviderService.onDidChangeProviders, e => Boolean(e.added?.includes(providerId))))
-        ]);
-        return this._chatProviderService.lookupChatResponseProvider(providerId);
-    }
-    async $fetchResponse(extension, providerId, requestId, messages, options, token) {
-        await this._extensionFeaturesManagementService.getAccess(extension, `lm-${providerId}`);
-        this._logService.debug('[CHAT] extension request STARTED', extension.value, requestId);
-        const task = this._chatProviderService.fetchChatResponse(providerId, extension, 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);
-            throw err;
-        }).finally(() => {
-            this._logService.debug('[CHAT] extension request DONE', extension.value, requestId);
-        });
-        return task;
-    }
-    _registerAuthenticationProvider(extension, auth) {
-        const authProviderId = INTERNAL_AUTH_PROVIDER_PREFIX + extension.value;
-        if (this._authenticationService.getProviderIds().includes(authProviderId)) {
-            return Disposable.None;
-        }
-        const accountLabel = auth.accountLabel ?? ( localizeWithPath(
-            'vs/workbench/api/browser/mainThreadChatProvider',
-            'languageModelsAccountId',
-            'Language Models'
-        ));
-        const disposables = ( new DisposableStore());
-        this._authenticationService.registerAuthenticationProvider(authProviderId, ( new LanguageModelAccessAuthProvider(authProviderId, auth.providerLabel, accountLabel)));
-        disposables.add(toDisposable(() => {
-            this._authenticationService.unregisterAuthenticationProvider(authProviderId);
-        }));
-        disposables.add(this._authenticationService.onDidChangeSessions(async (e) => {
-            if (e.providerId === authProviderId) {
-                if (e.event.removed?.length) {
-                    const allowedExtensions = this._authenticationService.readAllowedExtensions(authProviderId, accountLabel);
-                    const extensionsToUpdateAccess = [];
-                    for (const allowed of allowedExtensions) {
-                        const from = await this._extensionService.getExtension(allowed.id);
-                        this._authenticationService.updateAllowedExtension(authProviderId, authProviderId, allowed.id, allowed.name, false);
-                        if (from) {
-                            extensionsToUpdateAccess.push({
-                                from: from.identifier,
-                                to: extension,
-                                enabled: false
-                            });
-                        }
-                    }
-                    this._proxy.$updateModelAccesslist(extensionsToUpdateAccess);
-                }
-            }
-        }));
-        disposables.add(this._authenticationService.onDidChangeExtensionSessionAccess(async (e) => {
-            const allowedExtensions = this._authenticationService.readAllowedExtensions(authProviderId, accountLabel);
-            const accessList = [];
-            for (const allowedExtension of allowedExtensions) {
-                const from = await this._extensionService.getExtension(allowedExtension.id);
-                if (from) {
-                    accessList.push({
-                        from: from.identifier,
-                        to: extension,
-                        enabled: allowedExtension.allowed ?? true
-                    });
-                }
-            }
-            this._proxy.$updateModelAccesslist(accessList);
-        }));
-        return disposables;
-    }
-};
-MainThreadChatProvider = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadChatProvider),
-    ( __param(1, IChatProviderService)),
-    ( __param(2, IExtensionFeaturesManagementService)),
-    ( __param(3, ILogService)),
-    ( __param(4, IAuthenticationService)),
-    ( __param(5, IExtensionService))
-], MainThreadChatProvider);
-class LanguageModelAccessAuthProvider {
-    constructor(id, label, _accountLabel) {
-        this.id = id;
-        this.label = label;
-        this._accountLabel = _accountLabel;
-        this.supportsMultipleAccounts = false;
-        this._onDidChangeSessions = ( new Emitter());
-        this.onDidChangeSessions = this._onDidChangeSessions.event;
-    }
-    async getSessions(scopes) {
-        if (scopes === undefined && !this._session) {
-            return [];
-        }
-        if (this._session) {
-            return [this._session];
-        }
-        return [await this.createSession(scopes || [], {})];
-    }
-    async createSession(scopes, options) {
-        this._session = this._createFakeSession(scopes);
-        this._onDidChangeSessions.fire({ added: [this._session], changed: [], removed: [] });
-        return this._session;
-    }
-    removeSession(sessionId) {
-        if (this._session) {
-            this._onDidChangeSessions.fire({ added: [], changed: [], removed: [this._session] });
-            this._session = undefined;
-        }
-        return Promise.resolve();
-    }
-    _createFakeSession(scopes) {
-        return {
-            id: 'fake-session',
-            account: {
-                id: this.id,
-                label: this._accountLabel,
-            },
-            accessToken: 'fake-access-token',
-            scopes,
-        };
-    }
-}
-
-export { MainThreadChatProvider };

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

@@ -1,41 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { DisposableMap } from 'vscode/vscode/vs/base/common/lifecycle';
-import { revive } from 'vscode/vscode/vs/base/common/marshalling';
-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 MainThreadChatVariables = class MainThreadChatVariables {
-    constructor(extHostContext, _chatVariablesService) {
-        this._chatVariablesService = _chatVariablesService;
-        this._variables = ( new DisposableMap());
-        this._pendingProgress = ( new Map());
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostChatVariables));
-    }
-    dispose() {
-        this._variables.clearAndDisposeAll();
-    }
-    $registerVariable(handle, data) {
-        const registration = this._chatVariablesService.registerVariable(data, async (messageText, _arg, model, progress, token) => {
-            const varRequestId = `${model.sessionId}-${handle}`;
-            this._pendingProgress.set(varRequestId, progress);
-            const result = revive(await this._proxy.$resolveVariable(handle, varRequestId, messageText, token));
-            this._pendingProgress.delete(varRequestId);
-            return result;
-        });
-        this._variables.set(handle, registration);
-    }
-    async $handleProgressChunk(requestId, progress) {
-        const revivedProgress = revive(progress);
-        this._pendingProgress.get(requestId)?.(revivedProgress);
-    }
-    $unregisterVariable(handle) {
-        this._variables.deleteAndDispose(handle);
-    }
-};
-MainThreadChatVariables = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadChatVariables),
-    ( __param(1, IChatVariablesService))
-], MainThreadChatVariables);
-
-export { MainThreadChatVariables };

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

@@ -1,24 +0,0 @@
-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 'vscode/vscode/vs/platform/clipboard/common/clipboardService';
-
-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,107 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
-import { isEqual } from 'vscode/vscode/vs/base/common/resources';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { ICodeEditorService } from 'vscode/vscode/vs/editor/browser/services/codeEditorService';
-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

@@ -1,98 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { DisposableMap } from 'vscode/vscode/vs/base/common/lifecycle';
-import { revive } from 'vscode/vscode/vs/base/common/marshalling';
-import { ICommandService, CommandsRegistry } from 'vscode/vscode/vs/platform/commands/common/commands';
-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';
-import { isString } from 'vscode/vscode/vs/base/common/types';
-
-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.$getContributedCommandMetadata();
-        const commands = CommandsRegistry.getCommands();
-        for (const [id, command] of commands) {
-            if (command.metadata) {
-                result[id] = command.metadata;
-            }
-        }
-        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 descriptionString = isString(description.description)
-            ? description.description
-            : description.description.original;
-        const parts = [descriptionString];
-        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 };