@codingame/monaco-vscode-api 1.85.6 → 2.0.0-v2.1

package/vscode/src/vs/editor/contrib/dnd/browser/dnd.js

@@ -0,0 +1,206 @@
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { isMacintosh } from '../../../../base/common/platform.js';
+import './dnd.css.js';
+import { registerEditorContribution } from '../../../browser/editorExtensions.js';
+import { Position } from '../../../common/core/position.js';
+import { Range } from '../../../common/core/range.js';
+import { Selection } from '../../../common/core/selection.js';
+import { ModelDecorationOptions } from '../../../common/model/textModel.js';
+import { DragAndDropCommand } from './dragAndDropCommand.js';
+function hasTriggerModifier(e) {
+    if (isMacintosh) {
+        return e.altKey;
+    }
+    else {
+        return e.ctrlKey;
+    }
+}
+class DragAndDropController extends Disposable {
+    static { this.ID = 'editor.contrib.dragAndDrop'; }
+    static { this.TRIGGER_KEY_VALUE = isMacintosh ? 6  : 5 ; }
+    static get(editor) {
+        return editor.getContribution(DragAndDropController.ID);
+    }
+    constructor(editor) {
+        super();
+        this._editor = editor;
+        this._dndDecorationIds = this._editor.createDecorationsCollection();
+        this._register(this._editor.onMouseDown((e) => this._onEditorMouseDown(e)));
+        this._register(this._editor.onMouseUp((e) => this._onEditorMouseUp(e)));
+        this._register(this._editor.onMouseDrag((e) => this._onEditorMouseDrag(e)));
+        this._register(this._editor.onMouseDrop((e) => this._onEditorMouseDrop(e)));
+        this._register(this._editor.onMouseDropCanceled(() => this._onEditorMouseDropCanceled()));
+        this._register(this._editor.onKeyDown((e) => this.onEditorKeyDown(e)));
+        this._register(this._editor.onKeyUp((e) => this.onEditorKeyUp(e)));
+        this._register(this._editor.onDidBlurEditorWidget(() => this.onEditorBlur()));
+        this._register(this._editor.onDidBlurEditorText(() => this.onEditorBlur()));
+        this._mouseDown = false;
+        this._modifierPressed = false;
+        this._dragSelection = null;
+    }
+    onEditorBlur() {
+        this._removeDecoration();
+        this._dragSelection = null;
+        this._mouseDown = false;
+        this._modifierPressed = false;
+    }
+    onEditorKeyDown(e) {
+        if (!this._editor.getOption(35 ) || this._editor.getOption(22 )) {
+            return;
+        }
+        if (hasTriggerModifier(e)) {
+            this._modifierPressed = true;
+        }
+        if (this._mouseDown && hasTriggerModifier(e)) {
+            this._editor.updateOptions({
+                mouseStyle: 'copy'
+            });
+        }
+    }
+    onEditorKeyUp(e) {
+        if (!this._editor.getOption(35 ) || this._editor.getOption(22 )) {
+            return;
+        }
+        if (hasTriggerModifier(e)) {
+            this._modifierPressed = false;
+        }
+        if (this._mouseDown && e.keyCode === DragAndDropController.TRIGGER_KEY_VALUE) {
+            this._editor.updateOptions({
+                mouseStyle: 'default'
+            });
+        }
+    }
+    _onEditorMouseDown(mouseEvent) {
+        this._mouseDown = true;
+    }
+    _onEditorMouseUp(mouseEvent) {
+        this._mouseDown = false;
+        this._editor.updateOptions({
+            mouseStyle: 'text'
+        });
+    }
+    _onEditorMouseDrag(mouseEvent) {
+        const target = mouseEvent.target;
+        if (this._dragSelection === null) {
+            const selections = this._editor.getSelections() || [];
+            const possibleSelections = selections.filter(selection => target.position && selection.containsPosition(target.position));
+            if (possibleSelections.length === 1) {
+                this._dragSelection = possibleSelections[0];
+            }
+            else {
+                return;
+            }
+        }
+        if (hasTriggerModifier(mouseEvent.event)) {
+            this._editor.updateOptions({
+                mouseStyle: 'copy'
+            });
+        }
+        else {
+            this._editor.updateOptions({
+                mouseStyle: 'default'
+            });
+        }
+        if (target.position) {
+            if (this._dragSelection.containsPosition(target.position)) {
+                this._removeDecoration();
+            }
+            else {
+                this.showAt(target.position);
+            }
+        }
+    }
+    _onEditorMouseDropCanceled() {
+        this._editor.updateOptions({
+            mouseStyle: 'text'
+        });
+        this._removeDecoration();
+        this._dragSelection = null;
+        this._mouseDown = false;
+    }
+    _onEditorMouseDrop(mouseEvent) {
+        if (mouseEvent.target && (this._hitContent(mouseEvent.target) || this._hitMargin(mouseEvent.target)) && mouseEvent.target.position) {
+            const newCursorPosition = ( new Position(mouseEvent.target.position.lineNumber, mouseEvent.target.position.column));
+            if (this._dragSelection === null) {
+                let newSelections = null;
+                if (mouseEvent.event.shiftKey) {
+                    const primarySelection = this._editor.getSelection();
+                    if (primarySelection) {
+                        const { selectionStartLineNumber, selectionStartColumn } = primarySelection;
+                        newSelections = [( new Selection(
+                            selectionStartLineNumber,
+                            selectionStartColumn,
+                            newCursorPosition.lineNumber,
+                            newCursorPosition.column
+                        ))];
+                    }
+                }
+                else {
+                    newSelections = ( (this._editor.getSelections() || []).map(selection => {
+                        if (selection.containsPosition(newCursorPosition)) {
+                            return ( new Selection(
+                                newCursorPosition.lineNumber,
+                                newCursorPosition.column,
+                                newCursorPosition.lineNumber,
+                                newCursorPosition.column
+                            ));
+                        }
+                        else {
+                            return selection;
+                        }
+                    }));
+                }
+                this._editor.setSelections(newSelections || [], 'mouse', 3 );
+            }
+            else if (!this._dragSelection.containsPosition(newCursorPosition) ||
+                (((hasTriggerModifier(mouseEvent.event) || this._modifierPressed) && (this._dragSelection.getEndPosition().equals(newCursorPosition) || this._dragSelection.getStartPosition().equals(newCursorPosition)))
+                )) {
+                this._editor.pushUndoStop();
+                this._editor.executeCommand(DragAndDropController.ID, ( new DragAndDropCommand(
+                    this._dragSelection,
+                    newCursorPosition,
+                    hasTriggerModifier(mouseEvent.event) || this._modifierPressed
+                )));
+                this._editor.pushUndoStop();
+            }
+        }
+        this._editor.updateOptions({
+            mouseStyle: 'text'
+        });
+        this._removeDecoration();
+        this._dragSelection = null;
+        this._mouseDown = false;
+    }
+    static { this._DECORATION_OPTIONS = ModelDecorationOptions.register({
+        description: 'dnd-target',
+        className: 'dnd-target'
+    }); }
+    showAt(position) {
+        this._dndDecorationIds.set([{
+                range: ( new Range(position.lineNumber, position.column, position.lineNumber, position.column)),
+                options: DragAndDropController._DECORATION_OPTIONS
+            }]);
+        this._editor.revealPosition(position, 1 );
+    }
+    _removeDecoration() {
+        this._dndDecorationIds.clear();
+    }
+    _hitContent(target) {
+        return target.type === 6  ||
+            target.type === 7 ;
+    }
+    _hitMargin(target) {
+        return target.type === 2  ||
+            target.type === 3  ||
+            target.type === 4 ;
+    }
+    dispose() {
+        this._removeDecoration();
+        this._dragSelection = null;
+        this._mouseDown = false;
+        this._modifierPressed = false;
+        super.dispose();
+    }
+}
+registerEditorContribution(DragAndDropController.ID, DragAndDropController, 2 );
+export { DragAndDropController };

package/vscode/src/vs/editor/contrib/dnd/browser/dragAndDropCommand.js

@@ -0,0 +1,84 @@
+import { Range } from '../../../common/core/range.js';
+import { Selection } from '../../../common/core/selection.js';
+class DragAndDropCommand {
+    constructor(selection, targetPosition, copy) {
+        this.selection = selection;
+        this.targetPosition = targetPosition;
+        this.copy = copy;
+        this.targetSelection = null;
+    }
+    getEditOperations(model, builder) {
+        const text = model.getValueInRange(this.selection);
+        if (!this.copy) {
+            builder.addEditOperation(this.selection, null);
+        }
+        builder.addEditOperation(( new Range(
+            this.targetPosition.lineNumber,
+            this.targetPosition.column,
+            this.targetPosition.lineNumber,
+            this.targetPosition.column
+        )), text);
+        if (this.selection.containsPosition(this.targetPosition) && !((this.copy && (this.selection.getEndPosition().equals(this.targetPosition) || this.selection.getStartPosition().equals(this.targetPosition)))
+        )) {
+            this.targetSelection = this.selection;
+            return;
+        }
+        if (this.copy) {
+            this.targetSelection = ( new Selection(
+                this.targetPosition.lineNumber,
+                this.targetPosition.column,
+                this.selection.endLineNumber - this.selection.startLineNumber + this.targetPosition.lineNumber,
+                this.selection.startLineNumber === this.selection.endLineNumber ?
+                    this.targetPosition.column + this.selection.endColumn - this.selection.startColumn :
+                    this.selection.endColumn
+            ));
+            return;
+        }
+        if (this.targetPosition.lineNumber > this.selection.endLineNumber) {
+            this.targetSelection = ( new Selection(
+                this.targetPosition.lineNumber - this.selection.endLineNumber + this.selection.startLineNumber,
+                this.targetPosition.column,
+                this.targetPosition.lineNumber,
+                this.selection.startLineNumber === this.selection.endLineNumber ?
+                    this.targetPosition.column + this.selection.endColumn - this.selection.startColumn :
+                    this.selection.endColumn
+            ));
+            return;
+        }
+        if (this.targetPosition.lineNumber < this.selection.endLineNumber) {
+            this.targetSelection = ( new Selection(
+                this.targetPosition.lineNumber,
+                this.targetPosition.column,
+                this.targetPosition.lineNumber + this.selection.endLineNumber - this.selection.startLineNumber,
+                this.selection.startLineNumber === this.selection.endLineNumber ?
+                    this.targetPosition.column + this.selection.endColumn - this.selection.startColumn :
+                    this.selection.endColumn
+            ));
+            return;
+        }
+        if (this.selection.endColumn <= this.targetPosition.column) {
+            this.targetSelection = ( new Selection(
+                this.targetPosition.lineNumber - this.selection.endLineNumber + this.selection.startLineNumber,
+                this.selection.startLineNumber === this.selection.endLineNumber ?
+                    this.targetPosition.column - this.selection.endColumn + this.selection.startColumn :
+                    this.targetPosition.column - this.selection.endColumn + this.selection.startColumn,
+                this.targetPosition.lineNumber,
+                this.selection.startLineNumber === this.selection.endLineNumber ?
+                    this.targetPosition.column :
+                    this.selection.endColumn
+            ));
+        }
+        else {
+            this.targetSelection = ( new Selection(
+                this.targetPosition.lineNumber - this.selection.endLineNumber + this.selection.startLineNumber,
+                this.targetPosition.column,
+                this.targetPosition.lineNumber,
+                this.targetPosition.column + this.selection.endColumn - this.selection.startColumn
+            ));
+        }
+    }
+    computeCursorState(model, helper) {
+        return this.targetSelection;
+    }
+}
+export { DragAndDropCommand };

package/vscode/src/vs/editor/contrib/documentSymbols/browser/documentSymbols.js

@@ -0,0 +1,19 @@
+import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { assertType } from '../../../../base/common/types.js';
+import { URI } from '../../../../base/common/uri.js';
+import { ITextModelService } from '../../../common/services/resolverService.js';
+import { IOutlineModelService } from './outlineModel.js';
+import { CommandsRegistry } from '../../../../platform/commands/common/commands.js';
+CommandsRegistry.registerCommand('_executeDocumentSymbolProvider', async function (accessor, ...args) {
+    const [resource] = args;
+    assertType(URI.isUri(resource));
+    const outlineService = accessor.get(IOutlineModelService);
+    const modelService = accessor.get(ITextModelService);
+    const reference = await modelService.createModelReference(resource);
+    try {
+        return (await outlineService.getOrCreate(reference.object.textEditorModel, CancellationToken.None)).getTopLevelSymbols();
+    }
+    finally {
+        reference.dispose();
+    }
+});

package/vscode/src/vs/editor/contrib/documentSymbols/browser/outlineModel.js

@@ -0,0 +1,372 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { equals, binarySearch, coalesceInPlace } from '../../../../base/common/arrays.js';
+import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
+import { onUnexpectedExternalError } from '../../../../base/common/errors.js';
+import { Iterable } from '../../../../base/common/iterator.js';
+import { LRUCache } from '../../../../base/common/map.js';
+import { commonPrefixLength } from '../../../../base/common/strings.js';
+import { Position } from '../../../common/core/position.js';
+import { Range } from '../../../common/core/range.js';
+import { ILanguageFeatureDebounceService } from '../../../common/services/languageFeatureDebounce.js';
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+import { registerSingleton } from '../../../../platform/instantiation/common/extensions.js';
+import { IModelService } from '../../../common/services/model.js';
+import { DisposableStore } from '../../../../base/common/lifecycle.js';
+import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';
+class TreeElement {
+    remove() {
+        this.parent?.children.delete(this.id);
+    }
+    static findId(candidate, container) {
+        let candidateId;
+        if (typeof candidate === 'string') {
+            candidateId = `${container.id}/${candidate}`;
+        }
+        else {
+            candidateId = `${container.id}/${candidate.name}`;
+            if (container.children.get(candidateId) !== undefined) {
+                candidateId = `${container.id}/${candidate.name}_${candidate.range.startLineNumber}_${candidate.range.startColumn}`;
+            }
+        }
+        let id = candidateId;
+        for (let i = 0; container.children.get(id) !== undefined; i++) {
+            id = `${candidateId}_${i}`;
+        }
+        return id;
+    }
+    static getElementById(id, element) {
+        if (!id) {
+            return undefined;
+        }
+        const len = commonPrefixLength(id, element.id);
+        if (len === id.length) {
+            return element;
+        }
+        if (len < element.id.length) {
+            return undefined;
+        }
+        for (const [, child] of element.children) {
+            const candidate = TreeElement.getElementById(id, child);
+            if (candidate) {
+                return candidate;
+            }
+        }
+        return undefined;
+    }
+    static size(element) {
+        let res = 1;
+        for (const [, child] of element.children) {
+            res += TreeElement.size(child);
+        }
+        return res;
+    }
+    static empty(element) {
+        return element.children.size === 0;
+    }
+}
+class OutlineElement extends TreeElement {
+    constructor(id, parent, symbol) {
+        super();
+        this.id = id;
+        this.parent = parent;
+        this.symbol = symbol;
+        this.children = ( new Map());
+    }
+}
+class OutlineGroup extends TreeElement {
+    constructor(id, parent, label, order) {
+        super();
+        this.id = id;
+        this.parent = parent;
+        this.label = label;
+        this.order = order;
+        this.children = ( new Map());
+    }
+    getItemEnclosingPosition(position) {
+        return position ? this._getItemEnclosingPosition(position, this.children) : undefined;
+    }
+    _getItemEnclosingPosition(position, children) {
+        for (const [, item] of children) {
+            if (!item.symbol.range || !Range.containsPosition(item.symbol.range, position)) {
+                continue;
+            }
+            return this._getItemEnclosingPosition(position, item.children) || item;
+        }
+        return undefined;
+    }
+    updateMarker(marker) {
+        for (const [, child] of this.children) {
+            this._updateMarker(marker, child);
+        }
+    }
+    _updateMarker(markers, item) {
+        item.marker = undefined;
+        const idx = binarySearch(markers, item.symbol.range, Range.compareRangesUsingStarts);
+        let start;
+        if (idx < 0) {
+            start = ~idx;
+            if (start > 0 && Range.areIntersecting(markers[start - 1], item.symbol.range)) {
+                start -= 1;
+            }
+        }
+        else {
+            start = idx;
+        }
+        const myMarkers = [];
+        let myTopSev;
+        for (; start < markers.length && Range.areIntersecting(item.symbol.range, markers[start]); start++) {
+            const marker = markers[start];
+            myMarkers.push(marker);
+            markers[start] = undefined;
+            if (!myTopSev || marker.severity > myTopSev) {
+                myTopSev = marker.severity;
+            }
+        }
+        for (const [, child] of item.children) {
+            this._updateMarker(myMarkers, child);
+        }
+        if (myTopSev) {
+            item.marker = {
+                count: myMarkers.length,
+                topSev: myTopSev
+            };
+        }
+        coalesceInPlace(markers);
+    }
+}
+class OutlineModel extends TreeElement {
+    static create(registry, textModel, token) {
+        const cts = ( new CancellationTokenSource(token));
+        const result = ( new OutlineModel(textModel.uri));
+        const provider = registry.ordered(textModel);
+        const promises = ( provider.map((provider, index) => {
+            const id = TreeElement.findId(`provider_${index}`, result);
+            const group = ( new OutlineGroup(id, result, provider.displayName ?? 'Unknown Outline Provider', index));
+            return Promise.resolve(provider.provideDocumentSymbols(textModel, cts.token)).then(result => {
+                for (const info of result || []) {
+                    OutlineModel._makeOutlineElement(info, group);
+                }
+                return group;
+            }, err => {
+                onUnexpectedExternalError(err);
+                return group;
+            }).then(group => {
+                if (!TreeElement.empty(group)) {
+                    result._groups.set(id, group);
+                }
+                else {
+                    group.remove();
+                }
+            });
+        }));
+        const listener = registry.onDidChange(() => {
+            const newProvider = registry.ordered(textModel);
+            if (!equals(newProvider, provider)) {
+                cts.cancel();
+            }
+        });
+        return Promise.all(promises).then(() => {
+            if (cts.token.isCancellationRequested && !token.isCancellationRequested) {
+                return OutlineModel.create(registry, textModel, token);
+            }
+            else {
+                return result._compact();
+            }
+        }).finally(() => {
+            cts.dispose();
+            listener.dispose();
+            cts.dispose();
+        });
+    }
+    static _makeOutlineElement(info, container) {
+        const id = TreeElement.findId(info, container);
+        const res = ( new OutlineElement(id, container, info));
+        if (info.children) {
+            for (const childInfo of info.children) {
+                OutlineModel._makeOutlineElement(childInfo, res);
+            }
+        }
+        container.children.set(res.id, res);
+    }
+    static get(element) {
+        while (element) {
+            if (element instanceof OutlineModel) {
+                return element;
+            }
+            element = element.parent;
+        }
+        return undefined;
+    }
+    constructor(uri) {
+        super();
+        this.uri = uri;
+        this.id = 'root';
+        this.parent = undefined;
+        this._groups = ( new Map());
+        this.children = ( new Map());
+        this.id = 'root';
+        this.parent = undefined;
+    }
+    _compact() {
+        let count = 0;
+        for (const [key, group] of this._groups) {
+            if (group.children.size === 0) {
+                this._groups.delete(key);
+            }
+            else {
+                count += 1;
+            }
+        }
+        if (count !== 1) {
+            this.children = this._groups;
+        }
+        else {
+            const group = Iterable.first(( this._groups.values()));
+            for (const [, child] of group.children) {
+                child.parent = this;
+                this.children.set(child.id, child);
+            }
+        }
+        return this;
+    }
+    merge(other) {
+        if (( this.uri.toString()) !== ( other.uri.toString())) {
+            return false;
+        }
+        if (this._groups.size !== other._groups.size) {
+            return false;
+        }
+        this._groups = other._groups;
+        this.children = other.children;
+        return true;
+    }
+    getItemEnclosingPosition(position, context) {
+        let preferredGroup;
+        if (context) {
+            let candidate = context.parent;
+            while (candidate && !preferredGroup) {
+                if (candidate instanceof OutlineGroup) {
+                    preferredGroup = candidate;
+                }
+                candidate = candidate.parent;
+            }
+        }
+        let result = undefined;
+        for (const [, group] of this._groups) {
+            result = group.getItemEnclosingPosition(position);
+            if (result && (!preferredGroup || preferredGroup === group)) {
+                break;
+            }
+        }
+        return result;
+    }
+    getItemById(id) {
+        return TreeElement.getElementById(id, this);
+    }
+    updateMarker(marker) {
+        marker.sort(Range.compareRangesUsingStarts);
+        for (const [, group] of this._groups) {
+            group.updateMarker(marker.slice(0));
+        }
+    }
+    getTopLevelSymbols() {
+        const roots = [];
+        for (const child of ( this.children.values())) {
+            if (child instanceof OutlineElement) {
+                roots.push(child.symbol);
+            }
+            else {
+                roots.push(...( Iterable.map(( child.children.values()), child => child.symbol)));
+            }
+        }
+        return roots.sort((a, b) => Range.compareRangesUsingStarts(a.range, b.range));
+    }
+    asListOfDocumentSymbols() {
+        const roots = this.getTopLevelSymbols();
+        const bucket = [];
+        OutlineModel._flattenDocumentSymbols(bucket, roots, '');
+        return bucket.sort((a, b) => Position.compare(Range.getStartPosition(a.range), Range.getStartPosition(b.range)) || Position.compare(Range.getEndPosition(b.range), Range.getEndPosition(a.range)));
+    }
+    static _flattenDocumentSymbols(bucket, entries, overrideContainerLabel) {
+        for (const entry of entries) {
+            bucket.push({
+                kind: entry.kind,
+                tags: entry.tags,
+                name: entry.name,
+                detail: entry.detail,
+                containerName: entry.containerName || overrideContainerLabel,
+                range: entry.range,
+                selectionRange: entry.selectionRange,
+                children: undefined,
+            });
+            if (entry.children) {
+                OutlineModel._flattenDocumentSymbols(bucket, entry.children, entry.name);
+            }
+        }
+    }
+}
+const IOutlineModelService = ( createDecorator('IOutlineModelService'));
+let OutlineModelService = class OutlineModelService {
+    constructor(_languageFeaturesService, debounces, modelService) {
+        this._languageFeaturesService = _languageFeaturesService;
+        this._disposables = ( new DisposableStore());
+        this._cache = ( new LRUCache(10, 0.7));
+        this._debounceInformation = debounces.for(_languageFeaturesService.documentSymbolProvider, 'DocumentSymbols', { min: 350 });
+        this._disposables.add(modelService.onModelRemoved(textModel => {
+            this._cache.delete(textModel.id);
+        }));
+    }
+    dispose() {
+        this._disposables.dispose();
+    }
+    async getOrCreate(textModel, token) {
+        const registry = this._languageFeaturesService.documentSymbolProvider;
+        const provider = registry.ordered(textModel);
+        let data = this._cache.get(textModel.id);
+        if (!data || data.versionId !== textModel.getVersionId() || !equals(data.provider, provider)) {
+            const source = ( new CancellationTokenSource());
+            data = {
+                versionId: textModel.getVersionId(),
+                provider,
+                promiseCnt: 0,
+                source,
+                promise: OutlineModel.create(registry, textModel, source.token),
+                model: undefined,
+            };
+            this._cache.set(textModel.id, data);
+            const now = Date.now();
+            data.promise.then(outlineModel => {
+                data.model = outlineModel;
+                this._debounceInformation.update(textModel, Date.now() - now);
+            }).catch(_err => {
+                this._cache.delete(textModel.id);
+            });
+        }
+        if (data.model) {
+            return data.model;
+        }
+        data.promiseCnt += 1;
+        const listener = token.onCancellationRequested(() => {
+            if (--data.promiseCnt === 0) {
+                data.source.cancel();
+                this._cache.delete(textModel.id);
+            }
+        });
+        try {
+            return await data.promise;
+        }
+        finally {
+            listener.dispose();
+        }
+    }
+    getDebounceValue(textModel) {
+        return this._debounceInformation.get(textModel);
+    }
+};
+OutlineModelService = ( __decorate([
+    ( __param(0, ILanguageFeaturesService)),
+    ( __param(1, ILanguageFeatureDebounceService)),
+    ( __param(2, IModelService))
+], OutlineModelService));
+registerSingleton(IOutlineModelService, OutlineModelService, 1 );
+export { IOutlineModelService, OutlineElement, OutlineGroup, OutlineModel, OutlineModelService, TreeElement };