@codingame/monaco-vscode-view-common-service-override 26.2.2 → 27.0.0

package/vscode/src/vs/workbench/services/views/browser/viewsService.js

@@ -0,0 +1,711 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable, DisposableMap, toDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ViewContainerLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/views';
+import { IViewDescriptorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/views.service';
+import { FocusedViewContext, getVisbileViewContextKey } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contextkeys';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { RawContextKey, ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { isString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { registerAction2, Action2, MenuRegistry, MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { localize, localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { KeybindingWeight } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybindingsRegistry';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
+import { IContextMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service';
+import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { PaneComposite, PaneCompositeDescriptor } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/panecomposite';
+import { Parts } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService';
+import { IWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService.service';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { Categories } from '@codingame/monaco-vscode-api/vscode/vs/platform/action/common/actionCommonCategories';
+import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
+import { FilterViewPaneContainer } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/views/viewsViewlet';
+import { IPaneCompositePartService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/panecomposite/browser/panecomposite.service';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { IViewsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service';
+
+let ViewsService = class ViewsService extends Disposable {
+    constructor(
+        viewDescriptorService,
+        paneCompositeService,
+        contextKeyService,
+        layoutService,
+        editorService
+    ) {
+        super();
+        this.viewDescriptorService = viewDescriptorService;
+        this.paneCompositeService = paneCompositeService;
+        this.contextKeyService = contextKeyService;
+        this.layoutService = layoutService;
+        this.editorService = editorService;
+        this._onDidChangeViewVisibility = this._register(( new Emitter()));
+        this.onDidChangeViewVisibility = this._onDidChangeViewVisibility.event;
+        this._onDidChangeViewContainerVisibility = this._register(( new Emitter()));
+        this.onDidChangeViewContainerVisibility = this._onDidChangeViewContainerVisibility.event;
+        this._onDidChangeFocusedView = this._register(( new Emitter()));
+        this.onDidChangeFocusedView = this._onDidChangeFocusedView.event;
+        this.viewContainerDisposables = this._register(( new DisposableMap()));
+        this.viewDisposable = ( new Map());
+        this.enabledViewContainersContextKeys = ( new Map());
+        this.visibleViewContextKeys = ( new Map());
+        this.viewPaneContainers = ( new Map());
+        this._register(toDisposable(() => {
+            this.viewDisposable.forEach(disposable => disposable.dispose());
+            this.viewDisposable.clear();
+        }));
+        this.viewDescriptorService.viewContainers.forEach(viewContainer => this.onDidRegisterViewContainer(
+            viewContainer,
+            this.viewDescriptorService.getViewContainerLocation(viewContainer)
+        ));
+        this._register(this.viewDescriptorService.onDidChangeViewContainers((
+            {
+                added,
+                removed
+            }
+        ) => this.onDidChangeContainers(added, removed)));
+        this._register(this.viewDescriptorService.onDidChangeContainerLocation((
+            {
+                viewContainer,
+                from,
+                to
+            }
+        ) => this.onDidChangeContainerLocation(viewContainer, from, to)));
+        this._register(
+            this.paneCompositeService.onDidPaneCompositeOpen(e => this._onDidChangeViewContainerVisibility.fire({
+                id: e.composite.getId(),
+                visible: true,
+                location: e.viewContainerLocation
+            }))
+        );
+        this._register(
+            this.paneCompositeService.onDidPaneCompositeClose(e => this._onDidChangeViewContainerVisibility.fire({
+                id: e.composite.getId(),
+                visible: false,
+                location: e.viewContainerLocation
+            }))
+        );
+        this.focusedViewContextKey = FocusedViewContext.bindTo(contextKeyService);
+    }
+    onViewsAdded(added) {
+        for (const view of added) {
+            this.onViewsVisibilityChanged(view, view.isBodyVisible());
+        }
+    }
+    onViewsVisibilityChanged(view, visible) {
+        this.getOrCreateActiveViewContextKey(view).set(visible);
+        this._onDidChangeViewVisibility.fire({
+            id: view.id,
+            visible: visible
+        });
+    }
+    onViewsRemoved(removed) {
+        for (const view of removed) {
+            this.onViewsVisibilityChanged(view, false);
+        }
+    }
+    getOrCreateActiveViewContextKey(view) {
+        const visibleContextKeyId = getVisbileViewContextKey(view.id);
+        let contextKey = this.visibleViewContextKeys.get(visibleContextKeyId);
+        if (!contextKey) {
+            contextKey = ( new RawContextKey(visibleContextKeyId, false)).bindTo(this.contextKeyService);
+            this.visibleViewContextKeys.set(visibleContextKeyId, contextKey);
+        }
+        return contextKey;
+    }
+    onDidChangeContainers(added, removed) {
+        for (const {
+            container,
+            location
+        } of removed) {
+            this.onDidDeregisterViewContainer(container, location);
+        }
+        for (const {
+            container,
+            location
+        } of added) {
+            this.onDidRegisterViewContainer(container, location);
+        }
+    }
+    onDidRegisterViewContainer(viewContainer, viewContainerLocation) {
+        this.registerPaneComposite(viewContainer, viewContainerLocation);
+        const disposables = ( new DisposableStore());
+        const viewContainerModel = this.viewDescriptorService.getViewContainerModel(viewContainer);
+        this.onViewDescriptorsAdded(viewContainerModel.allViewDescriptors, viewContainer);
+        disposables.add(viewContainerModel.onDidChangeAllViewDescriptors((
+            {
+                added,
+                removed
+            }
+        ) => {
+            this.onViewDescriptorsAdded(added, viewContainer);
+            this.onViewDescriptorsRemoved(removed);
+        }));
+        this.updateViewContainerEnablementContextKey(viewContainer);
+        disposables.add(
+            viewContainerModel.onDidChangeActiveViewDescriptors(() => this.updateViewContainerEnablementContextKey(viewContainer))
+        );
+        disposables.add(this.registerOpenViewContainerAction(viewContainer));
+        this.viewContainerDisposables.set(viewContainer.id, disposables);
+    }
+    onDidDeregisterViewContainer(viewContainer, viewContainerLocation) {
+        this.deregisterPaneComposite(viewContainer, viewContainerLocation);
+        this.viewContainerDisposables.deleteAndDispose(viewContainer.id);
+    }
+    onDidChangeContainerLocation(viewContainer, from, to) {
+        this.deregisterPaneComposite(viewContainer, from);
+        this.registerPaneComposite(viewContainer, to);
+        if (this.layoutService.isVisible(this.paneCompositeService.getPartId(to)) && this.viewDescriptorService.getViewContainersByLocation(to).filter(vc => this.isViewContainerActive(vc.id)).length === 1) {
+            this.openViewContainer(viewContainer.id);
+        }
+    }
+    onViewDescriptorsAdded(views, container) {
+        const location = this.viewDescriptorService.getViewContainerLocation(container);
+        if (location === null) {
+            return;
+        }
+        for (const viewDescriptor of views) {
+            const disposables = ( new DisposableStore());
+            disposables.add(this.registerOpenViewAction(viewDescriptor));
+            disposables.add(this.registerFocusViewAction(viewDescriptor, container.title));
+            disposables.add(this.registerResetViewLocationAction(viewDescriptor));
+            this.viewDisposable.set(viewDescriptor, disposables);
+        }
+    }
+    onViewDescriptorsRemoved(views) {
+        for (const view of views) {
+            const disposable = this.viewDisposable.get(view);
+            if (disposable) {
+                disposable.dispose();
+                this.viewDisposable.delete(view);
+            }
+        }
+    }
+    updateViewContainerEnablementContextKey(viewContainer) {
+        let contextKey = this.enabledViewContainersContextKeys.get(viewContainer.id);
+        if (!contextKey) {
+            contextKey = this.contextKeyService.createKey(getEnabledViewContainerContextKey(viewContainer.id), false);
+            this.enabledViewContainersContextKeys.set(viewContainer.id, contextKey);
+        }
+        contextKey.set(
+            !(viewContainer.hideIfEmpty && this.viewDescriptorService.getViewContainerModel(viewContainer).activeViewDescriptors.length === 0)
+        );
+    }
+    async openComposite(compositeId, location, focus) {
+        return this.paneCompositeService.openPaneComposite(compositeId, location, focus);
+    }
+    getComposite(compositeId, location) {
+        return this.paneCompositeService.getPaneComposite(compositeId, location);
+    }
+    isViewContainerVisible(id) {
+        const viewContainer = this.viewDescriptorService.getViewContainerById(id);
+        if (!viewContainer) {
+            return false;
+        }
+        const viewContainerLocation = this.viewDescriptorService.getViewContainerLocation(viewContainer);
+        if (viewContainerLocation === null) {
+            return false;
+        }
+        return this.paneCompositeService.getActivePaneComposite(viewContainerLocation)?.getId() === id;
+    }
+    isViewContainerActive(id) {
+        const viewContainer = this.viewDescriptorService.getViewContainerById(id);
+        if (!viewContainer) {
+            return false;
+        }
+        if (!this.contextKeyService.contextMatchesRules(viewContainer.when)) {
+            return false;
+        }
+        if (!viewContainer.hideIfEmpty) {
+            return true;
+        }
+        return this.viewDescriptorService.getViewContainerModel(viewContainer).activeViewDescriptors.length > 0;
+    }
+    getVisibleViewContainer(location) {
+        const viewContainerId = this.paneCompositeService.getActivePaneComposite(location)?.getId();
+        return viewContainerId ? this.viewDescriptorService.getViewContainerById(viewContainerId) : null;
+    }
+    getActiveViewPaneContainerWithId(viewContainerId) {
+        const viewContainer = this.viewDescriptorService.getViewContainerById(viewContainerId);
+        return viewContainer ? this.getActiveViewPaneContainer(viewContainer) : null;
+    }
+    async openViewContainer(id, focus) {
+        const viewContainer = this.viewDescriptorService.getViewContainerById(id);
+        if (viewContainer) {
+            const viewContainerLocation = this.viewDescriptorService.getViewContainerLocation(viewContainer);
+            if (viewContainerLocation !== null) {
+                const paneComposite = await this.paneCompositeService.openPaneComposite(id, viewContainerLocation, focus);
+                return paneComposite || null;
+            }
+        }
+        return null;
+    }
+    async closeViewContainer(id) {
+        const viewContainer = this.viewDescriptorService.getViewContainerById(id);
+        if (viewContainer) {
+            const viewContainerLocation = this.viewDescriptorService.getViewContainerLocation(viewContainer);
+            const isActive = viewContainerLocation !== null && this.paneCompositeService.getActivePaneComposite(viewContainerLocation);
+            if (viewContainerLocation !== null) {
+                return isActive ? this.layoutService.setPartHidden(true, this.paneCompositeService.getPartId(viewContainerLocation)) : undefined;
+            }
+        }
+    }
+    isViewVisible(id) {
+        const activeView = this.getActiveViewWithId(id);
+        return activeView?.isBodyVisible() || false;
+    }
+    getActiveViewWithId(id) {
+        const viewContainer = this.viewDescriptorService.getViewContainerByViewId(id);
+        if (viewContainer) {
+            const activeViewPaneContainer = this.getActiveViewPaneContainer(viewContainer);
+            if (activeViewPaneContainer) {
+                return activeViewPaneContainer.getView(id);
+            }
+        }
+        return null;
+    }
+    getViewWithId(id) {
+        const viewContainer = this.viewDescriptorService.getViewContainerByViewId(id);
+        if (viewContainer) {
+            const viewPaneContainer = this.viewPaneContainers.get(viewContainer.id);
+            if (viewPaneContainer) {
+                return viewPaneContainer.getView(id);
+            }
+        }
+        return null;
+    }
+    getFocusedView() {
+        const viewId = this.contextKeyService.getContextKeyValue(FocusedViewContext.key) ?? "";
+        return this.viewDescriptorService.getViewDescriptorById(( viewId.toString()));
+    }
+    getFocusedViewName() {
+        const textEditorFocused = this.editorService.activeTextEditorControl?.hasTextFocus() ? ( localize(16131, "Text Editor")) : undefined;
+        return this.getFocusedView()?.name?.value ?? textEditorFocused ?? "";
+    }
+    async openView(id, focus) {
+        const viewContainer = this.viewDescriptorService.getViewContainerByViewId(id);
+        if (!viewContainer) {
+            return null;
+        }
+        if (!( this.viewDescriptorService.getViewContainerModel(viewContainer).activeViewDescriptors.some(viewDescriptor => viewDescriptor.id === id))) {
+            return null;
+        }
+        const location = this.viewDescriptorService.getViewContainerLocation(viewContainer);
+        const compositeDescriptor = this.getComposite(viewContainer.id, location);
+        if (compositeDescriptor) {
+            const paneComposite = await this.openComposite(compositeDescriptor.id, location);
+            if (paneComposite?.openView) {
+                return paneComposite.openView(id, focus) || null;
+            } else if (focus) {
+                paneComposite?.focus();
+            }
+        }
+        return null;
+    }
+    closeView(id) {
+        const viewContainer = this.viewDescriptorService.getViewContainerByViewId(id);
+        if (viewContainer) {
+            const activeViewPaneContainer = this.getActiveViewPaneContainer(viewContainer);
+            if (activeViewPaneContainer) {
+                const view = activeViewPaneContainer.getView(id);
+                if (view) {
+                    if (activeViewPaneContainer.views.length === 1) {
+                        const location = this.viewDescriptorService.getViewContainerLocation(viewContainer);
+                        if (location === ViewContainerLocation.Sidebar) {
+                            this.layoutService.setPartHidden(true, Parts.SIDEBAR_PART);
+                        } else if (location === ViewContainerLocation.Panel || location === ViewContainerLocation.AuxiliaryBar) {
+                            this.paneCompositeService.hideActivePaneComposite(location);
+                        }
+                        if (this.focusedViewContextKey.get() === id) {
+                            this.focusedViewContextKey.reset();
+                        }
+                    } else {
+                        view.setExpanded(false);
+                    }
+                }
+            }
+        }
+    }
+    getActiveViewPaneContainer(viewContainer) {
+        const location = this.viewDescriptorService.getViewContainerLocation(viewContainer);
+        if (location === null) {
+            return null;
+        }
+        const activePaneComposite = this.paneCompositeService.getActivePaneComposite(location);
+        if (activePaneComposite?.getId() === viewContainer.id) {
+            return activePaneComposite.getViewPaneContainer() || null;
+        }
+        return null;
+    }
+    getViewProgressIndicator(viewId) {
+        const viewContainer = this.viewDescriptorService.getViewContainerByViewId(viewId);
+        if (!viewContainer) {
+            return undefined;
+        }
+        const viewPaneContainer = this.viewPaneContainers.get(viewContainer.id);
+        if (!viewPaneContainer) {
+            return undefined;
+        }
+        const view = viewPaneContainer.getView(viewId);
+        if (!view) {
+            return undefined;
+        }
+        if (viewPaneContainer.isViewMergedWithContainer()) {
+            return this.getViewContainerProgressIndicator(viewContainer);
+        }
+        return view.getProgressIndicator();
+    }
+    getViewContainerProgressIndicator(viewContainer) {
+        const viewContainerLocation = this.viewDescriptorService.getViewContainerLocation(viewContainer);
+        if (viewContainerLocation === null) {
+            return undefined;
+        }
+        return this.paneCompositeService.getProgressIndicator(viewContainer.id, viewContainerLocation);
+    }
+    registerOpenViewContainerAction(viewContainer) {
+        const disposables = ( new DisposableStore());
+        if (viewContainer.openCommandActionDescriptor) {
+            const {
+                id,
+                mnemonicTitle,
+                keybindings,
+                order
+            } = viewContainer.openCommandActionDescriptor ?? {
+                id: viewContainer.id
+            };
+            const title = viewContainer.openCommandActionDescriptor.title ?? viewContainer.title;
+            const that = this;
+            disposables.add(registerAction2(class OpenViewContainerAction extends Action2 {
+                constructor() {
+                    super({
+                        id,
+                        get title() {
+                            const viewContainerLocation = that.viewDescriptorService.getViewContainerLocation(viewContainer);
+                            const localizedTitle = typeof title === "string" ? title : title.value;
+                            const originalTitle = typeof title === "string" ? title : title.original;
+                            if (viewContainerLocation === ViewContainerLocation.Sidebar) {
+                                return {
+                                    value: ( localize(16132, "Show {0}", localizedTitle)),
+                                    original: `Show ${originalTitle}`
+                                };
+                            } else {
+                                return {
+                                    value: ( localize(16133, "Toggle {0}", localizedTitle)),
+                                    original: `Toggle ${originalTitle}`
+                                };
+                            }
+                        },
+                        category: Categories.View,
+                        precondition: ( ContextKeyExpr.has(getEnabledViewContainerContextKey(viewContainer.id))),
+                        keybinding: keybindings ? {
+                            ...keybindings,
+                            weight: KeybindingWeight.WorkbenchContrib
+                        } : undefined,
+                        f1: true
+                    });
+                }
+                async run(serviceAccessor) {
+                    const editorGroupService = serviceAccessor.get(IEditorGroupsService);
+                    const viewDescriptorService = serviceAccessor.get(IViewDescriptorService);
+                    const layoutService = serviceAccessor.get(IWorkbenchLayoutService);
+                    const viewsService = serviceAccessor.get(IViewsService);
+                    const viewContainerLocation = viewDescriptorService.getViewContainerLocation(viewContainer);
+                    switch (viewContainerLocation) {
+                    case ViewContainerLocation.AuxiliaryBar:
+                    case ViewContainerLocation.Sidebar:
+                        {
+                            const part = viewContainerLocation === ViewContainerLocation.Sidebar ? Parts.SIDEBAR_PART : Parts.AUXILIARYBAR_PART;
+                            if (!viewsService.isViewContainerVisible(viewContainer.id) || !layoutService.hasFocus(part)) {
+                                await viewsService.openViewContainer(viewContainer.id, true);
+                            } else {
+                                editorGroupService.activeGroup.focus();
+                            }
+                            break;
+                        }
+                    case ViewContainerLocation.Panel:
+                        if (!viewsService.isViewContainerVisible(viewContainer.id) || !layoutService.hasFocus(Parts.PANEL_PART)) {
+                            await viewsService.openViewContainer(viewContainer.id, true);
+                        } else {
+                            viewsService.closeViewContainer(viewContainer.id);
+                        }
+                        break;
+                    }
+                }
+            }));
+            if (mnemonicTitle) {
+                const defaultLocation = this.viewDescriptorService.getDefaultViewContainerLocation(viewContainer);
+                disposables.add(MenuRegistry.appendMenuItem(MenuId.MenubarViewMenu, {
+                    command: {
+                        id,
+                        title: mnemonicTitle
+                    },
+                    group: defaultLocation === ViewContainerLocation.Sidebar ? "3_sidebar" : defaultLocation === ViewContainerLocation.AuxiliaryBar ? "4_auxbar" : "5_panel",
+                    when: ( ContextKeyExpr.has(getEnabledViewContainerContextKey(viewContainer.id))),
+                    order: order ?? Number.MAX_VALUE
+                }));
+            }
+        }
+        return disposables;
+    }
+    registerOpenViewAction(viewDescriptor) {
+        const disposables = ( new DisposableStore());
+        const title = viewDescriptor.openCommandActionDescriptor?.title ?? viewDescriptor.name;
+        const commandId = viewDescriptor.openCommandActionDescriptor?.id ?? `${viewDescriptor.id}.open`;
+        const that = this;
+        disposables.add(registerAction2(class OpenViewAction extends Action2 {
+            constructor() {
+                super({
+                    id: commandId,
+                    get title() {
+                        const viewContainerLocation = that.viewDescriptorService.getViewLocationById(viewDescriptor.id);
+                        const localizedTitle = typeof title === "string" ? title : title.value;
+                        const originalTitle = typeof title === "string" ? title : title.original;
+                        if (viewContainerLocation === ViewContainerLocation.Sidebar) {
+                            return {
+                                value: ( localize(16132, "Show {0}", localizedTitle)),
+                                original: `Show ${originalTitle}`
+                            };
+                        } else {
+                            return {
+                                value: ( localize(16133, "Toggle {0}", localizedTitle)),
+                                original: `Toggle ${originalTitle}`
+                            };
+                        }
+                    },
+                    category: Categories.View,
+                    precondition: ( ContextKeyExpr.has(`${viewDescriptor.id}.active`)),
+                    keybinding: viewDescriptor.openCommandActionDescriptor?.keybindings ? {
+                        ...viewDescriptor.openCommandActionDescriptor.keybindings,
+                        weight: KeybindingWeight.WorkbenchContrib
+                    } : undefined,
+                    f1: viewDescriptor.openCommandActionDescriptor ? true : undefined,
+                    metadata: {
+                        description: ( localize(16134, "Opens view {0}", viewDescriptor.name.value)),
+                        args: [{
+                            name: "options",
+                            schema: {
+                                type: "object",
+                                properties: {
+                                    "preserveFocus": {
+                                        type: "boolean",
+                                        default: false,
+                                        description: ( localize(16135, "Whether to preserve the existing focus when opening the view."))
+                                    }
+                                }
+                            }
+                        }]
+                    }
+                });
+            }
+            async run(serviceAccessor, options) {
+                const editorGroupService = serviceAccessor.get(IEditorGroupsService);
+                const viewDescriptorService = serviceAccessor.get(IViewDescriptorService);
+                const layoutService = serviceAccessor.get(IWorkbenchLayoutService);
+                const viewsService = serviceAccessor.get(IViewsService);
+                const contextKeyService = serviceAccessor.get(IContextKeyService);
+                const focusedViewId = FocusedViewContext.getValue(contextKeyService);
+                if (focusedViewId === viewDescriptor.id && !options?.preserveFocus) {
+                    const viewLocation = viewDescriptorService.getViewLocationById(viewDescriptor.id);
+                    if (viewDescriptorService.getViewLocationById(viewDescriptor.id) === ViewContainerLocation.Sidebar) {
+                        editorGroupService.activeGroup.focus();
+                    } else if (viewLocation !== null) {
+                        layoutService.setPartHidden(true, that.paneCompositeService.getPartId(viewLocation));
+                    }
+                } else {
+                    await viewsService.openView(viewDescriptor.id, !options?.preserveFocus);
+                }
+            }
+        }));
+        if (viewDescriptor.openCommandActionDescriptor?.mnemonicTitle) {
+            const defaultViewContainer = this.viewDescriptorService.getDefaultContainerById(viewDescriptor.id);
+            if (defaultViewContainer) {
+                const defaultLocation = this.viewDescriptorService.getDefaultViewContainerLocation(defaultViewContainer);
+                disposables.add(MenuRegistry.appendMenuItem(MenuId.MenubarViewMenu, {
+                    command: {
+                        id: commandId,
+                        title: viewDescriptor.openCommandActionDescriptor.mnemonicTitle
+                    },
+                    group: defaultLocation === ViewContainerLocation.Sidebar ? "3_sidebar" : defaultLocation === ViewContainerLocation.AuxiliaryBar ? "4_auxbar" : "5_panel",
+                    when: ( ContextKeyExpr.has(`${viewDescriptor.id}.active`)),
+                    order: viewDescriptor.openCommandActionDescriptor.order ?? Number.MAX_VALUE
+                }));
+            }
+        }
+        return disposables;
+    }
+    registerFocusViewAction(viewDescriptor, category) {
+        return registerAction2(class FocusViewAction extends Action2 {
+            constructor() {
+                const title = ( localize2(16136, "Focus on {0} View", viewDescriptor.name.value));
+                super({
+                    id: viewDescriptor.focusCommand ? viewDescriptor.focusCommand.id : `${viewDescriptor.id}.focus`,
+                    title,
+                    category,
+                    menu: [{
+                        id: MenuId.CommandPalette,
+                        when: viewDescriptor.when
+                    }],
+                    keybinding: {
+                        when: ( ContextKeyExpr.has(`${viewDescriptor.id}.active`)),
+                        weight: KeybindingWeight.WorkbenchContrib,
+                        primary: viewDescriptor.focusCommand?.keybindings?.primary,
+                        secondary: viewDescriptor.focusCommand?.keybindings?.secondary,
+                        linux: viewDescriptor.focusCommand?.keybindings?.linux,
+                        mac: viewDescriptor.focusCommand?.keybindings?.mac,
+                        win: viewDescriptor.focusCommand?.keybindings?.win
+                    },
+                    metadata: {
+                        description: title.value,
+                        args: [{
+                            name: "focusOptions",
+                            description: "Focus Options",
+                            schema: {
+                                type: "object",
+                                properties: {
+                                    "preserveFocus": {
+                                        type: "boolean",
+                                        default: false
+                                    }
+                                }
+                            }
+                        }]
+                    }
+                });
+            }
+            run(accessor, options) {
+                accessor.get(IViewsService).openView(viewDescriptor.id, !options?.preserveFocus);
+            }
+        });
+    }
+    registerResetViewLocationAction(viewDescriptor) {
+        return registerAction2(class ResetViewLocationAction extends Action2 {
+            constructor() {
+                super({
+                    id: `${viewDescriptor.id}.resetViewLocation`,
+                    title: ( localize2(16137, "Reset Location")),
+                    menu: [{
+                        id: MenuId.ViewTitleContext,
+                        when: ( ContextKeyExpr.or(( ContextKeyExpr.and(( ContextKeyExpr.equals("view", viewDescriptor.id)), ( ContextKeyExpr.equals(`${viewDescriptor.id}.defaultViewLocation`, false)))))),
+                        group: "1_hide",
+                        order: 2
+                    }]
+                });
+            }
+            run(accessor) {
+                const viewDescriptorService = accessor.get(IViewDescriptorService);
+                const defaultContainer = viewDescriptorService.getDefaultContainerById(viewDescriptor.id);
+                const containerModel = viewDescriptorService.getViewContainerModel(defaultContainer);
+                if (defaultContainer.hideIfEmpty && containerModel.visibleViewDescriptors.length === 0) {
+                    const defaultLocation = viewDescriptorService.getDefaultViewContainerLocation(defaultContainer);
+                    viewDescriptorService.moveViewContainerToLocation(defaultContainer, defaultLocation, undefined, this.desc.id);
+                }
+                viewDescriptorService.moveViewsToContainer([viewDescriptor], defaultContainer, undefined, this.desc.id);
+                accessor.get(IViewsService).openView(viewDescriptor.id, true);
+            }
+        });
+    }
+    registerPaneComposite(viewContainer, viewContainerLocation) {
+        const that = this;
+        let PaneContainer = class PaneContainer extends PaneComposite {
+            constructor(
+                telemetryService,
+                contextService,
+                storageService,
+                instantiationService,
+                themeService,
+                contextMenuService,
+                extensionService
+            ) {
+                super(
+                    viewContainer.id,
+                    telemetryService,
+                    storageService,
+                    instantiationService,
+                    themeService,
+                    contextMenuService,
+                    extensionService,
+                    contextService
+                );
+            }
+            createViewPaneContainer(element) {
+                const viewPaneContainerDisposables = this._register(( new DisposableStore()));
+                const viewPaneContainer = that.createViewPaneContainer(
+                    element,
+                    viewContainer,
+                    viewContainerLocation,
+                    viewPaneContainerDisposables,
+                    this.instantiationService
+                );
+                if (!(viewPaneContainer instanceof FilterViewPaneContainer)) {
+                    viewPaneContainerDisposables.add(Event.any(
+                        viewPaneContainer.onDidAddViews,
+                        viewPaneContainer.onDidRemoveViews,
+                        viewPaneContainer.onTitleAreaUpdate
+                    )(() => {
+                        this.updateTitleArea();
+                    }));
+                }
+                return viewPaneContainer;
+            }
+        };
+        PaneContainer = ( __decorate([( __param(0, ITelemetryService)), ( __param(1, IWorkspaceContextService)), ( __param(2, IStorageService)), ( __param(3, IInstantiationService)), ( __param(4, IThemeService)), ( __param(5, IContextMenuService)), ( __param(6, IExtensionService))], PaneContainer));
+        ( Registry.as(this.paneCompositeService.getRegistryId(viewContainerLocation))).registerPaneComposite(PaneCompositeDescriptor.create(
+            PaneContainer,
+            viewContainer.id,
+            typeof viewContainer.title === "string" ? viewContainer.title : viewContainer.title.value,
+            isString(viewContainer.icon) ? viewContainer.icon : undefined,
+            viewContainer.order,
+            viewContainer.requestedIndex,
+            viewContainer.icon instanceof URI ? viewContainer.icon : undefined
+        ));
+    }
+    deregisterPaneComposite(viewContainer, viewContainerLocation) {
+        ( Registry.as(this.paneCompositeService.getRegistryId(viewContainerLocation))).deregisterPaneComposite(viewContainer.id);
+    }
+    createViewPaneContainer(
+        element,
+        viewContainer,
+        viewContainerLocation,
+        disposables,
+        instantiationService
+    ) {
+        const viewPaneContainer = instantiationService.createInstance(
+            viewContainer.ctorDescriptor.ctor,
+            ...(viewContainer.ctorDescriptor.staticArguments || [])
+        );
+        this.viewPaneContainers.set(viewPaneContainer.getId(), viewPaneContainer);
+        disposables.add(
+            toDisposable(() => this.viewPaneContainers.delete(viewPaneContainer.getId()))
+        );
+        disposables.add(viewPaneContainer.onDidAddViews(views => this.onViewsAdded(views)));
+        disposables.add(
+            viewPaneContainer.onDidChangeViewVisibility(view => this.onViewsVisibilityChanged(view, view.isBodyVisible()))
+        );
+        disposables.add(viewPaneContainer.onDidRemoveViews(views => this.onViewsRemoved(views)));
+        disposables.add(viewPaneContainer.onDidFocusView(view => {
+            if (this.focusedViewContextKey.get() !== view.id) {
+                this.focusedViewContextKey.set(view.id);
+                this._onDidChangeFocusedView.fire();
+            }
+        }));
+        disposables.add(viewPaneContainer.onDidBlurView(view => {
+            if (this.focusedViewContextKey.get() === view.id) {
+                this.focusedViewContextKey.reset();
+                this._onDidChangeFocusedView.fire();
+            }
+        }));
+        return viewPaneContainer;
+    }
+};
+ViewsService = ( __decorate([( __param(0, IViewDescriptorService)), ( __param(1, IPaneCompositePartService)), ( __param(2, IContextKeyService)), ( __param(3, IWorkbenchLayoutService)), ( __param(4, IEditorService))], ViewsService));
+function getEnabledViewContainerContextKey(viewContainerId) {
+    return `viewContainer.${viewContainerId}.enabled`;
+}
+
+export { ViewsService };