@codingame/monaco-vscode-api 6.0.2 → 7.0.0

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

@@ -1,27 +1,20 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { addStandardDisposableListener } from '../../../../base/browser/dom.js';
 import { KeyCode } from '../../../../base/common/keyCodes.js';
-import { Disposable, toDisposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
 import { MouseTargetType } from '../../../browser/editorBrowser.js';
 import { EditorOption } from '../../../common/config/editorOptions.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, HoverStartMode, HoverStartSource } 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';
+import { HoverResult } from './contentHoverTypes.js';
 import { Emitter } from '../../../../base/common/event.js';
-var ContentHoverController_1;
+import { RenderedContentHover } from './contentHoverRendered.js';
 let ContentHoverController = class ContentHoverController extends Disposable {
-    static { ContentHoverController_1 = this; }
     constructor(_editor, _instantiationService, _keybindingService) {
         super();
         this._editor = _editor;
@@ -30,18 +23,25 @@ let ContentHoverController = class ContentHoverController extends Disposable {
         this._currentResult = null;
         this._onContentsChanged = this._register(( new Emitter()));
         this.onContentsChanged = this._onContentsChanged.event;
-        this._widget = this._register(this._instantiationService.createInstance(ContentHoverWidget, this._editor));
-        this._participants = [];
+        this._contentHoverWidget = this._register(this._instantiationService.createInstance(ContentHoverWidget, this._editor));
+        this._participants = this._initializeHoverParticipants();
+        this._computer = ( new ContentHoverComputer(this._editor, this._participants));
+        this._hoverOperation = this._register(( new HoverOperation(this._editor, this._computer)));
+        this._registerListeners();
+    }
+    _initializeHoverParticipants() {
+        const 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);
+            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)));
+        participants.sort((p1, p2) => p1.hoverOrdinal - p2.hoverOrdinal);
+        this._register(this._contentHoverWidget.onDidResize(() => {
+            this._participants.forEach(participant => participant.handleResize?.());
+        }));
+        return participants;
+    }
+    _registerListeners() {
         this._register(this._hoverOperation.onResult((result) => {
             if (!this._computer.anchor) {
                 return;
@@ -49,19 +49,20 @@ let ContentHoverController = class ContentHoverController extends Disposable {
             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) => {
+        this._register(addStandardDisposableListener(this._contentHoverWidget.getDomNode(), 'keydown', (e) => {
             if (e.equals(KeyCode.Escape)) {
                 this.hide();
             }
         }));
         this._register(TokenizationRegistry.onDidChange(() => {
-            if (this._widget.position && this._currentResult) {
+            if (this._contentHoverWidget.position && this._currentResult) {
                 this._setCurrentResult(this._currentResult);
             }
         }));
     }
     _startShowingOrUpdateHover(anchor, mode, source, focus, mouseEvent) {
-        if (!this._widget.position || !this._currentResult) {
+        const contentHoverIsVisible = this._contentHoverWidget.position && this._currentResult;
+        if (!contentHoverIsVisible) {
             if (anchor) {
                 this._startHoverOperationIfNecessary(anchor, mode, source, focus, false);
                 return true;
@@ -69,10 +70,9 @@ let ContentHoverController = class ContentHoverController extends Disposable {
             return false;
         }
         const isHoverSticky = this._editor.getOption(EditorOption.hover).sticky;
-        const isGettingCloser = (isHoverSticky
-            && mouseEvent
-            && this._widget.isMouseGettingCloser(mouseEvent.event.posx, mouseEvent.event.posy));
-        if (isGettingCloser) {
+        const isMouseGettingCloser = mouseEvent && this._contentHoverWidget.isMouseGettingCloser(mouseEvent.event.posx, mouseEvent.event.posy);
+        const isHoverStickyAndIsMouseGettingCloser = isHoverSticky && isMouseGettingCloser;
+        if (isHoverStickyAndIsMouseGettingCloser) {
             if (anchor) {
                 this._startHoverOperationIfNecessary(anchor, mode, source, focus, true);
             }
@@ -82,10 +82,12 @@ let ContentHoverController = class ContentHoverController extends Disposable {
             this._setCurrentResult(null);
             return false;
         }
-        if (anchor && this._currentResult.anchor.equals(anchor)) {
+        const currentAnchorEqualsPreviousAnchor = this._currentResult.anchor.equals(anchor);
+        if (currentAnchorEqualsPreviousAnchor) {
             return true;
         }
-        if (!anchor.canAdoptVisibleHover(this._currentResult.anchor, this._widget.position)) {
+        const currentAnchorCompatibleWithPreviousAnchor = anchor.canAdoptVisibleHover(this._currentResult.anchor, this._contentHoverWidget.position);
+        if (!currentAnchorCompatibleWithPreviousAnchor) {
             this._setCurrentResult(null);
             this._startHoverOperationIfNecessary(anchor, mode, source, focus, false);
             return true;
@@ -95,7 +97,8 @@ let ContentHoverController = class ContentHoverController extends Disposable {
         return true;
     }
     _startHoverOperationIfNecessary(anchor, mode, source, focus, insistOnKeepingHoverVisible) {
-        if (this._computer.anchor && this._computer.anchor.equals(anchor)) {
+        const currentAnchorEqualToPreviousHover = this._computer.anchor && this._computer.anchor.equals(anchor);
+        if (currentAnchorEqualToPreviousHover) {
             return;
         }
         this._hoverOperation.cancel();
@@ -106,219 +109,192 @@ let ContentHoverController = class ContentHoverController extends Disposable {
         this._hoverOperation.start(mode);
     }
     _setCurrentResult(hoverResult) {
-        if (this._currentResult === hoverResult) {
+        let currentHoverResult = hoverResult;
+        const currentResultEqualToPreviousResult = this._currentResult === currentHoverResult;
+        if (currentResultEqualToPreviousResult) {
             return;
         }
-        if (hoverResult && hoverResult.messages.length === 0) {
-            hoverResult = null;
+        const currentHoverResultIsEmpty = currentHoverResult && currentHoverResult.hoverParts.length === 0;
+        if (currentHoverResultIsEmpty) {
+            currentHoverResult = null;
         }
-        this._currentResult = hoverResult;
+        this._currentResult = currentHoverResult;
         if (this._currentResult) {
-            this._renderMessages(this._currentResult.anchor, this._currentResult.messages);
+            this._showHover(this._currentResult);
         }
         else {
-            this._widget.hide();
+            this._hideHover();
         }
     }
     _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]);
-                    }
-                }
+        if (!this._computer.anchor) {
+            return result;
+        }
+        for (const participant of this._participants) {
+            if (!participant.createLoadingMessage) {
+                continue;
             }
+            const loadingMessage = participant.createLoadingMessage(this._computer.anchor);
+            if (!loadingMessage) {
+                continue;
+            }
+            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;
-            }
+        const previousHoverIsVisibleWithCompleteResult = this._contentHoverWidget.position && this._currentResult && this._currentResult.isComplete;
+        if (!previousHoverIsVisibleWithCompleteResult) {
+            this._setCurrentResult(hoverResult);
         }
-        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._doOnContentsChanged(),
-            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 isCurrentHoverResultComplete = hoverResult.isComplete;
+        if (!isCurrentHoverResultComplete) {
+            return;
         }
-        const isBeforeContent = ( messages.some(m => m.isBeforeContent));
-        if (statusBar.hasContent) {
-            fragment.appendChild(statusBar.hoverElement);
+        const currentHoverResultIsEmpty = hoverResult.hoverParts.length === 0;
+        const insistOnKeepingPreviousHoverVisible = this._computer.insistOnKeepingHoverVisible;
+        const shouldKeepPreviousHoverVisible = currentHoverResultIsEmpty && insistOnKeepingPreviousHoverVisible;
+        if (shouldKeepPreviousHoverVisible) {
+            return;
         }
-        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(EditorOption.hover).above,
-                this._computer.shouldFocus,
-                this._computer.source,
-                isBeforeContent,
-                disposables
-            )));
+        this._setCurrentResult(hoverResult);
+    }
+    _showHover(hoverResult) {
+        const context = this._getHoverContext();
+        this._renderedContentHover = ( new RenderedContentHover(
+            this._editor,
+            hoverResult,
+            this._participants,
+            this._computer,
+            context,
+            this._keybindingService
+        ));
+        if (this._renderedContentHover.domNodeHasChildren) {
+            this._contentHoverWidget.show(this._renderedContentHover);
         }
         else {
-            disposables.dispose();
+            this._renderedContentHover.dispose();
         }
     }
-    _doOnContentsChanged() {
-        this._onContentsChanged.fire();
-        this._widget.onContentsChanged();
-    }
-    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
+    _hideHover() {
+        this._contentHoverWidget.hide();
+    }
+    _getHoverContext() {
+        const hide = () => {
+            this.hide();
         };
+        const onContentsChanged = () => {
+            this._onContentsChanged.fire();
+            this._contentHoverWidget.onContentsChanged();
+        };
+        const setMinimumDimensions = (dimensions) => {
+            this._contentHoverWidget.setMinimumDimensions(dimensions);
+        };
+        return { hide, onContentsChanged, setMinimumDimensions };
     }
     showsOrWillShow(mouseEvent) {
-        if (this._widget.isResizing) {
+        const isContentWidgetResizing = this._contentHoverWidget.isResizing;
+        if (isContentWidgetResizing) {
             return true;
         }
+        const anchorCandidates = this._findHoverAnchorCandidates(mouseEvent);
+        const anchorCandidatesExist = anchorCandidates.length > 0;
+        if (!anchorCandidatesExist) {
+            return this._startShowingOrUpdateHover(null, HoverStartMode.Delayed, HoverStartSource.Mouse, false, mouseEvent);
+        }
+        const anchor = anchorCandidates[0];
+        return this._startShowingOrUpdateHover(anchor, HoverStartMode.Delayed, HoverStartSource.Mouse, false, mouseEvent);
+    }
+    _findHoverAnchorCandidates(mouseEvent) {
         const anchorCandidates = [];
         for (const participant of this._participants) {
-            if (participant.suggestHoverAnchor) {
-                const anchor = participant.suggestHoverAnchor(mouseEvent);
-                if (anchor) {
-                    anchorCandidates.push(anchor);
-                }
+            if (!participant.suggestHoverAnchor) {
+                continue;
+            }
+            const anchor = participant.suggestHoverAnchor(mouseEvent);
+            if (!anchor) {
+                continue;
             }
+            anchorCandidates.push(anchor);
         }
         const target = mouseEvent.target;
-        if (target.type === MouseTargetType.CONTENT_TEXT) {
-            anchorCandidates.push(( new HoverRangeAnchor(0, target.range, mouseEvent.event.posx, mouseEvent.event.posy)));
-        }
-        if (target.type === MouseTargetType.CONTENT_EMPTY) {
-            const epsilon = this._editor.getOption(EditorOption.fontInfo).typicalHalfwidthCharacterWidth / 2;
-            if (!target.detail.isAfterLines
-                && typeof target.detail.horizontalDistanceToText === 'number'
-                && target.detail.horizontalDistanceToText < epsilon) {
+        switch (target.type) {
+            case MouseTargetType.CONTENT_TEXT: {
                 anchorCandidates.push(( new HoverRangeAnchor(0, target.range, mouseEvent.event.posx, mouseEvent.event.posy)));
+                break;
+            }
+            case MouseTargetType.CONTENT_EMPTY: {
+                const epsilon = this._editor.getOption(EditorOption.fontInfo).typicalHalfwidthCharacterWidth / 2;
+                const mouseIsWithinLinesAndCloseToHover = !target.detail.isAfterLines
+                    && typeof target.detail.horizontalDistanceToText === 'number'
+                    && target.detail.horizontalDistanceToText < epsilon;
+                if (!mouseIsWithinLinesAndCloseToHover) {
+                    break;
+                }
+                anchorCandidates.push(( new HoverRangeAnchor(0, target.range, mouseEvent.event.posx, mouseEvent.event.posy)));
+                break;
             }
-        }
-        if (anchorCandidates.length === 0) {
-            return this._startShowingOrUpdateHover(null, HoverStartMode.Delayed, HoverStartSource.Mouse, false, mouseEvent);
         }
         anchorCandidates.sort((a, b) => b.priority - a.priority);
-        return this._startShowingOrUpdateHover(anchorCandidates[0], HoverStartMode.Delayed, HoverStartSource.Mouse, false, mouseEvent);
+        return anchorCandidates;
     }
     startShowingAtRange(range, mode, source, focus) {
         this._startShowingOrUpdateHover(( new HoverRangeAnchor(0, range, undefined, undefined)), mode, source, focus, null);
     }
-    async updateMarkdownHoverVerbosityLevel(action, index, focus) {
-        this._markdownHoverParticipant?.updateMarkdownHoverVerbosityLevel(action, index, focus);
-    }
-    focusedMarkdownHoverIndex() {
-        return this._markdownHoverParticipant?.focusedMarkdownHoverIndex() ?? -1;
-    }
-    markdownHoverContentAtIndex(index) {
-        return this._markdownHoverParticipant?.markdownHoverContentAtIndex(index) ?? '';
-    }
-    doesMarkdownHoverAtIndexSupportVerbosityAction(index, action) {
-        return this._markdownHoverParticipant?.doesMarkdownHoverAtIndexSupportVerbosityAction(index, action) ?? false;
-    }
     getWidgetContent() {
-        const node = this._widget.getDomNode();
+        const node = this._contentHoverWidget.getDomNode();
         if (!node.textContent) {
             return undefined;
         }
         return node.textContent;
     }
+    async updateHoverVerbosityLevel(action, index, focus) {
+        this._renderedContentHover?.updateHoverVerbosityLevel(action, index, focus);
+    }
+    doesHoverAtIndexSupportVerbosityAction(index, action) {
+        return this._renderedContentHover?.doesHoverAtIndexSupportVerbosityAction(index, action) ?? false;
+    }
+    getAccessibleWidgetContent() {
+        return this._renderedContentHover?.getAccessibleWidgetContent();
+    }
+    getAccessibleWidgetContentAtIndex(index) {
+        return this._renderedContentHover?.getAccessibleWidgetContentAtIndex(index);
+    }
+    focusedHoverPartIndex() {
+        return this._renderedContentHover?.focusedHoverPartIndex ?? -1;
+    }
     containsNode(node) {
-        return (node ? this._widget.getDomNode().contains(node) : false);
+        return (node ? this._contentHoverWidget.getDomNode().contains(node) : false);
     }
     focus() {
-        this._widget.focus();
+        this._contentHoverWidget.focus();
+    }
+    focusHoverPartWithIndex(index) {
+        this._renderedContentHover?.focusHoverPartWithIndex(index);
     }
     scrollUp() {
-        this._widget.scrollUp();
+        this._contentHoverWidget.scrollUp();
     }
     scrollDown() {
-        this._widget.scrollDown();
+        this._contentHoverWidget.scrollDown();
     }
     scrollLeft() {
-        this._widget.scrollLeft();
+        this._contentHoverWidget.scrollLeft();
     }
     scrollRight() {
-        this._widget.scrollRight();
+        this._contentHoverWidget.scrollRight();
     }
     pageUp() {
-        this._widget.pageUp();
+        this._contentHoverWidget.pageUp();
     }
     pageDown() {
-        this._widget.pageDown();
+        this._contentHoverWidget.pageDown();
     }
     goToTop() {
-        this._widget.goToTop();
+        this._contentHoverWidget.goToTop();
     }
     goToBottom() {
-        this._widget.goToBottom();
+        this._contentHoverWidget.goToBottom();
     }
     hide() {
         this._computer.anchor = null;
@@ -326,25 +302,25 @@ let ContentHoverController = class ContentHoverController extends Disposable {
         this._setCurrentResult(null);
     }
     get isColorPickerVisible() {
-        return this._widget.isColorPickerVisible;
+        return this._renderedContentHover?.isColorPickerVisible() ?? false;
     }
     get isVisibleFromKeyboard() {
-        return this._widget.isVisibleFromKeyboard;
+        return this._contentHoverWidget.isVisibleFromKeyboard;
     }
     get isVisible() {
-        return this._widget.isVisible;
+        return this._contentHoverWidget.isVisible;
     }
     get isFocused() {
-        return this._widget.isFocused;
+        return this._contentHoverWidget.isFocused;
     }
     get isResizing() {
-        return this._widget.isResizing;
+        return this._contentHoverWidget.isResizing;
     }
     get widget() {
-        return this._widget;
+        return this._contentHoverWidget;
     }
 };
-ContentHoverController = ContentHoverController_1 = ( __decorate([
+ContentHoverController = ( __decorate([
     ( __param(1, IInstantiationService)),
     ( __param(2, IKeybindingService))
 ], ContentHoverController));