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

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

@@ -0,0 +1,912 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import './media/extensionsViewlet.css.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { Delayer, timeout, Promises } from 'monaco-editor/esm/vs/base/common/async.js';
+import { isCancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { createErrorWithActions } from 'monaco-editor/esm/vs/base/common/errorMessage.js';
+import { Disposable, MutableDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { append, $, hide, DragAndDropObserver, show, trackFocus, Dimension } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { VIEWLET_ID, CONTEXT_HAS_GALLERY, OUTDATED_EXTENSIONS_VIEW_ID, WORKSPACE_RECOMMENDATIONS_VIEW_ID, INSTALL_EXTENSION_FROM_VSIX_COMMAND_ID, AutoCheckUpdatesConfigurationKey, CloseExtensionDetailsOnViewChangeKey, IExtensionsWorkbenchService } from 'vscode/vscode/vs/workbench/contrib/extensions/common/extensions';
+import { InstallLocalExtensionsInRemoteAction, InstallRemoteExtensionsInLocalAction } from 'vscode/vscode/vs/workbench/contrib/extensions/browser/extensionsActions';
+import { IExtensionManagementService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagement';
+import { IExtensionManagementServerService, IWorkbenchExtensionEnablementService } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement';
+import { ExtensionsInput } from '../common/extensionsInput.js';
+import { ServerInstalledExtensionsView, DefaultPopularExtensionsView, DefaultRecommendedExtensionsView, EnabledExtensionsView, DisabledExtensionsView, SearchMarketplaceExtensionsView, ExtensionsListView, RecentlyUpdatedExtensionsView, OutdatedExtensionsView, WorkspaceRecommendedExtensionsView, RecommendedExtensionsView, BuiltInFeatureExtensionsView, BuiltInThemesExtensionsView, BuiltInProgrammingLanguageExtensionsView, UntrustedWorkspaceUnsupportedExtensionsView, UntrustedWorkspacePartiallySupportedExtensionsView, VirtualWorkspaceUnsupportedExtensionsView, VirtualWorkspacePartiallySupportedExtensionsView, DeprecatedExtensionsView } from './extensionsViews.js';
+import { IProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
+import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
+import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
+import { NumberBadge, IActivityService } from 'vscode/vscode/vs/workbench/services/activity/common/activity';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { Extensions, IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { RawContextKey, ContextKeyExpr, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { NotificationPriority, INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host';
+import { IWorkbenchLayoutService } from 'vscode/vscode/vs/workbench/services/layout/browser/layoutService';
+import { ViewPaneContainer } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPaneContainer';
+import { Query } from '../common/extensionQuery.js';
+import { SuggestEnabledInput } from 'vscode/vscode/vs/workbench/contrib/codeEditor/browser/suggestEnabledInput/suggestEnabledInput';
+import { alert } from 'monaco-editor/esm/vs/base/browser/ui/aria/aria.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { IPreferencesService } from 'vscode/vscode/vs/workbench/services/preferences/common/preferences';
+import { SIDE_BAR_DRAG_AND_DROP_BACKGROUND } from 'vscode/vscode/vs/workbench/common/theme';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
+import { WorkbenchStateContext, VirtualWorkspaceContext } from 'vscode/vscode/vs/workbench/common/contextkeys';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { installLocalInRemoteIcon } from 'vscode/vscode/vs/workbench/contrib/extensions/browser/extensionsIcons';
+import { registerAction2, Action2, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { IPaneCompositePartService } from 'vscode/vscode/vs/workbench/services/panecomposite/browser/panecomposite';
+import { coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { extractEditorsAndFilesDropData } from 'monaco-editor/esm/vs/platform/dnd/browser/dnd.js';
+import { extname } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { areSameExtensions } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagementUtil';
+import { registerNavigableContainer } from 'vscode/vscode/vs/workbench/browser/actions/widgetNavigationCommands';
+
+const DefaultViewsContext = ( new RawContextKey('defaultExtensionViews', true));
+const ExtensionsSortByContext = ( new RawContextKey('extensionsSortByValue', ''));
+const SearchMarketplaceExtensionsContext = ( new RawContextKey('searchMarketplaceExtensions', false));
+const SearchHasTextContext = ( new RawContextKey('extensionSearchHasText', false));
+const SearchInstalledExtensionsContext = ( new RawContextKey('searchInstalledExtensions', false));
+const SearchRecentlyUpdatedExtensionsContext = ( new RawContextKey('searchRecentlyUpdatedExtensions', false));
+const SearchExtensionUpdatesContext = ( new RawContextKey('searchExtensionUpdates', false));
+const SearchOutdatedExtensionsContext = ( new RawContextKey('searchOutdatedExtensions', false));
+const SearchEnabledExtensionsContext = ( new RawContextKey('searchEnabledExtensions', false));
+const SearchDisabledExtensionsContext = ( new RawContextKey('searchDisabledExtensions', false));
+const HasInstalledExtensionsContext = ( new RawContextKey('hasInstalledExtensions', true));
+const BuiltInExtensionsContext = ( new RawContextKey('builtInExtensions', false));
+const SearchBuiltInExtensionsContext = ( new RawContextKey('searchBuiltInExtensions', false));
+const SearchUnsupportedWorkspaceExtensionsContext = ( new RawContextKey('searchUnsupportedWorkspaceExtensions', false));
+const SearchDeprecatedExtensionsContext = ( new RawContextKey('searchDeprecatedExtensions', false));
+const RecommendedExtensionsContext = ( new RawContextKey('recommendedExtensions', false));
+const SortByUpdateDateContext = ( new RawContextKey('sortByUpdateDate', false));
+const REMOTE_CATEGORY = { value: ( localizeWithPath(
+    'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+    { key: 'remote', comment: ['Remote as in remote machine'] },
+    "Remote"
+)), original: 'Remote' };
+let ExtensionsViewletViewsContribution = class ExtensionsViewletViewsContribution {
+    constructor(extensionManagementServerService, labelService, viewDescriptorService, contextKeyService) {
+        this.extensionManagementServerService = extensionManagementServerService;
+        this.labelService = labelService;
+        this.contextKeyService = contextKeyService;
+        this.container = viewDescriptorService.getViewContainerById(VIEWLET_ID);
+        this.registerViews();
+    }
+    registerViews() {
+        const viewDescriptors = [];
+        viewDescriptors.push(...this.createDefaultExtensionsViewDescriptors());
+        viewDescriptors.push(...this.createSearchExtensionsViewDescriptors());
+        viewDescriptors.push(...this.createRecommendedExtensionsViewDescriptors());
+        viewDescriptors.push(...this.createBuiltinExtensionsViewDescriptors());
+        viewDescriptors.push(...this.createUnsupportedWorkspaceExtensionsViewDescriptors());
+        viewDescriptors.push(...this.createOtherLocalFilteredExtensionsViewDescriptors());
+        ( Registry.as(Extensions.ViewsRegistry)).registerViews(viewDescriptors, this.container);
+    }
+    createDefaultExtensionsViewDescriptors() {
+        const viewDescriptors = [];
+        const servers = [];
+        if (this.extensionManagementServerService.localExtensionManagementServer) {
+            servers.push(this.extensionManagementServerService.localExtensionManagementServer);
+        }
+        if (this.extensionManagementServerService.remoteExtensionManagementServer) {
+            servers.push(this.extensionManagementServerService.remoteExtensionManagementServer);
+        }
+        if (this.extensionManagementServerService.webExtensionManagementServer) {
+            servers.push(this.extensionManagementServerService.webExtensionManagementServer);
+        }
+        const getViewName = (viewTitle, server) => {
+            return servers.length > 1 ? `${server.label} - ${viewTitle}` : viewTitle;
+        };
+        let installedWebExtensionsContextChangeEvent = Event.None;
+        if (this.extensionManagementServerService.webExtensionManagementServer && this.extensionManagementServerService.remoteExtensionManagementServer) {
+            const interestingContextKeys = ( new Set());
+            interestingContextKeys.add('hasInstalledWebExtensions');
+            installedWebExtensionsContextChangeEvent = Event.filter(this.contextKeyService.onDidChangeContext, e => e.affectsSome(interestingContextKeys));
+        }
+        const serverLabelChangeEvent = Event.any(this.labelService.onDidChangeFormatters, installedWebExtensionsContextChangeEvent);
+        for (const server of servers) {
+            const getInstalledViewName = () => getViewName(( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+                'installed',
+                "Installed"
+            )), server);
+            const onDidChangeTitle = ( Event.map(serverLabelChangeEvent, () => getInstalledViewName()));
+            const id = servers.length > 1 ? `workbench.views.extensions.${server.id}.installed` : `workbench.views.extensions.installed`;
+            viewDescriptors.push({
+                id,
+                get name() { return getInstalledViewName(); },
+                weight: 100,
+                order: 1,
+                when: ( ContextKeyExpr.and(DefaultViewsContext)),
+                ctorDescriptor: ( new SyncDescriptor(
+                    ServerInstalledExtensionsView,
+                    [{ server, flexibleHeight: true, onDidChangeTitle }]
+                )),
+                canToggleVisibility: servers.length === 1
+            });
+            if (server === this.extensionManagementServerService.remoteExtensionManagementServer && this.extensionManagementServerService.localExtensionManagementServer) {
+                registerAction2(class InstallLocalExtensionsInRemoteAction2 extends Action2 {
+                    constructor() {
+                        super({
+                            id: 'workbench.extensions.installLocalExtensions',
+                            get title() {
+                                return {
+                                    value: ( localizeWithPath(
+                                        'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+                                        'select and install local extensions',
+                                        "Install Local Extensions in '{0}'...",
+                                        server.label
+                                    )),
+                                    original: `Install Local Extensions in '${server.label}'...`,
+                                };
+                            },
+                            category: REMOTE_CATEGORY,
+                            icon: installLocalInRemoteIcon,
+                            f1: true,
+                            menu: {
+                                id: MenuId.ViewTitle,
+                                when: ( ContextKeyExpr.equals('view', id)),
+                                group: 'navigation',
+                            }
+                        });
+                    }
+                    run(accessor) {
+                        return accessor.get(IInstantiationService).createInstance(InstallLocalExtensionsInRemoteAction).run();
+                    }
+                });
+            }
+        }
+        if (this.extensionManagementServerService.localExtensionManagementServer && this.extensionManagementServerService.remoteExtensionManagementServer) {
+            registerAction2(class InstallRemoteExtensionsInLocalAction2 extends Action2 {
+                constructor() {
+                    super({
+                        id: 'workbench.extensions.actions.installLocalExtensionsInRemote',
+                        title: { value: ( localizeWithPath(
+                            'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+                            'install remote in local',
+                            "Install Remote Extensions Locally..."
+                        )), original: 'Install Remote Extensions Locally...' },
+                        category: REMOTE_CATEGORY,
+                        f1: true
+                    });
+                }
+                run(accessor) {
+                    return accessor.get(IInstantiationService).createInstance(InstallRemoteExtensionsInLocalAction, 'workbench.extensions.actions.installLocalExtensionsInRemote').run();
+                }
+            });
+        }
+        viewDescriptors.push({
+            id: 'workbench.views.extensions.popular',
+            name: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+                'popularExtensions',
+                "Popular"
+            )),
+            ctorDescriptor: ( new SyncDescriptor(DefaultPopularExtensionsView, [{ hideBadge: true }])),
+            when: ( ContextKeyExpr.and(
+                DefaultViewsContext,
+                ContextKeyExpr.not('hasInstalledExtensions'),
+                CONTEXT_HAS_GALLERY
+            )),
+            weight: 60,
+            order: 2,
+            canToggleVisibility: false
+        });
+        viewDescriptors.push({
+            id: 'extensions.recommendedList',
+            name: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+                'recommendedExtensions',
+                "Recommended"
+            )),
+            ctorDescriptor: ( new SyncDescriptor(DefaultRecommendedExtensionsView, [{ flexibleHeight: true }])),
+            when: ( ContextKeyExpr.and(DefaultViewsContext, ( SortByUpdateDateContext.negate()), ContextKeyExpr.not('config.extensions.showRecommendationsOnlyOnDemand'), CONTEXT_HAS_GALLERY)),
+            weight: 40,
+            order: 3,
+            canToggleVisibility: true
+        });
+        if (servers.length === 1) {
+            viewDescriptors.push({
+                id: 'workbench.views.extensions.enabled',
+                name: ( localizeWithPath(
+                    'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+                    'enabledExtensions',
+                    "Enabled"
+                )),
+                ctorDescriptor: ( new SyncDescriptor(EnabledExtensionsView, [{}])),
+                when: ( ContextKeyExpr.and(DefaultViewsContext, ( ContextKeyExpr.has('hasInstalledExtensions')))),
+                hideByDefault: true,
+                weight: 40,
+                order: 4,
+                canToggleVisibility: true
+            });
+            viewDescriptors.push({
+                id: 'workbench.views.extensions.disabled',
+                name: ( localizeWithPath(
+                    'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+                    'disabledExtensions',
+                    "Disabled"
+                )),
+                ctorDescriptor: ( new SyncDescriptor(DisabledExtensionsView, [{}])),
+                when: ( ContextKeyExpr.and(DefaultViewsContext, ( ContextKeyExpr.has('hasInstalledExtensions')))),
+                hideByDefault: true,
+                weight: 10,
+                order: 5,
+                canToggleVisibility: true
+            });
+        }
+        return viewDescriptors;
+    }
+    createSearchExtensionsViewDescriptors() {
+        const viewDescriptors = [];
+        viewDescriptors.push({
+            id: 'workbench.views.extensions.marketplace',
+            name: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+                'marketPlace',
+                "Marketplace"
+            )),
+            ctorDescriptor: ( new SyncDescriptor(SearchMarketplaceExtensionsView, [{}])),
+            when: ( ContextKeyExpr.and(( ContextKeyExpr.has('searchMarketplaceExtensions')))),
+        });
+        viewDescriptors.push({
+            id: 'workbench.views.extensions.searchInstalled',
+            name: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+                'installed',
+                "Installed"
+            )),
+            ctorDescriptor: ( new SyncDescriptor(ExtensionsListView, [{}])),
+            when: ( ContextKeyExpr.and(( ContextKeyExpr.has('searchInstalledExtensions')))),
+        });
+        viewDescriptors.push({
+            id: 'workbench.views.extensions.searchRecentlyUpdated',
+            name: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+                'recently updated',
+                "Recently Updated"
+            )),
+            ctorDescriptor: ( new SyncDescriptor(RecentlyUpdatedExtensionsView, [{}])),
+            when: ( ContextKeyExpr.or(SearchExtensionUpdatesContext, ( ContextKeyExpr.has('searchRecentlyUpdatedExtensions')))),
+            order: 2,
+        });
+        viewDescriptors.push({
+            id: 'workbench.views.extensions.searchEnabled',
+            name: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+                'enabled',
+                "Enabled"
+            )),
+            ctorDescriptor: ( new SyncDescriptor(ExtensionsListView, [{}])),
+            when: ( ContextKeyExpr.and(( ContextKeyExpr.has('searchEnabledExtensions')))),
+        });
+        viewDescriptors.push({
+            id: 'workbench.views.extensions.searchDisabled',
+            name: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+                'disabled',
+                "Disabled"
+            )),
+            ctorDescriptor: ( new SyncDescriptor(ExtensionsListView, [{}])),
+            when: ( ContextKeyExpr.and(( ContextKeyExpr.has('searchDisabledExtensions')))),
+        });
+        viewDescriptors.push({
+            id: OUTDATED_EXTENSIONS_VIEW_ID,
+            name: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+                'availableUpdates',
+                "Available Updates"
+            )),
+            ctorDescriptor: ( new SyncDescriptor(OutdatedExtensionsView, [{}])),
+            when: ( ContextKeyExpr.or(SearchExtensionUpdatesContext, ( ContextKeyExpr.has('searchOutdatedExtensions')))),
+            order: 1,
+        });
+        viewDescriptors.push({
+            id: 'workbench.views.extensions.searchBuiltin',
+            name: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+                'builtin',
+                "Builtin"
+            )),
+            ctorDescriptor: ( new SyncDescriptor(ExtensionsListView, [{}])),
+            when: ( ContextKeyExpr.and(( ContextKeyExpr.has('searchBuiltInExtensions')))),
+        });
+        viewDescriptors.push({
+            id: 'workbench.views.extensions.searchWorkspaceUnsupported',
+            name: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+                'workspaceUnsupported',
+                "Workspace Unsupported"
+            )),
+            ctorDescriptor: ( new SyncDescriptor(ExtensionsListView, [{}])),
+            when: ( ContextKeyExpr.and(( ContextKeyExpr.has('searchWorkspaceUnsupportedExtensions')))),
+        });
+        return viewDescriptors;
+    }
+    createRecommendedExtensionsViewDescriptors() {
+        const viewDescriptors = [];
+        viewDescriptors.push({
+            id: WORKSPACE_RECOMMENDATIONS_VIEW_ID,
+            name: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+                'workspaceRecommendedExtensions',
+                "Workspace Recommendations"
+            )),
+            ctorDescriptor: ( new SyncDescriptor(WorkspaceRecommendedExtensionsView, [{}])),
+            when: ( ContextKeyExpr.and(( ContextKeyExpr.has('recommendedExtensions')), ( WorkbenchStateContext.notEqualsTo('empty')))),
+            order: 1
+        });
+        viewDescriptors.push({
+            id: 'workbench.views.extensions.otherRecommendations',
+            name: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+                'otherRecommendedExtensions',
+                "Other Recommendations"
+            )),
+            ctorDescriptor: ( new SyncDescriptor(RecommendedExtensionsView, [{}])),
+            when: ( ContextKeyExpr.has('recommendedExtensions')),
+            order: 2
+        });
+        return viewDescriptors;
+    }
+    createBuiltinExtensionsViewDescriptors() {
+        const viewDescriptors = [];
+        viewDescriptors.push({
+            id: 'workbench.views.extensions.builtinFeatureExtensions',
+            name: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+                'builtinFeatureExtensions',
+                "Features"
+            )),
+            ctorDescriptor: ( new SyncDescriptor(BuiltInFeatureExtensionsView, [{}])),
+            when: ( ContextKeyExpr.has('builtInExtensions')),
+        });
+        viewDescriptors.push({
+            id: 'workbench.views.extensions.builtinThemeExtensions',
+            name: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+                'builtInThemesExtensions',
+                "Themes"
+            )),
+            ctorDescriptor: ( new SyncDescriptor(BuiltInThemesExtensionsView, [{}])),
+            when: ( ContextKeyExpr.has('builtInExtensions')),
+        });
+        viewDescriptors.push({
+            id: 'workbench.views.extensions.builtinProgrammingLanguageExtensions',
+            name: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+                'builtinProgrammingLanguageExtensions',
+                "Programming Languages"
+            )),
+            ctorDescriptor: ( new SyncDescriptor(BuiltInProgrammingLanguageExtensionsView, [{}])),
+            when: ( ContextKeyExpr.has('builtInExtensions')),
+        });
+        return viewDescriptors;
+    }
+    createUnsupportedWorkspaceExtensionsViewDescriptors() {
+        const viewDescriptors = [];
+        viewDescriptors.push({
+            id: 'workbench.views.extensions.untrustedUnsupportedExtensions',
+            name: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+                'untrustedUnsupportedExtensions',
+                "Disabled in Restricted Mode"
+            )),
+            ctorDescriptor: ( new SyncDescriptor(UntrustedWorkspaceUnsupportedExtensionsView, [{}])),
+            when: ( ContextKeyExpr.and(SearchUnsupportedWorkspaceExtensionsContext)),
+        });
+        viewDescriptors.push({
+            id: 'workbench.views.extensions.untrustedPartiallySupportedExtensions',
+            name: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+                'untrustedPartiallySupportedExtensions',
+                "Limited in Restricted Mode"
+            )),
+            ctorDescriptor: ( new SyncDescriptor(UntrustedWorkspacePartiallySupportedExtensionsView, [{}])),
+            when: ( ContextKeyExpr.and(SearchUnsupportedWorkspaceExtensionsContext)),
+        });
+        viewDescriptors.push({
+            id: 'workbench.views.extensions.virtualUnsupportedExtensions',
+            name: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+                'virtualUnsupportedExtensions',
+                "Disabled in Virtual Workspaces"
+            )),
+            ctorDescriptor: ( new SyncDescriptor(VirtualWorkspaceUnsupportedExtensionsView, [{}])),
+            when: ( ContextKeyExpr.and(VirtualWorkspaceContext, SearchUnsupportedWorkspaceExtensionsContext)),
+        });
+        viewDescriptors.push({
+            id: 'workbench.views.extensions.virtualPartiallySupportedExtensions',
+            name: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+                'virtualPartiallySupportedExtensions',
+                "Limited in Virtual Workspaces"
+            )),
+            ctorDescriptor: ( new SyncDescriptor(VirtualWorkspacePartiallySupportedExtensionsView, [{}])),
+            when: ( ContextKeyExpr.and(VirtualWorkspaceContext, SearchUnsupportedWorkspaceExtensionsContext)),
+        });
+        return viewDescriptors;
+    }
+    createOtherLocalFilteredExtensionsViewDescriptors() {
+        const viewDescriptors = [];
+        viewDescriptors.push({
+            id: 'workbench.views.extensions.deprecatedExtensions',
+            name: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+                'deprecated',
+                "Deprecated"
+            )),
+            ctorDescriptor: ( new SyncDescriptor(DeprecatedExtensionsView, [{}])),
+            when: ( ContextKeyExpr.and(SearchDeprecatedExtensionsContext)),
+        });
+        return viewDescriptors;
+    }
+};
+ExtensionsViewletViewsContribution = ( __decorate([
+    ( __param(0, IExtensionManagementServerService)),
+    ( __param(1, ILabelService)),
+    ( __param(2, IViewDescriptorService)),
+    ( __param(3, IContextKeyService))
+], ExtensionsViewletViewsContribution));
+let ExtensionsViewPaneContainer = class ExtensionsViewPaneContainer extends ViewPaneContainer {
+    constructor(layoutService, telemetryService, progressService, instantiationService, editorGroupService, extensionsWorkbenchService, extensionManagementServerService, notificationService, paneCompositeService, themeService, configurationService, storageService, contextService, contextKeyService, contextMenuService, extensionService, viewDescriptorService, preferencesService, commandService) {
+        super(VIEWLET_ID, { mergeViewWithContainerWhenSingleView: true }, instantiationService, configurationService, layoutService, contextMenuService, telemetryService, extensionService, themeService, storageService, contextService, viewDescriptorService);
+        this.progressService = progressService;
+        this.editorGroupService = editorGroupService;
+        this.extensionsWorkbenchService = extensionsWorkbenchService;
+        this.extensionManagementServerService = extensionManagementServerService;
+        this.notificationService = notificationService;
+        this.paneCompositeService = paneCompositeService;
+        this.contextKeyService = contextKeyService;
+        this.preferencesService = preferencesService;
+        this.commandService = commandService;
+        this.searchDelayer = ( new Delayer(500));
+        this.defaultViewsContextKey = DefaultViewsContext.bindTo(contextKeyService);
+        this.sortByContextKey = ExtensionsSortByContext.bindTo(contextKeyService);
+        this.searchMarketplaceExtensionsContextKey = SearchMarketplaceExtensionsContext.bindTo(contextKeyService);
+        this.searchHasTextContextKey = SearchHasTextContext.bindTo(contextKeyService);
+        this.sortByUpdateDateContextKey = SortByUpdateDateContext.bindTo(contextKeyService);
+        this.searchInstalledExtensionsContextKey = SearchInstalledExtensionsContext.bindTo(contextKeyService);
+        this.searchRecentlyUpdatedExtensionsContextKey = SearchRecentlyUpdatedExtensionsContext.bindTo(contextKeyService);
+        this.searchExtensionUpdatesContextKey = SearchExtensionUpdatesContext.bindTo(contextKeyService);
+        this.searchWorkspaceUnsupportedExtensionsContextKey = SearchUnsupportedWorkspaceExtensionsContext.bindTo(contextKeyService);
+        this.searchDeprecatedExtensionsContextKey = SearchDeprecatedExtensionsContext.bindTo(contextKeyService);
+        this.searchOutdatedExtensionsContextKey = SearchOutdatedExtensionsContext.bindTo(contextKeyService);
+        this.searchEnabledExtensionsContextKey = SearchEnabledExtensionsContext.bindTo(contextKeyService);
+        this.searchDisabledExtensionsContextKey = SearchDisabledExtensionsContext.bindTo(contextKeyService);
+        this.hasInstalledExtensionsContextKey = HasInstalledExtensionsContext.bindTo(contextKeyService);
+        this.builtInExtensionsContextKey = BuiltInExtensionsContext.bindTo(contextKeyService);
+        this.searchBuiltInExtensionsContextKey = SearchBuiltInExtensionsContext.bindTo(contextKeyService);
+        this.recommendedExtensionsContextKey = RecommendedExtensionsContext.bindTo(contextKeyService);
+        this._register(this.paneCompositeService.onDidPaneCompositeOpen(e => { if (e.viewContainerLocation === 0 ) {
+            this.onViewletOpen(e.composite);
+        } }, this));
+        this._register(extensionsWorkbenchService.onReset(() => this.refresh()));
+        this.searchViewletState = this.getMemento(1 , 1 );
+    }
+    get searchValue() {
+        return this.searchBox?.getValue();
+    }
+    create(parent) {
+        parent.classList.add('extensions-viewlet');
+        this.root = parent;
+        const overlay = append(this.root, $('.overlay'));
+        const overlayBackgroundColor = this.getColor(SIDE_BAR_DRAG_AND_DROP_BACKGROUND) ?? '';
+        overlay.style.backgroundColor = overlayBackgroundColor;
+        hide(overlay);
+        const header = append(this.root, $('.header'));
+        const placeholder = ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+            'searchExtensions',
+            "Search Extensions in Marketplace"
+        ));
+        const searchValue = this.searchViewletState['query.value'] ? this.searchViewletState['query.value'] : '';
+        this.searchBox = this._register(this.instantiationService.createInstance(SuggestEnabledInput, `${VIEWLET_ID}.searchbox`, header, {
+            triggerCharacters: ['@'],
+            sortKey: (item) => {
+                if (item.indexOf(':') === -1) {
+                    return 'a';
+                }
+                else if (/ext:/.test(item) || /id:/.test(item) || /tag:/.test(item)) {
+                    return 'b';
+                }
+                else if (/sort:/.test(item)) {
+                    return 'c';
+                }
+                else {
+                    return 'd';
+                }
+            },
+            provideResults: (query) => Query.suggestions(query)
+        }, placeholder, 'extensions:searchinput', { placeholderText: placeholder, value: searchValue }));
+        this.updateInstalledExtensionsContexts();
+        if (this.searchBox.getValue()) {
+            this.triggerSearch();
+        }
+        this._register(this.searchBox.onInputDidChange(() => {
+            this.sortByContextKey.set(Query.parse(this.searchBox.getValue() || '').sortBy);
+            this.triggerSearch();
+        }, this));
+        this._register(this.searchBox.onShouldFocusResults(() => this.focusListView(), this));
+        this._register(( new DragAndDropObserver(this.root, {
+            onDragEnd: (e) => undefined,
+            onDragEnter: (e) => {
+                if (this.isSupportedDragElement(e)) {
+                    show(overlay);
+                }
+            },
+            onDragLeave: (e) => {
+                if (this.isSupportedDragElement(e)) {
+                    hide(overlay);
+                }
+            },
+            onDragOver: (e) => {
+                if (this.isSupportedDragElement(e)) {
+                    e.dataTransfer.dropEffect = 'copy';
+                }
+            },
+            onDrop: async (e) => {
+                if (this.isSupportedDragElement(e)) {
+                    hide(overlay);
+                    const vsixs = coalesce(( (await this.instantiationService.invokeFunction(accessor => extractEditorsAndFilesDropData(accessor, e)))
+                        .map(
+                        editor => editor.resource && extname(editor.resource) === '.vsix' ? editor.resource : undefined
+                    )));
+                    if (vsixs.length > 0) {
+                        try {
+                            await this.commandService.executeCommand(INSTALL_EXTENSION_FROM_VSIX_COMMAND_ID, vsixs);
+                        }
+                        catch (err) {
+                            this.notificationService.error(err);
+                        }
+                    }
+                }
+            }
+        })));
+        super.create(append(this.root, $('.extensions')));
+        const focusTracker = this._register(trackFocus(this.root));
+        const isSearchBoxFocused = () => this.searchBox?.inputWidget.hasWidgetFocus();
+        this._register(registerNavigableContainer({
+            focusNotifiers: [focusTracker],
+            focusNextWidget: () => {
+                if (isSearchBoxFocused()) {
+                    this.focusListView();
+                }
+            },
+            focusPreviousWidget: () => {
+                if (!isSearchBoxFocused()) {
+                    this.searchBox?.focus();
+                }
+            }
+        }));
+    }
+    focus() {
+        this.searchBox?.focus();
+    }
+    layout(dimension) {
+        if (this.root) {
+            this.root.classList.toggle('narrow', dimension.width <= 250);
+            this.root.classList.toggle('mini', dimension.width <= 200);
+        }
+        this.searchBox?.layout(( new Dimension(dimension.width - 34 -  8, 20)));
+        super.layout(( new Dimension(dimension.width, dimension.height - 41)));
+    }
+    getOptimalWidth() {
+        return 400;
+    }
+    search(value) {
+        if (this.searchBox && this.searchBox.getValue() !== value) {
+            this.searchBox.setValue(value);
+        }
+    }
+    async refresh() {
+        await this.updateInstalledExtensionsContexts();
+        this.doSearch(true);
+        if (this.configurationService.getValue(AutoCheckUpdatesConfigurationKey)) {
+            this.extensionsWorkbenchService.checkForUpdates();
+        }
+    }
+    async updateInstalledExtensionsContexts() {
+        const result = await this.extensionsWorkbenchService.queryLocal();
+        this.hasInstalledExtensionsContextKey.set(( result.some(r => !r.isBuiltin)));
+    }
+    triggerSearch() {
+        this.searchDelayer.trigger(() => this.doSearch(), this.searchBox && this.searchBox.getValue() ? 500 : 0).then(undefined, err => this.onError(err));
+    }
+    normalizedQuery() {
+        return this.searchBox
+            ? this.searchBox.getValue()
+                .trim()
+                .replace(/@category/g, 'category')
+                .replace(/@tag:/g, 'tag:')
+                .replace(/@ext:/g, 'ext:')
+                .replace(/@featured/g, 'featured')
+                .replace(/@popular/g, this.extensionManagementServerService.webExtensionManagementServer && !this.extensionManagementServerService.localExtensionManagementServer && !this.extensionManagementServerService.remoteExtensionManagementServer ? '@web' : '@popular')
+            : '';
+    }
+    saveState() {
+        const value = this.searchBox ? this.searchBox.getValue() : '';
+        if (ExtensionsListView.isLocalExtensionsQuery(value)) {
+            this.searchViewletState['query.value'] = value;
+        }
+        else {
+            this.searchViewletState['query.value'] = '';
+        }
+        super.saveState();
+    }
+    doSearch(refresh) {
+        const value = this.normalizedQuery();
+        this.contextKeyService.bufferChangeEvents(() => {
+            const isRecommendedExtensionsQuery = ExtensionsListView.isRecommendedExtensionsQuery(value);
+            this.searchHasTextContextKey.set(value.trim() !== '');
+            this.searchInstalledExtensionsContextKey.set(ExtensionsListView.isInstalledExtensionsQuery(value));
+            this.searchRecentlyUpdatedExtensionsContextKey.set(ExtensionsListView.isSearchRecentlyUpdatedQuery(value) && !ExtensionsListView.isSearchExtensionUpdatesQuery(value));
+            this.searchOutdatedExtensionsContextKey.set(ExtensionsListView.isOutdatedExtensionsQuery(value) && !ExtensionsListView.isSearchExtensionUpdatesQuery(value));
+            this.searchExtensionUpdatesContextKey.set(ExtensionsListView.isSearchExtensionUpdatesQuery(value));
+            this.searchEnabledExtensionsContextKey.set(ExtensionsListView.isEnabledExtensionsQuery(value));
+            this.searchDisabledExtensionsContextKey.set(ExtensionsListView.isDisabledExtensionsQuery(value));
+            this.searchBuiltInExtensionsContextKey.set(ExtensionsListView.isSearchBuiltInExtensionsQuery(value));
+            this.searchWorkspaceUnsupportedExtensionsContextKey.set(ExtensionsListView.isSearchWorkspaceUnsupportedExtensionsQuery(value));
+            this.searchDeprecatedExtensionsContextKey.set(ExtensionsListView.isSearchDeprecatedExtensionsQuery(value));
+            this.builtInExtensionsContextKey.set(ExtensionsListView.isBuiltInExtensionsQuery(value));
+            this.recommendedExtensionsContextKey.set(isRecommendedExtensionsQuery);
+            this.searchMarketplaceExtensionsContextKey.set(!!value && !ExtensionsListView.isLocalExtensionsQuery(value) && !isRecommendedExtensionsQuery);
+            this.sortByUpdateDateContextKey.set(ExtensionsListView.isSortUpdateDateQuery(value));
+            this.defaultViewsContextKey.set(!value || ExtensionsListView.isSortInstalledExtensionsQuery(value));
+        });
+        return this.progress(Promise.all(( this.panes.map(view => view.show(this.normalizedQuery(), refresh)
+            .then(model => this.alertSearchResult(model.length, view.id)))))).then(() => undefined);
+    }
+    onDidAddViewDescriptors(added) {
+        const addedViews = super.onDidAddViewDescriptors(added);
+        this.progress(Promise.all(( addedViews.map(addedView => addedView.show(this.normalizedQuery())
+            .then(model => this.alertSearchResult(model.length, addedView.id))))));
+        return addedViews;
+    }
+    alertSearchResult(count, viewId) {
+        const view = this.viewContainerModel.visibleViewDescriptors.find(view => view.id === viewId);
+        switch (count) {
+            case 0:
+                break;
+            case 1:
+                if (view) {
+                    alert(( localizeWithPath(
+                        'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+                        'extensionFoundInSection',
+                        "1 extension found in the {0} section.",
+                        view.name
+                    )));
+                }
+                else {
+                    alert(( localizeWithPath(
+                        'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+                        'extensionFound',
+                        "1 extension found."
+                    )));
+                }
+                break;
+            default:
+                if (view) {
+                    alert(( localizeWithPath(
+                        'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+                        'extensionsFoundInSection',
+                        "{0} extensions found in the {1} section.",
+                        count,
+                        view.name
+                    )));
+                }
+                else {
+                    alert(( localizeWithPath(
+                        'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+                        'extensionsFound',
+                        "{0} extensions found.",
+                        count
+                    )));
+                }
+                break;
+        }
+    }
+    getFirstExpandedPane() {
+        for (const pane of this.panes) {
+            if (pane.isExpanded() && pane instanceof ExtensionsListView) {
+                return pane;
+            }
+        }
+        return undefined;
+    }
+    focusListView() {
+        const pane = this.getFirstExpandedPane();
+        if (pane && pane.count() > 0) {
+            pane.focus();
+        }
+    }
+    onViewletOpen(viewlet) {
+        if (!viewlet || viewlet.getId() === VIEWLET_ID) {
+            return;
+        }
+        if (this.configurationService.getValue(CloseExtensionDetailsOnViewChangeKey)) {
+            const promises = ( this.editorGroupService.groups.map(group => {
+                const editors = group.editors.filter(input => input instanceof ExtensionsInput);
+                return group.closeEditors(editors);
+            }));
+            Promise.all(promises);
+        }
+    }
+    progress(promise) {
+        return this.progressService.withProgress({ location: 5  }, () => promise);
+    }
+    onError(err) {
+        if (isCancellationError(err)) {
+            return;
+        }
+        const message = err && err.message || '';
+        if (/ECONNREFUSED/.test(message)) {
+            const error = createErrorWithActions(( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+                'suggestProxyError',
+                "Marketplace returned 'ECONNREFUSED'. Please check the 'http.proxy' setting."
+            )), [
+                ( new Action('open user settings', ( localizeWithPath(
+                    'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+                    'open user settings',
+                    "Open User Settings"
+                )), undefined, true, () => this.preferencesService.openUserSettings()))
+            ]);
+            this.notificationService.error(error);
+            return;
+        }
+        this.notificationService.error(err);
+    }
+    isSupportedDragElement(e) {
+        if (e.dataTransfer) {
+            const typesLowerCase = ( e.dataTransfer.types.map(t => t.toLocaleLowerCase()));
+            return typesLowerCase.indexOf('files') !== -1;
+        }
+        return false;
+    }
+};
+ExtensionsViewPaneContainer = ( __decorate([
+    ( __param(0, IWorkbenchLayoutService)),
+    ( __param(1, ITelemetryService)),
+    ( __param(2, IProgressService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IEditorGroupsService)),
+    ( __param(5, IExtensionsWorkbenchService)),
+    ( __param(6, IExtensionManagementServerService)),
+    ( __param(7, INotificationService)),
+    ( __param(8, IPaneCompositePartService)),
+    ( __param(9, IThemeService)),
+    ( __param(10, IConfigurationService)),
+    ( __param(11, IStorageService)),
+    ( __param(12, IWorkspaceContextService)),
+    ( __param(13, IContextKeyService)),
+    ( __param(14, IContextMenuService)),
+    ( __param(15, IExtensionService)),
+    ( __param(16, IViewDescriptorService)),
+    ( __param(17, IPreferencesService)),
+    ( __param(18, ICommandService))
+], ExtensionsViewPaneContainer));
+let StatusUpdater = class StatusUpdater extends Disposable {
+    constructor(activityService, extensionsWorkbenchService, extensionEnablementService) {
+        super();
+        this.activityService = activityService;
+        this.extensionsWorkbenchService = extensionsWorkbenchService;
+        this.extensionEnablementService = extensionEnablementService;
+        this.badgeHandle = this._register(( new MutableDisposable()));
+        this.onServiceChange();
+        this._register(Event.debounce(extensionsWorkbenchService.onChange, () => undefined, 100, undefined, undefined, undefined, this._store)(this.onServiceChange, this));
+    }
+    onServiceChange() {
+        this.badgeHandle.clear();
+        const extensionsReloadRequired = this.extensionsWorkbenchService.installed.filter(e => e.reloadRequiredStatus !== undefined);
+        const outdated = this.extensionsWorkbenchService.outdated.reduce((r, e) => r + (this.extensionEnablementService.isEnabled(e.local) && !e.pinned && !extensionsReloadRequired.includes(e) ? 1 : 0), 0);
+        const newBadgeNumber = outdated + extensionsReloadRequired.length;
+        if (newBadgeNumber > 0) {
+            let msg = '';
+            if (outdated) {
+                msg += outdated === 1 ? ( localizeWithPath(
+                    'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+                    'extensionToUpdate',
+                    '{0} requires update',
+                    outdated
+                )) : ( localizeWithPath(
+                    'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+                    'extensionsToUpdate',
+                    '{0} require update',
+                    outdated
+                ));
+            }
+            if (outdated > 0 && extensionsReloadRequired.length > 0) {
+                msg += ', ';
+            }
+            if (extensionsReloadRequired.length) {
+                msg += extensionsReloadRequired.length === 1 ? ( localizeWithPath(
+                    'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+                    'extensionToReload',
+                    '{0} requires reload',
+                    extensionsReloadRequired.length
+                )) : ( localizeWithPath(
+                    'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+                    'extensionsToReload',
+                    '{0} require reload',
+                    extensionsReloadRequired.length
+                ));
+            }
+            const badge = ( new NumberBadge(newBadgeNumber, () => msg));
+            this.badgeHandle.value = this.activityService.showViewContainerActivity(VIEWLET_ID, { badge, clazz: 'extensions-badge count-badge' });
+        }
+    }
+};
+StatusUpdater = ( __decorate([
+    ( __param(0, IActivityService)),
+    ( __param(1, IExtensionsWorkbenchService)),
+    ( __param(2, IWorkbenchExtensionEnablementService))
+], StatusUpdater));
+let MaliciousExtensionChecker = class MaliciousExtensionChecker {
+    constructor(extensionsManagementService, hostService, logService, notificationService, environmentService) {
+        this.extensionsManagementService = extensionsManagementService;
+        this.hostService = hostService;
+        this.logService = logService;
+        this.notificationService = notificationService;
+        this.environmentService = environmentService;
+        if (!this.environmentService.disableExtensions) {
+            this.loopCheckForMaliciousExtensions();
+        }
+    }
+    loopCheckForMaliciousExtensions() {
+        this.checkForMaliciousExtensions()
+            .then(() => timeout(1000 * 60 * 5))
+            .then(() => this.loopCheckForMaliciousExtensions());
+    }
+    checkForMaliciousExtensions() {
+        return this.extensionsManagementService.getExtensionsControlManifest().then(extensionsControlManifest => {
+            return this.extensionsManagementService.getInstalled(1 ).then(installed => {
+                const maliciousExtensions = installed
+                    .filter(e => ( extensionsControlManifest.malicious.some(identifier => areSameExtensions(e.identifier, identifier))));
+                if (maliciousExtensions.length) {
+                    return Promises.settled(( maliciousExtensions.map(e => this.extensionsManagementService.uninstall(e).then(() => {
+                        this.notificationService.prompt(Severity.Warning, ( localizeWithPath(
+                            'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+                            'malicious warning',
+                            "We have uninstalled '{0}' which was reported to be problematic.",
+                            e.identifier.id
+                        )), [{
+                                label: ( localizeWithPath(
+                                    'vs/workbench/contrib/extensions/browser/extensionsViewlet',
+                                    'reloadNow',
+                                    "Reload Now"
+                                )),
+                                run: () => this.hostService.reload()
+                            }], {
+                            sticky: true,
+                            priority: NotificationPriority.URGENT
+                        });
+                    }))));
+                }
+                else {
+                    return Promise.resolve(undefined);
+                }
+            }).then(() => undefined);
+        }, err => this.logService.error(err));
+    }
+};
+MaliciousExtensionChecker = ( __decorate([
+    ( __param(0, IExtensionManagementService)),
+    ( __param(1, IHostService)),
+    ( __param(2, ILogService)),
+    ( __param(3, INotificationService)),
+    ( __param(4, IWorkbenchEnvironmentService))
+], MaliciousExtensionChecker));
+
+export { BuiltInExtensionsContext, DefaultViewsContext, ExtensionsSortByContext, ExtensionsViewPaneContainer, ExtensionsViewletViewsContribution, MaliciousExtensionChecker, RecommendedExtensionsContext, SearchHasTextContext, SearchMarketplaceExtensionsContext, StatusUpdater };