@codingame/monaco-vscode-api 19.1.4 → 20.0.0

package/vscode/src/vs/platform/quickinput/browser/tree/quickInputTreeController.js

@@ -0,0 +1,296 @@
+
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { $ as $$1, append } from '../../../../base/browser/dom.js';
+import { ObjectTreeElementCollapseState } from '../../../../base/browser/ui/tree/tree.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { IInstantiationService } from '../../../instantiation/common/instantiation.js';
+import { WorkbenchObjectTree } from '../../../list/browser/listService.js';
+import { QuickPickFocus } from '../../common/quickInput.js';
+import { QuickInputTreeDelegate } from './quickInputDelegate.js';
+import { getParentNodeState } from './quickInputTree.js';
+import { QuickTreeAccessibilityProvider } from './quickInputTreeAccessibilityProvider.js';
+import { QuickInputTreeFilter } from './quickInputTreeFilter.js';
+import { QuickInputTreeRenderer } from './quickInputTreeRenderer.js';
+
+const $ = $$1;
+let QuickInputTreeController = class QuickInputTreeController extends Disposable {
+    constructor(container, hoverDelegate, instantiationService) {
+        super();
+        this.instantiationService = instantiationService;
+        this._onDidTriggerButton = this._register(( new Emitter()));
+        this.onDidTriggerButton = this._onDidTriggerButton.event;
+        this._onDidChangeCheckboxState = this._register(( new Emitter()));
+        this.onDidChangeCheckboxState = this._onDidChangeCheckboxState.event;
+        this._onDidCheckedLeafItemsChange = this._register(( new Emitter()));
+        this.onDidChangeCheckedLeafItems = this._onDidCheckedLeafItemsChange.event;
+        this._onLeave = ( new Emitter());
+        this.onLeave = this._onLeave.event;
+        this._container = append(container, $('.quick-input-tree'));
+        this._renderer = this._register(this.instantiationService.createInstance(QuickInputTreeRenderer, hoverDelegate, this._onDidTriggerButton, this.onDidChangeCheckboxState));
+        this._filter = this.instantiationService.createInstance(QuickInputTreeFilter);
+        this._tree = this._register(this.instantiationService.createInstance((WorkbenchObjectTree), 'QuickInputTree', this._container, ( new QuickInputTreeDelegate()), [this._renderer], {
+            accessibilityProvider: ( new QuickTreeAccessibilityProvider(this.onDidChangeCheckboxState)),
+            horizontalScrolling: false,
+            multipleSelectionSupport: false,
+            findWidgetEnabled: false,
+            alwaysConsumeMouseWheel: true,
+            hideTwistiesOfChildlessElements: true,
+            expandOnDoubleClick: true,
+            expandOnlyOnTwistieClick: true,
+            disableExpandOnSpacebar: true,
+            sorter: {
+                compare: (a, b) => {
+                    if (a.label < b.label) {
+                        return -1;
+                    }
+                    else if (a.label > b.label) {
+                        return 1;
+                    }
+                    if (a.description && b.description) {
+                        if (a.description < b.description) {
+                            return -1;
+                        }
+                        else if (a.description > b.description) {
+                            return 1;
+                        }
+                    }
+                    else if (a.description) {
+                        return -1;
+                    }
+                    else if (b.description) {
+                        return 1;
+                    }
+                    if (a.detail && b.detail) {
+                        if (a.detail < b.detail) {
+                            return -1;
+                        }
+                        else if (a.detail > b.detail) {
+                            return 1;
+                        }
+                    }
+                    else if (a.detail) {
+                        return -1;
+                    }
+                    else if (b.detail) {
+                        return 1;
+                    }
+                    return 0;
+                }
+            },
+            filter: this._filter
+        }));
+        this.registerOnOpenListener();
+    }
+    get tree() {
+        return this._tree;
+    }
+    get renderer() {
+        return this._renderer;
+    }
+    get displayed() {
+        return this._container.style.display !== 'none';
+    }
+    set displayed(value) {
+        this._container.style.display = value ? '' : 'none';
+    }
+    getActiveDescendant() {
+        return this._tree.getHTMLElement().getAttribute('aria-activedescendant');
+    }
+    filter(input) {
+        this._filter.filterValue = input;
+        this._tree.refilter();
+    }
+    updateFilterOptions(options) {
+        if (options.matchOnLabel !== undefined) {
+            this._filter.matchOnLabel = options.matchOnLabel;
+        }
+        if (options.matchOnDescription !== undefined) {
+            this._filter.matchOnDescription = options.matchOnDescription;
+        }
+        if (options.matchOnDetail !== undefined) {
+            this._filter.matchOnDetail = options.matchOnDetail;
+        }
+        this._tree.refilter();
+    }
+    setTreeData(treeData) {
+        const createTreeElement = (item) => {
+            let children;
+            if (item.children) {
+                children = ( item.children.map(child => createTreeElement(child)));
+                item.checked = getParentNodeState(children);
+            }
+            return {
+                element: item,
+                children,
+                collapsible: !!children,
+                collapsed: item.collapsed ?? ObjectTreeElementCollapseState.PreserveOrExpanded
+            };
+        };
+        const treeElements = ( treeData.map(item => createTreeElement(item)));
+        this._tree.setChildren(null, treeElements);
+    }
+    layout(maxHeight) {
+        this._tree.getHTMLElement().style.maxHeight = maxHeight ? `${
+        Math.floor(maxHeight / 44) * 44
+            + 6}px` : '';
+        this._tree.layout();
+    }
+    focus(what) {
+        switch (what) {
+            case QuickPickFocus.First:
+                this._tree.scrollTop = 0;
+                this._tree.focusFirst();
+                break;
+            case QuickPickFocus.Second: {
+                this._tree.scrollTop = 0;
+                let isSecondItem = false;
+                this._tree.focusFirst(undefined, (e) => {
+                    if (isSecondItem) {
+                        return true;
+                    }
+                    isSecondItem = !isSecondItem;
+                    return false;
+                });
+                break;
+            }
+            case QuickPickFocus.Last:
+                this._tree.scrollTop = this._tree.scrollHeight;
+                this._tree.focusLast();
+                break;
+            case QuickPickFocus.Next: {
+                const prevFocus = this._tree.getFocus();
+                this._tree.focusNext(undefined, false, undefined, (e) => {
+                    this._tree.reveal(e.element);
+                    return true;
+                });
+                const currentFocus = this._tree.getFocus();
+                if (prevFocus.length && prevFocus[0] === currentFocus[0]) {
+                    this._onLeave.fire();
+                }
+                break;
+            }
+            case QuickPickFocus.Previous: {
+                const prevFocus = this._tree.getFocus();
+                this._tree.focusPrevious(undefined, false, undefined, (e) => {
+                    this._tree.reveal(e.element);
+                    return true;
+                });
+                const currentFocus = this._tree.getFocus();
+                if (prevFocus.length && prevFocus[0] === currentFocus[0]) {
+                    this._onLeave.fire();
+                }
+                break;
+            }
+            case QuickPickFocus.NextPage:
+                this._tree.focusNextPage(undefined, (e) => {
+                    this._tree.reveal(e.element);
+                    return true;
+                });
+                break;
+            case QuickPickFocus.PreviousPage:
+                this._tree.focusPreviousPage(undefined, (e) => {
+                    this._tree.reveal(e.element);
+                    return true;
+                });
+                break;
+            case QuickPickFocus.NextSeparator:
+            case QuickPickFocus.PreviousSeparator:
+                return;
+        }
+    }
+    registerOnOpenListener() {
+        this._register(this._tree.onDidOpen(e => {
+            const item = e.element;
+            if (!item) {
+                return;
+            }
+            const newState = item.checked !== true;
+            if ((item.checked ?? false) === newState) {
+                return;
+            }
+            item.checked = newState;
+            this._tree.rerender(item);
+            const updateSet = ( new Set());
+            const toUpdate = [...this._tree.getNode(item).children];
+            while (toUpdate.length) {
+                const pop = toUpdate.shift();
+                if (pop?.element && !( updateSet.has(pop.element))) {
+                    updateSet.add(pop.element);
+                    if ((pop.element.checked ?? false) !== item.checked) {
+                        pop.element.checked = item.checked;
+                        this._tree.rerender(pop.element);
+                    }
+                    toUpdate.push(...pop.children);
+                }
+            }
+            let parent = this._tree.getParentElement(item);
+            while (parent) {
+                const parentChildren = [...this._tree.getNode(parent).children];
+                const newState = getParentNodeState(parentChildren);
+                if ((parent.checked ?? false) !== newState) {
+                    parent.checked = newState;
+                    this._tree.rerender(parent);
+                }
+                parent = this._tree.getParentElement(parent);
+            }
+            this._onDidChangeCheckboxState.fire({
+                item,
+                checked: item.checked ?? false
+            });
+            this._onDidCheckedLeafItemsChange.fire(this.getCheckedLeafItems());
+        }));
+    }
+    getCheckedLeafItems() {
+        const lookedAt = ( new Set());
+        const toLookAt = [...this._tree.getNode().children];
+        const checkedItems = ( new Array());
+        while (toLookAt.length) {
+            const lookAt = toLookAt.shift();
+            if (!lookAt?.element || ( lookedAt.has(lookAt.element))) {
+                continue;
+            }
+            if (lookAt.element.checked) {
+                lookedAt.add(lookAt.element);
+                toLookAt.push(...lookAt.children);
+                if (!lookAt.element.children) {
+                    checkedItems.push(lookAt.element);
+                }
+            }
+        }
+        return checkedItems;
+    }
+    check(element, checked) {
+        if (element.checked === checked) {
+            return;
+        }
+        element.checked = checked;
+        this._onDidCheckedLeafItemsChange.fire(this.getCheckedLeafItems());
+    }
+    checkAll(checked) {
+        const updated = ( new Set());
+        const toUpdate = [...this._tree.getNode().children];
+        let fireCheckedChangeEvent = false;
+        while (toUpdate.length) {
+            const update = toUpdate.shift();
+            if (!update?.element || ( updated.has(update.element))) {
+                continue;
+            }
+            if (update.element.checked !== checked) {
+                fireCheckedChangeEvent = true;
+                update.element.checked = checked;
+                toUpdate.push(...update.children);
+                updated.add(update.element);
+                this._tree.rerender(update.element);
+            }
+        }
+        if (fireCheckedChangeEvent) {
+            this._onDidCheckedLeafItemsChange.fire(this.getCheckedLeafItems());
+        }
+    }
+};
+QuickInputTreeController = ( __decorate([
+    ( __param(2, IInstantiationService))
+], QuickInputTreeController));
+
+export { QuickInputTreeController };

package/vscode/src/vs/platform/quickinput/browser/tree/quickInputTreeFilter.d.ts

@@ -0,0 +1,10 @@
+import { ITreeFilter, ITreeFilterDataResult, TreeVisibility } from "../../../../base/browser/ui/tree/tree.js";
+import { IQuickTreeItem } from "../../common/quickInput.js";
+import { IQuickTreeFilterData } from "./quickInputTree.js";
+export declare class QuickInputTreeFilter implements ITreeFilter<IQuickTreeItem, IQuickTreeFilterData> {
+    filterValue: string;
+    matchOnLabel: boolean;
+    matchOnDescription: boolean;
+    matchOnDetail: boolean;
+    filter(element: IQuickTreeItem, parentVisibility: TreeVisibility): ITreeFilterDataResult<IQuickTreeFilterData>;
+}

package/vscode/src/vs/platform/quickinput/browser/tree/quickInputTreeFilter.js

@@ -0,0 +1,39 @@
+
+import { TreeVisibility } from '../../../../base/browser/ui/tree/tree.js';
+import { matchesFuzzyIconAware, parseLabelWithIcons } from '../../../../base/common/iconLabels.js';
+
+class QuickInputTreeFilter {
+    constructor() {
+        this.filterValue = '';
+        this.matchOnLabel = true;
+        this.matchOnDescription = false;
+        this.matchOnDetail = false;
+    }
+    filter(element, parentVisibility) {
+        if (!this.filterValue || !(this.matchOnLabel || this.matchOnDescription || this.matchOnDetail)) {
+            return element.children
+                ? { visibility: TreeVisibility.Recurse, data: {} }
+                : { visibility: TreeVisibility.Visible, data: {} };
+        }
+        const labelHighlights = this.matchOnLabel ? matchesFuzzyIconAware(this.filterValue, parseLabelWithIcons(element.label)) ?? undefined : undefined;
+        const descriptionHighlights = this.matchOnDescription ? matchesFuzzyIconAware(this.filterValue, parseLabelWithIcons(element.description || '')) ?? undefined : undefined;
+        const detailHighlights = this.matchOnDetail ? matchesFuzzyIconAware(this.filterValue, parseLabelWithIcons(element.detail || '')) ?? undefined : undefined;
+        const visibility = parentVisibility === TreeVisibility.Visible
+            ? TreeVisibility.Visible
+            : (labelHighlights || descriptionHighlights || detailHighlights)
+                ? TreeVisibility.Visible
+                : element.children
+                    ? TreeVisibility.Recurse
+                    : TreeVisibility.Hidden;
+        return {
+            visibility,
+            data: {
+                labelHighlights,
+                descriptionHighlights,
+                detailHighlights
+            }
+        };
+    }
+}
+
+export { QuickInputTreeFilter };

package/vscode/src/vs/platform/quickinput/browser/tree/quickInputTreeRenderer.d.ts

@@ -0,0 +1,33 @@
+import { ActionBar } from "../../../../base/browser/ui/actionbar/actionbar.js";
+import { IHoverDelegate } from "../../../../base/browser/ui/hover/hoverDelegate.js";
+import { IconLabel } from "../../../../base/browser/ui/iconLabel/iconLabel.js";
+import { TriStateCheckbox } from "../../../../base/browser/ui/toggle/toggle.js";
+import { ITreeElementRenderDetails, ITreeNode, ITreeRenderer } from "../../../../base/browser/ui/tree/tree.js";
+import { Emitter, Event } from "../../../../base/common/event.js";
+import { Disposable, DisposableStore } from "../../../../base/common/lifecycle.js";
+import { IThemeService } from "../../../theme/common/themeService.service.js";
+import { IQuickTreeCheckboxEvent, IQuickTreeItem, IQuickTreeItemButtonEvent } from "../../common/quickInput.js";
+import { IQuickTreeFilterData } from "./quickInputTree.js";
+export interface IQuickTreeTemplateData {
+    entry: HTMLElement;
+    checkbox: TriStateCheckbox;
+    icon: HTMLElement;
+    label: IconLabel;
+    detail: IconLabel;
+    actionBar: ActionBar;
+    toDisposeElement: DisposableStore;
+    toDisposeTemplate: DisposableStore;
+}
+export declare class QuickInputTreeRenderer<T extends IQuickTreeItem> extends Disposable implements ITreeRenderer<T, IQuickTreeFilterData, IQuickTreeTemplateData> {
+    private readonly _hoverDelegate;
+    private readonly _buttonTriggeredEmitter;
+    private readonly onCheckedEvent;
+    private readonly _themeService;
+    static readonly ID = "quickInputTreeElement";
+    templateId: string;
+    constructor(_hoverDelegate: IHoverDelegate | undefined, _buttonTriggeredEmitter: Emitter<IQuickTreeItemButtonEvent<T>>, onCheckedEvent: Event<IQuickTreeCheckboxEvent<T>>, _themeService: IThemeService);
+    renderTemplate(container: HTMLElement): IQuickTreeTemplateData;
+    renderElement(node: ITreeNode<T, IQuickTreeFilterData>, index: number, templateData: IQuickTreeTemplateData, details?: ITreeElementRenderDetails): void;
+    disposeElement(_element: ITreeNode<T, IQuickTreeFilterData>, _index: number, templateData: IQuickTreeTemplateData, _details?: ITreeElementRenderDetails): void;
+    disposeTemplate(templateData: IQuickTreeTemplateData): void;
+}

package/vscode/src/vs/platform/quickinput/browser/tree/quickInputTreeRenderer.js

@@ -0,0 +1,148 @@
+
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { asCSSUrl } from '../../../../base/browser/cssValue.js';
+import { $ as $$1, append, prepend } from '../../../../base/browser/dom.js';
+import { ActionBar } from '../../../../base/browser/ui/actionbar/actionbar.js';
+import { IconLabel } from '../../../../base/browser/ui/iconLabel/iconLabel.js';
+import { TriStateCheckbox } from '../../../../base/browser/ui/toggle/toggle.js';
+import { Event } from '../../../../base/common/event.js';
+import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { URI } from '../../../../base/common/uri.js';
+import { defaultCheckboxStyles } from '../../../theme/browser/defaultStyles.js';
+import { isDark } from '../../../theme/common/theme.js';
+import { escape } from '../../../../base/common/strings.js';
+import { IThemeService } from '../../../theme/common/themeService.service.js';
+import { quickInputButtonToAction } from '../quickInputUtils.js';
+
+var QuickInputTreeRenderer_1;
+const $ = $$1;
+let QuickInputTreeRenderer = class QuickInputTreeRenderer extends Disposable {
+    static { QuickInputTreeRenderer_1 = this; }
+    static { this.ID = 'quickInputTreeElement'; }
+    constructor(_hoverDelegate, _buttonTriggeredEmitter, onCheckedEvent, _themeService) {
+        super();
+        this._hoverDelegate = _hoverDelegate;
+        this._buttonTriggeredEmitter = _buttonTriggeredEmitter;
+        this.onCheckedEvent = onCheckedEvent;
+        this._themeService = _themeService;
+        this.templateId = QuickInputTreeRenderer_1.ID;
+    }
+    renderTemplate(container) {
+        const store = ( new DisposableStore());
+        const entry = append(container, $('.quick-input-tree-entry'));
+        const checkbox = store.add(( new TriStateCheckbox('', false, { ...defaultCheckboxStyles, size: 15 })));
+        entry.appendChild(checkbox.domNode);
+        const checkboxLabel = append(entry, $('label.quick-input-tree-label'));
+        const rows = append(checkboxLabel, $('.quick-input-tree-rows'));
+        const row1 = append(rows, $('.quick-input-tree-row'));
+        const icon = prepend(row1, $('.quick-input-tree-icon'));
+        const label = store.add(( new IconLabel(row1, {
+            supportHighlights: true,
+            supportDescriptionHighlights: true,
+            supportIcons: true,
+            hoverDelegate: this._hoverDelegate
+        })));
+        const row2 = append(rows, $('.quick-input-tree-row'));
+        const detailContainer = append(row2, $('.quick-input-tree-detail'));
+        const detail = store.add(( new IconLabel(detailContainer, {
+            supportHighlights: true,
+            supportIcons: true,
+            hoverDelegate: this._hoverDelegate
+        })));
+        const actionBar = store.add(( new ActionBar(
+            entry,
+            this._hoverDelegate ? { hoverDelegate: this._hoverDelegate } : undefined
+        )));
+        actionBar.domNode.classList.add('quick-input-tree-entry-action-bar');
+        return {
+            toDisposeTemplate: store,
+            entry,
+            checkbox,
+            icon,
+            label,
+            detail,
+            actionBar,
+            toDisposeElement: ( new DisposableStore()),
+        };
+    }
+    renderElement(node, index, templateData, details) {
+        const store = templateData.toDisposeElement;
+        const quickTreeItem = node.element;
+        templateData.checkbox.domNode.style.display = '';
+        templateData.checkbox.checked = quickTreeItem.checked ?? false;
+        store.add(Event.filter(this.onCheckedEvent, e => e.item === quickTreeItem)(e => templateData.checkbox.checked = e.checked));
+        if (quickTreeItem.iconPath) {
+            const icon = isDark(this._themeService.getColorTheme().type) ? quickTreeItem.iconPath.dark : (quickTreeItem.iconPath.light ?? quickTreeItem.iconPath.dark);
+            const iconUrl = URI.revive(icon);
+            templateData.icon.className = 'quick-input-tree-icon';
+            templateData.icon.style.backgroundImage = asCSSUrl(iconUrl);
+        }
+        else {
+            templateData.icon.style.backgroundImage = '';
+            templateData.icon.className = quickTreeItem.iconClass ? `quick-input-tree-icon ${quickTreeItem.iconClass}` : '';
+        }
+        const { labelHighlights: matches, descriptionHighlights: descriptionMatches, detailHighlights } = node.filterData || {};
+        let descriptionTitle;
+        if (quickTreeItem.description) {
+            descriptionTitle = {
+                markdown: {
+                    value: escape(quickTreeItem.description),
+                    supportThemeIcons: true
+                },
+                markdownNotSupportedFallback: quickTreeItem.description
+            };
+        }
+        templateData.label.setLabel(quickTreeItem.label, quickTreeItem.description, {
+            matches,
+            descriptionMatches,
+            extraClasses: quickTreeItem.iconClasses,
+            italic: quickTreeItem.italic,
+            strikethrough: quickTreeItem.strikethrough,
+            labelEscapeNewLines: true,
+            descriptionTitle
+        });
+        if (!quickTreeItem.detail) {
+            templateData.detail.element.style.display = 'none';
+        }
+        else {
+            let title;
+            if (!quickTreeItem.tooltip) {
+                title = {
+                    markdown: {
+                        value: escape(quickTreeItem.detail),
+                        supportThemeIcons: true
+                    },
+                    markdownNotSupportedFallback: quickTreeItem.detail
+                };
+            }
+            templateData.detail.setLabel(quickTreeItem.detail, undefined, {
+                matches: detailHighlights,
+                title,
+                labelEscapeNewLines: true
+            });
+        }
+        const buttons = quickTreeItem.buttons;
+        if (buttons && buttons.length) {
+            templateData.actionBar.push(( buttons.map(
+                (button, index) => quickInputButtonToAction(button, `tree-${index}`, () => this._buttonTriggeredEmitter.fire({ item: quickTreeItem, button }))
+            )), { icon: true, label: false });
+            templateData.entry.classList.add('has-actions');
+        }
+        else {
+            templateData.entry.classList.remove('has-actions');
+        }
+    }
+    disposeElement(_element, _index, templateData, _details) {
+        templateData.toDisposeElement.clear();
+        templateData.actionBar.clear();
+    }
+    disposeTemplate(templateData) {
+        templateData.toDisposeElement.dispose();
+        templateData.toDisposeTemplate.dispose();
+    }
+};
+QuickInputTreeRenderer = QuickInputTreeRenderer_1 = ( __decorate([
+    ( __param(3, IThemeService))
+], QuickInputTreeRenderer));
+
+export { QuickInputTreeRenderer };

package/vscode/src/vs/platform/quickinput/browser/tree/quickTree.d.ts

@@ -0,0 +1,53 @@
+import { Event } from "../../../../base/common/event.js";
+import { IReader } from "../../../../base/common/observable.js";
+import { IQuickTree, IQuickTreeItem, IQuickTreeItemButtonEvent, QuickInputType, QuickPickFocus } from "../../common/quickInput.js";
+import { QuickInput, QuickInputUI } from "../quickInput.js";
+export declare class QuickTree<T extends IQuickTreeItem> extends QuickInput implements IQuickTree<T> {
+    private static readonly DEFAULT_ARIA_LABEL;
+    readonly type = QuickInputType.QuickTree;
+    private readonly _value;
+    private readonly _ariaLabel;
+    private readonly _placeholder;
+    private readonly _matchOnDescription;
+    private readonly _matchOnDetail;
+    private readonly _matchOnLabel;
+    private readonly _activeItems;
+    private readonly _itemTree;
+    readonly onDidChangeValue: Event<string>;
+    readonly onDidChangeActive: Event<readonly T[]>;
+    private readonly _onDidChangeCheckedLeafItems;
+    onDidChangeCheckedLeafItems: Event<T[]>;
+    readonly onDidAccept: Event<void>;
+    constructor(ui: QuickInputUI);
+    get value(): string;
+    set value(value: string);
+    get ariaLabel(): string | undefined;
+    set ariaLabel(ariaLabel: string | undefined);
+    get placeholder(): string | undefined;
+    set placeholder(placeholder: string | undefined);
+    get matchOnDescription(): boolean;
+    set matchOnDescription(matchOnDescription: boolean);
+    get matchOnDetail(): boolean;
+    set matchOnDetail(matchOnDetail: boolean);
+    get matchOnLabel(): boolean;
+    set matchOnLabel(matchOnLabel: boolean);
+    get activeItems(): readonly T[];
+    set activeItems(activeItems: readonly T[]);
+    get itemTree(): ReadonlyArray<Readonly<T>>;
+    get onDidTriggerItemButton(): Event<IQuickTreeItemButtonEvent<T>>;
+    get checkedLeafItems(): readonly T[];
+    setItemTree(itemTree: T[]): void;
+    getParent(element: T): T | undefined;
+    setCheckboxState(element: T, checked: boolean | "partial"): void;
+    expand(element: T): void;
+    collapse(element: T): void;
+    isCollapsed(element: T): boolean;
+    focusOnInput(): void;
+    show(): void;
+    protected update(): void;
+    _registerListeners(): void;
+    _registerAutoruns(): void;
+    registerVisibleAutorun(fn: (reader: IReader) => void): void;
+    focus(focus: QuickPickFocus): void;
+    accept(_inBackground?: boolean): void;
+}