@codingame/monaco-vscode-api 6.0.2 → 7.0.0

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

@@ -0,0 +1,321 @@
+import { RenderedHoverParts } from './hoverTypes.js';
+import { Disposable, toDisposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { EditorHoverStatusBar } from './contentHoverStatusBar.js';
+import { ModelDecorationOptions } from '../../../common/model/textModel.js';
+import { Position } from '../../../common/core/position.js';
+import { Range } from '../../../common/core/range.js';
+import { addDisposableListener, EventType } from '../../../../base/browser/dom.js';
+import { MarkdownHoverParticipant } from './markdownHoverParticipant.js';
+import { ColorHoverParticipant } from '../../colorPicker/browser/colorHoverParticipant.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { InlayHintsHover } from '../../inlayHints/browser/inlayHintsHover.js';
+import { BugIndicatingError } from '../../../../base/common/errors.js';
+const _moduleId = "vs/editor/contrib/hover/browser/contentHoverRendered";
+class RenderedContentHover extends Disposable {
+    constructor(editor, hoverResult, participants, computer, context, keybindingService) {
+        super();
+        const anchor = hoverResult.anchor;
+        const parts = hoverResult.hoverParts;
+        this._renderedHoverParts = this._register(( (new RenderedContentHoverParts(editor, participants, parts, keybindingService, context))));
+        const { showAtPosition, showAtSecondaryPosition } = RenderedContentHover.computeHoverPositions(editor, anchor.range, parts);
+        this.shouldAppearBeforeContent = ( (parts.some(m => m.isBeforeContent)));
+        this.showAtPosition = showAtPosition;
+        this.showAtSecondaryPosition = showAtSecondaryPosition;
+        this.initialMousePosX = anchor.initialMousePosX;
+        this.initialMousePosY = anchor.initialMousePosY;
+        this.shouldFocus = computer.shouldFocus;
+        this.source = computer.source;
+    }
+    get domNode() {
+        return this._renderedHoverParts.domNode;
+    }
+    get domNodeHasChildren() {
+        return this._renderedHoverParts.domNodeHasChildren;
+    }
+    get focusedHoverPartIndex() {
+        return this._renderedHoverParts.focusedHoverPartIndex;
+    }
+    focusHoverPartWithIndex(index) {
+        this._renderedHoverParts.focusHoverPartWithIndex(index);
+    }
+    getAccessibleWidgetContent() {
+        return this._renderedHoverParts.getAccessibleContent();
+    }
+    getAccessibleWidgetContentAtIndex(index) {
+        return this._renderedHoverParts.getAccessibleHoverContentAtIndex(index);
+    }
+    async updateHoverVerbosityLevel(action, index, focus) {
+        this._renderedHoverParts.updateHoverVerbosityLevel(action, index, focus);
+    }
+    doesHoverAtIndexSupportVerbosityAction(index, action) {
+        return this._renderedHoverParts.doesHoverAtIndexSupportVerbosityAction(index, action);
+    }
+    isColorPickerVisible() {
+        return this._renderedHoverParts.isColorPickerVisible();
+    }
+    static computeHoverPositions(editor, anchorRange, hoverParts) {
+        let startColumnBoundary = 1;
+        if (editor.hasModel()) {
+            const viewModel = editor._getViewModel();
+            const coordinatesConverter = viewModel.coordinatesConverter;
+            const anchorViewRange = coordinatesConverter.convertModelRangeToViewRange(anchorRange);
+            const anchorViewMinColumn = viewModel.getLineMinColumn(anchorViewRange.startLineNumber);
+            const anchorViewRangeStart = ( (new Position(anchorViewRange.startLineNumber, anchorViewMinColumn)));
+            startColumnBoundary = coordinatesConverter.convertViewPositionToModelPosition(anchorViewRangeStart).column;
+        }
+        const anchorStartLineNumber = anchorRange.startLineNumber;
+        let secondaryPositionColumn = anchorRange.startColumn;
+        let forceShowAtRange;
+        for (const hoverPart of hoverParts) {
+            const hoverPartRange = hoverPart.range;
+            const hoverPartRangeOnAnchorStartLine = hoverPartRange.startLineNumber === anchorStartLineNumber;
+            const hoverPartRangeOnAnchorEndLine = hoverPartRange.endLineNumber === anchorStartLineNumber;
+            const hoverPartRangeIsOnAnchorLine = hoverPartRangeOnAnchorStartLine && hoverPartRangeOnAnchorEndLine;
+            if (hoverPartRangeIsOnAnchorLine) {
+                const hoverPartStartColumn = hoverPartRange.startColumn;
+                const minSecondaryPositionColumn = Math.min(secondaryPositionColumn, hoverPartStartColumn);
+                secondaryPositionColumn = Math.max(minSecondaryPositionColumn, startColumnBoundary);
+            }
+            if (hoverPart.forceShowAtRange) {
+                forceShowAtRange = hoverPartRange;
+            }
+        }
+        let showAtPosition;
+        let showAtSecondaryPosition;
+        if (forceShowAtRange) {
+            const forceShowAtPosition = forceShowAtRange.getStartPosition();
+            showAtPosition = forceShowAtPosition;
+            showAtSecondaryPosition = forceShowAtPosition;
+        }
+        else {
+            showAtPosition = anchorRange.getStartPosition();
+            showAtSecondaryPosition = ( (new Position(anchorStartLineNumber, secondaryPositionColumn)));
+        }
+        return {
+            showAtPosition,
+            showAtSecondaryPosition,
+        };
+    }
+}
+class RenderedStatusBar {
+    constructor(fragment, _statusBar) {
+        this._statusBar = _statusBar;
+        fragment.appendChild(this._statusBar.hoverElement);
+    }
+    get hoverElement() {
+        return this._statusBar.hoverElement;
+    }
+    get actions() {
+        return this._statusBar.actions;
+    }
+    dispose() {
+        this._statusBar.dispose();
+    }
+}
+class RenderedContentHoverParts extends Disposable {
+    static { this._DECORATION_OPTIONS = ModelDecorationOptions.register({
+        description: 'content-hover-highlight',
+        className: 'hoverHighlight'
+    }); }
+    constructor(editor, participants, hoverParts, keybindingService, context) {
+        super();
+        this._renderedParts = [];
+        this._focusedHoverPartIndex = -1;
+        this._context = context;
+        this._fragment = document.createDocumentFragment();
+        this._register(this._renderParts(participants, hoverParts, context, keybindingService));
+        this._register(this._registerListenersOnRenderedParts());
+        this._register(this._createEditorDecorations(editor, hoverParts));
+        this._updateMarkdownAndColorParticipantInfo(participants);
+    }
+    _createEditorDecorations(editor, hoverParts) {
+        if (hoverParts.length === 0) {
+            return Disposable.None;
+        }
+        let highlightRange = hoverParts[0].range;
+        for (const hoverPart of hoverParts) {
+            const hoverPartRange = hoverPart.range;
+            highlightRange = Range.plusRange(highlightRange, hoverPartRange);
+        }
+        const highlightDecoration = editor.createDecorationsCollection();
+        highlightDecoration.set([{
+                range: highlightRange,
+                options: RenderedContentHoverParts._DECORATION_OPTIONS
+            }]);
+        return toDisposable(() => {
+            highlightDecoration.clear();
+        });
+    }
+    _renderParts(participants, hoverParts, hoverContext, keybindingService) {
+        const statusBar = ( (new EditorHoverStatusBar(keybindingService)));
+        const hoverRenderingContext = {
+            fragment: this._fragment,
+            statusBar,
+            ...hoverContext
+        };
+        const disposables = ( (new DisposableStore()));
+        for (const participant of participants) {
+            const renderedHoverParts = this._renderHoverPartsForParticipant(hoverParts, participant, hoverRenderingContext);
+            disposables.add(renderedHoverParts);
+            for (const renderedHoverPart of renderedHoverParts.renderedHoverParts) {
+                this._renderedParts.push({
+                    type: 'hoverPart',
+                    participant,
+                    hoverPart: renderedHoverPart.hoverPart,
+                    hoverElement: renderedHoverPart.hoverElement,
+                });
+            }
+        }
+        const renderedStatusBar = this._renderStatusBar(this._fragment, statusBar);
+        if (renderedStatusBar) {
+            disposables.add(renderedStatusBar);
+            this._renderedParts.push({
+                type: 'statusBar',
+                hoverElement: renderedStatusBar.hoverElement,
+                actions: renderedStatusBar.actions,
+            });
+        }
+        return toDisposable(() => { disposables.dispose(); });
+    }
+    _renderHoverPartsForParticipant(hoverParts, participant, hoverRenderingContext) {
+        const hoverPartsForParticipant = hoverParts.filter(hoverPart => hoverPart.owner === participant);
+        const hasHoverPartsForParticipant = hoverPartsForParticipant.length > 0;
+        if (!hasHoverPartsForParticipant) {
+            return (
+                 (new RenderedHoverParts([]))
+            );
+        }
+        return participant.renderHoverParts(hoverRenderingContext, hoverPartsForParticipant);
+    }
+    _renderStatusBar(fragment, statusBar) {
+        if (!statusBar.hasContent) {
+            return undefined;
+        }
+        return (
+             (new RenderedStatusBar(fragment, statusBar))
+        );
+    }
+    _registerListenersOnRenderedParts() {
+        const disposables = ( (new DisposableStore()));
+        this._renderedParts.forEach((renderedPart, index) => {
+            const element = renderedPart.hoverElement;
+            element.tabIndex = 0;
+            disposables.add(addDisposableListener(element, EventType.FOCUS_IN, (event) => {
+                event.stopPropagation();
+                this._focusedHoverPartIndex = index;
+            }));
+            disposables.add(addDisposableListener(element, EventType.FOCUS_OUT, (event) => {
+                event.stopPropagation();
+                this._focusedHoverPartIndex = -1;
+            }));
+        });
+        return disposables;
+    }
+    _updateMarkdownAndColorParticipantInfo(participants) {
+        const markdownHoverParticipant = participants.find(p => {
+            return (p instanceof MarkdownHoverParticipant) && !(p instanceof InlayHintsHover);
+        });
+        if (markdownHoverParticipant) {
+            this._markdownHoverParticipant = markdownHoverParticipant;
+        }
+        this._colorHoverParticipant = participants.find(p => p instanceof ColorHoverParticipant);
+    }
+    focusHoverPartWithIndex(index) {
+        if (index < 0 || index >= this._renderedParts.length) {
+            return;
+        }
+        this._renderedParts[index].hoverElement.focus();
+    }
+    getAccessibleContent() {
+        const content = [];
+        for (let i = 0; i < this._renderedParts.length; i++) {
+            content.push(this.getAccessibleHoverContentAtIndex(i));
+        }
+        return content.join('\n\n');
+    }
+    getAccessibleHoverContentAtIndex(index) {
+        const renderedPart = this._renderedParts[index];
+        if (!renderedPart) {
+            return '';
+        }
+        if (renderedPart.type === 'statusBar') {
+            const statusBarDescription = [( localizeWithPath(_moduleId, 0, "This is a hover status bar."))];
+            for (const action of renderedPart.actions) {
+                const keybinding = action.actionKeybindingLabel;
+                if (keybinding) {
+                    statusBarDescription.push(( localizeWithPath(
+                        _moduleId,
+                        1,
+                        "It has an action with label {0} and keybinding {1}.",
+                        action.actionLabel,
+                        keybinding
+                    )));
+                }
+                else {
+                    statusBarDescription.push(( localizeWithPath(_moduleId, 2, "It has an action with label {0}.", action.actionLabel)));
+                }
+            }
+            return statusBarDescription.join('\n');
+        }
+        return renderedPart.participant.getAccessibleContent(renderedPart.hoverPart);
+    }
+    async updateHoverVerbosityLevel(action, index, focus) {
+        if (!this._markdownHoverParticipant) {
+            return;
+        }
+        const normalizedMarkdownHoverIndex = this._normalizedIndexToMarkdownHoverIndexRange(this._markdownHoverParticipant, index);
+        if (normalizedMarkdownHoverIndex === undefined) {
+            return;
+        }
+        const renderedPart = await this._markdownHoverParticipant.updateMarkdownHoverVerbosityLevel(action, normalizedMarkdownHoverIndex, focus);
+        if (!renderedPart) {
+            return;
+        }
+        this._renderedParts[index] = {
+            type: 'hoverPart',
+            participant: this._markdownHoverParticipant,
+            hoverPart: renderedPart.hoverPart,
+            hoverElement: renderedPart.hoverElement,
+        };
+        this._context.onContentsChanged();
+    }
+    doesHoverAtIndexSupportVerbosityAction(index, action) {
+        if (!this._markdownHoverParticipant) {
+            return false;
+        }
+        const normalizedMarkdownHoverIndex = this._normalizedIndexToMarkdownHoverIndexRange(this._markdownHoverParticipant, index);
+        if (normalizedMarkdownHoverIndex === undefined) {
+            return false;
+        }
+        return this._markdownHoverParticipant.doesMarkdownHoverAtIndexSupportVerbosityAction(normalizedMarkdownHoverIndex, action);
+    }
+    isColorPickerVisible() {
+        return this._colorHoverParticipant?.isColorPickerVisible() ?? false;
+    }
+    _normalizedIndexToMarkdownHoverIndexRange(markdownHoverParticipant, index) {
+        const renderedPart = this._renderedParts[index];
+        if (!renderedPart || renderedPart.type !== 'hoverPart') {
+            return undefined;
+        }
+        const isHoverPartMarkdownHover = renderedPart.participant === markdownHoverParticipant;
+        if (!isHoverPartMarkdownHover) {
+            return undefined;
+        }
+        const firstIndexOfMarkdownHovers = this._renderedParts.findIndex(renderedPart => renderedPart.type === 'hoverPart'
+            && renderedPart.participant === markdownHoverParticipant);
+        if (firstIndexOfMarkdownHovers === -1) {
+            throw ( (new BugIndicatingError()));
+        }
+        return index - firstIndexOfMarkdownHovers;
+    }
+    get domNode() {
+        return this._fragment;
+    }
+    get domNodeHasChildren() {
+        return this._fragment.hasChildNodes();
+    }
+    get focusedHoverPartIndex() {
+        return this._focusedHoverPartIndex;
+    }
+}
+export { RenderedContentHover };

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

@@ -11,6 +11,7 @@ let EditorHoverStatusBar = class EditorHoverStatusBar extends Disposable {
     constructor(_keybindingService) {
         super();
         this._keybindingService = _keybindingService;
+        this.actions = [];
         this._hasContent = false;
         this.hoverElement = $('div.hover-row.status-bar');
         this.hoverElement.tabIndex = 0;
@@ -20,7 +21,9 @@ let EditorHoverStatusBar = class EditorHoverStatusBar extends Disposable {
         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));
+        const action = this._register(HoverAction.render(this.actionsElement, actionOptions, keybindingLabel));
+        this.actions.push(action);
+        return action;
     }
     append(element) {
         const result = append(this.actionsElement, element);

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

@@ -1,15 +1,15 @@
 class HoverResult {
-    constructor(anchor, messages, isComplete) {
+    constructor(anchor, hoverParts, isComplete) {
         this.anchor = anchor;
-        this.messages = messages;
+        this.hoverParts = hoverParts;
         this.isComplete = isComplete;
     }
     filter(anchor) {
-        const filteredMessages = this.messages.filter((m) => m.isValidForHoverAnchor(anchor));
-        if (filteredMessages.length === this.messages.length) {
+        const filteredHoverParts = this.hoverParts.filter((m) => m.isValidForHoverAnchor(anchor));
+        if (filteredHoverParts.length === this.hoverParts.length) {
             return this;
         }
-        return ( new FilteredHoverResult(this, this.anchor, filteredMessages, this.isComplete));
+        return ( new FilteredHoverResult(this, this.anchor, filteredHoverParts, this.isComplete));
     }
 }
 class FilteredHoverResult extends HoverResult {
@@ -21,19 +21,4 @@ class FilteredHoverResult extends HoverResult {
         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 };
+export { FilteredHoverResult, HoverResult };

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

@@ -11,6 +11,7 @@ import { IAccessibilityService } from '../../../../platform/accessibility/common
 import { EditorContextKeys } from '../../../common/editorContextKeys.js';
 import { HoverWidget, getHoverAccessibleViewHint } from '../../../../base/browser/ui/hover/hoverWidget.js';
 import { PositionAffinity } from '../../../common/model.js';
+import { Emitter } from '../../../../base/common/event.js';
 var ContentHoverWidget_1;
 const HORIZONTAL_SCROLLING_BY = 30;
 const CONTAINER_HEIGHT_PADDING = 6;
@@ -18,11 +19,8 @@ let ContentHoverWidget = class ContentHoverWidget extends ResizableContentWidget
     static { ContentHoverWidget_1 = this; }
     static { this.ID = 'editor.contrib.resizableContentHoverWidget'; }
     static { this._lastDimensions = new Dimension(0, 0); }
-    get isColorPickerVisible() {
-        return Boolean(this._visibleData?.colorPicker);
-    }
     get isVisibleFromKeyboard() {
-        return (this._visibleData?.source === HoverStartSource.Keyboard);
+        return (this._renderedHover?.source === HoverStartSource.Keyboard);
     }
     get isVisible() {
         return this._hoverVisibleKey.get() ?? false;
@@ -39,6 +37,8 @@ let ContentHoverWidget = class ContentHoverWidget extends ResizableContentWidget
         this._accessibilityService = _accessibilityService;
         this._keybindingService = _keybindingService;
         this._hover = this._register(( new HoverWidget()));
+        this._onDidResize = this._register(( new Emitter()));
+        this.onDidResize = this._onDidResize.event;
         this._minimumSize = minimumSize;
         this._hoverVisibleKey = EditorContextKeys.hoverVisible.bindTo(contextKeyService);
         this._hoverFocusedKey = EditorContextKeys.hoverFocused.bindTo(contextKeyService);
@@ -61,12 +61,12 @@ let ContentHoverWidget = class ContentHoverWidget extends ResizableContentWidget
         this._register(focusTracker.onDidBlur(() => {
             this._hoverFocusedKey.set(false);
         }));
-        this._setHoverData(undefined);
+        this._setRenderedHover(undefined);
         this._editor.addContentWidget(this);
     }
     dispose() {
         super.dispose();
-        this._visibleData?.disposables.dispose();
+        this._renderedHover?.dispose();
         this._editor.removeContentWidget(this);
     }
     getId() {
@@ -122,10 +122,10 @@ let ContentHoverWidget = class ContentHoverWidget extends ResizableContentWidget
         this._updateResizableNodeMaxDimensions();
         this._hover.scrollbar.scanDomNode();
         this._editor.layoutContentWidget(this);
-        this._visibleData?.colorPicker?.layout();
+        this._onDidResize.fire();
     }
     _findAvailableSpaceVertically() {
-        const position = this._visibleData?.showAtPosition;
+        const position = this._renderedHover?.showAtPosition;
         if (!position) {
             return;
         }
@@ -171,31 +171,30 @@ let ContentHoverWidget = class ContentHoverWidget extends ResizableContentWidget
         }
     }
     isMouseGettingCloser(posx, posy) {
-        if (!this._visibleData) {
+        if (!this._renderedHover) {
             return false;
         }
-        if (typeof this._visibleData.initialMousePosX === 'undefined'
-            || typeof this._visibleData.initialMousePosY === 'undefined') {
-            this._visibleData.initialMousePosX = posx;
-            this._visibleData.initialMousePosY = posy;
+        if (this._renderedHover.initialMousePosX === undefined || this._renderedHover.initialMousePosY === undefined) {
+            this._renderedHover.initialMousePosX = posx;
+            this._renderedHover.initialMousePosY = posy;
             return false;
         }
         const widgetRect = getDomNodePagePosition(this.getDomNode());
-        if (typeof this._visibleData.closestMouseDistance === 'undefined') {
-            this._visibleData.closestMouseDistance = computeDistanceFromPointToRectangle(this._visibleData.initialMousePosX, this._visibleData.initialMousePosY, widgetRect.left, widgetRect.top, widgetRect.width, widgetRect.height);
+        if (this._renderedHover.closestMouseDistance === undefined) {
+            this._renderedHover.closestMouseDistance = computeDistanceFromPointToRectangle(this._renderedHover.initialMousePosX, this._renderedHover.initialMousePosY, widgetRect.left, widgetRect.top, widgetRect.width, widgetRect.height);
         }
         const distance = computeDistanceFromPointToRectangle(posx, posy, widgetRect.left, widgetRect.top, widgetRect.width, widgetRect.height);
-        if (distance > this._visibleData.closestMouseDistance + 4 ) {
+        if (distance > this._renderedHover.closestMouseDistance + 4 ) {
             return false;
         }
-        this._visibleData.closestMouseDistance = Math.min(this._visibleData.closestMouseDistance, distance);
+        this._renderedHover.closestMouseDistance = Math.min(this._renderedHover.closestMouseDistance, distance);
         return true;
     }
-    _setHoverData(hoverData) {
-        this._visibleData?.disposables.dispose();
-        this._visibleData = hoverData;
-        this._hoverVisibleKey.set(!!hoverData);
-        this._hover.containerDomNode.classList.toggle('hidden', !hoverData);
+    _setRenderedHover(renderedHover) {
+        this._renderedHover?.dispose();
+        this._renderedHover = renderedHover;
+        this._hoverVisibleKey.set(!!renderedHover);
+        this._hover.containerDomNode.classList.toggle('hidden', !renderedHover);
     }
     _updateFont() {
         const { fontSize, lineHeight } = this._editor.getOption(EditorOption.fontInfo);
@@ -220,38 +219,38 @@ let ContentHoverWidget = class ContentHoverWidget extends ResizableContentWidget
         const width = Math.max(this._editor.getLayoutInfo().width * 0.66, 500, ContentHoverWidget_1._lastDimensions.width);
         this._setHoverWidgetMaxDimensions(width, height);
     }
-    _render(node, hoverData) {
-        this._setHoverData(hoverData);
+    _render(renderedHover) {
+        this._setRenderedHover(renderedHover);
         this._updateFont();
-        this._updateContent(node);
+        this._updateContent(renderedHover.domNode);
         this._updateMaxDimensions();
         this.onContentsChanged();
         this._editor.render();
     }
     getPosition() {
-        if (!this._visibleData) {
+        if (!this._renderedHover) {
             return null;
         }
         return {
-            position: this._visibleData.showAtPosition,
-            secondaryPosition: this._visibleData.showAtSecondaryPosition,
-            positionAffinity: this._visibleData.isBeforeContent ? PositionAffinity.LeftOfInjectedText : undefined,
+            position: this._renderedHover.showAtPosition,
+            secondaryPosition: this._renderedHover.showAtSecondaryPosition,
+            positionAffinity: this._renderedHover.shouldAppearBeforeContent ? PositionAffinity.LeftOfInjectedText : undefined,
             preference: [this._positionPreference ?? ContentWidgetPositionPreference.ABOVE]
         };
     }
-    showAt(node, hoverData) {
+    show(renderedHover) {
         if (!this._editor || !this._editor.hasModel()) {
             return;
         }
-        this._render(node, hoverData);
+        this._render(renderedHover);
         const widgetHeight = getTotalHeight(this._hover.containerDomNode);
-        const widgetPosition = hoverData.showAtPosition;
+        const widgetPosition = renderedHover.showAtPosition;
         this._positionPreference = this._findPositionPreference(widgetHeight, widgetPosition) ?? ContentWidgetPositionPreference.ABOVE;
         this.onContentsChanged();
-        if (hoverData.stoleFocus) {
+        if (renderedHover.shouldFocus) {
             this._hover.containerDomNode.focus();
         }
-        hoverData.colorPicker?.layout();
+        this._onDidResize.fire();
         const hoverFocused = this._hover.containerDomNode.ownerDocument.activeElement === this._hover.containerDomNode;
         const accessibleViewHint = hoverFocused && getHoverAccessibleViewHint(this._configurationService.getValue('accessibility.verbosity.hover') === true && this._accessibilityService.isScreenReaderOptimized(), this._keybindingService.lookupKeybinding('editor.action.accessibleView')?.getAriaLabel() ?? '');
         if (accessibleViewHint) {
@@ -259,16 +258,16 @@ let ContentHoverWidget = class ContentHoverWidget extends ResizableContentWidget
         }
     }
     hide() {
-        if (!this._visibleData) {
+        if (!this._renderedHover) {
             return;
         }
-        const stoleFocus = this._visibleData.stoleFocus || this._hoverFocusedKey.get();
-        this._setHoverData(undefined);
+        const hoverStoleFocus = this._renderedHover.shouldFocus || this._hoverFocusedKey.get();
+        this._setRenderedHover(undefined);
         this._resizableNode.maxSize = new Dimension(Infinity, Infinity);
         this._resizableNode.clearSashHoverState();
         this._hoverFocusedKey.set(false);
         this._editor.layoutContentWidget(this);
-        if (stoleFocus) {
+        if (hoverStoleFocus) {
             this._editor.focus();
         }
     }
@@ -299,9 +298,9 @@ let ContentHoverWidget = class ContentHoverWidget extends ResizableContentWidget
         this._contentWidth = width;
         this._updateMinimumWidth();
         this._resizableNode.layout(height, width);
-        if (this._visibleData?.showAtPosition) {
+        if (this._renderedHover?.showAtPosition) {
             const widgetHeight = getTotalHeight(this._hover.containerDomNode);
-            this._positionPreference = this._findPositionPreference(widgetHeight, this._visibleData.showAtPosition);
+            this._positionPreference = this._findPositionPreference(widgetHeight, this._renderedHover.showAtPosition);
         }
         this._layoutContentWidget();
     }