@codingame/monaco-vscode-extensions-service-override 4.5.1 → 5.0.0

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

@@ -16,7 +16,7 @@ let MainThreadBulkEdits = class MainThreadBulkEdits {
     }
     dispose() { }
     $tryApplyWorkspaceEdit(dto, undoRedoGroupId, isRefactoring) {
-        const edits = reviveWorkspaceEditDto(dto, this._uriIdentService);
+        const edits = reviveWorkspaceEditDto(dto.value, this._uriIdentService);
         return this._bulkEditService.apply(edits, { undoRedoGroupId, respectAutoSaveConfig: isRefactoring }).then((res) => res.isApplied, err => {
             this._logService.warn(`IGNORING workspace edit: ${err}`);
             return false;
@@ -50,7 +50,7 @@ function reviveWorkspaceEditDto(data, uriIdentityService, resolveDataTransferFil
                             edit.options.contents = resolveDataTransferFile(inContents.id);
                         }
                         else {
-                            throw new Error('Could not revive data transfer file');
+                            throw ( new Error('Could not revive data transfer file'));
                         }
                     }
                 }
@@ -60,6 +60,24 @@ function reviveWorkspaceEditDto(data, uriIdentityService, resolveDataTransferFil
         }
         if (ResourceNotebookCellEdit.is(edit)) {
             edit.resource = uriIdentityService.asCanonicalUri(edit.resource);
+            const cellEdit = edit.cellEdit;
+            if (cellEdit.editType === 1 ) {
+                edit.cellEdit = {
+                    ...cellEdit,
+                    cells: ( cellEdit.cells.map(cell => ({
+                        ...cell,
+                        outputs: ( cell.outputs.map(output => ({
+                            ...output,
+                            outputs: ( output.items.map(item => {
+                                return {
+                                    mime: item.mime,
+                                    data: item.valueBytes
+                                };
+                            }))
+                        })))
+                    })))
+                };
+            }
         }
     }
     return data;

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

@@ -18,6 +18,7 @@ import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/service
 import { IExtensionManagementServerService } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement.service';
 import { IExtensionManifestPropertiesService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionManifestPropertiesService.service';
 
+const _moduleId = "vs/workbench/api/browser/mainThreadCLICommands";
 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 });
@@ -46,12 +47,12 @@ CommandsRegistry.registerCommand('_remoteCLI.manageExtensions', async function (
             lines.push(message);
         }
     })();
-    const cliService = instantiationService.createChild(( new ServiceCollection([IExtensionManagementService, remoteExtensionManagementService]))).createInstance(RemoteExtensionManagementCLI, logger);
+    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)));
+        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);
@@ -85,8 +86,8 @@ let RemoteExtensionManagementCLI = class RemoteExtensionManagementCLI extends Ex
         if (!this._extensionManifestPropertiesService.canExecuteOnWorkspace(manifest)
             && !(isWeb && this._extensionManifestPropertiesService.canExecuteOnWeb(manifest))) {
             this.logger.info(( localizeWithPath(
-                'vs/workbench/api/browser/mainThreadCLICommands',
-                'cannot be installed',
+                _moduleId,
+                0,
                 "Cannot install the '{0}' extension because it is declared to not run in this setup.",
                 getExtensionId(manifest.publisher, manifest.name)
             )));
@@ -95,10 +96,10 @@ let RemoteExtensionManagementCLI = class RemoteExtensionManagementCLI extends Ex
         return true;
     }
 };
-RemoteExtensionManagementCLI = ( __decorate([
-    ( __param(1, IExtensionManagementService)),
-    ( __param(2, IExtensionGalleryService)),
-    ( __param(3, ILabelService)),
-    ( __param(4, IWorkbenchEnvironmentService)),
-    ( __param(5, IExtensionManifestPropertiesService))
-], RemoteExtensionManagementCLI));
+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/mainThreadChatAgents2.js

@@ -2,10 +2,13 @@ import { __decorate, __param } from 'vscode/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 { URI } from 'vscode/vscode/vs/base/common/uri';
 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 { ExtensionIdentifier } from 'vscode/vscode/vs/platform/extensions/common/extensions';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
 import { ExtHostContext, MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
 import { IChatWidgetService } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chat.service';
 import { ChatInputPart } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chatInputPart';
@@ -16,15 +19,18 @@ import { ChatRequestAgentPart } from 'vscode/vscode/vs/workbench/contrib/chat/co
 import { ChatRequestParser } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatRequestParser';
 import { IChatService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatService.service';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
 
 let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
-    constructor(extHostContext, _chatAgentService, _chatService, _languageFeaturesService, _chatWidgetService, _instantiationService) {
+    constructor(extHostContext, _chatAgentService, _chatService, _languageFeaturesService, _chatWidgetService, _instantiationService, _logService, _extensionService) {
         super();
         this._chatAgentService = _chatAgentService;
         this._chatService = _chatService;
         this._languageFeaturesService = _languageFeaturesService;
         this._chatWidgetService = _chatWidgetService;
         this._instantiationService = _instantiationService;
+        this._logService = _logService;
+        this._extensionService = _extensionService;
         this._agents = this._register(( new DisposableMap()));
         this._agentCompletionProviders = this._register(( new DisposableMap()));
         this._pendingProgress = ( new Map());
@@ -51,13 +57,25 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
     $unregisterAgent(handle) {
         this._agents.deleteAndDispose(handle);
     }
+    $transferActiveChatSession(toWorkspace) {
+        const widget = this._chatWidgetService.lastFocusedWidget;
+        const sessionId = widget?.viewModel?.model.sessionId;
+        if (!sessionId) {
+            this._logService.error(`MainThreadChat#$transferActiveChatSession: No active chat session found`);
+            return;
+        }
+        const inputValue = widget?.inputEditor.getValue() ?? '';
+        this._chatService.transferChatSession({ sessionId, inputValue }, URI.revive(toWorkspace));
+    }
     $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 with an ID in package.json. The "id" property may be missing! "${id}"`
+                ));
             }
-            throw new Error(`chatParticipant must be declared in package.json: ${id}`);
+            throw ( new Error(`chatParticipant must be declared in package.json: ${id}`));
         }
         const impl = {
             invoke: async (request, progress, history, token) => {
@@ -75,20 +93,24 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
                 }
                 return this._proxy.$provideFollowups(request, handle, result, { history }, token);
             },
-            provideWelcomeMessage: (token) => {
-                return this._proxy.$provideWelcomeMessage(handle, token);
+            provideWelcomeMessage: (location, token) => {
+                return this._proxy.$provideWelcomeMessage(handle, location, token);
             },
-            provideSampleQuestions: (token) => {
-                return this._proxy.$provideSampleQuestions(handle, token);
+            provideSampleQuestions: (location, token) => {
+                return this._proxy.$provideSampleQuestions(handle, location, token);
             }
         };
         let disposable;
         if (!staticAgentRegistration && dynamicProps) {
+            const extensionDescription = this._extensionService.extensions.find(e => ExtensionIdentifier.equals(e.identifier, extension));
             disposable = this._chatAgentService.registerDynamicAgent({
                 id,
                 name: dynamicProps.name,
                 description: dynamicProps.description,
                 extensionId: extension,
+                extensionDisplayName: extensionDescription?.displayName ?? extension.value,
+                extensionPublisherId: extensionDescription?.publisher ?? '',
+                extensionPublisherDisplayName: extensionDescription?.publisherDisplayName,
                 metadata: revive(metadata),
                 slashCommands: [],
                 locations: [ChatAgentLocation.Panel]
@@ -107,7 +129,7 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
     $updateAgent(handle, metadataUpdate) {
         const data = this._agents.get(handle);
         if (!data) {
-            throw new Error(`No agent with handle ${handle} registered`);
+            throw ( new Error(`No agent with handle ${handle} registered`));
         }
         data.hasFollowups = metadataUpdate.hasFollowups;
         this._chatAgentService.updateAgent(data.id, revive(metadataUpdate));
@@ -157,7 +179,7 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
                         kind: 18 ,
                         detail: v.detail,
                         documentation: v.documentation,
-                        command: { id: AddDynamicVariableAction.ID, title: '', arguments: [{ widget, range: rangeAfterInsert, variableData: revive(v.values) }] }
+                        command: { id: AddDynamicVariableAction.ID, title: '', arguments: [{ widget, range: rangeAfterInsert, variableData: revive(v.values), command: v.command }] }
                     };
                 }));
                 return {
@@ -176,7 +198,9 @@ MainThreadChatAgents2 = __decorate([
     ( __param(2, IChatService)),
     ( __param(3, ILanguageFeaturesService)),
     ( __param(4, IChatWidgetService)),
-    ( __param(5, IInstantiationService))
+    ( __param(5, IInstantiationService)),
+    ( __param(6, ILogService)),
+    ( __param(7, IExtensionService))
 ], MainThreadChatAgents2);
 function computeCompletionRanges(model, position, reg) {
     const varWord = getWordAtText(position.column, reg, model.getLineContent(position.lineNumber), 0);

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

@@ -94,7 +94,7 @@ let MainThreadEditorInsets = class MainThreadEditorInsets {
     getInset(handle) {
         const inset = this._insets.get(handle);
         if (!inset) {
-            throw new Error('Unknown inset');
+            throw ( new Error('Unknown inset'));
         }
         return inset;
     }

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

@@ -60,7 +60,7 @@ let MainThreadCommands = class MainThreadCommands {
         }
         if (retry && args.length > 0 && !CommandsRegistry.getCommand(id)) {
             await this._extensionService.activateByEvent(`onCommand:${id}`);
-            throw new Error('$executeCommand:retry');
+            throw ( new Error('$executeCommand:retry'));
         }
         return this._commandService.executeCommand(id, ...args);
     }

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

@@ -19,6 +19,7 @@ import { localizeWithPath } from 'vscode/vscode/vs/nls';
 import { Schemas } from 'vscode/vscode/vs/base/common/network';
 import { IViewsService } from 'vscode/vscode/vs/workbench/services/views/common/viewsService.service';
 
+const _moduleId = "vs/workbench/api/browser/mainThreadComments";
 class MainThreadCommentThread {
     get input() {
         return this._input;
@@ -113,20 +114,20 @@ class MainThreadCommentThread {
         this._range = _range;
         this._canReply = _canReply;
         this._isTemplate = _isTemplate;
-        this._onDidChangeInput = ( new Emitter());
-        this._onDidChangeLabel = ( new Emitter());
+        this._onDidChangeInput = ( (new Emitter()));
+        this._onDidChangeLabel = ( (new Emitter()));
         this.onDidChangeLabel = this._onDidChangeLabel.event;
-        this._onDidChangeComments = ( new Emitter());
-        this._onDidChangeCanReply = ( new Emitter());
-        this._onDidChangeRange = ( new Emitter());
+        this._onDidChangeComments = ( (new Emitter()));
+        this._onDidChangeCanReply = ( (new Emitter()));
+        this._onDidChangeRange = ( (new Emitter()));
         this.onDidChangeRange = this._onDidChangeRange.event;
-        this._onDidChangeCollapsibleState = ( new Emitter());
+        this._onDidChangeCollapsibleState = ( (new Emitter()));
         this.onDidChangeCollapsibleState = this._onDidChangeCollapsibleState.event;
-        this._onDidChangeInitialCollapsibleState = ( new Emitter());
+        this._onDidChangeInitialCollapsibleState = ( (new Emitter()));
         this.onDidChangeInitialCollapsibleState = this._onDidChangeInitialCollapsibleState.event;
-        this._onDidChangeApplicability = ( new Emitter());
+        this._onDidChangeApplicability = ( (new Emitter()));
         this.onDidChangeApplicability = this._onDidChangeApplicability.event;
-        this._onDidChangeState = ( new Emitter());
+        this._onDidChangeState = ( (new Emitter()));
         this.onDidChangeState = this._onDidChangeState.event;
         this._isDisposed = false;
         if (_isTemplate) {
@@ -219,7 +220,7 @@ class MainThreadCommentController {
         this._id = _id;
         this._label = _label;
         this._features = _features;
-        this._threads = ( new Map());
+        this._threads = ( (new Map()));
     }
     async setActiveCommentAndThread(commentInfo) {
         return this._proxy.$setActiveComment(this._handle, commentInfo ? { commentThreadHandle: commentInfo.thread.commentThreadHandle, uniqueIdInThread: commentInfo.comment?.uniqueIdInThread } : undefined);
@@ -228,7 +229,16 @@ class MainThreadCommentController {
         this._features = features;
     }
     createCommentThread(extensionId, commentThreadHandle, threadId, resource, range, isTemplate) {
-        const thread = ( new MainThreadCommentThread(commentThreadHandle, this.handle, extensionId, threadId, ( URI.revive(resource).toString()), range, true, isTemplate));
+        const thread = ( (new MainThreadCommentThread(
+            commentThreadHandle,
+            this.handle,
+            extensionId,
+            threadId,
+             (URI.revive(resource).toString()),
+            range,
+            true,
+            isTemplate
+        )));
         this._threads.set(commentThreadHandle, thread);
         if (thread.isDocumentCommentThread()) {
             this._commentService.updateComments(this._uniqueId, {
@@ -310,7 +320,7 @@ class MainThreadCommentController {
     getKnownThread(commentThreadHandle) {
         const thread = this._threads.get(commentThreadHandle);
         if (!thread) {
-            throw new Error('unknown thread');
+            throw ( (new Error('unknown thread')));
         }
         return thread;
     }
@@ -328,9 +338,9 @@ class MainThreadCommentController {
             };
         }
         const ret = [];
-        for (const thread of [...( this._threads.keys())]) {
+        for (const thread of [...( (this._threads.keys()))]) {
             const commentThread = this._threads.get(thread);
-            if (commentThread.resource === ( resource.toString())) {
+            if (commentThread.resource === ( (resource.toString()))) {
                 ret.push(commentThread);
             }
         }
@@ -355,9 +365,9 @@ class MainThreadCommentController {
             };
         }
         const ret = [];
-        for (const thread of [...( this._threads.keys())]) {
+        for (const thread of [...( (this._threads.keys()))]) {
             const commentThread = this._threads.get(thread);
-            if (commentThread.resource === ( resource.toString())) {
+            if (commentThread.resource === ( (resource.toString()))) {
                 ret.push(commentThread);
             }
         }
@@ -372,7 +382,7 @@ class MainThreadCommentController {
     }
     getAllComments() {
         const ret = [];
-        for (const thread of [...( this._threads.keys())]) {
+        for (const thread of [...( (this._threads.keys()))]) {
             ret.push(this._threads.get(thread));
         }
         return ret;
@@ -390,22 +400,18 @@ class MainThreadCommentController {
         };
     }
 }
-const commentsViewIcon = registerIcon('comments-view-icon', Codicon.commentDiscussion, ( localizeWithPath(
-    'vs/workbench/api/browser/mainThreadComments',
-    'commentsViewIcon',
-    'View icon of the comments view.'
-)));
+const commentsViewIcon = registerIcon('comments-view-icon', Codicon.commentDiscussion, ( localizeWithPath(_moduleId, 0, 'View icon of the comments view.')));
 let MainThreadComments = class MainThreadComments extends Disposable {
     constructor(extHostContext, _commentService, _viewsService, _viewDescriptorService) {
         super();
         this._commentService = _commentService;
         this._viewsService = _viewsService;
         this._viewDescriptorService = _viewDescriptorService;
-        this._handlers = ( new Map());
-        this._commentControllers = ( new Map());
-        this._activeEditingCommentThreadDisposables = this._register(( new DisposableStore()));
+        this._handlers = ( (new Map()));
+        this._commentControllers = ( (new Map()));
+        this._activeEditingCommentThreadDisposables = this._register(( (new DisposableStore())));
         this._openViewListener = null;
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostComments));
+        this._proxy = ( (extHostContext.getProxy(ExtHostContext.ExtHostComments)));
         this._commentService.unregisterCommentController();
         this._register(this._commentService.onDidChangeActiveEditingCommentThread(async (thread) => {
             const handle = thread.controllerHandle;
@@ -421,7 +427,7 @@ let MainThreadComments = class MainThreadComments extends Disposable {
     $registerCommentController(handle, id, label, extensionId) {
         const providerId = `${id}-${extensionId}`;
         this._handlers.set(handle, providerId);
-        const provider = ( new MainThreadCommentController(this._proxy, this._commentService, handle, providerId, id, label, {}));
+        const provider = ( (new MainThreadCommentController(this._proxy, this._commentService, handle, providerId, id, label, {})));
         this._commentService.registerCommentController(providerId, provider);
         this._commentControllers.set(handle, provider);
         const commentsPanelAlreadyConstructed = !!this._viewDescriptorService.getViewDescriptorById(COMMENTS_VIEW_ID);
@@ -479,23 +485,23 @@ let MainThreadComments = class MainThreadComments extends Disposable {
     }
     registerView(commentsViewAlreadyRegistered) {
         if (!commentsViewAlreadyRegistered) {
-            const VIEW_CONTAINER = ( Registry.as(Extensions.ViewContainersRegistry)).registerViewContainer({
+            const VIEW_CONTAINER = ( (Registry.as(Extensions.ViewContainersRegistry))).registerViewContainer({
                 id: COMMENTS_VIEW_ID,
                 title: COMMENTS_VIEW_TITLE,
-                ctorDescriptor: ( new SyncDescriptor(
+                ctorDescriptor: ( (new SyncDescriptor(
                     ViewPaneContainer,
                     [COMMENTS_VIEW_ID, { mergeViewWithContainerWhenSingleView: true }]
-                )),
+                ))),
                 storageId: COMMENTS_VIEW_STORAGE_ID,
                 hideIfEmpty: true,
                 icon: commentsViewIcon,
                 order: 10,
             }, 1 );
-            ( Registry.as(Extensions.ViewsRegistry)).registerViews([{
+            ( (Registry.as(Extensions.ViewsRegistry))).registerViews([{
                     id: COMMENTS_VIEW_ID,
                     name: COMMENTS_VIEW_TITLE,
                     canToggleVisibility: false,
-                    ctorDescriptor: ( new SyncDescriptor(CommentsPanel)),
+                    ctorDescriptor: ( (new SyncDescriptor(CommentsPanel))),
                     canMoveView: true,
                     containerIcon: commentsViewIcon,
                     focusCommand: {
@@ -505,7 +511,7 @@ let MainThreadComments = class MainThreadComments extends Disposable {
         }
     }
     setComments() {
-        [...( this._commentControllers.keys())].forEach(handle => {
+        [...( (this._commentControllers.keys()))].forEach(handle => {
             const threads = this._commentControllers.get(handle).getAllComments();
             if (threads.length) {
                 const providerId = this.getHandler(handle);
@@ -545,17 +551,17 @@ let MainThreadComments = class MainThreadComments extends Disposable {
         }));
     }
     getHandler(handle) {
-        if (!( this._handlers.has(handle))) {
-            throw new Error('Unknown handler');
+        if (!( (this._handlers.has(handle)))) {
+            throw ( (new Error('Unknown handler')));
         }
         return this._handlers.get(handle);
     }
 };
 MainThreadComments = __decorate([
     extHostNamedCustomer(MainContext.MainThreadComments),
-    ( __param(1, ICommentService)),
-    ( __param(2, IViewsService)),
-    ( __param(3, IViewDescriptorService))
+    ( (__param(1, ICommentService))),
+    ( (__param(2, IViewsService))),
+    ( (__param(3, IViewDescriptorService)))
 ], MainThreadComments);
 
 export { MainThreadCommentController, MainThreadCommentThread, MainThreadComments };