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

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

@@ -0,0 +1,52 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IWorkspaceTrustEnablementService, IWorkspaceTrustManagementService } from 'monaco-editor/esm/vs/platform/workspace/common/workspaceTrust.js';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
+import { IWorkbenchExtensionEnablementService } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host';
+
+let ExtensionEnablementWorkspaceTrustTransitionParticipant = class ExtensionEnablementWorkspaceTrustTransitionParticipant extends Disposable {
+    constructor(extensionService, hostService, environmentService, extensionEnablementService, workspaceTrustEnablementService, workspaceTrustManagementService) {
+        super();
+        if (workspaceTrustEnablementService.isWorkspaceTrustEnabled()) {
+            workspaceTrustManagementService.workspaceTrustInitialized.then(() => {
+                const workspaceTrustTransitionParticipant = new (class {
+                    async participate(trusted) {
+                        if (trusted) {
+                            await extensionEnablementService.updateExtensionsEnablementsWhenWorkspaceTrustChanges();
+                        }
+                        else {
+                            if (environmentService.remoteAuthority) {
+                                hostService.reload();
+                            }
+                            else {
+                                const stopped = await extensionService.stopExtensionHosts(( localizeWithPath(
+                                    'vs/workbench/contrib/extensions/browser/extensionEnablementWorkspaceTrustTransitionParticipant',
+                                    'restartExtensionHost.reason',
+                                    "Restarting extension host due to workspace trust change."
+                                )));
+                                await extensionEnablementService.updateExtensionsEnablementsWhenWorkspaceTrustChanges();
+                                if (stopped) {
+                                    extensionService.startExtensionHosts();
+                                }
+                            }
+                        }
+                    }
+                });
+                this._register(workspaceTrustManagementService.addWorkspaceTrustTransitionParticipant(workspaceTrustTransitionParticipant));
+            });
+        }
+    }
+};
+ExtensionEnablementWorkspaceTrustTransitionParticipant = ( __decorate([
+    ( __param(0, IExtensionService)),
+    ( __param(1, IHostService)),
+    ( __param(2, IWorkbenchEnvironmentService)),
+    ( __param(3, IWorkbenchExtensionEnablementService)),
+    ( __param(4, IWorkspaceTrustEnablementService)),
+    ( __param(5, IWorkspaceTrustManagementService))
+], ExtensionEnablementWorkspaceTrustTransitionParticipant));
+
+export { ExtensionEnablementWorkspaceTrustTransitionParticipant };

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

@@ -0,0 +1,437 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { distinct } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { raceCancellablePromises, createCancelablePromise, raceCancellation, timeout, Promises } from 'monaco-editor/esm/vs/base/common/async.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { isCancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { Event, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable, DisposableStore, isDisposable, toDisposable, MutableDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { areSameExtensions } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagementUtil';
+import { RecommendationSourceToString } from 'vscode/vscode/vs/platform/extensionRecommendations/common/extensionRecommendations';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Severity, INotificationService, NotificationPriority } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IUserDataSyncEnablementService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSync';
+import { SearchExtensionsAction } from 'vscode/vscode/vs/workbench/contrib/extensions/browser/extensionsActions';
+import { IExtensionsWorkbenchService } from 'vscode/vscode/vs/workbench/contrib/extensions/common/extensions';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
+import { IWorkbenchExtensionManagementService, IWorkbenchExtensionEnablementService } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement';
+import { IExtensionIgnoredRecommendationsService } from 'vscode/vscode/vs/workbench/services/extensionRecommendations/common/extensionRecommendations';
+
+const ignoreImportantExtensionRecommendationStorageKey = 'extensionsAssistant/importantRecommendationsIgnore';
+const donotShowWorkspaceRecommendationsStorageKey = 'extensionsAssistant/workspaceRecommendationsIgnore';
+const choiceNever = ( localizeWithPath(
+    'vs/workbench/contrib/extensions/browser/extensionRecommendationNotificationService',
+    'neverShowAgain',
+    "Don't Show Again"
+));
+class RecommendationsNotification extends Disposable {
+    constructor(severity, message, choices, notificationService) {
+        super();
+        this.severity = severity;
+        this.message = message;
+        this.choices = choices;
+        this.notificationService = notificationService;
+        this._onDidClose = this._register(( new Emitter()));
+        this.onDidClose = this._onDidClose.event;
+        this._onDidChangeVisibility = this._register(( new Emitter()));
+        this.onDidChangeVisibility = this._onDidChangeVisibility.event;
+        this.cancelled = false;
+        this.onDidCloseDisposable = this._register(( new MutableDisposable()));
+        this.onDidChangeVisibilityDisposable = this._register(( new MutableDisposable()));
+    }
+    show() {
+        if (!this.notificationHandle) {
+            this.updateNotificationHandle(this.notificationService.prompt(this.severity, this.message, this.choices, { sticky: true, onCancel: () => this.cancelled = true }));
+        }
+    }
+    hide() {
+        if (this.notificationHandle) {
+            this.onDidCloseDisposable.clear();
+            this.notificationHandle.close();
+            this.cancelled = false;
+            this.updateNotificationHandle(this.notificationService.prompt(this.severity, this.message, this.choices, { priority: NotificationPriority.SILENT, onCancel: () => this.cancelled = true }));
+        }
+    }
+    isCancelled() {
+        return this.cancelled;
+    }
+    updateNotificationHandle(notificationHandle) {
+        this.onDidCloseDisposable.clear();
+        this.onDidChangeVisibilityDisposable.clear();
+        this.notificationHandle = notificationHandle;
+        this.onDidCloseDisposable.value = this.notificationHandle.onDidClose(() => {
+            this.onDidCloseDisposable.dispose();
+            this.onDidChangeVisibilityDisposable.dispose();
+            this._onDidClose.fire();
+            this._onDidClose.dispose();
+            this._onDidChangeVisibility.dispose();
+        });
+        this.onDidChangeVisibilityDisposable.value = this.notificationHandle.onDidChangeVisibility((e) => this._onDidChangeVisibility.fire(e));
+    }
+}
+let ExtensionRecommendationNotificationService = class ExtensionRecommendationNotificationService extends Disposable {
+    get ignoredRecommendations() {
+        return distinct(( [...JSON.parse(this.storageService.get(ignoreImportantExtensionRecommendationStorageKey, 0 , '[]'))].map(i => i.toLowerCase())));
+    }
+    constructor(configurationService, storageService, notificationService, telemetryService, instantiationService, extensionsWorkbenchService, extensionManagementService, extensionEnablementService, extensionIgnoredRecommendationsService, userDataSyncEnablementService, workbenchEnvironmentService) {
+        super();
+        this.configurationService = configurationService;
+        this.storageService = storageService;
+        this.notificationService = notificationService;
+        this.telemetryService = telemetryService;
+        this.instantiationService = instantiationService;
+        this.extensionsWorkbenchService = extensionsWorkbenchService;
+        this.extensionManagementService = extensionManagementService;
+        this.extensionEnablementService = extensionEnablementService;
+        this.extensionIgnoredRecommendationsService = extensionIgnoredRecommendationsService;
+        this.userDataSyncEnablementService = userDataSyncEnablementService;
+        this.workbenchEnvironmentService = workbenchEnvironmentService;
+        this.recommendedExtensions = [];
+        this.recommendationSources = [];
+        this.pendingNotificaitons = [];
+    }
+    hasToIgnoreRecommendationNotifications() {
+        const config = this.configurationService.getValue('extensions');
+        return config.ignoreRecommendations || !!config.showRecommendationsOnlyOnDemand;
+    }
+    async promptImportantExtensionsInstallNotification(extensionRecommendations) {
+        const ignoredRecommendations = [...this.extensionIgnoredRecommendationsService.ignoredRecommendations, ...this.ignoredRecommendations];
+        const extensions = extensionRecommendations.extensions.filter(id => !ignoredRecommendations.includes(id));
+        if (!extensions.length) {
+            return "ignored" ;
+        }
+        return this.promptRecommendationsNotification({ ...extensionRecommendations, extensions }, {
+            onDidInstallRecommendedExtensions: (extensions) => extensions.forEach(extension => this.telemetryService.publicLog2('extensionRecommendations:popup', { userReaction: 'install', extensionId: extension.identifier.id, source: RecommendationSourceToString(extensionRecommendations.source) })),
+            onDidShowRecommendedExtensions: (extensions) => extensions.forEach(extension => this.telemetryService.publicLog2('extensionRecommendations:popup', { userReaction: 'show', extensionId: extension.identifier.id, source: RecommendationSourceToString(extensionRecommendations.source) })),
+            onDidCancelRecommendedExtensions: (extensions) => extensions.forEach(extension => this.telemetryService.publicLog2('extensionRecommendations:popup', { userReaction: 'cancelled', extensionId: extension.identifier.id, source: RecommendationSourceToString(extensionRecommendations.source) })),
+            onDidNeverShowRecommendedExtensionsAgain: (extensions) => {
+                for (const extension of extensions) {
+                    this.addToImportantRecommendationsIgnore(extension.identifier.id);
+                    this.telemetryService.publicLog2('extensionRecommendations:popup', { userReaction: 'neverShowAgain', extensionId: extension.identifier.id, source: RecommendationSourceToString(extensionRecommendations.source) });
+                }
+                this.notificationService.prompt(Severity.Info, ( localizeWithPath(
+                    'vs/workbench/contrib/extensions/browser/extensionRecommendationNotificationService',
+                    'ignoreExtensionRecommendations',
+                    "Do you want to ignore all extension recommendations?"
+                )), [{
+                        label: ( localizeWithPath(
+                            'vs/workbench/contrib/extensions/browser/extensionRecommendationNotificationService',
+                            'ignoreAll',
+                            "Yes, Ignore All"
+                        )),
+                        run: () => this.setIgnoreRecommendationsConfig(true)
+                    }, {
+                        label: ( localizeWithPath(
+                            'vs/workbench/contrib/extensions/browser/extensionRecommendationNotificationService',
+                            'no',
+                            "No"
+                        )),
+                        run: () => this.setIgnoreRecommendationsConfig(false)
+                    }]);
+            },
+        });
+    }
+    async promptWorkspaceRecommendations(recommendations) {
+        if (this.storageService.getBoolean(donotShowWorkspaceRecommendationsStorageKey, 1 , false)) {
+            return;
+        }
+        let installed = await this.extensionManagementService.getInstalled();
+        installed = installed.filter(l => this.extensionEnablementService.getEnablementState(l) !== 1 );
+        recommendations = recommendations.filter(extensionId => installed.every(local => !areSameExtensions({ id: extensionId }, local.identifier)));
+        if (!recommendations.length) {
+            return;
+        }
+        await this.promptRecommendationsNotification({ extensions: recommendations, source: 2 , name: ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionRecommendationNotificationService',
+            { key: 'this repository', comment: ['this repository means the current repository that is opened'] },
+            "this repository"
+        )) }, {
+            onDidInstallRecommendedExtensions: () => this.telemetryService.publicLog2('extensionWorkspaceRecommendations:popup', { userReaction: 'install' }),
+            onDidShowRecommendedExtensions: () => this.telemetryService.publicLog2('extensionWorkspaceRecommendations:popup', { userReaction: 'show' }),
+            onDidCancelRecommendedExtensions: () => this.telemetryService.publicLog2('extensionWorkspaceRecommendations:popup', { userReaction: 'cancelled' }),
+            onDidNeverShowRecommendedExtensionsAgain: () => {
+                this.telemetryService.publicLog2('extensionWorkspaceRecommendations:popup', { userReaction: 'neverShowAgain' });
+                this.storageService.store(donotShowWorkspaceRecommendationsStorageKey, true, 1 , 1 );
+            },
+        });
+    }
+    async promptRecommendationsNotification({ extensions: extensionIds, source, name, searchValue }, recommendationsNotificationActions) {
+        if (this.hasToIgnoreRecommendationNotifications()) {
+            return "ignored" ;
+        }
+        if (source === 3  && this.workbenchEnvironmentService.remoteAuthority) {
+            return "incompatibleWindow" ;
+        }
+        if (source === 3  && (this.recommendationSources.includes(3 ) || this.recommendationSources.length >= 2)) {
+            return "toomany" ;
+        }
+        this.recommendationSources.push(source);
+        if (source === 3  && extensionIds.every(id => this.recommendedExtensions.includes(id))) {
+            return "ignored" ;
+        }
+        const extensions = await this.getInstallableExtensions(extensionIds);
+        if (!extensions.length) {
+            return "ignored" ;
+        }
+        this.recommendedExtensions = distinct([...this.recommendedExtensions, ...extensionIds]);
+        let extensionsMessage = '';
+        if (extensions.length === 1) {
+            extensionsMessage = ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionRecommendationNotificationService',
+                'extensionFromPublisher',
+                "'{0}' extension from {1}",
+                extensions[0].displayName,
+                extensions[0].publisherDisplayName
+            ));
+        }
+        else {
+            const publishers = [...extensions.reduce((result, extension) => result.add(extension.publisherDisplayName), ( new Set()))];
+            if (publishers.length > 2) {
+                extensionsMessage = ( localizeWithPath(
+                    'vs/workbench/contrib/extensions/browser/extensionRecommendationNotificationService',
+                    'extensionsFromMultiplePublishers',
+                    "extensions from {0}, {1} and others",
+                    publishers[0],
+                    publishers[1]
+                ));
+            }
+            else if (publishers.length === 2) {
+                extensionsMessage = ( localizeWithPath(
+                    'vs/workbench/contrib/extensions/browser/extensionRecommendationNotificationService',
+                    'extensionsFromPublishers',
+                    "extensions from {0} and {1}",
+                    publishers[0],
+                    publishers[1]
+                ));
+            }
+            else {
+                extensionsMessage = ( localizeWithPath(
+                    'vs/workbench/contrib/extensions/browser/extensionRecommendationNotificationService',
+                    'extensionsFromPublisher',
+                    "extensions from {0}",
+                    publishers[0]
+                ));
+            }
+        }
+        let message = ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionRecommendationNotificationService',
+            'recommended',
+            "Do you want to install the recommended {0} for {1}?",
+            extensionsMessage,
+            name
+        ));
+        if (source === 3 ) {
+            message = ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionRecommendationNotificationService',
+                { key: 'exeRecommended', comment: ['Placeholder string is the name of the software that is installed.'] },
+                "You have {0} installed on your system. Do you want to install the recommended {1} for it?",
+                name,
+                extensionsMessage
+            ));
+        }
+        if (!searchValue) {
+            searchValue = source === 2  ? '@recommended' : ( extensions.map(extensionId => `@id:${extensionId.identifier.id}`)).join(' ');
+        }
+        return raceCancellablePromises([
+            this._registerP(this.showRecommendationsNotification(extensions, message, searchValue, source, recommendationsNotificationActions)),
+            this._registerP(this.waitUntilRecommendationsAreInstalled(extensions))
+        ]);
+    }
+    showRecommendationsNotification(extensions, message, searchValue, source, { onDidInstallRecommendedExtensions, onDidShowRecommendedExtensions, onDidCancelRecommendedExtensions, onDidNeverShowRecommendedExtensionsAgain }) {
+        return createCancelablePromise(async (token) => {
+            let accepted = false;
+            const choices = [];
+            const installExtensions = async (isMachineScoped) => {
+                this.runAction(this.instantiationService.createInstance(SearchExtensionsAction, searchValue));
+                onDidInstallRecommendedExtensions(extensions);
+                await Promises.settled([
+                    Promises.settled(( extensions.map(
+                        extension => this.extensionsWorkbenchService.open(extension, { pinned: true })
+                    ))),
+                    this.extensionManagementService.installGalleryExtensions(( extensions.map(e => ({ extension: e.gallery, options: { isMachineScoped } }))))
+                ]);
+            };
+            choices.push({
+                label: ( localizeWithPath(
+                    'vs/workbench/contrib/extensions/browser/extensionRecommendationNotificationService',
+                    'install',
+                    "Install"
+                )),
+                run: () => installExtensions(false),
+                menu: this.userDataSyncEnablementService.isEnabled() && this.userDataSyncEnablementService.isResourceEnabled("extensions" ) ? [{
+                        label: ( localizeWithPath(
+                            'vs/workbench/contrib/extensions/browser/extensionRecommendationNotificationService',
+                            'install and do no sync',
+                            "Install (Do not sync)"
+                        )),
+                        run: () => installExtensions(true)
+                    }] : undefined,
+            });
+            choices.push(...[{
+                    label: ( localizeWithPath(
+                        'vs/workbench/contrib/extensions/browser/extensionRecommendationNotificationService',
+                        'show recommendations',
+                        "Show Recommendations"
+                    )),
+                    run: async () => {
+                        onDidShowRecommendedExtensions(extensions);
+                        for (const extension of extensions) {
+                            this.extensionsWorkbenchService.open(extension, { pinned: true });
+                        }
+                        this.runAction(this.instantiationService.createInstance(SearchExtensionsAction, searchValue));
+                    }
+                }, {
+                    label: choiceNever,
+                    isSecondary: true,
+                    run: () => {
+                        onDidNeverShowRecommendedExtensionsAgain(extensions);
+                    }
+                }]);
+            try {
+                accepted = await this.doShowRecommendationsNotification(Severity.Info, message, choices, source, token);
+            }
+            catch (error) {
+                if (!isCancellationError(error)) {
+                    throw error;
+                }
+            }
+            if (accepted) {
+                return "reacted" ;
+            }
+            else {
+                onDidCancelRecommendedExtensions(extensions);
+                return "cancelled" ;
+            }
+        });
+    }
+    waitUntilRecommendationsAreInstalled(extensions) {
+        const installedExtensions = [];
+        const disposables = ( new DisposableStore());
+        return createCancelablePromise(async (token) => {
+            disposables.add(token.onCancellationRequested(e => disposables.dispose()));
+            return ( new Promise((c, e) => {
+                disposables.add(this.extensionManagementService.onInstallExtension(e => {
+                    installedExtensions.push(e.identifier.id.toLowerCase());
+                    if (extensions.every(e => installedExtensions.includes(e.identifier.id.toLowerCase()))) {
+                        c("reacted" );
+                    }
+                }));
+            }));
+        });
+    }
+    async doShowRecommendationsNotification(severity, message, choices, source, token) {
+        const disposables = ( new DisposableStore());
+        try {
+            const recommendationsNotification = disposables.add(( new RecommendationsNotification(severity, message, choices, this.notificationService)));
+            disposables.add(Event.once(Event.filter(recommendationsNotification.onDidChangeVisibility, e => !e))(() => this.showNextNotification()));
+            if (this.visibleNotification) {
+                const index = this.pendingNotificaitons.length;
+                disposables.add(token.onCancellationRequested(() => this.pendingNotificaitons.splice(index, 1)));
+                this.pendingNotificaitons.push({ recommendationsNotification, source, token });
+                if (source !== 3  && source <= this.visibleNotification.source) {
+                    this.hideVisibleNotification(3000);
+                }
+            }
+            else {
+                this.visibleNotification = { recommendationsNotification, source, from: Date.now() };
+                recommendationsNotification.show();
+            }
+            await raceCancellation(( new Promise(
+                c => disposables.add(Event.once(recommendationsNotification.onDidClose)(c))
+            )), token);
+            return !recommendationsNotification.isCancelled();
+        }
+        finally {
+            disposables.dispose();
+        }
+    }
+    showNextNotification() {
+        const index = this.getNextPendingNotificationIndex();
+        const [nextNotificaiton] = index > -1 ? this.pendingNotificaitons.splice(index, 1) : [];
+        timeout(nextNotificaiton ? 500 : 0)
+            .then(() => {
+            this.unsetVisibileNotification();
+            if (nextNotificaiton) {
+                this.visibleNotification = { recommendationsNotification: nextNotificaiton.recommendationsNotification, source: nextNotificaiton.source, from: Date.now() };
+                nextNotificaiton.recommendationsNotification.show();
+            }
+        });
+    }
+    getNextPendingNotificationIndex() {
+        let index = this.pendingNotificaitons.length - 1;
+        if (this.pendingNotificaitons.length) {
+            for (let i = 0; i < this.pendingNotificaitons.length; i++) {
+                if (this.pendingNotificaitons[i].source <= this.pendingNotificaitons[index].source) {
+                    index = i;
+                }
+            }
+        }
+        return index;
+    }
+    hideVisibleNotification(timeInMillis) {
+        if (this.visibleNotification && !this.hideVisibleNotificationPromise) {
+            const visibleNotification = this.visibleNotification;
+            this.hideVisibleNotificationPromise = timeout(Math.max(timeInMillis - (Date.now() - visibleNotification.from), 0));
+            this.hideVisibleNotificationPromise.then(() => visibleNotification.recommendationsNotification.hide());
+        }
+    }
+    unsetVisibileNotification() {
+        this.hideVisibleNotificationPromise?.cancel();
+        this.hideVisibleNotificationPromise = undefined;
+        this.visibleNotification = undefined;
+    }
+    async getInstallableExtensions(extensionIds) {
+        const result = [];
+        if (extensionIds.length) {
+            const extensions = await this.extensionsWorkbenchService.getExtensions(( extensionIds.map(id => ({ id }))), { source: 'install-recommendations' }, CancellationToken.None);
+            for (const extension of extensions) {
+                if (extension.gallery && (await this.extensionManagementService.canInstall(extension.gallery))) {
+                    result.push(extension);
+                }
+            }
+        }
+        return result;
+    }
+    async runAction(action) {
+        try {
+            await action.run();
+        }
+        finally {
+            if (isDisposable(action)) {
+                action.dispose();
+            }
+        }
+    }
+    addToImportantRecommendationsIgnore(id) {
+        const importantRecommendationsIgnoreList = [...this.ignoredRecommendations];
+        if (!importantRecommendationsIgnoreList.includes(id.toLowerCase())) {
+            importantRecommendationsIgnoreList.push(id.toLowerCase());
+            this.storageService.store(ignoreImportantExtensionRecommendationStorageKey, JSON.stringify(importantRecommendationsIgnoreList), 0 , 0 );
+        }
+    }
+    setIgnoreRecommendationsConfig(configVal) {
+        this.configurationService.updateValue('extensions.ignoreRecommendations', configVal);
+    }
+    _registerP(o) {
+        this._register(toDisposable(() => o.cancel()));
+        return o;
+    }
+};
+ExtensionRecommendationNotificationService = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, IStorageService)),
+    ( __param(2, INotificationService)),
+    ( __param(3, ITelemetryService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IExtensionsWorkbenchService)),
+    ( __param(6, IWorkbenchExtensionManagementService)),
+    ( __param(7, IWorkbenchExtensionEnablementService)),
+    ( __param(8, IExtensionIgnoredRecommendationsService)),
+    ( __param(9, IUserDataSyncEnablementService)),
+    ( __param(10, IWorkbenchEnvironmentService))
+], ExtensionRecommendationNotificationService));
+
+export { ExtensionRecommendationNotificationService };

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

@@ -0,0 +1,17 @@
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+
+class ExtensionRecommendations extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._activationPromise = null;
+    }
+    get activated() { return this._activationPromise !== null; }
+    activate() {
+        if (!this._activationPromise) {
+            this._activationPromise = this.doActivate();
+        }
+        return this._activationPromise;
+    }
+}
+
+export { ExtensionRecommendations };