@codingame/monaco-vscode-api 1.79.7-next.0 → 1.79.7-next.2

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

@@ -0,0 +1,290 @@
+import { __decorate, __param } from '../../../../../../node_modules/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 {
+    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.Id = 'outline';
+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/dist/vscode/vs/workbench/contrib/outline/browser/outlineViewState.js

@@ -0,0 +1,66 @@
+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/dist/vscode/vs/workbench/contrib/url/common/urlGlob.js

@@ -0,0 +1,60 @@
+const testUrlMatchesGlob = (uri, globUrl) => {
+    let url = ( uri.with({ query: null, fragment: null }).toString(true));
+    const normalize = (url) => url.replace(/\/+$/, '');
+    globUrl = normalize(globUrl);
+    url = normalize(url);
+    const memo = ( Array.from({ length: url.length + 1 }).map(() => ( Array.from({ length: globUrl.length + 1 }).map(() => undefined))));
+    if (/^[^./:]*:\/\//.test(globUrl)) {
+        return doUrlMatch(memo, url, globUrl, 0, 0);
+    }
+    const scheme = /^(https?):\/\//.exec(url)?.[1];
+    if (scheme) {
+        return doUrlMatch(memo, url, `${scheme}://${globUrl}`, 0, 0);
+    }
+    return false;
+};
+const doUrlMatch = (memo, url, globUrl, urlOffset, globUrlOffset) => {
+    if (memo[urlOffset]?.[globUrlOffset] !== undefined) {
+        return memo[urlOffset][globUrlOffset];
+    }
+    const options = [];
+    if (urlOffset === url.length) {
+        return globUrlOffset === globUrl.length;
+    }
+    if (globUrlOffset === globUrl.length) {
+        const remaining = url.slice(urlOffset);
+        return remaining[0] === '/';
+    }
+    if (url[urlOffset] === globUrl[globUrlOffset]) {
+        options.push(doUrlMatch(memo, url, globUrl, urlOffset + 1, globUrlOffset + 1));
+    }
+    if (globUrl[globUrlOffset] + globUrl[globUrlOffset + 1] === '*.') {
+        if (!['/', ':'].includes(url[urlOffset])) {
+            options.push(doUrlMatch(memo, url, globUrl, urlOffset + 1, globUrlOffset));
+        }
+        options.push(doUrlMatch(memo, url, globUrl, urlOffset, globUrlOffset + 2));
+    }
+    if (globUrl[globUrlOffset] === '*') {
+        if (urlOffset + 1 === url.length) {
+            options.push(doUrlMatch(memo, url, globUrl, urlOffset + 1, globUrlOffset + 1));
+        }
+        else {
+            options.push(doUrlMatch(memo, url, globUrl, urlOffset + 1, globUrlOffset));
+        }
+        options.push(doUrlMatch(memo, url, globUrl, urlOffset, globUrlOffset + 1));
+    }
+    if (globUrl[globUrlOffset] + globUrl[globUrlOffset + 1] === ':*') {
+        if (url[urlOffset] === ':') {
+            let endPortIndex = urlOffset + 1;
+            do {
+                endPortIndex++;
+            } while (/[0-9]/.test(url[endPortIndex]));
+            options.push(doUrlMatch(memo, url, globUrl, endPortIndex, globUrlOffset + 2));
+        }
+        else {
+            options.push(doUrlMatch(memo, url, globUrl, urlOffset, globUrlOffset + 2));
+        }
+    }
+    return (memo[urlOffset][globUrlOffset] = ( options.some(a => a === true)));
+};
+export { testUrlMatchesGlob };