@codingame/monaco-vscode-extension-gallery-service-override 1.83.9

package/vscode/src/vs/workbench/services/extensionManagement/common/extensionManagementChannelClient.js

@@ -0,0 +1,109 @@
+import { ExtensionIdentifier } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
+import { ExtensionManagementChannelClient } from '../../../../platform/extensionManagement/common/extensionManagementIpc.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { delta } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { compare } from 'monaco-editor/esm/vs/base/common/strings.js';
+
+class ProfileAwareExtensionManagementChannelClient extends ExtensionManagementChannelClient {
+    constructor(channel, userDataProfileService, uriIdentityService) {
+        super(channel);
+        this.userDataProfileService = userDataProfileService;
+        this.uriIdentityService = uriIdentityService;
+        this._onDidChangeProfile = this._register(( new Emitter()));
+        this.onDidChangeProfile = this._onDidChangeProfile.event;
+        this._register(userDataProfileService.onDidChangeCurrentProfile(e => {
+            if (!this.uriIdentityService.extUri.isEqual(e.previous.extensionsResource, e.profile.extensionsResource)) {
+                e.join(this.whenProfileChanged(e));
+            }
+        }));
+    }
+    async fireEvent(arg0, arg1) {
+        if (Array.isArray(arg1)) {
+            const event = arg0;
+            const data = arg1;
+            const filtered = [];
+            for (const e of data) {
+                const result = this.filterEvent(e);
+                if (result instanceof Promise ? await result : result) {
+                    filtered.push(e);
+                }
+            }
+            if (filtered.length) {
+                event.fire(filtered);
+            }
+        }
+        else {
+            const event = arg0;
+            const data = arg1;
+            const result = this.filterEvent(data);
+            if (result instanceof Promise ? await result : result) {
+                event.fire(data);
+            }
+        }
+    }
+    async install(vsix, installOptions) {
+        installOptions = { ...installOptions, profileLocation: await this.getProfileLocation(installOptions?.profileLocation) };
+        return super.install(vsix, installOptions);
+    }
+    async installFromLocation(location, profileLocation) {
+        return super.installFromLocation(location, await this.getProfileLocation(profileLocation));
+    }
+    async installFromGallery(extension, installOptions) {
+        installOptions = { ...installOptions, profileLocation: await this.getProfileLocation(installOptions?.profileLocation) };
+        return super.installFromGallery(extension, installOptions);
+    }
+    async installGalleryExtensions(extensions) {
+        const infos = [];
+        for (const extension of extensions) {
+            infos.push({ ...extension, options: { ...extension.options, profileLocation: extension.options?.profileLocation ? (await this.getProfileLocation(extension.options?.profileLocation)) : undefined } });
+        }
+        return super.installGalleryExtensions(infos);
+    }
+    async uninstall(extension, options) {
+        options = { ...options, profileLocation: await this.getProfileLocation(options?.profileLocation) };
+        return super.uninstall(extension, options);
+    }
+    async getInstalled(type = null, extensionsProfileResource) {
+        return super.getInstalled(type, await this.getProfileLocation(extensionsProfileResource));
+    }
+    async updateMetadata(local, metadata, extensionsProfileResource) {
+        return super.updateMetadata(local, metadata, await this.getProfileLocation(extensionsProfileResource));
+    }
+    async toggleAppliationScope(local, fromProfileLocation) {
+        return super.toggleAppliationScope(local, await this.getProfileLocation(fromProfileLocation));
+    }
+    async copyExtensions(fromProfileLocation, toProfileLocation) {
+        return super.copyExtensions(await this.getProfileLocation(fromProfileLocation), await this.getProfileLocation(toProfileLocation));
+    }
+    async whenProfileChanged(e) {
+        const previousProfileLocation = await this.getProfileLocation(e.previous.extensionsResource);
+        const currentProfileLocation = await this.getProfileLocation(e.profile.extensionsResource);
+        if (this.uriIdentityService.extUri.isEqual(previousProfileLocation, currentProfileLocation)) {
+            return;
+        }
+        const eventData = await this.switchExtensionsProfile(previousProfileLocation, currentProfileLocation);
+        this._onDidChangeProfile.fire(eventData);
+    }
+    async switchExtensionsProfile(previousProfileLocation, currentProfileLocation, preserveExtensions) {
+        const oldExtensions = await this.getInstalled(1 , previousProfileLocation);
+        const newExtensions = await this.getInstalled(1 , currentProfileLocation);
+        if (preserveExtensions?.length) {
+            const extensionsToInstall = [];
+            for (const extension of oldExtensions) {
+                if (( preserveExtensions.some(id => ExtensionIdentifier.equals(extension.identifier.id, id))) &&
+                    !( newExtensions.some(e => ExtensionIdentifier.equals(e.identifier.id, extension.identifier.id)))) {
+                    extensionsToInstall.push(extension.identifier);
+                }
+            }
+            if (extensionsToInstall.length) {
+                await this.installExtensionsFromProfile(extensionsToInstall, previousProfileLocation, currentProfileLocation);
+            }
+        }
+        return delta(oldExtensions, newExtensions, (a, b) => compare(`${ExtensionIdentifier.toKey(a.identifier.id)}@${a.manifest.version}`, `${ExtensionIdentifier.toKey(b.identifier.id)}@${b.manifest.version}`));
+    }
+    async getProfileLocation(profileLocation) {
+        return profileLocation ?? this.userDataProfileService.currentProfile.extensionsResource;
+    }
+}
+
+export { ProfileAwareExtensionManagementChannelClient };

package/vscode/src/vs/workbench/services/extensionManagement/common/extensionManagementServerService.js

@@ -0,0 +1,62 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { IRemoteAgentService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteAgentService';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { WebExtensionManagementService } from './webExtensionManagementService.js';
+import { RemoteExtensionManagementService } from './remoteExtensionManagementService.js';
+
+let ExtensionManagementServerService = class ExtensionManagementServerService {
+    constructor(remoteAgentService, labelService, instantiationService) {
+        this.localExtensionManagementServer = null;
+        this.remoteExtensionManagementServer = null;
+        this.webExtensionManagementServer = null;
+        const remoteAgentConnection = remoteAgentService.getConnection();
+        if (remoteAgentConnection) {
+            const extensionManagementService = instantiationService.createInstance(RemoteExtensionManagementService, remoteAgentConnection.getChannel('extensions'));
+            this.remoteExtensionManagementServer = {
+                id: 'remote',
+                extensionManagementService,
+                get label() { return labelService.getHostLabel(Schemas.vscodeRemote, remoteAgentConnection.remoteAuthority) || ( localizeWithPath(
+                    'vs/workbench/services/extensionManagement/common/extensionManagementServerService',
+                    'remote',
+                    "Remote"
+                )); },
+            };
+        }
+        if (isWeb) {
+            const extensionManagementService = instantiationService.createInstance(WebExtensionManagementService);
+            this.webExtensionManagementServer = {
+                id: 'web',
+                extensionManagementService,
+                label: ( localizeWithPath(
+                    'vs/workbench/services/extensionManagement/common/extensionManagementServerService',
+                    'browser',
+                    "Browser"
+                )),
+            };
+        }
+    }
+    getExtensionManagementServer(extension) {
+        if (extension.location.scheme === Schemas.vscodeRemote) {
+            return this.remoteExtensionManagementServer;
+        }
+        if (this.webExtensionManagementServer) {
+            return this.webExtensionManagementServer;
+        }
+        throw new Error(`Invalid Extension ${extension.location}`);
+    }
+    getExtensionInstallLocation(extension) {
+        const server = this.getExtensionManagementServer(extension);
+        return server === this.remoteExtensionManagementServer ? 2  : 3 ;
+    }
+};
+ExtensionManagementServerService = ( __decorate([
+    ( __param(0, IRemoteAgentService)),
+    ( __param(1, ILabelService)),
+    ( __param(2, IInstantiationService))
+], ExtensionManagementServerService));
+
+export { ExtensionManagementServerService };