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

package/vscode/src/vs/workbench/contrib/extensions/browser/extensions.web.contribution.js

@@ -0,0 +1,13 @@
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { EditorPaneDescriptor } from 'vscode/vscode/vs/workbench/browser/editor';
+import { RuntimeExtensionsEditor } from './browserRuntimeExtensionsEditor.js';
+import { RuntimeExtensionsInput } from '../common/runtimeExtensionsInput.js';
+import { EditorExtensions } from 'vscode/vscode/vs/workbench/common/editor';
+
+( Registry.as(EditorExtensions.EditorPane)).registerEditorPane(EditorPaneDescriptor.create(RuntimeExtensionsEditor, RuntimeExtensionsEditor.ID, ( localizeWithPath(
+ 'vs/workbench/contrib/extensions/browser/extensions.web.contribution',
+ 'runtimeExtension',
+ "Running Extensions"
+))), [( new SyncDescriptor(RuntimeExtensionsInput))]);

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

@@ -0,0 +1,46 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { IProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { DeferredPromise, timeout } from 'monaco-editor/esm/vs/base/common/async.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+
+let ExtensionActivationProgress = class ExtensionActivationProgress {
+    constructor(extensionService, progressService, logService) {
+        const options = {
+            location: 10 ,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionsActivationProgress',
+                'activation',
+                "Activating Extensions..."
+            ))
+        };
+        let deferred;
+        let count = 0;
+        this._listener = extensionService.onWillActivateByEvent(e => {
+            logService.trace('onWillActivateByEvent: ', e.event);
+            if (!deferred) {
+                deferred = ( new DeferredPromise());
+                progressService.withProgress(options, _ => deferred.p);
+            }
+            count++;
+            Promise.race([e.activation, timeout(5000, CancellationToken.None)]).finally(() => {
+                if (--count === 0) {
+                    deferred.complete(undefined);
+                    deferred = undefined;
+                }
+            });
+        });
+    }
+    dispose() {
+        this._listener.dispose();
+    }
+};
+ExtensionActivationProgress = ( __decorate([
+    ( __param(0, IExtensionService)),
+    ( __param(1, IProgressService)),
+    ( __param(2, ILogService))
+], ExtensionActivationProgress));
+
+export { ExtensionActivationProgress };

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

@@ -0,0 +1,65 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { getLocation, parse } from 'monaco-editor/esm/vs/base/common/json.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IExtensionManagementService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagement';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { ILanguageFeaturesService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
+
+let ExtensionsCompletionItemsProvider = class ExtensionsCompletionItemsProvider extends Disposable {
+    constructor(extensionManagementService, languageFeaturesService) {
+        super();
+        this.extensionManagementService = extensionManagementService;
+        this._register(languageFeaturesService.completionProvider.register({ language: 'jsonc', pattern: '**/settings.json' }, {
+            _debugDisplayName: 'extensionsCompletionProvider',
+            provideCompletionItems: async (model, position, _context, token) => {
+                const getWordRangeAtPosition = (model, position) => {
+                    const wordAtPosition = model.getWordAtPosition(position);
+                    return wordAtPosition ? ( new Range(
+                        position.lineNumber,
+                        wordAtPosition.startColumn,
+                        position.lineNumber,
+                        wordAtPosition.endColumn
+                    )) : null;
+                };
+                const location = getLocation(model.getValue(), model.getOffsetAt(position));
+                const range = getWordRangeAtPosition(model, position) ?? Range.fromPositions(position, position);
+                if (location.path[0] === 'extensions.supportUntrustedWorkspaces' && location.path.length === 2 && location.isAtPropertyKey) {
+                    let alreadyConfigured = [];
+                    try {
+                        alreadyConfigured = ( Object.keys(parse(model.getValue())['extensions.supportUntrustedWorkspaces']));
+                    }
+                    catch (e) {  }
+                    return { suggestions: await this.provideSupportUntrustedWorkspacesExtensionProposals(alreadyConfigured, range) };
+                }
+                return { suggestions: [] };
+            }
+        }));
+    }
+    async provideSupportUntrustedWorkspacesExtensionProposals(alreadyConfigured, range) {
+        const suggestions = [];
+        const installedExtensions = (await this.extensionManagementService.getInstalled()).filter(e => e.manifest.main);
+        const proposedExtensions = installedExtensions.filter(e => alreadyConfigured.indexOf(e.identifier.id) === -1);
+        if (proposedExtensions.length) {
+            suggestions.push(...( proposedExtensions.map(e => {
+                const text = `"${e.identifier.id}": {\n\t"supported": true,\n\t"version": "${e.manifest.version}"\n},`;
+                return { label: e.identifier.id, kind: 13 , insertText: text, filterText: text, range };
+            })));
+        }
+        else {
+            const text = '"vscode.csharp": {\n\t"supported": true,\n\t"version": "0.0.0"\n},';
+            suggestions.push({ label: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionsCompletionItemsProvider',
+                'exampleExtension',
+                "Example"
+            )), kind: 13 , insertText: text, filterText: text, range });
+        }
+        return suggestions;
+    }
+};
+ExtensionsCompletionItemsProvider = ( __decorate([
+    ( __param(0, IExtensionManagementService)),
+    ( __param(1, ILanguageFeaturesService))
+], ExtensionsCompletionItemsProvider));
+
+export { ExtensionsCompletionItemsProvider };

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

@@ -0,0 +1,98 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { IExtensionsWorkbenchService } from 'vscode/vscode/vs/workbench/contrib/extensions/common/extensions';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { MenuRegistry, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { areSameExtensions } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagementUtil';
+import { Severity, INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { Promises } from 'monaco-editor/esm/vs/base/common/async.js';
+
+let ExtensionDependencyChecker = class ExtensionDependencyChecker extends Disposable {
+    constructor(extensionService, extensionsWorkbenchService, notificationService, hostService) {
+        super();
+        this.extensionService = extensionService;
+        this.extensionsWorkbenchService = extensionsWorkbenchService;
+        this.notificationService = notificationService;
+        this.hostService = hostService;
+        CommandsRegistry.registerCommand('workbench.extensions.installMissingDependencies', () => this.installMissingDependencies());
+        MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
+            command: {
+                id: 'workbench.extensions.installMissingDependencies',
+                category: ( localizeWithPath(
+                    'vs/workbench/contrib/extensions/browser/extensionsDependencyChecker',
+                    'extensions',
+                    "Extensions"
+                )),
+                title: ( localizeWithPath(
+                    'vs/workbench/contrib/extensions/browser/extensionsDependencyChecker',
+                    'auto install missing deps',
+                    "Install Missing Dependencies"
+                ))
+            }
+        });
+    }
+    async getUninstalledMissingDependencies() {
+        const allMissingDependencies = await this.getAllMissingDependencies();
+        const localExtensions = await this.extensionsWorkbenchService.queryLocal();
+        return allMissingDependencies.filter(id => localExtensions.every(l => !areSameExtensions(l.identifier, { id })));
+    }
+    async getAllMissingDependencies() {
+        await this.extensionService.whenInstalledExtensionsRegistered();
+        const runningExtensionsIds = this.extensionService.extensions.reduce((result, r) => { result.add(r.identifier.value.toLowerCase()); return result; }, ( new Set()));
+        const missingDependencies = ( new Set());
+        for (const extension of this.extensionService.extensions) {
+            if (extension.extensionDependencies) {
+                extension.extensionDependencies.forEach(dep => {
+                    if (!( runningExtensionsIds.has(dep.toLowerCase()))) {
+                        missingDependencies.add(dep);
+                    }
+                });
+            }
+        }
+        return [...( missingDependencies.values())];
+    }
+    async installMissingDependencies() {
+        const missingDependencies = await this.getUninstalledMissingDependencies();
+        if (missingDependencies.length) {
+            const extensions = await this.extensionsWorkbenchService.getExtensions(( missingDependencies.map(id => ({ id }))), CancellationToken.None);
+            if (extensions.length) {
+                await Promises.settled(( extensions.map(extension => this.extensionsWorkbenchService.install(extension))));
+                this.notificationService.notify({
+                    severity: Severity.Info,
+                    message: ( localizeWithPath(
+                        'vs/workbench/contrib/extensions/browser/extensionsDependencyChecker',
+                        'finished installing missing deps',
+                        "Finished installing missing dependencies. Please reload the window now."
+                    )),
+                    actions: {
+                        primary: [( new Action('realod', ( localizeWithPath(
+                            'vs/workbench/contrib/extensions/browser/extensionsDependencyChecker',
+                            'reload',
+                            "Reload Window"
+                        )), '', true, () => this.hostService.reload()))]
+                    }
+                });
+            }
+        }
+        else {
+            this.notificationService.info(( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionsDependencyChecker',
+                'no missing deps',
+                "There are no missing dependencies to install."
+            )));
+        }
+    }
+};
+ExtensionDependencyChecker = ( __decorate([
+    ( __param(0, IExtensionService)),
+    ( __param(1, IExtensionsWorkbenchService)),
+    ( __param(2, INotificationService)),
+    ( __param(3, IHostService))
+], ExtensionDependencyChecker));
+
+export { ExtensionDependencyChecker };

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

@@ -0,0 +1,224 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import './media/extension.css.js';
+import { append, $, addDisposableListener } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { combinedDisposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ActionBar } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { ExtensionContainers, IExtensionsWorkbenchService } from 'vscode/vscode/vs/workbench/contrib/extensions/common/extensions';
+import { ActionWithDropDownAction, ExtensionActionWithDropdownActionViewItem, ExtensionDropDownAction, ExtensionStatusAction, ExtensionStatusLabelAction, MigrateDeprecatedExtensionAction, ReloadAction, UpdateAction, SkipUpdateAction, InstallDropdownAction, InstallingLabelAction, SetLanguageAction, ClearLanguageAction, RemoteInstallAction, LocalInstallAction, WebInstallAction, SwitchToReleasedVersionAction, SwitchToPreReleaseVersionAction, ManageExtensionAction } from 'vscode/vscode/vs/workbench/contrib/extensions/browser/extensionsActions';
+import { areSameExtensions } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagementUtil';
+import { extensionVerifiedPublisherIconColor, RecommendationWidget, PreReleaseBookmarkWidget, RemoteBadgeWidget, ExtensionPackCountWidget, VerifiedPublisherWidget, ExtensionHoverWidget, SyncIgnoredWidget, ExtensionActivationStatusWidget, InstallCountWidget, RatingsWidget } from './extensionsWidgets.js';
+import { IExtensionService, toExtension } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { IExtensionManagementServerService } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { isLanguagePackExtension } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
+import { registerThemingParticipant } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { WORKBENCH_BACKGROUND } from 'vscode/vscode/vs/workbench/common/theme';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { verifiedPublisherIcon } from 'vscode/vscode/vs/workbench/contrib/extensions/browser/extensionsIcons';
+
+const EXTENSION_LIST_ELEMENT_HEIGHT = 72;
+class Delegate {
+    getHeight() { return EXTENSION_LIST_ELEMENT_HEIGHT; }
+    getTemplateId() { return 'extension'; }
+}
+let Renderer = class Renderer {
+    constructor(extensionViewState, options, instantiationService, notificationService, extensionService, extensionManagementServerService, extensionsWorkbenchService, contextMenuService) {
+        this.extensionViewState = extensionViewState;
+        this.options = options;
+        this.instantiationService = instantiationService;
+        this.notificationService = notificationService;
+        this.extensionService = extensionService;
+        this.extensionManagementServerService = extensionManagementServerService;
+        this.extensionsWorkbenchService = extensionsWorkbenchService;
+        this.contextMenuService = contextMenuService;
+    }
+    get templateId() { return 'extension'; }
+    renderTemplate(root) {
+        const recommendationWidget = this.instantiationService.createInstance(RecommendationWidget, append(root, $('.extension-bookmark-container')));
+        const preReleaseWidget = this.instantiationService.createInstance(PreReleaseBookmarkWidget, append(root, $('.extension-bookmark-container')));
+        const element = append(root, $('.extension-list-item'));
+        const iconContainer = append(element, $('.icon-container'));
+        const icon = append(iconContainer, $('img.icon', { alt: '' }));
+        const iconRemoteBadgeWidget = this.instantiationService.createInstance(RemoteBadgeWidget, iconContainer, false);
+        const extensionPackBadgeWidget = this.instantiationService.createInstance(ExtensionPackCountWidget, iconContainer);
+        const details = append(element, $('.details'));
+        const headerContainer = append(details, $('.header-container'));
+        const header = append(headerContainer, $('.header'));
+        const name = append(header, $('span.name'));
+        const installCount = append(header, $('span.install-count'));
+        const ratings = append(header, $('span.ratings'));
+        const syncIgnore = append(header, $('span.sync-ignored'));
+        const activationStatus = append(header, $('span.activation-status'));
+        const headerRemoteBadgeWidget = this.instantiationService.createInstance(RemoteBadgeWidget, header, false);
+        const description = append(details, $('.description.ellipsis'));
+        const footer = append(details, $('.footer'));
+        const publisher = append(footer, $('.author.ellipsis'));
+        const verifiedPublisherWidget = this.instantiationService.createInstance(VerifiedPublisherWidget, append(publisher, $(`.verified-publisher`)), true);
+        const publisherDisplayName = append(publisher, $('.publisher-name.ellipsis'));
+        const actionbar = ( new ActionBar(footer, {
+            animated: false,
+            actionViewItemProvider: (action) => {
+                if (action instanceof ActionWithDropDownAction) {
+                    return ( new ExtensionActionWithDropdownActionViewItem(
+                        action,
+                        { icon: true, label: true, menuActionsOrProvider: { getActions: () => action.menuActions }, menuActionClassNames: (action.class || '').split(' ') },
+                        this.contextMenuService
+                    ));
+                }
+                if (action instanceof ExtensionDropDownAction) {
+                    return action.createActionViewItem();
+                }
+                return undefined;
+            },
+            focusOnlyEnabledItems: true
+        }));
+        actionbar.setFocusable(false);
+        actionbar.onDidRun(({ error }) => error && this.notificationService.error(error));
+        const extensionStatusIconAction = this.instantiationService.createInstance(ExtensionStatusAction);
+        const actions = [
+            this.instantiationService.createInstance(ExtensionStatusLabelAction),
+            this.instantiationService.createInstance(MigrateDeprecatedExtensionAction, true),
+            this.instantiationService.createInstance(ReloadAction),
+            this.instantiationService.createInstance(ActionWithDropDownAction, 'extensions.updateActions', '', [[this.instantiationService.createInstance(UpdateAction, false)], [this.instantiationService.createInstance(SkipUpdateAction)]]),
+            this.instantiationService.createInstance(InstallDropdownAction),
+            this.instantiationService.createInstance(InstallingLabelAction),
+            this.instantiationService.createInstance(SetLanguageAction),
+            this.instantiationService.createInstance(ClearLanguageAction),
+            this.instantiationService.createInstance(RemoteInstallAction, false),
+            this.instantiationService.createInstance(LocalInstallAction),
+            this.instantiationService.createInstance(WebInstallAction),
+            extensionStatusIconAction,
+            this.instantiationService.createInstance(SwitchToReleasedVersionAction, true),
+            this.instantiationService.createInstance(SwitchToPreReleaseVersionAction, true),
+            this.instantiationService.createInstance(ManageExtensionAction)
+        ];
+        const extensionHoverWidget = this.instantiationService.createInstance(ExtensionHoverWidget, { target: root, position: this.options.hoverOptions.position }, extensionStatusIconAction);
+        const widgets = [
+            recommendationWidget,
+            preReleaseWidget,
+            iconRemoteBadgeWidget,
+            extensionPackBadgeWidget,
+            headerRemoteBadgeWidget,
+            verifiedPublisherWidget,
+            extensionHoverWidget,
+            this.instantiationService.createInstance(SyncIgnoredWidget, syncIgnore),
+            this.instantiationService.createInstance(ExtensionActivationStatusWidget, activationStatus, true),
+            this.instantiationService.createInstance(InstallCountWidget, installCount, true),
+            this.instantiationService.createInstance(RatingsWidget, ratings, true),
+        ];
+        const extensionContainers = this.instantiationService.createInstance(ExtensionContainers, [...actions, ...widgets]);
+        actionbar.push(actions, { icon: true, label: true });
+        const disposable = combinedDisposable(...actions, ...widgets, actionbar, extensionContainers);
+        return {
+            root, element, icon, name, installCount, ratings, description, publisherDisplayName, disposables: [disposable], actionbar,
+            extensionDisposables: [],
+            set extension(extension) {
+                extensionContainers.extension = extension;
+            }
+        };
+    }
+    renderPlaceholder(index, data) {
+        data.element.classList.add('loading');
+        data.root.removeAttribute('aria-label');
+        data.root.removeAttribute('data-extension-id');
+        data.extensionDisposables = dispose(data.extensionDisposables);
+        data.icon.src = '';
+        data.name.textContent = '';
+        data.description.textContent = '';
+        data.publisherDisplayName.textContent = '';
+        data.installCount.style.display = 'none';
+        data.ratings.style.display = 'none';
+        data.extension = null;
+    }
+    renderElement(extension, index, data) {
+        data.element.classList.remove('loading');
+        data.root.setAttribute('data-extension-id', extension.identifier.id);
+        if (extension.state !== 3  && !extension.server) {
+            extension = this.extensionsWorkbenchService.local.filter(e => e.server === extension.server && areSameExtensions(e.identifier, extension.identifier))[0] || extension;
+        }
+        data.extensionDisposables = dispose(data.extensionDisposables);
+        const computeEnablement = async () => {
+            if (extension.state === 3 ) {
+                if (!!extension.deprecationInfo) {
+                    return true;
+                }
+                if (this.extensionsWorkbenchService.canSetLanguage(extension)) {
+                    return false;
+                }
+                return !(await this.extensionsWorkbenchService.canInstall(extension));
+            }
+            else if (extension.local && !isLanguagePackExtension(extension.local.manifest)) {
+                const runningExtension = this.extensionService.extensions.filter(e => areSameExtensions({ id: e.identifier.value, uuid: e.uuid }, extension.identifier))[0];
+                return !(runningExtension && extension.server === this.extensionManagementServerService.getExtensionManagementServer(toExtension(runningExtension)));
+            }
+            return false;
+        };
+        const updateEnablement = async () => {
+            const disabled = await computeEnablement();
+            const deprecated = !!extension.deprecationInfo;
+            data.element.classList.toggle('deprecated', deprecated);
+            data.root.classList.toggle('disabled', disabled);
+        };
+        updateEnablement();
+        this.extensionService.onDidChangeExtensions(() => updateEnablement(), this, data.extensionDisposables);
+        data.extensionDisposables.push(addDisposableListener(data.icon, 'error', () => data.icon.src = extension.iconUrlFallback, { once: true }));
+        data.icon.src = extension.iconUrl;
+        if (!data.icon.complete) {
+            data.icon.style.visibility = 'hidden';
+            data.icon.onload = () => data.icon.style.visibility = 'inherit';
+        }
+        else {
+            data.icon.style.visibility = 'inherit';
+        }
+        data.name.textContent = extension.displayName;
+        data.description.textContent = extension.description;
+        const updatePublisher = () => {
+            data.publisherDisplayName.textContent = extension.publisherDisplayName;
+        };
+        updatePublisher();
+        Event.filter(this.extensionsWorkbenchService.onChange, e => !!e && areSameExtensions(e.identifier, extension.identifier))(() => updatePublisher(), this, data.extensionDisposables);
+        data.installCount.style.display = '';
+        data.ratings.style.display = '';
+        data.extension = extension;
+        if (extension.gallery && extension.gallery.properties && extension.gallery.properties.localizedLanguages && extension.gallery.properties.localizedLanguages.length) {
+            data.description.textContent = ( extension.gallery.properties.localizedLanguages.map(name => name[0].toLocaleUpperCase() + name.slice(1))).join(', ');
+        }
+        this.extensionViewState.onFocus(e => {
+            if (areSameExtensions(extension.identifier, e.identifier)) {
+                data.actionbar.setFocusable(true);
+            }
+        }, this, data.extensionDisposables);
+        this.extensionViewState.onBlur(e => {
+            if (areSameExtensions(extension.identifier, e.identifier)) {
+                data.actionbar.setFocusable(false);
+            }
+        }, this, data.extensionDisposables);
+    }
+    disposeElement(extension, index, data) {
+        data.extensionDisposables = dispose(data.extensionDisposables);
+    }
+    disposeTemplate(data) {
+        data.extensionDisposables = dispose(data.extensionDisposables);
+        data.disposables = dispose(data.disposables);
+    }
+};
+Renderer = ( __decorate([
+    ( __param(2, IInstantiationService)),
+    ( __param(3, INotificationService)),
+    ( __param(4, IExtensionService)),
+    ( __param(5, IExtensionManagementServerService)),
+    ( __param(6, IExtensionsWorkbenchService)),
+    ( __param(7, IContextMenuService))
+], Renderer));
+registerThemingParticipant((theme, collector) => {
+    const verifiedPublisherIconColor = theme.getColor(extensionVerifiedPublisherIconColor);
+    if (verifiedPublisherIconColor) {
+        const disabledVerifiedPublisherIconColor = ( verifiedPublisherIconColor.transparent(.5)).makeOpaque(WORKBENCH_BACKGROUND(theme));
+        collector.addRule(`.extensions-list .monaco-list .monaco-list-row.disabled .author .verified-publisher ${ThemeIcon.asCSSSelector(verifiedPublisherIcon)} { color: ${disabledVerifiedPublisherIconColor}; }`);
+    }
+});
+
+export { Delegate, Renderer };

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

@@ -0,0 +1,121 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { PickerQuickAccessProvider } from 'vscode/vscode/vs/platform/quickinput/browser/pickerQuickAccess';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { VIEWLET_ID } from 'vscode/vscode/vs/workbench/contrib/extensions/common/extensions';
+import { IExtensionGalleryService, IExtensionManagementService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagement';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IPaneCompositePartService } from 'vscode/vscode/vs/workbench/services/panecomposite/browser/panecomposite';
+
+var InstallExtensionQuickAccessProvider_1, ManageExtensionsQuickAccessProvider_1;
+let InstallExtensionQuickAccessProvider = class InstallExtensionQuickAccessProvider extends PickerQuickAccessProvider {
+    static { InstallExtensionQuickAccessProvider_1 = this; }
+    static { this.PREFIX = 'ext install '; }
+    constructor(paneCompositeService, galleryService, extensionsService, notificationService, logService) {
+        super(InstallExtensionQuickAccessProvider_1.PREFIX);
+        this.paneCompositeService = paneCompositeService;
+        this.galleryService = galleryService;
+        this.extensionsService = extensionsService;
+        this.notificationService = notificationService;
+        this.logService = logService;
+    }
+    _getPicks(filter, disposables, token) {
+        if (!filter) {
+            return [{
+                    label: ( localizeWithPath(
+                        'vs/workbench/contrib/extensions/browser/extensionsQuickAccess',
+                        'type',
+                        "Type an extension name to install or search."
+                    ))
+                }];
+        }
+        const genericSearchPickItem = {
+            label: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionsQuickAccess',
+                'searchFor',
+                "Press Enter to search for extension '{0}'.",
+                filter
+            )),
+            accept: () => this.searchExtension(filter)
+        };
+        if (/\./.test(filter)) {
+            return this.getPicksForExtensionId(filter, genericSearchPickItem, token);
+        }
+        return [genericSearchPickItem];
+    }
+    async getPicksForExtensionId(filter, fallback, token) {
+        try {
+            const [galleryExtension] = await this.galleryService.getExtensions([{ id: filter }], token);
+            if (token.isCancellationRequested) {
+                return [];
+            }
+            if (!galleryExtension) {
+                return [fallback];
+            }
+            return [{
+                    label: ( localizeWithPath(
+                        'vs/workbench/contrib/extensions/browser/extensionsQuickAccess',
+                        'install',
+                        "Press Enter to install extension '{0}'.",
+                        filter
+                    )),
+                    accept: () => this.installExtension(galleryExtension, filter)
+                }];
+        }
+        catch (error) {
+            if (token.isCancellationRequested) {
+                return [];
+            }
+            this.logService.error(error);
+            return [fallback];
+        }
+    }
+    async installExtension(extension, name) {
+        try {
+            await openExtensionsViewlet(this.paneCompositeService, `@id:${name}`);
+            await this.extensionsService.installFromGallery(extension);
+        }
+        catch (error) {
+            this.notificationService.error(error);
+        }
+    }
+    async searchExtension(name) {
+        openExtensionsViewlet(this.paneCompositeService, name);
+    }
+};
+InstallExtensionQuickAccessProvider = InstallExtensionQuickAccessProvider_1 = ( __decorate([
+    ( __param(0, IPaneCompositePartService)),
+    ( __param(1, IExtensionGalleryService)),
+    ( __param(2, IExtensionManagementService)),
+    ( __param(3, INotificationService)),
+    ( __param(4, ILogService))
+], InstallExtensionQuickAccessProvider));
+let ManageExtensionsQuickAccessProvider = class ManageExtensionsQuickAccessProvider extends PickerQuickAccessProvider {
+    static { ManageExtensionsQuickAccessProvider_1 = this; }
+    static { this.PREFIX = 'ext '; }
+    constructor(paneCompositeService) {
+        super(ManageExtensionsQuickAccessProvider_1.PREFIX);
+        this.paneCompositeService = paneCompositeService;
+    }
+    _getPicks() {
+        return [{
+                label: ( localizeWithPath(
+                    'vs/workbench/contrib/extensions/browser/extensionsQuickAccess',
+                    'manage',
+                    "Press Enter to manage your extensions."
+                )),
+                accept: () => openExtensionsViewlet(this.paneCompositeService)
+            }];
+    }
+};
+ManageExtensionsQuickAccessProvider = ManageExtensionsQuickAccessProvider_1 = ( __decorate([
+    ( __param(0, IPaneCompositePartService))
+], ManageExtensionsQuickAccessProvider));
+async function openExtensionsViewlet(paneCompositeService, search = '') {
+    const viewlet = await paneCompositeService.openPaneComposite(VIEWLET_ID, 0 , true);
+    const view = viewlet?.getViewPaneContainer();
+    view?.search(search);
+    view?.focus();
+}
+
+export { InstallExtensionQuickAccessProvider, ManageExtensionsQuickAccessProvider };