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

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

@@ -0,0 +1,87 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { IExtensionsWorkbenchService } from 'vscode/vscode/vs/workbench/contrib/extensions/common/extensions';
+import { Severity, INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { SearchExtensionsAction } from 'vscode/vscode/vs/workbench/contrib/extensions/browser/extensionsActions';
+import { distinct } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IExtensionManagementService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagement';
+import { areSameExtensions } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagementUtil';
+
+let DeprecatedExtensionsChecker = class DeprecatedExtensionsChecker extends Disposable {
+    constructor(extensionsWorkbenchService, extensionManagementService, storageService, notificationService, instantiationService) {
+        super();
+        this.extensionsWorkbenchService = extensionsWorkbenchService;
+        this.storageService = storageService;
+        this.notificationService = notificationService;
+        this.instantiationService = instantiationService;
+        this.checkForDeprecatedExtensions();
+        this._register(extensionManagementService.onDidInstallExtensions(e => {
+            const ids = [];
+            for (const { local } of e) {
+                if (local && extensionsWorkbenchService.local.find(extension => areSameExtensions(extension.identifier, local.identifier))?.deprecationInfo) {
+                    ids.push(local.identifier.id.toLowerCase());
+                }
+            }
+            if (ids.length) {
+                this.setNotifiedDeprecatedExtensions(ids);
+            }
+        }));
+    }
+    async checkForDeprecatedExtensions() {
+        if (this.storageService.getBoolean('extensionsAssistant/doNotCheckDeprecated', 0 , false)) {
+            return;
+        }
+        const local = await this.extensionsWorkbenchService.queryLocal();
+        const previouslyNotified = this.getNotifiedDeprecatedExtensions();
+        const toNotify = local.filter(e => !!e.deprecationInfo).filter(e => !previouslyNotified.includes(e.identifier.id.toLowerCase()));
+        if (toNotify.length) {
+            this.notificationService.prompt(Severity.Warning, ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/deprecatedExtensionsChecker',
+                'deprecated extensions',
+                "You have deprecated extensions installed. We recommend to review them and migrate to alternatives."
+            )), [{
+                    label: ( localizeWithPath(
+                        'vs/workbench/contrib/extensions/browser/deprecatedExtensionsChecker',
+                        'showDeprecated',
+                        "Show Deprecated Extensions"
+                    )),
+                    run: async () => {
+                        this.setNotifiedDeprecatedExtensions(( toNotify.map(e => e.identifier.id.toLowerCase())));
+                        const action = this.instantiationService.createInstance(SearchExtensionsAction, ( toNotify.map(extension => `@id:${extension.identifier.id}`)).join(' '));
+                        try {
+                            await action.run();
+                        }
+                        finally {
+                            action.dispose();
+                        }
+                    }
+                }, {
+                    label: ( localizeWithPath(
+                        'vs/workbench/contrib/extensions/browser/deprecatedExtensionsChecker',
+                        'neverShowAgain',
+                        "Don't Show Again"
+                    )),
+                    isSecondary: true,
+                    run: () => this.storageService.store('extensionsAssistant/doNotCheckDeprecated', true, 0 , 0 )
+                }]);
+        }
+    }
+    getNotifiedDeprecatedExtensions() {
+        return JSON.parse(this.storageService.get('extensionsAssistant/deprecated', 0 , '[]'));
+    }
+    setNotifiedDeprecatedExtensions(notified) {
+        this.storageService.store('extensionsAssistant/deprecated', JSON.stringify(distinct([...this.getNotifiedDeprecatedExtensions(), ...notified])), 0 , 0 );
+    }
+};
+DeprecatedExtensionsChecker = ( __decorate([
+    ( __param(0, IExtensionsWorkbenchService)),
+    ( __param(1, IExtensionManagementService)),
+    ( __param(2, IStorageService)),
+    ( __param(3, INotificationService)),
+    ( __param(4, IInstantiationService))
+], DeprecatedExtensionsChecker));
+
+export { DeprecatedExtensionsChecker };

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

@@ -0,0 +1,60 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { IExtensionTipsService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagement';
+import { ExtensionRecommendations } from './extensionRecommendations.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+
+let ExeBasedRecommendations = class ExeBasedRecommendations extends ExtensionRecommendations {
+    get otherRecommendations() { return ( this._otherTips.map(tip => this.toExtensionRecommendation(tip))); }
+    get importantRecommendations() { return ( this._importantTips.map(tip => this.toExtensionRecommendation(tip))); }
+    get recommendations() { return [...this.importantRecommendations, ...this.otherRecommendations]; }
+    constructor(extensionTipsService) {
+        super();
+        this.extensionTipsService = extensionTipsService;
+        this._otherTips = [];
+        this._importantTips = [];
+    }
+    getRecommendations(exe) {
+        const important = ( this._importantTips
+            .filter(tip => tip.exeName.toLowerCase() === exe.toLowerCase())
+            .map(tip => this.toExtensionRecommendation(tip)));
+        const others = ( this._otherTips
+            .filter(tip => tip.exeName.toLowerCase() === exe.toLowerCase())
+            .map(tip => this.toExtensionRecommendation(tip)));
+        return { important, others };
+    }
+    async doActivate() {
+        this._otherTips = await this.extensionTipsService.getOtherExecutableBasedTips();
+        await this.fetchImportantExeBasedRecommendations();
+    }
+    async fetchImportantExeBasedRecommendations() {
+        if (!this._importantExeBasedRecommendations) {
+            this._importantExeBasedRecommendations = this.doFetchImportantExeBasedRecommendations();
+        }
+        return this._importantExeBasedRecommendations;
+    }
+    async doFetchImportantExeBasedRecommendations() {
+        const importantExeBasedRecommendations = ( new Map());
+        this._importantTips = await this.extensionTipsService.getImportantExecutableBasedTips();
+        this._importantTips.forEach(tip => importantExeBasedRecommendations.set(tip.extensionId.toLowerCase(), tip));
+        return importantExeBasedRecommendations;
+    }
+    toExtensionRecommendation(tip) {
+        return {
+            extensionId: tip.extensionId.toLowerCase(),
+            reason: {
+                reasonId: 2 ,
+                reasonText: ( localizeWithPath(
+                    'vs/workbench/contrib/extensions/browser/exeBasedRecommendations',
+                    'exeBasedRecommendation',
+                    "This extension is recommended because you have {0} installed.",
+                    tip.exeFriendlyName
+                ))
+            }
+        };
+    }
+};
+ExeBasedRecommendations = ( __decorate([
+    ( __param(0, IExtensionTipsService))
+], ExeBasedRecommendations));
+
+export { ExeBasedRecommendations };