@codingame/monaco-vscode-api 22.1.9 → 23.0.0

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

@@ -11,3 +11,10 @@
 	display: inline-block;
 	padding: 0;
 }
+
+.monaco-toolbar.responsive {
+	.monaco-action-bar > .actions-container > .action-item {
+		flex-shrink: 1;
+		min-width: 20px;
+	}
+}

package/vscode/src/vs/base/browser/ui/toolbar/toolbar.d.ts

@@ -19,6 +19,7 @@ export interface IToolBarOptions {
     allowContextMenu?: boolean;
     skipTelemetry?: boolean;
     hoverDelegate?: IHoverDelegate;
+    trailingSeparator?: boolean;
     /**
      * If true, toggled primary items are highlighted with a background color.
      */
@@ -31,6 +32,10 @@ export interface IToolBarOptions {
      * Render action with label (default: `false`)
      */
     label?: boolean;
+    /**
+     * Hiding actions that are not visible
+     */
+    responsive?: boolean;
 }
 /**
  * A widget that combines an action bar for primary actions and a dropdown for secondary actions.
@@ -45,6 +50,9 @@ export declare class ToolBar extends Disposable {
     private readonly element;
     private _onDidChangeDropdownVisibility;
     get onDidChangeDropdownVisibility(): import("../../../common/event.js").Event<boolean>;
+    private originalPrimaryActions;
+    private originalSecondaryActions;
+    private hiddenActions;
     private readonly disposables;
     constructor(container: HTMLElement, contextMenuProvider: IContextMenuProvider, options?: IToolBarOptions);
     set actionRunner(actionRunner: IActionRunner);
@@ -60,6 +68,8 @@ export declare class ToolBar extends Disposable {
     setActions(primaryActions: ReadonlyArray<IAction>, secondaryActions?: ReadonlyArray<IAction>): void;
     isEmpty(): boolean;
     private getKeybindingLabel;
+    private getItemsWidthResponsive;
+    private setToolbarMaxWidth;
     private clear;
     dispose(): void;
 }

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

@@ -2,17 +2,18 @@
 import { registerCss } from '@codingame/monaco-vscode-api/css';
 import { ActionsOrientation, ActionBar } from '../actionbar/actionbar.js';
 import { DropdownMenuActionViewItem } from '../dropdown/dropdownActionViewItem.js';
-import { SubmenuAction, Action } from '../../../common/actions.js';
+import { SubmenuAction, Separator, Action } from '../../../common/actions.js';
 import { Codicon } from '../../../common/codicons.js';
 import { ThemeIcon } from '../../../common/themables.js';
 import { EventMultiplexer } from '../../../common/event.js';
-import { Disposable, DisposableStore } from '../../../common/lifecycle.js';
+import { Disposable, DisposableStore, toDisposable } from '../../../common/lifecycle.js';
 import * as toolbar from './toolbar.css';
 import { localize } from '../../../../nls.js';
 import { createInstantHoverDelegate } from '../hover/hoverDelegateFactory.js';
 import { createElement } from '../../dom.js';
 
 registerCss(toolbar);
+const ACTION_MIN_WIDTH = 24;
 class ToolBar extends Disposable {
     get onDidChangeDropdownVisibility() { return this._onDidChangeDropdownVisibility.event; }
     constructor(container, contextMenuProvider, options = { orientation: ActionsOrientation.HORIZONTAL }) {
@@ -20,6 +21,9 @@ class ToolBar extends Disposable {
         this.submenuActionViewItems = [];
         this.hasSecondaryActions = false;
         this._onDidChangeDropdownVisibility = this._register(( new EventMultiplexer()));
+        this.originalPrimaryActions = [];
+        this.originalSecondaryActions = [];
+        this.hiddenActions = [];
         this.disposables = this._register(( new DisposableStore()));
         options.hoverDelegate = options.hoverDelegate ?? this._register(createInstantHoverDelegate());
         this.options = options;
@@ -36,17 +40,22 @@ class ToolBar extends Disposable {
             hoverDelegate: options.hoverDelegate,
             actionViewItemProvider: (action, viewItemOptions) => {
                 if (action.id === ToggleMenuAction.ID) {
-                    this.toggleMenuActionViewItem = ( new DropdownMenuActionViewItem(action, action.menuActions, contextMenuProvider, {
-                        actionViewItemProvider: this.options.actionViewItemProvider,
-                        actionRunner: this.actionRunner,
-                        keybindingProvider: this.options.getKeyBinding,
-                        classNames: ThemeIcon.asClassNameArray(options.moreIcon ?? Codicon.toolBarMore),
-                        anchorAlignmentProvider: this.options.anchorAlignmentProvider,
-                        menuAsChild: !!this.options.renderDropdownAsChildElement,
-                        skipTelemetry: this.options.skipTelemetry,
-                        isMenu: true,
-                        hoverDelegate: this.options.hoverDelegate
-                    }));
+                    this.toggleMenuActionViewItem = ( new DropdownMenuActionViewItem(
+                        action,
+                        { getActions: () => this.toggleMenuAction.menuActions },
+                        contextMenuProvider,
+                        {
+                            actionViewItemProvider: this.options.actionViewItemProvider,
+                            actionRunner: this.actionRunner,
+                            keybindingProvider: this.options.getKeyBinding,
+                            classNames: ThemeIcon.asClassNameArray(options.moreIcon ?? Codicon.toolBarMore),
+                            anchorAlignmentProvider: this.options.anchorAlignmentProvider,
+                            menuAsChild: !!this.options.renderDropdownAsChildElement,
+                            skipTelemetry: this.options.skipTelemetry,
+                            isMenu: true,
+                            hoverDelegate: this.options.hoverDelegate
+                        }
+                    ));
                     this.toggleMenuActionViewItem.setActionContext(this.actionBar.context);
                     this.disposables.add(this._onDidChangeDropdownVisibility.add(this.toggleMenuActionViewItem.onDidChangeVisibility));
                     return this.toggleMenuActionViewItem;
@@ -76,6 +85,14 @@ class ToolBar extends Disposable {
                 return undefined;
             }
         })));
+        if (this.options.responsive) {
+            this.element.classList.add('responsive');
+            const observer = ( new ResizeObserver(() => {
+                this.setToolbarMaxWidth(this.element.getBoundingClientRect().width);
+            }));
+            observer.observe(this.element);
+            this._store.add(toDisposable(() => observer.disconnect()));
+        }
     }
     set actionRunner(actionRunner) {
         this.actionBar.actionRunner = actionRunner;
@@ -117,15 +134,24 @@ class ToolBar extends Disposable {
     }
     setActions(primaryActions, secondaryActions) {
         this.clear();
+        this.originalPrimaryActions = primaryActions ? primaryActions.slice(0) : [];
+        this.originalSecondaryActions = secondaryActions ? secondaryActions.slice(0) : [];
         const primaryActionsToSet = primaryActions ? primaryActions.slice(0) : [];
         this.hasSecondaryActions = !!(secondaryActions && secondaryActions.length > 0);
         if (this.hasSecondaryActions && secondaryActions) {
             this.toggleMenuAction.menuActions = secondaryActions.slice(0);
             primaryActionsToSet.push(this.toggleMenuAction);
         }
+        if (primaryActionsToSet.length > 0 && this.options.trailingSeparator) {
+            primaryActionsToSet.push(( new Separator()));
+        }
         primaryActionsToSet.forEach(action => {
             this.actionBar.push(action, { icon: this.options.icon ?? true, label: this.options.label ?? false, keybinding: this.getKeybindingLabel(action) });
         });
+        if (this.options.responsive) {
+            this.hiddenActions.length = 0;
+            this.setToolbarMaxWidth(this.element.getBoundingClientRect().width);
+        }
     }
     isEmpty() {
         return this.actionBar.isEmpty();
@@ -134,6 +160,58 @@ class ToolBar extends Disposable {
         const key = this.options.getKeyBinding?.(action);
         return key?.getLabel() ?? undefined;
     }
+    getItemsWidthResponsive() {
+        return this.actionBar.length() * ACTION_MIN_WIDTH;
+    }
+    setToolbarMaxWidth(maxWidth) {
+        if (this.actionBar.isEmpty() ||
+            (this.getItemsWidthResponsive() <= maxWidth && this.hiddenActions.length === 0)) {
+            return;
+        }
+        if (this.getItemsWidthResponsive() > maxWidth) {
+            while (this.getItemsWidthResponsive() > maxWidth && this.actionBar.length() > 0) {
+                const index = this.originalPrimaryActions.length - this.hiddenActions.length - 1;
+                if (index < 0) {
+                    break;
+                }
+                const size = Math.min(ACTION_MIN_WIDTH, this.getItemWidth(index));
+                const action = this.originalPrimaryActions[index];
+                this.hiddenActions.unshift({ action, size });
+                this.actionBar.pull(index);
+                if (this.originalSecondaryActions.length === 0 && this.hiddenActions.length === 1) {
+                    this.actionBar.push(this.toggleMenuAction, {
+                        icon: this.options.icon ?? true,
+                        label: this.options.label ?? false,
+                        keybinding: this.getKeybindingLabel(this.toggleMenuAction),
+                    });
+                }
+            }
+        }
+        else {
+            while (this.hiddenActions.length > 0) {
+                const entry = this.hiddenActions.shift();
+                if (this.getItemsWidthResponsive() + entry.size > maxWidth) {
+                    this.hiddenActions.unshift(entry);
+                    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
+                });
+                if (this.originalSecondaryActions.length === 0 && this.hiddenActions.length === 1) {
+                    this.toggleMenuAction.menuActions = [];
+                    this.actionBar.pull(this.actionBar.length() - 1);
+                }
+            }
+        }
+        const hiddenActions = ( this.hiddenActions.map(entry => entry.action));
+        if (this.originalSecondaryActions.length > 0 || hiddenActions.length > 0) {
+            const secondaryActions = this.originalSecondaryActions.slice(0);
+            this.toggleMenuAction.menuActions = Separator.join(hiddenActions, secondaryActions);
+        }
+    }
     clear() {
         this.submenuActionViewItems = [];
         this.disposables.clear();

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

@@ -170,7 +170,7 @@ export interface IFindControllerOptions extends IAbstractFindControllerOptions {
     defaultFindMatchType?: TreeFindMatchType;
 }
 export declare abstract class AbstractFindController<T, TFilterData> implements IDisposable {
-    protected tree: AbstractTree<T, TFilterData, any>;
+    protected tree: AbstractTree<T, TFilterData, unknown>;
     protected filter: IFindFilter<T>;
     protected readonly contextViewProvider: IContextViewProvider;
     protected readonly options: IAbstractFindControllerOptions;
@@ -189,7 +189,7 @@ export declare abstract class AbstractFindController<T, TFilterData> implements
     readonly onDidChangeOpenState: Event<boolean>;
     private readonly enabledDisposables;
     protected readonly disposables: DisposableStore;
-    constructor(tree: AbstractTree<T, TFilterData, any>, filter: IFindFilter<T>, contextViewProvider: IContextViewProvider, options?: IAbstractFindControllerOptions);
+    constructor(tree: AbstractTree<T, TFilterData, unknown>, filter: IFindFilter<T>, contextViewProvider: IContextViewProvider, options?: IAbstractFindControllerOptions);
     isOpened(): boolean;
     open(): void;
     close(): void;
@@ -211,7 +211,7 @@ export declare class FindController<T, TFilterData> extends AbstractFindControll
     readonly onDidChangeMode: Event<TreeFindMode>;
     private readonly _onDidChangeMatchType;
     readonly onDidChangeMatchType: Event<TreeFindMatchType>;
-    constructor(tree: AbstractTree<T, TFilterData, any>, filter: FindFilter<T>, contextViewProvider: IContextViewProvider, options?: IFindControllerOptions);
+    constructor(tree: AbstractTree<T, TFilterData, unknown>, filter: FindFilter<T>, contextViewProvider: IContextViewProvider, options?: IFindControllerOptions);
     updateOptions(optionsUpdate?: IAbstractTreeOptionsUpdate): void;
     protected applyPattern(pattern: string): void;
     shouldAllowFocus(node: ITreeNode<T, TFilterData>): boolean;
@@ -240,7 +240,7 @@ declare class StickyScrollController<T, TFilterData, TRef> extends Disposable {
     private readonly maxWidgetViewRatio;
     private readonly _widget;
     private paddingTop;
-    constructor(tree: AbstractTree<T, TFilterData, TRef>, model: ITreeModel<T, TFilterData, TRef>, view: List<ITreeNode<T, TFilterData>>, renderers: TreeRenderer<T, TFilterData, TRef, any>[], treeDelegate: IListVirtualDelegate<ITreeNode<T, TFilterData>>, options?: IAbstractTreeOptions<T, TFilterData>);
+    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;
     getNode(node: ITreeNode<T, TFilterData>): StickyScrollNode<T, TFilterData> | undefined;
@@ -295,7 +295,7 @@ export interface IAbstractTreeOptions<T, TFilterData = void> extends IAbstractTr
     readonly findWidgetEnabled?: boolean;
     readonly findWidgetStyles?: IFindWidgetStyles;
     readonly defaultFindVisibility?: TreeVisibility | ((e: T) => TreeVisibility);
-    readonly stickyScrollDelegate?: IStickyScrollDelegate<any, TFilterData>;
+    readonly stickyScrollDelegate?: IStickyScrollDelegate<T, TFilterData>;
     readonly disableExpandOnSpacebar?: boolean;
 }
 /**
@@ -311,13 +311,13 @@ declare class Trait<T> {
     readonly onDidChange: Event<ITreeEvent<T>>;
     private _nodeSet;
     private get nodeSet();
-    constructor(getFirstViewElementWithTrait: () => ITreeNode<T, any> | undefined, identityProvider?: IIdentityProvider<T> | undefined);
-    set(nodes: ITreeNode<T, any>[], browserEvent?: UIEvent): void;
+    constructor(getFirstViewElementWithTrait: () => ITreeNode<T, unknown> | undefined, identityProvider?: IIdentityProvider<T> | undefined);
+    set(nodes: ITreeNode<T, unknown>[], browserEvent?: UIEvent): void;
     private _set;
     get(): T[];
-    getNodes(): readonly ITreeNode<T, any>[];
-    has(node: ITreeNode<T, any>): boolean;
-    onDidModelSplice({ insertedNodes, deletedNodes }: ITreeModelSpliceEvent<T, any>): void;
+    getNodes(): readonly ITreeNode<T, unknown>[];
+    has(node: ITreeNode<T, unknown>): boolean;
+    onDidModelSplice({ insertedNodes, deletedNodes }: ITreeModelSpliceEvent<T, unknown>): void;
     private createNodeSet;
 }
 interface ITreeNodeListOptions<T, TFilterData, TRef> extends IListOptions<ITreeNode<T, TFilterData>> {
@@ -332,7 +332,7 @@ declare class TreeNodeList<T, TFilterData, TRef> extends List<ITreeNode<T, TFilt
     private focusTrait;
     private selectionTrait;
     private anchorTrait;
-    constructor(user: string, container: HTMLElement, virtualDelegate: IListVirtualDelegate<ITreeNode<T, TFilterData>>, renderers: IListRenderer<any, any>[], focusTrait: Trait<T>, selectionTrait: Trait<T>, anchorTrait: Trait<T>, options: ITreeNodeListOptions<T, TFilterData, TRef>);
+    constructor(user: string, container: HTMLElement, virtualDelegate: IListVirtualDelegate<ITreeNode<T, TFilterData>>, renderers: IListRenderer<ITreeNode<T, TFilterData>, unknown>[], focusTrait: Trait<T>, selectionTrait: Trait<T>, anchorTrait: Trait<T>, options: ITreeNodeListOptions<T, TFilterData, TRef>);
     protected createMouseController(options: ITreeNodeListOptions<T, TFilterData, TRef>): MouseController<ITreeNode<T, TFilterData>>;
     splice(start: number, deleteCount: number, elements?: readonly ITreeNode<T, TFilterData>[]): void;
     setFocus(indexes: number[], browserEvent?: UIEvent, fromAPI?: boolean): void;
@@ -400,7 +400,7 @@ export declare abstract class AbstractTree<T, TFilterData, TRef> implements IDis
     private readonly _onDidUpdateOptions;
     readonly onDidUpdateOptions: Event<IAbstractTreeOptions<T, TFilterData>>;
     get onDidDispose(): Event<void>;
-    constructor(_user: string, container: HTMLElement, delegate: IListVirtualDelegate<T>, renderers: ITreeRenderer<T, TFilterData, any>[], _options?: IAbstractTreeOptions<T, TFilterData>);
+    constructor(_user: string, container: HTMLElement, delegate: IListVirtualDelegate<T>, renderers: ITreeRenderer<T, TFilterData, unknown>[], _options?: IAbstractTreeOptions<T, TFilterData>);
     updateOptions(optionsUpdate?: IAbstractTreeOptionsUpdate): void;
     get options(): IAbstractTreeOptions<T, TFilterData>;
     private updateStickyScroll;

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

@@ -26,7 +26,6 @@ import { Disposable, DisposableStore, toDisposable, dispose } from '../../../com
 import { clamp } from '../../../common/numbers.js';
 import * as tree from './media/tree.css';
 import { localize } from '../../../../nls.js';
-import { createInstantHoverDelegate } from '../hover/hoverDelegateFactory.js';
 import '../../../common/observableInternal/index.js';
 import { alert } from '../aria/aria.js';
 import { autorun } from '../../../common/observableInternal/reactions/autorun.js';
@@ -541,7 +540,7 @@ class FindFilter {
     }
 }
 class TreeFindToggle extends Toggle {
-    constructor(contribution, opts, hoverDelegate) {
+    constructor(contribution, opts, hoverLifecycleOptions) {
         super({
             icon: contribution.icon,
             title: contribution.title,
@@ -549,7 +548,7 @@ class TreeFindToggle extends Toggle {
             inputActiveOptionBorder: opts.inputActiveOptionBorder,
             inputActiveOptionForeground: opts.inputActiveOptionForeground,
             inputActiveOptionBackground: opts.inputActiveOptionBackground,
-            hoverDelegate,
+            hoverLifecycleOptions,
         });
         this.id = contribution.id;
     }
@@ -622,8 +621,8 @@ class FindWidget extends Disposable {
         if (styles.listFilterWidgetShadow) {
             this.elements.root.style.boxShadow = `0 0 8px 2px ${styles.listFilterWidgetShadow}`;
         }
-        const toggleHoverDelegate = this._register(createInstantHoverDelegate());
-        this.toggles = ( toggleContributions.map(contribution => this._register(( new TreeFindToggle(contribution, styles.toggleStyles, toggleHoverDelegate)))));
+        const hoverLifecycleOptions = { groupId: 'abstract-tree' };
+        this.toggles = ( toggleContributions.map(contribution => this._register(( new TreeFindToggle(contribution, styles.toggleStyles, hoverLifecycleOptions)))));
         this.onDidToggleChange = Event.any(...( this.toggles.map(toggle => ( Event.map(toggle.onChange, () => ({ id: toggle.id, isChecked: toggle.checked }))))));
         const history = options?.history || [];
         this.findInput = this._register(( new FindInput(this.elements.findInput, contextViewProvider, {
@@ -633,7 +632,8 @@ class FindWidget extends Disposable {
             showCommonFindToggles: false,
             inputBoxStyles: styles.inputBoxStyles,
             toggleStyles: styles.toggleStyles,
-            history: ( new Set(history))
+            history: ( new Set(history)),
+            hoverLifecycleOptions,
         })));
         this.actionbar = this._register(( new ActionBar(this.elements.actionbar)));
         const emitter = this._register(( new DomEmitter(this.findInput.inputBox.inputElement, 'keydown')));
@@ -1640,7 +1640,8 @@ class Trait {
         this.onDidChange = this._onDidChange.event;
     }
     set(nodes, browserEvent) {
-        if (!browserEvent?.__forceEvent && equals(this.nodes, nodes)) {
+        const event = browserEvent;
+        if (!(event?.__forceEvent) && equals(this.nodes, nodes)) {
             return;
         }
         this._set(nodes, false, browserEvent);
@@ -2140,9 +2141,9 @@ class AbstractTree {
         if (styles.listFocusOutline) {
             content.push(`.monaco-list${suffix}.sticky-scroll-focused .monaco-scrollable-element .monaco-tree-sticky-container:focus .monaco-list-row.focused { outline: 1px solid ${styles.listFocusOutline}; outline-offset: -1px; }`);
             content.push(`.monaco-list${suffix}:not(.sticky-scroll-focused) .monaco-scrollable-element .monaco-tree-sticky-container .monaco-list-row.focused { outline: inherit; }`);
-            content.push(`.monaco-workbench.context-menu-visible .monaco-list${suffix}.last-focused.sticky-scroll-focused .monaco-scrollable-element .monaco-tree-sticky-container .monaco-list-row.passive-focused { outline: 1px solid ${styles.listFocusOutline}; outline-offset: -1px; }`);
-            content.push(`.monaco-workbench.context-menu-visible .monaco-list${suffix}.last-focused.sticky-scroll-focused .monaco-list-rows .monaco-list-row.focused { outline: inherit; }`);
-            content.push(`.monaco-workbench.context-menu-visible .monaco-list${suffix}.last-focused:not(.sticky-scroll-focused) .monaco-tree-sticky-container .monaco-list-rows .monaco-list-row.focused { outline: inherit; }`);
+            content.push(`.context-menu-visible .monaco-list${suffix}.last-focused.sticky-scroll-focused .monaco-scrollable-element .monaco-tree-sticky-container .monaco-list-row.passive-focused { outline: 1px solid ${styles.listFocusOutline}; outline-offset: -1px; }`);
+            content.push(`.context-menu-visible .monaco-list${suffix}.last-focused.sticky-scroll-focused .monaco-list-rows .monaco-list-row.focused { outline: inherit; }`);
+            content.push(`.context-menu-visible .monaco-list${suffix}.last-focused:not(.sticky-scroll-focused) .monaco-tree-sticky-container .monaco-list-rows .monaco-list-row.focused { outline: inherit; }`);
         }
         this.styleElement.textContent = content.join('\n');
         this.view.style(styles);

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

@@ -327,8 +327,8 @@ function asObjectTreeOptions(options) {
             }
         },
         sorter: undefined,
-        expandOnlyOnTwistieClick: typeof options.expandOnlyOnTwistieClick === 'undefined' ? undefined : (typeof options.expandOnlyOnTwistieClick !== 'function' ? options.expandOnlyOnTwistieClick : (e => options.expandOnlyOnTwistieClick(e.element))),
-        defaultFindVisibility: e => {
+        expandOnlyOnTwistieClick: typeof options.expandOnlyOnTwistieClick === 'undefined' ? undefined : (typeof options.expandOnlyOnTwistieClick !== 'function' ? options.expandOnlyOnTwistieClick : ((e) => options.expandOnlyOnTwistieClick(e.element))),
+        defaultFindVisibility: (e) => {
             if (e.hasChildren && e.stale) {
                 return TreeVisibility.Visible;
             }
@@ -341,7 +341,8 @@ function asObjectTreeOptions(options) {
             else {
                 return options.defaultFindVisibility(e.element);
             }
-        }
+        },
+        stickyScrollDelegate: options.stickyScrollDelegate
     };
 }
 function dfs(node, fn) {
@@ -1089,7 +1090,8 @@ function asCompressibleObjectTreeOptions(options) {
             getCompressedNodeKeyboardNavigationLabel(els) {
                 return options.keyboardNavigationLabelProvider.getCompressedNodeKeyboardNavigationLabel(( els.map(e => e.element)));
             }
-        }
+        },
+        stickyScrollDelegate: objectTreeOptions.stickyScrollDelegate
     };
 }
 class CompressibleAsyncDataTree extends AsyncDataTree {

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

@@ -20,5 +20,5 @@ export declare class DataTree<TInput, T, TFilterData = void> extends AbstractTre
     refresh(element?: T): void;
     private _refresh;
     private iterate;
-    protected createModel(user: string, options: IDataTreeOptions<T, TFilterData>): ITreeModel<T | null, TFilterData, T | null>;
+    protected createModel(user: string, options: IDataTreeOptions<T | null, TFilterData>): ITreeModel<T | null, TFilterData, T | null>;
 }

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

@@ -18,7 +18,7 @@ function getVisibleState(visibility) {
     }
 }
 function isCollapsibleStateUpdate(update) {
-    return typeof update.collapsible === 'boolean';
+    return 'collapsible' in update;
 }
 class IndexTreeModel {
     constructor(user, rootElement, options = {}) {

package/vscode/src/vs/base/browser/ui/tree/media/tree.css

@@ -33,7 +33,7 @@
 	opacity: 0;
 }
 
-.monaco-workbench:not(.reduce-motion) .monaco-tl-indent > .indent-guide {
+.monaco-enable-motion .monaco-tl-indent > .indent-guide {
 	transition: opacity 0.1s linear;
 }
 
@@ -86,7 +86,7 @@
 	border-bottom-right-radius: 4px;
 }
 
-.monaco-workbench:not(.reduce-motion) .monaco-tree-type-filter {
+.monaco-enable-motion .monaco-tree-type-filter {
 	transition: top 0.3s;
 }
 

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

@@ -33,7 +33,7 @@ export declare class ObjectTree<T extends NonNullable<any>, TFilterData = void>
     updateElementHeight(element: T, height: number | undefined): void;
     resort(element: T | null, recursive?: boolean): void;
     hasElement(element: T): boolean;
-    protected createModel(user: string, options: IObjectTreeOptions<T, TFilterData>): ITreeModel<T | null, TFilterData, T | null>;
+    protected createModel(user: string, options: IObjectTreeOptions<T | null, TFilterData>): ITreeModel<T | null, TFilterData, T | null>;
 }
 interface ICompressedTreeNodeProvider<T, TFilterData> {
     getCompressedTreeNode(location: T | null): ITreeNode<ICompressedTreeNode<T> | null, TFilterData>;
@@ -59,7 +59,7 @@ export declare class CompressibleObjectTree<T extends NonNullable<any>, TFilterD
     protected model: CompressibleObjectTreeModel<T, TFilterData>;
     constructor(user: string, container: HTMLElement, delegate: IListVirtualDelegate<T>, renderers: ICompressibleTreeRenderer<T, TFilterData, any>[], options?: ICompressibleObjectTreeOptions<T, TFilterData>);
     setChildren(element: T | null, children?: Iterable<ICompressedTreeElement<T>>, options?: IObjectTreeSetChildrenOptions<T>): void;
-    protected createModel(user: string, options: ICompressibleObjectTreeOptions<T, TFilterData>): ITreeModel<T | null, TFilterData, T | null>;
+    protected createModel(user: string, options: ICompressibleObjectTreeOptions<T | null, TFilterData>): ITreeModel<T | null, TFilterData, T | null>;
     updateOptions(optionsUpdate?: ICompressibleObjectTreeOptionsUpdate): void;
     getCompressedTreeNode(element?: T | null): ITreeNode<ICompressedTreeNode<T> | null, TFilterData>;
 }

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

@@ -133,7 +133,7 @@ export interface ITreeRenderer<T, TFilterData = void, TTemplateData = void> exte
     renderElement(element: ITreeNode<T, TFilterData>, index: number, templateData: TTemplateData, details?: ITreeElementRenderDetails): void;
     disposeElement?(element: ITreeNode<T, TFilterData>, index: number, templateData: TTemplateData, details?: ITreeElementRenderDetails): void;
     renderTwistie?(element: T, twistieElement: HTMLElement): boolean;
-    onDidChangeTwistieState?: Event<T>;
+    readonly onDidChangeTwistieState?: Event<T>;
 }
 export interface ITreeEvent<T> {
     readonly elements: readonly T[];

package/vscode/src/vs/base/browser/webWorkerFactory.js

@@ -8,6 +8,7 @@ import { Disposable, toDisposable } from '../common/lifecycle.js';
 import { coalesce } from '../common/arrays.js';
 import '../../nls.js';
 import { Emitter } from '../common/event.js';
+import { getMonacoEnvironment } from './browser.js';
 import { getNLSMessages, getNLSLanguage } from '../../nls.messages.js';
 
 let ttPolicy;
@@ -28,7 +29,7 @@ function createBlobWorker(blobUrl, options) {
 }
 function getWorker(descriptor, id) {
     const label = descriptor.label || 'anonymous' + id;
-    const monacoEnvironment = globalThis.MonacoEnvironment;
+    const monacoEnvironment = getMonacoEnvironment();
     if (monacoEnvironment) {
         if (typeof monacoEnvironment.getWorker === 'function') {
             return monacoEnvironment.getWorker('workerMain.js', label);

package/vscode/src/vs/base/common/actions.d.ts

@@ -50,6 +50,11 @@ export interface IActionChangeEvent {
     readonly enabled?: boolean;
     readonly checked?: boolean;
 }
+/**
+ * A concrete implementation of {@link IAction}.
+ *
+ * Note that in most cases you should use the lighter-weight {@linkcode toAction} function instead.
+ */
 export declare class Action extends Disposable implements IAction {
     protected _onDidChange: Emitter<IActionChangeEvent>;
     get onDidChange(): Event<IActionChangeEvent>;

package/vscode/src/vs/base/common/arrays.d.ts

@@ -164,6 +164,8 @@ export declare function pushToStart<T>(arr: T[], value: T): void;
 export declare function pushToEnd<T>(arr: T[], value: T): void;
 export declare function pushMany<T>(arr: T[], items: ReadonlyArray<T>): void;
 export declare function mapArrayOrNot<T, U>(items: T | T[], fn: (_: T) => U): U | U[];
+export declare function mapFilter<T, U>(array: ReadonlyArray<T>, fn: (t: T) => U | undefined): U[];
+export declare function withoutDuplicates<T>(array: ReadonlyArray<T>): T[];
 export declare function asArray<T>(x: T | T[]): T[];
 export declare function asArray<T>(x: T | readonly T[]): readonly T[];
 export declare function getRandomElement<T>(arr: T[]): T | undefined;

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

@@ -340,6 +340,16 @@ function mapArrayOrNot(items, fn) {
         ( items.map(fn)) :
         fn(items);
 }
+function mapFilter(array, fn) {
+    const result = [];
+    for (const item of array) {
+        const mapped = fn(item);
+        if (mapped !== undefined) {
+            result.push(mapped);
+        }
+    }
+    return result;
+}
 function asArray(x) {
     return Array.isArray(x) ? x : [x];
 }
@@ -565,4 +575,4 @@ function sumBy(array, selector) {
     return array.reduce((acc, value) => acc + selector(value), 0);
 }
 
-export { ArrayQueue, CallbackIterable, CompareResult, Permutation, arrayInsert, asArray, binarySearch, binarySearch2, booleanComparator, coalesce, coalesceInPlace, commonPrefixLength, compareBy, compareUndefinedSmallest, concatArrays, delta, distinct, equals, findAsync, forEachAdjacent, forEachWithNeighbors, groupAdjacentBy, groupBy, index, insert, insertInto, isFalsyOrEmpty, isNonEmptyArray, mapArrayOrNot, move, numberComparator, pushMany, pushToEnd, pushToStart, quickSelect, range, remove, removeFastWithoutKeepingOrder, reverseOrder, shuffle, sortedDiff, splice, sum, sumBy, tail, tieBreakComparators, top, uniqueFilter };
+export { ArrayQueue, CallbackIterable, CompareResult, Permutation, arrayInsert, asArray, binarySearch, binarySearch2, booleanComparator, coalesce, coalesceInPlace, commonPrefixLength, compareBy, compareUndefinedSmallest, concatArrays, delta, distinct, equals, findAsync, forEachAdjacent, forEachWithNeighbors, groupAdjacentBy, groupBy, index, insert, insertInto, isFalsyOrEmpty, isNonEmptyArray, mapArrayOrNot, mapFilter, move, numberComparator, pushMany, pushToEnd, pushToStart, quickSelect, range, remove, removeFastWithoutKeepingOrder, reverseOrder, shuffle, sortedDiff, splice, sum, sumBy, tail, tieBreakComparators, top, uniqueFilter };

package/vscode/src/vs/base/common/arraysFind.d.ts

@@ -1,7 +1,10 @@
 import { Comparator } from "./arrays.js";
-export declare function findLast<T, R extends T>(array: readonly T[], predicate: (item: T) => item is R, fromIndex?: number): R | undefined;
-export declare function findLast<T>(array: readonly T[], predicate: (item: T) => unknown, fromIndex?: number): T | undefined;
-export declare function findLastIdx<T>(array: readonly T[], predicate: (item: T) => unknown, fromIndex?: number): number;
+export declare function findLast<T, R extends T>(array: readonly T[], predicate: (item: T, index: number) => item is R, fromIndex?: number): R | undefined;
+export declare function findLast<T>(array: readonly T[], predicate: (item: T, index: number) => unknown, fromIndex?: number): T | undefined;
+export declare function findLastIdx<T>(array: readonly T[], predicate: (item: T, index: number) => unknown, fromIndex?: number): number;
+export declare function findFirst<T, R extends T>(array: readonly T[], predicate: (item: T, index: number) => item is R, fromIndex?: number): R | undefined;
+export declare function findFirst<T>(array: readonly T[], predicate: (item: T, index: number) => unknown, fromIndex?: number): T | undefined;
+export declare function findFirstIdx<T>(array: readonly T[], predicate: (item: T, index: number) => unknown, fromIndex?: number): number;
 /**
  * Finds the last item where predicate is true using binary search.
  * `predicate` must be monotonous, i.e. `arr.map(predicate)` must be like `[true, ..., true, false, ..., false]`!

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

@@ -10,7 +10,23 @@ function findLast(array, predicate, fromIndex = array.length - 1) {
 function findLastIdx(array, predicate, fromIndex = array.length - 1) {
     for (let i = fromIndex; i >= 0; i--) {
         const element = array[i];
-        if (predicate(element)) {
+        if (predicate(element, i)) {
+            return i;
+        }
+    }
+    return -1;
+}
+function findFirst(array, predicate, fromIndex = 0) {
+    const idx = findFirstIdx(array, predicate, fromIndex);
+    if (idx === -1) {
+        return undefined;
+    }
+    return array[idx];
+}
+function findFirstIdx(array, predicate, fromIndex = 0) {
+    for (let i = fromIndex; i < array.length; i++) {
+        const element = array[i];
+        if (predicate(element, i)) {
             return i;
         }
     }
@@ -128,4 +144,4 @@ function mapFindFirst(items, mapFn) {
     return undefined;
 }
 
-export { MonotonousArray, findFirstIdxMonotonousOrArrLen, findFirstMax, findFirstMin, findFirstMonotonous, findLast, findLastIdx, findLastIdxMonotonous, findLastMax, findLastMonotonous, findMaxIdx, mapFindFirst };
+export { MonotonousArray, findFirst, findFirstIdx, findFirstIdxMonotonousOrArrLen, findFirstMax, findFirstMin, findFirstMonotonous, findLast, findLastIdx, findLastIdxMonotonous, findLastMax, findLastMonotonous, findMaxIdx, mapFindFirst };

package/vscode/src/vs/base/common/async.d.ts

@@ -59,6 +59,9 @@ export declare function promiseWithResolvers<T>(): {
 export interface ITask<T> {
     (): T;
 }
+export interface ICancellableTask<T> {
+    (token: CancellationToken): T;
+}
 /**
  * A helper to prevent accumulation of sequential async tasks.
  *
@@ -89,9 +92,9 @@ export declare class Throttler implements IDisposable {
     private activePromise;
     private queuedPromise;
     private queuedPromiseFactory;
-    private isDisposed;
+    private cancellationTokenSource;
     constructor();
-    queue<T>(promiseFactory: ITask<Promise<T>>): Promise<T>;
+    queue<T>(promiseFactory: ICancellableTask<Promise<T>>): Promise<T>;
     dispose(): void;
 }
 export declare class Sequencer {
@@ -101,6 +104,7 @@ export declare class Sequencer {
 export declare class SequencerByKey<TKey> {
     private promiseMap;
     queue<T>(key: TKey, promiseTask: ITask<Promise<T>>): Promise<T>;
+    peek(key: TKey): Promise<unknown> | undefined;
     keys(): IterableIterator<TKey>;
 }
 /**
@@ -153,7 +157,7 @@ export declare class ThrottledDelayer<T> {
     private delayer;
     private throttler;
     constructor(defaultDelay: number);
-    trigger(promiseFactory: ITask<Promise<T>>, delay?: number): Promise<T>;
+    trigger(promiseFactory: ICancellableTask<Promise<T>>, delay?: number): Promise<T>;
     isTriggered(): boolean;
     cancel(): void;
     dispose(): void;
@@ -279,6 +283,11 @@ export declare class ResourceQueue implements IDisposable {
     dispose(): void;
 }
 export type Task<T = void> = () => (Promise<T> | T);
+/**
+ * Wrap a type in an optional promise. This can be useful to avoid the runtime
+ * overhead of creating a promise.
+ */
+export type MaybePromise<T> = Promise<T> | T;
 /**
  * Processes tasks in the order they were scheduled.
 */
@@ -538,6 +547,7 @@ export type ValueCallback<T = unknown> = (value: T | Promise<T>) => void;
  * Creates a promise whose resolution or rejection can be controlled imperatively.
  */
 export declare class DeferredPromise<T> {
+    static fromPromise<T>(promise: Promise<T>): DeferredPromise<T>;
     private completeCallback;
     private errorCallback;
     private outcome?;