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

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

@@ -0,0 +1,793 @@
+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 };