@codingame/monaco-vscode-api 1.83.1 → 1.83.3-next.0

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

@@ -39,11 +39,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,21 +163,21 @@ 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;
         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))),
+            assertRegistered: (identifiers) => ( this._rpcProtocol.assertRegistered(identifiers)),
             drain: () => this._rpcProtocol.drain(),
             internalExtensionService: this._internalExtensionService,
             _setExtensionHostProxy: (value) => {
@@ -227,15 +227,13 @@ 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) {
@@ -279,7 +277,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);
@@ -352,12 +350,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));
 let LazyCreateExtensionHostManager = class LazyCreateExtensionHostManager extends Disposable {
     get kind() {
         return this._extensionHost.runningLocation.kind;
@@ -370,11 +368,11 @@ let LazyCreateExtensionHostManager = class LazyCreateExtensionHostManager extend
         this._internalExtensionService = _internalExtensionService;
         this._instantiationService = _instantiationService;
         this._logService = _logService;
-        this._onDidChangeResponsiveState = this._register(( (new Emitter())));
+        this._onDidChangeResponsiveState = this._register(( new Emitter()));
         this.onDidChangeResponsiveState = this._onDidChangeResponsiveState.event;
         this._extensionHost = extensionHost;
         this.onDidExit = extensionHost.onExit;
-        this._startCalled = ( (new Barrier()));
+        this._startCalled = ( new Barrier());
         this._actual = null;
         this._lazyStartExtensions = null;
     }
@@ -408,7 +406,7 @@ let LazyCreateExtensionHostManager = class LazyCreateExtensionHostManager extend
         }
         this._lazyStartExtensions.delta(extensionsDelta);
         if (extensionsDelta.myToAdd.length > 0) {
-            const actual = this._createActual(`contains ${extensionsDelta.myToAdd.length} new extension(s) (installed or enabled): ${( ( extensionsDelta.myToAdd.map(extId => extId.value)))}`);
+            const actual = this._createActual(`contains ${extensionsDelta.myToAdd.length} new extension(s) (installed or enabled): ${( extensionsDelta.myToAdd.map(extId => extId.value))}`);
             await actual.start(this._lazyStartExtensions.versionId, this._lazyStartExtensions.allExtensions, this._lazyStartExtensions.myExtensions);
             return;
         }
@@ -474,12 +472,12 @@ let LazyCreateExtensionHostManager = class LazyCreateExtensionHostManager extend
     }
     async start(extensionRegistryVersionId, allExtensions, myExtensions) {
         if (myExtensions.length > 0) {
-            const actual = this._createActual(`contains ${myExtensions.length} extension(s): ${( ( myExtensions.map(extId => extId.value)))}.`);
+            const actual = this._createActual(`contains ${myExtensions.length} extension(s): ${( myExtensions.map(extId => extId.value))}.`);
             const result = actual.start(extensionRegistryVersionId, allExtensions, myExtensions);
             this._startCalled.open();
             return result;
         }
-        this._lazyStartExtensions = ( (new ExtensionHostExtensions(extensionRegistryVersionId, allExtensions, myExtensions)));
+        this._lazyStartExtensions = ( new ExtensionHostExtensions(extensionRegistryVersionId, allExtensions, myExtensions));
         this._startCalled.open();
     }
     async extensionTestsExecute() {
@@ -494,10 +492,10 @@ let LazyCreateExtensionHostManager = class LazyCreateExtensionHostManager extend
         }
     }
 };
-LazyCreateExtensionHostManager = ( (__decorate([
-    ( (__param(2, IInstantiationService))),
-    ( (__param(3, ILogService)))
-], LazyCreateExtensionHostManager)));
+LazyCreateExtensionHostManager = ( __decorate([
+    ( __param(2, IInstantiationService)),
+    ( __param(3, ILogService))
+], LazyCreateExtensionHostManager));
 const colorTables = [
     ['#2977B1', '#FC802D', '#34A13A', '#D3282F', '#9366BA'],
     ['#8B564C', '#E177C0', '#7F7F7F', '#BBBE3D', '#2EBECD']
@@ -507,7 +505,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;
         }
@@ -516,9 +514,7 @@ function prettyWithoutArrays(data) {
 }
 function pretty(data) {
     if (Array.isArray(data)) {
-        return (
-             (data.map(prettyWithoutArrays))
-        );
+        return ( data.map(prettyWithoutArrays));
     }
     return prettyWithoutArrays(data);
 }
@@ -557,7 +553,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)) {
@@ -585,9 +581,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);
@@ -610,7 +606,7 @@ registerAction2(class MeasureExtHostLatencyAction extends Action2 {
         super({
             id: 'editor.action.measureExtHostLatency',
             title: {
-                value: ( (nls.localize('measureExtHostLatency', "Measure Extension Host Latency"))),
+                value: nls.localizeWithPath('vs/workbench/services/extensions/common/extensionHostManager', 'measureExtHostLatency', "Measure Extension Host Latency"),
                 original: 'Measure Extension Host Latency'
             },
             category: Categories.Developer,
@@ -619,8 +615,8 @@ registerAction2(class MeasureExtHostLatencyAction extends Action2 {
     }
     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/extensionRunningLocationTracker.js

@@ -21,7 +21,7 @@ let ExtensionRunningLocationTracker = class ExtensionRunningLocationTracker {
         this._configurationService = _configurationService;
         this._logService = _logService;
         this._extensionManifestPropertiesService = _extensionManifestPropertiesService;
-        this._runningLocation = ( (new ExtensionIdentifierMap()));
+        this._runningLocation = ( new ExtensionIdentifierMap());
         this._maxLocalProcessAffinity = 0;
         this._maxLocalWebWorkerAffinity = 0;
     }
@@ -47,7 +47,7 @@ let ExtensionRunningLocationTracker = class ExtensionRunningLocationTracker {
         return filterExtensionDescriptions(extensions, this._runningLocation, extRunningLocation => extensionHostManager.representsRunningLocation(extRunningLocation));
     }
     _computeAffinity(inputExtensions, extensionHostKind, isInitialAllocation) {
-        const extensions = ( (new ExtensionIdentifierMap()));
+        const extensions = ( new ExtensionIdentifierMap());
         for (const extension of inputExtensions) {
             if (extension.main || extension.browser) {
                 extensions.set(extension.identifier, extension);
@@ -61,7 +61,7 @@ let ExtensionRunningLocationTracker = class ExtensionRunningLocationTracker {
                 }
             }
         }
-        const groups = ( (new ExtensionIdentifierMap()));
+        const groups = ( new ExtensionIdentifierMap());
         let groupNumber = 0;
         for (const [_, extension] of extensions) {
             groups.set(extension.identifier, ++groupNumber);
@@ -89,7 +89,7 @@ let ExtensionRunningLocationTracker = class ExtensionRunningLocationTracker {
                 changeGroup(depGroup, myGroup);
             }
         }
-        const resultingAffinities = ( (new Map()));
+        const resultingAffinities = ( new Map());
         let lastAffinity = 0;
         for (const [_, extension] of extensions) {
             const runningLocation = this._runningLocation.get(extension.identifier);
@@ -101,8 +101,8 @@ let ExtensionRunningLocationTracker = class ExtensionRunningLocationTracker {
         }
         if (!this._environmentService.isExtensionDevelopment) {
             const configuredAffinities = this._configurationService.getValue('extensions.experimental.affinity') || {};
-            const configuredExtensionIds = ( (Object.keys(configuredAffinities)));
-            const configuredAffinityToResultingAffinity = ( (new Map()));
+            const configuredExtensionIds = ( Object.keys(configuredAffinities));
+            const configuredAffinityToResultingAffinity = ( new Map());
             for (const extensionId of configuredExtensionIds) {
                 const configuredAffinity = configuredAffinities[extensionId];
                 if (typeof configuredAffinity !== 'number' || configuredAffinity <= 0 || Math.floor(configuredAffinity) !== configuredAffinity) {
@@ -132,7 +132,7 @@ let ExtensionRunningLocationTracker = class ExtensionRunningLocationTracker {
                 resultingAffinities.set(group, affinity3);
             }
         }
-        const result = ( (new ExtensionIdentifierMap()));
+        const result = ( new ExtensionIdentifierMap());
         for (const extension of inputExtensions) {
             const group = groups.get(extension.identifier) || 0;
             const affinity = resultingAffinities.get(group) || 0;
@@ -146,7 +146,7 @@ let ExtensionRunningLocationTracker = class ExtensionRunningLocationTracker {
                         extensionIds.push(extension.identifier);
                     }
                 }
-                this._logService.info(`Placing extension(s) ${( ( extensionIds.map(e => e.value))).join(', ')} on a separate extension host.`);
+                this._logService.info(`Placing extension(s) ${( extensionIds.map(e => e.value)).join(', ')} on a separate extension host.`);
             }
         }
         return { affinities: result, maxAffinity: lastAffinity };
@@ -155,17 +155,17 @@ let ExtensionRunningLocationTracker = class ExtensionRunningLocationTracker {
         return this._doComputeRunningLocation(this._runningLocation, localExtensions, remoteExtensions, isInitialAllocation).runningLocation;
     }
     _doComputeRunningLocation(existingRunningLocation, localExtensions, remoteExtensions, isInitialAllocation) {
-        localExtensions = localExtensions.filter(extension => !( (existingRunningLocation.has(extension.identifier))));
-        remoteExtensions = remoteExtensions.filter(extension => !( (existingRunningLocation.has(extension.identifier))));
+        localExtensions = localExtensions.filter(extension => !( existingRunningLocation.has(extension.identifier)));
+        remoteExtensions = remoteExtensions.filter(extension => !( existingRunningLocation.has(extension.identifier)));
         const extensionHostKinds = determineExtensionHostKinds(localExtensions, remoteExtensions, (extension) => this.readExtensionKinds(extension), (extensionId, extensionKinds, isInstalledLocally, isInstalledRemotely, preference) => this._extensionHostKindPicker.pickExtensionHostKind(extensionId, extensionKinds, isInstalledLocally, isInstalledRemotely, preference));
-        const extensions = ( (new ExtensionIdentifierMap()));
+        const extensions = ( new ExtensionIdentifierMap());
         for (const extension of localExtensions) {
             extensions.set(extension.identifier, extension);
         }
         for (const extension of remoteExtensions) {
             extensions.set(extension.identifier, extension);
         }
-        const result = ( (new ExtensionIdentifierMap()));
+        const result = ( new ExtensionIdentifierMap());
         const localProcessExtensions = [];
         const localWebWorkerExtensions = [];
         for (const [extensionIdKey, extensionHostKind] of extensionHostKinds) {
@@ -183,19 +183,19 @@ let ExtensionRunningLocationTracker = class ExtensionRunningLocationTracker {
                 }
             }
             else if (extensionHostKind === 3 ) {
-                runningLocation = ( (new RemoteRunningLocation()));
+                runningLocation = ( new RemoteRunningLocation());
             }
             result.set(extensionIdKey, runningLocation);
         }
         const { affinities, maxAffinity } = this._computeAffinity(localProcessExtensions, 1 , isInitialAllocation);
         for (const extension of localProcessExtensions) {
             const affinity = affinities.get(extension.identifier) || 0;
-            result.set(extension.identifier, ( (new LocalProcessRunningLocation(affinity))));
+            result.set(extension.identifier, ( new LocalProcessRunningLocation(affinity)));
         }
         const { affinities: localWebWorkerAffinities, maxAffinity: maxLocalWebWorkerAffinity } = this._computeAffinity(localWebWorkerExtensions, 2 , isInitialAllocation);
         for (const extension of localWebWorkerExtensions) {
             const affinity = localWebWorkerAffinities.get(extension.identifier) || 0;
-            result.set(extension.identifier, ( (new LocalWebWorkerRunningLocation(affinity))));
+            result.set(extension.identifier, ( new LocalWebWorkerRunningLocation(affinity)));
         }
         for (const [extensionIdKey, runningLocation] of existingRunningLocation) {
             if (runningLocation) {
@@ -211,7 +211,7 @@ let ExtensionRunningLocationTracker = class ExtensionRunningLocationTracker {
         this._maxLocalWebWorkerAffinity = maxLocalWebWorkerAffinity;
     }
     deltaExtensions(toAdd, toRemove) {
-        const removedRunningLocation = ( (new ExtensionIdentifierMap()));
+        const removedRunningLocation = ( new ExtensionIdentifierMap());
         for (const extensionId of toRemove) {
             const extensionKey = extensionId;
             removedRunningLocation.set(extensionKey, this._runningLocation.get(extensionKey) || null);
@@ -235,28 +235,28 @@ let ExtensionRunningLocationTracker = class ExtensionRunningLocationTracker {
                 localWebWorkerExtensions.push(extension);
             }
             else if (extensionHostKind === 3 ) {
-                runningLocation = ( (new RemoteRunningLocation()));
+                runningLocation = ( new RemoteRunningLocation());
             }
             this._runningLocation.set(extension.identifier, runningLocation);
         }
         const { affinities } = this._computeAffinity(localProcessExtensions, 1 , false);
         for (const extension of localProcessExtensions) {
             const affinity = affinities.get(extension.identifier) || 0;
-            this._runningLocation.set(extension.identifier, ( (new LocalProcessRunningLocation(affinity))));
+            this._runningLocation.set(extension.identifier, ( new LocalProcessRunningLocation(affinity)));
         }
         const { affinities: webWorkerExtensionsAffinities } = this._computeAffinity(localWebWorkerExtensions, 2 , false);
         for (const extension of localWebWorkerExtensions) {
             const affinity = webWorkerExtensionsAffinities.get(extension.identifier) || 0;
-            this._runningLocation.set(extension.identifier, ( (new LocalWebWorkerRunningLocation(affinity))));
+            this._runningLocation.set(extension.identifier, ( new LocalWebWorkerRunningLocation(affinity)));
         }
     }
 };
-ExtensionRunningLocationTracker = ( (__decorate([
-    ( (__param(2, IWorkbenchEnvironmentService))),
-    ( (__param(3, IConfigurationService))),
-    ( (__param(4, ILogService))),
-    ( (__param(5, IExtensionManifestPropertiesService)))
-], ExtensionRunningLocationTracker)));
+ExtensionRunningLocationTracker = ( __decorate([
+    ( __param(2, IWorkbenchEnvironmentService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, ILogService)),
+    ( __param(5, IExtensionManifestPropertiesService))
+], ExtensionRunningLocationTracker));
 function filterExtensionDescriptions(extensions, runningLocation, predicate) {
     return extensions.filter((ext) => {
         const extRunningLocation = runningLocation.get(ext.identifier);