@codingame/monaco-vscode-extensions-service-override 2.2.1 → 3.0.0

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

@@ -297,7 +297,7 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
                 const config = this._configurationService.getValue();
                 if (config.files?.watcherExclude) {
                     for (const key in config.files.watcherExclude) {
-                        if (config.files.watcherExclude[key] === true) {
+                        if (key && config.files.watcherExclude[key] === true) {
                             opts.excludes.push(key);
                         }
                     }
@@ -307,7 +307,7 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
                 const config = this._configurationService.getValue();
                 if (config.files?.watcherExclude) {
                     for (const key in config.files.watcherExclude) {
-                        if (config.files.watcherExclude[key] === true) {
+                        if (key && config.files.watcherExclude[key] === true) {
                             if (!opts.includes) {
                                 opts.includes = [];
                             }

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

@@ -391,6 +391,13 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
                 : undefined
         }));
     }
+    $registerNewSymbolNamesProvider(handle, selector) {
+        this._registrations.set(handle, this._languageFeaturesService.newSymbolNamesProvider.register(selector, {
+            provideNewSymbolNames: (model, range, token) => {
+                return this._proxy.$provideNewSymbolNames(handle, model.uri, range, token);
+            }
+        }));
+    }
     $registerDocumentSemanticTokensProvider(handle, selector, legend, eventHandle) {
         let event = undefined;
         if (typeof eventHandle === 'number') {
@@ -500,6 +507,17 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
         };
         this._registrations.set(handle, this._languageFeaturesService.inlineCompletionsProvider.register(selector, provider));
     }
+    $registerInlineEditProvider(handle, selector, extensionId) {
+        const provider = {
+            provideInlineEdit: async (model, context, token) => {
+                return this._proxy.$provideInlineEdit(handle, model.uri, context, token);
+            },
+            freeInlineEdit: (edit) => {
+                this._proxy.$freeInlineEdit(handle, edit.pid);
+            }
+        };
+        this._registrations.set(handle, this._languageFeaturesService.inlineEditProvider.register(selector, provider));
+    }
     $registerSignatureHelpProvider(handle, selector, metadata) {
         this._registrations.set(handle, this._languageFeaturesService.signatureHelpProvider.register(selector, {
             signatureHelpTriggerCharacters: metadata.triggerCharacters,

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

@@ -6,12 +6,14 @@ import { extHostNamedCustomer } from '../../services/extensions/common/extHostCu
 import '../../../../../../override/vs/platform/dialogs/common/dialogs.js';
 import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification';
 import { Event } from 'vscode/vscode/vs/base/common/event';
+import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
 import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
 import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
 
 let MainThreadMessageService = class MainThreadMessageService {
-    constructor(extHostContext, _notificationService, _dialogService, extensionService) {
+    constructor(extHostContext, _notificationService, _commandService, _dialogService, extensionService) {
         this._notificationService = _notificationService;
+        this._commandService = _commandService;
         this._dialogService = _dialogService;
         this.extensionsListener = extensionService.onDidChangeExtensions(e => {
             for (const extension of e.removed) {
@@ -56,6 +58,19 @@ let MainThreadMessageService = class MainThreadMessageService {
                 ));
             }
             const secondaryActions = [];
+            if (options.source) {
+                secondaryActions.push(toAction({
+                    id: options.source.identifier.value,
+                    label: ( localizeWithPath(
+                        'vs/workbench/api/browser/mainThreadMessageService',
+                        'manageExtension',
+                        "Manage Extension"
+                    )),
+                    run: () => {
+                        return this._commandService.executeCommand('_extensions.manage', options.source.identifier.value);
+                    }
+                }));
+            }
             const messageHandle = this._notificationService.notify({
                 severity,
                 message,
@@ -114,8 +129,9 @@ let MainThreadMessageService = class MainThreadMessageService {
 MainThreadMessageService = __decorate([
     extHostNamedCustomer(MainContext.MainThreadMessageService),
     ( __param(1, INotificationService)),
-    ( __param(2, IDialogService)),
-    ( __param(3, IExtensionService))
+    ( __param(2, ICommandService)),
+    ( __param(3, IDialogService)),
+    ( __param(4, IExtensionService))
 ], MainThreadMessageService);
 
 export { MainThreadMessageService };

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

@@ -11,7 +11,7 @@ class ExtHostNotebookDocumentSaveParticipant {
     constructor(extHostContext) {
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostNotebookDocumentSaveParticipant));
     }
-    async participate(workingCopy, env, _progress, token) {
+    async participate(workingCopy, context, _progress, token) {
         if (!workingCopy.model || !(workingCopy.model instanceof NotebookFileWorkingCopyModel)) {
             return undefined;
         }
@@ -22,7 +22,7 @@ class ExtHostNotebookDocumentSaveParticipant {
                 'timeout.onWillSave',
                 "Aborted onWillSaveNotebookDocument-event after 1750ms"
             ))))), 1750);
-            this._proxy.$participateInSave(workingCopy.resource, env.reason, token).then(_ => {
+            this._proxy.$participateInSave(workingCopy.resource, context.reason, token).then(_ => {
                 clearTimeout(_warningTimeout);
                 return undefined;
             }).then(resolve, reject);

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

@@ -11,7 +11,7 @@ class ExtHostSaveParticipant {
     constructor(extHostContext) {
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostDocumentSaveParticipant));
     }
-    async participate(editorModel, env, _progress, token) {
+    async participate(editorModel, context, _progress, token) {
         if (!editorModel.textEditorModel || !shouldSynchronizeModel(editorModel.textEditorModel)) {
             return undefined;
         }
@@ -21,7 +21,7 @@ class ExtHostSaveParticipant {
                 'timeout.onWillSave',
                 "Aborted onWillSaveTextDocument-event after 1750ms"
             ))))), 1750);
-            this._proxy.$participateInSave(editorModel.resource, env.reason).then(values => {
+            this._proxy.$participateInSave(editorModel.resource, context.reason).then(values => {
                 if (!values.every(success => success)) {
                     return Promise.reject(( new Error('listener failed')));
                 }

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

@@ -1,6 +1,5 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
-import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { Event, Emitter } from 'vscode/vscode/vs/base/common/event';
 import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
 import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
@@ -20,38 +19,44 @@ let MainThreadSpeech = class MainThreadSpeech {
         this.logService.trace('[Speech] extension registered provider', metadata.extension.value);
         const registration = this.speechService.registerSpeechProvider(identifier, {
             metadata,
-            createSpeechToTextSession: token => {
+            createSpeechToTextSession: (token, options) => {
+                if (token.isCancellationRequested) {
+                    return {
+                        onDidChange: Event.None
+                    };
+                }
                 const disposables = ( new DisposableStore());
-                const cts = ( new CancellationTokenSource(token));
                 const session = Math.random();
-                this.proxy.$createSpeechToTextSession(handle, session);
-                disposables.add(token.onCancellationRequested(() => this.proxy.$cancelSpeechToTextSession(session)));
+                this.proxy.$createSpeechToTextSession(handle, session, options?.language);
                 const onDidChange = disposables.add(( new Emitter()));
                 this.speechToTextSessions.set(session, { onDidChange });
+                disposables.add(token.onCancellationRequested(() => {
+                    this.proxy.$cancelSpeechToTextSession(session);
+                    this.speechToTextSessions.delete(session);
+                    disposables.dispose();
+                }));
                 return {
-                    onDidChange: onDidChange.event,
-                    dispose: () => {
-                        cts.dispose(true);
-                        this.speechToTextSessions.delete(session);
-                        disposables.dispose();
-                    }
+                    onDidChange: onDidChange.event
                 };
             },
             createKeywordRecognitionSession: token => {
+                if (token.isCancellationRequested) {
+                    return {
+                        onDidChange: Event.None
+                    };
+                }
                 const disposables = ( new DisposableStore());
-                const cts = ( new CancellationTokenSource(token));
                 const session = Math.random();
                 this.proxy.$createKeywordRecognitionSession(handle, session);
-                disposables.add(token.onCancellationRequested(() => this.proxy.$cancelKeywordRecognitionSession(session)));
                 const onDidChange = disposables.add(( new Emitter()));
                 this.keywordRecognitionSessions.set(session, { onDidChange });
+                disposables.add(token.onCancellationRequested(() => {
+                    this.proxy.$cancelKeywordRecognitionSession(session);
+                    this.keywordRecognitionSessions.delete(session);
+                    disposables.dispose();
+                }));
                 return {
-                    onDidChange: onDidChange.event,
-                    dispose: () => {
-                        cts.dispose(true);
-                        this.keywordRecognitionSessions.delete(session);
-                        disposables.dispose();
-                    }
+                    onDidChange: onDidChange.event
                 };
             }
         });

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

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { DisposableStore, MutableDisposable, Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { DisposableStore, MutableDisposable, combinedDisposable, Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
@@ -38,6 +38,7 @@ let MainThreadTerminalService = class MainThreadTerminalService {
         this._quickFixProviders = ( new Map());
         this._dataEventTracker = ( new MutableDisposable());
         this._sendCommandEventListener = ( new MutableDisposable());
+        this._linkProvider = this._store.add(( new MutableDisposable()));
         this._os = OS;
         this._proxy = ( _extHostContext.getProxy(ExtHostContext.ExtHostTerminalService));
         this._store.add(_terminalService.onDidCreateInstance((instance) => {
@@ -76,7 +77,6 @@ let MainThreadTerminalService = class MainThreadTerminalService {
     }
     dispose() {
         this._store.dispose();
-        this._linkProvider?.dispose();
         for (const provider of ( this._profileProviders.values())) {
             provider.dispose();
         }
@@ -188,7 +188,7 @@ let MainThreadTerminalService = class MainThreadTerminalService {
             return;
         }
         const multiplexer = this._terminalService.createOnInstanceCapabilityEvent(2 , capability => capability.onCommandFinished);
-        multiplexer.event(e => {
+        const sub = multiplexer.event(e => {
             this._onDidExecuteCommand(e.instance.instanceId, {
                 commandLine: e.data.command,
                 cwd: e.data.cwd,
@@ -196,18 +196,16 @@ let MainThreadTerminalService = class MainThreadTerminalService {
                 output: e.data.getOutput()
             });
         });
-        this._sendCommandEventListener.value = multiplexer;
+        this._sendCommandEventListener.value = combinedDisposable(multiplexer, sub);
     }
     $stopSendingCommandEvents() {
         this._sendCommandEventListener.clear();
     }
     $startLinkProvider() {
-        this._linkProvider?.dispose();
-        this._linkProvider = this._terminalLinkProviderService.registerLinkProvider(( new ExtensionTerminalLinkProvider(this._proxy)));
+        this._linkProvider.value = this._terminalLinkProviderService.registerLinkProvider(( new ExtensionTerminalLinkProvider(this._proxy)));
     }
     $stopLinkProvider() {
-        this._linkProvider?.dispose();
-        this._linkProvider = undefined;
+        this._linkProvider.clear();
     }
     $registerProcessSupport(isSupported) {
         this._terminalService.registerProcessSupport(isSupported);

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

@@ -136,18 +136,10 @@ let MainThreadWorkspace = class MainThreadWorkspace {
             transient: workspace.transient
         };
     }
-    $startFileSearch(includePattern, _includeFolder, excludePatternOrDisregardExcludes, maxResults, token) {
+    $startFileSearch(_includeFolder, options, token) {
         const includeFolder = URI.revive(_includeFolder);
         const workspace = this._contextService.getWorkspace();
-        const query = this._queryBuilder.file(includeFolder ? [includeFolder] : workspace.folders, {
-            maxResults: maxResults ?? undefined,
-            disregardExcludeSettings: (excludePatternOrDisregardExcludes === false) || undefined,
-            disregardSearchExcludeSettings: true,
-            disregardIgnoreFiles: true,
-            includePattern: includePattern ?? undefined,
-            excludePattern: typeof excludePatternOrDisregardExcludes === 'string' ? excludePatternOrDisregardExcludes : undefined,
-            _reason: 'startFileSearch'
-        });
+        const query = this._queryBuilder.file(includeFolder ? [includeFolder] : workspace.folders, options);
         return this._searchService.fileSearch(query, token).then(result => {
             return ( result.results.map(m => m.resource));
         }, err => {

package/vscode/src/vs/workbench/services/extensions/common/abstractExtensionService.js

@@ -2,6 +2,7 @@ import { __decorate, __param } from '../../../../../../../external/tslib/tslib.e
 import { Barrier } from 'vscode/vscode/vs/base/common/async';
 import { toErrorMessage } from 'vscode/vscode/vs/base/common/errorMessage';
 import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { MarkdownString } from 'vscode/vscode/vs/base/common/htmlContent';
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { Schemas } from 'vscode/vscode/vs/base/common/network';
 import { mark } from 'vscode/vscode/vs/base/common/performance';
@@ -14,16 +15,19 @@ import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
 import { ImplicitActivationEvents } from 'vscode/vscode/vs/platform/extensionManagement/common/implicitActivationEvents';
 import { ExtensionIdentifierMap, ExtensionIdentifier } from 'vscode/vscode/vs/platform/extensions/common/extensions';
 import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
+import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { handleVetos } from '../../../../platform/lifecycle/common/lifecycle.js';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
 import { INotificationService, Severity } from 'vscode/vscode/vs/platform/notification/common/notification';
 import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
 import { IRemoteAuthorityResolverService, RemoteAuthorityResolverError, getRemoteAuthorityPrefix, RemoteAuthorityResolverErrorCode } from 'vscode/vscode/vs/platform/remote/common/remoteAuthorityResolver';
 import { IRemoteExtensionsScannerService } from 'vscode/vscode/vs/platform/remote/common/remoteExtensionsScanner';
 import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
 import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace';
 import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
+import { Extensions } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionFeatures';
 import { IWorkbenchExtensionEnablementService, IWorkbenchExtensionManagementService } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement';
 import { LockableExtensionDescriptionRegistry } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionDescriptionRegistry';
 import { parseExtensionDevOptions } from './extensionDevOptions.js';
@@ -233,6 +237,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
                 ))
             });
         }
+        this._extensionsProposedApi.updateEnabledApiProposals(toAdd);
         this._doHandleExtensionPoints([].concat(toAdd).concat(toRemove));
         await this._updateExtensionsOnExtHosts(result.versionId, toAdd, ( toRemove.map(e => e.identifier)));
         for (let i = 0; i < toAdd.length; i++) {
@@ -996,6 +1001,7 @@ class DeltaExtensionsQueueItem {
     }
 }
 function checkEnabledAndProposedAPI(logService, extensionEnablementService, extensionsProposedApi, extensions, ignoreWorkspaceTrust) {
+    extensionsProposedApi.updateEnabledApiProposals(extensions);
     return filterEnabledExtensions(logService, extensionEnablementService, extensions, ignoreWorkspaceTrust);
 }
 function filterEnabledExtensions(logService, extensionEnablementService, extensions, ignoreWorkspaceTrust) {
@@ -1094,5 +1100,39 @@ class ImplicitActivationAwareReader {
         return ImplicitActivationEvents.readActivationEvents(extensionDescription);
     }
 }
+class ActivationFeatureMarkdowneRenderer extends Disposable {
+    constructor() {
+        super(...arguments);
+        this.type = 'markdown';
+    }
+    shouldRender(manifest) {
+        return !!manifest.activationEvents;
+    }
+    render(manifest) {
+        const activationEvents = manifest.activationEvents || [];
+        const data = ( new MarkdownString());
+        if (activationEvents.length) {
+            for (const activationEvent of activationEvents) {
+                data.appendMarkdown(`- \`${activationEvent}\`\n`);
+            }
+        }
+        return {
+            data,
+            dispose: () => { }
+        };
+    }
+}
+( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
+    id: 'activationEvents',
+    label: ( localizeWithPath(
+        'vs/workbench/services/extensions/common/abstractExtensionService',
+        'activation',
+        "Activation Events"
+    )),
+    access: {
+        canToggle: false
+    },
+    renderer: ( new SyncDescriptor(ActivationFeatureMarkdowneRenderer)),
+});
 
 export { AbstractExtensionService, DeltaExtensionsQueueItem, ExtensionHostCrashTracker, ExtensionStatus, ImplicitActivationAwareReader, ResolvedExtensions, checkEnabledAndProposedAPI, filterEnabledExtensions };

package/vscode/src/vs/workbench/services/extensions/common/extensionHostManager.js

@@ -5,7 +5,7 @@ import { onUnexpectedError } from 'vscode/vscode/vs/base/common/errors';
 import { Emitter } from 'vscode/vscode/vs/base/common/event';
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { StopWatch } from 'vscode/vscode/vs/base/common/stopwatch';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { localize2WithPath } from 'vscode/vscode/vs/nls';
 import { Categories } from 'vscode/vscode/vs/platform/action/common/actionCommonCategories';
 import { registerAction2, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
@@ -171,19 +171,21 @@ let ExtensionHostManager = ExtensionHostManager_1 = class ExtensionHostManager e
         this._rpcProtocol = ( new RPCProtocol(protocol, logger));
         this._register(this._rpcProtocol.onDidChangeResponsiveState((responsiveState) => this._onDidChangeResponsiveState.fire(responsiveState)));
         let extensionHostProxy = null;
+        let mainProxyIdentifiers = [];
         const extHostContext = {
             remoteAuthority: this._extensionHost.remoteAuthority,
             extensionHostKind: this.kind,
             getProxy: (identifier) => ( this._rpcProtocol.getProxy(identifier)),
             set: (identifier, instance) => this._rpcProtocol.set(identifier, instance),
             dispose: () => this._rpcProtocol.dispose(),
-            assertRegistered: (identifiers) => ( this._rpcProtocol.assertRegistered(identifiers)),
+            assertRegistered: (identifiers) => this._rpcProtocol.assertRegistered(identifiers),
             drain: () => this._rpcProtocol.drain(),
             internalExtensionService: this._internalExtensionService,
             _setExtensionHostProxy: (value) => {
                 extensionHostProxy = value;
             },
             _setAllMainProxyIdentifiers: (value) => {
+                mainProxyIdentifiers = value;
             },
         };
         const namedCustomers = ExtHostCustomersRegistry.getNamedCustomers();
@@ -214,6 +216,7 @@ let ExtensionHostManager = ExtensionHostManager_1 = class ExtensionHostManager e
         if (!extensionHostProxy) {
             throw new Error(`Missing IExtensionHostProxy!`);
         }
+        this._rpcProtocol.assertRegistered(mainProxyIdentifiers);
         return extensionHostProxy;
     }
     async activate(extension, reason) {
@@ -475,14 +478,11 @@ registerAction2(class MeasureExtHostLatencyAction extends Action2 {
     constructor() {
         super({
             id: 'editor.action.measureExtHostLatency',
-            title: {
-                value: ( localizeWithPath(
-                    'vs/workbench/services/extensions/common/extensionHostManager',
-                    'measureExtHostLatency',
-                    "Measure Extension Host Latency"
-                )),
-                original: 'Measure Extension Host Latency'
-            },
+            title: ( localize2WithPath(
+                'vs/workbench/services/extensions/common/extensionHostManager',
+                'measureExtHostLatency',
+                "Measure Extension Host Latency"
+            )),
             category: Categories.Developer,
             f1: true
         });