@codingame/monaco-vscode-api 19.1.4 → 20.0.1

package/vscode/src/vs/base/browser/ui/inputbox/inputBox.js

@@ -333,13 +333,13 @@ class InputBox extends Widget {
                 }
                 div = append(container, $('.monaco-inputbox-container'));
                 layout();
-                const renderOptions = {
-                    inline: true,
-                    className: 'monaco-inputbox-message'
-                };
-                const spanElement = (this.message.formatContent
-                    ? renderFormattedText(this.message.content, renderOptions)
-                    : renderText(this.message.content, renderOptions));
+                const spanElement = $('span.monaco-inputbox-message');
+                if (this.message.formatContent) {
+                    renderFormattedText(this.message.content, undefined, spanElement);
+                }
+                else {
+                    renderText(this.message.content, undefined, spanElement);
+                }
                 spanElement.classList.add(this.classForType(this.message.type));
                 const styles = this.stylesForType(this.message.type);
                 spanElement.style.backgroundColor = styles.background ?? '';

package/vscode/src/vs/base/browser/ui/list/listPaging.d.ts

@@ -1,6 +1,6 @@
 import { Event } from "../../../common/event.js";
 import { IDisposable } from "../../../common/lifecycle.js";
-import { IPagedModel } from "@codingame/monaco-vscode-9ed6fe06-a052-57c2-a234-5d9b94d2e7e0-common/vscode/vs/base/common/paging";
+import { IPagedModel } from "@codingame/monaco-vscode-62190c26-af1c-5f7a-a364-e05a59cfb7c7-common/vscode/vs/base/common/paging";
 import { ScrollbarVisibility } from "../../../common/scrollable.js";
 import { IListContextMenuEvent, IListEvent, IListMouseEvent, IListRenderer, IListVirtualDelegate } from "./list.js";
 import { IListAccessibilityProvider, IListOptionsUpdate, IListStyles, List, TypeNavigationMode } from "./listWidget.js";

package/vscode/src/vs/base/browser/ui/list/listWidget.d.ts

@@ -8,6 +8,7 @@ import { ScrollbarVisibility, ScrollEvent } from "../../../common/scrollable.js"
 import { ISpliceable } from "../../../common/sequence.js";
 import { IIdentityProvider, IKeyboardNavigationDelegate, IKeyboardNavigationLabelProvider, IListContextMenuEvent, IListDragAndDrop, IListEvent, IListGestureEvent, IListMouseEvent, IListRenderer, IListTouchEvent, IListVirtualDelegate } from "./list.js";
 import { IListView, IListViewAccessibilityProvider, IListViewOptions, IListViewOptionsUpdate } from "./listView.js";
+import { IMouseWheelEvent } from "../../mouseEvent.js";
 import { IObservable } from "../../../common/observable.js";
 export declare function isMonacoEditor(e: HTMLElement): boolean;
 export declare function isMonacoCustomToggle(e: HTMLElement): boolean;
@@ -228,6 +229,7 @@ export declare class List<T> implements ISpliceable<T>, IDisposable {
     getElementID(index: number): string;
     getElementTop(index: number): number;
     style(styles: IListStyles): void;
+    delegateScrollFromMouseWheelEvent(browserEvent: IMouseWheelEvent): void;
     private toListEvent;
     private _onFocusChange;
     private onDidChangeActiveDescendant;

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

@@ -1469,6 +1469,9 @@ class List {
     style(styles) {
         this.styleController.style(styles);
     }
+    delegateScrollFromMouseWheelEvent(browserEvent) {
+        this.view.delegateScrollFromMouseWheelEvent(browserEvent);
+    }
     toListEvent({ indexes, browserEvent }) {
         return { indexes, elements: ( indexes.map(i => this.view.element(i))), browserEvent };
     }

package/vscode/src/vs/base/browser/ui/scrollbar/abstractScrollbar.js

@@ -140,11 +140,15 @@ class AbstractScrollbar extends Widget {
             offsetX = e.pageX - domNodePosition.left;
             offsetY = e.pageY - domNodePosition.top;
         }
-        const offset = this._pointerDownRelativePosition(offsetX, offsetY);
-        this._setDesiredScrollPositionNow(this._scrollByPage
-            ? this._scrollbarState.getDesiredScrollPositionFromOffsetPaged(offset)
-            : this._scrollbarState.getDesiredScrollPositionFromOffset(offset));
-        if (e.button === 0) {
+        const isMouse = (e.pointerType === 'mouse');
+        const isLeftClick = (e.button === 0);
+        if (isLeftClick || !isMouse) {
+            const offset = this._pointerDownRelativePosition(offsetX, offsetY);
+            this._setDesiredScrollPositionNow(this._scrollByPage
+                ? this._scrollbarState.getDesiredScrollPositionFromOffsetPaged(offset)
+                : this._scrollbarState.getDesiredScrollPositionFromOffset(offset));
+        }
+        if (isLeftClick) {
             e.preventDefault();
             this._sliderPointerDown(e);
         }

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

@@ -36,6 +36,8 @@ export declare abstract class AbstractScrollableElement extends Widget {
     private readonly _hideTimeout;
     private _shouldRender;
     private _revealOnScroll;
+    private _inertialTimeout;
+    private _inertialSpeed;
     private readonly _onScroll;
     readonly onScroll: Event<ScrollEvent>;
     private readonly _onWillScroll;
@@ -52,6 +54,7 @@ export declare abstract class AbstractScrollableElement extends Widget {
     updateOptions(newOptions: ScrollableElementChangeOptions): void;
     setRevealOnScroll(value: boolean): void;
     delegateScrollFromMouseWheelEvent(browserEvent: IMouseWheelEvent): void;
+    private _periodicSync;
     private _setListeningToMouseWheel;
     private _onMouseWheel;
     private _onDidScroll;

package/vscode/src/vs/base/browser/ui/scrollbar/scrollableElement.js

@@ -106,8 +106,9 @@ class MouseWheelClassifier {
         return Math.min(Math.max(score, 0), 1);
     }
     _isAlmostInt(value) {
+        const epsilon = Number.EPSILON * 100;
         const delta = Math.abs(Math.round(value) - value);
-        return (delta < 0.01);
+        return (delta < 0.01 + epsilon);
     }
 }
 class AbstractScrollableElement extends Widget {
@@ -116,6 +117,8 @@ class AbstractScrollableElement extends Widget {
     }
     constructor(element, options, scrollable) {
         super();
+        this._inertialTimeout = null;
+        this._inertialSpeed = { X: 0, Y: 0 };
         this._onScroll = this._register(( new Emitter()));
         this.onScroll = this._onScroll.event;
         this._onWillScroll = this._register(( new Emitter()));
@@ -172,6 +175,10 @@ class AbstractScrollableElement extends Widget {
     }
     dispose() {
         this._mouseWheelToDispose = dispose(this._mouseWheelToDispose);
+        if (this._inertialTimeout) {
+            this._inertialTimeout.dispose();
+            this._inertialTimeout = null;
+        }
         super.dispose();
     }
     getDomNode() {
@@ -240,6 +247,34 @@ class AbstractScrollableElement extends Widget {
     delegateScrollFromMouseWheelEvent(browserEvent) {
         this._onMouseWheel(( new StandardWheelEvent(browserEvent)));
     }
+    async _periodicSync() {
+        let scheduleAgain = false;
+        if (this._inertialSpeed.X !== 0 || this._inertialSpeed.Y !== 0) {
+            this._scrollable.setScrollPositionNow({
+                scrollTop: this._scrollable.getCurrentScrollPosition().scrollTop - this._inertialSpeed.Y * 100,
+                scrollLeft: this._scrollable.getCurrentScrollPosition().scrollLeft - this._inertialSpeed.X * 100
+            });
+            this._inertialSpeed.X *= 0.9;
+            this._inertialSpeed.Y *= 0.9;
+            if (Math.abs(this._inertialSpeed.X) < 0.01) {
+                this._inertialSpeed.X = 0;
+            }
+            if (Math.abs(this._inertialSpeed.Y) < 0.01) {
+                this._inertialSpeed.Y = 0;
+            }
+            scheduleAgain = (this._inertialSpeed.X !== 0 || this._inertialSpeed.Y !== 0);
+        }
+        if (scheduleAgain) {
+            if (!this._inertialTimeout) {
+                this._inertialTimeout = ( new TimeoutTimer());
+            }
+            this._inertialTimeout.cancelAndSet(() => this._periodicSync(), 1000 / 60);
+        }
+        else {
+            this._inertialTimeout?.dispose();
+            this._inertialTimeout = null;
+        }
+    }
     _setListeningToMouseWheel(shouldListen) {
         const isListening = (this._mouseWheelToDispose.length > 0);
         if (isListening === shouldListen) {
@@ -301,6 +336,17 @@ class AbstractScrollableElement extends Widget {
                 this._horizontalScrollbar.writeScrollPosition(desiredScrollPosition, desiredScrollLeft);
             }
             desiredScrollPosition = this._scrollable.validateScrollPosition(desiredScrollPosition);
+            if (this._options.inertialScroll && (deltaX || deltaY)) {
+                let startPeriodic = false;
+                if (this._inertialSpeed.X === 0 && this._inertialSpeed.Y === 0) {
+                    startPeriodic = true;
+                }
+                this._inertialSpeed.Y = (deltaY < 0 ? -1 : 1) * (Math.abs(deltaY) ** 1.02);
+                this._inertialSpeed.X = (deltaX < 0 ? -1 : 1) * (Math.abs(deltaX) ** 1.02);
+                if (startPeriodic) {
+                    this._periodicSync();
+                }
+            }
             if (futureScrollPosition.scrollLeft !== desiredScrollPosition.scrollLeft || futureScrollPosition.scrollTop !== desiredScrollPosition.scrollTop) {
                 const canPerformSmoothScroll = (this._options.mouseWheelSmoothScroll
                     && classifier.isPhysicalMouseWheel());
@@ -486,6 +532,7 @@ function resolveOptions(opts) {
         fastScrollSensitivity: (typeof opts.fastScrollSensitivity !== 'undefined' ? opts.fastScrollSensitivity : 5),
         scrollPredominantAxis: (typeof opts.scrollPredominantAxis !== 'undefined' ? opts.scrollPredominantAxis : true),
         mouseWheelSmoothScroll: (typeof opts.mouseWheelSmoothScroll !== 'undefined' ? opts.mouseWheelSmoothScroll : true),
+        inertialScroll: (typeof opts.inertialScroll !== 'undefined' ? opts.inertialScroll : false),
         arrowSize: (typeof opts.arrowSize !== 'undefined' ? opts.arrowSize : 11),
         listenOnDomNode: (typeof opts.listenOnDomNode !== 'undefined' ? opts.listenOnDomNode : null),
         horizontal: (typeof opts.horizontal !== 'undefined' ? opts.horizontal : ScrollbarVisibility.Auto),

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

@@ -5,6 +5,7 @@ export interface ScrollableElementCreationOptions {
     useShadows?: boolean;
     handleMouseWheel?: boolean;
     mouseWheelSmoothScroll?: boolean;
+    inertialScroll?: boolean;
     flipAxes?: boolean;
     scrollYToX?: boolean;
     consumeMouseWheelIfScrollbarIsNeeded?: boolean;
@@ -48,6 +49,7 @@ export interface ScrollableElementResolvedOptions {
     fastScrollSensitivity: number;
     scrollPredominantAxis: boolean;
     mouseWheelSmoothScroll: boolean;
+    inertialScroll: boolean;
     arrowSize: number;
     listenOnDomNode: HTMLElement | null;
     horizontal: ScrollbarVisibility;

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

@@ -53,6 +53,3 @@
 .monaco-action-bar .checkbox-action-item > .checkbox-label {
 	font-size: 12px;
 }
-.monaco-custom-toggle.monaco-checkbox:not(.checked)::before {
-	visibility: hidden;
-}

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

@@ -1,5 +1,5 @@
 import { IAction } from "../../../common/actions.js";
-import { Event } from "../../../common/event.js";
+import { Emitter, Event } from "../../../common/event.js";
 import { ThemeIcon } from "../../../common/themables.js";
 import { IKeyboardEvent } from "../../keyboardEvent.js";
 import { BaseActionViewItem, IActionViewItemOptions } from "../actionbar/actionViewItems.js";
@@ -52,7 +52,7 @@ export declare class Toggle extends Widget {
     private _icon;
     readonly domNode: HTMLElement;
     private _checked;
-    private _hover?;
+    private _hover;
     constructor(opts: IToggleOpts);
     get enabled(): boolean;
     focus(): void;
@@ -67,19 +67,15 @@ export declare class Toggle extends Widget {
     set visible(visible: boolean);
     get visible(): boolean;
 }
-export declare class Checkbox extends Widget {
-    private title;
-    private isChecked;
+declare abstract class BaseCheckbox extends Widget {
+    protected readonly checkbox: Toggle;
+    readonly domNode: HTMLElement;
+    protected readonly styles: ICheckboxStyles;
     static readonly CLASS_NAME = "monaco-checkbox";
-    private readonly _onChange;
+    protected readonly _onChange: Emitter<boolean>;
     readonly onChange: Event<boolean>;
-    private checkbox;
-    private styles;
-    readonly domNode: HTMLElement;
-    constructor(title: string, isChecked: boolean, styles: ICheckboxStyles);
-    get checked(): boolean;
+    constructor(checkbox: Toggle, domNode: HTMLElement, styles: ICheckboxStyles);
     get enabled(): boolean;
-    set checked(newIsChecked: boolean);
     focus(): void;
     hasFocus(): boolean;
     enable(): void;
@@ -87,6 +83,19 @@ export declare class Checkbox extends Widget {
     setTitle(newTitle: string): void;
     protected applyStyles(enabled?: boolean): void;
 }
+export declare class Checkbox extends BaseCheckbox {
+    constructor(title: string, isChecked: boolean, styles: ICheckboxStyles);
+    get checked(): boolean;
+    set checked(newIsChecked: boolean);
+    protected applyStyles(enabled?: boolean): void;
+}
+export declare class TriStateCheckbox extends BaseCheckbox {
+    private _state;
+    constructor(title: string, _state: boolean | "partial", styles: ICheckboxStyles);
+    get checked(): boolean | "partial";
+    set checked(newState: boolean | "partial");
+    protected applyStyles(enabled?: boolean): void;
+}
 export interface ICheckboxActionViewItemOptions extends IActionViewItemOptions {
     checkboxStyles: ICheckboxStyles;
 }
@@ -103,3 +112,4 @@ export declare class CheckboxActionViewItem extends BaseActionViewItem {
     blur(): void;
     setFocusable(focusable: boolean): void;
 }
+export {};

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

@@ -95,12 +95,7 @@ class Toggle extends Widget {
             classes.push('checked');
         }
         this.domNode = createElement('div');
-        if (this._opts.hoverDelegate?.showNativeHover) {
-            this.domNode.title = this._opts.title;
-        }
-        else {
-            this._hover = this._register(getBaseLayerHoverDelegate().setupManagedHover(opts.hoverDelegate ?? getDefaultHoverDelegate('mouse'), this.domNode, this._opts.title));
-        }
+        this._hover = this._register(getBaseLayerHoverDelegate().setupManagedHover(opts.hoverDelegate ?? getDefaultHoverDelegate('mouse'), this.domNode, this._opts.title));
         this.domNode.classList.add(...classes);
         if (!this._opts.notFocusable) {
             this.domNode.tabIndex = 0;
@@ -174,12 +169,7 @@ class Toggle extends Widget {
         this.domNode.classList.add('disabled');
     }
     setTitle(newTitle) {
-        if (this._hover) {
-            this._hover.update(newTitle);
-        }
-        else {
-            this.domNode.title = newTitle;
-        }
+        this._hover.update(newTitle);
         this.domNode.setAttribute('aria-label', newTitle);
     }
     set visible(visible) {
@@ -189,35 +179,20 @@ class Toggle extends Widget {
         return this.domNode.style.display !== 'none';
     }
 }
-class Checkbox extends Widget {
+class BaseCheckbox extends Widget {
     static { this.CLASS_NAME = 'monaco-checkbox'; }
-    constructor(title, isChecked, styles) {
+    constructor(checkbox, domNode, styles) {
         super();
-        this.title = title;
-        this.isChecked = isChecked;
+        this.checkbox = checkbox;
+        this.domNode = domNode;
+        this.styles = styles;
         this._onChange = this._register(( new Emitter()));
         this.onChange = this._onChange.event;
-        this.checkbox = this._register(( new Toggle(
-            { title: this.title, isChecked: this.isChecked, icon: Codicon.check, actionClassName: Checkbox.CLASS_NAME, hoverDelegate: styles.hoverDelegate, ...unthemedToggleStyles }
-        )));
-        this.domNode = this.checkbox.domNode;
-        this.styles = styles;
         this.applyStyles();
-        this._register(this.checkbox.onChange(keyboard => {
-            this.applyStyles();
-            this._onChange.fire(keyboard);
-        }));
-    }
-    get checked() {
-        return this.checkbox.checked;
     }
     get enabled() {
         return this.checkbox.enabled;
     }
-    set checked(newIsChecked) {
-        this.checkbox.checked = newIsChecked;
-        this.applyStyles();
-    }
     focus() {
         this.domNode.focus();
     }
@@ -246,6 +221,91 @@ class Checkbox extends Widget {
         this.domNode.style.fontSize = `${size - 2}px`;
     }
 }
+class Checkbox extends BaseCheckbox {
+    constructor(title, isChecked, styles) {
+        const toggle = ( new Toggle(
+            { title, isChecked, icon: Codicon.check, actionClassName: BaseCheckbox.CLASS_NAME, hoverDelegate: styles.hoverDelegate, ...unthemedToggleStyles }
+        ));
+        super(toggle, toggle.domNode, styles);
+        this._register(toggle);
+        this._register(this.checkbox.onChange(keyboard => {
+            this.applyStyles();
+            this._onChange.fire(keyboard);
+        }));
+    }
+    get checked() {
+        return this.checkbox.checked;
+    }
+    set checked(newIsChecked) {
+        this.checkbox.checked = newIsChecked;
+        this.applyStyles();
+    }
+    applyStyles(enabled) {
+        if (this.checkbox.checked) {
+            this.checkbox.setIcon(Codicon.check);
+        }
+        else {
+            this.checkbox.setIcon(undefined);
+        }
+        super.applyStyles(enabled);
+    }
+}
+class TriStateCheckbox extends BaseCheckbox {
+    constructor(title, _state, styles) {
+        let icon;
+        switch (_state) {
+            case true:
+                icon = Codicon.check;
+                break;
+            case 'partial':
+                icon = Codicon.dash;
+                break;
+            case false:
+                icon = undefined;
+                break;
+        }
+        const checkbox = ( new Toggle({
+            title,
+            isChecked: _state === true,
+            icon,
+            actionClassName: Checkbox.CLASS_NAME,
+            hoverDelegate: styles.hoverDelegate,
+            ...unthemedToggleStyles
+        }));
+        super(checkbox, checkbox.domNode, styles);
+        this._state = _state;
+        this._register(checkbox);
+        this._register(this.checkbox.onChange(keyboard => {
+            this._state = this.checkbox.checked;
+            this.applyStyles();
+            this._onChange.fire(keyboard);
+        }));
+    }
+    get checked() {
+        return this._state;
+    }
+    set checked(newState) {
+        if (this._state !== newState) {
+            this._state = newState;
+            this.checkbox.checked = newState === true;
+            this.applyStyles();
+        }
+    }
+    applyStyles(enabled) {
+        switch (this._state) {
+            case true:
+                this.checkbox.setIcon(Codicon.check);
+                break;
+            case 'partial':
+                this.checkbox.setIcon(Codicon.dash);
+                break;
+            case false:
+                this.checkbox.setIcon(undefined);
+                break;
+        }
+        super.applyStyles(enabled);
+    }
+}
 class CheckboxActionViewItem extends BaseActionViewItem {
     constructor(context, action, options) {
         super(context, action, options);
@@ -312,4 +372,4 @@ class CheckboxActionViewItem extends BaseActionViewItem {
     }
 }
 
-export { Checkbox, CheckboxActionViewItem, Toggle, ToggleActionViewItem, unthemedToggleStyles };
+export { Checkbox, CheckboxActionViewItem, Toggle, ToggleActionViewItem, TriStateCheckbox, unthemedToggleStyles };

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

@@ -10,6 +10,7 @@ import { Event } from "../../../common/event.js";
 import { FuzzyScore } from "../../../common/filters.js";
 import { Disposable, DisposableStore, IDisposable } from "../../../common/lifecycle.js";
 import { ScrollEvent } from "../../../common/scrollable.js";
+import { IMouseWheelEvent } from "../../mouseEvent.js";
 export declare class ComposedTreeDelegate<T, N extends {
     element: T;
 }> implements IListVirtualDelegate<N> {
@@ -295,6 +296,7 @@ export interface IAbstractTreeOptions<T, TFilterData = void> extends IAbstractTr
     readonly findWidgetStyles?: IFindWidgetStyles;
     readonly defaultFindVisibility?: TreeVisibility | ((e: T) => TreeVisibility);
     readonly stickyScrollDelegate?: IStickyScrollDelegate<any, TFilterData>;
+    readonly disableExpandOnSpacebar?: boolean;
 }
 declare class Trait<T> {
     private getFirstViewElementWithTrait;
@@ -456,6 +458,7 @@ export declare abstract class AbstractTree<T, TFilterData, TRef> implements IDis
     private readonly modelDisposables;
     private setupModel;
     navigate(start?: TRef): ITreeNavigator<T>;
+    delegateScrollFromMouseWheelEvent(browserEvent: IMouseWheelEvent): void;
     dispose(): void;
 }
 export {};

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

@@ -2394,6 +2394,9 @@ class AbstractTree {
     navigate(start) {
         return ( new TreeNavigator(this.view, this.model, start));
     }
+    delegateScrollFromMouseWheelEvent(browserEvent) {
+        this.view.delegateScrollFromMouseWheelEvent(browserEvent);
+    }
     dispose() {
         dispose(this.disposables);
         this.stickyScrollController?.dispose();

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

@@ -4,6 +4,7 @@ import { TreeFindMode as TreeFindMode, IAbstractTreeOptions, IAbstractTreeOption
 import { ICompressedTreeElement, ICompressedTreeNode } from "./compressedObjectTreeModel.js";
 import { CompressibleObjectTree, ICompressibleKeyboardNavigationLabelProvider, ICompressibleTreeRenderer, IObjectTreeSetChildrenOptions, ObjectTree } from "./objectTree.js";
 import { IAsyncDataSource, ICollapseStateChangeEvent, IObjectTreeElement, ITreeContextMenuEvent, ITreeEvent, ITreeMouseEvent, ITreeNavigator, ITreeNode, ITreeRenderer, ITreeSorter, ObjectTreeElementCollapseState, WeakMapper } from "./tree.js";
+import { CancelablePromise } from "../../../common/async.js";
 import { Emitter, Event } from "../../../common/event.js";
 import { DisposableStore, IDisposable } from "../../../common/lifecycle.js";
 import { ScrollEvent } from "../../../common/scrollable.js";
@@ -13,7 +14,7 @@ interface IAsyncDataTreeNode<TInput, T> {
     readonly parent: IAsyncDataTreeNode<TInput, T> | null;
     readonly children: IAsyncDataTreeNode<TInput, T>[];
     readonly id?: string | null;
-    refreshPromise: Promise<void> | undefined;
+    refreshPromise: CancelablePromise<void> | undefined;
     hasChildren: boolean;
     stale: boolean;
     slow: boolean;
@@ -128,6 +129,7 @@ export declare class AsyncDataTree<TInput, T, TFilterData = void> implements IDi
     getInput(): TInput | undefined;
     setInput(input: TInput, viewState?: IAsyncDataTreeViewState): Promise<void>;
     updateChildren(element?: TInput | T, recursive?: boolean, rerender?: boolean, options?: IAsyncDataTreeUpdateChildrenOptions<T>): Promise<void>;
+    cancelAllRefreshPromises(): void;
     private _updateChildren;
     resort(element?: TInput | T, recursive?: boolean): void;
     hasNode(element: TInput | T): boolean;

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

@@ -4,7 +4,7 @@ import { FindFilter, TreeFindMode, FindController, ComposedTreeDelegate } from '
 import { isFilterResult, getVisibleState } from './indexTreeModel.js';
 import { ObjectTree, CompressibleObjectTree } from './objectTree.js';
 import { TreeVisibility, WeakMapper, ObjectTreeElementCollapseState, TreeError } from './tree.js';
-import { ThrottledDelayer, Promises, timeout, createCancelablePromise } from '../../../common/async.js';
+import { ThrottledDelayer, createCancelablePromise, Promises, timeout } from '../../../common/async.js';
 import { Codicon } from '../../../common/codicons.js';
 import { ThemeIcon } from '../../../common/themables.js';
 import { isCancellationError, onUnexpectedError } from '../../../common/errors.js';
@@ -531,8 +531,7 @@ class AsyncDataTree {
         return this.root.element;
     }
     async setInput(input, viewState) {
-        this.refreshPromises.forEach(promise => promise.cancel());
-        this.refreshPromises.clear();
+        this.cancelAllRefreshPromises();
         this.root.element = input;
         const viewStateContext = viewState && { viewState, focus: [], selection: [] };
         await this._updateChildren(input, true, false, viewStateContext);
@@ -547,6 +546,12 @@ class AsyncDataTree {
     async updateChildren(element = this.root.element, recursive = true, rerender = false, options) {
         await this._updateChildren(element, recursive, rerender, undefined, options);
     }
+    cancelAllRefreshPromises() {
+        this.refreshPromises.forEach(promise => promise.cancel());
+        this.refreshPromises.clear();
+        this.subTreeRefreshPromises.forEach(promise => promise.cancel());
+        this.subTreeRefreshPromises.clear();
+    }
     async _updateChildren(element = this.root.element, recursive = true, rerender = false, viewStateContext, options) {
         if (typeof this.root.element === 'undefined') {
             throw ( new TreeError(this.user, 'Tree input not set'));
@@ -609,7 +614,7 @@ class AsyncDataTree {
             return false;
         }
         if (node.refreshPromise) {
-            await this.root.refreshPromise;
+            await node.refreshPromise;
             await Event.toPromise(this._onDidRender.event);
         }
         if (node !== this.root && !node.refreshPromise && !this.tree.isCollapsed(node)) {
@@ -617,7 +622,7 @@ class AsyncDataTree {
         }
         const result = this.tree.expand(node === this.root ? null : node, recursive);
         if (node.refreshPromise) {
-            await this.root.refreshPromise;
+            await node.refreshPromise;
             await Event.toPromise(this._onDidRender.event);
         }
         return result;
@@ -781,21 +786,18 @@ class AsyncDataTree {
         return this.doRefreshSubTree(node, recursive, viewStateContext);
     }
     async doRefreshSubTree(node, recursive, viewStateContext) {
-        let done;
-        node.refreshPromise = ( new Promise(c => done = c));
-        this.subTreeRefreshPromises.set(node, node.refreshPromise);
-        node.refreshPromise.finally(() => {
-            node.refreshPromise = undefined;
-            this.subTreeRefreshPromises.delete(node);
-        });
-        try {
+        const cancelablePromise = createCancelablePromise(async () => {
             const childrenToRefresh = await this.doRefreshNode(node, recursive, viewStateContext);
             node.stale = false;
             await Promises.settled(( childrenToRefresh.map(child => this.doRefreshSubTree(child, recursive, viewStateContext))));
-        }
-        finally {
-            done();
-        }
+        });
+        node.refreshPromise = cancelablePromise;
+        this.subTreeRefreshPromises.set(node, cancelablePromise);
+        cancelablePromise.finally(() => {
+            node.refreshPromise = undefined;
+            this.subTreeRefreshPromises.delete(node);
+        });
+        return cancelablePromise;
     }
     async doRefreshNode(node, recursive, viewStateContext) {
         node.hasChildren = !!this.dataSource.hasChildren(node.element);

package/vscode/src/vs/base/browser/webWorkerFactory.d.ts

@@ -11,4 +11,4 @@ export declare class WebWorkerDescriptor implements IWebWorkerDescriptor {
     constructor(esmModuleLocation: URI, label: string | undefined);
 }
 export declare function createWebWorker<T extends object>(esmModuleLocation: URI, label: string | undefined): IWebWorkerClient<T>;
-export declare function createWebWorker<T extends object>(workerDescriptor: IWebWorkerDescriptor | Worker): IWebWorkerClient<T>;
+export declare function createWebWorker<T extends object>(workerDescriptor: IWebWorkerDescriptor | Worker | Promise<Worker>): IWebWorkerClient<T>;

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

@@ -108,8 +108,9 @@ class WebWorker extends Disposable {
         this.onError = this._onError.event;
         this.id = ++WebWorker.LAST_WORKER_ID;
         const workerOrPromise = (descriptorOrWorker instanceof Worker
-            ? descriptorOrWorker
-            : getWorker(descriptorOrWorker, this.id));
+            ? descriptorOrWorker :
+            'then' in descriptorOrWorker ? descriptorOrWorker
+                : getWorker(descriptorOrWorker, this.id));
         if (isPromiseLike(workerOrPromise)) {
             this.worker = workerOrPromise;
         }

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

@@ -558,8 +558,11 @@ async function findAsync(array, predicate) {
     )));
     return results.find(r => r.ok)?.element;
 }
+function sum(array) {
+    return array.reduce((acc, value) => acc + value, 0);
+}
 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, 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, 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,4 +1,5 @@
 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 findLastMonotonous<T>(array: readonly T[], predicate: (item: T) => boolean): T | undefined;