monaco-editor11 1.1.1 → 1.1.2

package/dist/workers/quickInputService.js

@@ -0,0 +1,197 @@
+import { CancellationToken } from '../../../base/common/cancellation.js';
+import { Emitter } from '../../../base/common/event.js';
+import { IContextKeyService, RawContextKey } from '../../contextkey/common/contextkey.js';
+import { IInstantiationService } from '../../instantiation/common/instantiation.js';
+import { ILayoutService } from '../../layout/browser/layoutService.js';
+import { IOpenerService } from '../../opener/common/opener.js';
+import { QuickAccessController } from './quickAccess.js';
+import { getListStyles, defaultKeybindingLabelStyles, defaultProgressBarStyles, defaultButtonStyles, defaultCountBadgeStyles, defaultToggleStyles, defaultInputBoxStyles } from '../../theme/browser/defaultStyles.js';
+import { asCssVariable } from '../../theme/common/colorUtils.js';
+import { activeContrastBorder } from '../../theme/common/colors/baseColors.js';
+import '../../theme/common/colors/chartsColors.js';
+import { widgetShadow, widgetBorder } from '../../theme/common/colors/editorColors.js';
+import '../../theme/common/colors/inputColors.js';
+import '../../theme/common/colors/listColors.js';
+import '../../theme/common/colors/menuColors.js';
+import '../../theme/common/colors/minimapColors.js';
+import '../../theme/common/colors/miscColors.js';
+import { pickerGroupForeground, pickerGroupBorder, quickInputBackground, quickInputListFocusBackground, quickInputListFocusIconForeground, quickInputListFocusForeground, quickInputTitleBackground, quickInputForeground } from '../../theme/common/colors/quickpickColors.js';
+import '../../theme/common/colors/searchColors.js';
+import { IThemeService, Themable } from '../../theme/common/themeService.js';
+import { QuickInputHoverDelegate } from './quickInput.js';
+import { QuickInputController } from './quickInputController.js';
+import { IConfigurationService } from '../../configuration/common/configuration.js';
+import { getWindow } from '../../../base/browser/dom.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (undefined && undefined.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+let QuickInputService = class QuickInputService extends Themable {
+    get controller() {
+        if (!this._controller) {
+            this._controller = this._register(this.createController());
+        }
+        return this._controller;
+    }
+    get hasController() { return !!this._controller; }
+    get currentQuickInput() { return this.controller.currentQuickInput; }
+    get quickAccess() {
+        if (!this._quickAccess) {
+            this._quickAccess = this._register(this.instantiationService.createInstance(QuickAccessController));
+        }
+        return this._quickAccess;
+    }
+    constructor(instantiationService, contextKeyService, themeService, layoutService, configurationService) {
+        super(themeService);
+        this.instantiationService = instantiationService;
+        this.contextKeyService = contextKeyService;
+        this.layoutService = layoutService;
+        this.configurationService = configurationService;
+        this._onShow = this._register(new Emitter());
+        this._onHide = this._register(new Emitter());
+        this.contexts = new Map();
+    }
+    createController(host = this.layoutService, options) {
+        const defaultOptions = {
+            idPrefix: 'quickInput_',
+            container: host.activeContainer,
+            ignoreFocusOut: () => false,
+            backKeybindingLabel: () => undefined,
+            setContextKey: (id) => this.setContextKey(id),
+            linkOpenerDelegate: (content) => {
+                // HACK: https://github.com/microsoft/vscode/issues/173691
+                this.instantiationService.invokeFunction(accessor => {
+                    const openerService = accessor.get(IOpenerService);
+                    openerService.open(content, { allowCommands: true, fromUserGesture: true });
+                });
+            },
+            returnFocus: () => host.focus(),
+            styles: this.computeStyles(),
+            hoverDelegate: this._register(this.instantiationService.createInstance(QuickInputHoverDelegate))
+        };
+        const controller = this._register(this.instantiationService.createInstance(QuickInputController, {
+            ...defaultOptions,
+            ...options
+        }));
+        controller.layout(host.activeContainerDimension, host.activeContainerOffset.quickPickTop);
+        // Layout changes
+        this._register(host.onDidLayoutActiveContainer(dimension => {
+            if (getWindow(host.activeContainer) === getWindow(controller.container)) {
+                controller.layout(dimension, host.activeContainerOffset.quickPickTop);
+            }
+        }));
+        this._register(host.onDidChangeActiveContainer(() => {
+            if (controller.isVisible()) {
+                return;
+            }
+            controller.layout(host.activeContainerDimension, host.activeContainerOffset.quickPickTop);
+        }));
+        // Context keys
+        this._register(controller.onShow(() => {
+            this.resetContextKeys();
+            this._onShow.fire();
+        }));
+        this._register(controller.onHide(() => {
+            this.resetContextKeys();
+            this._onHide.fire();
+        }));
+        return controller;
+    }
+    setContextKey(id) {
+        let key;
+        if (id) {
+            key = this.contexts.get(id);
+            if (!key) {
+                key = new RawContextKey(id, false)
+                    .bindTo(this.contextKeyService);
+                this.contexts.set(id, key);
+            }
+        }
+        if (key && key.get()) {
+            return; // already active context
+        }
+        this.resetContextKeys();
+        key?.set(true);
+    }
+    resetContextKeys() {
+        this.contexts.forEach(context => {
+            if (context.get()) {
+                context.reset();
+            }
+        });
+    }
+    pick(picks, options, token = CancellationToken.None) {
+        return this.controller.pick(picks, options, token);
+    }
+    input(options = {}, token = CancellationToken.None) {
+        return this.controller.input(options, token);
+    }
+    createQuickPick(options = { useSeparators: false }) {
+        return this.controller.createQuickPick(options);
+    }
+    createInputBox() {
+        return this.controller.createInputBox();
+    }
+    toggleHover() {
+        if (this.hasController) {
+            this.controller.toggleHover();
+        }
+    }
+    updateStyles() {
+        if (this.hasController) {
+            this.controller.applyStyles(this.computeStyles());
+        }
+    }
+    computeStyles() {
+        return {
+            widget: {
+                quickInputBackground: asCssVariable(quickInputBackground),
+                quickInputForeground: asCssVariable(quickInputForeground),
+                quickInputTitleBackground: asCssVariable(quickInputTitleBackground),
+                widgetBorder: asCssVariable(widgetBorder),
+                widgetShadow: asCssVariable(widgetShadow),
+            },
+            inputBox: defaultInputBoxStyles,
+            toggle: defaultToggleStyles,
+            countBadge: defaultCountBadgeStyles,
+            button: defaultButtonStyles,
+            progressBar: defaultProgressBarStyles,
+            keybindingLabel: defaultKeybindingLabelStyles,
+            list: getListStyles({
+                listBackground: quickInputBackground,
+                listFocusBackground: quickInputListFocusBackground,
+                listFocusForeground: quickInputListFocusForeground,
+                // Look like focused when inactive.
+                listInactiveFocusForeground: quickInputListFocusForeground,
+                listInactiveSelectionIconForeground: quickInputListFocusIconForeground,
+                listInactiveFocusBackground: quickInputListFocusBackground,
+                listFocusOutline: activeContrastBorder,
+                listInactiveFocusOutline: activeContrastBorder,
+                treeStickyScrollBackground: quickInputBackground,
+            }),
+            pickerGroup: {
+                pickerGroupBorder: asCssVariable(pickerGroupBorder),
+                pickerGroupForeground: asCssVariable(pickerGroupForeground),
+            }
+        };
+    }
+};
+QuickInputService = __decorate([
+    __param(0, IInstantiationService),
+    __param(1, IContextKeyService),
+    __param(2, IThemeService),
+    __param(3, ILayoutService),
+    __param(4, IConfigurationService)
+], QuickInputService);
+
+export { QuickInputService };

package/dist/workers/quickInputTree.js

@@ -0,0 +1,37 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+function getParentNodeState(parentChildren) {
+    let containsChecks = false;
+    let containsUnchecks = false;
+    let containsMixed = false;
+    for (const element of parentChildren) {
+        switch (element.element?.checked) {
+            case 'mixed':
+                containsMixed = true;
+                break;
+            case true:
+                containsChecks = true;
+                break;
+            default:
+                containsUnchecks = true;
+                break;
+        }
+        if (containsChecks && containsUnchecks && containsMixed) {
+            break;
+        }
+    }
+    const newState = containsUnchecks
+        ? containsMixed
+            ? 'mixed'
+            : containsChecks
+                ? 'mixed'
+                : false
+        : containsMixed
+            ? 'mixed'
+            : containsChecks;
+    return newState;
+}
+
+export { getParentNodeState };

package/dist/workers/quickInputTreeAccessibilityProvider.js

@@ -0,0 +1,39 @@
+import { Event } from '../../../../base/common/event.js';
+import { getCodiconAriaLabel } from '../../../../base/common/iconLabels.js';
+import { localize } from '../../../../nls.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * Accessibility provider for QuickTree.
+ */
+class QuickTreeAccessibilityProvider {
+    constructor(onCheckedEvent) {
+        this.onCheckedEvent = onCheckedEvent;
+    }
+    getWidgetAriaLabel() {
+        return localize(1772, "Quick Tree");
+    }
+    getAriaLabel(element) {
+        return element.ariaLabel || [element.label, element.description]
+            .map(s => getCodiconAriaLabel(s))
+            .filter(s => !!s)
+            .join(', ');
+    }
+    getWidgetRole() {
+        return 'tree';
+    }
+    getRole(_element) {
+        return 'checkbox';
+    }
+    isChecked(element) {
+        return {
+            get value() { return element.checked === 'mixed' ? 'mixed' : !!element.checked; },
+            onDidChange: e => Event.filter(this.onCheckedEvent, e => e.item === element)(_ => e()),
+        };
+    }
+}
+
+export { QuickTreeAccessibilityProvider };

package/dist/workers/quickInputTreeController.js

@@ -0,0 +1,181 @@
+import { append, $ as $$1 } from '../../../../base/browser/dom.js';
+import { RenderIndentGuides } from '../../../../base/browser/ui/tree/abstractTree.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 { QuickInputTreeDelegate } from './quickInputDelegate.js';
+import { getParentNodeState } from './quickInputTree.js';
+import { QuickTreeAccessibilityProvider } from './quickInputTreeAccessibilityProvider.js';
+import { QuickInputTreeFilter } from './quickInputTreeFilter.js';
+import { QuickInputTreeRenderer } from './quickInputTreeRenderer.js';
+import { QuickInputTreeSorter } from './quickInputTreeSorter.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (undefined && undefined.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+const $ = $$1;
+let QuickInputTreeController = class QuickInputTreeController extends Disposable {
+    constructor(container, hoverDelegate, instantiationService) {
+        super();
+        this.instantiationService = instantiationService;
+        this._onDidTriggerButton = this._register(new Emitter());
+        this._onDidChangeCheckboxState = this._register(new Emitter());
+        this.onDidChangeCheckboxState = this._onDidChangeCheckboxState.event;
+        this._onDidCheckedLeafItemsChange = this._register(new Emitter);
+        this._onLeave = new Emitter();
+        /**
+         * Event that is fired when the tree would no longer have focus.
+        */
+        this.onLeave = this._onLeave.event;
+        this._onDidAccept = this._register(new Emitter());
+        /**
+         * Event that is fired when a non-pickable item is clicked, indicating acceptance.
+         */
+        this.onDidAccept = this._onDidAccept.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._sorter = this._register(new QuickInputTreeSorter());
+        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,
+            renderIndentGuides: RenderIndentGuides.None,
+            expandOnDoubleClick: true,
+            expandOnlyOnTwistieClick: true,
+            disableExpandOnSpacebar: true,
+            sorter: this._sorter,
+            filter: this._filter
+        }));
+        this.registerOnOpenListener();
+    }
+    get tree() {
+        return this._tree;
+    }
+    get displayed() {
+        return this._container.style.display !== 'none';
+    }
+    set displayed(value) {
+        this._container.style.display = value ? '' : 'none';
+    }
+    get sortByLabel() {
+        return this._sorter.sortByLabel;
+    }
+    set sortByLabel(value) {
+        this._sorter.sortByLabel = value;
+        this._tree.resort(null, true);
+    }
+    getActiveDescendant() {
+        return this._tree.getHTMLElement().getAttribute('aria-activedescendant');
+    }
+    updateFilterOptions(options) {
+        if (options.matchOnLabel !== undefined) {
+            this._filter.matchOnLabel = options.matchOnLabel;
+        }
+        if (options.matchOnDescription !== undefined) {
+            this._filter.matchOnDescription = options.matchOnDescription;
+        }
+        this._tree.refilter();
+    }
+    layout(maxHeight) {
+        this._tree.getHTMLElement().style.maxHeight = maxHeight ? `${
+        // Make sure height aligns with list item heights
+        Math.floor(maxHeight / 44) * 44
+            // Add some extra height so that it's clear there's more to scroll
+            + 6}px` : '';
+        this._tree.layout();
+    }
+    registerOnOpenListener() {
+        this._register(this._tree.onDidOpen(e => {
+            const item = e.element;
+            if (!item) {
+                return;
+            }
+            if (item.disabled) {
+                return;
+            }
+            // Check if the item is pickable (defaults to true if not specified)
+            if (item.pickable === false) {
+                // For non-pickable items, set it as the active item and fire the accept event
+                this._tree.setFocus([item]);
+                this._onDidAccept.fire();
+                return;
+            }
+            const newState = item.checked !== true;
+            if ((item.checked ?? false) === newState) {
+                return; // No change
+            }
+            // Handle checked item
+            item.checked = newState;
+            this._tree.rerender(item);
+            // Handle children of the checked 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);
+                }
+            }
+            // Handle parents of the checked item
+            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;
+    }
+};
+QuickInputTreeController = __decorate([
+    __param(2, IInstantiationService)
+], QuickInputTreeController);
+
+export { QuickInputTreeController };

package/dist/workers/quickInputTreeFilter.js

@@ -0,0 +1,42 @@
+import { matchesFuzzyIconAware, parseLabelWithIcons } from '../../../../base/common/iconLabels.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class QuickInputTreeFilter {
+    constructor() {
+        this.filterValue = '';
+        this.matchOnLabel = true;
+        this.matchOnDescription = false;
+    }
+    filter(element, parentVisibility) {
+        if (!this.filterValue || !(this.matchOnLabel || this.matchOnDescription)) {
+            return element.children
+                ? { visibility: 2 /* TreeVisibility.Recurse */, data: {} }
+                : { visibility: 1 /* 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 visibility = parentVisibility === 1 /* TreeVisibility.Visible */
+            // Parent is visible because it had matches, so we show all children
+            ? 1 /* TreeVisibility.Visible */
+            // This would only happen on Parent is recurse so...
+            : (labelHighlights || descriptionHighlights)
+                // If we have any highlights, we are visible
+                ? 1 /* TreeVisibility.Visible */
+                // Otherwise, we defer to the children or if no children, we are hidden
+                : element.children
+                    ? 2 /* TreeVisibility.Recurse */
+                    : 0 /* TreeVisibility.Hidden */;
+        return {
+            visibility,
+            data: {
+                labelHighlights,
+                descriptionHighlights
+            }
+        };
+    }
+}
+
+export { QuickInputTreeFilter };

package/dist/workers/quickInputTreeRenderer.js

@@ -0,0 +1,141 @@
+import { asCSSUrl } from '../../../../base/browser/cssValue.js';
+import { append, $ as $$1, 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.js';
+import { quickInputButtonToAction } from '../quickInputUtils.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (undefined && undefined.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+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();
+        // Main entry container
+        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 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,
+            actionBar,
+            toDisposeElement: new DisposableStore(),
+        };
+    }
+    renderElement(node, index, templateData, _details) {
+        const store = templateData.toDisposeElement;
+        const quickTreeItem = node.element;
+        // Checkbox
+        if (quickTreeItem.pickable === false) {
+            // Hide checkbox for non-pickable items
+            templateData.checkbox.domNode.style.display = 'none';
+        }
+        else {
+            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.disabled) {
+                templateData.checkbox.disable();
+            }
+        }
+        // Icon
+        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 } = node.filterData || {};
+        // Label and Description
+        let descriptionTitle;
+        // NOTE: If we bring back quick tool tips, we need to check that here like we do in the QuickInputListRenderer
+        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
+        });
+        // Action Bar
+        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 };