@codingame/monaco-vscode-api 36.2.6 → 37.0.0

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

@@ -1,7 +1,8 @@
 
 import { registerCss } from '../../../../../../../css.js';
-import { createElement, DisposableResizeObserver, isHTMLElement } from '../../dom.js';
+import { createElement, DisposableResizeObserver, isHTMLElement, getWindow, getActiveElement, isAncestor } from '../../dom.js';
 import { ActionsOrientation, ActionBar } from '../actionbar/actionbar.js';
+import { BaseActionViewItem } from '../actionbar/actionViewItems.js';
 import { DropdownMenuActionViewItem } from '../dropdown/dropdownActionViewItem.js';
 import { SubmenuAction, Separator, Action } from '../../../common/actions.js';
 import { Codicon } from '../../../common/codicons.js';
@@ -58,6 +59,8 @@ class ToolBar extends Disposable {
                         actionRunner: this.actionRunner,
                         keybindingProvider: this.options.getKeyBinding,
                         classNames: ThemeIcon.asClassNameArray(options.moreIcon ?? Codicon.toolBarMore),
+                        menuClassName: this.options.dropdownMenuClassName,
+                        closeAnimation: this.options.dropdownMenuCloseAnimation,
                         anchorAlignmentProvider: this.options.anchorAlignmentProvider,
                         menuAsChild: !!this.options.renderDropdownAsChildElement,
                         skipTelemetry: this.options.skipTelemetry,
@@ -82,6 +85,8 @@ class ToolBar extends Disposable {
                         actionRunner: this.actionRunner,
                         keybindingProvider: this.options.getKeyBinding,
                         classNames: action.class,
+                        menuClassName: this.options.dropdownMenuClassName,
+                        closeAnimation: this.options.dropdownMenuCloseAnimation,
                         anchorAlignmentProvider: this.options.anchorAlignmentProvider,
                         menuAsChild: !!this.options.renderDropdownAsChildElement,
                         skipTelemetry: this.options.skipTelemetry,
@@ -122,8 +127,11 @@ class ToolBar extends Disposable {
     getElement() {
         return this.element;
     }
-    focus() {
-        this.actionBar.focus();
+    focus(index) {
+        this.actionBar.focus(index);
+    }
+    setFocusable(focusable) {
+        this.actionBar.setFocusable(focusable);
     }
     getItemsWidth() {
         let itemsWidth = 0;
@@ -138,9 +146,37 @@ class ToolBar extends Disposable {
     getItemWidth(index) {
         return this.actionBar.getWidth(index);
     }
+    getItemElement(index) {
+        const element = this.actionBar.getContainer().firstElementChild?.children.item(index);
+        return isHTMLElement(element) ? element : undefined;
+    }
+    getItemViewItem(index) {
+        return this.actionBar.viewItems[index];
+    }
+    getUnshrunkItemWidth(index) {
+        const actionItem = this.actionBar.getContainer().firstElementChild?.children.item(index);
+        if (!isHTMLElement(actionItem)) {
+            return this.actionBar.getWidth(index);
+        }
+        const previousFlexShrink = actionItem.style.flexShrink;
+        const previousMinWidth = actionItem.style.minWidth;
+        try {
+            actionItem.style.flexShrink = "0";
+            if (!previousMinWidth) {
+                actionItem.style.minWidth = "0";
+            }
+            return this.actionBar.getWidth(index);
+        } finally {
+            actionItem.style.flexShrink = previousFlexShrink;
+            actionItem.style.minWidth = previousMinWidth;
+        }
+    }
     getItemsLength() {
         return this.actionBar.length();
     }
+    hasOverflow() {
+        return this.actionBar.hasAction(this.toggleMenuAction);
+    }
     setAriaLabel(label) {
         this.actionBar.setAriaLabel(label);
     }
@@ -174,15 +210,17 @@ class ToolBar extends Disposable {
         this.applyResponsiveActionMinWidths();
         if (this.options.responsiveBehavior?.enabled) {
             this.hiddenActions.length = 0;
-            if (this.options.responsiveBehavior?.minItems !== undefined) {
+            if (this.options.responsiveBehavior.minItems !== undefined) {
                 const itemCount = this.options.responsiveBehavior.minItems;
-                const primaryActionsMinWidth = this.originalPrimaryActions.slice(0, itemCount).reduce((total, action) => total + this.getActionMinWidth(action), 0);
+                const requiredActions = this.overflowFromStart ? this.originalPrimaryActions.slice(Math.max(0, this.originalPrimaryActions.length - itemCount)) : this.originalPrimaryActions.slice(0, itemCount);
+                const primaryActionsMinWidth = requiredActions.reduce((total, action) => total + this.getActionMinWidth(action), 0);
                 let overflowWidth = 0;
                 if (this.originalSecondaryActions.length > 0 || itemCount < this.originalPrimaryActions.length) {
                     overflowWidth = ACTION_MIN_WIDTH + ACTION_PADDING;
                 }
-                this.container.style.minWidth = `${primaryActionsMinWidth + overflowWidth}px`;
-                this.element.style.minWidth = `${primaryActionsMinWidth + overflowWidth}px`;
+                const separatorWidth = this.options.trailingSeparator && !this.actionBar.isEmpty() ? this.actionBar.getWidth(this.actionBar.length() - 1) + ACTION_PADDING : 0;
+                this.container.style.minWidth = `${primaryActionsMinWidth + overflowWidth + separatorWidth}px`;
+                this.element.style.minWidth = `${primaryActionsMinWidth + overflowWidth + separatorWidth}px`;
             } else {
                 const minimumActionWidth = this.originalPrimaryActions.length > 0 ? this.getActionMinWidth(this.originalPrimaryActions[0]) : ACTION_MIN_WIDTH + ACTION_PADDING;
                 this.container.style.minWidth = `${minimumActionWidth}px`;
@@ -194,6 +232,9 @@ class ToolBar extends Disposable {
     isEmpty() {
         return this.actionBar.isEmpty();
     }
+    get overflowFromStart() {
+        return this.options.responsiveBehavior?.kind === "all" && this.options.responsiveBehavior.overflowFrom === "start";
+    }
     getKeybindingLabel(action) {
         const key = this.options.getKeyBinding?.(action);
         return key?.getLabel() ?? undefined;
@@ -237,7 +278,10 @@ class ToolBar extends Disposable {
                 continue;
             }
             const action = this.actionBar.getAction(i);
-            const minWidth = `${this.getConfiguredActionMinWidth(action)}px`;
+            const minWidth = action instanceof Separator ? "0px" : `${this.getConfiguredActionMinWidth(action)}px`;
+            if (action instanceof Separator) {
+                actionItem.style.flexShrink = "0";
+            }
             if (actionItem.style.minWidth !== minWidth) {
                 actionItem.style.minWidth = minWidth;
             }
@@ -250,90 +294,228 @@ class ToolBar extends Disposable {
         this.applyResponsiveActionMinWidths();
         const parsedMinWidth = parseInt(this.element.style.minWidth);
         containerWidth = Math.max(containerWidth, Number.isNaN(parsedMinWidth) ? 0 : parsedMinWidth);
-        const actionBarWidth = actualWidth => {
+        const isActionItemVisible = index => {
+            const element = this.getItemElement(index);
+            return !element || getWindow(element).getComputedStyle(element).display !== "none";
+        };
+        const getVisiblePrimaryActionIndexes = () => {
+            const indexes = [];
+            for (let index = 0; index < this.actionBar.length(); index++) {
+                const action = this.actionBar.getAction(index);
+                if (action && this.originalPrimaryActions.includes(action) && isActionItemVisible(index)) {
+                    indexes.push(index);
+                }
+            }
+            return indexes;
+        };
+        const getVisiblePrimaryActionCount = () => getVisiblePrimaryActionIndexes().reduce(
+            (count, index) => count + (this.actionBar.getAction(index) instanceof Separator ? 0 : 1),
+            0
+        );
+        const getActionsToHide = () => {
+            const indexes = getVisiblePrimaryActionIndexes();
+            const actionIndex = (this.overflowFromStart ? indexes : indexes.slice().reverse()).find(index => !(this.actionBar.getAction(index) instanceof Separator));
+            if (actionIndex === undefined) {
+                return [];
+            }
+            let startIndex = actionIndex;
+            let endIndex = actionIndex;
+            const step = this.overflowFromStart ? 1 : -1;
+            for (let index = actionIndex + step; index >= 0 && index < this.actionBar.length(); index += step) {
+                const action = this.actionBar.getAction(index);
+                if (!(action instanceof Separator) || !this.originalPrimaryActions.includes(action) || !isActionItemVisible(index)) {
+                    break;
+                }
+                startIndex = Math.min(startIndex, index);
+                endIndex = Math.max(endIndex, index);
+            }
+            const actions = [];
+            for (let index = startIndex; index <= endIndex; index++) {
+                const action = this.actionBar.getAction(index);
+                if (action) {
+                    actions.push(action);
+                }
+            }
+            return actions;
+        };
+        const getActionsToRestore = () => {
+            if (this.hiddenActions.length === 0) {
+                return [];
+            }
+            if (this.overflowFromStart) {
+                let startIndex = this.hiddenActions.length - 1;
+                while (startIndex > 0 && this.hiddenActions[startIndex] instanceof Separator) {
+                    startIndex--;
+                }
+                return this.hiddenActions.slice(startIndex);
+            }
+            let endIndex = 0;
+            while (endIndex < this.hiddenActions.length - 1 && this.hiddenActions[endIndex] instanceof Separator) {
+                endIndex++;
+            }
+            return this.hiddenActions.slice(0, endIndex + 1);
+        };
+        const actionBarMinimumWidth = () => {
             if (this.options.responsiveBehavior?.kind === "last") {
                 const hasToggleMenuAction = this.actionBar.hasAction(this.toggleMenuAction);
-                const primaryActionsCount = hasToggleMenuAction ? this.actionBar.length() - 1 : this.actionBar.length();
-                if (primaryActionsCount === 0) {
+                const primaryActionIndexes = getVisiblePrimaryActionIndexes();
+                if (primaryActionIndexes.length === 0) {
                     return hasToggleMenuAction ? ACTION_MIN_WIDTH + ACTION_PADDING : 0;
                 }
                 let itemsWidth = 0;
-                for (let i = 0; i < primaryActionsCount - 1; i++) {
-                    itemsWidth += this.actionBar.getWidth(i) + ACTION_PADDING;
+                for (const index of primaryActionIndexes.slice(0, -1)) {
+                    itemsWidth += this.actionBar.getWidth(index) + ACTION_PADDING;
                 }
-                const action = this.actionBar.getAction(primaryActionsCount - 1);
-                itemsWidth += actualWidth ? this.actionBar.getWidth(primaryActionsCount - 1) : this.getActionMinWidth(action);
+                const action = this.actionBar.getAction(primaryActionIndexes.at(-1));
+                itemsWidth += this.getActionMinWidth(action);
                 itemsWidth += hasToggleMenuAction ? ACTION_MIN_WIDTH + ACTION_PADDING : 0;
                 return itemsWidth;
             } else {
                 let itemsWidth = 0;
                 for (let i = 0; i < this.actionBar.length(); i++) {
-                    itemsWidth += actualWidth ? this.actionBar.getWidth(i) : this.getActionMinWidth(this.actionBar.getAction(i));
+                    if (isActionItemVisible(i)) {
+                        const action = this.actionBar.getAction(i);
+                        itemsWidth += action instanceof Separator ? this.actionBar.getWidth(i) + ACTION_PADDING : this.getActionMinWidth(action);
+                    }
                 }
                 return itemsWidth;
             }
         };
-        const minimumWidth = actionBarWidth(false);
+        const projectedActionBarMinimumWidth = (actionsToAdd, keepToggleMenuAction) => {
+            let itemsWidth = actionsToAdd.reduce((width, action) => width + this.getActionMinWidth(action), 0);
+            if (this.options.responsiveBehavior?.kind === "last") {
+                const primaryActionIndexes = getVisiblePrimaryActionIndexes();
+                for (const [position, index] of primaryActionIndexes.entries()) {
+                    const itemWidth = position === primaryActionIndexes.length - 1 ? this.getUnshrunkItemWidth(index) : this.actionBar.getWidth(index);
+                    itemsWidth += itemWidth + ACTION_PADDING;
+                }
+            } else {
+                for (let i = 0; i < this.actionBar.length(); i++) {
+                    const action = this.actionBar.getAction(i);
+                    if (action && action !== this.toggleMenuAction && isActionItemVisible(i)) {
+                        itemsWidth += action instanceof Separator ? this.actionBar.getWidth(i) + ACTION_PADDING : this.getActionMinWidth(action);
+                    }
+                }
+            }
+            if (keepToggleMenuAction) {
+                itemsWidth += ACTION_MIN_WIDTH + ACTION_PADDING;
+            }
+            return itemsWidth;
+        };
+        let minimumWidth = actionBarMinimumWidth();
         if (minimumWidth <= containerWidth && this.hiddenActions.length === 0) {
             return;
         }
+        const focusedElement = getActiveElement();
+        const focusedAction = isHTMLElement(focusedElement) ? this.actionBar.getAction(focusedElement) : undefined;
+        const previousHiddenActionsCount = this.hiddenActions.length;
         if (minimumWidth > containerWidth) {
+            const allowOverflow = this.options.responsiveBehavior?.allowOverflow;
+            if (allowOverflow === false || (typeof allowOverflow === "function" && !allowOverflow())) {
+                return;
+            }
             if (this.options.responsiveBehavior?.minItems !== undefined) {
-                const primaryActionsCount = this.actionBar.hasAction(this.toggleMenuAction) ? this.actionBar.length() - 1 : this.actionBar.length();
+                const primaryActionsCount = getVisiblePrimaryActionCount();
                 if (primaryActionsCount <= this.options.responsiveBehavior.minItems) {
                     return;
                 }
             }
-            while (actionBarWidth(false) > containerWidth && this.actionBar.length() > 0) {
-                const index = this.originalPrimaryActions.length - this.hiddenActions.length - 1;
-                if (index < 0) {
+            while (minimumWidth > containerWidth && this.actionBar.length() > 0) {
+                if (this.options.responsiveBehavior?.minItems !== undefined && getVisiblePrimaryActionCount() <= this.options.responsiveBehavior.minItems) {
                     break;
                 }
-                const action = this.originalPrimaryActions[index];
-                const size = Math.min(this.getActionMinWidth(action), this.getItemWidth(index));
-                this.hiddenActions.unshift({
-                    action,
-                    size
-                });
-                this.actionBar.pull(index);
-                if (this.originalSecondaryActions.length === 0 && this.hiddenActions.length === 1) {
+                const actionsToHide = getActionsToHide();
+                if (actionsToHide.length === 0) {
+                    break;
+                }
+                for (const action of actionsToHide) {
+                    this.hiddenActions.push(action);
+                    const index = this.actionBar.viewItems.findIndex(item => item.action === action);
+                    if (index !== -1) {
+                        this.actionBar.pull(index);
+                    }
+                }
+                this.hiddenActions.sort(
+                    (a, b) => this.originalPrimaryActions.indexOf(a) - this.originalPrimaryActions.indexOf(b)
+                );
+                if (this.originalSecondaryActions.length === 0 && !this.actionBar.hasAction(this.toggleMenuAction)) {
                     this.actionBar.push(this.toggleMenuAction, {
                         icon: this.options.icon ?? true,
                         label: this.options.label ?? false,
-                        keybinding: this.getKeybindingLabel(this.toggleMenuAction)
+                        keybinding: this.getKeybindingLabel(this.toggleMenuAction),
+                        index: this.options.trailingSeparator ? this.actionBar.length() - 1 : undefined
                     });
                     this.updateOverflowClassName();
                 }
                 this.applyResponsiveActionMinWidths();
+                minimumWidth = actionBarMinimumWidth();
             }
         } else {
             while (this.hiddenActions.length > 0) {
-                const entry = this.hiddenActions.shift();
-                if (actionBarWidth(true) + entry.size > containerWidth) {
-                    this.hiddenActions.unshift(entry);
+                const actionsToRestore = getActionsToRestore();
+                const keepToggleMenuAction = this.originalSecondaryActions.length > 0 || this.hiddenActions.length > actionsToRestore.length;
+                if (projectedActionBarMinimumWidth(actionsToRestore, keepToggleMenuAction) > containerWidth) {
                     break;
                 }
-                this.actionBar.push(entry.action, {
-                    icon: this.options.icon ?? true,
-                    label: this.options.label ?? false,
-                    keybinding: this.getKeybindingLabel(entry.action),
-                    index: this.originalPrimaryActions.length - this.hiddenActions.length - 1
-                });
+                for (const action of actionsToRestore) {
+                    this.hiddenActions.splice(this.hiddenActions.indexOf(action), 1);
+                    const visibleActions = ( new Set(( this.actionBar.viewItems.map(item => item.action))));
+                    this.actionBar.push(action, {
+                        icon: this.options.icon ?? true,
+                        label: this.options.label ?? false,
+                        keybinding: this.getKeybindingLabel(action),
+                        index: this.originalPrimaryActions.slice(0, this.originalPrimaryActions.indexOf(action)).reduce((index, precedingAction) => index + (( visibleActions.has(precedingAction)) ? 1 : 0), 0)
+                    });
+                }
                 if (this.originalSecondaryActions.length === 0 && this.hiddenActions.length === 0) {
                     this.toggleMenuAction.menuActions = [];
-                    this.actionBar.pull(this.actionBar.length() - 1);
+                    this.actionBar.pull(
+                        this.actionBar.viewItems.findIndex(item => item.action === this.toggleMenuAction)
+                    );
                     this.updateOverflowClassName();
                 }
                 this.applyResponsiveActionMinWidths();
             }
         }
-        const hiddenActions = ( this.hiddenActions.map(entry => entry.action));
+        const hiddenActions = ( this.hiddenActions.map(
+            action => this.options.responsiveBehavior?.getOverflowAction?.(action, () => this.toggleMenuActionViewItem?.element) ?? action
+        ));
         if (this.originalSecondaryActions.length > 0 || hiddenActions.length > 0) {
             const secondaryActions = this.originalSecondaryActions.slice(0);
-            this.toggleMenuAction.menuActions = Separator.join(hiddenActions, secondaryActions);
+            this.toggleMenuAction.menuActions = Separator.clean(Separator.join(hiddenActions, secondaryActions));
         }
         this.updateOverflowClassName();
         this.applyResponsiveActionMinWidths();
+        if (this.hiddenActions.length === previousHiddenActionsCount) {
+            return;
+        }
+        for (let i = 0; i < this.actionBar.length(); i++) {
+            const viewItem = this.getItemViewItem(i);
+            if (viewItem instanceof BaseActionViewItem) {
+                viewItem.setFocusable(false);
+            }
+        }
+        if (focusedAction) {
+            const index = Array.from({
+                length: this.actionBar.length()
+            }, (_, index) => index).find(index => this.actionBar.getAction(index) === focusedAction);
+            const overflowIndex = Array.from({
+                length: this.actionBar.length()
+            }, (_, index) => index).find(index => this.actionBar.getAction(index) === this.toggleMenuAction);
+            this.actionBar.focus(index ?? overflowIndex);
+            if (index !== undefined && isHTMLElement(focusedElement) && isAncestor(focusedElement, this.getItemElement(index) ?? null) && getActiveElement() !== focusedElement) {
+                const viewItem = this.getItemViewItem(index);
+                if (viewItem instanceof BaseActionViewItem) {
+                    viewItem.setFocusable(false);
+                }
+                focusedElement.tabIndex = 0;
+                focusedElement.focus({
+                    preventScroll: true
+                });
+            }
+        } else {
+            this.actionBar.setFocusable(true);
+        }
     }
     updateOverflowClassName() {
         this.actionBar.domNode.classList.toggle("has-overflow", this.actionBar.hasAction(this.toggleMenuAction));

package/vscode/src/vs/base/browser/ui/tree/abstractTree.d.ts

@@ -122,7 +122,7 @@ export declare class FindFilter<T> implements IFindFilter<T>, IDisposable {
     private _lowercasePattern;
     private readonly disposables;
     set pattern(pattern: string);
-    constructor(_keyboardNavigationLabelProvider: IKeyboardNavigationLabelProvider<T>, _filter?: ITreeFilter<T, FuzzyScore> | undefined, _defaultFindVisibility?: (TreeVisibility | ((node: T) => TreeVisibility)) | undefined);
+    constructor(_keyboardNavigationLabelProvider: IKeyboardNavigationLabelProvider<T>, _filter?: ITreeFilter<T, FuzzyScore> | undefined, _defaultFindVisibility?: TreeVisibility | ((node: T) => TreeVisibility) | undefined);
     filter(element: T, parentVisibility: TreeVisibility): TreeFilterResult<FuzzyScore | LabelFuzzyScore>;
     reset(): void;
     dispose(): void;
@@ -229,6 +229,15 @@ export interface StickyScrollNode<T, TFilterData> {
     readonly endIndex: number;
     readonly height: number;
     readonly position: number;
+    readonly sourceNodeEnd: number;
+    readonly sourceNodePartiallyVisible: boolean;
+    readonly hasExplicitHeight: boolean;
+}
+export interface IStickyScrollNodeSourceRange {
+    readonly start: number;
+    readonly end: number;
+    readonly stickyNodeHeight?: number;
+    readonly estimated?: boolean;
 }
 export interface IStickyScrollDelegate<T, TFilterData> {
     constrainStickyScrollNodes(stickyNodes: StickyScrollNode<T, TFilterData>[], stickyScrollMaxItemCount: number, maxWidgetHeight: number): StickyScrollNode<T, TFilterData>[];
@@ -245,6 +254,7 @@ declare class StickyScrollController<T, TFilterData, TRef> extends Disposable {
     private readonly maxWidgetViewRatio;
     private readonly _widget;
     private paddingTop;
+    get domNode(): HTMLElement;
     constructor(tree: AbstractTree<T, TFilterData, TRef>, model: ITreeModel<T, TFilterData, TRef>, view: List<ITreeNode<T, TFilterData>>, renderers: TreeRenderer<T, TFilterData, TRef, unknown>[], treeDelegate: IListVirtualDelegate<ITreeNode<T, TFilterData>>, options?: IAbstractTreeOptions<T, TFilterData>);
     get height(): number;
     get count(): number;
@@ -254,7 +264,10 @@ declare class StickyScrollController<T, TFilterData, TRef> extends Disposable {
     private findStickyState;
     private getNextVisibleNode;
     private getNextStickyNode;
-    private nodeTopAlignsWithStickyNodesBottom;
+    private getStickyScrollNodeSourceRange;
+    private getStickyScrollNodeHeight;
+    private getNodeHeight;
+    private clampNodeHeight;
     private createStickyScrollNode;
     private getAncestorUnderPrevious;
     private calculateStickyNodePosition;
@@ -268,12 +281,15 @@ declare class StickyScrollController<T, TFilterData, TRef> extends Disposable {
     domFocus(): void;
     focusedLast(): boolean;
     updateOptions(optionsUpdate?: IAbstractTreeOptionsUpdate<T>): void;
+    refresh(): void;
+    rerender(): void;
     validateStickySettings(options: IAbstractTreeOptionsUpdate<T>): {
         stickyScrollMaxItemCount: number;
     };
 }
 export interface IAbstractTreeOptionsUpdate<T> extends ITreeRendererOptions<T> {
     readonly defaultIndent?: number;
+    readonly paddingBottom?: number;
     readonly multipleSelectionSupport?: boolean;
     readonly typeNavigationEnabled?: boolean;
     readonly typeNavigationMode?: TypeNavigationMode;
@@ -289,6 +305,7 @@ export interface IAbstractTreeOptionsUpdate<T> extends ITreeRendererOptions<T> {
     readonly expandOnlyOnTwistieClick?: boolean | ((e: T) => boolean);
     readonly enableStickyScroll?: boolean;
     readonly stickyScrollMaxItemCount?: number;
+    readonly stickyScrollMaxNodeHeight?: number;
     readonly paddingTop?: number;
 }
 export interface IAbstractTreeOptions<T, TFilterData = void> extends IAbstractTreeOptionsUpdate<T>, IListOptions<T> {
@@ -303,6 +320,7 @@ export interface IAbstractTreeOptions<T, TFilterData = void> extends IAbstractTr
     readonly findWidgetContainer?: HTMLElement;
     readonly defaultFindVisibility?: TreeVisibility | ((e: T) => TreeVisibility);
     readonly stickyScrollDelegate?: IStickyScrollDelegate<T, TFilterData>;
+    readonly stickyScrollNodeSourceRangeProvider?: (element: T, defaultRange: IStickyScrollNodeSourceRange) => IStickyScrollNodeSourceRange | undefined;
     readonly disableExpandOnSpacebar?: boolean;
 }
 /**
@@ -369,6 +387,8 @@ export declare abstract class AbstractTree<T, TFilterData, TRef> implements IDis
     private stickyScrollController?;
     private styleElement;
     protected readonly disposables: DisposableStore;
+    private readonly _onDidChangeStickyScrollDomNode;
+    readonly onDidChangeStickyScrollDomNode: Event<HTMLElement | undefined>;
     get onDidScroll(): Event<ScrollEvent>;
     get onDidChangeFocus(): Event<ITreeEvent<T>>;
     get onDidChangeSelection(): Event<ITreeEvent<T>>;
@@ -408,6 +428,7 @@ export declare abstract class AbstractTree<T, TFilterData, TRef> implements IDis
     private readonly _onDidUpdateOptions;
     readonly onDidUpdateOptions: Event<IAbstractTreeOptions<T, TFilterData>>;
     get onDidDispose(): Event<void>;
+    get stickyScrollDomNode(): HTMLElement | undefined;
     constructor(_user: string, container: HTMLElement, delegate: IListVirtualDelegate<T>, renderers: ITreeRenderer<T, TFilterData, unknown>[], _options?: IAbstractTreeOptions<T, TFilterData>);
     updateOptions(optionsUpdate?: IAbstractTreeOptionsUpdate<T>): void;
     get options(): IAbstractTreeOptions<T, TFilterData>;
@@ -424,6 +445,8 @@ export declare abstract class AbstractTree<T, TFilterData, TRef> implements IDis
     set scrollLeft(scrollLeft: number);
     get scrollHeight(): number;
     get renderHeight(): number;
+    refreshStickyScroll(): void;
+    rerenderStickyScroll(): void;
     get firstVisibleElement(): T | undefined;
     get lastVisibleElement(): T;
     get ariaLabel(): string;
@@ -470,6 +493,13 @@ export declare abstract class AbstractTree<T, TFilterData, TRef> implements IDis
      * Returns `null` if the element isn't *entirely* in the visible viewport.
      */
     getRelativeTop(location: TRef): number | null;
+    /**
+     * Returns the absolute top offset of an element in the tree's scroll/content
+     * space, or `undefined` when the element is not in the tree. Unlike
+     * {@link getRelativeTop}, this reads the layout height model, so it also
+     * resolves elements outside the rendered viewport.
+     */
+    getElementTop(location: TRef): number | undefined;
     getViewState(identityProvider?: IIdentityProvider<T> | undefined): AbstractTreeViewState;
     private onLeftArrow;
     private onRightArrow;