@codingame/monaco-vscode-api 1.78.4 → 1.78.5-next.0

package/dist/vscode/vs/workbench/browser/parts/views/viewPane.js

@@ -0,0 +1,520 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import "../../../../../../assets/paneviewlet.css";
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { asCssVariable, foreground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { SIDE_BAR_BACKGROUND, PANEL_BACKGROUND } from '../../../common/theme.js';
+import { trackFocus, append, $, addDisposableListener, EventType, asCssValueWithDefault, createCSSRule, asCSSUrl, after } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { prepareActions } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { Pane } from '../../../../base/browser/ui/splitview/paneview.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { ViewContainerLocationToString, defaultViewIcon, IViewsService, IViewDescriptorService, Extensions } from '../../../common/views.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { MenuId, SubmenuItemAction, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { createActionViewItem } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
+import { parseLinkedText } from 'monaco-editor/esm/vs/base/common/linkedText.js';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { Button } from 'monaco-editor/esm/vs/base/browser/ui/button/button.js';
+import { Link } from 'monaco-editor/esm/vs/platform/opener/browser/link.js';
+import { ProgressBar } from 'monaco-editor/esm/vs/base/browser/ui/progressbar/progressbar.js';
+import { ScopedProgressIndicator, AbstractProgressScope } from '../../../services/progress/browser/progressIndicator.js';
+import { DomScrollableElement } from 'monaco-editor/esm/vs/base/browser/ui/scrollbar/scrollableElement.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { CompositeMenuActions } from '../../actions.js';
+import { WorkbenchToolBar } from 'monaco-editor/esm/vs/platform/actions/browser/toolbar.js';
+import { BaseActionViewItem } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionViewItems.js';
+import { ServiceCollection } from 'monaco-editor/esm/vs/platform/instantiation/common/serviceCollection.js';
+import { defaultProgressBarStyles, defaultButtonStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
+const VIEWPANE_FILTER_ACTION = ( new Action('viewpane.action.filter'));
+const viewPaneContainerExpandedIcon = ( registerIcon('view-pane-container-expanded', Codicon.chevronDown, ( nls.localize(
+    'viewPaneContainerExpandedIcon',
+    'Icon for an expanded view pane container.'
+))));
+const viewPaneContainerCollapsedIcon = ( registerIcon('view-pane-container-collapsed', Codicon.chevronRight, ( nls.localize(
+    'viewPaneContainerCollapsedIcon',
+    'Icon for a collapsed view pane container.'
+))));
+const viewsRegistry = ( Registry.as(Extensions.ViewsRegistry));
+let ViewWelcomeController = class ViewWelcomeController {
+    get contents() {
+        const visibleItems = this.items.filter(v => v.visible);
+        if (visibleItems.length === 0 && this.defaultItem) {
+            return [this.defaultItem.descriptor];
+        }
+        return ( visibleItems.map(v => v.descriptor));
+    }
+    constructor(id, contextKeyService) {
+        this.id = id;
+        this.contextKeyService = contextKeyService;
+        this._onDidChange = ( new Emitter());
+        this.onDidChange = this._onDidChange.event;
+        this.items = [];
+        this.disposables = ( new DisposableStore());
+        contextKeyService.onDidChangeContext(this.onDidChangeContext, this, this.disposables);
+        Event.filter(viewsRegistry.onDidChangeViewWelcomeContent, id => id === this.id)(this.onDidChangeViewWelcomeContent, this, this.disposables);
+        this.onDidChangeViewWelcomeContent();
+    }
+    onDidChangeViewWelcomeContent() {
+        const descriptors = viewsRegistry.getViewWelcomeContent(this.id);
+        this.items = [];
+        for (const descriptor of descriptors) {
+            if (descriptor.when === 'default') {
+                this.defaultItem = { descriptor, visible: true };
+            }
+            else {
+                const visible = descriptor.when ? this.contextKeyService.contextMatchesRules(descriptor.when) : true;
+                this.items.push({ descriptor, visible });
+            }
+        }
+        this._onDidChange.fire();
+    }
+    onDidChangeContext() {
+        let didChange = false;
+        for (const item of this.items) {
+            if (!item.descriptor.when || item.descriptor.when === 'default') {
+                continue;
+            }
+            const visible = this.contextKeyService.contextMatchesRules(item.descriptor.when);
+            if (item.visible === visible) {
+                continue;
+            }
+            item.visible = visible;
+            didChange = true;
+        }
+        if (didChange) {
+            this._onDidChange.fire();
+        }
+    }
+    dispose() {
+        this.disposables.dispose();
+    }
+};
+ViewWelcomeController = ( __decorate([
+    ( __param(1, IContextKeyService))
+], ViewWelcomeController));
+let ViewPane = class ViewPane extends Pane {
+    get title() {
+        return this._title;
+    }
+    get titleDescription() {
+        return this._titleDescription;
+    }
+    constructor(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService) {
+        super({ ...options, ...{ orientation: viewDescriptorService.getViewLocationById(options.id) === 1  ? 1  : 0  } });
+        this.keybindingService = keybindingService;
+        this.contextMenuService = contextMenuService;
+        this.configurationService = configurationService;
+        this.contextKeyService = contextKeyService;
+        this.viewDescriptorService = viewDescriptorService;
+        this.instantiationService = instantiationService;
+        this.openerService = openerService;
+        this.themeService = themeService;
+        this.telemetryService = telemetryService;
+        this._onDidFocus = this._register(( new Emitter()));
+        this.onDidFocus = this._onDidFocus.event;
+        this._onDidBlur = this._register(( new Emitter()));
+        this.onDidBlur = this._onDidBlur.event;
+        this._onDidChangeBodyVisibility = this._register(( new Emitter()));
+        this.onDidChangeBodyVisibility = this._onDidChangeBodyVisibility.event;
+        this._onDidChangeTitleArea = this._register(( new Emitter()));
+        this.onDidChangeTitleArea = this._onDidChangeTitleArea.event;
+        this._onDidChangeViewWelcomeState = this._register(( new Emitter()));
+        this.onDidChangeViewWelcomeState = this._onDidChangeViewWelcomeState.event;
+        this._isVisible = false;
+        this.showActionsAlways = false;
+        this.viewWelcomeDisposable = Disposable.None;
+        this.id = options.id;
+        this._title = options.title;
+        this._titleDescription = options.titleDescription;
+        this.showActionsAlways = !!options.showActionsAlways;
+        this.scopedContextKeyService = this._register(contextKeyService.createScoped(this.element));
+        this.scopedContextKeyService.createKey('view', this.id);
+        const viewLocationKey = this.scopedContextKeyService.createKey('viewLocation', ViewContainerLocationToString(viewDescriptorService.getViewLocationById(this.id)));
+        this._register(Event.filter(viewDescriptorService.onDidChangeLocation, e => ( e.views.some(view => view.id === this.id)))(() => viewLocationKey.set(ViewContainerLocationToString(viewDescriptorService.getViewLocationById(this.id)))));
+        this.menuActions = this._register(this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, this.scopedContextKeyService]))).createInstance(CompositeMenuActions, options.titleMenuId ?? MenuId.ViewTitle, MenuId.ViewTitleContext, { shouldForwardArgs: !options.donotForwardArgs }));
+        this._register(this.menuActions.onDidChange(() => this.updateActions()));
+        this.viewWelcomeController = ( new ViewWelcomeController(this.id, contextKeyService));
+    }
+    get headerVisible() {
+        return super.headerVisible;
+    }
+    set headerVisible(visible) {
+        super.headerVisible = visible;
+        this.element.classList.toggle('merged-header', !visible);
+    }
+    setVisible(visible) {
+        if (this._isVisible !== visible) {
+            this._isVisible = visible;
+            if (this.isExpanded()) {
+                this._onDidChangeBodyVisibility.fire(visible);
+            }
+        }
+    }
+    isVisible() {
+        return this._isVisible;
+    }
+    isBodyVisible() {
+        return this._isVisible && this.isExpanded();
+    }
+    setExpanded(expanded) {
+        const changed = super.setExpanded(expanded);
+        if (changed) {
+            this._onDidChangeBodyVisibility.fire(expanded);
+        }
+        if (this.twistiesContainer) {
+            this.twistiesContainer.classList.remove(...ThemeIcon.asClassNameArray(this.getTwistyIcon(!expanded)));
+            this.twistiesContainer.classList.add(...ThemeIcon.asClassNameArray(this.getTwistyIcon(expanded)));
+        }
+        return changed;
+    }
+    render() {
+        super.render();
+        const focusTracker = trackFocus(this.element);
+        this._register(focusTracker);
+        this._register(focusTracker.onDidFocus(() => this._onDidFocus.fire()));
+        this._register(focusTracker.onDidBlur(() => this._onDidBlur.fire()));
+    }
+    renderHeader(container) {
+        this.headerContainer = container;
+        this.twistiesContainer = append(container, $(ThemeIcon.asCSSSelector(this.getTwistyIcon(this.isExpanded()))));
+        this.renderHeaderTitle(container, this.title);
+        const actions = append(container, $('.actions'));
+        actions.classList.toggle('show', this.showActionsAlways);
+        this.toolbar = this.instantiationService.createInstance(WorkbenchToolBar, actions, {
+            orientation: 0 ,
+            actionViewItemProvider: action => this.getActionViewItem(action),
+            ariaLabel: ( nls.localize('viewToolbarAriaLabel', "{0} actions", this.title)),
+            getKeyBinding: action => this.keybindingService.lookupKeybinding(action.id),
+            renderDropdownAsChildElement: true,
+            actionRunner: this.getActionRunner(),
+            resetMenu: this.menuActions.menuId
+        });
+        this._register(this.toolbar);
+        this.setActions();
+        this._register(addDisposableListener(actions, EventType.CLICK, e => e.preventDefault()));
+        const viewContainerModel = this.viewDescriptorService.getViewContainerByViewId(this.id);
+        if (viewContainerModel) {
+            this._register(this.viewDescriptorService.getViewContainerModel(viewContainerModel).onDidChangeContainerInfo(({ title }) => this.updateTitle(this.title)));
+        }
+        else {
+            console.error(`View container model not found for view ${this.id}`);
+        }
+        const onDidRelevantConfigurationChange = Event.filter(this.configurationService.onDidChangeConfiguration, e => e.affectsConfiguration(ViewPane.AlwaysShowActionsConfig));
+        this._register(onDidRelevantConfigurationChange(this.updateActionsVisibility, this));
+        this.updateActionsVisibility();
+    }
+    getTwistyIcon(expanded) {
+        return expanded ? viewPaneContainerExpandedIcon : viewPaneContainerCollapsedIcon;
+    }
+    style(styles) {
+        super.style(styles);
+        const icon = this.getIcon();
+        if (this.iconContainer) {
+            const fgColor = asCssValueWithDefault(styles.headerForeground, asCssVariable(foreground));
+            if (URI.isUri(icon)) {
+                this.iconContainer.style.backgroundColor = fgColor;
+                this.iconContainer.style.color = '';
+            }
+            else {
+                this.iconContainer.style.color = fgColor;
+                this.iconContainer.style.backgroundColor = '';
+            }
+        }
+    }
+    getIcon() {
+        return this.viewDescriptorService.getViewDescriptorById(this.id)?.containerIcon || defaultViewIcon;
+    }
+    renderHeaderTitle(container, title) {
+        this.iconContainer = append(container, $('.icon', undefined));
+        const icon = this.getIcon();
+        let cssClass = undefined;
+        if (URI.isUri(icon)) {
+            cssClass = `view-${this.id.replace(/[\.\:]/g, '-')}`;
+            const iconClass = `.pane-header .icon.${cssClass}`;
+            createCSSRule(iconClass, `
+				mask: ${asCSSUrl(icon)} no-repeat 50% 50%;
+				mask-size: 24px;
+				-webkit-mask: ${asCSSUrl(icon)} no-repeat 50% 50%;
+				-webkit-mask-size: 16px;
+			`);
+        }
+        else if (ThemeIcon.isThemeIcon(icon)) {
+            cssClass = ThemeIcon.asClassName(icon);
+        }
+        if (cssClass) {
+            this.iconContainer.classList.add(...cssClass.split(' '));
+        }
+        const calculatedTitle = this.calculateTitle(title);
+        this.titleContainer = append(container, $('h3.title', { title: calculatedTitle }, calculatedTitle));
+        if (this._titleDescription) {
+            this.setTitleDescription(this._titleDescription);
+        }
+        this.iconContainer.title = calculatedTitle;
+        this.iconContainer.setAttribute('aria-label', calculatedTitle);
+    }
+    updateTitle(title) {
+        const calculatedTitle = this.calculateTitle(title);
+        if (this.titleContainer) {
+            this.titleContainer.textContent = calculatedTitle;
+            this.titleContainer.setAttribute('title', calculatedTitle);
+        }
+        if (this.iconContainer) {
+            this.iconContainer.title = calculatedTitle;
+            this.iconContainer.setAttribute('aria-label', calculatedTitle);
+        }
+        this._title = title;
+        this._onDidChangeTitleArea.fire();
+    }
+    setTitleDescription(description) {
+        if (this.titleDescriptionContainer) {
+            this.titleDescriptionContainer.textContent = description ?? '';
+            this.titleDescriptionContainer.setAttribute('title', description ?? '');
+        }
+        else if (description && this.titleContainer) {
+            this.titleDescriptionContainer = after(this.titleContainer, $('span.description', { title: description }, description));
+        }
+    }
+    updateTitleDescription(description) {
+        this.setTitleDescription(description);
+        this._titleDescription = description;
+        this._onDidChangeTitleArea.fire();
+    }
+    calculateTitle(title) {
+        const viewContainer = this.viewDescriptorService.getViewContainerByViewId(this.id);
+        const model = this.viewDescriptorService.getViewContainerModel(viewContainer);
+        const viewDescriptor = this.viewDescriptorService.getViewDescriptorById(this.id);
+        const isDefault = this.viewDescriptorService.getDefaultContainerById(this.id) === viewContainer;
+        if (!isDefault && viewDescriptor?.containerTitle && model.title !== viewDescriptor.containerTitle) {
+            return `${viewDescriptor.containerTitle}: ${title}`;
+        }
+        return title;
+    }
+    renderBody(container) {
+        this.bodyContainer = container;
+        const viewWelcomeContainer = append(container, $('.welcome-view'));
+        this.viewWelcomeContainer = $('.welcome-view-content', { tabIndex: 0 });
+        this.scrollableElement = this._register(( new DomScrollableElement(this.viewWelcomeContainer, {
+            alwaysConsumeMouseWheel: true,
+            horizontal: 2 ,
+            vertical: 3 ,
+        })));
+        append(viewWelcomeContainer, this.scrollableElement.getDomNode());
+        const onViewWelcomeChange = Event.any(this.viewWelcomeController.onDidChange, this.onDidChangeViewWelcomeState);
+        this._register(onViewWelcomeChange(this.updateViewWelcome, this));
+        this.updateViewWelcome();
+    }
+    layoutBody(height, width) {
+        this.viewWelcomeContainer.style.height = `${height}px`;
+        this.viewWelcomeContainer.style.width = `${width}px`;
+        this.viewWelcomeContainer.classList.toggle('wide', width > 640);
+        this.scrollableElement.scanDomNode();
+    }
+    onDidScrollRoot() {
+    }
+    getProgressIndicator() {
+        if (this.progressBar === undefined) {
+            this.progressBar = this._register(( new ProgressBar(this.element, defaultProgressBarStyles)));
+            this.progressBar.hide();
+        }
+        if (this.progressIndicator === undefined) {
+            const that = this;
+            this.progressIndicator = ( new ScopedProgressIndicator(
+                assertIsDefined(this.progressBar),
+                new (class extends AbstractProgressScope {
+                    constructor() {
+                        super(that.id, that.isBodyVisible());
+                        this._register(that.onDidChangeBodyVisibility(isVisible => isVisible ? this.onScopeOpened(that.id) : this.onScopeClosed(that.id)));
+                    }
+                })()
+            ));
+        }
+        return this.progressIndicator;
+    }
+    getProgressLocation() {
+        return this.viewDescriptorService.getViewContainerByViewId(this.id).id;
+    }
+    getBackgroundColor() {
+        switch (this.viewDescriptorService.getViewLocationById(this.id)) {
+            case 1 :
+                return PANEL_BACKGROUND;
+            case 0 :
+            case 2 :
+                return SIDE_BAR_BACKGROUND;
+        }
+        return SIDE_BAR_BACKGROUND;
+    }
+    focus() {
+        if (this.shouldShowWelcome()) {
+            this.viewWelcomeContainer.focus();
+        }
+        else if (this.element) {
+            this.element.focus();
+            this._onDidFocus.fire();
+        }
+    }
+    setActions() {
+        if (this.toolbar) {
+            const primaryActions = [...this.menuActions.getPrimaryActions()];
+            if (this.shouldShowFilterInHeader()) {
+                primaryActions.unshift(VIEWPANE_FILTER_ACTION);
+            }
+            this.toolbar.setActions(prepareActions(primaryActions), prepareActions(this.menuActions.getSecondaryActions()));
+            this.toolbar.context = this.getActionsContext();
+        }
+    }
+    updateActionsVisibility() {
+        if (!this.headerContainer) {
+            return;
+        }
+        const shouldAlwaysShowActions = this.configurationService.getValue('workbench.view.alwaysShowHeaderActions');
+        this.headerContainer.classList.toggle('actions-always-visible', shouldAlwaysShowActions);
+    }
+    updateActions() {
+        this.setActions();
+        this._onDidChangeTitleArea.fire();
+    }
+    getActionViewItem(action, options) {
+        if (action.id === VIEWPANE_FILTER_ACTION.id) {
+            const that = this;
+            return new (class extends BaseActionViewItem {
+                constructor() { super(null, action); }
+                setFocusable() { }
+                get trapsArrowNavigation() { return true; }
+                render(container) {
+                    container.classList.add('viewpane-filter-container');
+                    append(container, that.getFilterWidget().element);
+                }
+            });
+        }
+        return createActionViewItem(this.instantiationService, action, { ...options, ...{ menuAsChild: action instanceof SubmenuItemAction } });
+    }
+    getActionsContext() {
+        return undefined;
+    }
+    getActionRunner() {
+        return undefined;
+    }
+    getOptimalWidth() {
+        return 0;
+    }
+    saveState() {
+    }
+    updateViewWelcome() {
+        this.viewWelcomeDisposable.dispose();
+        if (!this.shouldShowWelcome()) {
+            this.bodyContainer.classList.remove('welcome');
+            this.viewWelcomeContainer.innerText = '';
+            this.scrollableElement.scanDomNode();
+            return;
+        }
+        const contents = this.viewWelcomeController.contents;
+        if (contents.length === 0) {
+            this.bodyContainer.classList.remove('welcome');
+            this.viewWelcomeContainer.innerText = '';
+            this.scrollableElement.scanDomNode();
+            return;
+        }
+        const disposables = ( new DisposableStore());
+        this.bodyContainer.classList.add('welcome');
+        this.viewWelcomeContainer.innerText = '';
+        for (const { content, precondition } of contents) {
+            const lines = content.split('\n');
+            for (let line of lines) {
+                line = line.trim();
+                if (!line) {
+                    continue;
+                }
+                const linkedText = parseLinkedText(line);
+                if (linkedText.nodes.length === 1 && typeof linkedText.nodes[0] !== 'string') {
+                    const node = linkedText.nodes[0];
+                    const buttonContainer = append(this.viewWelcomeContainer, $('.button-container'));
+                    const button = ( new Button(
+                        buttonContainer,
+                        { title: node.title, supportIcons: true, ...defaultButtonStyles }
+                    ));
+                    button.label = node.label;
+                    button.onDidClick(_ => {
+                        this.telemetryService.publicLog2('views.welcomeAction', { viewId: this.id, uri: node.href });
+                        this.openerService.open(node.href, { allowCommands: true });
+                    }, null, disposables);
+                    disposables.add(button);
+                    if (precondition) {
+                        const updateEnablement = () => button.enabled = this.contextKeyService.contextMatchesRules(precondition);
+                        updateEnablement();
+                        const keys = ( new Set());
+                        ( precondition.keys()).forEach(key => keys.add(key));
+                        const onDidChangeContext = Event.filter(this.contextKeyService.onDidChangeContext, e => e.affectsSome(keys));
+                        onDidChangeContext(updateEnablement, null, disposables);
+                    }
+                }
+                else {
+                    const p = append(this.viewWelcomeContainer, $('p'));
+                    for (const node of linkedText.nodes) {
+                        if (typeof node === 'string') {
+                            append(p, document.createTextNode(node));
+                        }
+                        else {
+                            const link = disposables.add(this.instantiationService.createInstance(Link, p, node, {}));
+                            if (precondition && node.href.startsWith('command:')) {
+                                const updateEnablement = () => link.enabled = this.contextKeyService.contextMatchesRules(precondition);
+                                updateEnablement();
+                                const keys = ( new Set());
+                                ( precondition.keys()).forEach(key => keys.add(key));
+                                const onDidChangeContext = Event.filter(this.contextKeyService.onDidChangeContext, e => e.affectsSome(keys));
+                                onDidChangeContext(updateEnablement, null, disposables);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        this.scrollableElement.scanDomNode();
+        this.viewWelcomeDisposable = disposables;
+    }
+    shouldShowWelcome() {
+        return false;
+    }
+    getFilterWidget() {
+        return undefined;
+    }
+    shouldShowFilterInHeader() {
+        return false;
+    }
+};
+ViewPane.AlwaysShowActionsConfig = 'workbench.view.alwaysShowHeaderActions';
+ViewPane = ( __decorate([
+    ( __param(1, IKeybindingService)),
+    ( __param(2, IContextMenuService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, IContextKeyService)),
+    ( __param(5, IViewDescriptorService)),
+    ( __param(6, IInstantiationService)),
+    ( __param(7, IOpenerService)),
+    ( __param(8, IThemeService)),
+    ( __param(9, ITelemetryService))
+], ViewPane));
+class ViewAction extends Action2 {
+    constructor(desc) {
+        super(desc);
+        this.desc = desc;
+    }
+    run(accessor, ...args) {
+        const view = accessor.get(IViewsService).getActiveViewWithId(this.desc.viewId);
+        if (view) {
+            return this.runInView(accessor, view, ...args);
+        }
+    }
+}
+export { VIEWPANE_FILTER_ACTION, ViewAction, ViewPane };

package/dist/vscode/vs/workbench/browser/quickaccess.js

@@ -0,0 +1,17 @@
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+const inQuickPickContextKeyValue = 'inQuickOpen';
+const inQuickPickContext = ContextKeyExpr.has(inQuickPickContextKeyValue);
+const defaultQuickAccessContextKeyValue = 'inFilesPicker';
+( ContextKeyExpr.and(inQuickPickContext, ContextKeyExpr.has(defaultQuickAccessContextKeyValue)));
+function getQuickNavigateHandler(id, next) {
+    return accessor => {
+        const keybindingService = accessor.get(IKeybindingService);
+        const quickInputService = accessor.get(IQuickInputService);
+        const keys = keybindingService.lookupKeybindings(id);
+        const quickNavigate = { keybindings: keys };
+        quickInputService.navigate(!!next, quickNavigate);
+    };
+}
+export { defaultQuickAccessContextKeyValue, getQuickNavigateHandler, inQuickPickContext, inQuickPickContextKeyValue };

package/dist/vscode/vs/workbench/common/component.js

@@ -0,0 +1,23 @@
+import { Memento } from './memento.js';
+import { Themable } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+class Component extends Themable {
+    constructor(id, themeService, storageService) {
+        super(themeService);
+        this.id = id;
+        this.id = id;
+        this.memento = ( new Memento(this.id, storageService));
+        this._register(storageService.onWillSaveState(() => {
+            this.saveState();
+            this.memento.saveMemento();
+        }));
+    }
+    getId() {
+        return this.id;
+    }
+    getMemento(scope, target) {
+        return this.memento.getMemento(scope, target);
+    }
+    saveState() {
+    }
+}
+export { Component };

package/dist/vscode/vs/workbench/common/configuration.js

@@ -0,0 +1,8 @@
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+const workbenchConfigurationNodeBase = ( Object.freeze({
+    'id': 'workbench',
+    'order': 7,
+    'title': ( localize('workbenchConfigurationTitle', "Workbench")),
+    'type': 'object',
+}));
+export { workbenchConfigurationNodeBase };