@codingame/monaco-vscode-api 1.78.6-next.0 → 1.78.7

package/dist/vscode/vs/workbench/contrib/files/browser/views/explorerView.js

@@ -1,793 +0,0 @@
-import { __decorate, __param } from '../../../../../../../node_modules/tslib/tslib.es6.js';
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import * as performance from 'monaco-editor/esm/vs/base/common/performance.js';
-import { memoize } from 'monaco-editor/esm/vs/base/common/decorators.js';
-import { ExplorerResourceNotReadonlyContext, VIEW_ID, VIEWLET_ID, ExplorerFolderContext, ExplorerResourceReadonlyContext, ExplorerResourceAvailableEditorIdsContext, ExplorerRootContext, ExplorerResourceMoveableToTrash, ExplorerCompressedFocusContext, ExplorerCompressedFirstFocusContext, ExplorerCompressedLastFocusContext, ViewHasSomeCollapsibleRootItemContext, FoldersViewVisibleContext, ExplorerResourceCut, FilesExplorerFocusedContext, ExplorerFocusedContext } from '../../common/files.js';
-import { NEW_FILE_COMMAND_ID, NEW_FOLDER_COMMAND_ID, FileCopiedContext } from '../fileActions.js';
-import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
-import { IWorkbenchLayoutService } from '../../../../services/layout/browser/layoutService.js';
-import { ExplorerDecorationsProvider } from './explorerDecorationsProvider.js';
-import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { IProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
-import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
-import { ContextKeyExpr, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { ResourceContextKey } from '../../../../common/contextkeys.js';
-import { IDecorationsService } from '../../../../services/decorations/common/decorations.js';
-import { WorkbenchCompressibleAsyncDataTree } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
-import { DelayedDragHandler } from 'monaco-editor/esm/vs/base/browser/dnd.js';
-import { SIDE_GROUP, ACTIVE_GROUP, IEditorService } from '../../../../services/editor/common/editorService.js';
-import { ViewPane } from '../../../../browser/parts/views/viewPane.js';
-import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
-import { FilesFilter, FilesRenderer, ExplorerDelegate, ExplorerCompressionDelegate, ExplorerDataSource, FileSorter, FileDragAndDrop, isCompressedFolderName } from './explorerViewer.js';
-import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
-import { registerAction2, Action2, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
-import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
-import { ExplorerItem, NewExplorerItem } from '../../common/explorerModel.js';
-import { ResourceLabels } from '../../../../browser/labels.js';
-import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
-import { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
-import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
-import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import { SIDE_BAR_BACKGROUND } from '../../../../common/theme.js';
-import { IViewsService, IViewDescriptorService } from '../../../../common/views.js';
-import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
-import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
-import { EditorResourceAccessor, SideBySideEditor } from '../../../../common/editor.js';
-import { IExplorerService } from '../files.js';
-import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
-import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
-import { IEditorResolverService } from '../../../../services/editor/common/editorResolverService.js';
-import { IPaneCompositePartService } from '../../../../services/panecomposite/browser/panecomposite.js';
-import { EditorOpenSource } from 'monaco-editor/esm/vs/platform/editor/common/editor.js';
-import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
-import { isInputElement } from 'monaco-editor/esm/vs/base/browser/ui/list/listWidget.js';
-function hasExpandedRootChild(tree, treeInput) {
-    for (const folder of treeInput) {
-        if (tree.hasNode(folder) && !tree.isCollapsed(folder)) {
-            for (const [, child] of folder.children.entries()) {
-                if (tree.hasNode(child) && tree.isCollapsible(child) && !tree.isCollapsed(child)) {
-                    return true;
-                }
-            }
-        }
-    }
-    return false;
-}
-function hasExpandedNode(tree, treeInput) {
-    for (const folder of treeInput) {
-        if (tree.hasNode(folder) && !tree.isCollapsed(folder)) {
-            return true;
-        }
-    }
-    return false;
-}
-const identityProvider = {
-    getId: (stat) => {
-        if (stat instanceof NewExplorerItem) {
-            return `new:${stat.getId()}`;
-        }
-        return stat.getId();
-    }
-};
-function getContext(focus, selection, respectMultiSelection, compressedNavigationControllerProvider) {
-    let focusedStat;
-    focusedStat = focus.length ? focus[0] : undefined;
-    if (respectMultiSelection && selection.length > 1) {
-        focusedStat = undefined;
-    }
-    const compressedNavigationController = focusedStat && compressedNavigationControllerProvider.getCompressedNavigationController(focusedStat);
-    focusedStat = compressedNavigationController ? compressedNavigationController.current : focusedStat;
-    const selectedStats = [];
-    for (const stat of selection) {
-        const controller = compressedNavigationControllerProvider.getCompressedNavigationController(stat);
-        if (controller && focusedStat && controller === compressedNavigationController) {
-            if (stat === focusedStat) {
-                selectedStats.push(stat);
-            }
-            continue;
-        }
-        if (controller) {
-            selectedStats.push(...controller.items);
-        }
-        else {
-            selectedStats.push(stat);
-        }
-    }
-    if (!focusedStat) {
-        if (respectMultiSelection) {
-            return selectedStats;
-        }
-        else {
-            return [];
-        }
-    }
-    if (respectMultiSelection && selectedStats.indexOf(focusedStat) >= 0) {
-        return selectedStats;
-    }
-    return [focusedStat];
-}
-let ExplorerView = class ExplorerView extends ViewPane {
-    constructor(options, contextMenuService, viewDescriptorService, instantiationService, contextService, progressService, editorService, editorResolverService, layoutService, keybindingService, contextKeyService, configurationService, decorationService, labelService, themeService, telemetryService, explorerService, storageService, clipboardService, fileService, uriIdentityService, commandService, openerService) {
-        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
-        this.contextService = contextService;
-        this.progressService = progressService;
-        this.editorService = editorService;
-        this.editorResolverService = editorResolverService;
-        this.layoutService = layoutService;
-        this.decorationService = decorationService;
-        this.labelService = labelService;
-        this.explorerService = explorerService;
-        this.storageService = storageService;
-        this.clipboardService = clipboardService;
-        this.fileService = fileService;
-        this.uriIdentityService = uriIdentityService;
-        this.commandService = commandService;
-        this.autoReveal = false;
-        this.delegate = options.delegate;
-        this.resourceContext = instantiationService.createInstance(ResourceContextKey);
-        this._register(this.resourceContext);
-        this.folderContext = ExplorerFolderContext.bindTo(contextKeyService);
-        this.readonlyContext = ExplorerResourceReadonlyContext.bindTo(contextKeyService);
-        this.availableEditorIdsContext = ExplorerResourceAvailableEditorIdsContext.bindTo(contextKeyService);
-        this.rootContext = ExplorerRootContext.bindTo(contextKeyService);
-        this.resourceMoveableToTrash = ExplorerResourceMoveableToTrash.bindTo(contextKeyService);
-        this.compressedFocusContext = ExplorerCompressedFocusContext.bindTo(contextKeyService);
-        this.compressedFocusFirstContext = ExplorerCompressedFirstFocusContext.bindTo(contextKeyService);
-        this.compressedFocusLastContext = ExplorerCompressedLastFocusContext.bindTo(contextKeyService);
-        this.viewHasSomeCollapsibleRootItem = ViewHasSomeCollapsibleRootItemContext.bindTo(contextKeyService);
-        this.viewVisibleContextKey = FoldersViewVisibleContext.bindTo(contextKeyService);
-        this.explorerService.registerView(this);
-    }
-    get name() {
-        return this.labelService.getWorkspaceLabel(this.contextService.getWorkspace());
-    }
-    get title() {
-        return this.name;
-    }
-    set title(_) {
-    }
-    setVisible(visible) {
-        this.viewVisibleContextKey.set(visible);
-        super.setVisible(visible);
-    }
-    get fileCopiedContextKey() {
-        return FileCopiedContext.bindTo(this.contextKeyService);
-    }
-    get resourceCutContextKey() {
-        return ExplorerResourceCut.bindTo(this.contextKeyService);
-    }
-    renderHeader(container) {
-        super.renderHeader(container);
-        this.dragHandler = ( new DelayedDragHandler(container, () => this.setExpanded(true)));
-        const titleElement = container.querySelector('.title');
-        const setHeader = () => {
-            const workspace = this.contextService.getWorkspace();
-            const title = ( workspace.folders.map(folder => folder.name)).join();
-            titleElement.textContent = this.name;
-            titleElement.title = title;
-            this.ariaHeaderLabel = ( nls.localize('explorerSection', "Explorer Section: {0}", this.name));
-            titleElement.setAttribute('aria-label', this.ariaHeaderLabel);
-        };
-        this._register(this.contextService.onDidChangeWorkspaceName(setHeader));
-        this._register(this.labelService.onDidChangeFormatters(setHeader));
-        setHeader();
-    }
-    layoutBody(height, width) {
-        super.layoutBody(height, width);
-        this.tree.layout(height, width);
-    }
-    renderBody(container) {
-        super.renderBody(container);
-        this.container = container;
-        this.treeContainer = dom.append(container, dom.$('.explorer-folders-view'));
-        this.createTree(this.treeContainer);
-        this._register(this.labelService.onDidChangeFormatters(() => {
-            this._onDidChangeTitleArea.fire();
-        }));
-        this.onConfigurationUpdated(undefined);
-        this._register(this.editorService.onDidActiveEditorChange(() => {
-            this.selectActiveFile();
-        }));
-        this._register(this.configurationService.onDidChangeConfiguration(e => this.onConfigurationUpdated(e)));
-        this._register(this.onDidChangeBodyVisibility(async (visible) => {
-            if (visible) {
-                await this.setTreeInput();
-                this.updateAnyCollapsedContext();
-                this.selectActiveFile(true);
-            }
-        }));
-    }
-    focus() {
-        this.tree.domFocus();
-        const focused = this.tree.getFocus();
-        if (focused.length === 1 && this.autoReveal) {
-            this.tree.reveal(focused[0], 0.5);
-        }
-    }
-    hasFocus() {
-        return dom.isAncestor(document.activeElement, this.container);
-    }
-    getContext(respectMultiSelection) {
-        return getContext(this.tree.getFocus(), this.tree.getSelection(), respectMultiSelection, this.renderer);
-    }
-    isItemVisible(item) {
-        return this.filter.filter(item, 1 );
-    }
-    isItemCollapsed(item) {
-        return this.tree.isCollapsed(item);
-    }
-    async setEditable(stat, isEditing) {
-        if (isEditing) {
-            this.horizontalScrolling = this.tree.options.horizontalScrolling;
-            if (this.horizontalScrolling) {
-                this.tree.updateOptions({ horizontalScrolling: false });
-            }
-            await this.tree.expand(stat.parent);
-        }
-        else {
-            if (this.horizontalScrolling !== undefined) {
-                this.tree.updateOptions({ horizontalScrolling: this.horizontalScrolling });
-            }
-            this.horizontalScrolling = undefined;
-            this.treeContainer.classList.remove('highlight');
-        }
-        await this.refresh(false, stat.parent, false);
-        if (isEditing) {
-            this.treeContainer.classList.add('highlight');
-            this.tree.reveal(stat);
-        }
-        else {
-            this.tree.domFocus();
-        }
-    }
-    selectActiveFile(reveal = this.autoReveal) {
-        if (this.autoReveal) {
-            const activeFile = EditorResourceAccessor.getCanonicalUri(this.editorService.activeEditor, { supportSideBySide: SideBySideEditor.PRIMARY });
-            if (activeFile) {
-                const focus = this.tree.getFocus();
-                const selection = this.tree.getSelection();
-                if (focus.length === 1 && this.uriIdentityService.extUri.isEqual(focus[0].resource, activeFile) && selection.length === 1 && this.uriIdentityService.extUri.isEqual(selection[0].resource, activeFile)) {
-                    return;
-                }
-                this.explorerService.select(activeFile, reveal);
-            }
-        }
-    }
-    createTree(container) {
-        this.filter = this.instantiationService.createInstance(FilesFilter);
-        this._register(this.filter);
-        this._register(this.filter.onDidChange(() => this.refresh(true)));
-        const explorerLabels = this.instantiationService.createInstance(ResourceLabels, { onDidChangeVisibility: this.onDidChangeBodyVisibility });
-        this._register(explorerLabels);
-        const updateWidth = (stat) => this.tree.updateWidth(stat);
-        this.renderer = this.instantiationService.createInstance(FilesRenderer, container, explorerLabels, updateWidth);
-        this._register(this.renderer);
-        this._register(createFileIconThemableTreeContainerScope(container, this.themeService));
-        const isCompressionEnabled = () => this.configurationService.getValue('explorer.compactFolders');
-        const getFileNestingSettings = (item) => this.configurationService.getValue({ resource: item?.root.resource }).explorer.fileNesting;
-        this.tree = this.instantiationService.createInstance(WorkbenchCompressibleAsyncDataTree, 'FileExplorer', container, ( new ExplorerDelegate()), ( new ExplorerCompressionDelegate()), [this.renderer], this.instantiationService.createInstance(ExplorerDataSource, this.filter), {
-            compressionEnabled: isCompressionEnabled(),
-            accessibilityProvider: this.renderer,
-            identityProvider,
-            keyboardNavigationLabelProvider: {
-                getKeyboardNavigationLabel: (stat) => {
-                    if (this.explorerService.isEditable(stat)) {
-                        return undefined;
-                    }
-                    return stat.name;
-                },
-                getCompressedNodeKeyboardNavigationLabel: (stats) => {
-                    if (( stats.some(stat => this.explorerService.isEditable(stat)))) {
-                        return undefined;
-                    }
-                    return ( stats.map(stat => stat.name)).join('/');
-                }
-            },
-            multipleSelectionSupport: true,
-            filter: this.filter,
-            sorter: this.instantiationService.createInstance(FileSorter),
-            dnd: this.instantiationService.createInstance(FileDragAndDrop, (item) => this.isItemCollapsed(item)),
-            collapseByDefault: (e) => {
-                if (e instanceof ExplorerItem) {
-                    if (e.hasNests && getFileNestingSettings(e).expand) {
-                        return false;
-                    }
-                }
-                return true;
-            },
-            autoExpandSingleChildren: true,
-            expandOnlyOnTwistieClick: (e) => {
-                if (e instanceof ExplorerItem) {
-                    if (e.hasNests) {
-                        return true;
-                    }
-                    else if (this.configurationService.getValue('workbench.tree.expandMode') === 'doubleClick') {
-                        return true;
-                    }
-                }
-                return false;
-            },
-            additionalScrollHeight: ExplorerDelegate.ITEM_HEIGHT,
-            overrideStyles: {
-                listBackground: SIDE_BAR_BACKGROUND
-            }
-        });
-        this._register(this.tree);
-        this._register(this.themeService.onDidColorThemeChange(() => this.tree.rerender()));
-        const onDidChangeCompressionConfiguration = Event.filter(this.configurationService.onDidChangeConfiguration, e => e.affectsConfiguration('explorer.compactFolders'));
-        this._register(onDidChangeCompressionConfiguration(_ => this.tree.updateOptions({ compressionEnabled: isCompressionEnabled() })));
-        FilesExplorerFocusedContext.bindTo(this.tree.contextKeyService);
-        ExplorerFocusedContext.bindTo(this.tree.contextKeyService);
-        this._register(this.tree.onDidChangeFocus(e => this.onFocusChanged(e.elements)));
-        this.onFocusChanged([]);
-        this._register(this.tree.onDidOpen(async (e) => {
-            const element = e.element;
-            if (!element) {
-                return;
-            }
-            const shiftDown = e.browserEvent instanceof KeyboardEvent && e.browserEvent.shiftKey;
-            if (!shiftDown) {
-                if (element.isDirectory || this.explorerService.isEditable(undefined)) {
-                    return;
-                }
-                this.telemetryService.publicLog2('workbenchActionExecuted', { id: 'workbench.files.openFile', from: 'explorer' });
-                try {
-                    this.delegate?.willOpenElement(e.browserEvent);
-                    await this.editorService.openEditor({ resource: element.resource, options: { preserveFocus: e.editorOptions.preserveFocus, pinned: e.editorOptions.pinned, source: EditorOpenSource.USER } }, e.sideBySide ? SIDE_GROUP : ACTIVE_GROUP);
-                }
-                finally {
-                    this.delegate?.didOpenElement();
-                }
-            }
-        }));
-        this._register(this.tree.onContextMenu(e => this.onContextMenu(e)));
-        this._register(this.tree.onDidScroll(async (e) => {
-            const editable = this.explorerService.getEditable();
-            if (e.scrollTopChanged && editable && this.tree.getRelativeTop(editable.stat) === null) {
-                await editable.data.onFinish('', false);
-            }
-        }));
-        this._register(this.tree.onDidChangeCollapseState(e => {
-            const element = e.node.element?.element;
-            if (element) {
-                const navigationController = this.renderer.getCompressedNavigationController(element instanceof Array ? element[0] : element);
-                navigationController?.updateCollapsed(e.node.collapsed);
-            }
-            this.updateAnyCollapsedContext();
-        }));
-        this.updateAnyCollapsedContext();
-        this._register(this.tree.onMouseDblClick(e => {
-            const scrollingByPage = this.configurationService.getValue('workbench.list.scrollByPage');
-            if (e.element === null && !scrollingByPage) {
-                this.commandService.executeCommand(NEW_FILE_COMMAND_ID);
-            }
-        }));
-        this._register(this.storageService.onWillSaveState(() => {
-            this.storageService.store(ExplorerView.TREE_VIEW_STATE_STORAGE_KEY, JSON.stringify(this.tree.getViewState()), 1 , 1 );
-        }));
-    }
-    onConfigurationUpdated(event) {
-        if (!event || event.affectsConfiguration('explorer.autoReveal')) {
-            const configuration = this.configurationService.getValue();
-            this.autoReveal = configuration?.explorer?.autoReveal;
-        }
-        if (event && (event.affectsConfiguration('explorer.decorations.colors') || event.affectsConfiguration('explorer.decorations.badges'))) {
-            this.refresh(true);
-        }
-    }
-    setContextKeys(stat) {
-        const folders = this.contextService.getWorkspace().folders;
-        const resource = stat ? stat.resource : folders[folders.length - 1].uri;
-        stat = stat || this.explorerService.findClosest(resource);
-        this.resourceContext.set(resource);
-        this.folderContext.set(!!stat && stat.isDirectory);
-        this.readonlyContext.set(!!stat && stat.isReadonly);
-        this.rootContext.set(!!stat && stat.isRoot);
-        if (resource) {
-            const overrides = resource ? ( this.editorResolverService.getEditors(resource).map(editor => editor.id)) : [];
-            this.availableEditorIdsContext.set(overrides.join(','));
-        }
-        else {
-            this.availableEditorIdsContext.reset();
-        }
-    }
-    async onContextMenu(e) {
-        if (isInputElement(e.browserEvent.target)) {
-            return;
-        }
-        const stat = e.element;
-        let anchor = e.anchor;
-        if (stat) {
-            const controller = this.renderer.getCompressedNavigationController(stat);
-            if (controller) {
-                if (e.browserEvent instanceof KeyboardEvent || isCompressedFolderName(e.browserEvent.target)) {
-                    anchor = controller.labels[controller.index];
-                }
-                else {
-                    controller.last();
-                }
-            }
-        }
-        this.fileCopiedContextKey.set(await this.clipboardService.hasResources());
-        this.setContextKeys(stat);
-        const selection = this.tree.getSelection();
-        const roots = this.explorerService.roots;
-        let arg;
-        if (stat instanceof ExplorerItem) {
-            const compressedController = this.renderer.getCompressedNavigationController(stat);
-            arg = compressedController ? compressedController.current.resource : stat.resource;
-        }
-        else {
-            arg = roots.length === 1 ? roots[0].resource : {};
-        }
-        this.contextMenuService.showContextMenu({
-            menuId: MenuId.ExplorerContext,
-            menuActionOptions: { arg, shouldForwardArgs: true },
-            contextKeyService: this.tree.contextKeyService,
-            getAnchor: () => anchor,
-            onHide: (wasCancelled) => {
-                if (wasCancelled) {
-                    this.tree.domFocus();
-                }
-            },
-            getActionsContext: () => stat && selection && selection.indexOf(stat) >= 0
-                ? ( selection.map((fs) => fs.resource))
-                : stat instanceof ExplorerItem ? [stat.resource] : []
-        });
-    }
-    onFocusChanged(elements) {
-        const stat = elements && elements.length ? elements[0] : undefined;
-        this.setContextKeys(stat);
-        if (stat) {
-            const enableTrash = this.configurationService.getValue().files.enableTrash;
-            const hasCapability = this.fileService.hasCapability(stat.resource, 4096 );
-            this.resourceMoveableToTrash.set(enableTrash && hasCapability);
-        }
-        else {
-            this.resourceMoveableToTrash.reset();
-        }
-        const compressedNavigationController = stat && this.renderer.getCompressedNavigationController(stat);
-        if (!compressedNavigationController) {
-            this.compressedFocusContext.set(false);
-            return;
-        }
-        this.compressedFocusContext.set(true);
-        this.updateCompressedNavigationContextKeys(compressedNavigationController);
-    }
-    refresh(recursive, item, cancelEditing = true) {
-        if (!this.tree || !this.isBodyVisible() || (item && !this.tree.hasNode(item))) {
-            return Promise.resolve(undefined);
-        }
-        if (cancelEditing && this.explorerService.isEditable(undefined)) {
-            this.tree.domFocus();
-        }
-        const toRefresh = item || this.tree.getInput();
-        return this.tree.updateChildren(toRefresh, recursive, false, {
-            diffIdentityProvider: identityProvider
-        });
-    }
-    getOptimalWidth() {
-        const parentNode = this.tree.getHTMLElement();
-        const childNodes = [].slice.call(parentNode.querySelectorAll('.explorer-item .label-name'));
-        return dom.getLargestChildWidth(parentNode, childNodes);
-    }
-    async setTreeInput() {
-        if (!this.isBodyVisible()) {
-            return Promise.resolve(undefined);
-        }
-        const initialInputSetup = !this.tree.getInput();
-        if (initialInputSetup) {
-            performance.mark('code/willResolveExplorer');
-        }
-        const roots = this.explorerService.roots;
-        let input = roots[0];
-        if (this.contextService.getWorkbenchState() !== 2  || roots[0].error) {
-            input = roots;
-        }
-        let viewState;
-        if (this.tree && this.tree.getInput()) {
-            viewState = this.tree.getViewState();
-        }
-        else {
-            const rawViewState = this.storageService.get(ExplorerView.TREE_VIEW_STATE_STORAGE_KEY, 1 );
-            if (rawViewState) {
-                viewState = JSON.parse(rawViewState);
-            }
-        }
-        const previousInput = this.tree.getInput();
-        const promise = this.tree.setInput(input, viewState).then(async () => {
-            if (Array.isArray(input)) {
-                if (!viewState || previousInput instanceof ExplorerItem) {
-                    await Promise.all(( input.map(async (item) => {
-                        try {
-                            await this.tree.expand(item);
-                        }
-                        catch (e) { }
-                    })));
-                }
-                if (!previousInput && input.length === 1 && this.configurationService.getValue().explorer.expandSingleFolderWorkspaces) {
-                    await this.tree.expand(input[0]).catch(() => { });
-                }
-                if (Array.isArray(previousInput)) {
-                    const previousRoots = ( new ResourceMap());
-                    previousInput.forEach(previousRoot => previousRoots.set(previousRoot.resource, true));
-                    await Promise.all(( input.map(async (item) => {
-                        if (!( previousRoots.has(item.resource))) {
-                            try {
-                                await this.tree.expand(item);
-                            }
-                            catch (e) { }
-                        }
-                    })));
-                }
-            }
-            if (initialInputSetup) {
-                performance.mark('code/didResolveExplorer');
-            }
-        });
-        this.progressService.withProgress({
-            location: 1 ,
-            delay: this.layoutService.isRestored() ? 800 : 1500
-        }, _progress => promise);
-        await promise;
-        if (!this.decorationsProvider) {
-            this.decorationsProvider = ( new ExplorerDecorationsProvider(this.explorerService, this.contextService));
-            this._register(this.decorationService.registerDecorationsProvider(this.decorationsProvider));
-        }
-    }
-    async selectResource(resource, reveal = this.autoReveal, retry = 0) {
-        if (retry === 2) {
-            return;
-        }
-        if (!resource || !this.isBodyVisible()) {
-            return;
-        }
-        let item = this.explorerService.findClosestRoot(resource);
-        while (item && ( item.resource.toString()) !== ( resource.toString())) {
-            try {
-                await this.tree.expand(item);
-            }
-            catch (e) {
-                return this.selectResource(resource, reveal, retry + 1);
-            }
-            for (const child of ( item.children.values())) {
-                if (this.uriIdentityService.extUri.isEqualOrParent(resource, child.resource)) {
-                    item = child;
-                    break;
-                }
-                item = null;
-            }
-        }
-        if (item) {
-            if (item === this.tree.getInput()) {
-                this.tree.setFocus([]);
-                this.tree.setSelection([]);
-                return;
-            }
-            try {
-                if (item.nestedParent) {
-                    await this.tree.expand(item.nestedParent);
-                }
-                if ((reveal === true || reveal === 'force') && this.tree.getRelativeTop(item) === null) {
-                    this.tree.reveal(item, 0.5);
-                }
-                this.tree.setFocus([item]);
-                this.tree.setSelection([item]);
-            }
-            catch (e) {
-                return this.selectResource(resource, reveal, retry + 1);
-            }
-        }
-    }
-    itemsCopied(stats, cut, previousCut) {
-        this.fileCopiedContextKey.set(stats.length > 0);
-        this.resourceCutContextKey.set(cut && stats.length > 0);
-        previousCut?.forEach(item => this.tree.rerender(item));
-        if (cut) {
-            stats.forEach(s => this.tree.rerender(s));
-        }
-    }
-    expandAll() {
-        if (this.explorerService.isEditable(undefined)) {
-            this.tree.domFocus();
-        }
-        this.tree.expandAll();
-    }
-    collapseAll() {
-        if (this.explorerService.isEditable(undefined)) {
-            this.tree.domFocus();
-        }
-        const treeInput = this.tree.getInput();
-        if (Array.isArray(treeInput)) {
-            if (hasExpandedRootChild(this.tree, treeInput)) {
-                treeInput.forEach(folder => {
-                    folder.children.forEach(child => this.tree.hasNode(child) && this.tree.collapse(child, true));
-                });
-                return;
-            }
-        }
-        this.tree.collapseAll();
-    }
-    previousCompressedStat() {
-        const focused = this.tree.getFocus();
-        if (!focused.length) {
-            return;
-        }
-        const compressedNavigationController = this.renderer.getCompressedNavigationController(focused[0]);
-        compressedNavigationController.previous();
-        this.updateCompressedNavigationContextKeys(compressedNavigationController);
-    }
-    nextCompressedStat() {
-        const focused = this.tree.getFocus();
-        if (!focused.length) {
-            return;
-        }
-        const compressedNavigationController = this.renderer.getCompressedNavigationController(focused[0]);
-        compressedNavigationController.next();
-        this.updateCompressedNavigationContextKeys(compressedNavigationController);
-    }
-    firstCompressedStat() {
-        const focused = this.tree.getFocus();
-        if (!focused.length) {
-            return;
-        }
-        const compressedNavigationController = this.renderer.getCompressedNavigationController(focused[0]);
-        compressedNavigationController.first();
-        this.updateCompressedNavigationContextKeys(compressedNavigationController);
-    }
-    lastCompressedStat() {
-        const focused = this.tree.getFocus();
-        if (!focused.length) {
-            return;
-        }
-        const compressedNavigationController = this.renderer.getCompressedNavigationController(focused[0]);
-        compressedNavigationController.last();
-        this.updateCompressedNavigationContextKeys(compressedNavigationController);
-    }
-    updateCompressedNavigationContextKeys(controller) {
-        this.compressedFocusFirstContext.set(controller.index === 0);
-        this.compressedFocusLastContext.set(controller.index === controller.count - 1);
-    }
-    updateAnyCollapsedContext() {
-        const treeInput = this.tree.getInput();
-        if (treeInput === undefined) {
-            return;
-        }
-        const treeInputArray = Array.isArray(treeInput) ? treeInput : Array.from(( treeInput.children.values()));
-        this.viewHasSomeCollapsibleRootItem.set(hasExpandedNode(this.tree, treeInputArray));
-    }
-    dispose() {
-        this.dragHandler?.dispose();
-        super.dispose();
-    }
-};
-ExplorerView.TREE_VIEW_STATE_STORAGE_KEY = 'workbench.explorer.treeViewState';
-ExplorerView.__decorator = ( __decorate([
-    memoize
-], ExplorerView.prototype, "fileCopiedContextKey", null));
-ExplorerView.__decorator = ( __decorate([
-    memoize
-], ExplorerView.prototype, "resourceCutContextKey", null));
-ExplorerView = ( __decorate([
-    ( __param(1, IContextMenuService)),
-    ( __param(2, IViewDescriptorService)),
-    ( __param(3, IInstantiationService)),
-    ( __param(4, IWorkspaceContextService)),
-    ( __param(5, IProgressService)),
-    ( __param(6, IEditorService)),
-    ( __param(7, IEditorResolverService)),
-    ( __param(8, IWorkbenchLayoutService)),
-    ( __param(9, IKeybindingService)),
-    ( __param(10, IContextKeyService)),
-    ( __param(11, IConfigurationService)),
-    ( __param(12, IDecorationsService)),
-    ( __param(13, ILabelService)),
-    ( __param(14, IThemeService)),
-    ( __param(15, ITelemetryService)),
-    ( __param(16, IExplorerService)),
-    ( __param(17, IStorageService)),
-    ( __param(18, IClipboardService)),
-    ( __param(19, IFileService)),
-    ( __param(20, IUriIdentityService)),
-    ( __param(21, ICommandService)),
-    ( __param(22, IOpenerService))
-], ExplorerView));
-function createFileIconThemableTreeContainerScope(container, themeService) {
-    container.classList.add('file-icon-themable-tree');
-    container.classList.add('show-file-icons');
-    const onDidChangeFileIconTheme = (theme) => {
-        container.classList.toggle('align-icons-and-twisties', theme.hasFileIcons && !theme.hasFolderIcons);
-        container.classList.toggle('hide-arrows', theme.hidesExplorerArrows === true);
-    };
-    onDidChangeFileIconTheme(themeService.getFileIconTheme());
-    return themeService.onDidFileIconThemeChange(onDidChangeFileIconTheme);
-}
-registerAction2(class extends Action2 {
-    constructor() {
-        super({
-            id: 'workbench.files.action.createFileFromExplorer',
-            title: ( nls.localize('createNewFile', "New File...")),
-            f1: false,
-            icon: Codicon.newFile,
-            precondition: ExplorerResourceNotReadonlyContext,
-            menu: {
-                id: MenuId.ViewTitle,
-                group: 'navigation',
-                when: ( ContextKeyExpr.equals('view', VIEW_ID)),
-                order: 10
-            }
-        });
-    }
-    run(accessor) {
-        const commandService = accessor.get(ICommandService);
-        commandService.executeCommand(NEW_FILE_COMMAND_ID);
-    }
-});
-registerAction2(class extends Action2 {
-    constructor() {
-        super({
-            id: 'workbench.files.action.createFolderFromExplorer',
-            title: ( nls.localize('createNewFolder', "New Folder...")),
-            f1: false,
-            icon: Codicon.newFolder,
-            precondition: ExplorerResourceNotReadonlyContext,
-            menu: {
-                id: MenuId.ViewTitle,
-                group: 'navigation',
-                when: ( ContextKeyExpr.equals('view', VIEW_ID)),
-                order: 20
-            }
-        });
-    }
-    run(accessor) {
-        const commandService = accessor.get(ICommandService);
-        commandService.executeCommand(NEW_FOLDER_COMMAND_ID);
-    }
-});
-registerAction2(class extends Action2 {
-    constructor() {
-        super({
-            id: 'workbench.files.action.refreshFilesExplorer',
-            title: { value: ( nls.localize('refreshExplorer', "Refresh Explorer")), original: 'Refresh Explorer' },
-            f1: true,
-            icon: Codicon.refresh,
-            menu: {
-                id: MenuId.ViewTitle,
-                group: 'navigation',
-                when: ( ContextKeyExpr.equals('view', VIEW_ID)),
-                order: 30
-            }
-        });
-    }
-    async run(accessor) {
-        const paneCompositeService = accessor.get(IPaneCompositePartService);
-        const explorerService = accessor.get(IExplorerService);
-        await paneCompositeService.openPaneComposite(VIEWLET_ID, 0 );
-        await explorerService.refresh();
-    }
-});
-registerAction2(class extends Action2 {
-    constructor() {
-        super({
-            id: 'workbench.files.action.collapseExplorerFolders',
-            title: { value: ( nls.localize('collapseExplorerFolders', "Collapse Folders in Explorer")), original: 'Collapse Folders in Explorer' },
-            f1: true,
-            icon: Codicon.collapseAll,
-            menu: {
-                id: MenuId.ViewTitle,
-                group: 'navigation',
-                when: ( ContextKeyExpr.equals('view', VIEW_ID)),
-                order: 40
-            }
-        });
-    }
-    run(accessor) {
-        const viewsService = accessor.get(IViewsService);
-        const explorerView = viewsService.getViewWithId(VIEW_ID);
-        explorerView.collapseAll();
-    }
-});
-export { ExplorerView, getContext };