@codingame/monaco-vscode-api 4.0.0 → 4.1.0

package/vscode/src/vs/workbench/contrib/extensions/browser/extensionsWidgets.js

@@ -0,0 +1,858 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import './media/extensionsWidgets.css.js';
+import { semverExports } from '../../../../../../../external/vscode-semver/semver.js';
+import { Disposable, DisposableStore, MutableDisposable, toDisposable } from '../../../../base/common/lifecycle.js';
+import { IExtensionsWorkbenchService } from '../common/extensions.js';
+import { addDisposableListener, finalHandler, EventType, append, $, reset } from '../../../../base/browser/dom.js';
+import { language } from '../../../../base/common/platform.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { IExtensionManagementServerService } from '../../../services/extensionManagement/common/extensionManagement.js';
+import { IExtensionRecommendationsService, IExtensionIgnoredRecommendationsService } from '../../../services/extensionRecommendations/common/extensionRecommendations.js';
+import { ILabelService } from '../../../../platform/label/common/label.js';
+import { extensionButtonProminentBackground } from './extensionsActions.js';
+import { registerThemingParticipant, IThemeService } from '../../../../platform/theme/common/themeService.js';
+import { ThemeIcon } from '../../../../base/common/themables.js';
+import { EXTENSION_BADGE_REMOTE_BACKGROUND, EXTENSION_BADGE_REMOTE_FOREGROUND } from '../../../common/theme.js';
+import { Emitter, Event } from '../../../../base/common/event.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { CountBadge } from '../../../../base/browser/ui/countBadge/countBadge.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { IUserDataSyncEnablementService } from '../../../../platform/userDataSync/common/userDataSync.js';
+import { installCountIcon, starFullIcon, starHalfIcon, starEmptyIcon, verifiedPublisherIcon, sponsorIcon, remoteIcon, ratingIcon, preReleaseIcon, syncIgnoredIcon, activationTimeIcon, errorIcon, warningIcon, infoIcon } from './extensionsIcons.js';
+import { registerColor } from '../../../../platform/theme/common/colorUtils.js';
+import { textLinkForeground } from '../../../../platform/theme/common/colors/baseColors.js';
+import '../../../../platform/theme/common/colors/chartsColors.js';
+import '../../../../platform/theme/common/colors/editorColors.js';
+import '../../../../platform/theme/common/colors/inputColors.js';
+import '../../../../platform/theme/common/colors/listColors.js';
+import '../../../../platform/theme/common/colors/menuColors.js';
+import '../../../../platform/theme/common/colors/minimapColors.js';
+import '../../../../platform/theme/common/colors/miscColors.js';
+import '../../../../platform/theme/common/colors/quickpickColors.js';
+import '../../../../platform/theme/common/colors/searchColors.js';
+import { IHoverService } from '../../../../platform/hover/browser/hover.js';
+import { MarkdownString } from '../../../../base/common/htmlContent.js';
+import { URI } from '../../../../base/common/uri.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.js';
+import { areSameExtensions } from '../../../../platform/extensionManagement/common/extensionManagementUtil.js';
+import Severity$1 from '../../../../base/common/severity.js';
+import { setupCustomHover } from '../../../../base/browser/ui/hover/updatableHoverWidget.js';
+import { Color } from '../../../../base/common/color.js';
+import { renderMarkdown } from '../../../../base/browser/markdownRenderer.js';
+import { IOpenerService } from '../../../../platform/opener/common/opener.js';
+import { onUnexpectedError } from '../../../../base/common/errors.js';
+import { renderIcon } from '../../../../base/browser/ui/iconLabel/iconLabels.js';
+import { StandardKeyboardEvent } from '../../../../base/browser/keyboardEvent.js';
+import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
+import { defaultCountBadgeStyles } from '../../../../platform/theme/browser/defaultStyles.js';
+import { getDefaultHoverDelegate } from '../../../../base/browser/ui/hover/hoverDelegateFactory.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
+var ExtensionHoverWidget_1;
+class ExtensionWidget extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._extension = null;
+    }
+    get extension() { return this._extension; }
+    set extension(extension) { this._extension = extension; this.update(); }
+    update() { this.render(); }
+}
+function onClick(element, callback) {
+    const disposables = ( new DisposableStore());
+    disposables.add(addDisposableListener(element, EventType.CLICK, finalHandler(callback)));
+    disposables.add(addDisposableListener(element, EventType.KEY_UP, e => {
+        const keyboardEvent = ( new StandardKeyboardEvent(e));
+        if (keyboardEvent.equals(10 ) || keyboardEvent.equals(3 )) {
+            e.preventDefault();
+            e.stopPropagation();
+            callback();
+        }
+    }));
+    return disposables;
+}
+class InstallCountWidget extends ExtensionWidget {
+    constructor(container, small) {
+        super();
+        this.container = container;
+        this.small = small;
+        container.classList.add('extension-install-count');
+        this.render();
+    }
+    render() {
+        this.container.innerText = '';
+        if (!this.extension) {
+            return;
+        }
+        if (this.small && this.extension.state !== 3 ) {
+            return;
+        }
+        const installLabel = InstallCountWidget.getInstallLabel(this.extension, this.small);
+        if (!installLabel) {
+            return;
+        }
+        append(this.container, $('span' + ThemeIcon.asCSSSelector(installCountIcon)));
+        const count = append(this.container, $('span.count'));
+        count.textContent = installLabel;
+    }
+    static getInstallLabel(extension, small) {
+        const installCount = extension.installCount;
+        if (installCount === undefined) {
+            return undefined;
+        }
+        let installLabel;
+        if (small) {
+            if (installCount > 1000000) {
+                installLabel = `${Math.floor(installCount / 100000) / 10}M`;
+            }
+            else if (installCount > 1000) {
+                installLabel = `${Math.floor(installCount / 1000)}K`;
+            }
+            else {
+                installLabel = String(installCount);
+            }
+        }
+        else {
+            installLabel = installCount.toLocaleString(language);
+        }
+        return installLabel;
+    }
+}
+class RatingsWidget extends ExtensionWidget {
+    constructor(container, small) {
+        super();
+        this.container = container;
+        this.small = small;
+        container.classList.add('extension-ratings');
+        if (this.small) {
+            container.classList.add('small');
+        }
+        this.containerHover = this._register(setupCustomHover(getDefaultHoverDelegate('mouse'), container, ''));
+        this.render();
+    }
+    render() {
+        this.container.innerText = '';
+        if (!this.extension) {
+            return;
+        }
+        if (this.small && this.extension.state !== 3 ) {
+            return;
+        }
+        if (this.extension.rating === undefined) {
+            return;
+        }
+        if (this.small && !this.extension.ratingCount) {
+            return;
+        }
+        const rating = Math.round(this.extension.rating * 2) / 2;
+        this.containerHover.update(( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionsWidgets',
+            'ratedLabel',
+            "Average rating: {0} out of 5",
+            rating
+        )));
+        if (this.small) {
+            append(this.container, $('span' + ThemeIcon.asCSSSelector(starFullIcon)));
+            const count = append(this.container, $('span.count'));
+            count.textContent = String(rating);
+        }
+        else {
+            for (let i = 1; i <= 5; i++) {
+                if (rating >= i) {
+                    append(this.container, $('span' + ThemeIcon.asCSSSelector(starFullIcon)));
+                }
+                else if (rating >= i - 0.5) {
+                    append(this.container, $('span' + ThemeIcon.asCSSSelector(starHalfIcon)));
+                }
+                else {
+                    append(this.container, $('span' + ThemeIcon.asCSSSelector(starEmptyIcon)));
+                }
+            }
+            if (this.extension.ratingCount) {
+                const ratingCountElemet = append(this.container, $('span', undefined, ` (${this.extension.ratingCount})`));
+                ratingCountElemet.style.paddingLeft = '1px';
+            }
+        }
+    }
+}
+let VerifiedPublisherWidget = class VerifiedPublisherWidget extends ExtensionWidget {
+    constructor(container, small, openerService) {
+        super();
+        this.container = container;
+        this.small = small;
+        this.openerService = openerService;
+        this.disposables = this._register(( new DisposableStore()));
+        this.containerHover = this._register(setupCustomHover(getDefaultHoverDelegate('mouse'), container, ''));
+        this.render();
+    }
+    render() {
+        reset(this.container);
+        this.disposables.clear();
+        if (!this.extension?.publisherDomain?.verified) {
+            return;
+        }
+        if (this.extension.resourceExtension) {
+            return;
+        }
+        if (this.extension.local?.source === 'resource') {
+            return;
+        }
+        const publisherDomainLink = ( URI.parse(this.extension.publisherDomain.link));
+        const verifiedPublisher = append(this.container, $('span.extension-verified-publisher.clickable'));
+        append(verifiedPublisher, renderIcon(verifiedPublisherIcon));
+        if (!this.small) {
+            verifiedPublisher.tabIndex = 0;
+            this.containerHover.update(`Verified Domain: ${this.extension.publisherDomain.link}`);
+            verifiedPublisher.setAttribute('role', 'link');
+            append(verifiedPublisher, $('span.extension-verified-publisher-domain', undefined, publisherDomainLink.authority.startsWith('www.') ? publisherDomainLink.authority.substring(4) : publisherDomainLink.authority));
+            this.disposables.add(onClick(verifiedPublisher, () => this.openerService.open(publisherDomainLink)));
+        }
+    }
+};
+VerifiedPublisherWidget = ( __decorate([
+    ( __param(2, IOpenerService))
+], VerifiedPublisherWidget));
+let SponsorWidget = class SponsorWidget extends ExtensionWidget {
+    constructor(container, openerService, telemetryService) {
+        super();
+        this.container = container;
+        this.openerService = openerService;
+        this.telemetryService = telemetryService;
+        this.disposables = this._register(( new DisposableStore()));
+        this.render();
+    }
+    render() {
+        reset(this.container);
+        this.disposables.clear();
+        if (!this.extension?.publisherSponsorLink) {
+            return;
+        }
+        const sponsor = append(this.container, $('span.sponsor.clickable', { tabIndex: 0 }));
+        this.disposables.add(setupCustomHover(getDefaultHoverDelegate('mouse'), sponsor, this.extension?.publisherSponsorLink.toString() ?? ''));
+        sponsor.setAttribute('role', 'link');
+        const sponsorIconElement = renderIcon(sponsorIcon);
+        const label = $('span', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionsWidgets',
+            'sponsor',
+            "Sponsor"
+        )));
+        append(sponsor, sponsorIconElement, label);
+        this.disposables.add(onClick(sponsor, () => {
+            this.telemetryService.publicLog2('extensionsAction.sponsorExtension', { extensionId: this.extension.identifier.id });
+            this.openerService.open(this.extension.publisherSponsorLink);
+        }));
+    }
+};
+SponsorWidget = ( __decorate([
+    ( __param(1, IOpenerService)),
+    ( __param(2, ITelemetryService))
+], SponsorWidget));
+let RecommendationWidget = class RecommendationWidget extends ExtensionWidget {
+    constructor(parent, extensionRecommendationsService) {
+        super();
+        this.parent = parent;
+        this.extensionRecommendationsService = extensionRecommendationsService;
+        this.disposables = this._register(( new DisposableStore()));
+        this.render();
+        this._register(toDisposable(() => this.clear()));
+        this._register(this.extensionRecommendationsService.onDidChangeRecommendations(() => this.render()));
+    }
+    clear() {
+        if (this.element) {
+            this.parent.removeChild(this.element);
+        }
+        this.element = undefined;
+        this.disposables.clear();
+    }
+    render() {
+        this.clear();
+        if (!this.extension || this.extension.state === 1  || this.extension.deprecationInfo) {
+            return;
+        }
+        const extRecommendations = this.extensionRecommendationsService.getAllRecommendationsWithReason();
+        if (extRecommendations[this.extension.identifier.id.toLowerCase()]) {
+            this.element = append(this.parent, $('div.extension-bookmark'));
+            const recommendation = append(this.element, $('.recommendation'));
+            append(recommendation, $('span' + ThemeIcon.asCSSSelector(ratingIcon)));
+        }
+    }
+};
+RecommendationWidget = ( __decorate([
+    ( __param(1, IExtensionRecommendationsService))
+], RecommendationWidget));
+class PreReleaseBookmarkWidget extends ExtensionWidget {
+    constructor(parent) {
+        super();
+        this.parent = parent;
+        this.disposables = this._register(( new DisposableStore()));
+        this.render();
+        this._register(toDisposable(() => this.clear()));
+    }
+    clear() {
+        if (this.element) {
+            this.parent.removeChild(this.element);
+        }
+        this.element = undefined;
+        this.disposables.clear();
+    }
+    render() {
+        this.clear();
+        if (this.extension?.state === 1  ? this.extension.preRelease : this.extension?.hasPreReleaseVersion) {
+            this.element = append(this.parent, $('div.extension-bookmark'));
+            const preRelease = append(this.element, $('.pre-release'));
+            append(preRelease, $('span' + ThemeIcon.asCSSSelector(preReleaseIcon)));
+        }
+    }
+}
+let RemoteBadgeWidget = class RemoteBadgeWidget extends ExtensionWidget {
+    constructor(parent, tooltip, extensionManagementServerService, instantiationService) {
+        super();
+        this.tooltip = tooltip;
+        this.extensionManagementServerService = extensionManagementServerService;
+        this.instantiationService = instantiationService;
+        this.remoteBadge = this._register(( new MutableDisposable()));
+        this.element = append(parent, $('.extension-remote-badge-container'));
+        this.render();
+        this._register(toDisposable(() => this.clear()));
+    }
+    clear() {
+        if (this.remoteBadge.value) {
+            this.element.removeChild(this.remoteBadge.value.element);
+        }
+        this.remoteBadge.clear();
+    }
+    render() {
+        this.clear();
+        if (!this.extension || !this.extension.local || !this.extension.server || !(this.extensionManagementServerService.localExtensionManagementServer && this.extensionManagementServerService.remoteExtensionManagementServer) || this.extension.server !== this.extensionManagementServerService.remoteExtensionManagementServer) {
+            return;
+        }
+        this.remoteBadge.value = this.instantiationService.createInstance(RemoteBadge, this.tooltip);
+        append(this.element, this.remoteBadge.value.element);
+    }
+};
+RemoteBadgeWidget = ( __decorate([
+    ( __param(2, IExtensionManagementServerService)),
+    ( __param(3, IInstantiationService))
+], RemoteBadgeWidget));
+let RemoteBadge = class RemoteBadge extends Disposable {
+    constructor(tooltip, labelService, themeService, extensionManagementServerService) {
+        super();
+        this.tooltip = tooltip;
+        this.labelService = labelService;
+        this.themeService = themeService;
+        this.extensionManagementServerService = extensionManagementServerService;
+        this.element = $('div.extension-badge.extension-remote-badge');
+        this.elementHover = this._register(setupCustomHover(getDefaultHoverDelegate('mouse'), this.element, ''));
+        this.render();
+    }
+    render() {
+        append(this.element, $('span' + ThemeIcon.asCSSSelector(remoteIcon)));
+        const applyBadgeStyle = () => {
+            if (!this.element) {
+                return;
+            }
+            const bgColor = this.themeService.getColorTheme().getColor(EXTENSION_BADGE_REMOTE_BACKGROUND);
+            const fgColor = this.themeService.getColorTheme().getColor(EXTENSION_BADGE_REMOTE_FOREGROUND);
+            this.element.style.backgroundColor = bgColor ? ( bgColor.toString()) : '';
+            this.element.style.color = fgColor ? ( fgColor.toString()) : '';
+        };
+        applyBadgeStyle();
+        this._register(this.themeService.onDidColorThemeChange(() => applyBadgeStyle()));
+        if (this.tooltip) {
+            const updateTitle = () => {
+                if (this.element && this.extensionManagementServerService.remoteExtensionManagementServer) {
+                    this.elementHover.update(( localizeWithPath(
+                        'vs/workbench/contrib/extensions/browser/extensionsWidgets',
+                        'remote extension title',
+                        "Extension in {0}",
+                        this.extensionManagementServerService.remoteExtensionManagementServer.label
+                    )));
+                }
+            };
+            this._register(this.labelService.onDidChangeFormatters(() => updateTitle()));
+            updateTitle();
+        }
+    }
+};
+RemoteBadge = ( __decorate([
+    ( __param(1, ILabelService)),
+    ( __param(2, IThemeService)),
+    ( __param(3, IExtensionManagementServerService))
+], RemoteBadge));
+class ExtensionPackCountWidget extends ExtensionWidget {
+    constructor(parent) {
+        super();
+        this.parent = parent;
+        this.render();
+        this._register(toDisposable(() => this.clear()));
+    }
+    clear() {
+        this.element?.remove();
+    }
+    render() {
+        this.clear();
+        if (!this.extension || !(this.extension.categories?.some(category => category.toLowerCase() === 'extension packs')) || !this.extension.extensionPack.length) {
+            return;
+        }
+        this.element = append(this.parent, $('.extension-badge.extension-pack-badge'));
+        const countBadge = ( new CountBadge(this.element, {}, defaultCountBadgeStyles));
+        countBadge.setCount(this.extension.extensionPack.length);
+    }
+}
+let SyncIgnoredWidget = class SyncIgnoredWidget extends ExtensionWidget {
+    constructor(container, configurationService, extensionsWorkbenchService, userDataSyncEnablementService) {
+        super();
+        this.container = container;
+        this.configurationService = configurationService;
+        this.extensionsWorkbenchService = extensionsWorkbenchService;
+        this.userDataSyncEnablementService = userDataSyncEnablementService;
+        this.disposables = this._register(( new DisposableStore()));
+        this._register(Event.filter(this.configurationService.onDidChangeConfiguration, e => e.affectsConfiguration('settingsSync.ignoredExtensions'))(() => this.render()));
+        this._register(userDataSyncEnablementService.onDidChangeEnablement(() => this.update()));
+        this.render();
+    }
+    render() {
+        this.disposables.clear();
+        this.container.innerText = '';
+        if (this.extension && this.extension.state === 1  && this.userDataSyncEnablementService.isEnabled() && this.extensionsWorkbenchService.isExtensionIgnoredToSync(this.extension)) {
+            const element = append(this.container, $('span.extension-sync-ignored' + ThemeIcon.asCSSSelector(syncIgnoredIcon)));
+            this.disposables.add(setupCustomHover(getDefaultHoverDelegate('mouse'), element, ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionsWidgets',
+                'syncingore.label',
+                "This extension is ignored during sync."
+            ))));
+            element.classList.add(...ThemeIcon.asClassNameArray(syncIgnoredIcon));
+        }
+    }
+};
+SyncIgnoredWidget = ( __decorate([
+    ( __param(1, IConfigurationService)),
+    ( __param(2, IExtensionsWorkbenchService)),
+    ( __param(3, IUserDataSyncEnablementService))
+], SyncIgnoredWidget));
+let ExtensionActivationStatusWidget = class ExtensionActivationStatusWidget extends ExtensionWidget {
+    constructor(container, small, extensionService, extensionsWorkbenchService) {
+        super();
+        this.container = container;
+        this.small = small;
+        this.extensionsWorkbenchService = extensionsWorkbenchService;
+        this._register(extensionService.onDidChangeExtensionsStatus(extensions => {
+            if (this.extension && ( extensions.some(e => areSameExtensions({ id: e.value }, this.extension.identifier)))) {
+                this.update();
+            }
+        }));
+    }
+    render() {
+        this.container.innerText = '';
+        if (!this.extension) {
+            return;
+        }
+        const extensionStatus = this.extensionsWorkbenchService.getExtensionStatus(this.extension);
+        if (!extensionStatus || !extensionStatus.activationTimes) {
+            return;
+        }
+        const activationTime = extensionStatus.activationTimes.codeLoadingTime + extensionStatus.activationTimes.activateCallTime;
+        if (this.small) {
+            append(this.container, $('span' + ThemeIcon.asCSSSelector(activationTimeIcon)));
+            const activationTimeElement = append(this.container, $('span.activationTime'));
+            activationTimeElement.textContent = `${activationTime}ms`;
+        }
+        else {
+            const activationTimeElement = append(this.container, $('span.activationTime'));
+            activationTimeElement.textContent = `${( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionsWidgets',
+                'activation',
+                "Activation time"
+            ))}${extensionStatus.activationTimes.activationReason.startup ? ` (${( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionsWidgets',
+                'startup',
+                "Startup"
+            ))})` : ''} : ${activationTime}ms`;
+        }
+    }
+};
+ExtensionActivationStatusWidget = ( __decorate([
+    ( __param(2, IExtensionService)),
+    ( __param(3, IExtensionsWorkbenchService))
+], ExtensionActivationStatusWidget));
+let ExtensionHoverWidget = ExtensionHoverWidget_1 = class ExtensionHoverWidget extends ExtensionWidget {
+    constructor(options, extensionStatusAction, extensionsWorkbenchService, hoverService, configurationService, extensionRecommendationsService, themeService, contextService) {
+        super();
+        this.options = options;
+        this.extensionStatusAction = extensionStatusAction;
+        this.extensionsWorkbenchService = extensionsWorkbenchService;
+        this.hoverService = hoverService;
+        this.configurationService = configurationService;
+        this.extensionRecommendationsService = extensionRecommendationsService;
+        this.themeService = themeService;
+        this.contextService = contextService;
+        this.hover = this._register(( new MutableDisposable()));
+    }
+    render() {
+        this.hover.value = undefined;
+        if (this.extension) {
+            this.hover.value = setupCustomHover({
+                delay: this.configurationService.getValue('workbench.hover.delay'),
+                showHover: (options) => {
+                    return this.hoverService.showHover({
+                        ...options,
+                        additionalClasses: ['extension-hover'],
+                        position: {
+                            hoverPosition: this.options.position(),
+                            forcePosition: true,
+                        },
+                    });
+                },
+                placement: 'element'
+            }, this.options.target, { markdown: () => Promise.resolve(this.getHoverMarkdown()), markdownNotSupportedFallback: undefined });
+        }
+    }
+    getHoverMarkdown() {
+        if (!this.extension) {
+            return undefined;
+        }
+        const markdown = ( new MarkdownString('', { isTrusted: true, supportThemeIcons: true }));
+        markdown.appendMarkdown(`**${this.extension.displayName}**`);
+        if (semverExports.valid(this.extension.version)) {
+            markdown.appendMarkdown(`&nbsp;<span style="background-color:#8080802B;">**&nbsp;_v${this.extension.version}${(this.extension.isPreReleaseVersion ? ' (pre-release)' : '')}_**&nbsp;</span>`);
+        }
+        markdown.appendText(`\n`);
+        if (this.extension.state === 1 ) {
+            let addSeparator = false;
+            const installLabel = InstallCountWidget.getInstallLabel(this.extension, true);
+            if (installLabel) {
+                if (addSeparator) {
+                    markdown.appendText(`  |  `);
+                }
+                markdown.appendMarkdown(`$(${installCountIcon.id}) ${installLabel}`);
+                addSeparator = true;
+            }
+            if (this.extension.rating) {
+                if (addSeparator) {
+                    markdown.appendText(`  |  `);
+                }
+                const rating = Math.round(this.extension.rating * 2) / 2;
+                markdown.appendMarkdown(`$(${starFullIcon.id}) [${rating}](${this.extension.url}&ssr=false#review-details)`);
+                addSeparator = true;
+            }
+            if (this.extension.publisherSponsorLink) {
+                if (addSeparator) {
+                    markdown.appendText(`  |  `);
+                }
+                markdown.appendMarkdown(`$(${sponsorIcon.id}) [${( localizeWithPath(
+                    'vs/workbench/contrib/extensions/browser/extensionsWidgets',
+                    'sponsor',
+                    "Sponsor"
+                ))}](${this.extension.publisherSponsorLink})`);
+                addSeparator = true;
+            }
+            if (addSeparator) {
+                markdown.appendText(`\n`);
+            }
+        }
+        const location = this.extension.resourceExtension?.location ?? (this.extension.local?.source === 'resource' ? this.extension.local?.location : undefined);
+        if (location) {
+            if (this.extension.isWorkspaceScoped && this.contextService.isInsideWorkspace(location)) {
+                markdown.appendMarkdown(( localizeWithPath(
+                    'vs/workbench/contrib/extensions/browser/extensionsWidgets',
+                    'workspace extension',
+                    "Workspace Extension"
+                )));
+            }
+            else {
+                markdown.appendMarkdown(( localizeWithPath(
+                    'vs/workbench/contrib/extensions/browser/extensionsWidgets',
+                    'local extension',
+                    "Local Extension"
+                )));
+            }
+            markdown.appendText(`\n`);
+        }
+        if (this.extension.description) {
+            markdown.appendMarkdown(`${this.extension.description}`);
+            markdown.appendText(`\n`);
+        }
+        if (this.extension.publisherDomain?.verified) {
+            const bgColor = this.themeService.getColorTheme().getColor(extensionVerifiedPublisherIconColor);
+            const publisherVerifiedTooltip = ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionsWidgets',
+                'publisher verified tooltip',
+                "This publisher has verified ownership of {0}",
+                `[${( URI.parse(this.extension.publisherDomain.link)).authority}](${this.extension.publisherDomain.link})`
+            ));
+            markdown.appendMarkdown(`<span style="color:${bgColor ? Color.Format.CSS.formatHex(bgColor) : '#ffffff'};">$(${verifiedPublisherIcon.id})</span>&nbsp;${publisherVerifiedTooltip}`);
+            markdown.appendText(`\n`);
+        }
+        if (this.extension.outdated) {
+            markdown.appendMarkdown(( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionsWidgets',
+                'updateRequired',
+                "Latest version:"
+            )));
+            markdown.appendMarkdown(`&nbsp;<span style="background-color:#8080802B;">**&nbsp;_v${this.extension.latestVersion}_**&nbsp;</span>`);
+            markdown.appendText(`\n`);
+        }
+        const preReleaseMessage = ExtensionHoverWidget_1.getPreReleaseMessage(this.extension);
+        const extensionRuntimeStatus = this.extensionsWorkbenchService.getExtensionStatus(this.extension);
+        const extensionStatus = this.extensionStatusAction.status;
+        const runtimeState = this.extension.runtimeState;
+        const recommendationMessage = this.getRecommendationMessage(this.extension);
+        if (extensionRuntimeStatus || extensionStatus || runtimeState || recommendationMessage || preReleaseMessage) {
+            markdown.appendMarkdown(`---`);
+            markdown.appendText(`\n`);
+            if (extensionRuntimeStatus) {
+                if (extensionRuntimeStatus.activationTimes) {
+                    const activationTime = extensionRuntimeStatus.activationTimes.codeLoadingTime + extensionRuntimeStatus.activationTimes.activateCallTime;
+                    markdown.appendMarkdown(`${( localizeWithPath(
+                        'vs/workbench/contrib/extensions/browser/extensionsWidgets',
+                        'activation',
+                        "Activation time"
+                    ))}${extensionRuntimeStatus.activationTimes.activationReason.startup ? ` (${( localizeWithPath(
+                        'vs/workbench/contrib/extensions/browser/extensionsWidgets',
+                        'startup',
+                        "Startup"
+                    ))})` : ''}: \`${activationTime}ms\``);
+                    markdown.appendText(`\n`);
+                }
+                if (extensionRuntimeStatus.runtimeErrors.length || extensionRuntimeStatus.messages.length) {
+                    const hasErrors = extensionRuntimeStatus.runtimeErrors.length || ( extensionRuntimeStatus.messages.some(message => message.type === Severity$1.Error));
+                    const hasWarnings = ( extensionRuntimeStatus.messages.some(message => message.type === Severity$1.Warning));
+                    const errorsLink = extensionRuntimeStatus.runtimeErrors.length ? `[${extensionRuntimeStatus.runtimeErrors.length === 1 ? ( localizeWithPath(
+                        'vs/workbench/contrib/extensions/browser/extensionsWidgets',
+                        'uncaught error',
+                        '1 uncaught error'
+                    )) : ( localizeWithPath(
+                        'vs/workbench/contrib/extensions/browser/extensionsWidgets',
+                        'uncaught errors',
+                        '{0} uncaught errors',
+                        extensionRuntimeStatus.runtimeErrors.length
+                    ))}](${( URI.parse(
+                        `command:extension.open?${encodeURIComponent(JSON.stringify([this.extension.identifier.id, "features" ]))}`
+                    ))})` : undefined;
+                    const messageLink = extensionRuntimeStatus.messages.length ? `[${extensionRuntimeStatus.messages.length === 1 ? ( localizeWithPath(
+                        'vs/workbench/contrib/extensions/browser/extensionsWidgets',
+                        'message',
+                        '1 message'
+                    )) : ( localizeWithPath(
+                        'vs/workbench/contrib/extensions/browser/extensionsWidgets',
+                        'messages',
+                        '{0} messages',
+                        extensionRuntimeStatus.messages.length
+                    ))}](${( URI.parse(
+                        `command:extension.open?${encodeURIComponent(JSON.stringify([this.extension.identifier.id, "features" ]))}`
+                    ))})` : undefined;
+                    markdown.appendMarkdown(`$(${hasErrors ? errorIcon.id : hasWarnings ? warningIcon.id : infoIcon.id}) This extension has reported `);
+                    if (errorsLink && messageLink) {
+                        markdown.appendMarkdown(`${errorsLink} and ${messageLink}`);
+                    }
+                    else {
+                        markdown.appendMarkdown(`${errorsLink || messageLink}`);
+                    }
+                    markdown.appendText(`\n`);
+                }
+            }
+            if (extensionStatus) {
+                if (extensionStatus.icon) {
+                    markdown.appendMarkdown(`$(${extensionStatus.icon.id})&nbsp;`);
+                }
+                markdown.appendMarkdown(extensionStatus.message.value);
+                if (this.extension.enablementState === 5  && this.extension.local) {
+                    markdown.appendMarkdown(`&nbsp;[${( localizeWithPath(
+                        'vs/workbench/contrib/extensions/browser/extensionsWidgets',
+                        'dependencies',
+                        "Show Dependencies"
+                    ))}](${( URI.parse(
+                        `command:extension.open?${encodeURIComponent(JSON.stringify([this.extension.identifier.id, "dependencies" ]))}`
+                    ))})`);
+                }
+                markdown.appendText(`\n`);
+            }
+            if (runtimeState) {
+                markdown.appendMarkdown(`$(${infoIcon.id})&nbsp;`);
+                markdown.appendMarkdown(`${runtimeState.reason}`);
+                markdown.appendText(`\n`);
+            }
+            if (preReleaseMessage) {
+                const extensionPreReleaseIcon = this.themeService.getColorTheme().getColor(extensionPreReleaseIconColor);
+                markdown.appendMarkdown(`<span style="color:${extensionPreReleaseIcon ? Color.Format.CSS.formatHex(extensionPreReleaseIcon) : '#ffffff'};">$(${preReleaseIcon.id})</span>&nbsp;${preReleaseMessage}`);
+                markdown.appendText(`\n`);
+            }
+            if (recommendationMessage) {
+                markdown.appendMarkdown(recommendationMessage);
+                markdown.appendText(`\n`);
+            }
+        }
+        return markdown;
+    }
+    getRecommendationMessage(extension) {
+        if (extension.state === 1 ) {
+            return undefined;
+        }
+        if (extension.deprecationInfo) {
+            return undefined;
+        }
+        const recommendation = this.extensionRecommendationsService.getAllRecommendationsWithReason()[extension.identifier.id.toLowerCase()];
+        if (!recommendation?.reasonText) {
+            return undefined;
+        }
+        const bgColor = this.themeService.getColorTheme().getColor(extensionButtonProminentBackground);
+        return `<span style="color:${bgColor ? Color.Format.CSS.formatHex(bgColor) : '#ffffff'};">$(${starEmptyIcon.id})</span>&nbsp;${recommendation.reasonText}`;
+    }
+    static getPreReleaseMessage(extension) {
+        if (!extension.hasPreReleaseVersion) {
+            return undefined;
+        }
+        if (extension.isBuiltin) {
+            return undefined;
+        }
+        if (extension.isPreReleaseVersion) {
+            return undefined;
+        }
+        if (extension.preRelease) {
+            return undefined;
+        }
+        const preReleaseVersionLink = `[${( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionsWidgets',
+            'Show prerelease version',
+            "Pre-Release version"
+        ))}](${( URI.parse(
+            `command:workbench.extensions.action.showPreReleaseVersion?${encodeURIComponent(JSON.stringify([extension.identifier.id]))}`
+        ))})`;
+        return ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionsWidgets',
+            'has prerelease',
+            "This extension has a {0} available",
+            preReleaseVersionLink
+        ));
+    }
+};
+ExtensionHoverWidget = ExtensionHoverWidget_1 = ( __decorate([
+    ( __param(2, IExtensionsWorkbenchService)),
+    ( __param(3, IHoverService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IExtensionRecommendationsService)),
+    ( __param(6, IThemeService)),
+    ( __param(7, IWorkspaceContextService))
+], ExtensionHoverWidget));
+let ExtensionStatusWidget = class ExtensionStatusWidget extends ExtensionWidget {
+    constructor(container, extensionStatusAction, openerService) {
+        super();
+        this.container = container;
+        this.extensionStatusAction = extensionStatusAction;
+        this.openerService = openerService;
+        this.renderDisposables = this._register(( new MutableDisposable()));
+        this._onDidRender = this._register(( new Emitter()));
+        this.onDidRender = this._onDidRender.event;
+        this.render();
+        this._register(extensionStatusAction.onDidChangeStatus(() => this.render()));
+    }
+    render() {
+        reset(this.container);
+        this.renderDisposables.value = undefined;
+        const disposables = ( new DisposableStore());
+        this.renderDisposables.value = disposables;
+        const extensionStatus = this.extensionStatusAction.status;
+        if (extensionStatus) {
+            const markdown = ( new MarkdownString('', { isTrusted: true, supportThemeIcons: true }));
+            if (extensionStatus.icon) {
+                markdown.appendMarkdown(`$(${extensionStatus.icon.id})&nbsp;`);
+            }
+            markdown.appendMarkdown(extensionStatus.message.value);
+            const rendered = disposables.add(renderMarkdown(markdown, {
+                actionHandler: {
+                    callback: (content) => {
+                        this.openerService.open(content, { allowCommands: true }).catch(onUnexpectedError);
+                    },
+                    disposables
+                }
+            }));
+            append(this.container, rendered.element);
+        }
+        this._onDidRender.fire();
+    }
+};
+ExtensionStatusWidget = ( __decorate([
+    ( __param(2, IOpenerService))
+], ExtensionStatusWidget));
+let ExtensionRecommendationWidget = class ExtensionRecommendationWidget extends ExtensionWidget {
+    constructor(container, extensionRecommendationsService, extensionIgnoredRecommendationsService) {
+        super();
+        this.container = container;
+        this.extensionRecommendationsService = extensionRecommendationsService;
+        this.extensionIgnoredRecommendationsService = extensionIgnoredRecommendationsService;
+        this._onDidRender = this._register(( new Emitter()));
+        this.onDidRender = this._onDidRender.event;
+        this.render();
+        this._register(this.extensionRecommendationsService.onDidChangeRecommendations(() => this.render()));
+    }
+    render() {
+        reset(this.container);
+        const recommendationStatus = this.getRecommendationStatus();
+        if (recommendationStatus) {
+            if (recommendationStatus.icon) {
+                append(this.container, $(`div${ThemeIcon.asCSSSelector(recommendationStatus.icon)}`));
+            }
+            append(this.container, $(`div.recommendation-text`, undefined, recommendationStatus.message));
+        }
+        this._onDidRender.fire();
+    }
+    getRecommendationStatus() {
+        if (!this.extension
+            || this.extension.deprecationInfo
+            || this.extension.state === 1 ) {
+            return undefined;
+        }
+        const extRecommendations = this.extensionRecommendationsService.getAllRecommendationsWithReason();
+        if (extRecommendations[this.extension.identifier.id.toLowerCase()]) {
+            const reasonText = extRecommendations[this.extension.identifier.id.toLowerCase()].reasonText;
+            if (reasonText) {
+                return { icon: starEmptyIcon, message: reasonText };
+            }
+        }
+        else if (this.extensionIgnoredRecommendationsService.globalIgnoredRecommendations.indexOf(this.extension.identifier.id.toLowerCase()) !== -1) {
+            return { icon: undefined, message: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionsWidgets',
+                'recommendationHasBeenIgnored',
+                "You have chosen not to receive recommendations for this extension."
+            )) };
+        }
+        return undefined;
+    }
+};
+ExtensionRecommendationWidget = ( __decorate([
+    ( __param(1, IExtensionRecommendationsService)),
+    ( __param(2, IExtensionIgnoredRecommendationsService))
+], ExtensionRecommendationWidget));
+const extensionRatingIconColor = registerColor('extensionIcon.starForeground', { light: '#DF6100', dark: '#FF8E00', hcDark: '#FF8E00', hcLight: textLinkForeground }, ( localizeWithPath(
+    'vs/workbench/contrib/extensions/browser/extensionsWidgets',
+    'extensionIconStarForeground',
+    "The icon color for extension ratings."
+)), true);
+const extensionVerifiedPublisherIconColor = registerColor('extensionIcon.verifiedForeground', { dark: textLinkForeground, light: textLinkForeground, hcDark: textLinkForeground, hcLight: textLinkForeground }, ( localizeWithPath(
+    'vs/workbench/contrib/extensions/browser/extensionsWidgets',
+    'extensionIconVerifiedForeground',
+    "The icon color for extension verified publisher."
+)), true);
+const extensionPreReleaseIconColor = registerColor('extensionIcon.preReleaseForeground', { dark: '#1d9271', light: '#1d9271', hcDark: '#1d9271', hcLight: textLinkForeground }, ( localizeWithPath(
+    'vs/workbench/contrib/extensions/browser/extensionsWidgets',
+    'extensionPreReleaseForeground',
+    "The icon color for pre-release extension."
+)), true);
+registerColor('extensionIcon.sponsorForeground', { light: '#B51E78', dark: '#D758B3', hcDark: null, hcLight: '#B51E78' }, ( localizeWithPath(
+    'vs/workbench/contrib/extensions/browser/extensionsWidgets',
+    'extensionIcon.sponsorForeground',
+    "The icon color for extension sponsor."
+)), true);
+registerThemingParticipant((theme, collector) => {
+    const extensionRatingIcon = theme.getColor(extensionRatingIconColor);
+    if (extensionRatingIcon) {
+        collector.addRule(`.extension-ratings .codicon-extensions-star-full, .extension-ratings .codicon-extensions-star-half { color: ${extensionRatingIcon}; }`);
+        collector.addRule(`.monaco-hover.extension-hover .markdown-hover .hover-contents ${ThemeIcon.asCSSSelector(starFullIcon)} { color: ${extensionRatingIcon}; }`);
+    }
+    const extensionVerifiedPublisherIcon = theme.getColor(extensionVerifiedPublisherIconColor);
+    if (extensionVerifiedPublisherIcon) {
+        collector.addRule(`${ThemeIcon.asCSSSelector(verifiedPublisherIcon)} { color: ${extensionVerifiedPublisherIcon}; }`);
+    }
+    collector.addRule(`.monaco-hover.extension-hover .markdown-hover .hover-contents ${ThemeIcon.asCSSSelector(sponsorIcon)} { color: var(--vscode-extensionIcon-sponsorForeground); }`);
+    collector.addRule(`.extension-editor > .header > .details > .subtitle .sponsor ${ThemeIcon.asCSSSelector(sponsorIcon)} { color: var(--vscode-extensionIcon-sponsorForeground); }`);
+});
+export { ExtensionActivationStatusWidget, ExtensionHoverWidget, ExtensionPackCountWidget, ExtensionRecommendationWidget, ExtensionStatusWidget, ExtensionWidget, InstallCountWidget, PreReleaseBookmarkWidget, RatingsWidget, RecommendationWidget, RemoteBadgeWidget, SponsorWidget, SyncIgnoredWidget, VerifiedPublisherWidget, extensionPreReleaseIconColor, extensionRatingIconColor, extensionVerifiedPublisherIconColor, onClick };