@codingame/monaco-vscode-views-service-override 1.85.2 → 1.85.4

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

@@ -1,307 +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 { localizeWithPath } 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 'vscode/vscode/vs/workbench/browser/parts/views/viewPane';
-import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
-import { basename } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views';
-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 'vscode/vscode/vs/workbench/services/outline/browser/outline';
-import { EditorResourceAccessor } from 'vscode/vscode/vs/workbench/common/editor';
-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() {
-        super.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(( localizeWithPath(
-                'vs/workbench/contrib/outline/browser/outlinePane',
-                'no-editor',
-                "The active editor cannot provide outline information."
-            )));
-        }
-        let loadingMessage;
-        if (!didCapture) {
-            loadingMessage = ( new TimeoutTimer(() => {
-                this._showMessage(( localizeWithPath(
-                    'vs/workbench/contrib/outline/browser/outlinePane',
-                    '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(( localizeWithPath(
-                    'vs/workbench/contrib/outline/browser/outlinePane',
-                    '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,68 +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 };

package/vscode/src/vs/workbench/services/outline/browser/outlineService.js

@@ -1,37 +0,0 @@
-import { toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { LinkedList } from 'monaco-editor/esm/vs/base/common/linkedList.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-
-class OutlineService {
-    constructor() {
-        this._factories = ( new LinkedList());
-        this._onDidChange = ( new Emitter());
-        this.onDidChange = this._onDidChange.event;
-    }
-    canCreateOutline(pane) {
-        for (const factory of this._factories) {
-            if (factory.matches(pane)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    async createOutline(pane, target, token) {
-        for (const factory of this._factories) {
-            if (factory.matches(pane)) {
-                return await factory.createOutline(pane, target, token);
-            }
-        }
-        return undefined;
-    }
-    registerOutlineCreator(creator) {
-        const rm = this._factories.push(creator);
-        this._onDidChange.fire();
-        return toDisposable(() => {
-            rm();
-            this._onDidChange.fire();
-        });
-    }
-}
-
-export { OutlineService };