@codingame/monaco-vscode-api 4.0.0 → 4.1.0

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

@@ -0,0 +1,748 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { distinct, isNonEmptyArray } from '../../../base/common/arrays.js';
+import { Barrier, createCancelablePromise } from '../../../base/common/async.js';
+import { CancellationToken } from '../../../base/common/cancellation.js';
+import { getErrorMessage, CancellationError } from '../../../base/common/errors.js';
+import { Emitter, Event } from '../../../base/common/event.js';
+import { Disposable, toDisposable } from '../../../base/common/lifecycle.js';
+import { isWeb } from '../../../base/common/platform.js';
+import { isDefined } from '../../../base/common/types.js';
+import { URI } from '../../../base/common/uri.js';
+import { localizeWithPath } from '../../../nls.js';
+import { isTargetPlatformCompatible, ExtensionManagementError, ExtensionManagementErrorCode, TargetPlatformToString, IExtensionGalleryService, ExtensionGalleryError, EXTENSION_INSTALL_DEP_PACK_CONTEXT } from './extensionManagement.js';
+import { areSameExtensions, getGalleryExtensionTelemetryData, ExtensionKey, getLocalExtensionTelemetryData } from './extensionManagementUtil.js';
+import { isApplicationScopedExtension } from '../../extensions/common/extensions.js';
+import { ILogService } from '../../log/common/log.js';
+import { IProductService } from '../../product/common/productService.js';
+import { ITelemetryService } from '../../telemetry/common/telemetry.js';
+import { IUriIdentityService } from '../../uriIdentity/common/uriIdentity.js';
+import { IUserDataProfilesService } from '../../userDataProfile/common/userDataProfile.js';
+let AbstractExtensionManagementService = class AbstractExtensionManagementService 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(galleryService, telemetryService, uriIdentityService, logService, productService, userDataProfilesService) {
+        super();
+        this.galleryService = galleryService;
+        this.telemetryService = telemetryService;
+        this.uriIdentityService = uriIdentityService;
+        this.logService = logService;
+        this.productService = productService;
+        this.userDataProfilesService = userDataProfilesService;
+        this.lastReportTimestamp = 0;
+        this.installingExtensions = ( new Map());
+        this.uninstallingExtensions = ( new Map());
+        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.participants = [];
+        this._register(toDisposable(() => {
+            this.installingExtensions.forEach(({ task }) => task.cancel());
+            this.uninstallingExtensions.forEach(promise => promise.cancel());
+            this.installingExtensions.clear();
+            this.uninstallingExtensions.clear();
+        }));
+    }
+    async canInstall(extension) {
+        const currentTargetPlatform = await this.getTargetPlatform();
+        return ( extension.allTargetPlatforms.some(
+            targetPlatform => isTargetPlatformCompatible(targetPlatform, extension.allTargetPlatforms, currentTargetPlatform)
+        ));
+    }
+    async installFromGallery(extension, options = {}) {
+        try {
+            const results = await this.installGalleryExtensions([{ extension, options }]);
+            const result = results.find(({ identifier }) => areSameExtensions(identifier, extension.identifier));
+            if (result?.local) {
+                return result?.local;
+            }
+            if (result?.error) {
+                throw result.error;
+            }
+            throw new ExtensionManagementError(`Unknown error while installing extension ${extension.identifier.id}`, ExtensionManagementErrorCode.Unknown);
+        }
+        catch (error) {
+            throw toExtensionManagementError(error);
+        }
+    }
+    async installGalleryExtensions(extensions) {
+        if (!this.galleryService.isEnabled()) {
+            throw new ExtensionManagementError(localizeWithPath('vs/platform/extensionManagement/common/abstractExtensionManagementService', 'MarketPlaceDisabled', "Marketplace is not enabled"), ExtensionManagementErrorCode.NotAllowed);
+        }
+        const results = [];
+        const installableExtensions = [];
+        await Promise.allSettled(( extensions.map(async ({ extension, options }) => {
+            try {
+                const compatible = await this.checkAndGetCompatibleVersion(extension, !!options?.installGivenVersion, !!options?.installPreReleaseVersion, options.productVersion ?? { version: this.productService.version, date: this.productService.date });
+                installableExtensions.push({ ...compatible, options });
+            }
+            catch (error) {
+                results.push({ identifier: extension.identifier, operation: 2 , source: extension, error });
+            }
+        })));
+        if (installableExtensions.length) {
+            results.push(...(await this.installExtensions(installableExtensions)));
+        }
+        for (const result of results) {
+            if (result.error) {
+                this.logService.error(`Failed to install extension.`, result.identifier.id);
+                this.logService.error(result.error);
+                if (result.source && !URI.isUri(result.source)) {
+                    reportTelemetry(this.telemetryService, 'extensionGallery:install', { extensionData: getGalleryExtensionTelemetryData(result.source), error: result.error });
+                }
+            }
+        }
+        return results;
+    }
+    async uninstall(extension, options = {}) {
+        this.logService.trace('ExtensionManagementService#uninstall', extension.identifier.id);
+        return this.uninstallExtension(extension, options);
+    }
+    async toggleAppliationScope(extension, fromProfileLocation) {
+        if (isApplicationScopedExtension(extension.manifest) || extension.isBuiltin) {
+            return extension;
+        }
+        if (extension.isApplicationScoped) {
+            let local = await this.updateMetadata(extension, { isApplicationScoped: false }, this.userDataProfilesService.defaultProfile.extensionsResource);
+            if (!this.uriIdentityService.extUri.isEqual(fromProfileLocation, this.userDataProfilesService.defaultProfile.extensionsResource)) {
+                local = await this.copyExtension(extension, this.userDataProfilesService.defaultProfile.extensionsResource, fromProfileLocation);
+            }
+            for (const profile of this.userDataProfilesService.profiles) {
+                const existing = (await this.getInstalled(1 , profile.extensionsResource))
+                    .find(e => areSameExtensions(e.identifier, extension.identifier));
+                if (existing) {
+                    this._onDidUpdateExtensionMetadata.fire(existing);
+                }
+                else {
+                    this._onDidUninstallExtension.fire({ identifier: extension.identifier, profileLocation: profile.extensionsResource });
+                }
+            }
+            return local;
+        }
+        else {
+            const local = this.uriIdentityService.extUri.isEqual(fromProfileLocation, this.userDataProfilesService.defaultProfile.extensionsResource)
+                ? await this.updateMetadata(extension, { isApplicationScoped: true }, this.userDataProfilesService.defaultProfile.extensionsResource)
+                : await this.copyExtension(extension, fromProfileLocation, this.userDataProfilesService.defaultProfile.extensionsResource, { isApplicationScoped: true });
+            this._onDidInstallExtensions.fire([{ identifier: local.identifier, operation: 2 , local, profileLocation: this.userDataProfilesService.defaultProfile.extensionsResource, applicationScoped: true }]);
+            return local;
+        }
+    }
+    getExtensionsControlManifest() {
+        const now = ( new Date()).getTime();
+        if (!this.extensionsControlManifest || now - this.lastReportTimestamp > 1000 * 60 * 5) {
+            this.extensionsControlManifest = this.updateControlCache();
+            this.lastReportTimestamp = now;
+        }
+        return this.extensionsControlManifest;
+    }
+    registerParticipant(participant) {
+        this.participants.push(participant);
+    }
+    async installExtensions(extensions) {
+        const results = [];
+        const installingExtensionsMap = ( new Map());
+        const alreadyRequestedInstallations = [];
+        const successResults = [];
+        const getInstallExtensionTaskKey = (extension, profileLocation) => `${( ExtensionKey.create(extension).toString())}-${( profileLocation.toString())}`;
+        const createInstallExtensionTask = (manifest, extension, options) => {
+            const installExtensionTask = this.createInstallExtensionTask(manifest, extension, options);
+            const key = URI.isUri(extension) ? extension.path : `${extension.identifier.id.toLowerCase()}-${( options.profileLocation.toString())}`;
+            installingExtensionsMap.set(key, { task: installExtensionTask, manifest });
+            this._onInstallExtension.fire({ identifier: installExtensionTask.identifier, source: extension, profileLocation: options.profileLocation });
+            this.logService.info('Installing extension:', installExtensionTask.identifier.id);
+            if (!URI.isUri(extension)) {
+                this.installingExtensions.set(getInstallExtensionTaskKey(extension, options.profileLocation), { task: installExtensionTask, waitingTasks: [] });
+            }
+        };
+        try {
+            for (const { manifest, extension, options } of extensions) {
+                const isApplicationScoped = options.isApplicationScoped || options.isBuiltin || isApplicationScopedExtension(manifest);
+                const installExtensionTaskOptions = {
+                    ...options,
+                    installOnlyNewlyAddedFromExtensionPack: options.installOnlyNewlyAddedFromExtensionPack ?? !URI.isUri(extension) ,
+                    isApplicationScoped,
+                    profileLocation: isApplicationScoped ? this.userDataProfilesService.defaultProfile.extensionsResource : options.profileLocation ?? this.getCurrentExtensionsManifestLocation(),
+                    productVersion: options.productVersion ?? { version: this.productService.version, date: this.productService.date }
+                };
+                const existingInstallExtensionTask = !URI.isUri(extension) ? this.installingExtensions.get(getInstallExtensionTaskKey(extension, installExtensionTaskOptions.profileLocation)) : undefined;
+                if (existingInstallExtensionTask) {
+                    this.logService.info('Extension is already requested to install', existingInstallExtensionTask.task.identifier.id);
+                    alreadyRequestedInstallations.push(existingInstallExtensionTask.task.waitUntilTaskIsFinished());
+                }
+                else {
+                    createInstallExtensionTask(manifest, extension, installExtensionTaskOptions);
+                }
+            }
+            await Promise.all(( [...( installingExtensionsMap.values())].map(async ({ task, manifest }) => {
+                if (task.options.donotIncludePackAndDependencies) {
+                    this.logService.info('Installing the extension without checking dependencies and pack', task.identifier.id);
+                }
+                else {
+                    try {
+                        const allDepsAndPackExtensionsToInstall = await this.getAllDepsAndPackExtensions(task.identifier, manifest, !!task.options.installOnlyNewlyAddedFromExtensionPack, !!task.options.installPreReleaseVersion, task.options.profileLocation, task.options.productVersion);
+                        const installed = await this.getInstalled(undefined, task.options.profileLocation, task.options.productVersion);
+                        const options = { ...task.options, donotIncludePackAndDependencies: true, context: { ...task.options.context, [EXTENSION_INSTALL_DEP_PACK_CONTEXT]: true } };
+                        for (const { gallery, manifest } of distinct(allDepsAndPackExtensionsToInstall, ({ gallery }) => gallery.identifier.id)) {
+                            if (( installingExtensionsMap.has(`${gallery.identifier.id.toLowerCase()}-${( options.profileLocation.toString())}`))) {
+                                continue;
+                            }
+                            const existingInstallingExtension = this.installingExtensions.get(getInstallExtensionTaskKey(gallery, options.profileLocation));
+                            if (existingInstallingExtension) {
+                                if (this.canWaitForTask(task, existingInstallingExtension.task)) {
+                                    const identifier = existingInstallingExtension.task.identifier;
+                                    this.logService.info('Waiting for already requested installing extension', identifier.id, task.identifier.id);
+                                    existingInstallingExtension.waitingTasks.push(task);
+                                    alreadyRequestedInstallations.push(Event.toPromise(Event.filter(this.onDidInstallExtensions, results => ( results.some(result => areSameExtensions(result.identifier, identifier))))).then(results => {
+                                        this.logService.info('Finished waiting for already requested installing extension', identifier.id, task.identifier.id);
+                                        const result = results.find(result => areSameExtensions(result.identifier, identifier));
+                                        if (!result?.local) {
+                                            throw new Error(`Extension ${identifier.id} is not installed`);
+                                        }
+                                    }));
+                                }
+                            }
+                            else if (!( installed.some(({ identifier }) => areSameExtensions(identifier, gallery.identifier)))) {
+                                createInstallExtensionTask(manifest, gallery, options);
+                            }
+                        }
+                    }
+                    catch (error) {
+                        if (URI.isUri(task.source)) {
+                            if (isNonEmptyArray(manifest.extensionDependencies)) {
+                                this.logService.warn(`Cannot install dependencies of extension:`, task.identifier.id, error.message);
+                            }
+                            if (isNonEmptyArray(manifest.extensionPack)) {
+                                this.logService.warn(`Cannot install packed extensions of extension:`, task.identifier.id, error.message);
+                            }
+                        }
+                        else {
+                            this.logService.error('Error while preparing to install dependencies and extension packs of the extension:', task.identifier.id);
+                            throw error;
+                        }
+                    }
+                }
+            })));
+            await this.joinAllSettled(( [...( installingExtensionsMap.values())].map(async ({ task }) => {
+                const startTime = ( new Date()).getTime();
+                try {
+                    const local = await task.run();
+                    await this.joinAllSettled(( this.participants.map(
+                        participant => participant.postInstall(local, task.source, task.options, CancellationToken.None)
+                    )));
+                    if (!URI.isUri(task.source)) {
+                        const isUpdate = task.operation === 3 ;
+                        const durationSinceUpdate = isUpdate ? undefined : (( new Date()).getTime() - task.source.lastUpdated) / 1000;
+                        reportTelemetry(this.telemetryService, isUpdate ? 'extensionGallery:update' : 'extensionGallery:install', {
+                            extensionData: getGalleryExtensionTelemetryData(task.source),
+                            verificationStatus: task.verificationStatus,
+                            duration: ( new Date()).getTime() - startTime,
+                            durationSinceUpdate
+                        });
+                        if (isWeb && task.operation !== 3 ) {
+                            try {
+                                await this.galleryService.reportStatistic(local.manifest.publisher, local.manifest.name, local.manifest.version, "install" );
+                            }
+                            catch (error) {  }
+                        }
+                    }
+                    successResults.push({ local, identifier: task.identifier, operation: task.operation, source: task.source, context: task.options.context, profileLocation: task.profileLocation, applicationScoped: local.isApplicationScoped });
+                }
+                catch (error) {
+                    this.logService.error('Error while installing the extension', task.identifier.id, getErrorMessage(error));
+                    throw error;
+                }
+            })));
+            if (alreadyRequestedInstallations.length) {
+                await this.joinAllSettled(alreadyRequestedInstallations);
+            }
+            for (const result of successResults) {
+                this.logService.info(`Extension installed successfully:`, result.identifier.id);
+                results.push(result);
+            }
+            return results;
+        }
+        catch (error) {
+            if (successResults.length) {
+                this.logService.info('Rollback: Uninstalling installed extensions', getErrorMessage(error));
+                await Promise.allSettled(( successResults.map(async ({ local, profileLocation }) => {
+                    try {
+                        await this.createUninstallExtensionTask(local, { versionOnly: true, profileLocation }).run();
+                        this.logService.info('Rollback: Uninstalled extension', local.identifier.id);
+                    }
+                    catch (error) {
+                        this.logService.warn('Rollback: Error while uninstalling extension', local.identifier.id, getErrorMessage(error));
+                    }
+                })));
+            }
+            for (const { task } of ( installingExtensionsMap.values())) {
+                task.cancel();
+                results.push({ identifier: task.identifier, operation: 2 , source: task.source, context: task.options.context, profileLocation: task.profileLocation, error });
+            }
+            throw error;
+        }
+        finally {
+            for (const { task } of ( installingExtensionsMap.values())) {
+                if (task.source && !URI.isUri(task.source)) {
+                    this.installingExtensions.delete(getInstallExtensionTaskKey(task.source, task.profileLocation));
+                }
+            }
+            if (results.length) {
+                this._onDidInstallExtensions.fire(results);
+            }
+        }
+    }
+    canWaitForTask(taskToWait, taskToWaitFor) {
+        for (const [, { task, waitingTasks }] of this.installingExtensions.entries()) {
+            if (task === taskToWait) {
+                if (waitingTasks.includes(taskToWaitFor)) {
+                    return false;
+                }
+                if (( waitingTasks.some(waitingTask => this.canWaitForTask(waitingTask, taskToWaitFor)))) {
+                    return false;
+                }
+            }
+            if (task === taskToWaitFor && waitingTasks[0] && !this.canWaitForTask(taskToWait, waitingTasks[0])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    async joinAllSettled(promises) {
+        const results = [];
+        const errors = [];
+        const promiseResults = await Promise.allSettled(promises);
+        for (const r of promiseResults) {
+            if (r.status === 'fulfilled') {
+                results.push(r.value);
+            }
+            else {
+                errors.push(r.reason);
+            }
+        }
+        if (errors.length) {
+            throw joinErrors(errors);
+        }
+        return results;
+    }
+    async getAllDepsAndPackExtensions(extensionIdentifier, manifest, getOnlyNewlyAddedFromExtensionPack, installPreRelease, profile, productVersion) {
+        if (!this.galleryService.isEnabled()) {
+            return [];
+        }
+        const installed = await this.getInstalled(undefined, profile, productVersion);
+        const knownIdentifiers = [];
+        const allDependenciesAndPacks = [];
+        const collectDependenciesAndPackExtensionsToInstall = async (extensionIdentifier, manifest) => {
+            knownIdentifiers.push(extensionIdentifier);
+            const dependecies = manifest.extensionDependencies || [];
+            const dependenciesAndPackExtensions = [...dependecies];
+            if (manifest.extensionPack) {
+                const existing = getOnlyNewlyAddedFromExtensionPack ? installed.find(e => areSameExtensions(e.identifier, extensionIdentifier)) : undefined;
+                for (const extension of manifest.extensionPack) {
+                    if (!(existing && existing.manifest.extensionPack && ( existing.manifest.extensionPack.some(old => areSameExtensions({ id: old }, { id: extension }))))) {
+                        if (dependenciesAndPackExtensions.every(e => !areSameExtensions({ id: e }, { id: extension }))) {
+                            dependenciesAndPackExtensions.push(extension);
+                        }
+                    }
+                }
+            }
+            if (dependenciesAndPackExtensions.length) {
+                const ids = dependenciesAndPackExtensions.filter(id => knownIdentifiers.every(galleryIdentifier => !areSameExtensions(galleryIdentifier, { id })));
+                if (ids.length) {
+                    const galleryExtensions = await this.galleryService.getExtensions(( ids.map(id => ({ id, preRelease: installPreRelease }))), CancellationToken.None);
+                    for (const galleryExtension of galleryExtensions) {
+                        if (knownIdentifiers.find(identifier => areSameExtensions(identifier, galleryExtension.identifier))) {
+                            continue;
+                        }
+                        const isDependency = ( dependecies.some(id => areSameExtensions({ id }, galleryExtension.identifier)));
+                        let compatible;
+                        try {
+                            compatible = await this.checkAndGetCompatibleVersion(galleryExtension, false, installPreRelease, productVersion);
+                        }
+                        catch (error) {
+                            if (!isDependency) {
+                                this.logService.info('Skipping the packed extension as it cannot be installed', galleryExtension.identifier.id, getErrorMessage(error));
+                                continue;
+                            }
+                            else {
+                                throw error;
+                            }
+                        }
+                        allDependenciesAndPacks.push({ gallery: compatible.extension, manifest: compatible.manifest });
+                        await collectDependenciesAndPackExtensionsToInstall(compatible.extension.identifier, compatible.manifest);
+                    }
+                }
+            }
+        };
+        await collectDependenciesAndPackExtensionsToInstall(extensionIdentifier, manifest);
+        return allDependenciesAndPacks;
+    }
+    async checkAndGetCompatibleVersion(extension, sameVersion, installPreRelease, productVersion) {
+        let compatibleExtension;
+        const extensionsControlManifest = await this.getExtensionsControlManifest();
+        if (( extensionsControlManifest.malicious.some(identifier => areSameExtensions(extension.identifier, identifier)))) {
+            throw new ExtensionManagementError(localizeWithPath('vs/platform/extensionManagement/common/abstractExtensionManagementService', 'malicious extension', "Can't install '{0}' extension since it was reported to be problematic.", extension.identifier.id), ExtensionManagementErrorCode.Malicious);
+        }
+        const deprecationInfo = extensionsControlManifest.deprecated[extension.identifier.id.toLowerCase()];
+        if (deprecationInfo?.extension?.autoMigrate) {
+            this.logService.info(`The '${extension.identifier.id}' extension is deprecated, fetching the compatible '${deprecationInfo.extension.id}' extension instead.`);
+            compatibleExtension = (await this.galleryService.getExtensions([{ id: deprecationInfo.extension.id, preRelease: deprecationInfo.extension.preRelease }], { targetPlatform: await this.getTargetPlatform(), compatible: true, productVersion }, CancellationToken.None))[0];
+            if (!compatibleExtension) {
+                throw new ExtensionManagementError(localizeWithPath('vs/platform/extensionManagement/common/abstractExtensionManagementService', 'notFoundDeprecatedReplacementExtension', "Can't install '{0}' extension since it was deprecated and the replacement extension '{1}' can't be found.", extension.identifier.id, deprecationInfo.extension.id), ExtensionManagementErrorCode.Deprecated);
+            }
+        }
+        else {
+            if (!(await this.canInstall(extension))) {
+                const targetPlatform = await this.getTargetPlatform();
+                throw new ExtensionManagementError(localizeWithPath('vs/platform/extensionManagement/common/abstractExtensionManagementService', 'incompatible platform', "The '{0}' extension is not available in {1} for {2}.", extension.identifier.id, this.productService.nameLong, TargetPlatformToString(targetPlatform)), ExtensionManagementErrorCode.IncompatibleTargetPlatform);
+            }
+            compatibleExtension = await this.getCompatibleVersion(extension, sameVersion, installPreRelease, productVersion);
+            if (!compatibleExtension) {
+                if (!installPreRelease && extension.properties.isPreReleaseVersion && (await this.galleryService.getExtensions([extension.identifier], CancellationToken.None))[0]) {
+                    throw new ExtensionManagementError(localizeWithPath('vs/platform/extensionManagement/common/abstractExtensionManagementService', 'notFoundReleaseExtension', "Can't install release version of '{0}' extension because it has no release version.", extension.displayName ?? extension.identifier.id), ExtensionManagementErrorCode.ReleaseVersionNotFound);
+                }
+                throw new ExtensionManagementError(localizeWithPath('vs/platform/extensionManagement/common/abstractExtensionManagementService', 'notFoundCompatibleDependency', "Can't install '{0}' extension because it is not compatible with the current version of {1} (version {2}).", extension.identifier.id, this.productService.nameLong, this.productService.version), ExtensionManagementErrorCode.Incompatible);
+            }
+        }
+        this.logService.info('Getting Manifest...', compatibleExtension.identifier.id);
+        const manifest = await this.galleryService.getManifest(compatibleExtension, CancellationToken.None);
+        if (manifest === null) {
+            throw new ExtensionManagementError(`Missing manifest for extension ${compatibleExtension.identifier.id}`, ExtensionManagementErrorCode.Invalid);
+        }
+        if (manifest.version !== compatibleExtension.version) {
+            throw new ExtensionManagementError(`Cannot install '${compatibleExtension.identifier.id}' extension because of version mismatch in Marketplace`, ExtensionManagementErrorCode.Invalid);
+        }
+        return { extension: compatibleExtension, manifest };
+    }
+    async getCompatibleVersion(extension, sameVersion, includePreRelease, productVersion) {
+        const targetPlatform = await this.getTargetPlatform();
+        let compatibleExtension = null;
+        if (!sameVersion && extension.hasPreReleaseVersion && extension.properties.isPreReleaseVersion !== includePreRelease) {
+            compatibleExtension = (await this.galleryService.getExtensions([{ ...extension.identifier, preRelease: includePreRelease }], { targetPlatform, compatible: true, productVersion }, CancellationToken.None))[0] || null;
+        }
+        if (!compatibleExtension && (await this.galleryService.isExtensionCompatible(extension, includePreRelease, targetPlatform, productVersion))) {
+            compatibleExtension = extension;
+        }
+        if (!compatibleExtension) {
+            if (sameVersion) {
+                compatibleExtension = (await this.galleryService.getExtensions([{ ...extension.identifier, version: extension.version }], { targetPlatform, compatible: true, productVersion }, CancellationToken.None))[0] || null;
+            }
+            else {
+                compatibleExtension = await this.galleryService.getCompatibleExtension(extension, includePreRelease, targetPlatform, productVersion);
+            }
+        }
+        return compatibleExtension;
+    }
+    async uninstallExtension(extension, options) {
+        const uninstallOptions = {
+            ...options,
+            profileLocation: extension.isApplicationScoped ? this.userDataProfilesService.defaultProfile.extensionsResource : options.profileLocation ?? this.getCurrentExtensionsManifestLocation()
+        };
+        const getUninstallExtensionTaskKey = (identifier) => `${identifier.id.toLowerCase()}${uninstallOptions.versionOnly ? `-${extension.manifest.version}` : ''}${uninstallOptions.profileLocation ? `@${( uninstallOptions.profileLocation.toString())}` : ''}`;
+        const uninstallExtensionTask = this.uninstallingExtensions.get(getUninstallExtensionTaskKey(extension.identifier));
+        if (uninstallExtensionTask) {
+            this.logService.info('Extensions is already requested to uninstall', extension.identifier.id);
+            return uninstallExtensionTask.waitUntilTaskIsFinished();
+        }
+        const createUninstallExtensionTask = (extension) => {
+            const uninstallExtensionTask = this.createUninstallExtensionTask(extension, uninstallOptions);
+            this.uninstallingExtensions.set(getUninstallExtensionTaskKey(uninstallExtensionTask.extension.identifier), uninstallExtensionTask);
+            if (uninstallOptions.profileLocation) {
+                this.logService.info('Uninstalling extension from the profile:', `${extension.identifier.id}@${extension.manifest.version}`, ( uninstallOptions.profileLocation.toString()));
+            }
+            else {
+                this.logService.info('Uninstalling extension:', `${extension.identifier.id}@${extension.manifest.version}`);
+            }
+            this._onUninstallExtension.fire({ identifier: extension.identifier, profileLocation: uninstallOptions.profileLocation, applicationScoped: extension.isApplicationScoped });
+            return uninstallExtensionTask;
+        };
+        const postUninstallExtension = (extension, error) => {
+            if (error) {
+                if (uninstallOptions.profileLocation) {
+                    this.logService.error('Failed to uninstall extension from the profile:', `${extension.identifier.id}@${extension.manifest.version}`, ( uninstallOptions.profileLocation.toString()), error.message);
+                }
+                else {
+                    this.logService.error('Failed to uninstall extension:', `${extension.identifier.id}@${extension.manifest.version}`, error.message);
+                }
+            }
+            else {
+                if (uninstallOptions.profileLocation) {
+                    this.logService.info('Successfully uninstalled extension from the profile', `${extension.identifier.id}@${extension.manifest.version}`, ( uninstallOptions.profileLocation.toString()));
+                }
+                else {
+                    this.logService.info('Successfully uninstalled extension:', `${extension.identifier.id}@${extension.manifest.version}`);
+                }
+            }
+            reportTelemetry(this.telemetryService, 'extensionGallery:uninstall', { extensionData: getLocalExtensionTelemetryData(extension), error });
+            this._onDidUninstallExtension.fire({ identifier: extension.identifier, error: error?.code, profileLocation: uninstallOptions.profileLocation, applicationScoped: extension.isApplicationScoped });
+        };
+        const allTasks = [];
+        const processedTasks = [];
+        try {
+            allTasks.push(createUninstallExtensionTask(extension));
+            const installed = await this.getInstalled(1 , uninstallOptions.profileLocation);
+            if (uninstallOptions.donotIncludePack) {
+                this.logService.info('Uninstalling the extension without including packed extension', `${extension.identifier.id}@${extension.manifest.version}`);
+            }
+            else {
+                const packedExtensions = this.getAllPackExtensionsToUninstall(extension, installed);
+                for (const packedExtension of packedExtensions) {
+                    if (( this.uninstallingExtensions.has(getUninstallExtensionTaskKey(packedExtension.identifier)))) {
+                        this.logService.info('Extensions is already requested to uninstall', packedExtension.identifier.id);
+                    }
+                    else {
+                        allTasks.push(createUninstallExtensionTask(packedExtension));
+                    }
+                }
+            }
+            if (uninstallOptions.donotCheckDependents) {
+                this.logService.info('Uninstalling the extension without checking dependents', `${extension.identifier.id}@${extension.manifest.version}`);
+            }
+            else {
+                this.checkForDependents(( allTasks.map(task => task.extension)), installed, extension);
+            }
+            await this.joinAllSettled(( allTasks.map(async (task) => {
+                try {
+                    await task.run();
+                    await this.joinAllSettled(( this.participants.map(
+                        participant => participant.postUninstall(task.extension, uninstallOptions, CancellationToken.None)
+                    )));
+                    if (task.extension.identifier.uuid) {
+                        try {
+                            await this.galleryService.reportStatistic(task.extension.manifest.publisher, task.extension.manifest.name, task.extension.manifest.version, "uninstall" );
+                        }
+                        catch (error) {  }
+                    }
+                    postUninstallExtension(task.extension);
+                }
+                catch (e) {
+                    const error = e instanceof ExtensionManagementError ? e : ( new ExtensionManagementError(getErrorMessage(e), ExtensionManagementErrorCode.Internal));
+                    postUninstallExtension(task.extension, error);
+                    throw error;
+                }
+                finally {
+                    processedTasks.push(task);
+                }
+            })));
+        }
+        catch (e) {
+            const error = e instanceof ExtensionManagementError ? e : ( new ExtensionManagementError(getErrorMessage(e), ExtensionManagementErrorCode.Internal));
+            for (const task of allTasks) {
+                try {
+                    task.cancel();
+                }
+                catch (error) {  }
+                if (!processedTasks.includes(task)) {
+                    postUninstallExtension(task.extension, error);
+                }
+            }
+            throw error;
+        }
+        finally {
+            for (const task of allTasks) {
+                if (!this.uninstallingExtensions.delete(getUninstallExtensionTaskKey(task.extension.identifier))) {
+                    this.logService.warn('Uninstallation task is not found in the cache', task.extension.identifier.id);
+                }
+            }
+        }
+    }
+    checkForDependents(extensionsToUninstall, installed, extensionToUninstall) {
+        for (const extension of extensionsToUninstall) {
+            const dependents = this.getDependents(extension, installed);
+            if (dependents.length) {
+                const remainingDependents = dependents.filter(dependent => !( extensionsToUninstall.some(e => areSameExtensions(e.identifier, dependent.identifier))));
+                if (remainingDependents.length) {
+                    throw new Error(this.getDependentsErrorMessage(extension, remainingDependents, extensionToUninstall));
+                }
+            }
+        }
+    }
+    getDependentsErrorMessage(dependingExtension, dependents, extensionToUninstall) {
+        if (extensionToUninstall === dependingExtension) {
+            if (dependents.length === 1) {
+                return ( localizeWithPath(
+                    'vs/platform/extensionManagement/common/abstractExtensionManagementService',
+                    'singleDependentError',
+                    "Cannot uninstall '{0}' extension. '{1}' extension depends on this.",
+                    extensionToUninstall.manifest.displayName || extensionToUninstall.manifest.name,
+                    dependents[0].manifest.displayName || dependents[0].manifest.name
+                ));
+            }
+            if (dependents.length === 2) {
+                return ( localizeWithPath(
+                    'vs/platform/extensionManagement/common/abstractExtensionManagementService',
+                    'twoDependentsError',
+                    "Cannot uninstall '{0}' extension. '{1}' and '{2}' extensions depend on this.",
+                    extensionToUninstall.manifest.displayName || extensionToUninstall.manifest.name,
+                    dependents[0].manifest.displayName || dependents[0].manifest.name,
+                    dependents[1].manifest.displayName || dependents[1].manifest.name
+                ));
+            }
+            return ( localizeWithPath(
+                'vs/platform/extensionManagement/common/abstractExtensionManagementService',
+                'multipleDependentsError',
+                "Cannot uninstall '{0}' extension. '{1}', '{2}' and other extension depend on this.",
+                extensionToUninstall.manifest.displayName || extensionToUninstall.manifest.name,
+                dependents[0].manifest.displayName || dependents[0].manifest.name,
+                dependents[1].manifest.displayName || dependents[1].manifest.name
+            ));
+        }
+        if (dependents.length === 1) {
+            return ( localizeWithPath(
+                'vs/platform/extensionManagement/common/abstractExtensionManagementService',
+                'singleIndirectDependentError',
+                "Cannot uninstall '{0}' extension . It includes uninstalling '{1}' extension and '{2}' extension depends on this.",
+                extensionToUninstall.manifest.displayName || extensionToUninstall.manifest.name,
+                dependingExtension.manifest.displayName
+                    || dependingExtension.manifest.name,
+                dependents[0].manifest.displayName || dependents[0].manifest.name
+            ));
+        }
+        if (dependents.length === 2) {
+            return ( localizeWithPath(
+                'vs/platform/extensionManagement/common/abstractExtensionManagementService',
+                'twoIndirectDependentsError',
+                "Cannot uninstall '{0}' extension. It includes uninstalling '{1}' extension and '{2}' and '{3}' extensions depend on this.",
+                extensionToUninstall.manifest.displayName || extensionToUninstall.manifest.name,
+                dependingExtension.manifest.displayName
+                    || dependingExtension.manifest.name,
+                dependents[0].manifest.displayName || dependents[0].manifest.name,
+                dependents[1].manifest.displayName || dependents[1].manifest.name
+            ));
+        }
+        return ( localizeWithPath(
+            'vs/platform/extensionManagement/common/abstractExtensionManagementService',
+            'multipleIndirectDependentsError',
+            "Cannot uninstall '{0}' extension. It includes uninstalling '{1}' extension and '{2}', '{3}' and other extensions depend on this.",
+            extensionToUninstall.manifest.displayName || extensionToUninstall.manifest.name,
+            dependingExtension.manifest.displayName
+                || dependingExtension.manifest.name,
+            dependents[0].manifest.displayName || dependents[0].manifest.name,
+            dependents[1].manifest.displayName || dependents[1].manifest.name
+        ));
+    }
+    getAllPackExtensionsToUninstall(extension, installed, checked = []) {
+        if (checked.indexOf(extension) !== -1) {
+            return [];
+        }
+        checked.push(extension);
+        const extensionsPack = extension.manifest.extensionPack ? extension.manifest.extensionPack : [];
+        if (extensionsPack.length) {
+            const packedExtensions = installed.filter(i => !i.isBuiltin && ( extensionsPack.some(id => areSameExtensions({ id }, i.identifier))));
+            const packOfPackedExtensions = [];
+            for (const packedExtension of packedExtensions) {
+                packOfPackedExtensions.push(...this.getAllPackExtensionsToUninstall(packedExtension, installed, checked));
+            }
+            return [...packedExtensions, ...packOfPackedExtensions];
+        }
+        return [];
+    }
+    getDependents(extension, installed) {
+        return installed.filter(e => e.manifest.extensionDependencies && ( e.manifest.extensionDependencies.some(id => areSameExtensions({ id }, extension.identifier))));
+    }
+    async updateControlCache() {
+        try {
+            this.logService.trace('ExtensionManagementService.updateControlCache');
+            return await this.galleryService.getExtensionsControlManifest();
+        }
+        catch (err) {
+            this.logService.trace('ExtensionManagementService.refreshControlCache - failed to get extension control manifest', getErrorMessage(err));
+            return { malicious: [], deprecated: {}, search: [] };
+        }
+    }
+};
+AbstractExtensionManagementService = ( __decorate([
+    ( __param(0, IExtensionGalleryService)),
+    ( __param(1, ITelemetryService)),
+    ( __param(2, IUriIdentityService)),
+    ( __param(3, ILogService)),
+    ( __param(4, IProductService)),
+    ( __param(5, IUserDataProfilesService))
+], AbstractExtensionManagementService));
+function joinErrors(errorOrErrors) {
+    const errors = Array.isArray(errorOrErrors) ? errorOrErrors : [errorOrErrors];
+    if (errors.length === 1) {
+        return errors[0] instanceof Error ? errors[0] : ( new Error(errors[0]));
+    }
+    return errors.reduce((previousValue, currentValue) => {
+        return ( new Error(
+            `${previousValue.message}${previousValue.message ? ',' : ''}${currentValue instanceof Error ? currentValue.message : currentValue}`
+        ));
+    }, ( new Error('')));
+}
+function toExtensionManagementError(error) {
+    if (error instanceof ExtensionManagementError) {
+        return error;
+    }
+    if (error instanceof ExtensionGalleryError) {
+        const e = ( new ExtensionManagementError(error.message, ExtensionManagementErrorCode.Gallery));
+        e.stack = error.stack;
+        return e;
+    }
+    const e = ( new ExtensionManagementError(error.message, ExtensionManagementErrorCode.Internal));
+    e.stack = error.stack;
+    return e;
+}
+function reportTelemetry(telemetryService, eventName, { extensionData, verificationStatus, duration, error, durationSinceUpdate }) {
+    let errorcode;
+    let errorcodeDetail;
+    if (isDefined(verificationStatus)) {
+        if (verificationStatus === true) {
+            verificationStatus = 'Verified';
+        }
+        else if (verificationStatus === false) {
+            verificationStatus = 'Unverified';
+        }
+        else {
+            errorcode = ExtensionManagementErrorCode.Signature;
+            errorcodeDetail = verificationStatus;
+            verificationStatus = 'Unverified';
+        }
+    }
+    if (error) {
+        if (error instanceof ExtensionManagementError || error instanceof ExtensionGalleryError) {
+            errorcode = error.code;
+            if (error.code === ExtensionManagementErrorCode.Signature) {
+                errorcodeDetail = error.message;
+            }
+        }
+        else {
+            errorcode = ExtensionManagementErrorCode.Internal;
+        }
+    }
+    telemetryService.publicLog(eventName, { ...extensionData, verificationStatus, success: !error, duration, errorcode, errorcodeDetail, durationSinceUpdate });
+}
+class AbstractExtensionTask {
+    constructor() {
+        this.barrier = ( new Barrier());
+    }
+    async waitUntilTaskIsFinished() {
+        await this.barrier.wait();
+        return this.cancellablePromise;
+    }
+    async run() {
+        if (!this.cancellablePromise) {
+            this.cancellablePromise = createCancelablePromise(token => this.doRun(token));
+        }
+        this.barrier.open();
+        return this.cancellablePromise;
+    }
+    cancel() {
+        if (!this.cancellablePromise) {
+            this.cancellablePromise = createCancelablePromise(token => {
+                return ( new Promise((c, e) => {
+                    const disposable = token.onCancellationRequested(() => {
+                        disposable.dispose();
+                        e(( new CancellationError()));
+                    });
+                }));
+            });
+            this.barrier.open();
+        }
+        this.cancellablePromise.cancel();
+    }
+}
+export { AbstractExtensionManagementService, AbstractExtensionTask, joinErrors, toExtensionManagementError };