@codingame/monaco-vscode-api 2.0.3 → 2.1.0

package/vscode/src/vs/workbench/browser/parts/editor/breadcrumbsControl.js

@@ -0,0 +1,801 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { append, getWindow, getDomNodePagePosition, $, trackFocus } from '../../../../base/browser/dom.js';
+import { StandardMouseEvent } from '../../../../base/browser/mouseEvent.js';
+import { BreadcrumbsWidget, BreadcrumbsItem } from '../../../../base/browser/ui/breadcrumbs/breadcrumbsWidget.js';
+import { tail } from '../../../../base/common/arrays.js';
+import { timeout } from '../../../../base/common/async.js';
+import { DisposableStore, MutableDisposable, toDisposable, combinedDisposable } from '../../../../base/common/lifecycle.js';
+import { extUri } from '../../../../base/common/resources.js';
+import { URI } from '../../../../base/common/uri.js';
+import './media/breadcrumbscontrol.css.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { registerAction2, Action2, MenuId } from '../../../../platform/actions/common/actions.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { RawContextKey, ContextKeyExpr, IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { IContextViewService } from '../../../../platform/contextview/browser/contextView.js';
+import { FileKind, IFileService } from '../../../../platform/files/common/files.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { KeybindingsRegistry } from '../../../../platform/keybinding/common/keybindingsRegistry.js';
+import { WorkbenchListFocusContextKey, IListService, WorkbenchDataTree, WorkbenchAsyncDataTree } from '../../../../platform/list/browser/listService.js';
+import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.js';
+import { ResourceLabels, DEFAULT_LABELS_CONTAINER } from '../../labels.js';
+import { BreadcrumbsConfig, IBreadcrumbsService } from './breadcrumbs.js';
+import { BreadcrumbsModel, OutlineElement2, FileElement } from './breadcrumbsModel.js';
+import { BreadcrumbsFilePicker, BreadcrumbsOutlinePicker } from './breadcrumbsPicker.js';
+import { EditorResourceAccessor, SideBySideEditor } from '../../../common/editor.js';
+import { SIDE_GROUP, ACTIVE_GROUP, IEditorService } from '../../../services/editor/common/editorService.js';
+import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
+import { PixelRatio } from '../../../../base/browser/browser.js';
+import { ILabelService } from '../../../../platform/label/common/label.js';
+import { Categories } from '../../../../platform/action/common/actionCommonCategories.js';
+import { registerIcon } from '../../../../platform/theme/common/iconRegistry.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { defaultBreadcrumbsWidgetStyles } from '../../../../platform/theme/browser/defaultStyles.js';
+import { Emitter } from '../../../../base/common/event.js';
+var BreadcrumbsControl_1;
+class OutlineItem extends BreadcrumbsItem {
+    constructor(model, element, options) {
+        super();
+        this.model = model;
+        this.element = element;
+        this.options = options;
+        this._disposables = ( new DisposableStore());
+    }
+    dispose() {
+        this._disposables.dispose();
+    }
+    equals(other) {
+        if (!(other instanceof OutlineItem)) {
+            return false;
+        }
+        return this.element.element === other.element.element &&
+            this.options.showFileIcons === other.options.showFileIcons &&
+            this.options.showSymbolIcons === other.options.showSymbolIcons;
+    }
+    render(container) {
+        const { element, outline } = this.element;
+        if (element === outline) {
+            const element = $('span', undefined, '…');
+            container.appendChild(element);
+            return;
+        }
+        const templateId = outline.config.delegate.getTemplateId(element);
+        const renderer = outline.config.renderers.find(renderer => renderer.templateId === templateId);
+        if (!renderer) {
+            container.innerText = '<<NO RENDERER>>';
+            return;
+        }
+        const template = renderer.renderTemplate(container);
+        renderer.renderElement({
+            element,
+            children: [],
+            depth: 0,
+            visibleChildrenCount: 0,
+            visibleChildIndex: 0,
+            collapsible: false,
+            collapsed: false,
+            visible: true,
+            filterData: undefined
+        }, 0, template, undefined);
+        this._disposables.add(toDisposable(() => { renderer.disposeTemplate(template); }));
+    }
+}
+class FileItem extends BreadcrumbsItem {
+    constructor(model, element, options, _labels) {
+        super();
+        this.model = model;
+        this.element = element;
+        this.options = options;
+        this._labels = _labels;
+        this._disposables = ( new DisposableStore());
+    }
+    dispose() {
+        this._disposables.dispose();
+    }
+    equals(other) {
+        if (!(other instanceof FileItem)) {
+            return false;
+        }
+        return (extUri.isEqual(this.element.uri, other.element.uri) &&
+            this.options.showFileIcons === other.options.showFileIcons &&
+            this.options.showSymbolIcons === other.options.showSymbolIcons);
+    }
+    render(container) {
+        const label = this._labels.create(container);
+        label.setFile(this.element.uri, {
+            hidePath: true,
+            hideIcon: this.element.kind === FileKind.FOLDER || !this.options.showFileIcons,
+            fileKind: this.element.kind,
+            fileDecorations: { colors: this.options.showDecorationColors, badges: false },
+        });
+        container.classList.add(FileKind[this.element.kind].toLowerCase());
+        this._disposables.add(label);
+    }
+}
+const separatorIcon = registerIcon('breadcrumb-separator', Codicon.chevronRight, ( localizeWithPath(
+    'vs/workbench/browser/parts/editor/breadcrumbsControl',
+    'separatorIcon',
+    'Icon for the separator in the breadcrumbs.'
+)));
+let BreadcrumbsControl = class BreadcrumbsControl {
+    static { BreadcrumbsControl_1 = this; }
+    static { this.HEIGHT = 22; }
+    static { this.SCROLLBAR_SIZES = {
+        default: 3,
+        large: 8
+    }; }
+    static { this.Payload_Reveal = {}; }
+    static { this.Payload_RevealAside = {}; }
+    static { this.Payload_Pick = {}; }
+    static { this.CK_BreadcrumbsPossible = ( new RawContextKey('breadcrumbsPossible', false, ( localizeWithPath(
+        'vs/workbench/browser/parts/editor/breadcrumbsControl',
+        'breadcrumbsPossible',
+        "Whether the editor can show breadcrumbs"
+    )))); }
+    static { this.CK_BreadcrumbsVisible = ( new RawContextKey('breadcrumbsVisible', false, ( localizeWithPath(
+        'vs/workbench/browser/parts/editor/breadcrumbsControl',
+        'breadcrumbsVisible',
+        "Whether breadcrumbs are currently visible"
+    )))); }
+    static { this.CK_BreadcrumbsActive = ( new RawContextKey('breadcrumbsActive', false, ( localizeWithPath(
+        'vs/workbench/browser/parts/editor/breadcrumbsControl',
+        'breadcrumbsActive',
+        "Whether breadcrumbs have focus"
+    )))); }
+    get onDidVisibilityChange() { return this._onDidVisibilityChange.event; }
+    constructor(container, _options, _editorGroup, _contextKeyService, _contextViewService, _instantiationService, _quickInputService, _fileService, _editorService, _labelService, configurationService, breadcrumbsService) {
+        this._options = _options;
+        this._editorGroup = _editorGroup;
+        this._contextKeyService = _contextKeyService;
+        this._contextViewService = _contextViewService;
+        this._instantiationService = _instantiationService;
+        this._quickInputService = _quickInputService;
+        this._fileService = _fileService;
+        this._editorService = _editorService;
+        this._labelService = _labelService;
+        this._disposables = ( new DisposableStore());
+        this._breadcrumbsDisposables = ( new DisposableStore());
+        this._model = ( new MutableDisposable());
+        this._breadcrumbsPickerShowing = false;
+        this._onDidVisibilityChange = this._disposables.add(( new Emitter()));
+        this.domNode = document.createElement('div');
+        this.domNode.classList.add('breadcrumbs-control');
+        append(container, this.domNode);
+        this._cfUseQuickPick = BreadcrumbsConfig.UseQuickPick.bindTo(configurationService);
+        this._cfShowIcons = BreadcrumbsConfig.Icons.bindTo(configurationService);
+        this._cfTitleScrollbarSizing = BreadcrumbsConfig.TitleScrollbarSizing.bindTo(configurationService);
+        this._labels = this._instantiationService.createInstance(ResourceLabels, DEFAULT_LABELS_CONTAINER);
+        const sizing = this._cfTitleScrollbarSizing.getValue() ?? 'default';
+        const styles = _options.widgetStyles ?? defaultBreadcrumbsWidgetStyles;
+        this._widget = ( new BreadcrumbsWidget(
+            this.domNode,
+            BreadcrumbsControl_1.SCROLLBAR_SIZES[sizing],
+            separatorIcon,
+            styles
+        ));
+        this._widget.onDidSelectItem(this._onSelectEvent, this, this._disposables);
+        this._widget.onDidFocusItem(this._onFocusEvent, this, this._disposables);
+        this._widget.onDidChangeFocus(this._updateCkBreadcrumbsActive, this, this._disposables);
+        this._ckBreadcrumbsPossible = BreadcrumbsControl_1.CK_BreadcrumbsPossible.bindTo(this._contextKeyService);
+        this._ckBreadcrumbsVisible = BreadcrumbsControl_1.CK_BreadcrumbsVisible.bindTo(this._contextKeyService);
+        this._ckBreadcrumbsActive = BreadcrumbsControl_1.CK_BreadcrumbsActive.bindTo(this._contextKeyService);
+        this._disposables.add(breadcrumbsService.register(this._editorGroup.id, this._widget));
+        this.hide();
+    }
+    dispose() {
+        this._disposables.dispose();
+        this._breadcrumbsDisposables.dispose();
+        this._ckBreadcrumbsPossible.reset();
+        this._ckBreadcrumbsVisible.reset();
+        this._ckBreadcrumbsActive.reset();
+        this._cfUseQuickPick.dispose();
+        this._cfShowIcons.dispose();
+        this._widget.dispose();
+        this._labels.dispose();
+        this.domNode.remove();
+    }
+    get model() {
+        return this._model.value;
+    }
+    layout(dim) {
+        this._widget.layout(dim);
+    }
+    isHidden() {
+        return this.domNode.classList.contains('hidden');
+    }
+    hide() {
+        const wasHidden = this.isHidden();
+        this._breadcrumbsDisposables.clear();
+        this._ckBreadcrumbsVisible.set(false);
+        this.domNode.classList.toggle('hidden', true);
+        if (!wasHidden) {
+            this._onDidVisibilityChange.fire();
+        }
+    }
+    show() {
+        const wasHidden = this.isHidden();
+        this._ckBreadcrumbsVisible.set(true);
+        this.domNode.classList.toggle('hidden', false);
+        if (wasHidden) {
+            this._onDidVisibilityChange.fire();
+        }
+    }
+    revealLast() {
+        this._widget.revealLast();
+    }
+    update() {
+        this._breadcrumbsDisposables.clear();
+        const uri = EditorResourceAccessor.getCanonicalUri(this._editorGroup.activeEditor, { supportSideBySide: SideBySideEditor.PRIMARY });
+        const wasHidden = this.isHidden();
+        if (!uri || !this._fileService.hasProvider(uri)) {
+            this._ckBreadcrumbsPossible.set(false);
+            if (!wasHidden) {
+                this.hide();
+                return true;
+            }
+            else {
+                return false;
+            }
+        }
+        const fileInfoUri = EditorResourceAccessor.getOriginalUri(this._editorGroup.activeEditor, { supportSideBySide: SideBySideEditor.PRIMARY });
+        this.show();
+        this._ckBreadcrumbsPossible.set(true);
+        const model = this._instantiationService.createInstance(BreadcrumbsModel, fileInfoUri ?? uri, this._editorGroup.activeEditorPane);
+        this._model.value = model;
+        this.domNode.classList.toggle('backslash-path', this._labelService.getSeparator(uri.scheme, uri.authority) === '\\');
+        const updateBreadcrumbs = () => {
+            this.domNode.classList.toggle('relative-path', model.isRelative());
+            const showIcons = this._cfShowIcons.getValue();
+            const options = {
+                ...this._options,
+                showFileIcons: this._options.showFileIcons && showIcons,
+                showSymbolIcons: this._options.showSymbolIcons && showIcons
+            };
+            const items = ( model.getElements().map(element => element instanceof FileElement ? ( new FileItem(model, element, options, this._labels)) : ( new OutlineItem(model, element, options))));
+            if (items.length === 0) {
+                this._widget.setEnabled(false);
+                this._widget.setItems([new (class extends BreadcrumbsItem {
+                        render(container) {
+                            container.innerText = ( localizeWithPath(
+                                'vs/workbench/browser/parts/editor/breadcrumbsControl',
+                                'empty',
+                                "no elements"
+                            ));
+                        }
+                        equals(other) {
+                            return other === this;
+                        }
+                        dispose() {
+                        }
+                    })]);
+            }
+            else {
+                this._widget.setEnabled(true);
+                this._widget.setItems(items);
+                this._widget.reveal(items[items.length - 1]);
+            }
+        };
+        const listener = model.onDidUpdate(updateBreadcrumbs);
+        const configListener = this._cfShowIcons.onDidChange(updateBreadcrumbs);
+        updateBreadcrumbs();
+        this._breadcrumbsDisposables.clear();
+        this._breadcrumbsDisposables.add(listener);
+        this._breadcrumbsDisposables.add(toDisposable(() => this._model.clear()));
+        this._breadcrumbsDisposables.add(configListener);
+        this._breadcrumbsDisposables.add(toDisposable(() => this._widget.setItems([])));
+        const updateScrollbarSizing = () => {
+            const sizing = this._cfTitleScrollbarSizing.getValue() ?? 'default';
+            this._widget.setHorizontalScrollbarSize(BreadcrumbsControl_1.SCROLLBAR_SIZES[sizing]);
+        };
+        updateScrollbarSizing();
+        const updateScrollbarSizeListener = this._cfTitleScrollbarSizing.onDidChange(updateScrollbarSizing);
+        this._breadcrumbsDisposables.add(updateScrollbarSizeListener);
+        this._breadcrumbsDisposables.add({
+            dispose: () => {
+                if (this._breadcrumbsPickerShowing) {
+                    this._contextViewService.hideContextView({ source: this });
+                }
+            }
+        });
+        return wasHidden !== this.isHidden();
+    }
+    _onFocusEvent(event) {
+        if (event.item && this._breadcrumbsPickerShowing) {
+            this._breadcrumbsPickerIgnoreOnceItem = undefined;
+            this._widget.setSelection(event.item);
+        }
+    }
+    _onSelectEvent(event) {
+        if (!event.item) {
+            return;
+        }
+        if (event.item === this._breadcrumbsPickerIgnoreOnceItem) {
+            this._breadcrumbsPickerIgnoreOnceItem = undefined;
+            this._widget.setFocused(undefined);
+            this._widget.setSelection(undefined);
+            return;
+        }
+        const { element } = event.item;
+        this._editorGroup.focus();
+        const group = this._getEditorGroup(event.payload);
+        if (group !== undefined) {
+            this._widget.setFocused(undefined);
+            this._widget.setSelection(undefined);
+            this._revealInEditor(event, element, group);
+            return;
+        }
+        if (this._cfUseQuickPick.getValue()) {
+            this._widget.setFocused(undefined);
+            this._widget.setSelection(undefined);
+            this._quickInputService.quickAccess.show(element instanceof OutlineElement2 ? '@' : '');
+            return;
+        }
+        let picker;
+        let pickerAnchor;
+        this._contextViewService.showContextView({
+            render: (parent) => {
+                if (event.item instanceof FileItem) {
+                    picker = this._instantiationService.createInstance(BreadcrumbsFilePicker, parent, event.item.model.resource);
+                }
+                else if (event.item instanceof OutlineItem) {
+                    picker = this._instantiationService.createInstance(BreadcrumbsOutlinePicker, parent, event.item.model.resource);
+                }
+                const selectListener = picker.onWillPickElement(() => this._contextViewService.hideContextView({ source: this, didPick: true }));
+                const zoomListener = PixelRatio.onDidChange(() => this._contextViewService.hideContextView({ source: this }));
+                const focusTracker = trackFocus(parent);
+                const blurListener = focusTracker.onDidBlur(() => {
+                    this._breadcrumbsPickerIgnoreOnceItem = this._widget.isDOMFocused() ? event.item : undefined;
+                    this._contextViewService.hideContextView({ source: this });
+                });
+                this._breadcrumbsPickerShowing = true;
+                this._updateCkBreadcrumbsActive();
+                return combinedDisposable(picker, selectListener, zoomListener, focusTracker, blurListener);
+            },
+            getAnchor: () => {
+                if (!pickerAnchor) {
+                    const window = getWindow(this.domNode);
+                    const maxInnerWidth = window.innerWidth - 8 ;
+                    let maxHeight = Math.min(window.innerHeight * 0.7, 300);
+                    const pickerWidth = Math.min(maxInnerWidth, Math.max(240, maxInnerWidth / 4.17));
+                    const pickerArrowSize = 8;
+                    let pickerArrowOffset;
+                    const data = getDomNodePagePosition(event.node.firstChild);
+                    const y = data.top + data.height + pickerArrowSize;
+                    if (y + maxHeight >= window.innerHeight) {
+                        maxHeight = window.innerHeight - y - 30 ;
+                    }
+                    let x = data.left;
+                    if (x + pickerWidth >= maxInnerWidth) {
+                        x = maxInnerWidth - pickerWidth;
+                    }
+                    if (event.payload instanceof StandardMouseEvent) {
+                        const maxPickerArrowOffset = pickerWidth - 2 * pickerArrowSize;
+                        pickerArrowOffset = event.payload.posx - x;
+                        if (pickerArrowOffset > maxPickerArrowOffset) {
+                            x = Math.min(maxInnerWidth - pickerWidth, x + pickerArrowOffset - maxPickerArrowOffset);
+                            pickerArrowOffset = maxPickerArrowOffset;
+                        }
+                    }
+                    else {
+                        pickerArrowOffset = (data.left + (data.width * 0.3)) - x;
+                    }
+                    picker.show(element, maxHeight, pickerWidth, pickerArrowSize, Math.max(0, pickerArrowOffset));
+                    pickerAnchor = { x, y };
+                }
+                return pickerAnchor;
+            },
+            onHide: (data) => {
+                if (!data?.didPick) {
+                    picker.restoreViewState();
+                }
+                this._breadcrumbsPickerShowing = false;
+                this._updateCkBreadcrumbsActive();
+                if (data?.source === this) {
+                    this._widget.setFocused(undefined);
+                    this._widget.setSelection(undefined);
+                }
+                picker.dispose();
+            }
+        });
+    }
+    _updateCkBreadcrumbsActive() {
+        const value = this._widget.isDOMFocused() || this._breadcrumbsPickerShowing;
+        this._ckBreadcrumbsActive.set(value);
+    }
+    async _revealInEditor(event, element, group, pinned = false) {
+        if (element instanceof FileElement) {
+            if (element.kind === FileKind.FILE) {
+                await this._editorService.openEditor({ resource: element.uri, options: { pinned } }, group);
+            }
+            else {
+                const items = this._widget.getItems();
+                const idx = items.indexOf(event.item);
+                this._widget.setFocused(items[idx + 1]);
+                this._widget.setSelection(items[idx + 1], BreadcrumbsControl_1.Payload_Pick);
+            }
+        }
+        else {
+            element.outline.reveal(element, { pinned }, group === SIDE_GROUP);
+        }
+    }
+    _getEditorGroup(data) {
+        if (data === BreadcrumbsControl_1.Payload_RevealAside) {
+            return SIDE_GROUP;
+        }
+        else if (data === BreadcrumbsControl_1.Payload_Reveal) {
+            return ACTIVE_GROUP;
+        }
+        else {
+            return undefined;
+        }
+    }
+};
+BreadcrumbsControl = BreadcrumbsControl_1 = ( __decorate([
+    ( __param(3, IContextKeyService)),
+    ( __param(4, IContextViewService)),
+    ( __param(5, IInstantiationService)),
+    ( __param(6, IQuickInputService)),
+    ( __param(7, IFileService)),
+    ( __param(8, IEditorService)),
+    ( __param(9, ILabelService)),
+    ( __param(10, IConfigurationService)),
+    ( __param(11, IBreadcrumbsService))
+], BreadcrumbsControl));
+let BreadcrumbsControlFactory = class BreadcrumbsControlFactory {
+    get control() { return this._control; }
+    get onDidEnablementChange() { return this._onDidEnablementChange.event; }
+    get onDidVisibilityChange() { return this._onDidVisibilityChange.event; }
+    constructor(_container, _editorGroup, _options, configurationService, _instantiationService, fileService) {
+        this._container = _container;
+        this._editorGroup = _editorGroup;
+        this._options = _options;
+        this._instantiationService = _instantiationService;
+        this._disposables = ( new DisposableStore());
+        this._controlDisposables = ( new DisposableStore());
+        this._onDidEnablementChange = this._disposables.add(( new Emitter()));
+        this._onDidVisibilityChange = this._disposables.add(( new Emitter()));
+        const config = this._disposables.add(BreadcrumbsConfig.IsEnabled.bindTo(configurationService));
+        this._disposables.add(config.onDidChange(() => {
+            const value = config.getValue();
+            if (!value && this._control) {
+                this._controlDisposables.clear();
+                this._control = undefined;
+                this._onDidEnablementChange.fire();
+            }
+            else if (value && !this._control) {
+                this._control = this.createControl();
+                this._control.update();
+                this._onDidEnablementChange.fire();
+            }
+        }));
+        if (config.getValue()) {
+            this._control = this.createControl();
+        }
+        this._disposables.add(fileService.onDidChangeFileSystemProviderRegistrations(e => {
+            if (this._control?.model && this._control.model.resource.scheme !== e.scheme) {
+                return;
+            }
+            if (this._control?.update()) {
+                this._onDidEnablementChange.fire();
+            }
+        }));
+    }
+    createControl() {
+        const control = this._controlDisposables.add(this._instantiationService.createInstance(BreadcrumbsControl, this._container, this._options, this._editorGroup));
+        this._controlDisposables.add(control.onDidVisibilityChange(() => this._onDidVisibilityChange.fire()));
+        return control;
+    }
+    dispose() {
+        this._disposables.dispose();
+        this._controlDisposables.dispose();
+    }
+};
+BreadcrumbsControlFactory = ( __decorate([
+    ( __param(3, IConfigurationService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IFileService))
+], BreadcrumbsControlFactory));
+registerAction2(class ToggleBreadcrumb extends Action2 {
+    constructor() {
+        super({
+            id: 'breadcrumbs.toggle',
+            title: {
+                value: ( localizeWithPath(
+                    'vs/workbench/browser/parts/editor/breadcrumbsControl',
+                    'cmd.toggle',
+                    "Toggle Breadcrumbs"
+                )),
+                mnemonicTitle: ( localizeWithPath(
+                    'vs/workbench/browser/parts/editor/breadcrumbsControl',
+                    { key: 'miBreadcrumbs', comment: ['&& denotes a mnemonic'] },
+                    "Toggle &&Breadcrumbs"
+                )),
+                original: 'Toggle Breadcrumbs',
+            },
+            category: Categories.View,
+            toggled: {
+                condition: ( ContextKeyExpr.equals('config.breadcrumbs.enabled', true)),
+                title: ( localizeWithPath(
+                    'vs/workbench/browser/parts/editor/breadcrumbsControl',
+                    'cmd.toggle2',
+                    "Breadcrumbs"
+                )),
+                mnemonicTitle: ( localizeWithPath(
+                    'vs/workbench/browser/parts/editor/breadcrumbsControl',
+                    { key: 'miBreadcrumbs2', comment: ['&& denotes a mnemonic'] },
+                    "&&Breadcrumbs"
+                ))
+            },
+            menu: [
+                { id: MenuId.CommandPalette },
+                { id: MenuId.MenubarAppearanceMenu, group: '4_editor', order: 2 },
+                { id: MenuId.NotebookToolbar, group: 'notebookLayout', order: 2 },
+                { id: MenuId.StickyScrollContext }
+            ]
+        });
+    }
+    run(accessor) {
+        const config = accessor.get(IConfigurationService);
+        const value = BreadcrumbsConfig.IsEnabled.bindTo(config).getValue();
+        BreadcrumbsConfig.IsEnabled.bindTo(config).updateValue(!value);
+    }
+});
+function focusAndSelectHandler(accessor, select) {
+    const groups = accessor.get(IEditorGroupsService);
+    const breadcrumbs = accessor.get(IBreadcrumbsService);
+    const widget = breadcrumbs.getWidget(groups.activeGroup.id);
+    if (widget) {
+        const item = tail(widget.getItems());
+        widget.setFocused(item);
+        if (select) {
+            widget.setSelection(item, BreadcrumbsControl.Payload_Pick);
+        }
+    }
+}
+registerAction2(class FocusAndSelectBreadcrumbs extends Action2 {
+    constructor() {
+        super({
+            id: 'breadcrumbs.focusAndSelect',
+            title: {
+                value: ( localizeWithPath(
+                    'vs/workbench/browser/parts/editor/breadcrumbsControl',
+                    'cmd.focusAndSelect',
+                    "Focus and Select Breadcrumbs"
+                )),
+                original: 'Focus and Select Breadcrumbs'
+            },
+            precondition: BreadcrumbsControl.CK_BreadcrumbsVisible,
+            keybinding: {
+                weight: 200 ,
+                primary: 2048  | 1024  | 89 ,
+                when: BreadcrumbsControl.CK_BreadcrumbsPossible,
+            },
+            f1: true
+        });
+    }
+    run(accessor, ...args) {
+        focusAndSelectHandler(accessor, true);
+    }
+});
+registerAction2(class FocusBreadcrumbs extends Action2 {
+    constructor() {
+        super({
+            id: 'breadcrumbs.focus',
+            title: {
+                value: ( localizeWithPath(
+                    'vs/workbench/browser/parts/editor/breadcrumbsControl',
+                    'cmd.focus',
+                    "Focus Breadcrumbs"
+                )),
+                original: 'Focus Breadcrumbs'
+            },
+            precondition: BreadcrumbsControl.CK_BreadcrumbsVisible,
+            keybinding: {
+                weight: 200 ,
+                primary: 2048  | 1024  | 85 ,
+                when: BreadcrumbsControl.CK_BreadcrumbsPossible,
+            },
+            f1: true
+        });
+    }
+    run(accessor, ...args) {
+        focusAndSelectHandler(accessor, false);
+    }
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: 'breadcrumbs.toggleToOn',
+    weight: 200 ,
+    primary: 2048  | 1024  | 89 ,
+    when: ContextKeyExpr.not('config.breadcrumbs.enabled'),
+    handler: async (accessor) => {
+        const instant = accessor.get(IInstantiationService);
+        const config = accessor.get(IConfigurationService);
+        const isEnabled = BreadcrumbsConfig.IsEnabled.bindTo(config);
+        if (!isEnabled.getValue()) {
+            await isEnabled.updateValue(true);
+            await timeout(50);
+        }
+        return instant.invokeFunction(focusAndSelectHandler, true);
+    }
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: 'breadcrumbs.focusNext',
+    weight: 200 ,
+    primary: 17 ,
+    secondary: [2048  | 17 ],
+    mac: {
+        primary: 17 ,
+        secondary: [512  | 17 ],
+    },
+    when: ( ContextKeyExpr.and(
+        BreadcrumbsControl.CK_BreadcrumbsVisible,
+        BreadcrumbsControl.CK_BreadcrumbsActive
+    )),
+    handler(accessor) {
+        const groups = accessor.get(IEditorGroupsService);
+        const breadcrumbs = accessor.get(IBreadcrumbsService);
+        const widget = breadcrumbs.getWidget(groups.activeGroup.id);
+        if (!widget) {
+            return;
+        }
+        widget.focusNext();
+    }
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: 'breadcrumbs.focusPrevious',
+    weight: 200 ,
+    primary: 15 ,
+    secondary: [2048  | 15 ],
+    mac: {
+        primary: 15 ,
+        secondary: [512  | 15 ],
+    },
+    when: ( ContextKeyExpr.and(
+        BreadcrumbsControl.CK_BreadcrumbsVisible,
+        BreadcrumbsControl.CK_BreadcrumbsActive
+    )),
+    handler(accessor) {
+        const groups = accessor.get(IEditorGroupsService);
+        const breadcrumbs = accessor.get(IBreadcrumbsService);
+        const widget = breadcrumbs.getWidget(groups.activeGroup.id);
+        if (!widget) {
+            return;
+        }
+        widget.focusPrev();
+    }
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: 'breadcrumbs.focusNextWithPicker',
+    weight: 200  + 1,
+    primary: 2048  | 17 ,
+    mac: {
+        primary: 512  | 17 ,
+    },
+    when: ( ContextKeyExpr.and(
+        BreadcrumbsControl.CK_BreadcrumbsVisible,
+        BreadcrumbsControl.CK_BreadcrumbsActive,
+        WorkbenchListFocusContextKey
+    )),
+    handler(accessor) {
+        const groups = accessor.get(IEditorGroupsService);
+        const breadcrumbs = accessor.get(IBreadcrumbsService);
+        const widget = breadcrumbs.getWidget(groups.activeGroup.id);
+        if (!widget) {
+            return;
+        }
+        widget.focusNext();
+    }
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: 'breadcrumbs.focusPreviousWithPicker',
+    weight: 200  + 1,
+    primary: 2048  | 15 ,
+    mac: {
+        primary: 512  | 15 ,
+    },
+    when: ( ContextKeyExpr.and(
+        BreadcrumbsControl.CK_BreadcrumbsVisible,
+        BreadcrumbsControl.CK_BreadcrumbsActive,
+        WorkbenchListFocusContextKey
+    )),
+    handler(accessor) {
+        const groups = accessor.get(IEditorGroupsService);
+        const breadcrumbs = accessor.get(IBreadcrumbsService);
+        const widget = breadcrumbs.getWidget(groups.activeGroup.id);
+        if (!widget) {
+            return;
+        }
+        widget.focusPrev();
+    }
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: 'breadcrumbs.selectFocused',
+    weight: 200 ,
+    primary: 3 ,
+    secondary: [18 ],
+    when: ( ContextKeyExpr.and(
+        BreadcrumbsControl.CK_BreadcrumbsVisible,
+        BreadcrumbsControl.CK_BreadcrumbsActive
+    )),
+    handler(accessor) {
+        const groups = accessor.get(IEditorGroupsService);
+        const breadcrumbs = accessor.get(IBreadcrumbsService);
+        const widget = breadcrumbs.getWidget(groups.activeGroup.id);
+        if (!widget) {
+            return;
+        }
+        widget.setSelection(widget.getFocused(), BreadcrumbsControl.Payload_Pick);
+    }
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: 'breadcrumbs.revealFocused',
+    weight: 200 ,
+    primary: 10 ,
+    secondary: [2048  | 3 ],
+    when: ( ContextKeyExpr.and(
+        BreadcrumbsControl.CK_BreadcrumbsVisible,
+        BreadcrumbsControl.CK_BreadcrumbsActive
+    )),
+    handler(accessor) {
+        const groups = accessor.get(IEditorGroupsService);
+        const breadcrumbs = accessor.get(IBreadcrumbsService);
+        const widget = breadcrumbs.getWidget(groups.activeGroup.id);
+        if (!widget) {
+            return;
+        }
+        widget.setSelection(widget.getFocused(), BreadcrumbsControl.Payload_Reveal);
+    }
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: 'breadcrumbs.selectEditor',
+    weight: 200  + 1,
+    primary: 9 ,
+    when: ( ContextKeyExpr.and(
+        BreadcrumbsControl.CK_BreadcrumbsVisible,
+        BreadcrumbsControl.CK_BreadcrumbsActive
+    )),
+    handler(accessor) {
+        const groups = accessor.get(IEditorGroupsService);
+        const breadcrumbs = accessor.get(IBreadcrumbsService);
+        const widget = breadcrumbs.getWidget(groups.activeGroup.id);
+        if (!widget) {
+            return;
+        }
+        widget.setFocused(undefined);
+        widget.setSelection(undefined);
+        groups.activeGroup.activeEditorPane?.focus();
+    }
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: 'breadcrumbs.revealFocusedFromTreeAside',
+    weight: 200 ,
+    primary: 2048  | 3 ,
+    when: ( ContextKeyExpr.and(
+        BreadcrumbsControl.CK_BreadcrumbsVisible,
+        BreadcrumbsControl.CK_BreadcrumbsActive,
+        WorkbenchListFocusContextKey
+    )),
+    handler(accessor) {
+        const editors = accessor.get(IEditorService);
+        const lists = accessor.get(IListService);
+        const tree = lists.lastFocusedList;
+        if (!(tree instanceof WorkbenchDataTree) && !(tree instanceof WorkbenchAsyncDataTree)) {
+            return;
+        }
+        const element = tree.getFocus()[0];
+        if (URI.isUri(element?.resource)) {
+            return editors.openEditor({
+                resource: element.resource,
+                options: { pinned: true }
+            }, SIDE_GROUP);
+        }
+        const input = tree.getInput();
+        if (input && typeof input.outlineKind === 'string') {
+            return input.reveal(element, {
+                pinned: true,
+                preserveFocus: false
+            }, true);
+        }
+    }
+});
+export { BreadcrumbsControl, BreadcrumbsControlFactory };