@codingame/monaco-vscode-api 1.82.4-next.1 → 1.82.5-next.0

package/vscode/src/vs/workbench/contrib/outline/browser/outline.contribution.js

@@ -1,261 +0,0 @@
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { Extensions } from '../../../common/views.js';
-import { OutlinePane } from './outlinePane.js';
-import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-import { Extensions as Extensions$1 } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
-import { VIEW_CONTAINER } from '../../files/browser/explorerViewlet.js';
-import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
-import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
-import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
-import { IOutlinePane } from './outline.js';
-const outlineViewIcon = registerIcon('outline-view-icon', Codicon.symbolClass, ( localize('outlineViewIcon', 'View icon of the outline view.')));
-( Registry.as(Extensions.ViewsRegistry)).registerViews([{
-        id: IOutlinePane.Id,
-        name: ( localize('name', "Outline")),
-        containerIcon: outlineViewIcon,
-        ctorDescriptor: ( new SyncDescriptor(OutlinePane)),
-        canToggleVisibility: true,
-        canMoveView: true,
-        hideByDefault: false,
-        collapsed: true,
-        order: 2,
-        weight: 30,
-        focusCommand: { id: 'outline.focus' }
-    }], VIEW_CONTAINER);
-( Registry.as(Extensions$1.Configuration)).registerConfiguration({
-    'id': 'outline',
-    'order': 117,
-    'title': ( localize('outlineConfigurationTitle', "Outline")),
-    'type': 'object',
-    'properties': {
-        ["outline.icons" ]: {
-            'description': ( localize('outline.showIcons', "Render Outline elements with icons.")),
-            'type': 'boolean',
-            'default': true
-        },
-        ["outline.collapseItems" ]: {
-            'description': ( localize(
-                'outline.initialState',
-                "Controls whether Outline items are collapsed or expanded."
-            )),
-            'type': 'string',
-            scope: 5 ,
-            'enum': [
-                'alwaysCollapse',
-                'alwaysExpand'
-            ],
-            'enumDescriptions': [
-                ( localize('outline.initialState.collapsed', "Collapse all items.")),
-                ( localize('outline.initialState.expanded', "Expand all items."))
-            ],
-            'default': 'alwaysExpand'
-        },
-        ["outline.problems.enabled" ]: {
-            'description': ( localize('outline.showProblem', "Show errors and warnings on Outline elements.")),
-            'type': 'boolean',
-            'default': true
-        },
-        ["outline.problems.colors" ]: {
-            'description': ( localize(
-                'outline.problem.colors',
-                "Use colors for errors and warnings on Outline elements."
-            )),
-            'type': 'boolean',
-            'default': true
-        },
-        ["outline.problems.badges" ]: {
-            'description': ( localize(
-                'outline.problems.badges',
-                "Use badges for errors and warnings on Outline elements."
-            )),
-            'type': 'boolean',
-            'default': true
-        },
-        'outline.showFiles': {
-            type: 'boolean',
-            scope: 5 ,
-            default: true,
-            markdownDescription: ( localize('filteredTypes.file', "When enabled, Outline shows `file`-symbols."))
-        },
-        'outline.showModules': {
-            type: 'boolean',
-            scope: 5 ,
-            default: true,
-            markdownDescription: ( localize('filteredTypes.module', "When enabled, Outline shows `module`-symbols."))
-        },
-        'outline.showNamespaces': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize(
-                'filteredTypes.namespace',
-                "When enabled, Outline shows `namespace`-symbols."
-            ))
-        },
-        'outline.showPackages': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize('filteredTypes.package', "When enabled, Outline shows `package`-symbols."))
-        },
-        'outline.showClasses': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize('filteredTypes.class', "When enabled, Outline shows `class`-symbols."))
-        },
-        'outline.showMethods': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize('filteredTypes.method', "When enabled, Outline shows `method`-symbols."))
-        },
-        'outline.showProperties': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize(
-                'filteredTypes.property',
-                "When enabled, Outline shows `property`-symbols."
-            ))
-        },
-        'outline.showFields': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize('filteredTypes.field', "When enabled, Outline shows `field`-symbols."))
-        },
-        'outline.showConstructors': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize(
-                'filteredTypes.constructor',
-                "When enabled, Outline shows `constructor`-symbols."
-            ))
-        },
-        'outline.showEnums': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize('filteredTypes.enum', "When enabled, Outline shows `enum`-symbols."))
-        },
-        'outline.showInterfaces': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize(
-                'filteredTypes.interface',
-                "When enabled, Outline shows `interface`-symbols."
-            ))
-        },
-        'outline.showFunctions': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize(
-                'filteredTypes.function',
-                "When enabled, Outline shows `function`-symbols."
-            ))
-        },
-        'outline.showVariables': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize(
-                'filteredTypes.variable',
-                "When enabled, Outline shows `variable`-symbols."
-            ))
-        },
-        'outline.showConstants': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize(
-                'filteredTypes.constant',
-                "When enabled, Outline shows `constant`-symbols."
-            ))
-        },
-        'outline.showStrings': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize('filteredTypes.string', "When enabled, Outline shows `string`-symbols."))
-        },
-        'outline.showNumbers': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize('filteredTypes.number', "When enabled, Outline shows `number`-symbols."))
-        },
-        'outline.showBooleans': {
-            type: 'boolean',
-            scope: 5 ,
-            default: true,
-            markdownDescription: ( localize('filteredTypes.boolean', "When enabled, Outline shows `boolean`-symbols."))
-        },
-        'outline.showArrays': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize('filteredTypes.array', "When enabled, Outline shows `array`-symbols."))
-        },
-        'outline.showObjects': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize('filteredTypes.object', "When enabled, Outline shows `object`-symbols."))
-        },
-        'outline.showKeys': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize('filteredTypes.key', "When enabled, Outline shows `key`-symbols."))
-        },
-        'outline.showNull': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize('filteredTypes.null', "When enabled, Outline shows `null`-symbols."))
-        },
-        'outline.showEnumMembers': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize(
-                'filteredTypes.enumMember',
-                "When enabled, Outline shows `enumMember`-symbols."
-            ))
-        },
-        'outline.showStructs': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize('filteredTypes.struct', "When enabled, Outline shows `struct`-symbols."))
-        },
-        'outline.showEvents': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize('filteredTypes.event', "When enabled, Outline shows `event`-symbols."))
-        },
-        'outline.showOperators': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize(
-                'filteredTypes.operator',
-                "When enabled, Outline shows `operator`-symbols."
-            ))
-        },
-        'outline.showTypeParameters': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize(
-                'filteredTypes.typeParameter',
-                "When enabled, Outline shows `typeParameter`-symbols."
-            ))
-        }
-    }
-});

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

@@ -1,10 +0,0 @@
-import { RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-var IOutlinePane;
-( (function(IOutlinePane) {
-    IOutlinePane.Id = 'outline';
-})(IOutlinePane || (IOutlinePane = {})));
-const ctxFollowsCursor = ( new RawContextKey('outlineFollowsCursor', false));
-const ctxFilterOnType = ( new RawContextKey('outlineFiltersOnType', false));
-const ctxSortMode = ( new RawContextKey('outlineSortMode', 0 ));
-const ctxAllCollapsed = ( new RawContextKey('outlineAllCollapsed', false));
-export { IOutlinePane, ctxAllCollapsed, ctxFilterOnType, ctxFollowsCursor, ctxSortMode };

package/vscode/src/vs/workbench/contrib/outline/browser/outlinePane.css.js

@@ -1,4 +0,0 @@
-import n from '../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
-var css = ".monaco-workbench .outline-pane{display:flex;flex-direction:column}.monaco-workbench .outline-pane .outline-progress{height:2px;padding-bottom:3px;position:absolute;width:100%}.monaco-workbench .outline-pane .outline-progress .monaco-progress-container,.monaco-workbench .outline-pane .outline-progress .monaco-progress-container .progress-bit{height:2px}.monaco-workbench .outline-pane .outline-tree{height:100%}.monaco-workbench .outline-pane .outline-message{display:none;opacity:.5;padding:10px 22px 0;pointer-events:none;position:absolute;z-index:1}.monaco-workbench .outline-pane.message .outline-message{display:inherit}.monaco-workbench .outline-pane.message .outline-progress{display:none}";
-n(css,{});
-export { css, css as default };

package/vscode/src/vs/workbench/contrib/outline/browser/outlinePane.js

@@ -1,290 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import './outlinePane.css.js';
-import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
-import { ProgressBar } from 'monaco-editor/esm/vs/base/browser/ui/progressbar/progressbar.js';
-import { TimeoutTimer } from 'monaco-editor/esm/vs/base/common/async.js';
-import { DisposableStore, MutableDisposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { LRUCache } from 'monaco-editor/esm/vs/base/common/map.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
-import { WorkbenchDataTree } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
-import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
-import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
-import { ViewPane } from '../../../browser/parts/views/viewPane.js';
-import { IEditorService } from '../../../services/editor/common/editorService.js';
-import { basename } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { IViewDescriptorService } from '../../../common/views.js';
-import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
-import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
-import { OutlineViewState } from './outlineViewState.js';
-import { IOutlineService } from '../../../services/outline/browser/outline.js';
-import { EditorResourceAccessor } from '../../../common/editor.js';
-import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
-import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import { TreeFindMode, AbstractTreeViewState } from 'monaco-editor/esm/vs/base/browser/ui/tree/abstractTree.js';
-import { ctxFollowsCursor, ctxFilterOnType, ctxSortMode, ctxAllCollapsed } from './outline.js';
-import { defaultProgressBarStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
-class OutlineTreeSorter {
-    constructor(_comparator, order) {
-        this._comparator = _comparator;
-        this.order = order;
-    }
-    compare(a, b) {
-        if (this.order === 2 ) {
-            return this._comparator.compareByType(a, b);
-        }
-        else if (this.order === 1 ) {
-            return this._comparator.compareByName(a, b);
-        }
-        else {
-            return this._comparator.compareByPosition(a, b);
-        }
-    }
-}
-let OutlinePane = class OutlinePane extends ViewPane {
-    static { this.Id = 'outline'; }
-    constructor(options, _outlineService, _instantiationService, viewDescriptorService, _storageService, _editorService, configurationService, keybindingService, contextKeyService, contextMenuService, openerService, themeService, telemetryService) {
-        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, _instantiationService, openerService, themeService, telemetryService);
-        this._outlineService = _outlineService;
-        this._instantiationService = _instantiationService;
-        this._storageService = _storageService;
-        this._editorService = _editorService;
-        this._disposables = ( new DisposableStore());
-        this._editorControlDisposables = ( new DisposableStore());
-        this._editorPaneDisposables = ( new DisposableStore());
-        this._outlineViewState = ( new OutlineViewState());
-        this._editorListener = ( new MutableDisposable());
-        this._treeStates = ( new LRUCache(10));
-        this._outlineViewState.restore(this._storageService);
-        this._disposables.add(this._outlineViewState);
-        contextKeyService.bufferChangeEvents(() => {
-            this._ctxFollowsCursor = ctxFollowsCursor.bindTo(contextKeyService);
-            this._ctxFilterOnType = ctxFilterOnType.bindTo(contextKeyService);
-            this._ctxSortMode = ctxSortMode.bindTo(contextKeyService);
-            this._ctxAllCollapsed = ctxAllCollapsed.bindTo(contextKeyService);
-        });
-        const updateContext = () => {
-            this._ctxFollowsCursor.set(this._outlineViewState.followCursor);
-            this._ctxFilterOnType.set(this._outlineViewState.filterOnType);
-            this._ctxSortMode.set(this._outlineViewState.sortBy);
-        };
-        updateContext();
-        this._disposables.add(this._outlineViewState.onDidChange(updateContext));
-    }
-    dispose() {
-        this._disposables.dispose();
-        this._editorPaneDisposables.dispose();
-        this._editorControlDisposables.dispose();
-        this._editorListener.dispose();
-        super.dispose();
-    }
-    focus() {
-        this._tree?.domFocus();
-    }
-    renderBody(container) {
-        super.renderBody(container);
-        this._domNode = container;
-        container.classList.add('outline-pane');
-        const progressContainer = dom.$('.outline-progress');
-        this._message = dom.$('.outline-message');
-        this._progressBar = ( new ProgressBar(progressContainer, defaultProgressBarStyles));
-        this._treeContainer = dom.$('.outline-tree');
-        dom.append(container, progressContainer, this._message, this._treeContainer);
-        this._disposables.add(this.onDidChangeBodyVisibility(visible => {
-            if (!visible) {
-                this._editorListener.clear();
-                this._editorPaneDisposables.clear();
-                this._editorControlDisposables.clear();
-            }
-            else if (!this._editorListener.value) {
-                const event = Event.any(this._editorService.onDidActiveEditorChange, this._outlineService.onDidChange);
-                this._editorListener.value = event(() => this._handleEditorChanged(this._editorService.activeEditorPane));
-                this._handleEditorChanged(this._editorService.activeEditorPane);
-            }
-        }));
-    }
-    layoutBody(height, width) {
-        super.layoutBody(height, width);
-        this._tree?.layout(height, width);
-        this._treeDimensions = new dom.Dimension(width, height);
-    }
-    collapseAll() {
-        this._tree?.collapseAll();
-    }
-    expandAll() {
-        this._tree?.expandAll();
-    }
-    get outlineViewState() {
-        return this._outlineViewState;
-    }
-    _showMessage(message) {
-        this._domNode.classList.add('message');
-        this._progressBar.stop().hide();
-        this._message.innerText = message;
-    }
-    _captureViewState(uri) {
-        if (this._tree) {
-            const oldOutline = this._tree.getInput();
-            if (!uri) {
-                uri = oldOutline?.uri;
-            }
-            if (oldOutline && uri) {
-                this._treeStates.set(`${oldOutline.outlineKind}/${uri}`, this._tree.getViewState());
-                return true;
-            }
-        }
-        return false;
-    }
-    _handleEditorChanged(pane) {
-        this._editorPaneDisposables.clear();
-        if (pane) {
-            this._editorPaneDisposables.add(pane.onDidChangeControl(() => {
-                this._handleEditorControlChanged(pane);
-            }));
-        }
-        this._handleEditorControlChanged(pane);
-    }
-    async _handleEditorControlChanged(pane) {
-        const resource = EditorResourceAccessor.getOriginalUri(pane?.input);
-        const didCapture = this._captureViewState();
-        this._editorControlDisposables.clear();
-        if (!pane || !this._outlineService.canCreateOutline(pane) || !resource) {
-            return this._showMessage(( localize('no-editor', "The active editor cannot provide outline information.")));
-        }
-        let loadingMessage;
-        if (!didCapture) {
-            loadingMessage = ( new TimeoutTimer(() => {
-                this._showMessage(( localize('loading', "Loading document symbols for '{0}'...", basename(resource))));
-            }, 100));
-        }
-        this._progressBar.infinite().show(500);
-        const cts = ( new CancellationTokenSource());
-        this._editorControlDisposables.add(toDisposable(() => cts.dispose(true)));
-        const newOutline = await this._outlineService.createOutline(pane, 1 , cts.token);
-        loadingMessage?.dispose();
-        if (!newOutline) {
-            return;
-        }
-        if (cts.token.isCancellationRequested) {
-            newOutline?.dispose();
-            return;
-        }
-        this._editorControlDisposables.add(newOutline);
-        this._progressBar.stop().hide();
-        const sorter = ( new OutlineTreeSorter(newOutline.config.comparator, this._outlineViewState.sortBy));
-        const tree = this._instantiationService.createInstance(WorkbenchDataTree, 'OutlinePane', this._treeContainer, newOutline.config.delegate, newOutline.config.renderers, newOutline.config.treeDataSource, {
-            ...newOutline.config.options,
-            sorter,
-            expandOnDoubleClick: false,
-            expandOnlyOnTwistieClick: true,
-            multipleSelectionSupport: false,
-            hideTwistiesOfChildlessElements: true,
-            defaultFindMode: this._outlineViewState.filterOnType ? TreeFindMode.Filter : TreeFindMode.Highlight,
-            overrideStyles: { listBackground: this.getBackgroundColor() }
-        });
-        const updateTree = () => {
-            if (newOutline.isEmpty) {
-                this._showMessage(( localize('no-symbols', "No symbols found in document '{0}'", basename(resource))));
-                this._captureViewState(resource);
-                tree.setInput(undefined);
-            }
-            else if (!tree.getInput()) {
-                this._domNode.classList.remove('message');
-                const state = this._treeStates.get(`${newOutline.outlineKind}/${newOutline.uri}`);
-                tree.setInput(newOutline, state && AbstractTreeViewState.lift(state));
-            }
-            else {
-                this._domNode.classList.remove('message');
-                tree.updateChildren();
-            }
-        };
-        updateTree();
-        this._editorControlDisposables.add(newOutline.onDidChange(updateTree));
-        tree.findMode = this._outlineViewState.filterOnType ? TreeFindMode.Filter : TreeFindMode.Highlight;
-        this._editorControlDisposables.add(this.viewDescriptorService.onDidChangeLocation(({ views }) => {
-            if (( views.some(v => v.id === this.id))) {
-                tree.updateOptions({ overrideStyles: { listBackground: this.getBackgroundColor() } });
-            }
-        }));
-        this._editorControlDisposables.add(tree.onDidChangeFindMode(mode => this._outlineViewState.filterOnType = mode === TreeFindMode.Filter));
-        this._editorControlDisposables.add(tree.onDidOpen(e => newOutline.reveal(e.element, e.editorOptions, e.sideBySide)));
-        const revealActiveElement = () => {
-            if (!this._outlineViewState.followCursor || !newOutline.activeElement) {
-                return;
-            }
-            let item = newOutline.activeElement;
-            while (item) {
-                const top = tree.getRelativeTop(item);
-                if (top === null) {
-                    tree.reveal(item, 0.5);
-                }
-                if (tree.getRelativeTop(item) !== null) {
-                    tree.setFocus([item]);
-                    tree.setSelection([item]);
-                    break;
-                }
-                item = tree.getParentElement(item);
-            }
-        };
-        revealActiveElement();
-        this._editorControlDisposables.add(newOutline.onDidChange(revealActiveElement));
-        this._editorControlDisposables.add(this._outlineViewState.onDidChange((e) => {
-            this._outlineViewState.persist(this._storageService);
-            if (e.filterOnType) {
-                tree.findMode = this._outlineViewState.filterOnType ? TreeFindMode.Filter : TreeFindMode.Highlight;
-            }
-            if (e.followCursor) {
-                revealActiveElement();
-            }
-            if (e.sortBy) {
-                sorter.order = this._outlineViewState.sortBy;
-                tree.resort();
-            }
-        }));
-        let viewState;
-        this._editorControlDisposables.add(tree.onDidChangeFindPattern(pattern => {
-            if (tree.findMode === TreeFindMode.Highlight) {
-                return;
-            }
-            if (!viewState && pattern) {
-                viewState = tree.getViewState();
-                tree.expandAll();
-            }
-            else if (!pattern && viewState) {
-                tree.setInput(tree.getInput(), viewState);
-                viewState = undefined;
-            }
-        }));
-        const updateAllCollapsedCtx = () => {
-            this._ctxAllCollapsed.set(tree.getNode(null).children.every(node => !node.collapsible || node.collapsed));
-        };
-        this._editorControlDisposables.add(tree.onDidChangeCollapseState(updateAllCollapsedCtx));
-        this._editorControlDisposables.add(tree.onDidChangeModel(updateAllCollapsedCtx));
-        updateAllCollapsedCtx();
-        tree.layout(this._treeDimensions?.height, this._treeDimensions?.width);
-        this._tree = tree;
-        this._editorControlDisposables.add(toDisposable(() => {
-            tree.dispose();
-            this._tree = undefined;
-        }));
-    }
-};
-OutlinePane = ( __decorate([
-    ( __param(1, IOutlineService)),
-    ( __param(2, IInstantiationService)),
-    ( __param(3, IViewDescriptorService)),
-    ( __param(4, IStorageService)),
-    ( __param(5, IEditorService)),
-    ( __param(6, IConfigurationService)),
-    ( __param(7, IKeybindingService)),
-    ( __param(8, IContextKeyService)),
-    ( __param(9, IContextMenuService)),
-    ( __param(10, IOpenerService)),
-    ( __param(11, IThemeService)),
-    ( __param(12, ITelemetryService))
-], OutlinePane));
-export { OutlinePane };

package/vscode/src/vs/workbench/contrib/outline/browser/outlineViewState.js

@@ -1,66 +0,0 @@
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-class OutlineViewState {
-    constructor() {
-        this._followCursor = false;
-        this._filterOnType = true;
-        this._sortBy = 0 ;
-        this._onDidChange = ( new Emitter());
-        this.onDidChange = this._onDidChange.event;
-    }
-    dispose() {
-        this._onDidChange.dispose();
-    }
-    set followCursor(value) {
-        if (value !== this._followCursor) {
-            this._followCursor = value;
-            this._onDidChange.fire({ followCursor: true });
-        }
-    }
-    get followCursor() {
-        return this._followCursor;
-    }
-    get filterOnType() {
-        return this._filterOnType;
-    }
-    set filterOnType(value) {
-        if (value !== this._filterOnType) {
-            this._filterOnType = value;
-            this._onDidChange.fire({ filterOnType: true });
-        }
-    }
-    set sortBy(value) {
-        if (value !== this._sortBy) {
-            this._sortBy = value;
-            this._onDidChange.fire({ sortBy: true });
-        }
-    }
-    get sortBy() {
-        return this._sortBy;
-    }
-    persist(storageService) {
-        storageService.store('outline/state', JSON.stringify({
-            followCursor: this.followCursor,
-            sortBy: this.sortBy,
-            filterOnType: this.filterOnType,
-        }), 1 , 1 );
-    }
-    restore(storageService) {
-        const raw = storageService.get('outline/state', 1 );
-        if (!raw) {
-            return;
-        }
-        let data;
-        try {
-            data = JSON.parse(raw);
-        }
-        catch (e) {
-            return;
-        }
-        this.followCursor = data.followCursor;
-        this.sortBy = data.sortBy ?? 0 ;
-        if (typeof data.filterOnType === 'boolean') {
-            this.filterOnType = data.filterOnType;
-        }
-    }
-}
-export { OutlineViewState };