@codingame/monaco-vscode-notebook-service-override 4.1.0 → 4.1.2

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline.js

@@ -0,0 +1,656 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { clearNode, WindowIdleValue } from 'vscode/vscode/vs/base/browser/dom';
+import { ToolBar } from 'vscode/vscode/vs/base/browser/ui/toolbar/toolbar';
+import { IconLabel } from 'vscode/vscode/vs/base/browser/ui/iconLabel/iconLabel';
+import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { createMatches } from 'vscode/vscode/vs/base/common/filters';
+import { DisposableStore, Disposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
+import { getIconClassesForLanguageId } from 'vscode/vscode/vs/editor/common/services/getIconClasses';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { Extensions as Extensions$1 } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { MarkerSeverity } from 'vscode/vscode/vs/platform/markers/common/markers';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import 'vscode/vscode/vs/platform/theme/common/colorUtils';
+import 'vscode/vscode/vs/platform/theme/common/colors/baseColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/chartsColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/editorColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/inputColors';
+import { listErrorForeground, listWarningForeground } from 'vscode/vscode/vs/platform/theme/common/colors/listColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/menuColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/minimapColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/miscColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/quickpickColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/searchColors';
+import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
+import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
+import { NotebookEditor } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookEditor';
+import { NotebookCellOutlineProvider } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/viewModel/notebookOutlineProvider';
+import { NotebookSetting, CellKind } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { SIDE_GROUP, IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { IOutlineService } from 'vscode/vscode/vs/workbench/services/outline/browser/outline';
+import { Range } from 'vscode/vscode/vs/editor/common/core/range';
+import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
+import { IContextMenuService } from 'vscode/vscode/vs/platform/contextview/browser/contextView';
+import { MenuRegistry, MenuId, registerAction2, Action2, MenuItemAction, IMenuService } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { RawContextKey, ContextKeyExpr, IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { MenuEntryActionViewItem, createAndFillInActionBarActions } from 'vscode/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
+import { disposableTimeout } from 'vscode/vscode/vs/base/common/async';
+import { IOutlinePane } from 'vscode/vscode/vs/workbench/contrib/outline/browser/outline';
+import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
+import { NOTEBOOK_IS_ACTIVE_EDITOR } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookContextKeys';
+
+var NotebookCellOutline_1;
+class NotebookOutlineTemplate {
+    static { this.templateId = 'NotebookOutlineRenderer'; }
+    constructor(container, iconClass, iconLabel, decoration, actionMenu, elementDisposables) {
+        this.container = container;
+        this.iconClass = iconClass;
+        this.iconLabel = iconLabel;
+        this.decoration = decoration;
+        this.actionMenu = actionMenu;
+        this.elementDisposables = elementDisposables;
+    }
+}
+let NotebookOutlineRenderer = class NotebookOutlineRenderer {
+    constructor(_editor, _target, _themeService, _configurationService, _contextMenuService, _contextKeyService, _menuService, _instantiationService) {
+        this._editor = _editor;
+        this._target = _target;
+        this._themeService = _themeService;
+        this._configurationService = _configurationService;
+        this._contextMenuService = _contextMenuService;
+        this._contextKeyService = _contextKeyService;
+        this._menuService = _menuService;
+        this._instantiationService = _instantiationService;
+        this.templateId = NotebookOutlineTemplate.templateId;
+    }
+    renderTemplate(container) {
+        const elementDisposables = ( new DisposableStore());
+        container.classList.add('notebook-outline-element', 'show-file-icons');
+        const iconClass = document.createElement('div');
+        container.append(iconClass);
+        const iconLabel = ( new IconLabel(container, { supportHighlights: true }));
+        const decoration = document.createElement('div');
+        decoration.className = 'element-decoration';
+        container.append(decoration);
+        const actionMenu = document.createElement('div');
+        actionMenu.className = 'action-menu';
+        container.append(actionMenu);
+        return ( new NotebookOutlineTemplate(
+            container,
+            iconClass,
+            iconLabel,
+            decoration,
+            actionMenu,
+            elementDisposables
+        ));
+    }
+    renderElement(node, _index, template, _height) {
+        const extraClasses = [];
+        const options = {
+            matches: createMatches(node.filterData),
+            labelEscapeNewLines: true,
+            extraClasses,
+        };
+        const isCodeCell = node.element.cell.cellKind === CellKind.Code;
+        if (node.element.level >= 8) {
+            template.iconClass.className = 'element-icon ' + ThemeIcon.asClassNameArray(node.element.icon).join(' ');
+        }
+        else if (isCodeCell && this._themeService.getFileIconTheme().hasFileIcons && !node.element.isExecuting) {
+            template.iconClass.className = '';
+            extraClasses.push(...getIconClassesForLanguageId(node.element.cell.language ?? ''));
+        }
+        else {
+            template.iconClass.className = 'element-icon ' + ThemeIcon.asClassNameArray(node.element.icon).join(' ');
+        }
+        template.iconLabel.setLabel(' ' + node.element.label, undefined, options);
+        const { markerInfo } = node.element;
+        template.container.style.removeProperty('--outline-element-color');
+        template.decoration.innerText = '';
+        if (markerInfo) {
+            const problem = this._configurationService.getValue('problems.visibility');
+            const useBadges = this._configurationService.getValue("outline.problems.badges" );
+            if (!useBadges || !problem) {
+                template.decoration.classList.remove('bubble');
+                template.decoration.innerText = '';
+            }
+            else if (markerInfo.count === 0) {
+                template.decoration.classList.add('bubble');
+                template.decoration.innerText = '\uea71';
+            }
+            else {
+                template.decoration.classList.remove('bubble');
+                template.decoration.innerText = markerInfo.count > 9 ? '9+' : String(markerInfo.count);
+            }
+            const color = this._themeService.getColorTheme().getColor(markerInfo.topSev === MarkerSeverity.Error ? listErrorForeground : listWarningForeground);
+            if (problem === undefined) {
+                return;
+            }
+            const useColors = this._configurationService.getValue("outline.problems.colors" );
+            if (!useColors || !problem) {
+                template.container.style.removeProperty('--outline-element-color');
+                template.decoration.style.setProperty('--outline-element-color', color?.toString() ?? 'inherit');
+            }
+            else {
+                template.container.style.setProperty('--outline-element-color', color?.toString() ?? 'inherit');
+            }
+        }
+        if (this._target === 1 ) {
+            const nbCell = node.element.cell;
+            const nbViewModel = this._editor?.getViewModel();
+            if (!nbViewModel) {
+                return;
+            }
+            const idx = nbViewModel.getCellIndex(nbCell);
+            const length = isCodeCell ? 0 : nbViewModel.getFoldedLength(idx);
+            const scopedContextKeyService = template.elementDisposables.add(this._contextKeyService.createScoped(template.container));
+            NotebookOutlineContext.CellKind.bindTo(scopedContextKeyService).set(isCodeCell ? CellKind.Code : CellKind.Markup);
+            NotebookOutlineContext.CellHasChildren.bindTo(scopedContextKeyService).set(length > 0);
+            NotebookOutlineContext.CellHasHeader.bindTo(scopedContextKeyService).set(node.element.level !== 7);
+            NotebookOutlineContext.OutlineElementTarget.bindTo(scopedContextKeyService).set(this._target);
+            this.setupFolding(isCodeCell, nbViewModel, scopedContextKeyService, template, nbCell);
+            const outlineEntryToolbar = template.elementDisposables.add(( new ToolBar(template.actionMenu, this._contextMenuService, {
+                actionViewItemProvider: action => {
+                    if (action instanceof MenuItemAction) {
+                        return this._instantiationService.createInstance(MenuEntryActionViewItem, action, undefined);
+                    }
+                    return undefined;
+                },
+            })));
+            const menu = template.elementDisposables.add(this._menuService.createMenu(MenuId.NotebookOutlineActionMenu, scopedContextKeyService));
+            const actions = getOutlineToolbarActions(menu, { notebookEditor: this._editor, outlineEntry: node.element });
+            outlineEntryToolbar.setActions(actions.primary, actions.secondary);
+            this.setupToolbarListeners(outlineEntryToolbar, menu, actions, node.element, template);
+            template.actionMenu.style.padding = '0 0.8em 0 0.4em';
+        }
+    }
+    disposeTemplate(templateData) {
+        templateData.iconLabel.dispose();
+        templateData.elementDisposables.clear();
+    }
+    disposeElement(element, index, templateData, height) {
+        templateData.elementDisposables.clear();
+        clearNode(templateData.actionMenu);
+    }
+    setupFolding(isCodeCell, nbViewModel, scopedContextKeyService, template, nbCell) {
+        const foldingState = isCodeCell ? 0  : (nbCell.foldingState);
+        const foldingStateCtx = NotebookOutlineContext.CellFoldingState.bindTo(scopedContextKeyService);
+        foldingStateCtx.set(foldingState);
+        if (!isCodeCell) {
+            template.elementDisposables.add(nbViewModel.onDidFoldingStateChanged(() => {
+                const foldingState = nbCell.foldingState;
+                NotebookOutlineContext.CellFoldingState.bindTo(scopedContextKeyService).set(foldingState);
+                foldingStateCtx.set(foldingState);
+            }));
+        }
+    }
+    setupToolbarListeners(toolbar, menu, initActions, entry, templateData) {
+        let dropdownIsVisible = false;
+        let deferredUpdate;
+        toolbar.setActions(initActions.primary, initActions.secondary);
+        templateData.elementDisposables.add(menu.onDidChange(() => {
+            if (dropdownIsVisible) {
+                const actions = getOutlineToolbarActions(menu, { notebookEditor: this._editor, outlineEntry: entry });
+                deferredUpdate = () => toolbar.setActions(actions.primary, actions.secondary);
+                return;
+            }
+            const actions = getOutlineToolbarActions(menu, { notebookEditor: this._editor, outlineEntry: entry });
+            toolbar.setActions(actions.primary, actions.secondary);
+        }));
+        templateData.container.classList.remove('notebook-outline-toolbar-dropdown-active');
+        templateData.elementDisposables.add(toolbar.onDidChangeDropdownVisibility(visible => {
+            dropdownIsVisible = visible;
+            if (visible) {
+                templateData.container.classList.add('notebook-outline-toolbar-dropdown-active');
+            }
+            else {
+                templateData.container.classList.remove('notebook-outline-toolbar-dropdown-active');
+            }
+            if (deferredUpdate && !visible) {
+                disposableTimeout(() => {
+                    deferredUpdate?.();
+                }, 0, templateData.elementDisposables);
+                deferredUpdate = undefined;
+            }
+        }));
+    }
+};
+NotebookOutlineRenderer = ( __decorate([
+    ( __param(2, IThemeService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, IContextMenuService)),
+    ( __param(5, IContextKeyService)),
+    ( __param(6, IMenuService)),
+    ( __param(7, IInstantiationService))
+], NotebookOutlineRenderer));
+function getOutlineToolbarActions(menu, args) {
+    const primary = [];
+    const secondary = [];
+    const result = { primary, secondary };
+    createAndFillInActionBarActions(menu, { shouldForwardArgs: true, arg: args }, result);
+    return result;
+}
+class NotebookOutlineAccessibility {
+    getAriaLabel(element) {
+        return element.label;
+    }
+    getWidgetAriaLabel() {
+        return '';
+    }
+}
+class NotebookNavigationLabelProvider {
+    getKeyboardNavigationLabel(element) {
+        return element.label;
+    }
+}
+class NotebookOutlineVirtualDelegate {
+    getHeight(_element) {
+        return 22;
+    }
+    getTemplateId(_element) {
+        return NotebookOutlineTemplate.templateId;
+    }
+}
+let NotebookQuickPickProvider = class NotebookQuickPickProvider {
+    constructor(_getEntries, _themeService) {
+        this._getEntries = _getEntries;
+        this._themeService = _themeService;
+    }
+    getQuickPickElements() {
+        const bucket = [];
+        for (const entry of this._getEntries()) {
+            entry.asFlatList(bucket);
+        }
+        const result = [];
+        const { hasFileIcons } = this._themeService.getFileIconTheme();
+        for (const element of bucket) {
+            const useFileIcon = hasFileIcons && !element.symbolKind;
+            result.push({
+                element,
+                label: useFileIcon ? element.label : `$(${element.icon.id}) ${element.label}`,
+                ariaLabel: element.label,
+                iconClasses: useFileIcon ? getIconClassesForLanguageId(element.cell.language ?? '') : undefined,
+            });
+        }
+        return result;
+    }
+};
+NotebookQuickPickProvider = ( __decorate([
+    ( __param(1, IThemeService))
+], NotebookQuickPickProvider));
+class NotebookComparator {
+    constructor() {
+        this._collator = new WindowIdleValue(mainWindow, () => new Intl.Collator(undefined, { numeric: true }));
+    }
+    compareByPosition(a, b) {
+        return a.index - b.index;
+    }
+    compareByType(a, b) {
+        return a.cell.cellKind - b.cell.cellKind || this._collator.value.compare(a.label, b.label);
+    }
+    compareByName(a, b) {
+        return this._collator.value.compare(a.label, b.label);
+    }
+}
+let NotebookCellOutline = NotebookCellOutline_1 = class NotebookCellOutline {
+    get entries() {
+        return this._outlineProvider?.entries ?? [];
+    }
+    get activeElement() {
+        return this._outlineProvider?.activeElement;
+    }
+    constructor(_editor, _target, instantiationService, _editorService, _configurationService) {
+        this._editor = _editor;
+        this._editorService = _editorService;
+        this._dispoables = ( new DisposableStore());
+        this._onDidChange = ( new Emitter());
+        this.onDidChange = this._onDidChange.event;
+        this._entriesDisposables = ( new DisposableStore());
+        this.outlineKind = 'notebookCells';
+        this._localDisposables = ( new DisposableStore());
+        const installSelectionListener = () => {
+            const notebookEditor = _editor.getControl();
+            if (!notebookEditor?.hasModel()) {
+                this._outlineProvider?.dispose();
+                this._outlineProvider = undefined;
+                this._localDisposables.clear();
+            }
+            else {
+                this._outlineProvider?.dispose();
+                this._localDisposables.clear();
+                this._outlineProvider = instantiationService.createInstance(NotebookCellOutlineProvider, notebookEditor, _target);
+                this._localDisposables.add(this._outlineProvider.onDidChange(e => {
+                    this._onDidChange.fire(e);
+                }));
+            }
+        };
+        this._dispoables.add(_editor.onDidChangeModel(() => {
+            installSelectionListener();
+        }));
+        installSelectionListener();
+        const treeDataSource = {
+            getChildren: parent => {
+                return this.getChildren(parent, _configurationService);
+            }
+        };
+        const delegate = ( new NotebookOutlineVirtualDelegate());
+        const renderers = [instantiationService.createInstance(NotebookOutlineRenderer, this._editor.getControl(), _target)];
+        const comparator = ( new NotebookComparator());
+        const options = {
+            collapseByDefault: _target === 2  || ((_target === 1  && _configurationService.getValue("outline.collapseItems" ) === "alwaysCollapse") ),
+            expandOnlyOnTwistieClick: true,
+            multipleSelectionSupport: false,
+            accessibilityProvider: ( new NotebookOutlineAccessibility()),
+            identityProvider: { getId: element => ( element.cell.uri.toString()) },
+            keyboardNavigationLabelProvider: ( new NotebookNavigationLabelProvider())
+        };
+        this.config = {
+            breadcrumbsDataSource: {
+                getBreadcrumbElements: () => {
+                    const result = [];
+                    let candidate = this.activeElement;
+                    while (candidate) {
+                        result.unshift(candidate);
+                        candidate = candidate.parent;
+                    }
+                    return result;
+                }
+            },
+            quickPickDataSource: instantiationService.createInstance(NotebookQuickPickProvider, () => (this._outlineProvider?.entries ?? [])),
+            treeDataSource,
+            delegate,
+            renderers,
+            comparator,
+            options
+        };
+    }
+    *getChildren(parent, configurationService) {
+        const showCodeCells = configurationService.getValue(NotebookSetting.outlineShowCodeCells);
+        const showCodeCellSymbols = configurationService.getValue(NotebookSetting.outlineShowCodeCellSymbols);
+        const showMarkdownHeadersOnly = configurationService.getValue(NotebookSetting.outlineShowMarkdownHeadersOnly);
+        for (const entry of parent instanceof NotebookCellOutline_1 ? (this._outlineProvider?.entries ?? []) : parent.children) {
+            if (entry.cell.cellKind === CellKind.Markup) {
+                if (!showMarkdownHeadersOnly) {
+                    yield entry;
+                }
+                else if (entry.level < 7) {
+                    yield entry;
+                }
+            }
+            else if (showCodeCells && entry.cell.cellKind === CellKind.Code) {
+                if (showCodeCellSymbols) {
+                    yield entry;
+                }
+                else if (entry.level === 7) {
+                    yield entry;
+                }
+            }
+        }
+    }
+    async setFullSymbols(cancelToken) {
+        await this._outlineProvider?.setFullSymbols(cancelToken);
+    }
+    get uri() {
+        return this._outlineProvider?.uri;
+    }
+    get isEmpty() {
+        return this._outlineProvider?.isEmpty ?? true;
+    }
+    async reveal(entry, options, sideBySide) {
+        await this._editorService.openEditor({
+            resource: entry.cell.uri,
+            options: {
+                ...options,
+                override: this._editor.input?.editorId,
+                cellRevealType: 5 ,
+                selection: entry.position
+            },
+        }, sideBySide ? SIDE_GROUP : undefined);
+    }
+    preview(entry) {
+        const widget = this._editor.getControl();
+        if (!widget) {
+            return Disposable.None;
+        }
+        if (entry.range) {
+            const range = Range.lift(entry.range);
+            widget.revealRangeInCenterIfOutsideViewportAsync(entry.cell, range);
+        }
+        else {
+            widget.revealInCenterIfOutsideViewport(entry.cell);
+        }
+        const ids = widget.deltaCellDecorations([], [{
+                handle: entry.cell.handle,
+                options: { className: 'nb-symbolHighlight', outputClassName: 'nb-symbolHighlight' }
+            }]);
+        let editorDecorations;
+        widget.changeModelDecorations(accessor => {
+            if (entry.range) {
+                const decorations = [
+                    {
+                        range: entry.range, options: {
+                            description: 'document-symbols-outline-range-highlight',
+                            className: 'rangeHighlight',
+                            isWholeLine: true
+                        }
+                    }
+                ];
+                const deltaDecoration = {
+                    ownerId: entry.cell.handle,
+                    decorations: decorations
+                };
+                editorDecorations = accessor.deltaDecorations([], [deltaDecoration]);
+            }
+        });
+        return toDisposable(() => {
+            widget.deltaCellDecorations(ids, []);
+            if (editorDecorations?.length) {
+                widget.changeModelDecorations(accessor => {
+                    accessor.deltaDecorations(editorDecorations, []);
+                });
+            }
+        });
+    }
+    captureViewState() {
+        const widget = this._editor.getControl();
+        const viewState = widget?.getEditorViewState();
+        return toDisposable(() => {
+            if (viewState) {
+                widget?.restoreListViewState(viewState);
+            }
+        });
+    }
+    dispose() {
+        this._onDidChange.dispose();
+        this._dispoables.dispose();
+        this._entriesDisposables.dispose();
+        this._outlineProvider?.dispose();
+        this._localDisposables.dispose();
+    }
+};
+NotebookCellOutline = NotebookCellOutline_1 = ( __decorate([
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IEditorService)),
+    ( __param(4, IConfigurationService))
+], NotebookCellOutline));
+let NotebookOutlineCreator = class NotebookOutlineCreator {
+    constructor(outlineService, _instantiationService, _configurationService) {
+        this._instantiationService = _instantiationService;
+        this._configurationService = _configurationService;
+        const reg = outlineService.registerOutlineCreator(this);
+        this.dispose = () => reg.dispose();
+    }
+    matches(candidate) {
+        return candidate.getId() === NotebookEditor.ID;
+    }
+    async createOutline(editor, target, cancelToken) {
+        const outline = this._instantiationService.createInstance(NotebookCellOutline, editor, target);
+        const showAllGotoSymbols = this._configurationService.getValue(NotebookSetting.gotoSymbolsAllSymbols);
+        const showAllOutlineSymbols = this._configurationService.getValue(NotebookSetting.outlineShowCodeCellSymbols);
+        if (target === 4  && showAllGotoSymbols) {
+            await outline.setFullSymbols(cancelToken);
+        }
+        else if (target === 1  && showAllOutlineSymbols) {
+            await outline.setFullSymbols(cancelToken);
+        }
+        return outline;
+    }
+};
+NotebookOutlineCreator = ( __decorate([
+    ( __param(0, IOutlineService)),
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IConfigurationService))
+], NotebookOutlineCreator));
+const NotebookOutlineContext = {
+    CellKind: ( new RawContextKey('notebookCellKind', undefined)),
+    CellHasChildren: ( new RawContextKey('notebookCellHasChildren', false)),
+    CellHasHeader: ( new RawContextKey('notebookCellHasHeader', false)),
+    CellFoldingState: ( new RawContextKey('notebookCellFoldingState', 0 )),
+    OutlineElementTarget: ( new RawContextKey('notebookOutlineElementTarget', undefined)),
+};
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(NotebookOutlineCreator, 4 );
+( Registry.as(Extensions$1.Configuration)).registerConfiguration({
+    id: 'notebook',
+    order: 100,
+    type: 'object',
+    'properties': {
+        [NotebookSetting.outlineShowMarkdownHeadersOnly]: {
+            type: 'boolean',
+            default: true,
+            markdownDescription: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
+                'outline.showMarkdownHeadersOnly',
+                "When enabled, notebook outline will show only markdown cells containing a header."
+            ))
+        },
+        [NotebookSetting.outlineShowCodeCells]: {
+            type: 'boolean',
+            default: false,
+            markdownDescription: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
+                'outline.showCodeCells',
+                "When enabled, notebook outline shows code cells."
+            ))
+        },
+        [NotebookSetting.outlineShowCodeCellSymbols]: {
+            type: 'boolean',
+            default: true,
+            markdownDescription: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
+                'outline.showCodeCellSymbols',
+                "When enabled, notebook outline shows code cell symbols. Relies on `notebook.outline.showCodeCells` being enabled."
+            ))
+        },
+        [NotebookSetting.breadcrumbsShowCodeCells]: {
+            type: 'boolean',
+            default: true,
+            markdownDescription: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
+                'breadcrumbs.showCodeCells',
+                "When enabled, notebook breadcrumbs contain code cells."
+            ))
+        },
+        [NotebookSetting.gotoSymbolsAllSymbols]: {
+            type: 'boolean',
+            default: true,
+            markdownDescription: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
+                'notebook.gotoSymbols.showAllSymbols',
+                "When enabled, the Go to Symbol Quick Pick will display full code symbols from the notebook, as well as Markdown headers."
+            ))
+        },
+    }
+});
+MenuRegistry.appendMenuItem(MenuId.ViewTitle, {
+    submenu: MenuId.NotebookOutlineFilter,
+    title: ( localizeWithPath(
+        'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
+        'filter',
+        "Filter Entries"
+    )),
+    icon: Codicon.filter,
+    group: 'navigation',
+    order: -1,
+    when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', IOutlinePane.Id)), NOTEBOOK_IS_ACTIVE_EDITOR)),
+});
+registerAction2(class ToggleShowMarkdownHeadersOnly extends Action2 {
+    constructor() {
+        super({
+            id: 'notebook.outline.toggleShowMarkdownHeadersOnly',
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
+                'toggleShowMarkdownHeadersOnly',
+                "Markdown Headers Only"
+            )),
+            f1: false,
+            toggled: {
+                condition: ( ContextKeyExpr.equals('config.notebook.outline.showMarkdownHeadersOnly', true))
+            },
+            menu: {
+                id: MenuId.NotebookOutlineFilter,
+                group: '0_markdown_cells',
+            }
+        });
+    }
+    run(accessor, ...args) {
+        const configurationService = accessor.get(IConfigurationService);
+        const showMarkdownHeadersOnly = configurationService.getValue(NotebookSetting.outlineShowMarkdownHeadersOnly);
+        configurationService.updateValue(NotebookSetting.outlineShowMarkdownHeadersOnly, !showMarkdownHeadersOnly);
+    }
+});
+registerAction2(class ToggleCodeCellEntries extends Action2 {
+    constructor() {
+        super({
+            id: 'notebook.outline.toggleCodeCells',
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
+                'toggleCodeCells',
+                "Code Cells"
+            )),
+            f1: false,
+            toggled: {
+                condition: ( ContextKeyExpr.equals('config.notebook.outline.showCodeCells', true))
+            },
+            menu: {
+                id: MenuId.NotebookOutlineFilter,
+                order: 1,
+                group: '1_code_cells',
+            }
+        });
+    }
+    run(accessor, ...args) {
+        const configurationService = accessor.get(IConfigurationService);
+        const showCodeCells = configurationService.getValue(NotebookSetting.outlineShowCodeCells);
+        configurationService.updateValue(NotebookSetting.outlineShowCodeCells, !showCodeCells);
+    }
+});
+registerAction2(class ToggleCodeCellSymbolEntries extends Action2 {
+    constructor() {
+        super({
+            id: 'notebook.outline.toggleCodeCellSymbols',
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
+                'toggleCodeCellSymbols',
+                "Code Cell Symbols"
+            )),
+            f1: false,
+            toggled: {
+                condition: ( ContextKeyExpr.equals('config.notebook.outline.showCodeCellSymbols', true))
+            },
+            menu: {
+                id: MenuId.NotebookOutlineFilter,
+                order: 2,
+                group: '1_code_cells',
+            }
+        });
+    }
+    run(accessor, ...args) {
+        const configurationService = accessor.get(IConfigurationService);
+        const showCodeCellSymbols = configurationService.getValue(NotebookSetting.outlineShowCodeCellSymbols);
+        configurationService.updateValue(NotebookSetting.outlineShowCodeCellSymbols, !showCodeCellSymbols);
+    }
+});
+
+export { NotebookCellOutline, NotebookOutlineContext, NotebookOutlineCreator };