@codingame/monaco-vscode-api 2.2.1 → 3.0.0

package/vscode/src/vs/base/browser/ui/iconLabel/iconLabel.js

@@ -5,6 +5,7 @@ import { setupNativeHover, setupCustomHover } from './iconLabelHover.js';
 import { Disposable } from '../../../common/lifecycle.js';
 import { equals } from '../../../common/objects.js';
 import { Range } from '../../../common/range.js';
+import { getDefaultHoverDelegate } from '../hover/hoverDelegate.js';
 class FastLabelNode {
     constructor(_element) {
         this._element = _element;
@@ -51,7 +52,7 @@ class IconLabel extends Disposable {
         else {
             this.nameNode = ( new Label(this.nameContainer));
         }
-        this.hoverDelegate = options?.hoverDelegate;
+        this.hoverDelegate = options?.hoverDelegate ?? getDefaultHoverDelegate('mouse');
     }
     get element() {
         return this.domNode.element;
@@ -114,7 +115,7 @@ class IconLabel extends Disposable {
             htmlElement.removeAttribute('title');
             return;
         }
-        if (!this.hoverDelegate) {
+        if (this.hoverDelegate.showNativeHover) {
             setupNativeHover(htmlElement, tooltip);
         }
         else {

package/vscode/src/vs/base/browser/ui/iconLabel/iconLabelHover.js

@@ -110,13 +110,14 @@ function setupCustomHover(hoverDelegate, htmlElement, content, options) {
         }
         if (hadHover) {
             hoverDelegate.onDidHideHover?.();
+            hoverWidget = undefined;
         }
     };
     const triggerShowHover = (delay, focus, target) => {
         return ( new TimeoutTimer(async () => {
             if (!hoverWidget || hoverWidget.isDisposed) {
                 hoverWidget = ( new UpdatableHoverWidget(hoverDelegate, target || htmlElement, delay > 0));
-                await hoverWidget.update(content, focus, options);
+                await hoverWidget.update(typeof content === 'function' ? content() : content, focus, options);
             }
         }, delay));
     };

package/vscode/src/vs/base/browser/ui/list/listView.js

@@ -14,6 +14,7 @@ import { Scrollable } from '../../../common/scrollable.js';
 import { RangeMap, shift } from './rangeMap.js';
 import { RowCache } from './rowCache.js';
 import { BugIndicatingError } from '../../../common/errors.js';
+import { clamp } from '../../../common/numbers.js';
 const StaticDND = {
     CurrentDragAndDropData: undefined
 };
@@ -176,7 +177,7 @@ class ListView {
         }
         this.items = [];
         this.itemId = 0;
-        this.rangeMap = ( new RangeMap(options.paddingTop ?? 0));
+        this.rangeMap = this.createRangeMap(options.paddingTop ?? 0);
         for (const renderer of renderers) {
             this.renderers.set(renderer.templateId, renderer);
         }
@@ -310,6 +311,9 @@ class ListView {
             this._rerender(this.lastRenderTop, this.lastRenderHeight);
         }
     }
+    createRangeMap(paddingTop) {
+        return ( new RangeMap(paddingTop));
+    }
     splice(start, deleteCount, elements = []) {
         if (this.splicing) {
             throw new Error('Can\'t run recursive splices.');
@@ -345,6 +349,7 @@ class ListView {
                 rows.push(item.row);
             }
             item.row = null;
+            item.stale = true;
         }
         const previousRestRange = { start: start + deleteCount, end: this.items.length };
         const previousRenderedRestRange = Range.intersect(previousRestRange, previousRenderRange);
@@ -361,11 +366,12 @@ class ListView {
             uri: undefined,
             dropTarget: false,
             dragStartDisposable: Disposable.None,
-            checkedDisposable: Disposable.None
+            checkedDisposable: Disposable.None,
+            stale: false
         })));
         let deleted;
         if (start === 0 && deleteCount >= this.items.length) {
-            this.rangeMap = ( new RangeMap(this.rangeMap.paddingTop));
+            this.rangeMap = this.createRangeMap(this.rangeMap.paddingTop);
             this.rangeMap.splice(0, 0, inserted);
             deleted = this.items;
             this.items = inserted;
@@ -389,14 +395,13 @@ class ListView {
         }
         const unrenderedRestRanges = ( previousUnrenderedRestRanges.map(r => shift(r, delta)));
         const elementsRange = { start, end: start + elements.length };
-        const insertRanges = ( [elementsRange, ...unrenderedRestRanges].map(r => Range.intersect(renderRange, r)));
-        const beforeElement = this.getNextToLastElement(insertRanges);
+        const insertRanges = ( [elementsRange, ...unrenderedRestRanges].map(r => Range.intersect(renderRange, r))).reverse();
         for (const range of insertRanges) {
-            for (let i = range.start; i < range.end; i++) {
+            for (let i = range.end - 1; i >= range.start; i--) {
                 const item = this.items[i];
                 const rows = rowsToDispose.get(item.templateId);
                 const row = rows?.pop();
-                this.insertItemInDOM(i, beforeElement, row);
+                this.insertItemInDOM(i, row);
             }
         }
         for (const rows of ( rowsToDispose.values())) {
@@ -536,9 +541,8 @@ class ListView {
     }
     render(previousRenderRange, renderTop, renderHeight, renderLeft, scrollWidth, updateItemsInDOM = false) {
         const renderRange = this.getRenderRange(renderTop, renderHeight);
-        const rangesToInsert = Range.relativeComplement(renderRange, previousRenderRange);
+        const rangesToInsert = Range.relativeComplement(renderRange, previousRenderRange).reverse();
         const rangesToRemove = Range.relativeComplement(previousRenderRange, renderRange);
-        const beforeElement = this.getNextToLastElement(rangesToInsert);
         if (updateItemsInDOM) {
             const rangesToUpdate = Range.intersect(previousRenderRange, renderRange);
             for (let i = rangesToUpdate.start; i < rangesToUpdate.end; i++) {
@@ -552,8 +556,8 @@ class ListView {
                 }
             }
             for (const range of rangesToInsert) {
-                for (let i = range.start; i < range.end; i++) {
-                    this.insertItemInDOM(i, beforeElement);
+                for (let i = range.end - 1; i >= range.start; i--) {
+                    this.insertItemInDOM(i);
                 }
             }
         });
@@ -567,17 +571,17 @@ class ListView {
         this.lastRenderTop = renderTop;
         this.lastRenderHeight = renderHeight;
     }
-    insertItemInDOM(index, beforeElement, row) {
+    insertItemInDOM(index, row) {
         const item = this.items[index];
-        let isStale = false;
         if (!item.row) {
             if (row) {
                 item.row = row;
+                item.stale = true;
             }
             else {
                 const result = this.cache.alloc(item.templateId);
                 item.row = result.row;
-                isStale = result.isReusingConnectedDomNode;
+                item.stale ||= result.isReusingConnectedDomNode;
             }
         }
         const role = this.accessibilityProvider.getRole(item.element) || 'listitem';
@@ -591,13 +595,10 @@ class ListView {
             update(checked.value);
             item.checkedDisposable = checked.onDidChange(update);
         }
-        if (isStale || !item.row.domNode.parentElement) {
-            if (beforeElement) {
-                this.rowsContainer.insertBefore(item.row.domNode, beforeElement);
-            }
-            else {
-                this.rowsContainer.appendChild(item.row.domNode);
-            }
+        if (item.stale || !item.row.domNode.parentElement) {
+            const referenceNode = this.items.at(index + 1)?.row?.domNode ?? null;
+            this.rowsContainer.insertBefore(item.row.domNode, referenceNode);
+            item.stale = false;
         }
         this.updateItemInDOM(item, index);
         const renderer = this.renderers.get(item.templateId);
@@ -944,7 +945,8 @@ class ListView {
             return undefined;
         }
         const relativePosition = browserEvent.offsetY / this.items[targetIndex].size;
-        return Math.floor(relativePosition / 0.25);
+        const sector = Math.floor(relativePosition / 0.25);
+        return clamp(sector, 0, 3);
     }
     getItemIndexFromEventTarget(target) {
         const scrollableElement = this.scrollableElement.getDomNode();
@@ -1003,13 +1005,10 @@ class ListView {
                         }
                     }
                 }
-                const renderRanges = Range.relativeComplement(renderRange, previousRenderRange);
+                const renderRanges = Range.relativeComplement(renderRange, previousRenderRange).reverse();
                 for (const range of renderRanges) {
-                    for (let i = range.start; i < range.end; i++) {
-                        const afterIndex = i + 1;
-                        const beforeRow = afterIndex < this.items.length ? this.items[afterIndex].row : null;
-                        const beforeElement = beforeRow ? beforeRow.domNode : null;
-                        this.insertItemInDOM(i, beforeElement);
+                    for (let i = range.end - 1; i >= range.start; i--) {
+                        this.insertItemInDOM(i);
                     }
                 }
                 for (let i = renderRange.start; i < renderRange.end; i++) {
@@ -1067,20 +1066,6 @@ class ListView {
         this.cache.release(row);
         return item.size - size;
     }
-    getNextToLastElement(ranges) {
-        const lastRange = ranges[ranges.length - 1];
-        if (!lastRange) {
-            return null;
-        }
-        const nextToLastItem = this.items[lastRange.end];
-        if (!nextToLastItem) {
-            return null;
-        }
-        if (!nextToLastItem.row) {
-            return null;
-        }
-        return nextToLastItem.row.domNode;
-    }
     getElementDomId(index) {
         return `${this.domId}_${index}`;
     }

package/vscode/src/vs/base/browser/ui/menu/menu.js

@@ -767,10 +767,6 @@ ${formatRule(Codicon.menuSubmenu)}
 	cursor: default;
 }
 
-.monaco-menu .monaco-action-bar.animated .action-item.active {
-	transform: scale(1.272019649, 1.272019649); /* 1.272019649 = √φ */
-}
-
 .monaco-menu .monaco-action-bar .action-item .icon,
 .monaco-menu .monaco-action-bar .action-item .codicon {
 	display: inline-block;

package/vscode/src/vs/base/browser/ui/scrollbar/scrollableElement.d.ts

@@ -0,0 +1,81 @@
+import { IMouseWheelEvent } from '../../mouseEvent.js';
+import { ScrollableElementCreationOptions, ScrollableElementResolvedOptions, ScrollableElementChangeOptions } from './scrollableElementOptions.js';
+import { Widget } from '../widget.js';
+import { Event } from '../../../common/event.js';
+import { INewScrollPosition, IScrollPosition, Scrollable, ScrollEvent, IScrollDimensions, INewScrollDimensions } from '../../../common/scrollable.js';
+
+interface IOverviewRulerLayoutInfo {
+    parent: HTMLElement;
+    insertBefore: HTMLElement;
+}
+declare abstract class AbstractScrollableElement extends Widget {
+    private readonly _options;
+    protected readonly _scrollable: Scrollable;
+    private readonly _verticalScrollbar;
+    private readonly _horizontalScrollbar;
+    private readonly _domNode;
+    private readonly _leftShadowDomNode;
+    private readonly _topShadowDomNode;
+    private readonly _topLeftShadowDomNode;
+    private readonly _listenOnDomNode;
+    private _mouseWheelToDispose;
+    private _isDragging;
+    private _mouseIsOver;
+    private readonly _hideTimeout;
+    private _shouldRender;
+    private _revealOnScroll;
+    private readonly _onScroll;
+    readonly onScroll: Event<ScrollEvent>;
+    private readonly _onWillScroll;
+    readonly onWillScroll: Event<ScrollEvent>;
+    get options(): Readonly<ScrollableElementResolvedOptions>;
+    protected constructor(element: HTMLElement, options: ScrollableElementCreationOptions, scrollable: Scrollable);
+    dispose(): void;
+    /**
+     * Get the generated 'scrollable' dom node
+     */
+    getDomNode(): HTMLElement;
+    getOverviewRulerLayoutInfo(): IOverviewRulerLayoutInfo;
+    /**
+     * Delegate a pointer down event to the vertical scrollbar.
+     * This is to help with clicking somewhere else and having the scrollbar react.
+     */
+    delegateVerticalScrollbarPointerDown(browserEvent: PointerEvent): void;
+    getScrollDimensions(): IScrollDimensions;
+    setScrollDimensions(dimensions: INewScrollDimensions): void;
+    /**
+     * Update the class name of the scrollable element.
+     */
+    updateClassName(newClassName: string): void;
+    /**
+     * Update configuration options for the scrollbar.
+     */
+    updateOptions(newOptions: ScrollableElementChangeOptions): void;
+    setRevealOnScroll(value: boolean): void;
+    delegateScrollFromMouseWheelEvent(browserEvent: IMouseWheelEvent): void;
+    private _setListeningToMouseWheel;
+    private _onMouseWheel;
+    private _onDidScroll;
+    /**
+     * Render / mutate the DOM now.
+     * Should be used together with the ctor option `lazyRender`.
+     */
+    renderNow(): void;
+    private _render;
+    private _onDragStart;
+    private _onDragEnd;
+    private _onMouseLeave;
+    private _onMouseOver;
+    private _reveal;
+    private _hide;
+    private _scheduleHide;
+}
+declare class DomScrollableElement extends AbstractScrollableElement {
+    private _element;
+    constructor(element: HTMLElement, options: ScrollableElementCreationOptions);
+    setScrollPosition(update: INewScrollPosition): void;
+    getScrollPosition(): IScrollPosition;
+    scanDomNode(): void;
+}
+
+export { AbstractScrollableElement, DomScrollableElement, type IOverviewRulerLayoutInfo };

package/vscode/src/vs/base/browser/ui/scrollbar/scrollableElementOptions.d.ts

@@ -0,0 +1,160 @@
+import { ScrollbarVisibility } from '../../../common/scrollable.js';
+
+interface ScrollableElementCreationOptions {
+    /**
+     * The scrollable element should not do any DOM mutations until renderNow() is called.
+     * Defaults to false.
+     */
+    lazyRender?: boolean;
+    /**
+     * CSS Class name for the scrollable element.
+     */
+    className?: string;
+    /**
+     * Drop subtle horizontal and vertical shadows.
+     * Defaults to false.
+     */
+    useShadows?: boolean;
+    /**
+     * Handle mouse wheel (listen to mouse wheel scrolling).
+     * Defaults to true
+     */
+    handleMouseWheel?: boolean;
+    /**
+     * If mouse wheel is handled, make mouse wheel scrolling smooth.
+     * Defaults to true.
+     */
+    mouseWheelSmoothScroll?: boolean;
+    /**
+     * Flip axes. Treat vertical scrolling like horizontal and vice-versa.
+     * Defaults to false.
+     */
+    flipAxes?: boolean;
+    /**
+     * If enabled, will scroll horizontally when scrolling vertical.
+     * Defaults to false.
+     */
+    scrollYToX?: boolean;
+    /**
+     * Consume all mouse wheel events if a scrollbar is needed (i.e. scrollSize > size).
+     * Defaults to false.
+     */
+    consumeMouseWheelIfScrollbarIsNeeded?: boolean;
+    /**
+     * Always consume mouse wheel events, even when scrolling is no longer possible.
+     * Defaults to false.
+     */
+    alwaysConsumeMouseWheel?: boolean;
+    /**
+     * A multiplier to be used on the `deltaX` and `deltaY` of mouse wheel scroll events.
+     * Defaults to 1.
+     */
+    mouseWheelScrollSensitivity?: number;
+    /**
+     * FastScrolling mulitplier speed when pressing `Alt`
+     * Defaults to 5.
+     */
+    fastScrollSensitivity?: number;
+    /**
+     * Whether the scrollable will only scroll along the predominant axis when scrolling both
+     * vertically and horizontally at the same time.
+     * Prevents horizontal drift when scrolling vertically on a trackpad.
+     * Defaults to true.
+     */
+    scrollPredominantAxis?: boolean;
+    /**
+     * Height for vertical arrows (top/bottom) and width for horizontal arrows (left/right).
+     * Defaults to 11.
+     */
+    arrowSize?: number;
+    /**
+     * The dom node events should be bound to.
+     * If no listenOnDomNode is provided, the dom node passed to the constructor will be used for event listening.
+     */
+    listenOnDomNode?: HTMLElement;
+    /**
+     * Control the visibility of the horizontal scrollbar.
+     * Accepted values: 'auto' (on mouse over), 'visible' (always visible), 'hidden' (never visible)
+     * Defaults to 'auto'.
+     */
+    horizontal?: ScrollbarVisibility;
+    /**
+     * Height (in px) of the horizontal scrollbar.
+     * Defaults to 10.
+     */
+    horizontalScrollbarSize?: number;
+    /**
+     * Height (in px) of the horizontal scrollbar slider.
+     * Defaults to `horizontalScrollbarSize`
+     */
+    horizontalSliderSize?: number;
+    /**
+     * Render arrows (left/right) for the horizontal scrollbar.
+     * Defaults to false.
+     */
+    horizontalHasArrows?: boolean;
+    /**
+     * Control the visibility of the vertical scrollbar.
+     * Accepted values: 'auto' (on mouse over), 'visible' (always visible), 'hidden' (never visible)
+     * Defaults to 'auto'.
+     */
+    vertical?: ScrollbarVisibility;
+    /**
+     * Width (in px) of the vertical scrollbar.
+     * Defaults to 10.
+     */
+    verticalScrollbarSize?: number;
+    /**
+     * Width (in px) of the vertical scrollbar slider.
+     * Defaults to `verticalScrollbarSize`
+     */
+    verticalSliderSize?: number;
+    /**
+     * Render arrows (top/bottom) for the vertical scrollbar.
+     * Defaults to false.
+     */
+    verticalHasArrows?: boolean;
+    /**
+     * Scroll gutter clicks move by page vs. jump to position.
+     * Defaults to false.
+     */
+    scrollByPage?: boolean;
+}
+interface ScrollableElementChangeOptions {
+    handleMouseWheel?: boolean;
+    mouseWheelScrollSensitivity?: number;
+    fastScrollSensitivity?: number;
+    scrollPredominantAxis?: boolean;
+    horizontal?: ScrollbarVisibility;
+    horizontalScrollbarSize?: number;
+    vertical?: ScrollbarVisibility;
+    verticalScrollbarSize?: number;
+    scrollByPage?: boolean;
+}
+interface ScrollableElementResolvedOptions {
+    lazyRender: boolean;
+    className: string;
+    useShadows: boolean;
+    handleMouseWheel: boolean;
+    flipAxes: boolean;
+    scrollYToX: boolean;
+    consumeMouseWheelIfScrollbarIsNeeded: boolean;
+    alwaysConsumeMouseWheel: boolean;
+    mouseWheelScrollSensitivity: number;
+    fastScrollSensitivity: number;
+    scrollPredominantAxis: boolean;
+    mouseWheelSmoothScroll: boolean;
+    arrowSize: number;
+    listenOnDomNode: HTMLElement | null;
+    horizontal: ScrollbarVisibility;
+    horizontalScrollbarSize: number;
+    horizontalSliderSize: number;
+    horizontalHasArrows: boolean;
+    vertical: ScrollbarVisibility;
+    verticalScrollbarSize: number;
+    verticalSliderSize: number;
+    verticalHasArrows: boolean;
+    scrollByPage: boolean;
+}
+
+export type { ScrollableElementChangeOptions, ScrollableElementCreationOptions, ScrollableElementResolvedOptions };

package/vscode/src/vs/base/browser/ui/selectBox/selectBoxCustom.js

@@ -2,6 +2,8 @@ import { $ as $$1, append, createStyleSheet, addDisposableListener, addStandardD
 import { DomEmitter } from '../../event.js';
 import { StandardKeyboardEvent } from '../../keyboardEvent.js';
 import { renderMarkdown } from '../../markdownRenderer.js';
+import { getDefaultHoverDelegate } from '../hover/hoverDelegate.js';
+import { setupCustomHover } from '../iconLabel/iconLabelHover.js';
 import { List } from '../list/listWidget.js';
 import { equals } from '../../../common/arrays.js';
 import { Emitter, Event } from '../../../common/event.js';
@@ -69,6 +71,7 @@ class SelectBoxList extends Disposable {
         if (typeof this.selectBoxOptions.ariaDescription === 'string') {
             this.selectElement.setAttribute('aria-description', this.selectBoxOptions.ariaDescription);
         }
+        this._hover = this._register(setupCustomHover(getDefaultHoverDelegate('mouse'), this.selectElement, ''));
         this._onDidSelect = ( new Emitter());
         this._register(this._onDidSelect);
         this.registerListeners();
@@ -110,7 +113,7 @@ class SelectBoxList extends Disposable {
                 selected: e.target.value
             });
             if (!!this.options[this.selected] && !!this.options[this.selected].text) {
-                this.selectElement.title = this.options[this.selected].text;
+                this._hover.update(this.options[this.selected].text);
             }
         }));
         this._register(addDisposableListener(this.selectElement, EventType.CLICK, (e) => {
@@ -193,7 +196,7 @@ class SelectBoxList extends Disposable {
         }
         this.selectElement.selectedIndex = this.selected;
         if (!!this.options[this.selected] && !!this.options[this.selected].text) {
-            this.selectElement.title = this.options[this.selected].text;
+            this._hover.update(this.options[this.selected].text);
         }
     }
     setAriaLabel(label) {
@@ -568,7 +571,7 @@ class SelectBoxList extends Disposable {
                     selected: this.options[this.selected].text
                 });
                 if (!!this.options[this.selected] && !!this.options[this.selected].text) {
-                    this.selectElement.title = this.options[this.selected].text;
+                    this._hover.update(this.options[this.selected].text);
                 }
             }
             this.hideSelectDropDown(true);
@@ -643,7 +646,7 @@ class SelectBoxList extends Disposable {
                 selected: this.options[this.selected].text
             });
             if (!!this.options[this.selected] && !!this.options[this.selected].text) {
-                this.selectElement.title = this.options[this.selected].text;
+                this._hover.update(this.options[this.selected].text);
             }
         }
         this.hideSelectDropDown(true);

package/vscode/src/vs/base/browser/ui/table/tableWidget.js

@@ -1,8 +1,10 @@
 import { append, $, createStyleSheet, getContentHeight, getContentWidth, clearNode } from '../../dom.js';
+import { getDefaultHoverDelegate } from '../hover/hoverDelegate.js';
+import { setupCustomHover } from '../iconLabel/iconLabelHover.js';
 import { List, unthemedListStyles } from '../list/listWidget.js';
 import { SplitView } from '../splitview/splitview.js';
 import { Event, Emitter } from '../../../common/event.js';
-import { DisposableStore } from '../../../common/lifecycle.js';
+import { DisposableStore, Disposable } from '../../../common/lifecycle.js';
 import './table.css.js';
 class TableListRenderer {
     static { this.TemplateId = 'row'; }
@@ -74,16 +76,18 @@ function asListVirtualDelegate(delegate) {
         getTemplateId() { return TableListRenderer.TemplateId; },
     };
 }
-class ColumnHeader {
+class ColumnHeader extends Disposable {
     get minimumSize() { return this.column.minimumWidth ?? 120; }
     get maximumSize() { return this.column.maximumWidth ?? Number.POSITIVE_INFINITY; }
     get onDidChange() { return this.column.onDidChangeWidthConstraints ?? Event.None; }
     constructor(column, index) {
+        super();
         this.column = column;
         this.index = index;
         this._onDidLayout = ( new Emitter());
         this.onDidLayout = this._onDidLayout.event;
-        this.element = $('.monaco-table-th', { 'data-col-index': index, title: column.tooltip }, column.label);
+        this.element = $('.monaco-table-th', { 'data-col-index': index }, column.label);
+        this._register(setupCustomHover(getDefaultHoverDelegate('mouse'), this.element, column.tooltip));
     }
     layout(size) {
         this._onDidLayout.fire([this.index, size]);
@@ -122,7 +126,7 @@ class Table {
         this.cachedWidth = 0;
         this.cachedHeight = 0;
         this.domNode = append(container, $(`.monaco-table.${this.domId}`));
-        const headers = ( columns.map((c, i) => ( new ColumnHeader(c, i))));
+        const headers = ( columns.map((c, i) => this.disposables.add(( new ColumnHeader(c, i)))));
         const descriptor = {
             size: headers.reduce((a, b) => a + b.column.weight, 0),
             views: ( headers.map(view => ({ size: view.column.weight, view })))

package/vscode/src/vs/base/browser/ui/toggle/toggle.js

@@ -5,6 +5,8 @@ import { ThemeIcon } from '../../../common/themables.js';
 import { Emitter } from '../../../common/event.js';
 import './toggle.css.js';
 import { $, addDisposableListener, EventType, isActiveElement } from '../../dom.js';
+import { setupCustomHover } from '../iconLabel/iconLabelHover.js';
+import { getDefaultHoverDelegate } from '../hover/hoverDelegate.js';
 const unthemedToggleStyles = {
     inputActiveOptionBorder: '#007ACC00',
     inputActiveOptionForeground: '#FFFFFF',
@@ -74,7 +76,7 @@ class Toggle extends Widget {
             classes.push('checked');
         }
         this.domNode = document.createElement('div');
-        this.domNode.title = this._opts.title;
+        this._hover = this._register(setupCustomHover(getDefaultHoverDelegate('mouse'), this.domNode, this._opts.title));
         this.domNode.classList.add(...classes);
         if (!this._opts.notFocusable) {
             this.domNode.tabIndex = 0;
@@ -143,7 +145,7 @@ class Toggle extends Widget {
         this.domNode.setAttribute('aria-disabled', String(true));
     }
     setTitle(newTitle) {
-        this.domNode.title = newTitle;
+        this._hover.update(newTitle);
         this.domNode.setAttribute('aria-label', newTitle);
     }
 }

package/vscode/src/vs/base/browser/ui/toolbar/toolbar.js

@@ -7,6 +7,7 @@ import { EventMultiplexer } from '../../../common/event.js';
 import { Disposable, DisposableStore } from '../../../common/lifecycle.js';
 import './toolbar.css.js';
 import { localizeWithPath } from '../../../../nls.js';
+import { getDefaultHoverDelegate } from '../hover/hoverDelegate.js';
 class ToolBar extends Disposable {
     constructor(container, contextMenuProvider, options = { orientation: 0  }) {
         super();
@@ -15,6 +16,7 @@ class ToolBar extends Disposable {
         this._onDidChangeDropdownVisibility = this._register(( new EventMultiplexer()));
         this.onDidChangeDropdownVisibility = this._onDidChangeDropdownVisibility.event;
         this.disposables = this._register(( new DisposableStore()));
+        options.hoverDelegate = options.hoverDelegate ?? this._register(getDefaultHoverDelegate('element', true));
         this.options = options;
         this.lookupKeybindings = typeof this.options.getKeyBinding === 'function';
         this.toggleMenuAction = this._register(( new ToggleMenuAction(() => this.toggleMenuActionViewItem?.show(), options.toggleMenuTitle)));
@@ -27,6 +29,7 @@ class ToolBar extends Disposable {
             actionRunner: options.actionRunner,
             allowContextMenu: options.allowContextMenu,
             highlightToggledItems: options.highlightToggledItems,
+            hoverDelegate: options.hoverDelegate,
             actionViewItemProvider: (action, viewItemOptions) => {
                 if (action.id === ToggleMenuAction.ID) {
                     this.toggleMenuActionViewItem = ( new DropdownMenuActionViewItem(action, action.menuActions, contextMenuProvider, {
@@ -37,7 +40,8 @@ class ToolBar extends Disposable {
                         anchorAlignmentProvider: this.options.anchorAlignmentProvider,
                         menuAsChild: !!this.options.renderDropdownAsChildElement,
                         skipTelemetry: this.options.skipTelemetry,
-                        isMenu: true
+                        isMenu: true,
+                        hoverDelegate: this.options.hoverDelegate
                     }));
                     this.toggleMenuActionViewItem.setActionContext(this.actionBar.context);
                     this.disposables.add(this._onDidChangeDropdownVisibility.add(this.toggleMenuActionViewItem.onDidChangeVisibility));
@@ -57,7 +61,8 @@ class ToolBar extends Disposable {
                         classNames: action.class,
                         anchorAlignmentProvider: this.options.anchorAlignmentProvider,
                         menuAsChild: !!this.options.renderDropdownAsChildElement,
-                        skipTelemetry: this.options.skipTelemetry
+                        skipTelemetry: this.options.skipTelemetry,
+                        hoverDelegate: this.options.hoverDelegate
                     }));
                     result.setActionContext(this.actionBar.context);
                     this.submenuActionViewItems.push(result);

package/vscode/src/vs/base/browser/ui/tree/asyncDataTree.js

@@ -590,6 +590,7 @@ class AsyncDataTree {
             if (treeNode.collapsed) {
                 node.hasChildren = !!this.dataSource.hasChildren(node.element);
                 node.stale = true;
+                this.setChildren(node, [], recursive, viewStateContext);
                 return;
             }
         }

package/vscode/src/vs/base/common/actions.js

@@ -158,7 +158,7 @@ function toAction(props) {
         label: props.label,
         class: props.class,
         enabled: props.enabled ?? true,
-        checked: props.checked ?? false,
+        checked: props.checked,
         run: async (...args) => props.run(...args),
         tooltip: props.label
     };

package/vscode/src/vs/base/common/assert.js

@@ -9,7 +9,7 @@ function assertNever(value, message = 'Unreachable') {
 }
 function softAssert(condition) {
     if (!condition) {
-        onUnexpectedError(( new BugIndicatingError('Assertion Failed')));
+        onUnexpectedError(( new BugIndicatingError('Soft Assertion Failed')));
     }
 }
 function assertFn(condition) {