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

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

@@ -0,0 +1,221 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IExtensionGalleryService, IExtensionManagementService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagement';
+import { IExtensionIgnoredRecommendationsService } from 'vscode/vscode/vs/workbench/services/extensionRecommendations/common/extensionRecommendations';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { distinct, shuffle } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
+import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
+import { ExeBasedRecommendations } from './exeBasedRecommendations.js';
+import { WorkspaceRecommendations } from './workspaceRecommendations.js';
+import { FileBasedRecommendations } from './fileBasedRecommendations.js';
+import { KeymapRecommendations } from './keymapRecommendations.js';
+import { LanguageRecommendations } from './languageRecommendations.js';
+import { ConfigBasedRecommendations } from './configBasedRecommendations.js';
+import { IExtensionRecommendationNotificationService } from 'vscode/vscode/vs/platform/extensionRecommendations/common/extensionRecommendations';
+import { timeout } from 'monaco-editor/esm/vs/base/common/async.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { WebRecommendations } from './webRecommendations.js';
+import { IExtensionsWorkbenchService } from 'vscode/vscode/vs/workbench/contrib/extensions/common/extensions';
+import { areSameExtensions } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagementUtil';
+import { RemoteRecommendations } from './remoteRecommendations.js';
+import { IRemoteExtensionsScannerService } from 'vscode/vscode/vs/platform/remote/common/remoteExtensionsScanner';
+import { IUserDataInitializationService } from 'vscode/vscode/vs/workbench/services/userData/browser/userDataInit';
+
+let ExtensionRecommendationsService = class ExtensionRecommendationsService extends Disposable {
+    constructor(instantiationService, lifecycleService, galleryService, telemetryService, environmentService, extensionManagementService, extensionRecommendationsManagementService, extensionRecommendationNotificationService, extensionsWorkbenchService, remoteExtensionsScannerService, userDataInitializationService) {
+        super();
+        this.lifecycleService = lifecycleService;
+        this.galleryService = galleryService;
+        this.telemetryService = telemetryService;
+        this.environmentService = environmentService;
+        this.extensionManagementService = extensionManagementService;
+        this.extensionRecommendationsManagementService = extensionRecommendationsManagementService;
+        this.extensionRecommendationNotificationService = extensionRecommendationNotificationService;
+        this.extensionsWorkbenchService = extensionsWorkbenchService;
+        this.remoteExtensionsScannerService = remoteExtensionsScannerService;
+        this.userDataInitializationService = userDataInitializationService;
+        this._onDidChangeRecommendations = this._register(( new Emitter()));
+        this.onDidChangeRecommendations = this._onDidChangeRecommendations.event;
+        this.workspaceRecommendations = this._register(instantiationService.createInstance(WorkspaceRecommendations));
+        this.fileBasedRecommendations = this._register(instantiationService.createInstance(FileBasedRecommendations));
+        this.configBasedRecommendations = this._register(instantiationService.createInstance(ConfigBasedRecommendations));
+        this.exeBasedRecommendations = this._register(instantiationService.createInstance(ExeBasedRecommendations));
+        this.keymapRecommendations = this._register(instantiationService.createInstance(KeymapRecommendations));
+        this.webRecommendations = this._register(instantiationService.createInstance(WebRecommendations));
+        this.languageRecommendations = this._register(instantiationService.createInstance(LanguageRecommendations));
+        this.remoteRecommendations = this._register(instantiationService.createInstance(RemoteRecommendations));
+        if (!this.isEnabled()) {
+            this.sessionSeed = 0;
+            this.activationPromise = Promise.resolve();
+            return;
+        }
+        this.sessionSeed = +( new Date());
+        this.activationPromise = this.activate();
+        this._register(this.extensionManagementService.onDidInstallExtensions(e => this.onDidInstallExtensions(e)));
+    }
+    async activate() {
+        try {
+            await Promise.allSettled([
+                this.remoteExtensionsScannerService.whenExtensionsReady(),
+                this.userDataInitializationService.whenInitializationFinished(),
+                this.lifecycleService.when(3 )
+            ]);
+        }
+        catch (error) {  }
+        await Promise.all([
+            this.workspaceRecommendations.activate(),
+            this.configBasedRecommendations.activate(),
+            this.fileBasedRecommendations.activate(),
+            this.keymapRecommendations.activate(),
+            this.languageRecommendations.activate(),
+            this.webRecommendations.activate(),
+            this.remoteRecommendations.activate()
+        ]);
+        this._register(Event.any(this.workspaceRecommendations.onDidChangeRecommendations, this.configBasedRecommendations.onDidChangeRecommendations, this.extensionRecommendationsManagementService.onDidChangeIgnoredRecommendations)(() => this._onDidChangeRecommendations.fire()));
+        this._register(this.extensionRecommendationsManagementService.onDidChangeGlobalIgnoredRecommendation(({ extensionId, isRecommended }) => {
+            if (!isRecommended) {
+                const reason = this.getAllRecommendationsWithReason()[extensionId];
+                if (reason && reason.reasonId) {
+                    this.telemetryService.publicLog2('extensionsRecommendations:ignoreRecommendation', { extensionId, recommendationReason: reason.reasonId });
+                }
+            }
+        }));
+        this.promptWorkspaceRecommendations();
+    }
+    isEnabled() {
+        return this.galleryService.isEnabled() && !this.environmentService.isExtensionDevelopment;
+    }
+    async activateProactiveRecommendations() {
+        await Promise.all([this.exeBasedRecommendations.activate(), this.configBasedRecommendations.activate()]);
+    }
+    getAllRecommendationsWithReason() {
+        this.activateProactiveRecommendations();
+        const output = Object.create(null);
+        const allRecommendations = [
+            ...this.configBasedRecommendations.recommendations,
+            ...this.exeBasedRecommendations.recommendations,
+            ...this.fileBasedRecommendations.recommendations,
+            ...this.workspaceRecommendations.recommendations,
+            ...this.keymapRecommendations.recommendations,
+            ...this.languageRecommendations.recommendations,
+            ...this.webRecommendations.recommendations,
+        ];
+        for (const { extensionId, reason } of allRecommendations) {
+            if (this.isExtensionAllowedToBeRecommended(extensionId)) {
+                output[extensionId.toLowerCase()] = reason;
+            }
+        }
+        return output;
+    }
+    async getConfigBasedRecommendations() {
+        await this.configBasedRecommendations.activate();
+        return {
+            important: this.toExtensionRecommendations(this.configBasedRecommendations.importantRecommendations),
+            others: this.toExtensionRecommendations(this.configBasedRecommendations.otherRecommendations)
+        };
+    }
+    async getOtherRecommendations() {
+        await this.activationPromise;
+        await this.activateProactiveRecommendations();
+        const recommendations = [
+            ...this.configBasedRecommendations.otherRecommendations,
+            ...this.exeBasedRecommendations.otherRecommendations,
+            ...this.webRecommendations.recommendations
+        ];
+        const extensionIds = distinct(( recommendations.map(e => e.extensionId)))
+            .filter(extensionId => this.isExtensionAllowedToBeRecommended(extensionId));
+        shuffle(extensionIds, this.sessionSeed);
+        return extensionIds;
+    }
+    async getImportantRecommendations() {
+        await this.activateProactiveRecommendations();
+        const recommendations = [
+            ...this.fileBasedRecommendations.importantRecommendations,
+            ...this.configBasedRecommendations.importantRecommendations,
+            ...this.exeBasedRecommendations.importantRecommendations,
+        ];
+        const extensionIds = distinct(( recommendations.map(e => e.extensionId)))
+            .filter(extensionId => this.isExtensionAllowedToBeRecommended(extensionId));
+        shuffle(extensionIds, this.sessionSeed);
+        return extensionIds;
+    }
+    getKeymapRecommendations() {
+        return this.toExtensionRecommendations(this.keymapRecommendations.recommendations);
+    }
+    getLanguageRecommendations() {
+        return this.toExtensionRecommendations(this.languageRecommendations.recommendations);
+    }
+    getRemoteRecommendations() {
+        return this.toExtensionRecommendations(this.remoteRecommendations.recommendations);
+    }
+    async getWorkspaceRecommendations() {
+        if (!this.isEnabled()) {
+            return [];
+        }
+        await this.workspaceRecommendations.activate();
+        return this.toExtensionRecommendations(this.workspaceRecommendations.recommendations);
+    }
+    async getExeBasedRecommendations(exe) {
+        await this.exeBasedRecommendations.activate();
+        const { important, others } = exe ? this.exeBasedRecommendations.getRecommendations(exe)
+            : { important: this.exeBasedRecommendations.importantRecommendations, others: this.exeBasedRecommendations.otherRecommendations };
+        return { important: this.toExtensionRecommendations(important), others: this.toExtensionRecommendations(others) };
+    }
+    getFileBasedRecommendations() {
+        return this.toExtensionRecommendations(this.fileBasedRecommendations.recommendations);
+    }
+    onDidInstallExtensions(results) {
+        for (const e of results) {
+            if (e.source && !URI.isUri(e.source) && e.operation === 2 ) {
+                const extRecommendations = this.getAllRecommendationsWithReason() || {};
+                const recommendationReason = extRecommendations[e.source.identifier.id.toLowerCase()];
+                if (recommendationReason) {
+                    this.telemetryService.publicLog('extensionGallery:install:recommendations', { ...e.source.telemetryData, recommendationReason: recommendationReason.reasonId });
+                }
+            }
+        }
+    }
+    toExtensionRecommendations(recommendations) {
+        const extensionIds = distinct(( recommendations.map(e => e.extensionId)))
+            .filter(extensionId => this.isExtensionAllowedToBeRecommended(extensionId));
+        return extensionIds;
+    }
+    isExtensionAllowedToBeRecommended(extensionId) {
+        return !this.extensionRecommendationsManagementService.ignoredRecommendations.includes(extensionId.toLowerCase());
+    }
+    async promptWorkspaceRecommendations() {
+        const installed = await this.extensionsWorkbenchService.queryLocal();
+        const allowedRecommendations = ( [
+            ...this.workspaceRecommendations.recommendations,
+            ...this.configBasedRecommendations.importantRecommendations.filter(recommendation => !recommendation.whenNotInstalled || recommendation.whenNotInstalled.every(id => installed.every(local => !areSameExtensions(local.identifier, { id }))))
+        ]
+            .map(({ extensionId }) => extensionId))
+            .filter(extensionId => this.isExtensionAllowedToBeRecommended(extensionId));
+        if (allowedRecommendations.length) {
+            await this._registerP(timeout(5000));
+            await this.extensionRecommendationNotificationService.promptWorkspaceRecommendations(allowedRecommendations);
+        }
+    }
+    _registerP(o) {
+        this._register(toDisposable(() => o.cancel()));
+        return o;
+    }
+};
+ExtensionRecommendationsService = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, ILifecycleService)),
+    ( __param(2, IExtensionGalleryService)),
+    ( __param(3, ITelemetryService)),
+    ( __param(4, IEnvironmentService)),
+    ( __param(5, IExtensionManagementService)),
+    ( __param(6, IExtensionIgnoredRecommendationsService)),
+    ( __param(7, IExtensionRecommendationNotificationService)),
+    ( __param(8, IExtensionsWorkbenchService)),
+    ( __param(9, IRemoteExtensionsScannerService)),
+    ( __param(10, IUserDataInitializationService))
+], ExtensionRecommendationsService));
+
+export { ExtensionRecommendationsService };