@codingame/monaco-vscode-api 4.5.2 → 5.0.0

package/vscode/src/vs/editor/contrib/hover/browser/contentHoverController.js

@@ -0,0 +1,332 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { addStandardDisposableListener } from '../../../../base/browser/dom.js';
+import { Disposable, toDisposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { Position } from '../../../common/core/position.js';
+import { Range } from '../../../common/core/range.js';
+import { ModelDecorationOptions } from '../../../common/model/textModel.js';
+import { TokenizationRegistry } from '../../../common/languages.js';
+import { HoverOperation } from './hoverOperation.js';
+import { HoverParticipantRegistry, HoverRangeAnchor } from './hoverTypes.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.service.js';
+import { MarkdownHoverParticipant } from './markdownHoverParticipant.js';
+import { InlayHintsHover } from '../../inlayHints/browser/inlayHintsHover.js';
+import { ContentHoverWidget } from './contentHoverWidget.js';
+import { ContentHoverComputer } from './contentHoverComputer.js';
+import { HoverResult, ContentHoverVisibleData } from './contentHoverTypes.js';
+import { EditorHoverStatusBar } from './contentHoverStatusBar.js';
+var ContentHoverController_1;
+let ContentHoverController = class ContentHoverController extends Disposable {
+    static { ContentHoverController_1 = this; }
+    constructor(_editor, _instantiationService, _keybindingService) {
+        super();
+        this._editor = _editor;
+        this._instantiationService = _instantiationService;
+        this._keybindingService = _keybindingService;
+        this._currentResult = null;
+        this._widget = this._register(this._instantiationService.createInstance(ContentHoverWidget, this._editor));
+        this._participants = [];
+        for (const participant of HoverParticipantRegistry.getAll()) {
+            const participantInstance = this._instantiationService.createInstance(participant, this._editor);
+            if (participantInstance instanceof MarkdownHoverParticipant && !(participantInstance instanceof InlayHintsHover)) {
+                this._markdownHoverParticipant = participantInstance;
+            }
+            this._participants.push(participantInstance);
+        }
+        this._participants.sort((p1, p2) => p1.hoverOrdinal - p2.hoverOrdinal);
+        this._computer = ( new ContentHoverComputer(this._editor, this._participants));
+        this._hoverOperation = this._register(( new HoverOperation(this._editor, this._computer)));
+        this._register(this._hoverOperation.onResult((result) => {
+            if (!this._computer.anchor) {
+                return;
+            }
+            const messages = (result.hasLoadingMessage ? this._addLoadingMessage(result.value) : result.value);
+            this._withResult(( new HoverResult(this._computer.anchor, messages, result.isComplete)));
+        }));
+        this._register(addStandardDisposableListener(this._widget.getDomNode(), 'keydown', (e) => {
+            if (e.equals(9 )) {
+                this.hide();
+            }
+        }));
+        this._register(TokenizationRegistry.onDidChange(() => {
+            if (this._widget.position && this._currentResult) {
+                this._setCurrentResult(this._currentResult);
+            }
+        }));
+    }
+    _startShowingOrUpdateHover(anchor, mode, source, focus, mouseEvent) {
+        if (!this._widget.position || !this._currentResult) {
+            if (anchor) {
+                this._startHoverOperationIfNecessary(anchor, mode, source, focus, false);
+                return true;
+            }
+            return false;
+        }
+        const isHoverSticky = this._editor.getOption(60 ).sticky;
+        const isGettingCloser = (isHoverSticky
+            && mouseEvent
+            && this._widget.isMouseGettingCloser(mouseEvent.event.posx, mouseEvent.event.posy));
+        if (isGettingCloser) {
+            if (anchor) {
+                this._startHoverOperationIfNecessary(anchor, mode, source, focus, true);
+            }
+            return true;
+        }
+        if (!anchor) {
+            this._setCurrentResult(null);
+            return false;
+        }
+        if (anchor && this._currentResult.anchor.equals(anchor)) {
+            return true;
+        }
+        if (!anchor.canAdoptVisibleHover(this._currentResult.anchor, this._widget.position)) {
+            this._setCurrentResult(null);
+            this._startHoverOperationIfNecessary(anchor, mode, source, focus, false);
+            return true;
+        }
+        this._setCurrentResult(this._currentResult.filter(anchor));
+        this._startHoverOperationIfNecessary(anchor, mode, source, focus, false);
+        return true;
+    }
+    _startHoverOperationIfNecessary(anchor, mode, source, focus, insistOnKeepingHoverVisible) {
+        if (this._computer.anchor && this._computer.anchor.equals(anchor)) {
+            return;
+        }
+        this._hoverOperation.cancel();
+        this._computer.anchor = anchor;
+        this._computer.shouldFocus = focus;
+        this._computer.source = source;
+        this._computer.insistOnKeepingHoverVisible = insistOnKeepingHoverVisible;
+        this._hoverOperation.start(mode);
+    }
+    _setCurrentResult(hoverResult) {
+        if (this._currentResult === hoverResult) {
+            return;
+        }
+        if (hoverResult && hoverResult.messages.length === 0) {
+            hoverResult = null;
+        }
+        this._currentResult = hoverResult;
+        if (this._currentResult) {
+            this._renderMessages(this._currentResult.anchor, this._currentResult.messages);
+        }
+        else {
+            this._widget.hide();
+        }
+    }
+    _addLoadingMessage(result) {
+        if (this._computer.anchor) {
+            for (const participant of this._participants) {
+                if (participant.createLoadingMessage) {
+                    const loadingMessage = participant.createLoadingMessage(this._computer.anchor);
+                    if (loadingMessage) {
+                        return result.slice(0).concat([loadingMessage]);
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    _withResult(hoverResult) {
+        if (this._widget.position && this._currentResult && this._currentResult.isComplete) {
+            if (!hoverResult.isComplete) {
+                return;
+            }
+            if (this._computer.insistOnKeepingHoverVisible && hoverResult.messages.length === 0) {
+                return;
+            }
+        }
+        this._setCurrentResult(hoverResult);
+    }
+    _renderMessages(anchor, messages) {
+        const { showAtPosition, showAtSecondaryPosition, highlightRange } = ContentHoverController_1.computeHoverRanges(this._editor, anchor.range, messages);
+        const disposables = ( new DisposableStore());
+        const statusBar = disposables.add(( new EditorHoverStatusBar(this._keybindingService)));
+        const fragment = document.createDocumentFragment();
+        let colorPicker = null;
+        const context = {
+            fragment,
+            statusBar,
+            setColorPicker: (widget) => colorPicker = widget,
+            onContentsChanged: () => this._widget.onContentsChanged(),
+            setMinimumDimensions: (dimensions) => this._widget.setMinimumDimensions(dimensions),
+            hide: () => this.hide()
+        };
+        for (const participant of this._participants) {
+            const hoverParts = messages.filter(msg => msg.owner === participant);
+            if (hoverParts.length > 0) {
+                disposables.add(participant.renderHoverParts(context, hoverParts));
+            }
+        }
+        const isBeforeContent = ( messages.some(m => m.isBeforeContent));
+        if (statusBar.hasContent) {
+            fragment.appendChild(statusBar.hoverElement);
+        }
+        if (fragment.hasChildNodes()) {
+            if (highlightRange) {
+                const highlightDecoration = this._editor.createDecorationsCollection();
+                highlightDecoration.set([{
+                        range: highlightRange,
+                        options: ContentHoverController_1._DECORATION_OPTIONS
+                    }]);
+                disposables.add(toDisposable(() => {
+                    highlightDecoration.clear();
+                }));
+            }
+            this._widget.showAt(fragment, ( new ContentHoverVisibleData(
+                anchor.initialMousePosX,
+                anchor.initialMousePosY,
+                colorPicker,
+                showAtPosition,
+                showAtSecondaryPosition,
+                this._editor.getOption(60 ).above,
+                this._computer.shouldFocus,
+                this._computer.source,
+                isBeforeContent,
+                disposables
+            )));
+        }
+        else {
+            disposables.dispose();
+        }
+    }
+    static { this._DECORATION_OPTIONS = ModelDecorationOptions.register({
+        description: 'content-hover-highlight',
+        className: 'hoverHighlight'
+    }); }
+    static computeHoverRanges(editor, anchorRange, messages) {
+        let startColumnBoundary = 1;
+        if (editor.hasModel()) {
+            const viewModel = editor._getViewModel();
+            const coordinatesConverter = viewModel.coordinatesConverter;
+            const anchorViewRange = coordinatesConverter.convertModelRangeToViewRange(anchorRange);
+            const anchorViewRangeStart = ( new Position(
+                anchorViewRange.startLineNumber,
+                viewModel.getLineMinColumn(anchorViewRange.startLineNumber)
+            ));
+            startColumnBoundary = coordinatesConverter.convertViewPositionToModelPosition(anchorViewRangeStart).column;
+        }
+        const anchorLineNumber = anchorRange.startLineNumber;
+        let renderStartColumn = anchorRange.startColumn;
+        let highlightRange = messages[0].range;
+        let forceShowAtRange = null;
+        for (const msg of messages) {
+            highlightRange = Range.plusRange(highlightRange, msg.range);
+            if (msg.range.startLineNumber === anchorLineNumber && msg.range.endLineNumber === anchorLineNumber) {
+                renderStartColumn = Math.max(Math.min(renderStartColumn, msg.range.startColumn), startColumnBoundary);
+            }
+            if (msg.forceShowAtRange) {
+                forceShowAtRange = msg.range;
+            }
+        }
+        const showAtPosition = forceShowAtRange ? forceShowAtRange.getStartPosition() : ( new Position(anchorLineNumber, anchorRange.startColumn));
+        const showAtSecondaryPosition = forceShowAtRange ? forceShowAtRange.getStartPosition() : ( new Position(anchorLineNumber, renderStartColumn));
+        return {
+            showAtPosition,
+            showAtSecondaryPosition,
+            highlightRange
+        };
+    }
+    showsOrWillShow(mouseEvent) {
+        if (this._widget.isResizing) {
+            return true;
+        }
+        const anchorCandidates = [];
+        for (const participant of this._participants) {
+            if (participant.suggestHoverAnchor) {
+                const anchor = participant.suggestHoverAnchor(mouseEvent);
+                if (anchor) {
+                    anchorCandidates.push(anchor);
+                }
+            }
+        }
+        const target = mouseEvent.target;
+        if (target.type === 6 ) {
+            anchorCandidates.push(( new HoverRangeAnchor(0, target.range, mouseEvent.event.posx, mouseEvent.event.posy)));
+        }
+        if (target.type === 7 ) {
+            const epsilon = this._editor.getOption(50 ).typicalHalfwidthCharacterWidth / 2;
+            if (!target.detail.isAfterLines
+                && typeof target.detail.horizontalDistanceToText === 'number'
+                && target.detail.horizontalDistanceToText < epsilon) {
+                anchorCandidates.push(( new HoverRangeAnchor(0, target.range, mouseEvent.event.posx, mouseEvent.event.posy)));
+            }
+        }
+        if (anchorCandidates.length === 0) {
+            return this._startShowingOrUpdateHover(null, 0 , 0 , false, mouseEvent);
+        }
+        anchorCandidates.sort((a, b) => b.priority - a.priority);
+        return this._startShowingOrUpdateHover(anchorCandidates[0], 0 , 0 , false, mouseEvent);
+    }
+    startShowingAtRange(range, mode, source, focus) {
+        this._startShowingOrUpdateHover(( new HoverRangeAnchor(0, range, undefined, undefined)), mode, source, focus, null);
+    }
+    async updateFocusedMarkdownHoverVerbosityLevel(action) {
+        this._markdownHoverParticipant?.updateFocusedMarkdownHoverPartVerbosityLevel(action);
+    }
+    getWidgetContent() {
+        const node = this._widget.getDomNode();
+        if (!node.textContent) {
+            return undefined;
+        }
+        return node.textContent;
+    }
+    containsNode(node) {
+        return (node ? this._widget.getDomNode().contains(node) : false);
+    }
+    focus() {
+        this._widget.focus();
+    }
+    scrollUp() {
+        this._widget.scrollUp();
+    }
+    scrollDown() {
+        this._widget.scrollDown();
+    }
+    scrollLeft() {
+        this._widget.scrollLeft();
+    }
+    scrollRight() {
+        this._widget.scrollRight();
+    }
+    pageUp() {
+        this._widget.pageUp();
+    }
+    pageDown() {
+        this._widget.pageDown();
+    }
+    goToTop() {
+        this._widget.goToTop();
+    }
+    goToBottom() {
+        this._widget.goToBottom();
+    }
+    hide() {
+        this._computer.anchor = null;
+        this._hoverOperation.cancel();
+        this._setCurrentResult(null);
+    }
+    get isColorPickerVisible() {
+        return this._widget.isColorPickerVisible;
+    }
+    get isVisibleFromKeyboard() {
+        return this._widget.isVisibleFromKeyboard;
+    }
+    get isVisible() {
+        return this._widget.isVisible;
+    }
+    get isFocused() {
+        return this._widget.isFocused;
+    }
+    get isResizing() {
+        return this._widget.isResizing;
+    }
+    get widget() {
+        return this._widget;
+    }
+};
+ContentHoverController = ContentHoverController_1 = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IKeybindingService))
+], ContentHoverController));
+export { ContentHoverController };

package/vscode/src/vs/editor/contrib/hover/browser/contentHoverStatusBar.js

@@ -0,0 +1,34 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { append, $ as $$1 } from '../../../../base/browser/dom.js';
+import { HoverAction } from '../../../../base/browser/ui/hover/hoverWidget.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.service.js';
+const $ = $$1;
+let EditorHoverStatusBar = class EditorHoverStatusBar extends Disposable {
+    get hasContent() {
+        return this._hasContent;
+    }
+    constructor(_keybindingService) {
+        super();
+        this._keybindingService = _keybindingService;
+        this._hasContent = false;
+        this.hoverElement = $('div.hover-row.status-bar');
+        this.hoverElement.tabIndex = 0;
+        this.actionsElement = append(this.hoverElement, $('div.actions'));
+    }
+    addAction(actionOptions) {
+        const keybinding = this._keybindingService.lookupKeybinding(actionOptions.commandId);
+        const keybindingLabel = keybinding ? keybinding.getLabel() : null;
+        this._hasContent = true;
+        return this._register(HoverAction.render(this.actionsElement, actionOptions, keybindingLabel));
+    }
+    append(element) {
+        const result = append(this.actionsElement, element);
+        this._hasContent = true;
+        return result;
+    }
+};
+EditorHoverStatusBar = ( __decorate([
+    ( __param(0, IKeybindingService))
+], EditorHoverStatusBar));
+export { EditorHoverStatusBar };

package/vscode/src/vs/editor/contrib/hover/browser/contentHoverTypes.js

@@ -0,0 +1,39 @@
+class HoverResult {
+    constructor(anchor, messages, isComplete) {
+        this.anchor = anchor;
+        this.messages = messages;
+        this.isComplete = isComplete;
+    }
+    filter(anchor) {
+        const filteredMessages = this.messages.filter((m) => m.isValidForHoverAnchor(anchor));
+        if (filteredMessages.length === this.messages.length) {
+            return this;
+        }
+        return ( new FilteredHoverResult(this, this.anchor, filteredMessages, this.isComplete));
+    }
+}
+class FilteredHoverResult extends HoverResult {
+    constructor(original, anchor, messages, isComplete) {
+        super(anchor, messages, isComplete);
+        this.original = original;
+    }
+    filter(anchor) {
+        return this.original.filter(anchor);
+    }
+}
+class ContentHoverVisibleData {
+    constructor(initialMousePosX, initialMousePosY, colorPicker, showAtPosition, showAtSecondaryPosition, preferAbove, stoleFocus, source, isBeforeContent, disposables) {
+        this.initialMousePosX = initialMousePosX;
+        this.initialMousePosY = initialMousePosY;
+        this.colorPicker = colorPicker;
+        this.showAtPosition = showAtPosition;
+        this.showAtSecondaryPosition = showAtSecondaryPosition;
+        this.preferAbove = preferAbove;
+        this.stoleFocus = stoleFocus;
+        this.source = source;
+        this.isBeforeContent = isBeforeContent;
+        this.disposables = disposables;
+        this.closestMouseDistance = undefined;
+    }
+}
+export { ContentHoverVisibleData, FilteredHoverResult, HoverResult };