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

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

@@ -19,6 +19,7 @@ import { extensionHostKindToString } from 'vscode/vscode/vs/workbench/services/e
 import { RPCProtocol } from 'vscode/vscode/vs/workbench/services/extensions/common/rpcProtocol';
 
 var ExtensionHostManager_1;
+const _moduleId = "vs/workbench/services/extensions/common/extensionHostManager";
 let ExtensionHostManager = ExtensionHostManager_1 = class ExtensionHostManager extends Disposable {
     get pid() {
         return this._extensionHost.pid;
@@ -39,11 +40,11 @@ let ExtensionHostManager = ExtensionHostManager_1 = class ExtensionHostManager e
         this._environmentService = _environmentService;
         this._telemetryService = _telemetryService;
         this._logService = _logService;
-        this._onDidChangeResponsiveState = this._register(( new Emitter()));
+        this._onDidChangeResponsiveState = this._register(( (new Emitter())));
         this.onDidChangeResponsiveState = this._onDidChangeResponsiveState.event;
         this._hasStarted = false;
-        this._cachedActivationEvents = ( new Map());
-        this._resolvedActivationEvents = ( new Set());
+        this._cachedActivationEvents = ( (new Map()));
+        this._resolvedActivationEvents = ( (new Set()));
         this._rpcProtocol = null;
         this._customers = [];
         this._extensionHost = extensionHost;
@@ -163,19 +164,19 @@ let ExtensionHostManager = ExtensionHostManager_1 = class ExtensionHostManager e
     _createExtensionHostCustomers(kind, protocol) {
         let logger = null;
         if (this._environmentService.logExtensionHostCommunication) {
-            logger = ( new RPCLogger(kind));
+            logger = ( (new RPCLogger(kind)));
         }
         else if (TelemetryRPCLogger.isEnabled()) {
-            logger = ( new TelemetryRPCLogger(this._telemetryService));
+            logger = ( (new TelemetryRPCLogger(this._telemetryService)));
         }
-        this._rpcProtocol = ( new RPCProtocol(protocol, logger));
+        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)),
+            getProxy: (identifier) => ( (this._rpcProtocol.getProxy(identifier))),
             set: (identifier, instance) => this._rpcProtocol.set(identifier, instance),
             dispose: () => this._rpcProtocol.dispose(),
             assertRegistered: (identifiers) => this._rpcProtocol.assertRegistered(identifiers),
@@ -214,7 +215,7 @@ let ExtensionHostManager = ExtensionHostManager_1 = class ExtensionHostManager e
             }
         }
         if (!extensionHostProxy) {
-            throw new Error(`Missing IExtensionHostProxy!`);
+            throw ( (new Error(`Missing IExtensionHostProxy!`)));
         }
         this._rpcProtocol.assertRegistered(mainProxyIdentifiers);
         return extensionHostProxy;
@@ -230,13 +231,15 @@ let ExtensionHostManager = ExtensionHostManager_1 = class ExtensionHostManager e
         if (activationKind === 1  && !this._hasStarted) {
             return Promise.resolve();
         }
-        if (!( this._cachedActivationEvents.has(activationEvent))) {
+        if (!( (this._cachedActivationEvents.has(activationEvent)))) {
             this._cachedActivationEvents.set(activationEvent, this._activateByEvent(activationEvent, activationKind));
         }
         return this._cachedActivationEvents.get(activationEvent);
     }
     activationEventIsDone(activationEvent) {
-        return ( this._resolvedActivationEvents.has(activationEvent));
+        return (
+             (this._resolvedActivationEvents.has(activationEvent))
+        );
     }
     async _activateByEvent(activationEvent, activationKind) {
         if (!this._proxy) {
@@ -263,7 +266,7 @@ let ExtensionHostManager = ExtensionHostManager_1 = class ExtensionHostManager e
                 return port;
             }
         }
-        return 0;
+        return undefined;
     }
     async resolveAuthority(remoteAuthority, resolveAttempt) {
         const sw = StopWatch.create(false);
@@ -284,7 +287,7 @@ let ExtensionHostManager = ExtensionHostManager_1 = class ExtensionHostManager e
             };
         }
         logInfo(`invoking...`);
-        const intervalLogger = ( new IntervalTimer());
+        const intervalLogger = ( (new IntervalTimer()));
         try {
             intervalLogger.cancelAndSet(() => logInfo('waiting...'), 1000);
             const resolverResult = await proxy.resolveAuthority(remoteAuthority, resolveAttempt);
@@ -313,7 +316,7 @@ let ExtensionHostManager = ExtensionHostManager_1 = class ExtensionHostManager e
     async getCanonicalURI(remoteAuthority, uri) {
         const proxy = await this._proxy;
         if (!proxy) {
-            throw new Error(`Cannot resolve canonical URI`);
+            throw ( (new Error(`Cannot resolve canonical URI`)));
         }
         return proxy.getCanonicalURI(remoteAuthority, uri);
     }
@@ -328,7 +331,7 @@ let ExtensionHostManager = ExtensionHostManager_1 = class ExtensionHostManager e
     async extensionTestsExecute() {
         const proxy = await this._proxy;
         if (!proxy) {
-            throw new Error('Could not obtain Extension Host Proxy');
+            throw ( (new Error('Could not obtain Extension Host Proxy')));
         }
         return proxy.extensionTestsExecute();
     }
@@ -357,12 +360,12 @@ let ExtensionHostManager = ExtensionHostManager_1 = class ExtensionHostManager e
         return proxy.setRemoteEnvironment(env);
     }
 };
-ExtensionHostManager = ExtensionHostManager_1 = ( __decorate([
-    ( __param(3, IInstantiationService)),
-    ( __param(4, IWorkbenchEnvironmentService)),
-    ( __param(5, ITelemetryService)),
-    ( __param(6, ILogService))
-], ExtensionHostManager));
+ExtensionHostManager = ExtensionHostManager_1 = ( (__decorate([
+    ( (__param(3, IInstantiationService))),
+    ( (__param(4, IWorkbenchEnvironmentService))),
+    ( (__param(5, ITelemetryService))),
+    ( (__param(6, ILogService)))
+], ExtensionHostManager)));
 function friendlyExtHostName(kind, pid) {
     if (pid) {
         return `${extensionHostKindToString(kind)} pid: ${pid}`;
@@ -378,7 +381,7 @@ function prettyWithoutArrays(data) {
         return data;
     }
     if (data && typeof data === 'object' && typeof data.toString === 'function') {
-        const result = ( data.toString());
+        const result = ( (data.toString()));
         if (result !== '[object Object]') {
             return result;
         }
@@ -387,7 +390,9 @@ function prettyWithoutArrays(data) {
 }
 function pretty(data) {
     if (Array.isArray(data)) {
-        return ( data.map(prettyWithoutArrays));
+        return (
+             (data.map(prettyWithoutArrays))
+        );
     }
     return prettyWithoutArrays(data);
 }
@@ -426,7 +431,7 @@ let TelemetryRPCLogger = class TelemetryRPCLogger {
     }
     constructor(_telemetryService) {
         this._telemetryService = _telemetryService;
-        this._pendingRequests = ( new Map());
+        this._pendingRequests = ( (new Map()));
     }
     logIncoming(msgLength, req, initiator, str) {
         if (initiator === 0  && /^receiveReply(Err)?:/.test(str)) {
@@ -454,9 +459,9 @@ let TelemetryRPCLogger = class TelemetryRPCLogger {
         }
     }
 };
-TelemetryRPCLogger = ( __decorate([
-    ( __param(0, ITelemetryService))
-], TelemetryRPCLogger));
+TelemetryRPCLogger = ( (__decorate([
+    ( (__param(0, ITelemetryService)))
+], TelemetryRPCLogger)));
 const providers = [];
 function registerLatencyTestProvider(provider) {
     providers.push(provider);
@@ -478,19 +483,15 @@ registerAction2(class MeasureExtHostLatencyAction extends Action2 {
     constructor() {
         super({
             id: 'editor.action.measureExtHostLatency',
-            title: ( localize2WithPath(
-                'vs/workbench/services/extensions/common/extensionHostManager',
-                'measureExtHostLatency',
-                "Measure Extension Host Latency"
-            )),
+            title: ( localize2WithPath(_moduleId, 0, "Measure Extension Host Latency")),
             category: Categories.Developer,
             f1: true
         });
     }
     async run(accessor) {
         const editorService = accessor.get(IEditorService);
-        const measurements = await Promise.all(( getLatencyTestProviders().map(provider => provider.measure())));
-        editorService.openEditor({ resource: undefined, contents: ( measurements.map(MeasureExtHostLatencyAction._print)).join('\n\n'), options: { pinned: true } });
+        const measurements = await Promise.all(( (getLatencyTestProviders().map(provider => provider.measure()))));
+        editorService.openEditor({ resource: undefined, contents: ( (measurements.map(MeasureExtHostLatencyAction._print))).join('\n\n'), options: { pinned: true } });
     }
     static _print(m) {
         if (!m) {

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

@@ -2,14 +2,15 @@ import { ExtensionIdentifierMap } from 'vscode/vscode/vs/platform/extensions/com
 import { localizeWithPath } from 'vscode/vscode/vs/nls';
 import { semverExports } from 'vscode/external/vscode-semver/semver.js';
 
+const _moduleId = "vs/workbench/services/extensions/common/extensionsUtil";
 function dedupExtensions(system, user, development, logService) {
-    const result = ( new ExtensionIdentifierMap());
+    const result = ( (new ExtensionIdentifierMap()));
     system.forEach((systemExtension) => {
         const extension = result.get(systemExtension.identifier);
         if (extension) {
             logService.warn(( localizeWithPath(
-                'vs/workbench/services/extensions/common/extensionsUtil',
-                'overwritingExtension',
+                _moduleId,
+                0,
                 "Overwriting extension {0} with {1}.",
                 extension.extensionLocation.fsPath,
                 systemExtension.extensionLocation.fsPath
@@ -29,8 +30,8 @@ function dedupExtensions(system, user, development, logService) {
             }
             else {
                 logService.warn(( localizeWithPath(
-                    'vs/workbench/services/extensions/common/extensionsUtil',
-                    'overwritingExtension',
+                    _moduleId,
+                    0,
                     "Overwriting extension {0} with {1}.",
                     extension.extensionLocation.fsPath,
                     userExtension.extensionLocation.fsPath
@@ -45,8 +46,8 @@ function dedupExtensions(system, user, development, logService) {
     });
     development.forEach(developedExtension => {
         logService.info(( localizeWithPath(
-            'vs/workbench/services/extensions/common/extensionsUtil',
-            'extensionUnderDevelopment',
+            _moduleId,
+            1,
             "Loading development extension at {0}",
             developedExtension.extensionLocation.fsPath
         )));
@@ -58,7 +59,7 @@ function dedupExtensions(system, user, development, logService) {
         }
         result.set(developedExtension.identifier, developedExtension);
     });
-    return Array.from(( result.values()));
+    return Array.from(( (result.values())));
 }
 
 export { dedupExtensions };

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

@@ -105,10 +105,7 @@ let LazyCreateExtensionHostManager = class LazyCreateExtensionHostManager extend
     }
     async getInspectPort(tryEnableInspector) {
         await this._startCalled.wait();
-        if (this._actual) {
-            return this._actual.getInspectPort(tryEnableInspector);
-        }
-        return 0;
+        return this._actual?.getInspectPort(tryEnableInspector);
     }
     async resolveAuthority(remoteAuthority, resolveAttempt) {
         await this._startCalled.wait();
@@ -129,7 +126,7 @@ let LazyCreateExtensionHostManager = class LazyCreateExtensionHostManager extend
         if (this._actual) {
             return this._actual.getCanonicalURI(remoteAuthority, uri);
         }
-        throw new Error(`Cannot resolve canonical URI`);
+        throw ( new Error(`Cannot resolve canonical URI`));
     }
     async start(extensionRegistryVersionId, allExtensions, myExtensions) {
         if (myExtensions.length > 0) {

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

@@ -1,70 +0,0 @@
-import { __decorate, __param } from 'vscode/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 { ExtHostContext, MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
-import { IChatWidgetService } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chat.service';
-import { IChatContributionService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatContributionService.service';
-import { IChatService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatService.service';
-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/mainThreadIssueReporter.js

@@ -1,50 +0,0 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
-import { Disposable, DisposableMap } from 'vscode/vscode/vs/base/common/lifecycle';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { ExtHostContext, MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { IWorkbenchIssueService } from 'vscode/vscode/vs/workbench/services/issue/common/issue.service';
-
-let MainThreadIssueReporter = class MainThreadIssueReporter extends Disposable {
-    constructor(context, _issueService) {
-        super();
-        this._issueService = _issueService;
-        this._registrationsUri = this._register(( new DisposableMap()));
-        this._registrationsData = this._register(( new DisposableMap()));
-        this._proxy = ( context.getProxy(ExtHostContext.ExtHostIssueReporter));
-    }
-    $registerIssueUriRequestHandler(extensionId) {
-        const handler = {
-            provideIssueUrl: async (token) => {
-                const parts = await this._proxy.$getIssueReporterUri(extensionId, token);
-                return ( URI.from(parts));
-            }
-        };
-        this._registrationsUri.set(extensionId, this._issueService.registerIssueUriRequestHandler(extensionId, handler));
-    }
-    $unregisterIssueUriRequestHandler(extensionId) {
-        this._registrationsUri.deleteAndDispose(extensionId);
-    }
-    $registerIssueDataProvider(extensionId) {
-        const provider = {
-            provideIssueExtensionData: async (token) => {
-                const parts = await this._proxy.$getIssueReporterData(extensionId, token);
-                return parts;
-            },
-            provideIssueExtensionTemplate: async (token) => {
-                const parts = await this._proxy.$getIssueReporterTemplate(extensionId, token);
-                return parts;
-            }
-        };
-        this._registrationsData.set(extensionId, this._issueService.registerIssueDataProvider(extensionId, provider));
-    }
-    $unregisterIssueDataProvider(extensionId) {
-        this._registrationsData.deleteAndDispose(extensionId);
-    }
-};
-MainThreadIssueReporter = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadIssueReporter),
-    ( __param(1, IWorkbenchIssueService))
-], MainThreadIssueReporter);
-
-export { MainThreadIssueReporter };