@codingame/monaco-vscode-extensions-service-override 25.1.1 → 26.0.0

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

@@ -8,6 +8,7 @@ import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscod
 import { determineExtensionHostKinds, ExtensionHostKind, ExtensionRunningPreference } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensionHostKind';
 import { IExtensionManifestPropertiesService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensionManifestPropertiesService.service';
 import { RemoteRunningLocation, LocalProcessRunningLocation, LocalWebWorkerRunningLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensionRunningLocation';
+import { isProposedApiEnabled } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions';
 
 let ExtensionRunningLocationTracker = class ExtensionRunningLocationTracker {
     get maxLocalProcessAffinity() {
@@ -16,7 +17,14 @@ let ExtensionRunningLocationTracker = class ExtensionRunningLocationTracker {
     get maxLocalWebWorkerAffinity() {
         return this._maxLocalWebWorkerAffinity;
     }
-    constructor(_registry, _extensionHostKindPicker, _environmentService, _configurationService, _logService, _extensionManifestPropertiesService) {
+    constructor(
+        _registry,
+        _extensionHostKindPicker,
+        _environmentService,
+        _configurationService,
+        _logService,
+        _extensionManifestPropertiesService
+    ) {
         this._registry = _registry;
         this._extensionHostKindPicker = _extensionHostKindPicker;
         this._environmentService = _environmentService;
@@ -40,13 +48,25 @@ let ExtensionRunningLocationTracker = class ExtensionRunningLocationTracker {
         return this._runningLocation.get(extensionId) || null;
     }
     filterByRunningLocation(extensions, desiredRunningLocation) {
-        return filterExtensionDescriptions(extensions, this._runningLocation, extRunningLocation => desiredRunningLocation.equals(extRunningLocation));
+        return filterExtensionDescriptions(
+            extensions,
+            this._runningLocation,
+            extRunningLocation => desiredRunningLocation.equals(extRunningLocation)
+        );
     }
     filterByExtensionHostKind(extensions, desiredExtensionHostKind) {
-        return filterExtensionDescriptions(extensions, this._runningLocation, extRunningLocation => extRunningLocation.kind === desiredExtensionHostKind);
+        return filterExtensionDescriptions(
+            extensions,
+            this._runningLocation,
+            extRunningLocation => extRunningLocation.kind === desiredExtensionHostKind
+        );
     }
     filterByExtensionHostManager(extensions, extensionHostManager) {
-        return filterExtensionDescriptions(extensions, this._runningLocation, extRunningLocation => extensionHostManager.representsRunningLocation(extRunningLocation));
+        return filterExtensionDescriptions(
+            extensions,
+            this._runningLocation,
+            extRunningLocation => extensionHostManager.representsRunningLocation(extRunningLocation)
+        );
     }
     _computeAffinity(inputExtensions, extensionHostKind, isInitialAllocation) {
         const extensions = ( new ExtensionIdentifierMap());
@@ -91,6 +111,28 @@ let ExtensionRunningLocationTracker = class ExtensionRunningLocationTracker {
                 changeGroup(depGroup, myGroup);
             }
         }
+        for (const [_, extension] of extensions) {
+            if (!extension.extensionAffinity) {
+                continue;
+            }
+            if (!isProposedApiEnabled(extension, "extensionAffinity")) {
+                this._logService.warn(
+                    `Extension '${extension.identifier.value}' declares 'extensionAffinity' in its package.json but does not enable the 'extensionAffinity' API proposal. Add '"enabledApiProposals": ["extensionAffinity"]' to the extension's package.json to use this feature.`
+                );
+                continue;
+            }
+            const myGroup = groups.get(extension.identifier);
+            for (const colocateId of extension.extensionAffinity) {
+                const colocateGroup = groups.get(colocateId);
+                if (!colocateGroup) {
+                    continue;
+                }
+                if (colocateGroup === myGroup) {
+                    continue;
+                }
+                changeGroup(colocateGroup, myGroup);
+            }
+        }
         const resultingAffinities = ( new Map());
         let lastAffinity = 0;
         for (const [_, extension] of extensions) {
@@ -102,13 +144,15 @@ let ExtensionRunningLocationTracker = class ExtensionRunningLocationTracker {
             }
         }
         if (!this._environmentService.isExtensionDevelopment) {
-            const configuredAffinities = this._configurationService.getValue('extensions.experimental.affinity') || {};
+            const configuredAffinities = this._configurationService.getValue("extensions.experimental.affinity") || {};
             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) {
-                    this._logService.info(`Ignoring configured affinity for '${extensionId}' because the value is not a positive integer.`);
+                if (typeof configuredAffinity !== "number" || configuredAffinity <= 0 || Math.floor(configuredAffinity) !== configuredAffinity) {
+                    this._logService.info(
+                        `Ignoring configured affinity for '${extensionId}' because the value is not a positive integer.`
+                    );
                     continue;
                 }
                 const group = groups.get(extensionId);
@@ -126,7 +170,9 @@ let ExtensionRunningLocationTracker = class ExtensionRunningLocationTracker {
                     continue;
                 }
                 if (!isInitialAllocation) {
-                    this._logService.info(`Ignoring configured affinity for '${extensionId}' because extension host(s) are already running. Reload window.`);
+                    this._logService.info(
+                        `Ignoring configured affinity for '${extensionId}' because extension host(s) are already running. Reload window.`
+                    );
                     continue;
                 }
                 const affinity3 = ++lastAffinity;
@@ -148,18 +194,48 @@ 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 };
+        return {
+            affinities: result,
+            maxAffinity: lastAffinity
+        };
     }
     computeRunningLocation(localExtensions, remoteExtensions, isInitialAllocation) {
-        return this._doComputeRunningLocation(this._runningLocation, localExtensions, remoteExtensions, isInitialAllocation).runningLocation;
+        return this._doComputeRunningLocation(
+            this._runningLocation,
+            localExtensions,
+            remoteExtensions,
+            isInitialAllocation
+        ).runningLocation;
     }
-    _doComputeRunningLocation(existingRunningLocation, localExtensions, remoteExtensions, isInitialAllocation) {
+    _doComputeRunningLocation(
+        existingRunningLocation,
+        localExtensions,
+        remoteExtensions,
+        isInitialAllocation
+    ) {
         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 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());
         for (const extension of localExtensions) {
             extensions.set(extension.identifier, extension);
@@ -177,24 +253,36 @@ let ExtensionRunningLocationTracker = class ExtensionRunningLocationTracker {
                 if (extensionDescription) {
                     localProcessExtensions.push(extensionDescription);
                 }
-            }
-            else if (extensionHostKind === ExtensionHostKind.LocalWebWorker) {
+            } else if (extensionHostKind === ExtensionHostKind.LocalWebWorker) {
                 const extensionDescription = extensions.get(extensionIdKey);
                 if (extensionDescription) {
                     localWebWorkerExtensions.push(extensionDescription);
                 }
-            }
-            else if (extensionHostKind === ExtensionHostKind.Remote) {
+            } else if (extensionHostKind === ExtensionHostKind.Remote) {
                 runningLocation = ( new RemoteRunningLocation());
             }
             result.set(extensionIdKey, runningLocation);
         }
-        const { affinities, maxAffinity } = this._computeAffinity(localProcessExtensions, ExtensionHostKind.LocalProcess, isInitialAllocation);
+        const {
+            affinities,
+            maxAffinity
+        } = this._computeAffinity(
+            localProcessExtensions,
+            ExtensionHostKind.LocalProcess,
+            isInitialAllocation
+        );
         for (const extension of localProcessExtensions) {
             const affinity = affinities.get(extension.identifier) || 0;
             result.set(extension.identifier, ( new LocalProcessRunningLocation(affinity)));
         }
-        const { affinities: localWebWorkerAffinities, maxAffinity: maxLocalWebWorkerAffinity } = this._computeAffinity(localWebWorkerExtensions, ExtensionHostKind.LocalWebWorker, isInitialAllocation);
+        const {
+            affinities: localWebWorkerAffinities,
+            maxAffinity: maxLocalWebWorkerAffinity
+        } = this._computeAffinity(
+            localWebWorkerExtensions,
+            ExtensionHostKind.LocalWebWorker,
+            isInitialAllocation
+        );
         for (const extension of localWebWorkerExtensions) {
             const affinity = localWebWorkerAffinities.get(extension.identifier) || 0;
             result.set(extension.identifier, ( new LocalWebWorkerRunningLocation(affinity)));
@@ -204,10 +292,18 @@ let ExtensionRunningLocationTracker = class ExtensionRunningLocationTracker {
                 result.set(extensionIdKey, runningLocation);
             }
         }
-        return { runningLocation: result, maxLocalProcessAffinity: maxAffinity, maxLocalWebWorkerAffinity: maxLocalWebWorkerAffinity };
+        return {
+            runningLocation: result,
+            maxLocalProcessAffinity: maxAffinity,
+            maxLocalWebWorkerAffinity: maxLocalWebWorkerAffinity
+        };
     }
     initializeRunningLocation(localExtensions, remoteExtensions) {
-        const { runningLocation, maxLocalProcessAffinity, maxLocalWebWorkerAffinity } = this._doComputeRunningLocation(this._runningLocation, localExtensions, remoteExtensions, true);
+        const {
+            runningLocation,
+            maxLocalProcessAffinity,
+            maxLocalWebWorkerAffinity
+        } = this._doComputeRunningLocation(this._runningLocation, localExtensions, remoteExtensions, true);
         this._runningLocation = runningLocation;
         this._maxLocalProcessAffinity = maxLocalProcessAffinity;
         this._maxLocalWebWorkerAffinity = maxLocalWebWorkerAffinity;
@@ -228,45 +324,48 @@ let ExtensionRunningLocationTracker = class ExtensionRunningLocationTracker {
         for (const extension of toAdd) {
             const extensionKind = this.readExtensionKinds(extension);
             const isRemote = extension.extensionLocation.scheme === Schemas.vscodeRemote;
-            const extensionHostKind = this._extensionHostKindPicker.pickExtensionHostKind(extension.identifier, extensionKind, !isRemote, isRemote, ExtensionRunningPreference.None);
+            const extensionHostKind = this._extensionHostKindPicker.pickExtensionHostKind(
+                extension.identifier,
+                extensionKind,
+                !isRemote,
+                isRemote,
+                ExtensionRunningPreference.None
+            );
             let runningLocation = null;
             if (extensionHostKind === ExtensionHostKind.LocalProcess) {
                 localProcessExtensions.push(extension);
-            }
-            else if (extensionHostKind === ExtensionHostKind.LocalWebWorker) {
+            } else if (extensionHostKind === ExtensionHostKind.LocalWebWorker) {
                 localWebWorkerExtensions.push(extension);
-            }
-            else if (extensionHostKind === ExtensionHostKind.Remote) {
+            } else if (extensionHostKind === ExtensionHostKind.Remote) {
                 runningLocation = ( new RemoteRunningLocation());
             }
             this._runningLocation.set(extension.identifier, runningLocation);
         }
-        const { affinities } = this._computeAffinity(localProcessExtensions, ExtensionHostKind.LocalProcess, false);
+        const {
+            affinities
+        } = this._computeAffinity(localProcessExtensions, ExtensionHostKind.LocalProcess, false);
         for (const extension of localProcessExtensions) {
             const affinity = affinities.get(extension.identifier) || 0;
             this._runningLocation.set(extension.identifier, ( new LocalProcessRunningLocation(affinity)));
         }
-        const { affinities: webWorkerExtensionsAffinities } = this._computeAffinity(localWebWorkerExtensions, ExtensionHostKind.LocalWebWorker, false);
+        const {
+            affinities: webWorkerExtensionsAffinities
+        } = this._computeAffinity(localWebWorkerExtensions, ExtensionHostKind.LocalWebWorker, false);
         for (const extension of localWebWorkerExtensions) {
             const affinity = webWorkerExtensionsAffinities.get(extension.identifier) || 0;
             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) => {
+    return extensions.filter(ext => {
         const extRunningLocation = runningLocation.get(ext.identifier);
         return extRunningLocation && predicate(extRunningLocation);
     });
 }
 function filterExtensionIdentifiers(extensions, runningLocation, predicate) {
-    return extensions.filter((ext) => {
+    return extensions.filter(ext => {
         const extRunningLocation = runningLocation.get(ext);
         return extRunningLocation && predicate(extRunningLocation);
     });

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

@@ -19,16 +19,16 @@ let ExtensionsProposedApi = class ExtensionsProposedApi {
         this._environmentService = _environmentService;
         this._envEnabledExtensions = ( new Set(( (_environmentService.extensionEnabledProposedApi ?? []).map(id => ExtensionIdentifier.toKey(id)))));
         this._envEnablesProposedApiForAll =
-            !_environmentService.isBuilt ||
-                (_environmentService.isExtensionDevelopment && productService.quality !== 'stable') ||
-                (this._envEnabledExtensions.size === 0 && Array.isArray(_environmentService.extensionEnabledProposedApi));
+        !_environmentService.isBuilt || (_environmentService.isExtensionDevelopment && productService.quality !== "stable") || (this._envEnabledExtensions.size === 0 && Array.isArray(_environmentService.extensionEnabledProposedApi));
         this._productEnabledExtensions = ( new Map());
         if (productService.extensionEnabledApiProposals) {
             for (const [k, value] of Object.entries(productService.extensionEnabledApiProposals)) {
                 const key = ExtensionIdentifier.toKey(k);
                 const proposalNames = value.filter(name => {
                     if (!allApiProposals[name]) {
-                        _logService.warn(`Via 'product.json#extensionEnabledApiProposals' extension '${key}' wants API proposal '${name}' but that proposal DOES NOT EXIST. Likely, the proposal has been finalized (check 'vscode.d.ts') or was abandoned.`);
+                        _logService.warn(
+                            `Via 'product.json#extensionEnabledApiProposals' extension '${key}' wants API proposal '${name}' but that proposal DOES NOT EXIST. Likely, the proposal has been finalized (check 'vscode.d.ts') or was abandoned.`
+                        );
                         return false;
                     }
                     return true;
@@ -48,7 +48,9 @@ let ExtensionsProposedApi = class ExtensionsProposedApi {
             extension.enabledApiProposals = extension.enabledApiProposals.filter(name => {
                 const result = Boolean(allApiProposals[name]);
                 if (!result) {
-                    this._logService.error(`Extension '${key}' wants API proposal '${name}' but that proposal DOES NOT EXIST. Likely, the proposal has been finalized (check 'vscode.d.ts') or was abandoned.`);
+                    this._logService.error(
+                        `Extension '${key}' wants API proposal '${name}' but that proposal DOES NOT EXIST. Likely, the proposal has been finalized (check 'vscode.d.ts') or was abandoned.`
+                    );
                 }
                 return result;
             });
@@ -59,9 +61,13 @@ let ExtensionsProposedApi = class ExtensionsProposedApi {
             const extensionSet = ( new Set(extension.enabledApiProposals));
             const diff = ( new Set([...extensionSet].filter(a => !( productSet.has(a)))));
             if (diff.size > 0) {
-                this._logService.error(`Extension '${key}' appears in product.json but enables LESS API proposals than the extension wants.\npackage.json (LOSES): ${[...extensionSet].join(', ')}\nproduct.json (WINS): ${[...productSet].join(', ')}`);
+                this._logService.error(
+                    `Extension '${key}' appears in product.json but enables LESS API proposals than the extension wants.\npackage.json (LOSES): ${[...extensionSet].join("\n")}\nproduct.json (WINS): ${[...productSet].join("\n")}\nDELTA: ${[...diff].join("\n")}`
+                );
                 if (this._environmentService.isExtensionDevelopment) {
-                    this._logService.error(`Proceeding with EXTRA proposals (${[...diff].join(', ')}) because extension is in development mode. Still, this EXTENSION WILL BE BROKEN unless product.json is updated.`);
+                    this._logService.error(
+                        `Proceeding with EXTRA proposals (${[...diff].join(", ")}) because extension is in development mode. Still, this EXTENSION WILL BE BROKEN unless product.json is updated.`
+                    );
                     productEnabledProposals.push(...diff);
                 }
             }
@@ -72,20 +78,18 @@ let ExtensionsProposedApi = class ExtensionsProposedApi {
             return;
         }
         if (!extension.isBuiltin && isNonEmptyArray(extension.enabledApiProposals)) {
-            this._logService.error(`Extension '${extension.identifier.value} CANNOT USE these API proposals '${extension.enabledApiProposals?.join(', ') || '*'}'. You MUST start in extension development mode or use the --enable-proposed-api command line flag`);
+            this._logService.error(
+                `Extension '${extension.identifier.value} CANNOT USE these API proposals '${extension.enabledApiProposals?.join(", ") || "*"}'. You MUST start in extension development mode or use the --enable-proposed-api command line flag`
+            );
             extension.enabledApiProposals = [];
         }
     }
 };
-ExtensionsProposedApi = ( __decorate([
-    ( __param(0, ILogService)),
-    ( __param(1, IWorkbenchEnvironmentService)),
-    ( __param(2, IProductService))
-], ExtensionsProposedApi));
+ExtensionsProposedApi = ( __decorate([( __param(0, ILogService)), ( __param(1, IWorkbenchEnvironmentService)), ( __param(2, IProductService))], ExtensionsProposedApi));
 class ApiProposalsMarkdowneRenderer extends Disposable {
     constructor() {
         super(...arguments);
-        this.type = 'markdown';
+        this.type = "markdown";
     }
     shouldRender(manifest) {
         return !!manifest.originalEnabledApiProposals?.length || !!manifest.enabledApiProposals?.length;
@@ -100,17 +104,17 @@ class ApiProposalsMarkdowneRenderer extends Disposable {
         }
         return {
             data,
-            dispose: () => { }
+            dispose: () => {}
         };
     }
 }
 ( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
-    id: 'enabledApiProposals',
-    label: ( localize(14008, "API Proposals")),
+    id: "enabledApiProposals",
+    label: ( localize(14395, "API Proposals")),
     access: {
         canToggle: false
     },
-    renderer: ( new SyncDescriptor(ApiProposalsMarkdowneRenderer)),
+    renderer: ( new SyncDescriptor(ApiProposalsMarkdowneRenderer))
 });
 
 export { ExtensionsProposedApi };

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

@@ -5,11 +5,11 @@ import { semverExports } from '@codingame/monaco-vscode-api/_virtual/semver';
 
 function dedupExtensions(system, user, workspace, development, logService) {
     const result = ( new ExtensionIdentifierMap());
-    system.forEach((systemExtension) => {
+    system.forEach(systemExtension => {
         const extension = result.get(systemExtension.identifier);
         if (extension) {
             logService.warn(( localize(
-                14095,
+                14484,
                 "Overwriting extension {0} with {1}.",
                 extension.extensionLocation.fsPath,
                 systemExtension.extensionLocation.fsPath
@@ -17,27 +17,29 @@ function dedupExtensions(system, user, workspace, development, logService) {
         }
         result.set(systemExtension.identifier, systemExtension);
     });
-    user.forEach((userExtension) => {
+    user.forEach(userExtension => {
         const extension = result.get(userExtension.identifier);
         if (extension) {
             if (extension.isBuiltin) {
                 if (semverExports.gte(extension.version, userExtension.version)) {
-                    logService.warn(`Skipping extension ${userExtension.extensionLocation.path} in favour of the builtin extension ${extension.extensionLocation.path}.`);
+                    logService.warn(
+                        `Skipping extension ${userExtension.extensionLocation.path} in favour of the builtin extension ${extension.extensionLocation.path}.`
+                    );
                     return;
                 }
                 userExtension.isBuiltin = true;
-            }
-            else {
+            } else {
                 logService.warn(( localize(
-                    14095,
+                    14484,
                     "Overwriting extension {0} with {1}.",
                     extension.extensionLocation.fsPath,
                     userExtension.extensionLocation.fsPath
                 )));
             }
-        }
-        else if (userExtension.isBuiltin) {
-            logService.warn(`Skipping obsolete builtin extension ${userExtension.extensionLocation.path}`);
+        } else if (userExtension.isBuiltin) {
+            logService.warn(
+                `Skipping obsolete builtin extension ${userExtension.extensionLocation.path}`
+            );
             return;
         }
         result.set(userExtension.identifier, userExtension);
@@ -46,7 +48,7 @@ function dedupExtensions(system, user, workspace, development, logService) {
         const extension = result.get(workspaceExtension.identifier);
         if (extension) {
             logService.warn(( localize(
-                14096,
+                14485,
                 "Overwriting {0} with Workspace Extension {1}.",
                 extension.extensionLocation.fsPath,
                 workspaceExtension.extensionLocation.fsPath
@@ -56,7 +58,7 @@ function dedupExtensions(system, user, workspace, development, logService) {
     });
     development.forEach(developedExtension => {
         logService.info(( localize(
-            14097,
+            14486,
             "Loading development extension at {0}",
             developedExtension.extensionLocation.fsPath
         )));

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

@@ -25,7 +25,13 @@ let LazyCreateExtensionHostManager = class LazyCreateExtensionHostManager extend
     get friendyName() {
         return friendlyExtHostName(this.kind, this.pid);
     }
-    constructor(extensionHost, _initialActivationEvents, _internalExtensionService, _instantiationService, _logService) {
+    constructor(
+        extensionHost,
+        _initialActivationEvents,
+        _internalExtensionService,
+        _instantiationService,
+        _logService
+    ) {
         super();
         this._initialActivationEvents = _initialActivationEvents;
         this._internalExtensionService = _internalExtensionService;
@@ -46,8 +52,15 @@ let LazyCreateExtensionHostManager = class LazyCreateExtensionHostManager extend
     }
     _createActual(reason) {
         this._logService.info(`Creating lazy extension host (${this.friendyName}). Reason: ${reason}`);
-        this._actual = this._register(this._instantiationService.createInstance(ExtensionHostManager, this._extensionHost, this._initialActivationEvents, this._internalExtensionService));
-        this._register(this._actual.onDidChangeResponsiveState((e) => this._onDidChangeResponsiveState.fire(e)));
+        this._actual = this._register(this._instantiationService.createInstance(
+            ExtensionHostManager,
+            this._extensionHost,
+            this._initialActivationEvents,
+            this._internalExtensionService
+        ));
+        this._register(
+            this._actual.onDidChangeResponsiveState(e => this._onDidChangeResponsiveState.fire(e))
+        );
         return this._actual;
     }
     async _getOrCreateActualAndStart(reason) {
@@ -76,7 +89,9 @@ let LazyCreateExtensionHostManager = class LazyCreateExtensionHostManager extend
             return this._actual.deltaExtensions(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.ready();
             return;
         }
@@ -122,7 +137,7 @@ let LazyCreateExtensionHostManager = class LazyCreateExtensionHostManager extend
             return this._actual.resolveAuthority(remoteAuthority, resolveAttempt);
         }
         return {
-            type: 'error',
+            type: "error",
             error: {
                 message: `Cannot resolve authority`,
                 code: RemoteAuthorityResolverErrorCode.Unknown,
@@ -158,9 +173,6 @@ let LazyCreateExtensionHostManager = class LazyCreateExtensionHostManager extend
         }
     }
 };
-LazyCreateExtensionHostManager = ( __decorate([
-    ( __param(3, IInstantiationService)),
-    ( __param(4, ILogService))
-], LazyCreateExtensionHostManager));
+LazyCreateExtensionHostManager = ( __decorate([( __param(3, IInstantiationService)), ( __param(4, ILogService))], LazyCreateExtensionHostManager));
 
 export { LazyCreateExtensionHostManager };

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

@@ -24,7 +24,22 @@ import { isMessageOfType, MessageType, UIKind, createMessageOfType } from '@codi
 import { ExtensionHostStartup } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions';
 
 let RemoteExtensionHost = class RemoteExtensionHost extends Disposable {
-    constructor(runningLocation, _initDataProvider, remoteSocketFactoryService, _contextService, _environmentService, _telemetryService, _logService, _loggerService, _labelService, remoteAuthorityResolverService, _extensionHostDebugService, _productService, _signService, _defaultLogLevelsService) {
+    constructor(
+        runningLocation,
+        _initDataProvider,
+        remoteSocketFactoryService,
+        _contextService,
+        _environmentService,
+        _telemetryService,
+        _logService,
+        _loggerService,
+        _labelService,
+        remoteAuthorityResolverService,
+        _extensionHostDebugService,
+        _productService,
+        _signService,
+        _defaultLogLevelsService
+    ) {
         super();
         this.runningLocation = runningLocation;
         this._initDataProvider = _initDataProvider;
@@ -59,8 +74,13 @@ let RemoteExtensionHost = class RemoteExtensionHost extends Disposable {
             quality: this._productService.quality,
             addressProvider: {
                 getAddress: async () => {
-                    const { authority } = await this.remoteAuthorityResolverService.resolveAuthority(this._initDataProvider.remoteAuthority);
-                    return { connectTo: authority.connectTo, connectionToken: authority.connectionToken };
+                    const {
+                        authority
+                    } = await this.remoteAuthorityResolverService.resolveAuthority(this._initDataProvider.remoteAuthority);
+                    return {
+                        connectTo: authority.connectTo,
+                        connectionToken: authority.connectionToken
+                    };
                 }
             },
             remoteSocketFactoryService: this.remoteSocketFactoryService,
@@ -68,13 +88,16 @@ let RemoteExtensionHost = class RemoteExtensionHost extends Disposable {
             logService: this._logService,
             ipcLogger: null
         };
-        return this.remoteAuthorityResolverService.resolveAuthority(this._initDataProvider.remoteAuthority).then((resolverResult) => {
+        return this.remoteAuthorityResolverService.resolveAuthority(this._initDataProvider.remoteAuthority).then(resolverResult => {
             const startParams = {
                 language: language,
                 debugId: this._environmentService.debugExtensionHost.debugId,
                 break: this._environmentService.debugExtensionHost.break,
                 port: this._environmentService.debugExtensionHost.port,
-                env: { ...this._environmentService.debugExtensionHost.env, ...resolverResult.options?.extensionHostEnv },
+                env: {
+                    ...this._environmentService.debugExtensionHost.env,
+                    ...resolverResult.options?.extensionHostEnv
+                }
             };
             const extDevLocs = this._environmentService.extensionDevelopmentLocationURI;
             let debugOk = true;
@@ -88,10 +111,18 @@ let RemoteExtensionHost = class RemoteExtensionHost extends Disposable {
             }
             return connectRemoteAgentExtensionHost(options, startParams).then(result => {
                 this._register(result);
-                const { protocol, debugPort, reconnectionToken } = result;
-                const isExtensionDevelopmentDebug = typeof debugPort === 'number';
+                const {
+                    protocol,
+                    debugPort,
+                    reconnectionToken
+                } = result;
+                const isExtensionDevelopmentDebug = typeof debugPort === "number";
                 if (debugOk && this._environmentService.isExtensionDevelopment && this._environmentService.debugExtensionHost.debugId && debugPort) {
-                    this._extensionHostDebugService.attachSession(this._environmentService.debugExtensionHost.debugId, debugPort, this._initDataProvider.remoteAuthority);
+                    this._extensionHostDebugService.attachSession(
+                        this._environmentService.debugExtensionHost.debugId,
+                        debugPort,
+                        this._initDataProvider.remoteAuthority
+                    );
                 }
                 protocol.onDidDispose(() => {
                     this._onExtHostConnectionLost(reconnectionToken);
@@ -103,7 +134,9 @@ let RemoteExtensionHost = class RemoteExtensionHost extends Disposable {
                 });
                 return ( new Promise((resolve, reject) => {
                     const handle = setTimeout(() => {
-                        reject('The remote extension host took longer than 60s to send its ready message.');
+                        reject(
+                            "The remote extension host took longer than 60s to send its ready message."
+                        );
                     }, 60 * 1000);
                     const disposable = protocol.onMessage(msg => {
                         if (isMessageOfType(msg, MessageType.Ready)) {
@@ -119,7 +152,10 @@ let RemoteExtensionHost = class RemoteExtensionHost extends Disposable {
                             resolve(protocol);
                             return;
                         }
-                        console.error(`received unexpected message during handshake phase from the extension host: `, msg);
+                        console.error(
+                            `received unexpected message during handshake phase from the extension host: `,
+                            msg
+                        );
                     });
                 }));
             });
@@ -152,7 +188,7 @@ let RemoteExtensionHost = class RemoteExtensionHost extends Disposable {
                 isExtensionDevelopmentDebug,
                 appRoot: remoteInitData.appRoot,
                 appName: this._productService.nameLong,
-                appHost: this._productService.embedderIdentifier || 'desktop',
+                appHost: this._productService.embedderIdentifier || "desktop",
                 appUriScheme: this._productService.urlProtocol,
                 isExtensionTelemetryLoggingOnly: isLoggingOnly(this._productService, this._environmentService),
                 appLanguage: language,
@@ -219,19 +255,6 @@ let RemoteExtensionHost = class RemoteExtensionHost extends Disposable {
         }
     }
 };
-RemoteExtensionHost = ( __decorate([
-    ( __param(2, IRemoteSocketFactoryService)),
-    ( __param(3, IWorkspaceContextService)),
-    ( __param(4, IWorkbenchEnvironmentService)),
-    ( __param(5, ITelemetryService)),
-    ( __param(6, ILogService)),
-    ( __param(7, ILoggerService)),
-    ( __param(8, ILabelService)),
-    ( __param(9, IRemoteAuthorityResolverService)),
-    ( __param(10, IExtensionHostDebugService)),
-    ( __param(11, IProductService)),
-    ( __param(12, ISignService)),
-    ( __param(13, IDefaultLogLevelsService))
-], RemoteExtensionHost));
+RemoteExtensionHost = ( __decorate([( __param(2, IRemoteSocketFactoryService)), ( __param(3, IWorkspaceContextService)), ( __param(4, IWorkbenchEnvironmentService)), ( __param(5, ITelemetryService)), ( __param(6, ILogService)), ( __param(7, ILoggerService)), ( __param(8, ILabelService)), ( __param(9, IRemoteAuthorityResolverService)), ( __param(10, IExtensionHostDebugService)), ( __param(11, IProductService)), ( __param(12, ISignService)), ( __param(13, IDefaultLogLevelsService))], RemoteExtensionHost));
 
 export { RemoteExtensionHost };