@codingame/monaco-vscode-api 1.85.0 → 1.85.2

package/vscode/src/vs/workbench/browser/parts/views/treeView.js

@@ -0,0 +1,1614 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { DataTransfers } from 'monaco-editor/esm/vs/base/browser/dnd.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { renderMarkdownAsPlaintext } from 'monaco-editor/esm/vs/base/browser/markdownRenderer.js';
+import { ActionBar } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.js';
+import { ActionViewItem } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionViewItems.js';
+import { CollapseAllAction } from '../../../../base/browser/ui/tree/treeDefaults.js';
+import { ActionRunner } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { timeout } from 'monaco-editor/esm/vs/base/common/async.js';
+import { CancellationTokenSource, CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { isCancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { createMatches } from 'monaco-editor/esm/vs/base/common/filters.js';
+import { isMarkdownString } from 'monaco-editor/esm/vs/base/common/htmlContent.js';
+import { Disposable, DisposableStore, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Mimes } from 'monaco-editor/esm/vs/base/common/mime.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { basename, dirname } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { isFalsyOrWhitespace } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { isString } from 'monaco-editor/esm/vs/base/common/types.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
+import './media/views.css.js';
+import { VSDataTransfer } from 'monaco-editor/esm/vs/base/common/dataTransfer.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { createActionViewItem, createAndFillInContextMenuActions } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
+import { MenuId, MenuRegistry, registerAction2, Action2, IMenuService } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { CommandsRegistry, ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IContextKeyService, RawContextKey, ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { FileKind } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { WorkbenchAsyncDataTree } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { IProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { ColorScheme } from 'monaco-editor/esm/vs/platform/theme/common/theme.js';
+import { FolderThemeIcon, FileThemeIcon, IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { fillEditorsDragData } from '../../dnd.js';
+import { ResourceLabels } from '../../labels.js';
+import { API_OPEN_EDITOR_COMMAND_ID, API_OPEN_DIFF_EDITOR_COMMAND_ID } from '../editor/editorCommands.js';
+import { ViewPane } from './viewPane.js';
+import { PANEL_BACKGROUND, SIDE_BAR_BACKGROUND } from '../../../common/theme.js';
+import { ResolvableTreeItem, TreeItemCollapsibleState, Extensions, IViewDescriptorService } from '../../../common/views.js';
+import { IActivityService, NumberBadge } from '../../../services/activity/common/activity.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.js';
+import { IHoverService } from '../../../services/hover/browser/hover.js';
+import { ITreeViewsService } from '../../../services/views/browser/treeViewsService.js';
+import { LocalSelectionTransfer, CodeDataTransfers } from 'monaco-editor/esm/vs/platform/dnd/browser/dnd.js';
+import { toExternalVSDataTransfer } from 'monaco-editor/esm/vs/editor/browser/dnd.js';
+import { TreeItemCheckbox, CheckboxStateHandler } from './checkbox.js';
+import { setTimeout0 } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { TelemetryTrustedValue } from '../../../../platform/telemetry/common/telemetryUtils.js';
+import { ITreeViewsDnDService } from 'monaco-editor/esm/vs/editor/common/services/treeViewsDndService.js';
+import { DraggedTreeItemsIdentifier } from 'monaco-editor/esm/vs/editor/common/services/treeViewsDnd.js';
+import { MarkdownRenderer } from 'monaco-editor/esm/vs/editor/contrib/markdownRenderer/browser/markdownRenderer.js';
+var TreeRenderer_1;
+let TreeViewPane = class TreeViewPane extends ViewPane {
+    constructor(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService, notificationService) {
+        super({ ...options, titleMenuId: MenuId.ViewTitle, donotForwardArgs: false }, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
+        const { treeView } = ( Registry.as(Extensions.ViewsRegistry)).getView(options.id);
+        this.treeView = treeView;
+        this._register(this.treeView.onDidChangeActions(() => this.updateActions(), this));
+        this._register(this.treeView.onDidChangeTitle((newTitle) => this.updateTitle(newTitle)));
+        this._register(this.treeView.onDidChangeDescription((newDescription) => this.updateTitleDescription(newDescription)));
+        this._register(toDisposable(() => {
+            if (this._container && this.treeView.container && (this._container === this.treeView.container)) {
+                this.treeView.setVisibility(false);
+            }
+        }));
+        this._register(this.onDidChangeBodyVisibility(() => this.updateTreeVisibility()));
+        this._register(this.treeView.onDidChangeWelcomeState(() => this._onDidChangeViewWelcomeState.fire()));
+        if (options.title !== this.treeView.title) {
+            this.updateTitle(this.treeView.title);
+        }
+        if (options.titleDescription !== this.treeView.description) {
+            this.updateTitleDescription(this.treeView.description);
+        }
+        this._actionRunner = ( new MultipleSelectionActionRunner(notificationService, () => this.treeView.getSelection()));
+        this.updateTreeVisibility();
+    }
+    focus() {
+        super.focus();
+        this.treeView.focus();
+    }
+    renderBody(container) {
+        this._container = container;
+        super.renderBody(container);
+        this.renderTreeView(container);
+    }
+    shouldShowWelcome() {
+        return ((this.treeView.dataProvider === undefined) || !!this.treeView.dataProvider.isTreeEmpty) && ((this.treeView.message === undefined) || (this.treeView.message === ''));
+    }
+    layoutBody(height, width) {
+        super.layoutBody(height, width);
+        this.layoutTreeView(height, width);
+    }
+    getOptimalWidth() {
+        return this.treeView.getOptimalWidth();
+    }
+    renderTreeView(container) {
+        this.treeView.show(container);
+    }
+    layoutTreeView(height, width) {
+        this.treeView.layout(height, width);
+    }
+    updateTreeVisibility() {
+        this.treeView.setVisibility(this.isBodyVisible());
+    }
+    getActionRunner() {
+        return this._actionRunner;
+    }
+    getActionsContext() {
+        return { $treeViewId: this.id, $focusedTreeItem: true, $selectedTreeItems: true };
+    }
+};
+TreeViewPane = ( __decorate([
+    ( __param(1, IKeybindingService)),
+    ( __param(2, IContextMenuService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, IContextKeyService)),
+    ( __param(5, IViewDescriptorService)),
+    ( __param(6, IInstantiationService)),
+    ( __param(7, IOpenerService)),
+    ( __param(8, IThemeService)),
+    ( __param(9, ITelemetryService)),
+    ( __param(10, INotificationService))
+], TreeViewPane));
+class Root {
+    constructor() {
+        this.label = { label: 'root' };
+        this.handle = '0';
+        this.parentHandle = undefined;
+        this.collapsibleState = TreeItemCollapsibleState.Expanded;
+        this.children = undefined;
+    }
+}
+function isTreeCommandEnabled(treeCommand, contextKeyService) {
+    const command = CommandsRegistry.getCommand(treeCommand.originalId ? treeCommand.originalId : treeCommand.id);
+    if (command) {
+        const commandAction = MenuRegistry.getCommand(command.id);
+        const precondition = commandAction && commandAction.precondition;
+        if (precondition) {
+            return contextKeyService.contextMatchesRules(precondition);
+        }
+    }
+    return true;
+}
+function isRenderedMessageValue(messageValue) {
+    return !!messageValue && typeof messageValue !== 'string' && 'element' in messageValue && 'dispose' in messageValue;
+}
+const noDataProviderMessage = ( localizeWithPath(
+    'vs/workbench/browser/parts/views/treeView',
+    'no-dataprovider',
+    "There is no data provider registered that can provide view data."
+));
+const RawCustomTreeViewContextKey = ( new RawContextKey('customTreeView', false));
+class Tree extends WorkbenchAsyncDataTree {
+}
+let AbstractTreeView = class AbstractTreeView extends Disposable {
+    constructor(id, _title, themeService, instantiationService, commandService, configurationService, progressService, contextMenuService, keybindingService, notificationService, viewDescriptorService, hoverService, contextKeyService, activityService, logService) {
+        super();
+        this.id = id;
+        this._title = _title;
+        this.themeService = themeService;
+        this.instantiationService = instantiationService;
+        this.commandService = commandService;
+        this.configurationService = configurationService;
+        this.progressService = progressService;
+        this.contextMenuService = contextMenuService;
+        this.keybindingService = keybindingService;
+        this.notificationService = notificationService;
+        this.viewDescriptorService = viewDescriptorService;
+        this.hoverService = hoverService;
+        this.contextKeyService = contextKeyService;
+        this.activityService = activityService;
+        this.logService = logService;
+        this.isVisible = false;
+        this._hasIconForParentNode = false;
+        this._hasIconForLeafNode = false;
+        this.focused = false;
+        this._canSelectMany = false;
+        this._manuallyManageCheckboxes = false;
+        this.elementsToRefresh = [];
+        this.lastSelection = [];
+        this._onDidExpandItem = this._register(( new Emitter()));
+        this.onDidExpandItem = this._onDidExpandItem.event;
+        this._onDidCollapseItem = this._register(( new Emitter()));
+        this.onDidCollapseItem = this._onDidCollapseItem.event;
+        this._onDidChangeSelectionAndFocus = this._register(( new Emitter()));
+        this.onDidChangeSelectionAndFocus = this._onDidChangeSelectionAndFocus.event;
+        this._onDidChangeVisibility = this._register(( new Emitter()));
+        this.onDidChangeVisibility = this._onDidChangeVisibility.event;
+        this._onDidChangeActions = this._register(( new Emitter()));
+        this.onDidChangeActions = this._onDidChangeActions.event;
+        this._onDidChangeWelcomeState = this._register(( new Emitter()));
+        this.onDidChangeWelcomeState = this._onDidChangeWelcomeState.event;
+        this._onDidChangeTitle = this._register(( new Emitter()));
+        this.onDidChangeTitle = this._onDidChangeTitle.event;
+        this._onDidChangeDescription = this._register(( new Emitter()));
+        this.onDidChangeDescription = this._onDidChangeDescription.event;
+        this._onDidChangeCheckboxState = this._register(( new Emitter()));
+        this.onDidChangeCheckboxState = this._onDidChangeCheckboxState.event;
+        this._onDidCompleteRefresh = this._register(( new Emitter()));
+        this._isInitialized = false;
+        this._height = 0;
+        this._width = 0;
+        this.refreshing = false;
+        this.root = ( new Root());
+        this.lastActive = this.root;
+    }
+    initialize() {
+        if (this._isInitialized) {
+            return;
+        }
+        this._isInitialized = true;
+        this.contextKeyService.bufferChangeEvents(() => {
+            this.initializeShowCollapseAllAction();
+            this.initializeCollapseAllToggle();
+            this.initializeShowRefreshAction();
+        });
+        this.treeViewDnd = this.instantiationService.createInstance(CustomTreeViewDragAndDrop, this.id);
+        if (this._dragAndDropController) {
+            this.treeViewDnd.controller = this._dragAndDropController;
+        }
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration('explorer.decorations')) {
+                this.doRefresh([this.root]);
+            }
+        }));
+        this._register(this.viewDescriptorService.onDidChangeLocation(({ views, from, to }) => {
+            if (( views.some(v => v.id === this.id))) {
+                this.tree?.updateOptions({ overrideStyles: { listBackground: this.viewLocation === 1  ? PANEL_BACKGROUND : SIDE_BAR_BACKGROUND } });
+            }
+        }));
+        this.registerActions();
+        this.create();
+    }
+    get viewContainer() {
+        return this.viewDescriptorService.getViewContainerByViewId(this.id);
+    }
+    get viewLocation() {
+        return this.viewDescriptorService.getViewLocationById(this.id);
+    }
+    get dragAndDropController() {
+        return this._dragAndDropController;
+    }
+    set dragAndDropController(dnd) {
+        this._dragAndDropController = dnd;
+        if (this.treeViewDnd) {
+            this.treeViewDnd.controller = dnd;
+        }
+    }
+    get dataProvider() {
+        return this._dataProvider;
+    }
+    set dataProvider(dataProvider) {
+        if (dataProvider) {
+            const self = this;
+            this._dataProvider = new (class {
+                constructor() {
+                    this._isEmpty = true;
+                    this._onDidChangeEmpty = ( new Emitter());
+                    this.onDidChangeEmpty = this._onDidChangeEmpty.event;
+                }
+                get isTreeEmpty() {
+                    return this._isEmpty;
+                }
+                async getChildren(node) {
+                    let children;
+                    const checkboxesUpdated = [];
+                    if (node && node.children) {
+                        children = node.children;
+                    }
+                    else {
+                        node = node ?? self.root;
+                        node.children = await (node instanceof Root ? dataProvider.getChildren() : dataProvider.getChildren(node));
+                        children = node.children ?? [];
+                        children.forEach(child => {
+                            child.parent = node;
+                            if (!self.manuallyManageCheckboxes && (node?.checkbox?.isChecked === true) && (child.checkbox?.isChecked === false)) {
+                                child.checkbox.isChecked = true;
+                                checkboxesUpdated.push(child);
+                            }
+                        });
+                    }
+                    if (node instanceof Root) {
+                        const oldEmpty = this._isEmpty;
+                        this._isEmpty = children.length === 0;
+                        if (oldEmpty !== this._isEmpty) {
+                            this._onDidChangeEmpty.fire();
+                        }
+                    }
+                    if (checkboxesUpdated.length > 0) {
+                        self._onDidChangeCheckboxState.fire(checkboxesUpdated);
+                    }
+                    return children;
+                }
+            });
+            if (this._dataProvider.onDidChangeEmpty) {
+                this._register(this._dataProvider.onDidChangeEmpty(() => {
+                    this.updateCollapseAllToggle();
+                    this._onDidChangeWelcomeState.fire();
+                }));
+            }
+            this.updateMessage();
+            this.refresh();
+        }
+        else {
+            this._dataProvider = undefined;
+            this.updateMessage();
+        }
+        this._onDidChangeWelcomeState.fire();
+    }
+    get message() {
+        return this._message;
+    }
+    set message(message) {
+        this._message = message;
+        this.updateMessage();
+        this._onDidChangeWelcomeState.fire();
+    }
+    get title() {
+        return this._title;
+    }
+    set title(name) {
+        this._title = name;
+        this._onDidChangeTitle.fire(this._title);
+    }
+    get description() {
+        return this._description;
+    }
+    set description(description) {
+        this._description = description;
+        this._onDidChangeDescription.fire(this._description);
+    }
+    get badge() {
+        return this._badge;
+    }
+    set badge(badge) {
+        if (this._badge?.value === badge?.value &&
+            this._badge?.tooltip === badge?.tooltip) {
+            return;
+        }
+        if (this._badgeActivity) {
+            this._badgeActivity.dispose();
+            this._badgeActivity = undefined;
+        }
+        this._badge = badge;
+        if (badge) {
+            const activity = {
+                badge: ( new NumberBadge(badge.value, () => badge.tooltip)),
+                priority: 50
+            };
+            this._badgeActivity = this.activityService.showViewActivity(this.id, activity);
+        }
+    }
+    get canSelectMany() {
+        return this._canSelectMany;
+    }
+    set canSelectMany(canSelectMany) {
+        const oldCanSelectMany = this._canSelectMany;
+        this._canSelectMany = canSelectMany;
+        if (this._canSelectMany !== oldCanSelectMany) {
+            this.tree?.updateOptions({ multipleSelectionSupport: this.canSelectMany });
+        }
+    }
+    get manuallyManageCheckboxes() {
+        return this._manuallyManageCheckboxes;
+    }
+    set manuallyManageCheckboxes(manuallyManageCheckboxes) {
+        this._manuallyManageCheckboxes = manuallyManageCheckboxes;
+    }
+    get hasIconForParentNode() {
+        return this._hasIconForParentNode;
+    }
+    get hasIconForLeafNode() {
+        return this._hasIconForLeafNode;
+    }
+    get visible() {
+        return this.isVisible;
+    }
+    initializeShowCollapseAllAction(startingValue = false) {
+        if (!this.collapseAllContext) {
+            this.collapseAllContextKey = ( new RawContextKey(`treeView.${this.id}.enableCollapseAll`, startingValue, ( localizeWithPath(
+                'vs/workbench/browser/parts/views/treeView',
+                'treeView.enableCollapseAll',
+                "Whether the the tree view with id {0} enables collapse all.",
+                this.id
+            ))));
+            this.collapseAllContext = this.collapseAllContextKey.bindTo(this.contextKeyService);
+        }
+        return true;
+    }
+    get showCollapseAllAction() {
+        this.initializeShowCollapseAllAction();
+        return !!this.collapseAllContext?.get();
+    }
+    set showCollapseAllAction(showCollapseAllAction) {
+        this.initializeShowCollapseAllAction(showCollapseAllAction);
+        this.collapseAllContext?.set(showCollapseAllAction);
+    }
+    initializeShowRefreshAction(startingValue = false) {
+        if (!this.refreshContext) {
+            this.refreshContextKey = ( new RawContextKey(`treeView.${this.id}.enableRefresh`, startingValue, ( localizeWithPath(
+                'vs/workbench/browser/parts/views/treeView',
+                'treeView.enableRefresh',
+                "Whether the tree view with id {0} enables refresh.",
+                this.id
+            ))));
+            this.refreshContext = this.refreshContextKey.bindTo(this.contextKeyService);
+        }
+    }
+    get showRefreshAction() {
+        this.initializeShowRefreshAction();
+        return !!this.refreshContext?.get();
+    }
+    set showRefreshAction(showRefreshAction) {
+        this.initializeShowRefreshAction(showRefreshAction);
+        this.refreshContext?.set(showRefreshAction);
+    }
+    registerActions() {
+        const that = this;
+        this._register(registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: `workbench.actions.treeView.${that.id}.refresh`,
+                    title: ( localizeWithPath('vs/workbench/browser/parts/views/treeView', 'refresh', "Refresh")),
+                    menu: {
+                        id: MenuId.ViewTitle,
+                        when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', that.id)), that.refreshContextKey)),
+                        group: 'navigation',
+                        order: Number.MAX_SAFE_INTEGER - 1,
+                    },
+                    icon: Codicon.refresh
+                });
+            }
+            async run() {
+                return that.refresh();
+            }
+        }));
+        this._register(registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: `workbench.actions.treeView.${that.id}.collapseAll`,
+                    title: ( localizeWithPath('vs/workbench/browser/parts/views/treeView', 'collapseAll', "Collapse All")),
+                    menu: {
+                        id: MenuId.ViewTitle,
+                        when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', that.id)), that.collapseAllContextKey)),
+                        group: 'navigation',
+                        order: Number.MAX_SAFE_INTEGER,
+                    },
+                    precondition: that.collapseAllToggleContextKey,
+                    icon: Codicon.collapseAll
+                });
+            }
+            async run() {
+                if (that.tree) {
+                    return ( new CollapseAllAction(that.tree, true)).run();
+                }
+            }
+        }));
+    }
+    setVisibility(isVisible) {
+        this.initialize();
+        isVisible = !!isVisible;
+        if (this.isVisible === isVisible) {
+            return;
+        }
+        this.isVisible = isVisible;
+        if (this.tree) {
+            if (this.isVisible) {
+                dom.show(this.tree.getHTMLElement());
+            }
+            else {
+                dom.hide(this.tree.getHTMLElement());
+            }
+            if (this.isVisible && this.elementsToRefresh.length && this.dataProvider) {
+                this.doRefresh(this.elementsToRefresh);
+                this.elementsToRefresh = [];
+            }
+        }
+        setTimeout0(() => {
+            if (this.dataProvider) {
+                this._onDidChangeVisibility.fire(this.isVisible);
+            }
+        });
+        if (this.visible) {
+            this.activate();
+        }
+    }
+    focus(reveal = true, revealItem) {
+        if (this.tree && this.root.children && this.root.children.length > 0) {
+            const element = revealItem ?? this.tree.getSelection()[0];
+            if (element && reveal) {
+                this.tree.reveal(element, 0.5);
+            }
+            this.tree.domFocus();
+        }
+        else if (this.tree && this.treeContainer && !this.treeContainer.classList.contains('hide')) {
+            this.tree.domFocus();
+        }
+        else {
+            this.domNode.focus();
+        }
+    }
+    show(container) {
+        this._container = container;
+        dom.append(container, this.domNode);
+    }
+    create() {
+        this.domNode = dom.$('.tree-explorer-viewlet-tree-view');
+        this.messageElement = dom.append(this.domNode, dom.$('.message'));
+        this.updateMessage();
+        this.treeContainer = dom.append(this.domNode, dom.$('.customview-tree'));
+        this.treeContainer.classList.add('file-icon-themable-tree', 'show-file-icons');
+        const focusTracker = this._register(dom.trackFocus(this.domNode));
+        this._register(focusTracker.onDidFocus(() => this.focused = true));
+        this._register(focusTracker.onDidBlur(() => this.focused = false));
+    }
+    createTree() {
+        const actionViewItemProvider = createActionViewItem.bind(undefined, this.instantiationService);
+        const treeMenus = this._register(this.instantiationService.createInstance(TreeMenus, this.id));
+        this.treeLabels = this._register(this.instantiationService.createInstance(ResourceLabels, this));
+        const dataSource = this.instantiationService.createInstance(TreeDataSource, this, (task) => this.progressService.withProgress({ location: this.id }, () => task));
+        const aligner = ( new Aligner(this.themeService));
+        const checkboxStateHandler = this._register(( new CheckboxStateHandler()));
+        const renderer = this.instantiationService.createInstance(TreeRenderer, this.id, treeMenus, this.treeLabels, actionViewItemProvider, aligner, checkboxStateHandler, () => this.manuallyManageCheckboxes);
+        this._register(renderer.onDidChangeCheckboxState(e => this._onDidChangeCheckboxState.fire(e)));
+        const widgetAriaLabel = this._title;
+        this.tree = this._register(this.instantiationService.createInstance(Tree, this.id, this.treeContainer, ( new TreeViewDelegate()), [renderer], dataSource, {
+            identityProvider: ( new TreeViewIdentityProvider()),
+            accessibilityProvider: {
+                getAriaLabel(element) {
+                    if (element.accessibilityInformation) {
+                        return element.accessibilityInformation.label;
+                    }
+                    if (isString(element.tooltip)) {
+                        return element.tooltip;
+                    }
+                    else {
+                        if (element.resourceUri && !element.label) {
+                            return null;
+                        }
+                        let buildAriaLabel = '';
+                        if (element.label) {
+                            buildAriaLabel += element.label.label + ' ';
+                        }
+                        if (element.description) {
+                            buildAriaLabel += element.description;
+                        }
+                        return buildAriaLabel;
+                    }
+                },
+                getRole(element) {
+                    return element.accessibilityInformation?.role ?? 'treeitem';
+                },
+                getWidgetAriaLabel() {
+                    return widgetAriaLabel;
+                }
+            },
+            keyboardNavigationLabelProvider: {
+                getKeyboardNavigationLabel: (item) => {
+                    return item.label ? item.label.label : (item.resourceUri ? basename(URI.revive(item.resourceUri)) : undefined);
+                }
+            },
+            expandOnlyOnTwistieClick: (e) => {
+                return !!e.command || !!e.checkbox || this.configurationService.getValue('workbench.tree.expandMode') === 'doubleClick';
+            },
+            collapseByDefault: (e) => {
+                return e.collapsibleState !== TreeItemCollapsibleState.Expanded;
+            },
+            multipleSelectionSupport: this.canSelectMany,
+            dnd: this.treeViewDnd,
+            overrideStyles: {
+                listBackground: this.viewLocation === 1  ? PANEL_BACKGROUND : SIDE_BAR_BACKGROUND
+            }
+        }));
+        treeMenus.setContextKeyService(this.tree.contextKeyService);
+        aligner.tree = this.tree;
+        const actionRunner = ( new MultipleSelectionActionRunner(this.notificationService, () => this.tree.getSelection()));
+        renderer.actionRunner = actionRunner;
+        this.tree.contextKeyService.createKey(this.id, true);
+        const customTreeKey = RawCustomTreeViewContextKey.bindTo(this.tree.contextKeyService);
+        customTreeKey.set(true);
+        this._register(this.tree.onContextMenu(e => this.onContextMenu(treeMenus, e, actionRunner)));
+        this._register(this.tree.onDidChangeSelection(e => {
+            this.lastSelection = e.elements;
+            this.lastActive = this.tree?.getFocus()[0] ?? this.lastActive;
+            this._onDidChangeSelectionAndFocus.fire({ selection: this.lastSelection, focus: this.lastActive });
+        }));
+        this._register(this.tree.onDidChangeFocus(e => {
+            if (e.elements.length && (e.elements[0] !== this.lastActive)) {
+                this.lastActive = e.elements[0];
+                this.lastSelection = this.tree?.getSelection() ?? this.lastSelection;
+                this._onDidChangeSelectionAndFocus.fire({ selection: this.lastSelection, focus: this.lastActive });
+            }
+        }));
+        this._register(this.tree.onDidChangeCollapseState(e => {
+            if (!e.node.element) {
+                return;
+            }
+            const element = Array.isArray(e.node.element.element) ? e.node.element.element[0] : e.node.element.element;
+            if (e.node.collapsed) {
+                this._onDidCollapseItem.fire(element);
+            }
+            else {
+                this._onDidExpandItem.fire(element);
+            }
+        }));
+        this.tree.setInput(this.root).then(() => this.updateContentAreas());
+        this._register(this.tree.onDidOpen(async (e) => {
+            if (!e.browserEvent) {
+                return;
+            }
+            if (e.browserEvent.target && e.browserEvent.target.classList.contains(TreeItemCheckbox.checkboxClass)) {
+                return;
+            }
+            const selection = this.tree.getSelection();
+            const command = await this.resolveCommand(selection.length === 1 ? selection[0] : undefined);
+            if (command && isTreeCommandEnabled(command, this.contextKeyService)) {
+                let args = command.arguments || [];
+                if (command.id === API_OPEN_EDITOR_COMMAND_ID || command.id === API_OPEN_DIFF_EDITOR_COMMAND_ID) {
+                    args = [...args, e];
+                }
+                try {
+                    await this.commandService.executeCommand(command.id, ...args);
+                }
+                catch (err) {
+                    this.notificationService.error(err);
+                }
+            }
+        }));
+        this._register(treeMenus.onDidChange((changed) => {
+            if (this.tree?.hasNode(changed)) {
+                this.tree?.rerender(changed);
+            }
+        }));
+    }
+    async resolveCommand(element) {
+        let command = element?.command;
+        if (element && !command) {
+            if ((element instanceof ResolvableTreeItem) && element.hasResolve) {
+                await element.resolve(( new CancellationTokenSource()).token);
+                command = element.command;
+            }
+        }
+        return command;
+    }
+    onContextMenu(treeMenus, treeEvent, actionRunner) {
+        this.hoverService.hideHover();
+        const node = treeEvent.element;
+        if (node === null) {
+            return;
+        }
+        const event = treeEvent.browserEvent;
+        event.preventDefault();
+        event.stopPropagation();
+        this.tree.setFocus([node]);
+        const actions = treeMenus.getResourceContextActions(node);
+        if (!actions.length) {
+            return;
+        }
+        this.contextMenuService.showContextMenu({
+            getAnchor: () => treeEvent.anchor,
+            getActions: () => actions,
+            getActionViewItem: (action) => {
+                const keybinding = this.keybindingService.lookupKeybinding(action.id);
+                if (keybinding) {
+                    return ( new ActionViewItem(action, action, { label: true, keybinding: keybinding.getLabel() }));
+                }
+                return undefined;
+            },
+            onHide: (wasCancelled) => {
+                if (wasCancelled) {
+                    this.tree.domFocus();
+                }
+            },
+            getActionsContext: () => ({ $treeViewId: this.id, $treeItemHandle: node.handle }),
+            actionRunner
+        });
+    }
+    updateMessage() {
+        if (this._message) {
+            this.showMessage(this._message);
+        }
+        else if (!this.dataProvider) {
+            this.showMessage(noDataProviderMessage);
+        }
+        else {
+            this.hideMessage();
+        }
+        this.updateContentAreas();
+    }
+    showMessage(message) {
+        if (isRenderedMessageValue(this._messageValue)) {
+            this._messageValue.dispose();
+        }
+        if (isMarkdownString(message) && !this.markdownRenderer) {
+            this.markdownRenderer = this.instantiationService.createInstance(MarkdownRenderer, {});
+        }
+        this._messageValue = isMarkdownString(message) ? this.markdownRenderer.render(message) : message;
+        if (!this.messageElement) {
+            return;
+        }
+        this.messageElement.classList.remove('hide');
+        this.resetMessageElement();
+        if (typeof this._messageValue === 'string' && !isFalsyOrWhitespace(this._messageValue)) {
+            this.messageElement.textContent = this._messageValue;
+        }
+        else if (isRenderedMessageValue(this._messageValue)) {
+            this.messageElement.appendChild(this._messageValue.element);
+        }
+        this.layout(this._height, this._width);
+    }
+    hideMessage() {
+        this.resetMessageElement();
+        this.messageElement?.classList.add('hide');
+        this.layout(this._height, this._width);
+    }
+    resetMessageElement() {
+        if (this.messageElement) {
+            dom.clearNode(this.messageElement);
+        }
+    }
+    layout(height, width) {
+        if (height && width && this.messageElement && this.treeContainer) {
+            this._height = height;
+            this._width = width;
+            const treeHeight = height - dom.getTotalHeight(this.messageElement);
+            this.treeContainer.style.height = treeHeight + 'px';
+            this.tree?.layout(treeHeight, width);
+        }
+    }
+    getOptimalWidth() {
+        if (this.tree) {
+            const parentNode = this.tree.getHTMLElement();
+            const childNodes = [].slice.call(parentNode.querySelectorAll('.outline-item-label > a'));
+            return dom.getLargestChildWidth(parentNode, childNodes);
+        }
+        return 0;
+    }
+    async refresh(elements) {
+        if (this.dataProvider && this.tree) {
+            if (this.refreshing) {
+                await Event.toPromise(this._onDidCompleteRefresh.event);
+            }
+            if (!elements) {
+                elements = [this.root];
+                this.elementsToRefresh = [];
+            }
+            for (const element of elements) {
+                element.children = undefined;
+            }
+            if (this.isVisible) {
+                return this.doRefresh(elements);
+            }
+            else {
+                if (this.elementsToRefresh.length) {
+                    const seen = ( new Set());
+                    this.elementsToRefresh.forEach(element => seen.add(element.handle));
+                    for (const element of elements) {
+                        if (!( seen.has(element.handle))) {
+                            this.elementsToRefresh.push(element);
+                        }
+                    }
+                }
+                else {
+                    this.elementsToRefresh.push(...elements);
+                }
+            }
+        }
+        return undefined;
+    }
+    async expand(itemOrItems) {
+        const tree = this.tree;
+        if (!tree) {
+            return;
+        }
+        try {
+            itemOrItems = Array.isArray(itemOrItems) ? itemOrItems : [itemOrItems];
+            for (const element of itemOrItems) {
+                await tree.expand(element, false);
+            }
+        }
+        catch (e) {
+        }
+    }
+    isCollapsed(item) {
+        return !!this.tree?.isCollapsed(item);
+    }
+    setSelection(items) {
+        this.tree?.setSelection(items);
+    }
+    getSelection() {
+        return this.tree?.getSelection() ?? [];
+    }
+    setFocus(item) {
+        if (this.tree) {
+            if (item) {
+                this.focus(true, item);
+                this.tree.setFocus([item]);
+            }
+            else if (this.tree.getFocus().length === 0) {
+                this.tree.setFocus([]);
+            }
+        }
+    }
+    async reveal(item) {
+        if (this.tree) {
+            return this.tree.reveal(item);
+        }
+    }
+    async doRefresh(elements) {
+        const tree = this.tree;
+        if (tree && this.visible) {
+            this.refreshing = true;
+            const oldSelection = tree.getSelection();
+            try {
+                await Promise.all(( elements.map(element => tree.updateChildren(element, true, true))));
+            }
+            catch (e) {
+                this.logService.error(e);
+            }
+            const newSelection = tree.getSelection();
+            if (oldSelection.length !== newSelection.length || ( oldSelection.some((value, index) => value.handle !== newSelection[index].handle))) {
+                this.lastSelection = newSelection;
+                this._onDidChangeSelectionAndFocus.fire({ selection: this.lastSelection, focus: this.lastActive });
+            }
+            this.refreshing = false;
+            this._onDidCompleteRefresh.fire();
+            this.updateContentAreas();
+            if (this.focused) {
+                this.focus(false);
+            }
+            this.updateCollapseAllToggle();
+        }
+    }
+    initializeCollapseAllToggle() {
+        if (!this.collapseAllToggleContext) {
+            this.collapseAllToggleContextKey = ( new RawContextKey(`treeView.${this.id}.toggleCollapseAll`, false, ( localizeWithPath(
+                'vs/workbench/browser/parts/views/treeView',
+                'treeView.toggleCollapseAll',
+                "Whether collapse all is toggled for the tree view with id {0}.",
+                this.id
+            ))));
+            this.collapseAllToggleContext = this.collapseAllToggleContextKey.bindTo(this.contextKeyService);
+        }
+    }
+    updateCollapseAllToggle() {
+        if (this.showCollapseAllAction) {
+            this.initializeCollapseAllToggle();
+            this.collapseAllToggleContext?.set(!!this.root.children && (this.root.children.length > 0) &&
+                ( this.root.children.some(value => value.collapsibleState !== TreeItemCollapsibleState.None)));
+        }
+    }
+    updateContentAreas() {
+        const isTreeEmpty = !this.root.children || this.root.children.length === 0;
+        if (this._messageValue && isTreeEmpty && !this.refreshing && this.treeContainer) {
+            if (!this.dragAndDropController) {
+                this.treeContainer.classList.add('hide');
+            }
+            this.domNode.setAttribute('tabindex', '0');
+        }
+        else if (this.treeContainer) {
+            this.treeContainer.classList.remove('hide');
+            if (this.domNode === dom.getActiveElement()) {
+                this.focus();
+            }
+            this.domNode.removeAttribute('tabindex');
+        }
+    }
+    get container() {
+        return this._container;
+    }
+};
+AbstractTreeView = ( __decorate([
+    ( __param(2, IThemeService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, ICommandService)),
+    ( __param(5, IConfigurationService)),
+    ( __param(6, IProgressService)),
+    ( __param(7, IContextMenuService)),
+    ( __param(8, IKeybindingService)),
+    ( __param(9, INotificationService)),
+    ( __param(10, IViewDescriptorService)),
+    ( __param(11, IHoverService)),
+    ( __param(12, IContextKeyService)),
+    ( __param(13, IActivityService)),
+    ( __param(14, ILogService))
+], AbstractTreeView));
+class TreeViewIdentityProvider {
+    getId(element) {
+        return element.handle;
+    }
+}
+class TreeViewDelegate {
+    getHeight(element) {
+        return TreeRenderer.ITEM_HEIGHT;
+    }
+    getTemplateId(element) {
+        return TreeRenderer.TREE_TEMPLATE_ID;
+    }
+}
+class TreeDataSource {
+    constructor(treeView, withProgress) {
+        this.treeView = treeView;
+        this.withProgress = withProgress;
+    }
+    hasChildren(element) {
+        return !!this.treeView.dataProvider && (element.collapsibleState !== TreeItemCollapsibleState.None);
+    }
+    async getChildren(element) {
+        let result = [];
+        if (this.treeView.dataProvider) {
+            try {
+                result = (await this.withProgress(this.treeView.dataProvider.getChildren(element))) ?? [];
+            }
+            catch (e) {
+                if (!e.message.startsWith('Bad progress location:')) {
+                    throw e;
+                }
+            }
+        }
+        return result;
+    }
+}
+let TreeRenderer = class TreeRenderer extends Disposable {
+    static { TreeRenderer_1 = this; }
+    static { this.ITEM_HEIGHT = 22; }
+    static { this.TREE_TEMPLATE_ID = 'treeExplorer'; }
+    constructor(treeViewId, menus, labels, actionViewItemProvider, aligner, checkboxStateHandler, manuallyManageCheckboxes, themeService, configurationService, labelService, hoverService, treeViewsService, contextKeyService) {
+        super();
+        this.treeViewId = treeViewId;
+        this.menus = menus;
+        this.labels = labels;
+        this.actionViewItemProvider = actionViewItemProvider;
+        this.aligner = aligner;
+        this.checkboxStateHandler = checkboxStateHandler;
+        this.manuallyManageCheckboxes = manuallyManageCheckboxes;
+        this.themeService = themeService;
+        this.configurationService = configurationService;
+        this.labelService = labelService;
+        this.hoverService = hoverService;
+        this.treeViewsService = treeViewsService;
+        this.contextKeyService = contextKeyService;
+        this._onDidChangeCheckboxState = this._register(( new Emitter()));
+        this.onDidChangeCheckboxState = this._onDidChangeCheckboxState.event;
+        this._hasCheckbox = false;
+        this._renderedElements = ( new Map());
+        this._hoverDelegate = {
+            showHover: (options) => this.hoverService.showHover(options),
+            delay: this.configurationService.getValue('workbench.hover.delay')
+        };
+        this._register(this.themeService.onDidFileIconThemeChange(() => this.rerender()));
+        this._register(this.themeService.onDidColorThemeChange(() => this.rerender()));
+        this._register(checkboxStateHandler.onDidChangeCheckboxState(items => {
+            this.updateCheckboxes(items);
+        }));
+    }
+    get templateId() {
+        return TreeRenderer_1.TREE_TEMPLATE_ID;
+    }
+    set actionRunner(actionRunner) {
+        this._actionRunner = actionRunner;
+    }
+    renderTemplate(container) {
+        container.classList.add('custom-view-tree-node-item');
+        const checkboxContainer = dom.append(container, dom.$(''));
+        const resourceLabel = this.labels.create(container, { supportHighlights: true, hoverDelegate: this._hoverDelegate });
+        const icon = dom.prepend(resourceLabel.element, dom.$('.custom-view-tree-node-item-icon'));
+        const actionsContainer = dom.append(resourceLabel.element, dom.$('.actions'));
+        const actionBar = ( new ActionBar(actionsContainer, {
+            actionViewItemProvider: this.actionViewItemProvider
+        }));
+        return { resourceLabel, icon, checkboxContainer, actionBar, container, elementDisposable: ( new DisposableStore()) };
+    }
+    getHover(label, resource, node) {
+        if (!(node instanceof ResolvableTreeItem) || !node.hasResolve) {
+            if (resource && !node.tooltip) {
+                return undefined;
+            }
+            else if (node.tooltip === undefined) {
+                return label;
+            }
+            else if (!isString(node.tooltip)) {
+                return { markdown: node.tooltip, markdownNotSupportedFallback: resource ? undefined : renderMarkdownAsPlaintext(node.tooltip) };
+            }
+            else if (node.tooltip !== '') {
+                return node.tooltip;
+            }
+            else {
+                return undefined;
+            }
+        }
+        return {
+            markdown: typeof node.tooltip === 'string' ? node.tooltip :
+                (token) => {
+                    return ( new Promise((resolve) => {
+                        node.resolve(token).then(() => resolve(node.tooltip));
+                    }));
+                },
+            markdownNotSupportedFallback: resource ? undefined : (label ?? '')
+        };
+    }
+    renderElement(element, index, templateData) {
+        const node = element.element;
+        const resource = node.resourceUri ? URI.revive(node.resourceUri) : null;
+        const treeItemLabel = node.label ? node.label : (resource ? { label: basename(resource) } : undefined);
+        const description = isString(node.description) ? node.description : resource && node.description === true ? this.labelService.getUriLabel(dirname(resource), { relative: true }) : undefined;
+        const label = treeItemLabel ? treeItemLabel.label : undefined;
+        const matches = (treeItemLabel && treeItemLabel.highlights && label) ? ( treeItemLabel.highlights.map(([start, end]) => {
+            if (start < 0) {
+                start = label.length + start;
+            }
+            if (end < 0) {
+                end = label.length + end;
+            }
+            if ((start >= label.length) || (end > label.length)) {
+                return ({ start: 0, end: 0 });
+            }
+            if (start > end) {
+                const swap = start;
+                start = end;
+                end = swap;
+            }
+            return ({ start, end });
+        })) : undefined;
+        const icon = this.themeService.getColorTheme().type === ColorScheme.LIGHT ? node.icon : node.iconDark;
+        const iconUrl = icon ? URI.revive(icon) : undefined;
+        const title = this.getHover(label, resource, node);
+        templateData.actionBar.clear();
+        templateData.icon.style.color = '';
+        let commandEnabled = true;
+        if (node.command) {
+            commandEnabled = isTreeCommandEnabled(node.command, this.contextKeyService);
+        }
+        this.renderCheckbox(node, templateData);
+        if (resource) {
+            const fileDecorations = this.configurationService.getValue('explorer.decorations');
+            const labelResource = resource ? resource : ( URI.parse('missing:_icon_resource'));
+            templateData.resourceLabel.setResource({ name: label, description, resource: labelResource }, {
+                fileKind: this.getFileKind(node),
+                title,
+                hideIcon: this.shouldHideResourceLabelIcon(iconUrl, node.themeIcon),
+                fileDecorations,
+                extraClasses: ['custom-view-tree-node-item-resourceLabel'],
+                matches: matches ? matches : createMatches(element.filterData),
+                strikethrough: treeItemLabel?.strikethrough,
+                disabledCommand: !commandEnabled,
+                labelEscapeNewLines: true,
+                forceLabel: !!node.label
+            });
+        }
+        else {
+            templateData.resourceLabel.setResource({ name: label, description }, {
+                title,
+                hideIcon: true,
+                extraClasses: ['custom-view-tree-node-item-resourceLabel'],
+                matches: matches ? matches : createMatches(element.filterData),
+                strikethrough: treeItemLabel?.strikethrough,
+                disabledCommand: !commandEnabled,
+                labelEscapeNewLines: true
+            });
+        }
+        if (iconUrl) {
+            templateData.icon.className = 'custom-view-tree-node-item-icon';
+            templateData.icon.style.backgroundImage = dom.asCSSUrl(iconUrl);
+        }
+        else {
+            let iconClass;
+            if (this.shouldShowThemeIcon(!!resource, node.themeIcon)) {
+                iconClass = ThemeIcon.asClassName(node.themeIcon);
+                if (node.themeIcon.color) {
+                    templateData.icon.style.color = this.themeService.getColorTheme().getColor(node.themeIcon.color.id)?.toString() ?? '';
+                }
+            }
+            templateData.icon.className = iconClass ? `custom-view-tree-node-item-icon ${iconClass}` : '';
+            templateData.icon.style.backgroundImage = '';
+        }
+        if (!commandEnabled) {
+            templateData.icon.className = templateData.icon.className + ' disabled';
+            if (templateData.container.parentElement) {
+                templateData.container.parentElement.className = templateData.container.parentElement.className + ' disabled';
+            }
+        }
+        templateData.actionBar.context = { $treeViewId: this.treeViewId, $treeItemHandle: node.handle };
+        const menuActions = this.menus.getResourceActions(node, templateData.elementDisposable);
+        templateData.actionBar.push(menuActions.actions, { icon: true, label: false });
+        if (this._actionRunner) {
+            templateData.actionBar.actionRunner = this._actionRunner;
+        }
+        this.setAlignment(templateData.container, node);
+        this.treeViewsService.addRenderedTreeItemElement(node, templateData.container);
+        const renderedItems = this._renderedElements.get(element.element.handle) ?? [];
+        this._renderedElements.set(element.element.handle, [...renderedItems, { original: element, rendered: templateData }]);
+    }
+    rerender() {
+        const keys = ( new Set(( this._renderedElements.keys())));
+        for (const key of keys) {
+            const values = this._renderedElements.get(key) ?? [];
+            for (const value of values) {
+                this.disposeElement(value.original, 0, value.rendered);
+                this.renderElement(value.original, 0, value.rendered);
+            }
+        }
+    }
+    renderCheckbox(node, templateData) {
+        if (node.checkbox) {
+            if (!this._hasCheckbox) {
+                this._hasCheckbox = true;
+                this.rerender();
+            }
+            if (!templateData.checkbox) {
+                const checkbox = ( new TreeItemCheckbox(
+                    templateData.checkboxContainer,
+                    this.checkboxStateHandler,
+                    this._hoverDelegate
+                ));
+                templateData.checkbox = checkbox;
+            }
+            templateData.checkbox.render(node);
+        }
+        else if (templateData.checkbox) {
+            templateData.checkbox.dispose();
+            templateData.checkbox = undefined;
+        }
+    }
+    setAlignment(container, treeItem) {
+        container.parentElement.classList.toggle('align-icon-with-twisty', !this._hasCheckbox && this.aligner.alignIconWithTwisty(treeItem));
+    }
+    shouldHideResourceLabelIcon(iconUrl, icon) {
+        return (!!iconUrl || (!!icon && !this.isFileKindThemeIcon(icon)));
+    }
+    shouldShowThemeIcon(hasResource, icon) {
+        if (!icon) {
+            return false;
+        }
+        return !(hasResource && this.isFileKindThemeIcon(icon));
+    }
+    isFolderThemeIcon(icon) {
+        return icon?.id === FolderThemeIcon.id;
+    }
+    isFileKindThemeIcon(icon) {
+        if (icon) {
+            return icon.id === FileThemeIcon.id || this.isFolderThemeIcon(icon);
+        }
+        else {
+            return false;
+        }
+    }
+    getFileKind(node) {
+        if (node.themeIcon) {
+            switch (node.themeIcon.id) {
+                case FileThemeIcon.id:
+                    return FileKind.FILE;
+                case FolderThemeIcon.id:
+                    return FileKind.FOLDER;
+            }
+        }
+        return node.collapsibleState === TreeItemCollapsibleState.Collapsed || node.collapsibleState === TreeItemCollapsibleState.Expanded ? FileKind.FOLDER : FileKind.FILE;
+    }
+    updateCheckboxes(items) {
+        const additionalItems = [];
+        if (!this.manuallyManageCheckboxes()) {
+            for (const item of items) {
+                if (item.checkbox !== undefined) {
+                    function checkChildren(currentItem) {
+                        for (const child of (currentItem.children ?? [])) {
+                            if ((child.checkbox !== undefined) && (currentItem.checkbox !== undefined) && (child.checkbox.isChecked !== currentItem.checkbox.isChecked)) {
+                                child.checkbox.isChecked = currentItem.checkbox.isChecked;
+                                additionalItems.push(child);
+                                checkChildren(child);
+                            }
+                        }
+                    }
+                    checkChildren(item);
+                    const visitedParents = ( new Set());
+                    function checkParents(currentItem) {
+                        if (currentItem.parent && (currentItem.parent.checkbox !== undefined) && currentItem.parent.children) {
+                            if (( visitedParents.has(currentItem.parent))) {
+                                return;
+                            }
+                            else {
+                                visitedParents.add(currentItem.parent);
+                            }
+                            let someUnchecked = false;
+                            let someChecked = false;
+                            for (const child of currentItem.parent.children) {
+                                if (someUnchecked && someChecked) {
+                                    break;
+                                }
+                                if (child.checkbox !== undefined) {
+                                    if (child.checkbox.isChecked) {
+                                        someChecked = true;
+                                    }
+                                    else {
+                                        someUnchecked = true;
+                                    }
+                                }
+                            }
+                            if (someChecked && !someUnchecked && (currentItem.parent.checkbox.isChecked !== true)) {
+                                currentItem.parent.checkbox.isChecked = true;
+                                additionalItems.push(currentItem.parent);
+                                checkParents(currentItem.parent);
+                            }
+                            else if (someUnchecked && (currentItem.parent.checkbox.isChecked !== false)) {
+                                currentItem.parent.checkbox.isChecked = false;
+                                additionalItems.push(currentItem.parent);
+                                checkParents(currentItem.parent);
+                            }
+                        }
+                    }
+                    checkParents(item);
+                }
+            }
+        }
+        items = items.concat(additionalItems);
+        items.forEach(item => {
+            const renderedItems = this._renderedElements.get(item.handle);
+            if (renderedItems) {
+                renderedItems.forEach(renderedItems => renderedItems.rendered.checkbox?.render(item));
+            }
+        });
+        this._onDidChangeCheckboxState.fire(items);
+    }
+    disposeElement(resource, index, templateData) {
+        templateData.elementDisposable.clear();
+        const itemRenders = this._renderedElements.get(resource.element.handle) ?? [];
+        const renderedIndex = itemRenders.findIndex(renderedItem => templateData === renderedItem.rendered);
+        if (renderedIndex < 0) {
+            throw new Error('Disposing unknown element');
+        }
+        if (itemRenders.length === 1) {
+            this._renderedElements.delete(resource.element.handle);
+        }
+        else {
+            itemRenders.splice(renderedIndex, 1);
+        }
+        this.treeViewsService.removeRenderedTreeItemElement(resource.element);
+        templateData.checkbox?.dispose();
+        templateData.checkbox = undefined;
+    }
+    disposeTemplate(templateData) {
+        templateData.resourceLabel.dispose();
+        templateData.actionBar.dispose();
+        templateData.elementDisposable.dispose();
+    }
+};
+TreeRenderer = TreeRenderer_1 = ( __decorate([
+    ( __param(7, IThemeService)),
+    ( __param(8, IConfigurationService)),
+    ( __param(9, ILabelService)),
+    ( __param(10, IHoverService)),
+    ( __param(11, ITreeViewsService)),
+    ( __param(12, IContextKeyService))
+], TreeRenderer));
+class Aligner extends Disposable {
+    constructor(themeService) {
+        super();
+        this.themeService = themeService;
+    }
+    set tree(tree) {
+        this._tree = tree;
+    }
+    alignIconWithTwisty(treeItem) {
+        if (treeItem.collapsibleState !== TreeItemCollapsibleState.None) {
+            return false;
+        }
+        if (!this.hasIcon(treeItem)) {
+            return false;
+        }
+        if (this._tree) {
+            const parent = this._tree.getParentElement(treeItem) || this._tree.getInput();
+            if (this.hasIcon(parent)) {
+                return !!parent.children && ( parent.children.some(
+                    c => c.collapsibleState !== TreeItemCollapsibleState.None && !this.hasIcon(c)
+                ));
+            }
+            return !!parent.children && parent.children.every(c => c.collapsibleState === TreeItemCollapsibleState.None || !this.hasIcon(c));
+        }
+        else {
+            return false;
+        }
+    }
+    hasIcon(node) {
+        const icon = this.themeService.getColorTheme().type === ColorScheme.LIGHT ? node.icon : node.iconDark;
+        if (icon) {
+            return true;
+        }
+        if (node.resourceUri || node.themeIcon) {
+            const fileIconTheme = this.themeService.getFileIconTheme();
+            const isFolder = node.themeIcon ? node.themeIcon.id === FolderThemeIcon.id : node.collapsibleState !== TreeItemCollapsibleState.None;
+            if (isFolder) {
+                return fileIconTheme.hasFileIcons && fileIconTheme.hasFolderIcons;
+            }
+            return fileIconTheme.hasFileIcons;
+        }
+        return false;
+    }
+}
+class MultipleSelectionActionRunner extends ActionRunner {
+    constructor(notificationService, getSelectedResources) {
+        super();
+        this.getSelectedResources = getSelectedResources;
+        this._register(this.onDidRun(e => {
+            if (e.error && !isCancellationError(e.error)) {
+                notificationService.error(( localizeWithPath(
+                    'vs/workbench/browser/parts/views/treeView',
+                    'command-error',
+                    'Error running command {1}: {0}. This is likely caused by the extension that contributes {1}.',
+                    e.error.message,
+                    e.action.id
+                )));
+            }
+        }));
+    }
+    async runAction(action, context) {
+        const selection = this.getSelectedResources();
+        let selectionHandleArgs = undefined;
+        let actionInSelected = false;
+        if (selection.length > 1) {
+            selectionHandleArgs = ( selection.map(selected => {
+                if ((selected.handle === context.$treeItemHandle) || context.$selectedTreeItems) {
+                    actionInSelected = true;
+                }
+                return { $treeViewId: context.$treeViewId, $treeItemHandle: selected.handle };
+            }));
+        }
+        if (!actionInSelected) {
+            selectionHandleArgs = undefined;
+        }
+        await action.run(context, selectionHandleArgs);
+    }
+}
+let TreeMenus = class TreeMenus {
+    constructor(id, menuService) {
+        this.id = id;
+        this.menuService = menuService;
+        this._onDidChange = ( new Emitter());
+        this.onDidChange = this._onDidChange.event;
+    }
+    getResourceActions(element, disposableStore) {
+        const actions = this.getActions(MenuId.ViewItemContext, element, disposableStore);
+        return { menu: actions.menu, actions: actions.primary };
+    }
+    getResourceContextActions(element) {
+        return this.getActions(MenuId.ViewItemContext, element).secondary;
+    }
+    setContextKeyService(service) {
+        this.contextKeyService = service;
+    }
+    getActions(menuId, element, listen) {
+        if (!this.contextKeyService) {
+            return { primary: [], secondary: [] };
+        }
+        const contextKeyService = this.contextKeyService.createOverlay([
+            ['view', this.id],
+            ['viewItem', element.contextValue]
+        ]);
+        const menu = this.menuService.createMenu(menuId, contextKeyService);
+        const primary = [];
+        const secondary = [];
+        const result = { primary, secondary, menu };
+        createAndFillInContextMenuActions(menu, { shouldForwardArgs: true }, result, 'inline');
+        if (listen) {
+            listen.add(menu.onDidChange(() => this._onDidChange.fire(element)));
+            listen.add(menu);
+        }
+        else {
+            menu.dispose();
+        }
+        return result;
+    }
+    dispose() {
+        this.contextKeyService = undefined;
+    }
+};
+TreeMenus = ( __decorate([
+    ( __param(1, IMenuService))
+], TreeMenus));
+let CustomTreeView = class CustomTreeView extends AbstractTreeView {
+    constructor(id, title, extensionId, themeService, instantiationService, commandService, configurationService, progressService, contextMenuService, keybindingService, notificationService, viewDescriptorService, contextKeyService, hoverService, extensionService, activityService, telemetryService, logService) {
+        super(id, title, themeService, instantiationService, commandService, configurationService, progressService, contextMenuService, keybindingService, notificationService, viewDescriptorService, hoverService, contextKeyService, activityService, logService);
+        this.extensionId = extensionId;
+        this.extensionService = extensionService;
+        this.telemetryService = telemetryService;
+        this.activated = false;
+    }
+    activate() {
+        if (!this.activated) {
+            this.telemetryService.publicLog2('Extension:ViewActivate', {
+                extensionId: ( new TelemetryTrustedValue(this.extensionId)),
+                id: this.id,
+            });
+            this.createTree();
+            this.progressService.withProgress({ location: this.id }, () => this.extensionService.activateByEvent(`onView:${this.id}`))
+                .then(() => timeout(2000))
+                .then(() => {
+                this.updateMessage();
+            });
+            this.activated = true;
+        }
+    }
+};
+CustomTreeView = ( __decorate([
+    ( __param(3, IThemeService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, ICommandService)),
+    ( __param(6, IConfigurationService)),
+    ( __param(7, IProgressService)),
+    ( __param(8, IContextMenuService)),
+    ( __param(9, IKeybindingService)),
+    ( __param(10, INotificationService)),
+    ( __param(11, IViewDescriptorService)),
+    ( __param(12, IContextKeyService)),
+    ( __param(13, IHoverService)),
+    ( __param(14, IExtensionService)),
+    ( __param(15, IActivityService)),
+    ( __param(16, ITelemetryService)),
+    ( __param(17, ILogService))
+], CustomTreeView));
+class TreeView extends AbstractTreeView {
+    constructor() {
+        super(...arguments);
+        this.activated = false;
+    }
+    activate() {
+        if (!this.activated) {
+            this.createTree();
+            this.activated = true;
+        }
+    }
+}
+let CustomTreeViewDragAndDrop = class CustomTreeViewDragAndDrop {
+    constructor(treeId, labelService, instantiationService, treeViewsDragAndDropService, logService) {
+        this.treeId = treeId;
+        this.labelService = labelService;
+        this.instantiationService = instantiationService;
+        this.treeViewsDragAndDropService = treeViewsDragAndDropService;
+        this.logService = logService;
+        this.treeItemsTransfer = LocalSelectionTransfer.getInstance();
+        this.treeMimeType = `application/vnd.code.tree.${treeId.toLowerCase()}`;
+    }
+    set controller(controller) {
+        this.dndController = controller;
+    }
+    handleDragAndLog(dndController, itemHandles, uuid, dragCancellationToken) {
+        return dndController.handleDrag(itemHandles, uuid, dragCancellationToken).then(additionalDataTransfer => {
+            if (additionalDataTransfer) {
+                const unlistedTypes = [];
+                for (const item of additionalDataTransfer) {
+                    if ((item[0] !== this.treeMimeType) && (dndController.dragMimeTypes.findIndex(value => value === item[0]) < 0)) {
+                        unlistedTypes.push(item[0]);
+                    }
+                }
+                if (unlistedTypes.length) {
+                    this.logService.warn(`Drag and drop controller for tree ${this.treeId} adds the following data transfer types but does not declare them in dragMimeTypes: ${unlistedTypes.join(', ')}`);
+                }
+            }
+            return additionalDataTransfer;
+        });
+    }
+    addExtensionProvidedTransferTypes(originalEvent, itemHandles) {
+        if (!originalEvent.dataTransfer || !this.dndController) {
+            return;
+        }
+        const uuid = generateUuid();
+        this.dragCancellationToken = ( new CancellationTokenSource());
+        this.treeViewsDragAndDropService.addDragOperationTransfer(uuid, this.handleDragAndLog(this.dndController, itemHandles, uuid, this.dragCancellationToken.token));
+        this.treeItemsTransfer.setData([( new DraggedTreeItemsIdentifier(uuid))], DraggedTreeItemsIdentifier.prototype);
+        originalEvent.dataTransfer.clearData(Mimes.text);
+        if (this.dndController.dragMimeTypes.find((element) => element === Mimes.uriList)) {
+            originalEvent.dataTransfer?.setData(DataTransfers.RESOURCES, '');
+        }
+        this.dndController.dragMimeTypes.forEach(supportedType => {
+            originalEvent.dataTransfer?.setData(supportedType, '');
+        });
+    }
+    addResourceInfoToTransfer(originalEvent, resources) {
+        if (resources.length && originalEvent.dataTransfer) {
+            this.instantiationService.invokeFunction(accessor => fillEditorsDragData(accessor, resources, originalEvent));
+            const fileResources = ( resources.filter(s => s.scheme === Schemas.file).map(r => r.fsPath));
+            if (fileResources.length) {
+                originalEvent.dataTransfer.setData(CodeDataTransfers.FILES, JSON.stringify(fileResources));
+            }
+        }
+    }
+    onDragStart(data, originalEvent) {
+        if (originalEvent.dataTransfer) {
+            const treeItemsData = data.getData();
+            const resources = [];
+            const sourceInfo = {
+                id: this.treeId,
+                itemHandles: []
+            };
+            treeItemsData.forEach(item => {
+                sourceInfo.itemHandles.push(item.handle);
+                if (item.resourceUri) {
+                    resources.push(URI.revive(item.resourceUri));
+                }
+            });
+            this.addResourceInfoToTransfer(originalEvent, resources);
+            this.addExtensionProvidedTransferTypes(originalEvent, sourceInfo.itemHandles);
+            originalEvent.dataTransfer.setData(this.treeMimeType, JSON.stringify(sourceInfo));
+        }
+    }
+    debugLog(types) {
+        if (types.size) {
+            this.logService.debug(`TreeView dragged mime types: ${Array.from(types).join(', ')}`);
+        }
+        else {
+            this.logService.debug(`TreeView dragged with no supported mime types.`);
+        }
+    }
+    onDragOver(data, targetElement, targetIndex, originalEvent) {
+        const dataTransfer = toExternalVSDataTransfer(originalEvent.dataTransfer);
+        const types = ( new Set(Array.from(dataTransfer, x => x[0])));
+        if (originalEvent.dataTransfer) {
+            for (const item of originalEvent.dataTransfer.items) {
+                if (item.kind === 'file' || item.type === DataTransfers.RESOURCES.toLowerCase()) {
+                    types.add(Mimes.uriList);
+                    break;
+                }
+            }
+        }
+        this.debugLog(types);
+        const dndController = this.dndController;
+        if (!dndController || !originalEvent.dataTransfer || (dndController.dropMimeTypes.length === 0)) {
+            return false;
+        }
+        const dragContainersSupportedType = ( Array.from(types).some((value, index) => {
+            if (value === this.treeMimeType) {
+                return true;
+            }
+            else {
+                return dndController.dropMimeTypes.indexOf(value) >= 0;
+            }
+        }));
+        if (dragContainersSupportedType) {
+            return { accept: true, bubble: 0 , autoExpand: true };
+        }
+        return false;
+    }
+    getDragURI(element) {
+        if (!this.dndController) {
+            return null;
+        }
+        return element.resourceUri ? ( URI.revive(element.resourceUri).toString()) : element.handle;
+    }
+    getDragLabel(elements) {
+        if (!this.dndController) {
+            return undefined;
+        }
+        if (elements.length > 1) {
+            return String(elements.length);
+        }
+        const element = elements[0];
+        return element.label ? element.label.label : (element.resourceUri ? this.labelService.getUriLabel(URI.revive(element.resourceUri)) : undefined);
+    }
+    async drop(data, targetNode, targetIndex, originalEvent) {
+        const dndController = this.dndController;
+        if (!originalEvent.dataTransfer || !dndController) {
+            return;
+        }
+        let treeSourceInfo;
+        let willDropUuid;
+        if (this.treeItemsTransfer.hasData(DraggedTreeItemsIdentifier.prototype)) {
+            willDropUuid = this.treeItemsTransfer.getData(DraggedTreeItemsIdentifier.prototype)[0].identifier;
+        }
+        const originalDataTransfer = toExternalVSDataTransfer(originalEvent.dataTransfer, true);
+        const outDataTransfer = ( new VSDataTransfer());
+        for (const [type, item] of originalDataTransfer) {
+            if (type === this.treeMimeType || dndController.dropMimeTypes.includes(type) || (item.asFile() && dndController.dropMimeTypes.includes(DataTransfers.FILES.toLowerCase()))) {
+                outDataTransfer.append(type, item);
+                if (type === this.treeMimeType) {
+                    try {
+                        treeSourceInfo = JSON.parse(await item.asString());
+                    }
+                    catch {
+                    }
+                }
+            }
+        }
+        const additionalDataTransfer = await this.treeViewsDragAndDropService.removeDragOperationTransfer(willDropUuid);
+        if (additionalDataTransfer) {
+            for (const [type, item] of additionalDataTransfer) {
+                outDataTransfer.append(type, item);
+            }
+        }
+        return dndController.handleDrop(outDataTransfer, targetNode, CancellationToken.None, willDropUuid, treeSourceInfo?.id, treeSourceInfo?.itemHandles);
+    }
+    onDragEnd(originalEvent) {
+        if (originalEvent.dataTransfer?.dropEffect === 'none') {
+            this.dragCancellationToken?.cancel();
+        }
+    }
+    dispose() { }
+};
+CustomTreeViewDragAndDrop = ( __decorate([
+    ( __param(1, ILabelService)),
+    ( __param(2, IInstantiationService)),
+    ( __param(3, ITreeViewsDnDService)),
+    ( __param(4, ILogService))
+], CustomTreeViewDragAndDrop));
+export { CustomTreeView, CustomTreeViewDragAndDrop, RawCustomTreeViewContextKey, TreeView, TreeViewPane };