@codingame/monaco-vscode-extensions-service-override 4.5.0 → 4.5.2

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

@@ -16,6 +16,7 @@ import { IExtensionFeaturesManagementService } from 'vscode/vscode/vs/workbench/
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
 
+const _moduleId = "vs/workbench/api/browser/mainThreadLanguageModels";
 let MainThreadLanguageModels = class MainThreadLanguageModels {
     constructor(extHostContext, _chatProviderService, _extensionFeaturesManagementService, _logService, _authenticationService, _authenticationAccessService, _extensionService) {
         this._chatProviderService = _chatProviderService;
@@ -24,11 +25,11 @@ let MainThreadLanguageModels = class MainThreadLanguageModels {
         this._authenticationService = _authenticationService;
         this._authenticationAccessService = _authenticationAccessService;
         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: coalesce(( _chatProviderService.getLanguageModelIds().map(id => _chatProviderService.lookupLanguageModel(id)))) });
+        this._store = ( (new DisposableStore()));
+        this._providerRegistrations = ( (new DisposableMap()));
+        this._pendingProgress = ( (new Map()));
+        this._proxy = ( (extHostContext.getProxy(ExtHostContext.ExtHostChatProvider)));
+        this._proxy.$updateLanguageModels({ added: coalesce(( (_chatProviderService.getLanguageModelIds().map(id => _chatProviderService.lookupLanguageModel(id))))) });
         this._store.add(_chatProviderService.onDidChangeLanguageModels(this._proxy.$updateLanguageModels, this._proxy));
     }
     dispose() {
@@ -36,7 +37,7 @@ let MainThreadLanguageModels = class MainThreadLanguageModels {
         this._store.dispose();
     }
     $registerLanguageModelProvider(handle, identifier, metadata) {
-        const dipsosables = ( new DisposableStore());
+        const dipsosables = ( (new DisposableStore()));
         dipsosables.add(this._chatProviderService.registerLanguageModelChat(identifier, {
             metadata,
             provideChatResponse: async (messages, from, options, progress, token) => {
@@ -53,14 +54,9 @@ let MainThreadLanguageModels = class MainThreadLanguageModels {
         if (metadata.auth) {
             dipsosables.add(this._registerAuthenticationProvider(metadata.extension, metadata.auth));
         }
-        dipsosables.add(( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
+        dipsosables.add(( (Registry.as(Extensions.ExtensionFeaturesRegistry))).registerExtensionFeature({
             id: `lm-${identifier}`,
-            label: ( localizeWithPath(
-                'vs/workbench/api/browser/mainThreadLanguageModels',
-                'languageModels',
-                "Language Model ({0})",
-                `${identifier}`
-            )),
+            label: ( localizeWithPath(_moduleId, 0, "Language Model ({0})", `${identifier}`)),
             access: {
                 canToggle: false,
             },
@@ -88,9 +84,9 @@ let MainThreadLanguageModels = class MainThreadLanguageModels {
     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.makeLanguageModelChatRequest(providerId, extension, messages, options, ( new Progress(value => {
+        const task = this._chatProviderService.makeLanguageModelChatRequest(providerId, extension, messages, options, ( (new Progress(value => {
             this._proxy.$handleResponseFragment(requestId, value);
-        })), token);
+        }))), token);
         task.catch(err => {
             this._logService.error('[CHAT] extension request ERRORED', err, extension.value, requestId);
             throw err;
@@ -104,13 +100,9 @@ let MainThreadLanguageModels = class MainThreadLanguageModels {
         if (this._authenticationService.getProviderIds().includes(authProviderId)) {
             return Disposable.None;
         }
-        const accountLabel = auth.accountLabel ?? ( localizeWithPath(
-            'vs/workbench/api/browser/mainThreadLanguageModels',
-            'languageModelsAccountId',
-            'Language Models'
-        ));
-        const disposables = ( new DisposableStore());
-        this._authenticationService.registerAuthenticationProvider(authProviderId, ( new LanguageModelAccessAuthProvider(authProviderId, auth.providerLabel, accountLabel)));
+        const accountLabel = auth.accountLabel ?? ( localizeWithPath(_moduleId, 1, 'Language Models'));
+        const disposables = ( (new DisposableStore()));
+        this._authenticationService.registerAuthenticationProvider(authProviderId, ( (new LanguageModelAccessAuthProvider(authProviderId, auth.providerLabel, accountLabel))));
         disposables.add(toDisposable(() => {
             this._authenticationService.unregisterAuthenticationProvider(authProviderId);
         }));
@@ -134,12 +126,12 @@ let MainThreadLanguageModels = class MainThreadLanguageModels {
 };
 MainThreadLanguageModels = __decorate([
     extHostNamedCustomer(MainContext.MainThreadLanguageModels),
-    ( __param(1, ILanguageModelsService)),
-    ( __param(2, IExtensionFeaturesManagementService)),
-    ( __param(3, ILogService)),
-    ( __param(4, IAuthenticationService)),
-    ( __param(5, IAuthenticationAccessService)),
-    ( __param(6, IExtensionService))
+    ( (__param(1, ILanguageModelsService))),
+    ( (__param(2, IExtensionFeaturesManagementService))),
+    ( (__param(3, ILogService))),
+    ( (__param(4, IAuthenticationService))),
+    ( (__param(5, IAuthenticationAccessService))),
+    ( (__param(6, IExtensionService)))
 ], MainThreadLanguageModels);
 class LanguageModelAccessAuthProvider {
     constructor(id, label, _accountLabel) {
@@ -147,7 +139,7 @@ class LanguageModelAccessAuthProvider {
         this.label = label;
         this._accountLabel = _accountLabel;
         this.supportsMultipleAccounts = false;
-        this._onDidChangeSessions = ( new Emitter());
+        this._onDidChangeSessions = ( (new Emitter()));
         this.onDidChangeSessions = this._onDidChangeSessions.event;
     }
     async getSessions(scopes) {

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

@@ -25,7 +25,7 @@ let MainThreadLoggerService = class MainThreadLoggerService {
     $log(file, messages) {
         const logger = this.loggerService.getLogger(URI.revive(file));
         if (!logger) {
-            throw new Error('Create the logger before logging');
+            throw ( new Error('Create the logger before logging'));
         }
         for (const [level, message] of messages) {
             log(logger, level, message);
@@ -49,7 +49,7 @@ let MainThreadLoggerService = class MainThreadLoggerService {
     $flush(file) {
         const logger = this.loggerService.getLogger(URI.revive(file));
         if (!logger) {
-            throw new Error('Create the logger before flushing');
+            throw ( new Error('Create the logger before flushing'));
         }
         logger.flush();
     }

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

@@ -9,6 +9,7 @@ import { Event } from 'vscode/vscode/vs/base/common/event';
 import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands.service';
 import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
 
+const _moduleId = "vs/workbench/api/browser/mainThreadMessageService";
 let MainThreadMessageService = class MainThreadMessageService {
     constructor(extHostContext, _notificationService, _commandService, _dialogService, extensionService) {
         this._notificationService = _notificationService;
@@ -32,54 +33,48 @@ let MainThreadMessageService = class MainThreadMessageService {
         }
     }
     _showMessage(severity, message, commands, options) {
-        return ( new Promise(resolve => {
-            const primaryActions = ( commands.map(command => toAction({
-                id: `_extension_message_handle_${command.handle}`,
-                label: command.title,
-                enabled: true,
-                run: () => {
-                    resolve(command.handle);
-                    return Promise.resolve();
-                }
-            })));
-            let source;
-            if (options.source) {
-                source = {
-                    label: options.source.label,
-                    id: options.source.identifier.value
-                };
-            }
-            if (!source) {
-                source = ( localizeWithPath(
-                    'vs/workbench/api/browser/mainThreadMessageService',
-                    'defaultSource',
-                    "Extension"
-                ));
-            }
-            const secondaryActions = [];
-            if (options.source) {
-                secondaryActions.push(toAction({
-                    id: options.source.identifier.value,
-                    label: ( localizeWithPath(
-                        'vs/workbench/api/browser/mainThreadMessageService',
-                        'manageExtension',
-                        "Manage Extension"
-                    )),
+        return (
+             (new Promise(resolve => {
+                const primaryActions = ( (commands.map(command => toAction({
+                    id: `_extension_message_handle_${command.handle}`,
+                    label: command.title,
+                    enabled: true,
                     run: () => {
-                        return this._commandService.executeCommand('_extensions.manage', options.source.identifier.value);
+                        resolve(command.handle);
+                        return Promise.resolve();
                     }
-                }));
-            }
-            const messageHandle = this._notificationService.notify({
-                severity,
-                message,
-                actions: { primary: primaryActions, secondary: secondaryActions },
-                source
-            });
-            Event.once(messageHandle.onDidClose)(() => {
-                resolve(undefined);
-            });
-        }));
+                }))));
+                let source;
+                if (options.source) {
+                    source = {
+                        label: options.source.label,
+                        id: options.source.identifier.value
+                    };
+                }
+                if (!source) {
+                    source = ( localizeWithPath(_moduleId, 0, "Extension"));
+                }
+                const secondaryActions = [];
+                if (options.source) {
+                    secondaryActions.push(toAction({
+                        id: options.source.identifier.value,
+                        label: ( localizeWithPath(_moduleId, 1, "Manage Extension")),
+                        run: () => {
+                            return this._commandService.executeCommand('_extensions.manage', options.source.identifier.value);
+                        }
+                    }));
+                }
+                const messageHandle = this._notificationService.notify({
+                    severity,
+                    message,
+                    actions: { primary: primaryActions, secondary: secondaryActions },
+                    source
+                });
+                Event.once(messageHandle.onDidClose)(() => {
+                    resolve(undefined);
+                });
+            }))
+        );
     }
     async _showModalMessage(severity, message, detail, commands, useCustom) {
         const buttons = [];
@@ -99,17 +94,13 @@ let MainThreadMessageService = class MainThreadMessageService {
         if (!cancelButton) {
             if (buttons.length > 0) {
                 cancelButton = {
-                    label: ( localizeWithPath('vs/workbench/api/browser/mainThreadMessageService', 'cancel', "Cancel")),
+                    label: ( localizeWithPath(_moduleId, 2, "Cancel")),
                     run: () => undefined
                 };
             }
             else {
                 cancelButton = {
-                    label: ( localizeWithPath(
-                        'vs/workbench/api/browser/mainThreadMessageService',
-                        { key: 'ok', comment: ['&& denotes a mnemonic'] },
-                        "&&OK"
-                    )),
+                    label: ( localizeWithPath(_moduleId, 3, "&&OK")),
                     run: () => undefined
                 };
             }
@@ -127,10 +118,10 @@ let MainThreadMessageService = class MainThreadMessageService {
 };
 MainThreadMessageService = __decorate([
     extHostNamedCustomer(MainContext.MainThreadMessageService),
-    ( __param(1, INotificationService)),
-    ( __param(2, ICommandService)),
-    ( __param(3, IDialogService)),
-    ( __param(4, IExtensionService))
+    ( (__param(1, INotificationService))),
+    ( (__param(2, ICommandService))),
+    ( (__param(3, IDialogService))),
+    ( (__param(4, IExtensionService)))
 ], MainThreadMessageService);
 
 export { MainThreadMessageService };

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

@@ -83,7 +83,9 @@ let MainThreadNotebookEditors = class MainThreadNotebookEditors {
             return notebookEditor.getId();
         }
         else {
-            throw new Error(`Notebook Editor creation failure for document ${JSON.stringify(resource)}`);
+            throw ( new Error(
+                `Notebook Editor creation failure for document ${JSON.stringify(resource)}`
+            ));
         }
     }
     async $tryRevealRange(id, range, revealType) {

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

@@ -147,7 +147,7 @@ let MainThreadNotebookKernels = class MainThreadNotebookKernels {
     async $postMessage(handle, editorId, message) {
         const tuple = this._kernels.get(handle);
         if (!tuple) {
-            throw new Error('kernel already disposed');
+            throw ( new Error('kernel already disposed'));
         }
         const [kernel] = tuple;
         let didSend = false;
@@ -236,11 +236,11 @@ let MainThreadNotebookKernels = class MainThreadNotebookKernels {
         const uri = URI.revive(rawUri);
         const notebook = this._notebookService.getNotebookTextModel(uri);
         if (!notebook) {
-            throw new Error(`Notebook not found: ${uri.toString()}`);
+            throw ( new Error(`Notebook not found: ${( uri.toString())}`));
         }
         const kernel = this._notebookKernelService.getMatchingKernel(notebook);
         if (!kernel.selected || kernel.selected.id !== controllerId) {
-            throw new Error(`Kernel is not selected: ${kernel.selected?.id} !== ${controllerId}`);
+            throw ( new Error(`Kernel is not selected: ${kernel.selected?.id} !== ${controllerId}`));
         }
         const execution = this._notebookExecutionStateService.createCellExecution(uri, cellHandle);
         execution.confirm();
@@ -272,11 +272,11 @@ let MainThreadNotebookKernels = class MainThreadNotebookKernels {
         const uri = URI.revive(rawUri);
         const notebook = this._notebookService.getNotebookTextModel(uri);
         if (!notebook) {
-            throw new Error(`Notebook not found: ${uri.toString()}`);
+            throw ( new Error(`Notebook not found: ${( uri.toString())}`));
         }
         const kernel = this._notebookKernelService.getMatchingKernel(notebook);
         if (!kernel.selected || kernel.selected.id !== controllerId) {
-            throw new Error(`Kernel is not selected: ${kernel.selected?.id} !== ${controllerId}`);
+            throw ( new Error(`Kernel is not selected: ${kernel.selected?.id} !== ${controllerId}`));
         }
         const execution = this._notebookExecutionStateService.createExecution(uri);
         execution.confirm();

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

@@ -7,26 +7,23 @@ import { raceCancellationError } from 'vscode/vscode/vs/base/common/async';
 import { IWorkingCopyFileService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService.service';
 import { NotebookFileWorkingCopyModel } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookEditorModel';
 
+const _moduleId = "vs/workbench/api/browser/mainThreadNotebookSaveParticipant";
 class ExtHostNotebookDocumentSaveParticipant {
     constructor(extHostContext) {
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostNotebookDocumentSaveParticipant));
+        this._proxy = ( (extHostContext.getProxy(ExtHostContext.ExtHostNotebookDocumentSaveParticipant)));
     }
     async participate(workingCopy, context, _progress, token) {
         if (!workingCopy.model || !(workingCopy.model instanceof NotebookFileWorkingCopyModel)) {
             return undefined;
         }
         let _warningTimeout;
-        const p = ( new Promise((resolve, reject) => {
-            _warningTimeout = setTimeout(() => reject(( new Error(( localizeWithPath(
-                'vs/workbench/api/browser/mainThreadNotebookSaveParticipant',
-                'timeout.onWillSave',
-                "Aborted onWillSaveNotebookDocument-event after 1750ms"
-            ))))), 1750);
+        const p = ( (new Promise((resolve, reject) => {
+            _warningTimeout = setTimeout(() => reject(( (new Error(( localizeWithPath(_moduleId, 0, "Aborted onWillSaveNotebookDocument-event after 1750ms")))))), 1750);
             this._proxy.$participateInSave(workingCopy.resource, context.reason, token).then(_ => {
                 clearTimeout(_warningTimeout);
                 return undefined;
             }).then(resolve, reject);
-        }));
+        })));
         return raceCancellationError(p, token);
     }
 }
@@ -41,8 +38,8 @@ let SaveParticipant = class SaveParticipant {
 };
 SaveParticipant = __decorate([
     extHostCustomer,
-    ( __param(1, IInstantiationService)),
-    ( __param(2, IWorkingCopyFileService))
+    ( (__param(1, IInstantiationService))),
+    ( (__param(2, IWorkingCopyFileService)))
 ], SaveParticipant);
 
 export { SaveParticipant };

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

@@ -6,6 +6,7 @@ import { Action } from 'vscode/vscode/vs/base/common/actions';
 import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands.service';
 import { localizeWithPath } from 'vscode/vscode/vs/nls';
 
+const _moduleId = "vs/workbench/api/browser/mainThreadProgress";
 class ManageExtensionAction extends Action {
     constructor(extensionId, label, commandService) {
         super(extensionId, label, undefined, true, () => {
@@ -16,8 +17,8 @@ class ManageExtensionAction extends Action {
 let MainThreadProgress = class MainThreadProgress {
     constructor(extHostContext, progressService, _commandService) {
         this._commandService = _commandService;
-        this._progress = ( new Map());
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostProgress));
+        this._progress = ( (new Map()));
+        this._proxy = ( (extHostContext.getProxy(ExtHostContext.ExtHostProgress)));
         this._progressService = progressService;
     }
     dispose() {
@@ -30,11 +31,7 @@ let MainThreadProgress = class MainThreadProgress {
             const notificationOptions = {
                 ...options,
                 location: 15 ,
-                secondaryActions: [( new ManageExtensionAction(extensionId, ( localizeWithPath(
-                    'vs/workbench/api/browser/mainThreadProgress',
-                    'manageExtension',
-                    "Manage Extension"
-                )), this._commandService))]
+                secondaryActions: [( (new ManageExtensionAction(extensionId, ( localizeWithPath(_moduleId, 0, "Manage Extension")), this._commandService)))]
             };
             options = notificationOptions;
         }
@@ -53,16 +50,18 @@ let MainThreadProgress = class MainThreadProgress {
     }
     _createTask(handle) {
         return (progress) => {
-            return ( new Promise(resolve => {
-                this._progress.set(handle, { resolve, progress });
-            }));
+            return (
+                 (new Promise(resolve => {
+                    this._progress.set(handle, { resolve, progress });
+                }))
+            );
         };
     }
 };
 MainThreadProgress = __decorate([
     extHostNamedCustomer(MainContext.MainThreadProgress),
-    ( __param(1, IProgressService)),
-    ( __param(2, ICommandService))
+    ( (__param(1, IProgressService))),
+    ( (__param(2, ICommandService)))
 ], MainThreadProgress);
 
 export { MainThreadProgress };

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

@@ -7,27 +7,24 @@ import { ITextFileService } from 'vscode/vscode/vs/workbench/services/textfile/c
 import { ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
 import { raceCancellationError } from 'vscode/vscode/vs/base/common/async';
 
+const _moduleId = "vs/workbench/api/browser/mainThreadSaveParticipant";
 class ExtHostSaveParticipant {
     constructor(extHostContext) {
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostDocumentSaveParticipant));
+        this._proxy = ( (extHostContext.getProxy(ExtHostContext.ExtHostDocumentSaveParticipant)));
     }
     async participate(editorModel, context, _progress, token) {
         if (!editorModel.textEditorModel || !shouldSynchronizeModel(editorModel.textEditorModel)) {
             return undefined;
         }
-        const p = ( new Promise((resolve, reject) => {
-            setTimeout(() => reject(( new Error(( localizeWithPath(
-                'vs/workbench/api/browser/mainThreadSaveParticipant',
-                'timeout.onWillSave',
-                "Aborted onWillSaveTextDocument-event after 1750ms"
-            ))))), 1750);
+        const p = ( (new Promise((resolve, reject) => {
+            setTimeout(() => reject(( (new Error(( localizeWithPath(_moduleId, 0, "Aborted onWillSaveTextDocument-event after 1750ms")))))), 1750);
             this._proxy.$participateInSave(editorModel.resource, context.reason).then(values => {
                 if (!values.every(success => success)) {
-                    return Promise.reject(( new Error('listener failed')));
+                    return Promise.reject(( (new Error('listener failed'))));
                 }
                 return undefined;
             }).then(resolve, reject);
-        }));
+        })));
         return raceCancellationError(p, token);
     }
 }
@@ -42,8 +39,8 @@ let SaveParticipant = class SaveParticipant {
 };
 SaveParticipant = __decorate([
     extHostCustomer,
-    ( __param(1, IInstantiationService)),
-    ( __param(2, ITextFileService))
+    ( (__param(1, IInstantiationService))),
+    ( (__param(2, ITextFileService)))
 ], SaveParticipant);
 
 export { SaveParticipant };

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

@@ -59,14 +59,14 @@ let MainThreadSearch = class MainThreadSearch {
     $handleFileMatch(handle, session, data) {
         const provider = this._searchProvider.get(handle);
         if (!provider) {
-            throw new Error('Got result for unknown provider');
+            throw ( new Error('Got result for unknown provider'));
         }
         provider.handleFindMatch(session, data);
     }
     $handleTextMatch(handle, session, data) {
         const provider = this._searchProvider.get(handle);
         if (!provider) {
-            throw new Error('Got result for unknown provider');
+            throw ( new Error('Got result for unknown provider'));
         }
         provider.handleFindMatch(session, data);
     }
@@ -121,7 +121,7 @@ class RemoteSearchProvider {
     }
     doSearch(query, onProgress, token = CancellationToken.None) {
         if (!query.folderQueries.length) {
-            throw new Error('Empty folderQueries');
+            throw ( new Error('Empty folderQueries'));
         }
         const search = ( new SearchOperation(onProgress));
         this._searches.set(search.id, search);