@codingame/monaco-vscode-api 4.5.2 → 5.0.0

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

@@ -1,27 +1,40 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { append, $ as $$1 } from '../../../../base/browser/dom.js';
-import { asArray } from '../../../../base/common/arrays.js';
-import { AsyncIterableObject } from '../../../../base/common/async.js';
+import { trackFocus, append, $ as $$1 } from '../../../../base/browser/dom.js';
+import { asArray, compareBy, numberComparator } from '../../../../base/common/arrays.js';
+import { CancellationToken } from '../../../../base/common/cancellation.js';
 import { MarkdownString, isEmptyMarkdownString } from '../../../../base/common/htmlContent.js';
-import { DisposableStore } from '../../../../base/common/lifecycle.js';
+import { Disposable, toDisposable, DisposableStore } from '../../../../base/common/lifecycle.js';
 import { MarkdownRenderer } from '../../../browser/widget/markdownRenderer/browser/markdownRenderer.js';
-import { Position } from '../../../common/core/position.js';
+import { INCREASE_HOVER_VERBOSITY_ACTION_ID, DECREASE_HOVER_VERBOSITY_ACTION_ID } from './hoverActionIds.js';
 import { Range } from '../../../common/core/range.js';
 import { ILanguageService } from '../../../common/languages/language.js';
-import { getHover } from './getHover.js';
 import { localizeWithPath } from '../../../../nls.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
 import { IOpenerService } from '../../../../platform/opener/common/opener.service.js';
 import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';
+import { HoverVerbosityAction } from '../../../common/languages.js';
+import { registerIcon } from '../../../../platform/theme/common/iconRegistry.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { ThemeIcon } from '../../../../base/common/themables.js';
+import { onUnexpectedExternalError } from '../../../../base/common/errors.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.service.js';
+import { ClickAction, KeyDownAction } from '../../../../base/browser/ui/hover/hoverWidget.js';
+import { WorkbenchHoverDelegate } from '../../../../platform/hover/browser/hover.js';
+import { IHoverService } from '../../../../platform/hover/browser/hover.service.js';
+import { AsyncIterableObject } from '../../../../base/common/async.js';
+import { getHoverProviderResultsAsAsyncIterable } from './getHover.js';
 const _moduleId = "vs/editor/contrib/hover/browser/markdownHoverParticipant";
 const $ = $$1;
+const increaseHoverVerbosityIcon = registerIcon('hover-increase-verbosity', Codicon.add, ( localizeWithPath(_moduleId, 0, 'Icon for increaseing hover verbosity.')));
+const decreaseHoverVerbosityIcon = registerIcon('hover-decrease-verbosity', Codicon.remove, ( localizeWithPath(_moduleId, 1, 'Icon for decreasing hover verbosity.')));
 class MarkdownHover {
-    constructor(owner, range, contents, isBeforeContent, ordinal) {
+    constructor(owner, range, contents, isBeforeContent, ordinal, source = undefined) {
         this.owner = owner;
         this.range = range;
         this.contents = contents;
         this.isBeforeContent = isBeforeContent;
         this.ordinal = ordinal;
+        this.source = source;
     }
     isValidForHoverAnchor(anchor) {
         return (anchor.type === 1
@@ -29,13 +42,30 @@ class MarkdownHover {
             && this.range.endColumn >= anchor.range.endColumn);
     }
 }
+class HoverSource {
+    constructor(hover, hoverProvider, hoverPosition) {
+        this.hover = hover;
+        this.hoverProvider = hoverProvider;
+        this.hoverPosition = hoverPosition;
+    }
+    supportsVerbosityAction(hoverVerbosityAction) {
+        switch (hoverVerbosityAction) {
+            case HoverVerbosityAction.Increase:
+                return this.hover.canIncreaseVerbosity ?? false;
+            case HoverVerbosityAction.Decrease:
+                return this.hover.canDecreaseVerbosity ?? false;
+        }
+    }
+}
 let MarkdownHoverParticipant = class MarkdownHoverParticipant {
-    constructor(_editor, _languageService, _openerService, _configurationService, _languageFeaturesService) {
+    constructor(_editor, _languageService, _openerService, _configurationService, _languageFeaturesService, _keybindingService, _hoverService) {
         this._editor = _editor;
         this._languageService = _languageService;
         this._openerService = _openerService;
         this._configurationService = _configurationService;
         this._languageFeaturesService = _languageFeaturesService;
+        this._keybindingService = _keybindingService;
+        this._hoverService = _hoverService;
         this.hoverOrdinal = 3;
     }
     createLoadingMessage(anchor) {
@@ -43,7 +73,7 @@ let MarkdownHoverParticipant = class MarkdownHoverParticipant {
              (new MarkdownHover(
                 this,
                 anchor.range,
-                [( (new MarkdownString())).appendText(( localizeWithPath(_moduleId, 0, "Loading...")))],
+                [( (new MarkdownString())).appendText(( localizeWithPath(_moduleId, 2, "Loading...")))],
                 false,
                 2000
             ))
@@ -70,7 +100,7 @@ let MarkdownHoverParticipant = class MarkdownHoverParticipant {
             result.push(( (new MarkdownHover(this, anchor.range, [{
                     value: ( localizeWithPath(
                         _moduleId,
-                        1,
+                        3,
                         "Rendering paused for long line for performance reasons. This can be configured via `editor.stopRenderingLineAfter`."
                     ))
                 }], false, index++))));
@@ -79,7 +109,7 @@ let MarkdownHoverParticipant = class MarkdownHoverParticipant {
             result.push(( (new MarkdownHover(this, anchor.range, [{
                     value: ( localizeWithPath(
                         _moduleId,
-                        2,
+                        4,
                         "Tokenization is skipped for long lines for performance reasons. This can be configured via `editor.maxTokenizationLineLength`."
                     ))
                 }], false, index++))));
@@ -110,51 +140,230 @@ let MarkdownHoverParticipant = class MarkdownHoverParticipant {
             return AsyncIterableObject.EMPTY;
         }
         const model = this._editor.getModel();
-        if (!( (this._languageFeaturesService.hoverProvider.has(model)))) {
+        const hoverProviderRegistry = this._languageFeaturesService.hoverProvider;
+        if (!( (hoverProviderRegistry.has(model)))) {
             return AsyncIterableObject.EMPTY;
         }
-        const position = ( (new Position(anchor.range.startLineNumber, anchor.range.startColumn)));
-        return (
-             (getHover(this._languageFeaturesService.hoverProvider, model, position, token)
-                .filter(item => !isEmptyMarkdownString(item.hover.contents))
-                .map(item => {
-                const rng = item.hover.range ? Range.lift(item.hover.range) : anchor.range;
-                return (
-                     (new MarkdownHover(this, rng, item.hover.contents, false, item.ordinal))
-                );
-            }))
-        );
+        const markdownHovers = this._getMarkdownHovers(hoverProviderRegistry, model, anchor, token);
+        return markdownHovers;
+    }
+    _getMarkdownHovers(hoverProviderRegistry, model, anchor, token) {
+        const position = anchor.range.getStartPosition();
+        const hoverProviderResults = getHoverProviderResultsAsAsyncIterable(hoverProviderRegistry, model, position, token);
+        const markdownHovers = ( (hoverProviderResults.filter(item => !isEmptyMarkdownString(item.hover.contents))
+            .map(item => {
+            const range = item.hover.range ? Range.lift(item.hover.range) : anchor.range;
+            const hoverSource = ( (new HoverSource(item.hover, item.provider, position)));
+            return (
+                 (new MarkdownHover(this, range, item.hover.contents, false, item.ordinal, hoverSource))
+            );
+        })));
+        return markdownHovers;
     }
     renderHoverParts(context, hoverParts) {
-        return renderMarkdownHovers(context, hoverParts, this._editor, this._languageService, this._openerService);
+        this._renderedHoverParts = ( (new MarkdownRenderedHoverParts(
+            hoverParts,
+            context.fragment,
+            this._editor,
+            this._languageService,
+            this._openerService,
+            this._keybindingService,
+            this._hoverService,
+            this._configurationService,
+            context.onContentsChanged
+        )));
+        return this._renderedHoverParts;
+    }
+    updateFocusedMarkdownHoverPartVerbosityLevel(action) {
+        this._renderedHoverParts?.updateFocusedHoverPartVerbosityLevel(action);
     }
 };
 MarkdownHoverParticipant = ( (__decorate([
     ( (__param(1, ILanguageService))),
     ( (__param(2, IOpenerService))),
     ( (__param(3, IConfigurationService))),
-    ( (__param(4, ILanguageFeaturesService)))
+    ( (__param(4, ILanguageFeaturesService))),
+    ( (__param(5, IKeybindingService))),
+    ( (__param(6, IHoverService)))
 ], MarkdownHoverParticipant)));
+class MarkdownRenderedHoverParts extends Disposable {
+    constructor(hoverParts,
+    hoverPartsContainer, _editor, _languageService, _openerService, _keybindingService, _hoverService, _configurationService, _onFinishedRendering) {
+        super();
+        this._editor = _editor;
+        this._languageService = _languageService;
+        this._openerService = _openerService;
+        this._keybindingService = _keybindingService;
+        this._hoverService = _hoverService;
+        this._configurationService = _configurationService;
+        this._onFinishedRendering = _onFinishedRendering;
+        this._hoverFocusInfo = { hoverPartIndex: -1, focusRemains: false };
+        this._renderedHoverParts = this._renderHoverParts(hoverParts, hoverPartsContainer, this._onFinishedRendering);
+        this._register(toDisposable(() => {
+            this._renderedHoverParts.forEach(renderedHoverPart => {
+                renderedHoverPart.disposables.dispose();
+            });
+        }));
+    }
+    _renderHoverParts(hoverParts, hoverPartsContainer, onFinishedRendering) {
+        hoverParts.sort(compareBy(hover => hover.ordinal, numberComparator));
+        return (
+             (hoverParts.map((hoverPart, hoverIndex) => {
+                const renderedHoverPart = this._renderHoverPart(hoverIndex, hoverPart.contents, hoverPart.source, onFinishedRendering);
+                hoverPartsContainer.appendChild(renderedHoverPart.renderedMarkdown);
+                return renderedHoverPart;
+            }))
+        );
+    }
+    _renderHoverPart(hoverPartIndex, hoverContents, hoverSource, onFinishedRendering) {
+        const { renderedMarkdown, disposables } = this._renderMarkdownContent(hoverContents, onFinishedRendering);
+        if (!hoverSource) {
+            return { renderedMarkdown, disposables };
+        }
+        const canIncreaseVerbosity = hoverSource.supportsVerbosityAction(HoverVerbosityAction.Increase);
+        const canDecreaseVerbosity = hoverSource.supportsVerbosityAction(HoverVerbosityAction.Decrease);
+        if (!canIncreaseVerbosity && !canDecreaseVerbosity) {
+            return { renderedMarkdown, disposables, hoverSource };
+        }
+        const actionsContainer = $('div.verbosity-actions');
+        renderedMarkdown.prepend(actionsContainer);
+        disposables.add(this._renderHoverExpansionAction(actionsContainer, HoverVerbosityAction.Increase, canIncreaseVerbosity));
+        disposables.add(this._renderHoverExpansionAction(actionsContainer, HoverVerbosityAction.Decrease, canDecreaseVerbosity));
+        const focusTracker = disposables.add(trackFocus(renderedMarkdown));
+        disposables.add(focusTracker.onDidFocus(() => {
+            this._hoverFocusInfo = {
+                hoverPartIndex,
+                focusRemains: true
+            };
+        }));
+        disposables.add(focusTracker.onDidBlur(() => {
+            if (this._hoverFocusInfo?.focusRemains) {
+                this._hoverFocusInfo.focusRemains = false;
+                return;
+            }
+        }));
+        return { renderedMarkdown, disposables, hoverSource };
+    }
+    _renderMarkdownContent(markdownContent, onFinishedRendering) {
+        const renderedMarkdown = $('div.hover-row');
+        renderedMarkdown.tabIndex = 0;
+        const renderedMarkdownContents = $('div.hover-row-contents');
+        renderedMarkdown.appendChild(renderedMarkdownContents);
+        const disposables = ( (new DisposableStore()));
+        disposables.add(renderMarkdownInContainer(this._editor, renderedMarkdownContents, markdownContent, this._languageService, this._openerService, onFinishedRendering));
+        return { renderedMarkdown, disposables };
+    }
+    _renderHoverExpansionAction(container, action, actionEnabled) {
+        const store = ( (new DisposableStore()));
+        const isActionIncrease = action === HoverVerbosityAction.Increase;
+        const actionElement = append(container, $(ThemeIcon.asCSSSelector(isActionIncrease ? increaseHoverVerbosityIcon : decreaseHoverVerbosityIcon)));
+        actionElement.tabIndex = 0;
+        const hoverDelegate = ( (new WorkbenchHoverDelegate(
+            'mouse',
+            false,
+            { target: container, position: { hoverPosition: 0  } },
+            this._configurationService,
+            this._hoverService
+        )));
+        if (isActionIncrease) {
+            const kb = this._keybindingService.lookupKeybinding(INCREASE_HOVER_VERBOSITY_ACTION_ID);
+            store.add(this._hoverService.setupUpdatableHover(hoverDelegate, actionElement, kb ?
+                ( localizeWithPath(_moduleId, 5, "Increase Verbosity ({0})", kb.getLabel())) :
+                ( localizeWithPath(_moduleId, 6, "Increase Verbosity"))));
+        }
+        else {
+            const kb = this._keybindingService.lookupKeybinding(DECREASE_HOVER_VERBOSITY_ACTION_ID);
+            store.add(this._hoverService.setupUpdatableHover(hoverDelegate, actionElement, kb ?
+                ( localizeWithPath(_moduleId, 7, "Decrease Verbosity ({0})", kb.getLabel())) :
+                ( localizeWithPath(_moduleId, 8, "Decrease Verbosity"))));
+        }
+        if (!actionEnabled) {
+            actionElement.classList.add('disabled');
+            return store;
+        }
+        actionElement.classList.add('enabled');
+        const actionFunction = () => this.updateFocusedHoverPartVerbosityLevel(action);
+        store.add(( (new ClickAction(actionElement, actionFunction))));
+        store.add(( (new KeyDownAction(
+            actionElement,
+            actionFunction,
+            [3 , 10 ]
+        ))));
+        return store;
+    }
+    async updateFocusedHoverPartVerbosityLevel(action) {
+        const model = this._editor.getModel();
+        if (!model) {
+            return;
+        }
+        const hoverFocusedPartIndex = this._hoverFocusInfo.hoverPartIndex;
+        const hoverRenderedPart = this._getRenderedHoverPartAtIndex(hoverFocusedPartIndex);
+        if (!hoverRenderedPart || !hoverRenderedPart.hoverSource?.supportsVerbosityAction(action)) {
+            return;
+        }
+        const hoverPosition = hoverRenderedPart.hoverSource.hoverPosition;
+        const hoverProvider = hoverRenderedPart.hoverSource.hoverProvider;
+        const hover = hoverRenderedPart.hoverSource.hover;
+        const hoverContext = { verbosityRequest: { action, previousHover: hover } };
+        let newHover;
+        try {
+            newHover = await Promise.resolve(hoverProvider.provideHover(model, hoverPosition, CancellationToken.None, hoverContext));
+        }
+        catch (e) {
+            onUnexpectedExternalError(e);
+        }
+        if (!newHover) {
+            return;
+        }
+        const hoverSource = ( (new HoverSource(newHover, hoverProvider, hoverPosition)));
+        const renderedHoverPart = this._renderHoverPart(hoverFocusedPartIndex, newHover.contents, hoverSource, this._onFinishedRendering);
+        this._replaceRenderedHoverPartAtIndex(hoverFocusedPartIndex, renderedHoverPart);
+        this._focusOnHoverPartWithIndex(hoverFocusedPartIndex);
+        this._onFinishedRendering();
+    }
+    _replaceRenderedHoverPartAtIndex(index, renderedHoverPart) {
+        if (index >= this._renderHoverParts.length || index < 0) {
+            return;
+        }
+        const currentRenderedHoverPart = this._renderedHoverParts[index];
+        const currentRenderedMarkdown = currentRenderedHoverPart.renderedMarkdown;
+        currentRenderedMarkdown.replaceWith(renderedHoverPart.renderedMarkdown);
+        currentRenderedHoverPart.disposables.dispose();
+        this._renderedHoverParts[index] = renderedHoverPart;
+    }
+    _focusOnHoverPartWithIndex(index) {
+        this._renderedHoverParts[index].renderedMarkdown.focus();
+        this._hoverFocusInfo.focusRemains = true;
+    }
+    _getRenderedHoverPartAtIndex(index) {
+        return this._renderedHoverParts[index];
+    }
+}
 function renderMarkdownHovers(context, hoverParts, editor, languageService, openerService) {
-    hoverParts.sort((a, b) => a.ordinal - b.ordinal);
+    hoverParts.sort(compareBy(hover => hover.ordinal, numberComparator));
     const disposables = ( (new DisposableStore()));
     for (const hoverPart of hoverParts) {
-        for (const contents of hoverPart.contents) {
-            if (isEmptyMarkdownString(contents)) {
-                continue;
-            }
-            const markdownHoverElement = $('div.hover-row.markdown-hover');
-            const hoverContentsElement = append(markdownHoverElement, $('div.hover-contents'));
-            const renderer = disposables.add(( (new MarkdownRenderer({ editor }, languageService, openerService))));
-            disposables.add(renderer.onDidRenderAsync(() => {
-                hoverContentsElement.className = 'hover-contents code-hover-contents';
-                context.onContentsChanged();
-            }));
-            const renderedContents = disposables.add(renderer.render(contents));
-            hoverContentsElement.appendChild(renderedContents.element);
-            context.fragment.appendChild(markdownHoverElement);
-        }
+        disposables.add(renderMarkdownInContainer(editor, context.fragment, hoverPart.contents, languageService, openerService, context.onContentsChanged));
     }
     return disposables;
 }
+function renderMarkdownInContainer(editor, container, markdownStrings, languageService, openerService, onFinishedRendering) {
+    const store = ( (new DisposableStore()));
+    for (const contents of markdownStrings) {
+        if (isEmptyMarkdownString(contents)) {
+            continue;
+        }
+        const markdownHoverElement = $('div.markdown-hover');
+        const hoverContentsElement = append(markdownHoverElement, $('div.hover-contents'));
+        const renderer = store.add(( (new MarkdownRenderer({ editor }, languageService, openerService))));
+        store.add(renderer.onDidRenderAsync(() => {
+            hoverContentsElement.className = 'hover-contents code-hover-contents';
+            onFinishedRendering();
+        }));
+        const renderedContents = store.add(renderer.render(contents));
+        hoverContentsElement.appendChild(renderedContents.element);
+        container.appendChild(markdownHoverElement);
+    }
+    return store;
+}
 export { MarkdownHover, MarkdownHoverParticipant, renderMarkdownHovers };

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

@@ -81,6 +81,7 @@ let MarkerHoverParticipant = class MarkerHoverParticipant {
     }
     renderMarkerHover(markerHover, disposables) {
         const hoverElement = $('div.hover-row');
+        hoverElement.tabIndex = 0;
         const markerElement = append(hoverElement, $('div.marker.hover-contents'));
         const { source, message, code, relatedInformation } = markerHover.marker;
         this._editor.applyFontInfo(markerElement);

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

@@ -8,7 +8,7 @@ import { EditorContextKeys } from '../../../common/editorContextKeys.js';
 import { ILanguageConfigurationService } from '../../../common/languages/languageConfigurationRegistry.js';
 import { IModelService } from '../../../common/services/model.js';
 import { getSpaceCnt, generateIndent } from '../common/indentUtils.js';
-import { localizeWithPath } from '../../../../nls.js';
+import { localizeWithPath, localize2WithPath } from '../../../../nls.js';
 import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.service.js';
 import { getGoodIndentForLine, getIndentMetadata } from '../../../common/languages/autoIndent.js';
 import { getReindentEditOperations } from '../common/indentation.js';
@@ -20,7 +20,10 @@ class IndentationToSpacesAction extends EditorAction {
             id: IndentationToSpacesAction.ID,
             label: ( localizeWithPath(_moduleId, 0, "Convert Indentation to Spaces")),
             alias: 'Convert Indentation to Spaces',
-            precondition: EditorContextKeys.writable
+            precondition: EditorContextKeys.writable,
+            metadata: {
+                description: ( localize2WithPath(_moduleId, 1, "Convert the tab indentation to spaces.")),
+            }
         });
     }
     run(accessor, editor) {
@@ -47,9 +50,12 @@ class IndentationToTabsAction extends EditorAction {
     constructor() {
         super({
             id: IndentationToTabsAction.ID,
-            label: ( localizeWithPath(_moduleId, 1, "Convert Indentation to Tabs")),
+            label: ( localizeWithPath(_moduleId, 2, "Convert Indentation to Tabs")),
             alias: 'Convert Indentation to Tabs',
-            precondition: EditorContextKeys.writable
+            precondition: EditorContextKeys.writable,
+            metadata: {
+                description: ( localize2WithPath(_moduleId, 3, "Convert the spaces indentation to tabs.")),
+            }
         });
     }
     run(accessor, editor) {
@@ -90,16 +96,16 @@ class ChangeIndentationSizeAction extends EditorAction {
             id: ( (n.toString())),
             label: ( (n.toString())),
             description: (n === creationOpts.tabSize && n === modelOpts.tabSize
-                ? ( localizeWithPath(_moduleId, 2, "Configured Tab Size"))
+                ? ( localizeWithPath(_moduleId, 4, "Configured Tab Size"))
                 : n === creationOpts.tabSize
-                    ? ( localizeWithPath(_moduleId, 3, "Default Tab Size"))
+                    ? ( localizeWithPath(_moduleId, 5, "Default Tab Size"))
                     : n === modelOpts.tabSize
-                        ? ( localizeWithPath(_moduleId, 4, "Current Tab Size"))
+                        ? ( localizeWithPath(_moduleId, 6, "Current Tab Size"))
                         : undefined)
         }))));
         const autoFocusIndex = Math.min(model.getOptions().tabSize - 1, 7);
         setTimeout(() => {
-            quickInputService.pick(picks, { placeHolder: ( localizeWithPath(_moduleId, 5, "Select Tab Size for Current File")), activeItem: picks[autoFocusIndex] }).then(pick => {
+            quickInputService.pick(picks, { placeHolder: ( localizeWithPath(_moduleId, 7, "Select Tab Size for Current File")), activeItem: picks[autoFocusIndex] }).then(pick => {
                 if (pick) {
                     if (model && !model.isDisposed()) {
                         const pickedVal = parseInt(pick.label, 10);
@@ -126,9 +132,12 @@ class IndentUsingTabs extends ChangeIndentationSizeAction {
     constructor() {
         super(false, false, {
             id: IndentUsingTabs.ID,
-            label: ( localizeWithPath(_moduleId, 6, "Indent Using Tabs")),
+            label: ( localizeWithPath(_moduleId, 8, "Indent Using Tabs")),
             alias: 'Indent Using Tabs',
-            precondition: undefined
+            precondition: undefined,
+            metadata: {
+                description: ( localize2WithPath(_moduleId, 9, "Use indentation with tabs.")),
+            }
         });
     }
 }
@@ -137,9 +146,12 @@ class IndentUsingSpaces extends ChangeIndentationSizeAction {
     constructor() {
         super(true, false, {
             id: IndentUsingSpaces.ID,
-            label: ( localizeWithPath(_moduleId, 7, "Indent Using Spaces")),
+            label: ( localizeWithPath(_moduleId, 10, "Indent Using Spaces")),
             alias: 'Indent Using Spaces',
-            precondition: undefined
+            precondition: undefined,
+            metadata: {
+                description: ( localize2WithPath(_moduleId, 11, "Use indentation with spaces.")),
+            }
         });
     }
 }
@@ -148,9 +160,12 @@ class ChangeTabDisplaySize extends ChangeIndentationSizeAction {
     constructor() {
         super(true, true, {
             id: ChangeTabDisplaySize.ID,
-            label: ( localizeWithPath(_moduleId, 8, "Change Tab Display Size")),
+            label: ( localizeWithPath(_moduleId, 12, "Change Tab Display Size")),
             alias: 'Change Tab Display Size',
-            precondition: undefined
+            precondition: undefined,
+            metadata: {
+                description: ( localize2WithPath(_moduleId, 13, "Change the space size equivalent of the tab.")),
+            }
         });
     }
 }
@@ -159,9 +174,12 @@ class DetectIndentation extends EditorAction {
     constructor() {
         super({
             id: DetectIndentation.ID,
-            label: ( localizeWithPath(_moduleId, 9, "Detect Indentation from Content")),
+            label: ( localizeWithPath(_moduleId, 14, "Detect Indentation from Content")),
             alias: 'Detect Indentation from Content',
-            precondition: undefined
+            precondition: undefined,
+            metadata: {
+                description: ( localize2WithPath(_moduleId, 15, "Detect the indentation from content.")),
+            }
         });
     }
     run(accessor, editor) {
@@ -178,9 +196,12 @@ class ReindentLinesAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.reindentlines',
-            label: ( localizeWithPath(_moduleId, 10, "Reindent Lines")),
+            label: ( localizeWithPath(_moduleId, 16, "Reindent Lines")),
             alias: 'Reindent Lines',
-            precondition: EditorContextKeys.writable
+            precondition: EditorContextKeys.writable,
+            metadata: {
+                description: ( localize2WithPath(_moduleId, 17, "Reindent the lines of the editor.")),
+            }
         });
     }
     run(accessor, editor) {
@@ -201,9 +222,12 @@ class ReindentSelectedLinesAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.reindentselectedlines',
-            label: ( localizeWithPath(_moduleId, 11, "Reindent Selected Lines")),
+            label: ( localizeWithPath(_moduleId, 18, "Reindent Selected Lines")),
             alias: 'Reindent Selected Lines',
-            precondition: EditorContextKeys.writable
+            precondition: EditorContextKeys.writable,
+            metadata: {
+                description: ( localize2WithPath(_moduleId, 19, "Reindent the selected lines of the editor.")),
+            }
         });
     }
     run(accessor, editor) {

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

@@ -6,7 +6,7 @@ import { ModelDecorationInjectedTextOptions } from '../../../common/model/textMo
 import { HoverForeignElementAnchor } from '../../hover/browser/hoverTypes.js';
 import { ILanguageService } from '../../../common/languages/language.js';
 import { ITextModelService } from '../../../common/services/resolverService.js';
-import { getHover } from '../../hover/browser/getHover.js';
+import { getHoverProviderResultsAsAsyncIterable } from '../../hover/browser/getHover.js';
 import { MarkdownHoverParticipant, MarkdownHover } from '../../hover/browser/markdownHoverParticipant.js';
 import { InlayHintsController, RenderedInlayHintLabelPart } from './inlayHintsController.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
@@ -16,6 +16,8 @@ import { localizeWithPath } from '../../../../nls.js';
 import { isMacintosh } from '../../../../base/common/platform.js';
 import { asCommandLink } from './inlayHints.js';
 import { isNonEmptyArray } from '../../../../base/common/arrays.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.service.js';
+import { IHoverService } from '../../../../platform/hover/browser/hover.service.js';
 const _moduleId = "vs/editor/contrib/inlayHints/browser/inlayHintsHover";
 class InlayHintsHoverAnchor extends HoverForeignElementAnchor {
     constructor(part, owner, initialMousePosX, initialMousePosY) {
@@ -24,8 +26,8 @@ class InlayHintsHoverAnchor extends HoverForeignElementAnchor {
     }
 }
 let InlayHintsHover = class InlayHintsHover extends MarkdownHoverParticipant {
-    constructor(editor, languageService, openerService, configurationService, _resolverService, languageFeaturesService) {
-        super(editor, languageService, openerService, configurationService, languageFeaturesService);
+    constructor(editor, languageService, openerService, keybindingService, hoverService, configurationService, _resolverService, languageFeaturesService) {
+        super(editor, languageService, openerService, configurationService, languageFeaturesService, keybindingService, hoverService);
         this._resolverService = _resolverService;
         this.hoverOrdinal = 6;
     }
@@ -130,7 +132,7 @@ let InlayHintsHover = class InlayHintsHover extends MarkdownHoverParticipant {
                 return AsyncIterableObject.EMPTY;
             }
             return (
-                 (getHover(this._languageFeaturesService.hoverProvider, model, ( (new Position(range.startLineNumber, range.startColumn))), token)
+                 (getHoverProviderResultsAsAsyncIterable(this._languageFeaturesService.hoverProvider, model, ( (new Position(range.startLineNumber, range.startColumn))), token)
                     .filter(item => !isEmptyMarkdownString(item.hover.contents))
                     .map(
                     item => ( (new MarkdownHover(this, part.item.anchor.range, item.hover.contents, false, 2 + item.ordinal)))
@@ -145,8 +147,10 @@ let InlayHintsHover = class InlayHintsHover extends MarkdownHoverParticipant {
 InlayHintsHover = ( (__decorate([
     ( (__param(1, ILanguageService))),
     ( (__param(2, IOpenerService))),
-    ( (__param(3, IConfigurationService))),
-    ( (__param(4, ITextModelService))),
-    ( (__param(5, ILanguageFeaturesService)))
+    ( (__param(3, IKeybindingService))),
+    ( (__param(4, IHoverService))),
+    ( (__param(5, IConfigurationService))),
+    ( (__param(6, ITextModelService))),
+    ( (__param(7, ILanguageFeaturesService)))
 ], InlayHintsHover)));
 export { InlayHintsHover };

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/commands.js

@@ -3,6 +3,7 @@ import '../../../../base/common/observableInternal/derived.js';
 import '../../../../base/common/observableInternal/autorun.js';
 import '../../../../base/common/observableInternal/utils.js';
 import '../../../../base/common/cancellation.js';
+import '../../../../base/common/arrays.js';
 import { EditorAction } from '../../../browser/editorExtensions.js';
 import { EditorContextKeys } from '../../../common/editorContextKeys.js';
 import { showNextInlineSuggestionActionId, showPreviousInlineSuggestionActionId, inlineSuggestCommitId } from './commandIds.js';

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/ghostTextWidget.js

@@ -7,6 +7,7 @@ import { derived } from '../../../../base/common/observableInternal/derived.js';
 import { autorun } from '../../../../base/common/observableInternal/autorun.js';
 import { observableSignalFromEvent, observableFromEvent } from '../../../../base/common/observableInternal/utils.js';
 import '../../../../base/common/cancellation.js';
+import '../../../../base/common/arrays.js';
 import { containsRTL, isBasicASCII } from '../../../../base/common/strings.js';
 import './ghostText.css.js';
 import { applyFontInfo } from '../../../browser/config/domFontInfo.js';

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/hoverParticipant.js

@@ -2,6 +2,7 @@ import { __decorate, __param } from '../../../../../../../external/tslib/tslib.e
 import { append, reset, $ } from '../../../../base/browser/dom.js';
 import { MarkdownString } from '../../../../base/common/htmlContent.js';
 import { DisposableStore } from '../../../../base/common/lifecycle.js';
+import '../../../../base/common/arrays.js';
 import '../../../../base/common/observableInternal/derived.js';
 import { autorun } from '../../../../base/common/observableInternal/autorun.js';
 import { constObservable } from '../../../../base/common/observableInternal/utils.js';
@@ -110,9 +111,7 @@ let InlineCompletionsHoverParticipant = class InlineCompletionsHoverParticipant
             this.renderScreenReaderText(context, part, disposableStore);
         }
         const model = part.controller.model.get();
-        const w = this._instantiationService.createInstance(InlineSuggestionHintsContentWidget, this._editor, false, constObservable(null), model.selectedInlineCompletionIndex, model.inlineCompletionsCount, ( (model.selectedInlineCompletion.map(
-            v =>  v?.inlineCompletion.source.inlineCompletions.commands ?? []
-        ))));
+        const w = this._instantiationService.createInstance(InlineSuggestionHintsContentWidget, this._editor, false, constObservable(null), model.selectedInlineCompletionIndex, model.inlineCompletionsCount, model.activeCommands);
         context.fragment.appendChild(w.getDomNode());
         model.triggerExplicitly();
         disposableStore.add(w);

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/inlineCompletionContextKeys.js

@@ -1,3 +1,4 @@
+import '../../../../base/common/arrays.js';
 import '../../../../base/common/observableInternal/derived.js';
 import { autorun } from '../../../../base/common/observableInternal/autorun.js';
 import '../../../../base/common/observableInternal/utils.js';