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

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

@@ -1,103 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { Schemas } from 'vscode/vscode/vs/base/common/network';
-import { isWeb } from 'vscode/vscode/vs/base/common/platform';
-import { isString } from 'vscode/vscode/vs/base/common/types';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { CommandsRegistry, ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
-import { IExtensionManagementService, IExtensionGalleryService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagement';
-import { ExtensionManagementCLI } from '../../../platform/extensionManagement/common/extensionManagementCLI.js';
-import { getExtensionId } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagementUtil';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { ServiceCollection } from 'vscode/vscode/vs/platform/instantiation/common/serviceCollection';
-import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label';
-import { AbstractMessageLogger } from 'vscode/vscode/vs/platform/log/common/log';
-import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
-import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
-import { IExtensionManagementServerService } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement';
-import { IExtensionManifestPropertiesService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionManifestPropertiesService';
-
-CommandsRegistry.registerCommand('_remoteCLI.openExternal', function (accessor, uri) {
-    const openerService = accessor.get(IOpenerService);
-    return openerService.open(isString(uri) ? uri : URI.revive(uri), { openExternal: true, allowTunneling: true });
-});
-CommandsRegistry.registerCommand('_remoteCLI.windowOpen', function (accessor, toOpen, options) {
-    const commandService = accessor.get(ICommandService);
-    if (!toOpen.length) {
-        return commandService.executeCommand('_files.newWindow', options);
-    }
-    return commandService.executeCommand('_files.windowOpen', toOpen, options);
-});
-CommandsRegistry.registerCommand('_remoteCLI.getSystemStatus', function (accessor) {
-    const commandService = accessor.get(ICommandService);
-    return commandService.executeCommand('_issues.getSystemStatus');
-});
-CommandsRegistry.registerCommand('_remoteCLI.manageExtensions', async function (accessor, args) {
-    const instantiationService = accessor.get(IInstantiationService);
-    const extensionManagementServerService = accessor.get(IExtensionManagementServerService);
-    const remoteExtensionManagementService = extensionManagementServerService.remoteExtensionManagementServer?.extensionManagementService;
-    if (!remoteExtensionManagementService) {
-        return;
-    }
-    const lines = [];
-    const logger = new (class extends AbstractMessageLogger {
-        log(level, message) {
-            lines.push(message);
-        }
-    })();
-    const cliService = instantiationService.createChild(( new ServiceCollection([IExtensionManagementService, remoteExtensionManagementService]))).createInstance(RemoteExtensionManagementCLI, logger);
-    if (args.list) {
-        await cliService.listExtensions(!!args.list.showVersions, args.list.category, undefined);
-    }
-    else {
-        const revive = (inputs) => ( inputs.map(input => isString(input) ? input : URI.revive(input)));
-        if (Array.isArray(args.install) && args.install.length) {
-            try {
-                await cliService.installExtensions(revive(args.install), [], { isMachineScoped: true }, !!args.force);
-            }
-            catch (e) {
-                lines.push(e.message);
-            }
-        }
-        if (Array.isArray(args.uninstall) && args.uninstall.length) {
-            try {
-                await cliService.uninstallExtensions(revive(args.uninstall), !!args.force, undefined);
-            }
-            catch (e) {
-                lines.push(e.message);
-            }
-        }
-    }
-    return lines.join('\n');
-});
-let RemoteExtensionManagementCLI = class RemoteExtensionManagementCLI extends ExtensionManagementCLI {
-    constructor(logger, extensionManagementService, extensionGalleryService, labelService, envService, _extensionManifestPropertiesService) {
-        super(logger, extensionManagementService, extensionGalleryService);
-        this._extensionManifestPropertiesService = _extensionManifestPropertiesService;
-        const remoteAuthority = envService.remoteAuthority;
-        this._location = remoteAuthority ? labelService.getHostLabel(Schemas.vscodeRemote, remoteAuthority) : undefined;
-    }
-    get location() {
-        return this._location;
-    }
-    validateExtensionKind(manifest) {
-        if (!this._extensionManifestPropertiesService.canExecuteOnWorkspace(manifest)
-            && !(isWeb && this._extensionManifestPropertiesService.canExecuteOnWeb(manifest))) {
-            this.logger.info(( localizeWithPath(
-                'vs/workbench/api/browser/mainThreadCLICommands',
-                'cannot be installed',
-                "Cannot install the '{0}' extension because it is declared to not run in this setup.",
-                getExtensionId(manifest.publisher, manifest.name)
-            )));
-            return false;
-        }
-        return true;
-    }
-};
-RemoteExtensionManagementCLI = ( __decorate([
-    ( __param(1, IExtensionManagementService)),
-    ( __param(2, IExtensionGalleryService)),
-    ( __param(3, ILabelService)),
-    ( __param(4, IWorkbenchEnvironmentService)),
-    ( __param(5, IExtensionManifestPropertiesService))
-], RemoteExtensionManagementCLI));

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

@@ -1,70 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { Emitter } from 'vscode/vscode/vs/base/common/event';
-import { Disposable, DisposableMap } from 'vscode/vscode/vs/base/common/lifecycle';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
-import { IChatWidgetService } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chat';
-import { IChatContributionService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatContributionService';
-import { IChatService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatService';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-
-let MainThreadChat = class MainThreadChat extends Disposable {
-    constructor(extHostContext, _chatService, _chatWidgetService, chatContribService) {
-        super();
-        this._chatService = _chatService;
-        this._chatWidgetService = _chatWidgetService;
-        this.chatContribService = chatContribService;
-        this._providerRegistrations = this._register(( new DisposableMap()));
-        this._stateEmitters = ( new Map());
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostChat));
-    }
-    $transferChatSession(sessionId, toWorkspace) {
-        const sessionIdStr = this._chatService.getSessionId(sessionId);
-        if (!sessionIdStr) {
-            throw new Error(`Failed to transfer session. Unknown session provider ID: ${sessionId}`);
-        }
-        const widget = this._chatWidgetService.getWidgetBySessionId(sessionIdStr);
-        const inputValue = widget?.inputEditor.getValue() ?? '';
-        this._chatService.transferChatSession({ sessionId: sessionIdStr, inputValue: inputValue }, URI.revive(toWorkspace));
-    }
-    async $registerChatProvider(handle, id) {
-        const registration = this.chatContribService.registeredProviders.find(staticProvider => staticProvider.id === id);
-        if (!registration) {
-            throw new Error(`Provider ${id} must be declared in the package.json.`);
-        }
-        const unreg = this._chatService.registerProvider({
-            id,
-            prepareSession: async (token) => {
-                const session = await this._proxy.$prepareChat(handle, token);
-                if (!session) {
-                    return undefined;
-                }
-                const emitter = ( new Emitter());
-                this._stateEmitters.set(session.id, emitter);
-                return {
-                    id: session.id,
-                    dispose: () => {
-                        emitter.dispose();
-                        this._stateEmitters.delete(session.id);
-                        this._proxy.$releaseSession(session.id);
-                    }
-                };
-            },
-        });
-        this._providerRegistrations.set(handle, unreg);
-    }
-    async $acceptChatState(sessionId, state) {
-        this._stateEmitters.get(sessionId)?.fire(state);
-    }
-    async $unregisterChatProvider(handle) {
-        this._providerRegistrations.deleteAndDispose(handle);
-    }
-};
-MainThreadChat = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadChat),
-    ( __param(1, IChatService)),
-    ( __param(2, IChatWidgetService)),
-    ( __param(3, IChatContributionService))
-], MainThreadChat);
-
-export { MainThreadChat };

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

@@ -1,207 +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, ChatAgentLocation } 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.id === 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, id, metadata, dynamicProps) {
-        const staticAgentRegistration = this._chatAgentService.getAgent(id);
-        if (!staticAgentRegistration && !dynamicProps) {
-            if (this._chatAgentService.getAgentsByName(id).length) {
-                throw new Error(`chatParticipant must be declared with an ID in package.json. The "id" property may be missing! "${id}"`);
-            }
-            throw new Error(`chatParticipant must be declared in package.json: ${id}`);
-        }
-        const impl = {
-            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, history, token) => {
-                if (!this._agents.get(handle)?.hasFollowups) {
-                    return [];
-                }
-                return this._proxy.$provideFollowups(request, handle, result, { history }, token);
-            },
-            provideWelcomeMessage: (token) => {
-                return this._proxy.$provideWelcomeMessage(handle, token);
-            },
-            provideSampleQuestions: (token) => {
-                return this._proxy.$provideSampleQuestions(handle, token);
-            }
-        };
-        let disposable;
-        if (!staticAgentRegistration && dynamicProps) {
-            disposable = this._chatAgentService.registerDynamicAgent({
-                id,
-                name: dynamicProps.name,
-                description: dynamicProps.description,
-                extensionId: extension,
-                metadata: revive(metadata),
-                slashCommands: [],
-                locations: [ChatAgentLocation.Panel]
-            }, impl);
-        }
-        else {
-            disposable = this._chatAgentService.registerAgentImplementation(id, impl);
-        }
-        this._agents.set(handle, {
-            id: id,
-            extensionId: extension,
-            dispose: disposable.dispose,
-            hasFollowups: metadata.hasFollowups
-        });
-    }
-    $updateAgent(handle, metadataUpdate) {
-        const data = this._agents.get(handle);
-        if (!data) {
-            throw new Error(`No agent with handle ${handle} registered`);
-        }
-        data.hasFollowups = metadataUpdate.hasFollowups;
-        this._chatAgentService.updateAgent(data.id, 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 thisAgentId = this._agents.get(handle)?.id;
-                if (agentPart?.agent.id !== thisAgentId) {
-                    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/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,108 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { getWindow } from 'vscode/vscode/vs/base/browser/dom';
-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, getWindow(editor.getDomNode()));
-    }
-    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 };