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

package/vscode/src/vs/platform/extensionManagement/common/extensionManagementIpc.js

@@ -0,0 +1,119 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { transformAndReviveIncomingURIs, DefaultURITransformer } from 'vscode/vscode/vs/base/common/uriIpc';
+import { isTargetPlatformCompatible } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagement';
+
+function transformIncomingExtension(extension, transformer) {
+    transformer = transformer ? transformer : DefaultURITransformer;
+    const manifest = extension.manifest;
+    const transformed = transformAndReviveIncomingURIs({ ...extension, ...{ manifest: undefined } }, transformer);
+    return { ...transformed, ...{ manifest } };
+}
+class ExtensionManagementChannelClient extends Disposable {
+    get onInstallExtension() { return this._onInstallExtension.event; }
+    get onDidInstallExtensions() { return this._onDidInstallExtensions.event; }
+    get onUninstallExtension() { return this._onUninstallExtension.event; }
+    get onDidUninstallExtension() { return this._onDidUninstallExtension.event; }
+    get onDidUpdateExtensionMetadata() { return this._onDidUpdateExtensionMetadata.event; }
+    constructor(channel) {
+        super();
+        this.channel = channel;
+        this._onInstallExtension = this._register(( new Emitter()));
+        this._onDidInstallExtensions = this._register(( new Emitter()));
+        this._onUninstallExtension = this._register(( new Emitter()));
+        this._onDidUninstallExtension = this._register(( new Emitter()));
+        this._onDidUpdateExtensionMetadata = this._register(( new Emitter()));
+        this._register(this.channel.listen('onInstallExtension')(e => this.fireEvent(this._onInstallExtension, { ...e, source: this.isUriComponents(e.source) ? URI.revive(e.source) : e.source, profileLocation: URI.revive(e.profileLocation) })));
+        this._register(this.channel.listen('onDidInstallExtensions')(results => this.fireEvent(this._onDidInstallExtensions, ( results.map(
+            e => ({ ...e, local: e.local ? transformIncomingExtension(e.local, null) : e.local, source: this.isUriComponents(e.source) ? URI.revive(e.source) : e.source, profileLocation: URI.revive(e.profileLocation) })
+        )))));
+        this._register(this.channel.listen('onUninstallExtension')(e => this.fireEvent(this._onUninstallExtension, { ...e, profileLocation: URI.revive(e.profileLocation) })));
+        this._register(this.channel.listen('onDidUninstallExtension')(e => this.fireEvent(this._onDidUninstallExtension, { ...e, profileLocation: URI.revive(e.profileLocation) })));
+        this._register(this.channel.listen('onDidUpdateExtensionMetadata')(e => this._onDidUpdateExtensionMetadata.fire(transformIncomingExtension(e, null))));
+    }
+    fireEvent(event, data) {
+        event.fire(data);
+    }
+    isUriComponents(thing) {
+        if (!thing) {
+            return false;
+        }
+        return typeof thing.path === 'string' &&
+            typeof thing.scheme === 'string';
+    }
+    getTargetPlatform() {
+        if (!this._targetPlatformPromise) {
+            this._targetPlatformPromise = this.channel.call('getTargetPlatform');
+        }
+        return this._targetPlatformPromise;
+    }
+    async canInstall(extension) {
+        const currentTargetPlatform = await this.getTargetPlatform();
+        return ( extension.allTargetPlatforms.some(
+            targetPlatform => isTargetPlatformCompatible(targetPlatform, extension.allTargetPlatforms, currentTargetPlatform)
+        ));
+    }
+    zip(extension) {
+        return Promise.resolve(this.channel.call('zip', [extension]).then(result => URI.revive(result)));
+    }
+    unzip(zipLocation) {
+        return Promise.resolve(this.channel.call('unzip', [zipLocation]));
+    }
+    install(vsix, options) {
+        return Promise.resolve(this.channel.call('install', [vsix, options])).then(local => transformIncomingExtension(local, null));
+    }
+    installFromLocation(location, profileLocation) {
+        return Promise.resolve(this.channel.call('installFromLocation', [location, profileLocation])).then(local => transformIncomingExtension(local, null));
+    }
+    async installExtensionsFromProfile(extensions, fromProfileLocation, toProfileLocation) {
+        const result = await this.channel.call('installExtensionsFromProfile', [extensions, fromProfileLocation, toProfileLocation]);
+        return ( result.map(local => transformIncomingExtension(local, null)));
+    }
+    getManifest(vsix) {
+        return Promise.resolve(this.channel.call('getManifest', [vsix]));
+    }
+    installFromGallery(extension, installOptions) {
+        return Promise.resolve(this.channel.call('installFromGallery', [extension, installOptions])).then(local => transformIncomingExtension(local, null));
+    }
+    async installGalleryExtensions(extensions) {
+        const results = await this.channel.call('installGalleryExtensions', [extensions]);
+        return ( results.map(
+            e => ({ ...e, local: e.local ? transformIncomingExtension(e.local, null) : e.local, source: this.isUriComponents(e.source) ? URI.revive(e.source) : e.source, profileLocation: URI.revive(e.profileLocation) })
+        ));
+    }
+    uninstall(extension, options) {
+        return Promise.resolve(this.channel.call('uninstall', [extension, options]));
+    }
+    reinstallFromGallery(extension) {
+        return Promise.resolve(this.channel.call('reinstallFromGallery', [extension])).then(local => transformIncomingExtension(local, null));
+    }
+    getInstalled(type = null, extensionsProfileResource) {
+        return Promise.resolve(this.channel.call('getInstalled', [type, extensionsProfileResource]))
+            .then(extensions => ( extensions.map(extension => transformIncomingExtension(extension, null))));
+    }
+    updateMetadata(local, metadata, extensionsProfileResource) {
+        return Promise.resolve(this.channel.call('updateMetadata', [local, metadata, extensionsProfileResource]))
+            .then(extension => transformIncomingExtension(extension, null));
+    }
+    toggleAppliationScope(local, fromProfileLocation) {
+        return this.channel.call('toggleAppliationScope', [local, fromProfileLocation])
+            .then(extension => transformIncomingExtension(extension, null));
+    }
+    copyExtensions(fromProfileLocation, toProfileLocation) {
+        return this.channel.call('copyExtensions', [fromProfileLocation, toProfileLocation]);
+    }
+    getExtensionsControlManifest() {
+        return Promise.resolve(this.channel.call('getExtensionsControlManifest'));
+    }
+    async download(extension, operation, donotVerifySignature) {
+        const result = await this.channel.call('download', [extension, operation, donotVerifySignature]);
+        return URI.revive(result);
+    }
+    async cleanUp() {
+        return this.channel.call('cleanUp');
+    }
+    registerParticipant() { throw new Error('Not Supported'); }
+}
+
+export { ExtensionManagementChannelClient };

package/vscode/src/vs/platform/extensionManagement/common/extensionTipsService.js

@@ -0,0 +1,57 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+
+let ExtensionTipsService = class ExtensionTipsService extends Disposable {
+    constructor(fileService, productService) {
+        super();
+        this.fileService = fileService;
+        this.productService = productService;
+        this.allConfigBasedTips = ( new Map());
+        if (this.productService.configBasedExtensionTips) {
+            Object.entries(this.productService.configBasedExtensionTips).forEach(([, value]) => this.allConfigBasedTips.set(value.configPath, value));
+        }
+    }
+    getConfigBasedTips(folder) {
+        return this.getValidConfigBasedTips(folder);
+    }
+    async getImportantExecutableBasedTips() {
+        return [];
+    }
+    async getOtherExecutableBasedTips() {
+        return [];
+    }
+    async getValidConfigBasedTips(folder) {
+        const result = [];
+        for (const [configPath, tip] of this.allConfigBasedTips) {
+            if (tip.configScheme && tip.configScheme !== folder.scheme) {
+                continue;
+            }
+            try {
+                const content = ( (await this.fileService.readFile(joinPath(folder, configPath))).value.toString());
+                for (const [key, value] of Object.entries(tip.recommendations)) {
+                    if (!value.contentPattern || ( new RegExp(value.contentPattern, 'mig')).test(content)) {
+                        result.push({
+                            extensionId: key,
+                            extensionName: value.name,
+                            configName: tip.configName,
+                            important: !!value.important,
+                            isExtensionPack: !!value.isExtensionPack,
+                            whenNotInstalled: value.whenNotInstalled
+                        });
+                    }
+                }
+            }
+            catch (error) {  }
+        }
+        return result;
+    }
+};
+ExtensionTipsService = ( __decorate([
+    ( __param(0, IFileService)),
+    ( __param(1, IProductService))
+], ExtensionTipsService));
+
+export { ExtensionTipsService };

package/vscode/src/vs/platform/extensionManagement/common/unsupportedExtensionsMigration.js

@@ -0,0 +1,58 @@
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { areSameExtensions, getExtensionId } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagementUtil';
+
+async function migrateUnsupportedExtensions(extensionManagementService, galleryService, extensionStorageService, extensionEnablementService, logService) {
+    try {
+        const extensionsControlManifest = await extensionManagementService.getExtensionsControlManifest();
+        if (!extensionsControlManifest.deprecated) {
+            return;
+        }
+        const installed = await extensionManagementService.getInstalled(1 );
+        for (const [unsupportedExtensionId, deprecated] of Object.entries(extensionsControlManifest.deprecated)) {
+            if (!deprecated?.extension) {
+                continue;
+            }
+            const { id: preReleaseExtensionId, autoMigrate, preRelease } = deprecated.extension;
+            if (!autoMigrate) {
+                continue;
+            }
+            const unsupportedExtension = installed.find(i => areSameExtensions(i.identifier, { id: unsupportedExtensionId }));
+            if (!unsupportedExtension) {
+                continue;
+            }
+            const gallery = (await galleryService.getExtensions([{ id: preReleaseExtensionId, preRelease }], { targetPlatform: await extensionManagementService.getTargetPlatform(), compatible: true }, CancellationToken.None))[0];
+            if (!gallery) {
+                logService.info(`Skipping migrating '${unsupportedExtension.identifier.id}' extension because, the comaptible target '${preReleaseExtensionId}' extension is not found`);
+                continue;
+            }
+            try {
+                logService.info(`Migrating '${unsupportedExtension.identifier.id}' extension to '${preReleaseExtensionId}' extension...`);
+                const isUnsupportedExtensionEnabled = !( extensionEnablementService.getDisabledExtensions().some(e => areSameExtensions(e, unsupportedExtension.identifier)));
+                await extensionManagementService.uninstall(unsupportedExtension);
+                logService.info(`Uninstalled the unsupported extension '${unsupportedExtension.identifier.id}'`);
+                let preReleaseExtension = installed.find(i => areSameExtensions(i.identifier, { id: preReleaseExtensionId }));
+                if (!preReleaseExtension || (!preReleaseExtension.isPreReleaseVersion && isUnsupportedExtensionEnabled)) {
+                    preReleaseExtension = await extensionManagementService.installFromGallery(gallery, { installPreReleaseVersion: true, isMachineScoped: unsupportedExtension.isMachineScoped, operation: 4  });
+                    logService.info(`Installed the pre-release extension '${preReleaseExtension.identifier.id}'`);
+                    if (!isUnsupportedExtensionEnabled) {
+                        await extensionEnablementService.disableExtension(preReleaseExtension.identifier);
+                        logService.info(`Disabled the pre-release extension '${preReleaseExtension.identifier.id}' because the unsupported extension '${unsupportedExtension.identifier.id}' is disabled`);
+                    }
+                    if (autoMigrate.storage) {
+                        extensionStorageService.addToMigrationList(getExtensionId(unsupportedExtension.manifest.publisher, unsupportedExtension.manifest.name), getExtensionId(preReleaseExtension.manifest.publisher, preReleaseExtension.manifest.name));
+                        logService.info(`Added pre-release extension to the storage migration list`);
+                    }
+                }
+                logService.info(`Migrated '${unsupportedExtension.identifier.id}' extension to '${preReleaseExtensionId}' extension.`);
+            }
+            catch (error) {
+                logService.error(error);
+            }
+        }
+    }
+    catch (error) {
+        logService.error(error);
+    }
+}
+
+export { migrateUnsupportedExtensions };

package/vscode/src/vs/platform/externalServices/common/marketplace.js

@@ -0,0 +1,17 @@
+import { getServiceMachineId } from 'vscode/vscode/vs/platform/externalServices/common/serviceMachineId';
+import { supportsTelemetry, getTelemetryLevel } from 'vscode/vscode/vs/platform/telemetry/common/telemetryUtils';
+
+async function resolveMarketplaceHeaders(version, productService, environmentService, configurationService, fileService, storageService, telemetryService) {
+    const headers = {
+        'X-Market-Client-Id': `VSCode ${version}`,
+        'User-Agent': `VSCode ${version} (${productService.nameShort})`
+    };
+    if (supportsTelemetry(productService, environmentService) && getTelemetryLevel(configurationService) === 3 ) {
+        const serviceMachineId = await getServiceMachineId(environmentService, fileService, storageService);
+        headers['X-Market-User-Id'] = serviceMachineId;
+        headers['VSCode-SessionId'] = telemetryService.machineId || serviceMachineId;
+    }
+    return headers;
+}
+
+export { resolveMarketplaceHeaders };