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

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) {
@@ -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

@@ -129,7 +129,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) {