@codingame/monaco-vscode-api 2.0.3-improve-modularity.1 → 2.1.0-update-vscode-1.86.1

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

@@ -17,18 +17,14 @@ import { MarkdownHoverParticipant } from './markdownHoverParticipant.js';
 import { MarkerHoverParticipant } from './markerHoverParticipant.js';
 import { InlineSuggestionHintsContentWidget } from '../../inlineCompletions/browser/inlineCompletionsHintsWidget.js';
 import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
+import { RunOnceScheduler } from '../../../../base/common/async.js';
 import { localizeWithPath } from '../../../../nls.js';
 import './hover.css.js';
-import { RunOnceScheduler } from '../../../../base/common/async.js';
-var ModesHoverController_1;
+var HoverController_1;
 const _sticky = false;
-let ModesHoverController = class ModesHoverController extends Disposable {
-    static { ModesHoverController_1 = this; }
+let HoverController = class HoverController extends Disposable {
+    static { HoverController_1 = this; }
     static { this.ID = 'editor.contrib.hover'; }
-    getWidgetContent() { return this._contentWidget?.getWidgetContent(); }
-    static get(editor) {
-        return editor.getContribution(ModesHoverController_1.ID);
-    }
     constructor(_editor, _instantiationService, _openerService, _languageService, _keybindingService) {
         super();
         this._editor = _editor;
@@ -36,105 +32,110 @@ let ModesHoverController = class ModesHoverController extends Disposable {
         this._openerService = _openerService;
         this._languageService = _languageService;
         this._keybindingService = _keybindingService;
-        this._toUnhook = ( new DisposableStore());
-        this._hoverActivatedByColorDecoratorClick = false;
-        this._isMouseDown = false;
-        this._hoverClicked = false;
-        this._contentWidget = null;
-        this._glyphWidget = null;
+        this._listenersStore = ( new DisposableStore());
+        this._hoverState = {
+            mouseDown: false,
+            contentHoverFocused: false,
+            activatedByDecoratorClick: false
+        };
         this._reactToEditorMouseMoveRunner = this._register(( new RunOnceScheduler(() => this._reactToEditorMouseMove(this._mouseMoveEvent), 0)));
-        this._hookEvents();
+        this._hookListeners();
         this._register(this._editor.onDidChangeConfiguration((e) => {
             if (e.hasChanged(60 )) {
-                this._unhookEvents();
-                this._hookEvents();
+                this._unhookListeners();
+                this._hookListeners();
             }
         }));
     }
-    _hookEvents() {
+    static get(editor) {
+        return editor.getContribution(HoverController_1.ID);
+    }
+    _hookListeners() {
         const hoverOpts = this._editor.getOption(60 );
-        this._isHoverEnabled = hoverOpts.enabled;
-        this._isHoverSticky = hoverOpts.sticky;
-        this._hidingDelay = hoverOpts.hidingDelay;
-        if (this._isHoverEnabled) {
-            this._toUnhook.add(this._editor.onMouseDown((e) => this._onEditorMouseDown(e)));
-            this._toUnhook.add(this._editor.onMouseUp((e) => this._onEditorMouseUp(e)));
-            this._toUnhook.add(this._editor.onMouseMove((e) => this._onEditorMouseMove(e)));
-            this._toUnhook.add(this._editor.onKeyDown((e) => this._onKeyDown(e)));
+        this._hoverSettings = {
+            enabled: hoverOpts.enabled,
+            sticky: hoverOpts.sticky,
+            hidingDelay: hoverOpts.delay
+        };
+        if (hoverOpts.enabled) {
+            this._listenersStore.add(this._editor.onMouseDown((e) => this._onEditorMouseDown(e)));
+            this._listenersStore.add(this._editor.onMouseUp(() => this._onEditorMouseUp()));
+            this._listenersStore.add(this._editor.onMouseMove((e) => this._onEditorMouseMove(e)));
+            this._listenersStore.add(this._editor.onKeyDown((e) => this._onKeyDown(e)));
         }
         else {
-            this._toUnhook.add(this._editor.onMouseMove((e) => this._onEditorMouseMove(e)));
-            this._toUnhook.add(this._editor.onKeyDown((e) => this._onKeyDown(e)));
+            this._listenersStore.add(this._editor.onMouseMove((e) => this._onEditorMouseMove(e)));
+            this._listenersStore.add(this._editor.onKeyDown((e) => this._onKeyDown(e)));
         }
-        this._toUnhook.add(this._editor.onMouseLeave((e) => this._onEditorMouseLeave(e)));
-        this._toUnhook.add(this._editor.onDidChangeModel(() => {
+        this._listenersStore.add(this._editor.onMouseLeave((e) => this._onEditorMouseLeave(e)));
+        this._listenersStore.add(this._editor.onDidChangeModel(() => {
             this._cancelScheduler();
             this._hideWidgets();
         }));
-        this._toUnhook.add(this._editor.onDidChangeModelContent(() => this._cancelScheduler()));
-        this._toUnhook.add(this._editor.onDidScrollChange((e) => this._onEditorScrollChanged(e)));
+        this._listenersStore.add(this._editor.onDidChangeModelContent(() => this._cancelScheduler()));
+        this._listenersStore.add(this._editor.onDidScrollChange((e) => this._onEditorScrollChanged(e)));
+    }
+    _unhookListeners() {
+        this._listenersStore.clear();
     }
     _cancelScheduler() {
         this._mouseMoveEvent = undefined;
         this._reactToEditorMouseMoveRunner.cancel();
     }
-    _unhookEvents() {
-        this._toUnhook.clear();
-    }
     _onEditorScrollChanged(e) {
         if (e.scrollTopChanged || e.scrollLeftChanged) {
             this._hideWidgets();
         }
     }
     _onEditorMouseDown(mouseEvent) {
-        this._isMouseDown = true;
+        this._hoverState.mouseDown = true;
         const target = mouseEvent.target;
         if (target.type === 9  && target.detail === ContentHoverWidget.ID) {
-            this._hoverClicked = true;
+            this._hoverState.contentHoverFocused = true;
             return;
         }
         if (target.type === 12  && target.detail === MarginHoverWidget.ID) {
             return;
         }
         if (target.type !== 12 ) {
-            this._hoverClicked = false;
+            this._hoverState.contentHoverFocused = false;
         }
-        if (!this._contentWidget?.widget.isResizing) {
-            this._hideWidgets();
+        if (this._contentWidget?.widget.isResizing) {
+            return;
         }
+        this._hideWidgets();
     }
-    _onEditorMouseUp(mouseEvent) {
-        this._isMouseDown = false;
+    _onEditorMouseUp() {
+        this._hoverState.mouseDown = false;
     }
     _onEditorMouseLeave(mouseEvent) {
         this._cancelScheduler();
-        const targetEm = (mouseEvent.event.browserEvent.relatedTarget);
-        if (this._contentWidget?.widget.isResizing || this._contentWidget?.containsNode(targetEm)) {
+        const targetElement = (mouseEvent.event.browserEvent.relatedTarget);
+        if (this._contentWidget?.widget.isResizing || this._contentWidget?.containsNode(targetElement)) {
             return;
         }
-        {
-            this._hideWidgets();
-        }
+        this._hideWidgets();
     }
     _isMouseOverWidget(mouseEvent) {
         const target = mouseEvent.target;
-        if (this._isHoverSticky
+        const sticky = this._hoverSettings.sticky;
+        if (sticky
             && target.type === 9
             && target.detail === ContentHoverWidget.ID) {
             return true;
         }
-        if (this._isHoverSticky
+        if (sticky
             && this._contentWidget?.containsNode(mouseEvent.event.browserEvent.view?.document.activeElement)
             && !mouseEvent.event.browserEvent.view?.getSelection()?.isCollapsed) {
             return true;
         }
-        if (!this._isHoverSticky
+        if (!sticky
             && target.type === 9
             && target.detail === ContentHoverWidget.ID
             && this._contentWidget?.isColorPickerVisible) {
             return true;
         }
-        if (this._isHoverSticky
+        if (sticky
             && target.type === 12
             && target.detail === MarginHoverWidget.ID) {
             return true;
@@ -146,10 +147,11 @@ let ModesHoverController = class ModesHoverController extends Disposable {
         if (this._contentWidget?.isFocused || this._contentWidget?.isResizing) {
             return;
         }
-        if (this._isMouseDown && this._hoverClicked) {
+        if (this._hoverState.mouseDown && this._hoverState.contentHoverFocused) {
             return;
         }
-        if (this._isHoverSticky && this._contentWidget?.isVisibleFromKeyboard) {
+        const sticky = this._hoverSettings.sticky;
+        if (sticky && this._contentWidget?.isVisibleFromKeyboard) {
             return;
         }
         const mouseIsOverWidget = this._isMouseOverWidget(mouseEvent);
@@ -157,9 +159,10 @@ let ModesHoverController = class ModesHoverController extends Disposable {
             this._reactToEditorMouseMoveRunner.cancel();
             return;
         }
-        if (this._contentWidget?.isVisible && this._isHoverSticky && this._hidingDelay > 0) {
+        const hidingDelay = this._hoverSettings.hidingDelay;
+        if (this._contentWidget?.isVisible && sticky && hidingDelay > 0) {
             if (!this._reactToEditorMouseMoveRunner.isScheduled()) {
-                this._reactToEditorMouseMoveRunner.schedule(this._hidingDelay);
+                this._reactToEditorMouseMoveRunner.schedule(hidingDelay);
             }
             return;
         }
@@ -172,24 +175,29 @@ let ModesHoverController = class ModesHoverController extends Disposable {
         const target = mouseEvent.target;
         const mouseOnDecorator = target.element?.classList.contains('colorpicker-color-decoration');
         const decoratorActivatedOn = this._editor.getOption(146 );
-        if ((mouseOnDecorator && ((decoratorActivatedOn === 'click' && !this._hoverActivatedByColorDecoratorClick) ||
-            (decoratorActivatedOn === 'hover' && !this._isHoverEnabled && !_sticky) ||
-            (decoratorActivatedOn === 'clickAndHover' && !this._isHoverEnabled && !this._hoverActivatedByColorDecoratorClick)))
-            || !mouseOnDecorator && !this._isHoverEnabled && !this._hoverActivatedByColorDecoratorClick) {
+        const enabled = this._hoverSettings.enabled;
+        const activatedByDecoratorClick = this._hoverState.activatedByDecoratorClick;
+        if ((mouseOnDecorator && ((decoratorActivatedOn === 'click' && !activatedByDecoratorClick) ||
+            (decoratorActivatedOn === 'hover' && !enabled && !_sticky) ||
+            (decoratorActivatedOn === 'clickAndHover' && !enabled && !activatedByDecoratorClick))) || (!mouseOnDecorator && !enabled && !activatedByDecoratorClick)) {
             this._hideWidgets();
             return;
         }
         const contentWidget = this._getOrCreateContentWidget();
-        if (contentWidget.maybeShowAt(mouseEvent)) {
+        if (contentWidget.showsOrWillShow(mouseEvent)) {
             this._glyphWidget?.hide();
             return;
         }
-        if (target.type === 2  && target.position) {
+        if (target.type === 2  && target.position && target.detail.glyphMarginLane) {
             this._contentWidget?.hide();
-            if (!this._glyphWidget) {
-                this._glyphWidget = ( new MarginHoverWidget(this._editor, this._languageService, this._openerService));
-            }
-            this._glyphWidget.startShowingAt(target.position.lineNumber);
+            const glyphWidget = this._getOrCreateGlyphWidget();
+            glyphWidget.startShowingAt(target.position.lineNumber, target.detail.glyphMarginLane);
+            return;
+        }
+        if (target.type === 3  && target.position) {
+            this._contentWidget?.hide();
+            const glyphWidget = this._getOrCreateGlyphWidget();
+            glyphWidget.startShowingAt(target.position.lineNumber, 'lineNo');
             return;
         }
         this._hideWidgets();
@@ -199,18 +207,28 @@ let ModesHoverController = class ModesHoverController extends Disposable {
             return;
         }
         const resolvedKeyboardEvent = this._keybindingService.softDispatch(e, this._editor.getDomNode());
-        const mightTriggerFocus = (resolvedKeyboardEvent.kind === 1  || (resolvedKeyboardEvent.kind === 2  && resolvedKeyboardEvent.commandId === 'editor.action.showHover' && this._contentWidget?.isVisible));
-        if (e.keyCode !== 5  && e.keyCode !== 6  && e.keyCode !== 57  && e.keyCode !== 4
-            && !mightTriggerFocus) {
-            this._hideWidgets();
+        const mightTriggerFocus = (resolvedKeyboardEvent.kind === 1  ||
+            (resolvedKeyboardEvent.kind === 2
+                && resolvedKeyboardEvent.commandId === 'editor.action.showHover'
+                && this._contentWidget?.isVisible));
+        if (e.keyCode === 5
+            || e.keyCode === 6
+            || e.keyCode === 57
+            || e.keyCode === 4
+            || mightTriggerFocus) {
+            return;
         }
+        this._hideWidgets();
     }
     _hideWidgets() {
-        if ((this._isMouseDown && this._hoverClicked && this._contentWidget?.isColorPickerVisible) || InlineSuggestionHintsContentWidget.dropDownVisible) {
+        if ((this._hoverState.mouseDown
+            && this._hoverState.contentHoverFocused
+            && this._contentWidget?.isColorPickerVisible)
+            || InlineSuggestionHintsContentWidget.dropDownVisible) {
             return;
         }
-        this._hoverActivatedByColorDecoratorClick = false;
-        this._hoverClicked = false;
+        this._hoverState.activatedByDecoratorClick = false;
+        this._hoverState.contentHoverFocused = false;
         this._glyphWidget?.hide();
         this._contentWidget?.hide();
     }
@@ -220,8 +238,17 @@ let ModesHoverController = class ModesHoverController extends Disposable {
         }
         return this._contentWidget;
     }
+    _getOrCreateGlyphWidget() {
+        if (!this._glyphWidget) {
+            this._glyphWidget = ( new MarginHoverWidget(this._editor, this._languageService, this._openerService));
+        }
+        return this._glyphWidget;
+    }
+    hideContentHover() {
+        this._hideWidgets();
+    }
     showContentHover(range, mode, source, focus, activatedByColorDecoratorClick = false) {
-        this._hoverActivatedByColorDecoratorClick = activatedByColorDecoratorClick;
+        this._hoverState.activatedByDecoratorClick = activatedByColorDecoratorClick;
         this._getOrCreateContentWidget().startShowingAtRange(range, mode, source, focus);
     }
     focus() {
@@ -251,6 +278,9 @@ let ModesHoverController = class ModesHoverController extends Disposable {
     goToBottom() {
         this._contentWidget?.goToBottom();
     }
+    getWidgetContent() {
+        return this._contentWidget?.getWidgetContent();
+    }
     get isColorPickerVisible() {
         return this._contentWidget?.isColorPickerVisible;
     }
@@ -259,18 +289,18 @@ let ModesHoverController = class ModesHoverController extends Disposable {
     }
     dispose() {
         super.dispose();
-        this._unhookEvents();
-        this._toUnhook.dispose();
+        this._unhookListeners();
+        this._listenersStore.dispose();
         this._glyphWidget?.dispose();
         this._contentWidget?.dispose();
     }
 };
-ModesHoverController = ModesHoverController_1 = ( __decorate([
+HoverController = HoverController_1 = ( __decorate([
     ( __param(1, IInstantiationService)),
     ( __param(2, IOpenerService)),
     ( __param(3, ILanguageService)),
     ( __param(4, IKeybindingService))
-], ModesHoverController));
+], HoverController));
 var HoverFocusBehavior;
 ( (function(HoverFocusBehavior) {
     HoverFocusBehavior["NoAutoFocus"] = "noAutoFocus";
@@ -335,13 +365,13 @@ class ShowOrFocusHoverAction extends EditorAction {
         if (!editor.hasModel()) {
             return;
         }
-        const controller = ModesHoverController.get(editor);
+        const controller = HoverController.get(editor);
         if (!controller) {
             return;
         }
         const focusArgument = args?.focus;
         let focusOption = HoverFocusBehavior.FocusIfVisible;
-        if (focusArgument in HoverFocusBehavior) {
+        if (( Object.values(HoverFocusBehavior)).includes(focusArgument)) {
             focusOption = focusArgument;
         }
         else if (typeof focusArgument === 'boolean' && focusArgument) {
@@ -382,7 +412,7 @@ class ShowDefinitionPreviewHoverAction extends EditorAction {
         });
     }
     run(accessor, editor) {
-        const controller = ModesHoverController.get(editor);
+        const controller = HoverController.get(editor);
         if (!controller) {
             return;
         }
@@ -421,7 +451,7 @@ class ScrollUpHoverAction extends EditorAction {
         });
     }
     run(accessor, editor) {
-        const controller = ModesHoverController.get(editor);
+        const controller = HoverController.get(editor);
         if (!controller) {
             return;
         }
@@ -448,7 +478,7 @@ class ScrollDownHoverAction extends EditorAction {
         });
     }
     run(accessor, editor) {
-        const controller = ModesHoverController.get(editor);
+        const controller = HoverController.get(editor);
         if (!controller) {
             return;
         }
@@ -475,7 +505,7 @@ class ScrollLeftHoverAction extends EditorAction {
         });
     }
     run(accessor, editor) {
-        const controller = ModesHoverController.get(editor);
+        const controller = HoverController.get(editor);
         if (!controller) {
             return;
         }
@@ -502,7 +532,7 @@ class ScrollRightHoverAction extends EditorAction {
         });
     }
     run(accessor, editor) {
-        const controller = ModesHoverController.get(editor);
+        const controller = HoverController.get(editor);
         if (!controller) {
             return;
         }
@@ -530,7 +560,7 @@ class PageUpHoverAction extends EditorAction {
         });
     }
     run(accessor, editor) {
-        const controller = ModesHoverController.get(editor);
+        const controller = HoverController.get(editor);
         if (!controller) {
             return;
         }
@@ -558,7 +588,7 @@ class PageDownHoverAction extends EditorAction {
         });
     }
     run(accessor, editor) {
-        const controller = ModesHoverController.get(editor);
+        const controller = HoverController.get(editor);
         if (!controller) {
             return;
         }
@@ -586,7 +616,7 @@ class GoToTopHoverAction extends EditorAction {
         });
     }
     run(accessor, editor) {
-        const controller = ModesHoverController.get(editor);
+        const controller = HoverController.get(editor);
         if (!controller) {
             return;
         }
@@ -614,14 +644,14 @@ class GoToBottomHoverAction extends EditorAction {
         });
     }
     run(accessor, editor) {
-        const controller = ModesHoverController.get(editor);
+        const controller = HoverController.get(editor);
         if (!controller) {
             return;
         }
         controller.goToBottom();
     }
 }
-registerEditorContribution(ModesHoverController.ID, ModesHoverController, 2 );
+registerEditorContribution(HoverController.ID, HoverController, 2 );
 registerEditorAction(ShowOrFocusHoverAction);
 registerEditorAction(ShowDefinitionPreviewHoverAction);
 registerEditorAction(ScrollUpHoverAction);
@@ -642,4 +672,4 @@ registerThemingParticipant((theme, collector) => {
         collector.addRule(`.monaco-editor .monaco-hover hr { border-bottom: 0px solid ${( hoverBorder.transparent(0.5))}; }`);
     }
 });
-export { ModesHoverController };
+export { HoverController };

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

@@ -2,9 +2,10 @@ import { append, $ as $$1 } from '../../../../base/browser/dom.js';
 import { asArray } from '../../../../base/common/arrays.js';
 import { isEmptyMarkdownString } from '../../../../base/common/htmlContent.js';
 import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
-import { MarkdownRenderer } from '../../markdownRenderer/browser/markdownRenderer.js';
+import { MarkdownRenderer } from '../../../browser/widget/markdownRenderer/browser/markdownRenderer.js';
 import { HoverOperation } from './hoverOperation.js';
 import { HoverWidget } from '../../../../base/browser/ui/hover/hoverWidget.js';
+import { GlyphMarginLane } from '../../../common/model.js';
 const $ = $$1;
 class MarginHoverWidget extends Disposable {
     static { this.ID = 'editor.contrib.modesGlyphHoverWidget'; }
@@ -53,13 +54,14 @@ class MarginHoverWidget extends Disposable {
             this._hoverOperation.start(0 );
         }
     }
-    startShowingAt(lineNumber) {
-        if (this._computer.lineNumber === lineNumber) {
+    startShowingAt(lineNumber, laneOrLine) {
+        if (this._computer.lineNumber === lineNumber && this._computer.lane === laneOrLine) {
             return;
         }
         this._hoverOperation.cancel();
         this.hide();
         this._computer.lineNumber = lineNumber;
+        this._computer.lane = laneOrLine;
         this._hoverOperation.start(0 );
     }
     hide() {
@@ -109,7 +111,8 @@ class MarginHoverWidget extends Disposable {
         const lineHeight = this._editor.getOption(66 );
         const nodeHeight = this._hover.containerDomNode.clientHeight;
         const top = topForLineNumber - editorScrollTop - ((nodeHeight - lineHeight) / 2);
-        this._hover.containerDomNode.style.left = `${editorLayout.glyphMarginLeft + editorLayout.glyphMarginWidth}px`;
+        const left = editorLayout.glyphMarginLeft + editorLayout.glyphMarginWidth + (this._computer.lane === 'lineNo' ? editorLayout.lineNumbersWidth : 0);
+        this._hover.containerDomNode.style.left = `${left}px`;
         this._hover.containerDomNode.style.top = `${Math.max(Math.round(top), 0)}px`;
     }
 }
@@ -120,9 +123,16 @@ class MarginHoverComputer {
     set lineNumber(value) {
         this._lineNumber = value;
     }
+    get lane() {
+        return this._laneOrLine;
+    }
+    set lane(value) {
+        this._laneOrLine = value;
+    }
     constructor(_editor) {
         this._editor = _editor;
         this._lineNumber = -1;
+        this._laneOrLine = GlyphMarginLane.Center;
     }
     computeSync() {
         const toHoverMessage = (contents) => {
@@ -132,14 +142,16 @@ class MarginHoverComputer {
         };
         const lineDecorations = this._editor.getLineDecorations(this._lineNumber);
         const result = [];
+        const isLineHover = this._laneOrLine === 'lineNo';
         if (!lineDecorations) {
             return result;
         }
         for (const d of lineDecorations) {
-            if (!d.options.glyphMarginClassName) {
+            const lane = d.options.glyphMargin?.position ?? GlyphMarginLane.Center;
+            if (!isLineHover && lane !== this._laneOrLine) {
                 continue;
             }
-            const hoverMessage = d.options.glyphMarginHoverMessage;
+            const hoverMessage = isLineHover ? d.options.lineNumberHoverMessage : d.options.glyphMarginHoverMessage;
             if (!hoverMessage || isEmptyMarkdownString(hoverMessage)) {
                 continue;
             }

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

@@ -4,7 +4,7 @@ import { asArray } from '../../../../base/common/arrays.js';
 import { AsyncIterableObject } from '../../../../base/common/async.js';
 import { MarkdownString, isEmptyMarkdownString } from '../../../../base/common/htmlContent.js';
 import { DisposableStore } from '../../../../base/common/lifecycle.js';
-import { MarkdownRenderer } from '../../markdownRenderer/browser/markdownRenderer.js';
+import { MarkdownRenderer } from '../../../browser/widget/markdownRenderer/browser/markdownRenderer.js';
 import { Position } from '../../../common/core/position.js';
 import { Range } from '../../../common/core/range.js';
 import { ILanguageService } from '../../../common/languages/language.js';

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

@@ -169,11 +169,11 @@ let MarkerHoverParticipant = class MarkerHoverParticipant {
                     this.recentMarkerCodeActionsInfo = undefined;
                 }
             }
-            const updatePlaceholderDisposable = this.recentMarkerCodeActionsInfo && !this.recentMarkerCodeActionsInfo.hasCodeActions ? Disposable.None : disposables.add(disposableTimeout(() => quickfixPlaceholderElement.textContent = ( localizeWithPath(
+            const updatePlaceholderDisposable = this.recentMarkerCodeActionsInfo && !this.recentMarkerCodeActionsInfo.hasCodeActions ? Disposable.None : disposableTimeout(() => quickfixPlaceholderElement.textContent = ( localizeWithPath(
                 'vs/editor/contrib/hover/browser/markerHoverParticipant',
                 'checkingForQuickFixes',
                 "Checking for quick fixes..."
-            )), 200));
+            )), 200, disposables);
             if (!quickfixPlaceholderElement.textContent) {
                 quickfixPlaceholderElement.textContent = String.fromCharCode(0xA0);
             }

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

@@ -45,6 +45,7 @@ class InlayHintItem {
             const newHint = await Promise.resolve(this.provider.resolveInlayHint(this.hint, token));
             this.hint.tooltip = newHint?.tooltip ?? this.hint.tooltip;
             this.hint.label = newHint?.label ?? this.hint.label;
+            this.hint.textEdits = newHint?.textEdits ?? this.hint.textEdits;
             this._isResolved = true;
         }
         catch (err) {
@@ -54,13 +55,14 @@ class InlayHintItem {
     }
 }
 class InlayHintsFragments {
+    static { this._emptyInlayHintList = ( Object.freeze({ dispose() { }, hints: [] })); }
     static async create(registry, model, ranges, token) {
         const data = [];
         const promises = ( registry.ordered(model).reverse().map(provider => ( ranges.map(async (range) => {
             try {
                 const result = await provider.provideInlayHints(model, range, token);
-                if (result?.hints.length) {
-                    data.push([result, provider]);
+                if (result?.hints.length || provider.onDidChangeInlayHints) {
+                    data.push([result ?? InlayHintsFragments._emptyInlayHintList, provider]);
                 }
             }
             catch (err) {