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

package/dist/vscode/vs/workbench/contrib/files/browser/explorerService.js

@@ -0,0 +1,398 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ExplorerModel, ExplorerItem } from '../common/explorerModel.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { dirname, basename } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.js';
+import { IBulkEditService } from 'monaco-editor/esm/vs/editor/browser/services/bulkEditService.js';
+import { UndoRedoSource } from 'monaco-editor/esm/vs/platform/undoRedo/common/undoRedo.js';
+import { IProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
+import { IHostService } from '../../../services/host/browser/host.js';
+import { ResourceGlobMatcher } from '../../../common/resources.js';
+const UNDO_REDO_SOURCE = ( new UndoRedoSource());
+let ExplorerService = class ExplorerService {
+    constructor(fileService, configurationService, contextService, clipboardService, editorService, uriIdentityService, bulkEditService, progressService, hostService) {
+        this.fileService = fileService;
+        this.configurationService = configurationService;
+        this.contextService = contextService;
+        this.clipboardService = clipboardService;
+        this.editorService = editorService;
+        this.uriIdentityService = uriIdentityService;
+        this.bulkEditService = bulkEditService;
+        this.progressService = progressService;
+        this.disposables = ( new DisposableStore());
+        this.fileChangeEvents = [];
+        this.config = this.configurationService.getValue('explorer');
+        this.model = ( new ExplorerModel(
+            this.contextService,
+            this.uriIdentityService,
+            this.fileService,
+            this.configurationService
+        ));
+        this.disposables.add(this.model);
+        this.disposables.add(this.fileService.onDidRunOperation(e => this.onDidRunOperation(e)));
+        this.onFileChangesScheduler = ( new RunOnceScheduler(async () => {
+            const events = this.fileChangeEvents;
+            this.fileChangeEvents = [];
+            const types = [2 ];
+            if (this.config.sortOrder === "modified" ) {
+                types.push(0 );
+            }
+            let shouldRefresh = false;
+            this.roots.forEach(r => {
+                if (this.view && !shouldRefresh) {
+                    shouldRefresh = doesFileEventAffect(r, this.view, events, types);
+                }
+            });
+            events.forEach(e => {
+                if (!shouldRefresh) {
+                    for (const resource of e.rawAdded) {
+                        const parent = this.model.findClosest(dirname(resource));
+                        if (parent && !parent.getChild(basename(resource))) {
+                            shouldRefresh = true;
+                            break;
+                        }
+                    }
+                }
+            });
+            if (shouldRefresh) {
+                await this.refresh(false);
+            }
+        }, ExplorerService.EXPLORER_FILE_CHANGES_REACT_DELAY));
+        this.disposables.add(this.fileService.onDidFilesChange(e => {
+            this.fileChangeEvents.push(e);
+            if (this.editable) {
+                return;
+            }
+            if (!this.onFileChangesScheduler.isScheduled()) {
+                this.onFileChangesScheduler.schedule();
+            }
+        }));
+        this.disposables.add(this.configurationService.onDidChangeConfiguration(e => this.onConfigurationUpdated(e)));
+        this.disposables.add(Event.any(this.fileService.onDidChangeFileSystemProviderRegistrations, this.fileService.onDidChangeFileSystemProviderCapabilities)(async (e) => {
+            let affected = false;
+            this.model.roots.forEach(r => {
+                if (r.resource.scheme === e.scheme) {
+                    affected = true;
+                    r.forgetChildren();
+                }
+            });
+            if (affected) {
+                if (this.view) {
+                    await this.view.setTreeInput();
+                }
+            }
+        }));
+        this.disposables.add(this.model.onDidChangeRoots(() => {
+            this.view?.setTreeInput();
+        }));
+        this.disposables.add(hostService.onDidChangeFocus(hasFocus => {
+            if (hasFocus) {
+                this.refresh(false);
+            }
+        }));
+        this.revealExcludeMatcher = ( new ResourceGlobMatcher(
+            (uri) => getRevealExcludes(configurationService.getValue({ resource: uri })),
+            (event) => event.affectsConfiguration('explorer.autoRevealExclude'),
+            contextService,
+            configurationService
+        ));
+        this.disposables.add(this.revealExcludeMatcher);
+    }
+    get roots() {
+        return this.model.roots;
+    }
+    get sortOrderConfiguration() {
+        return {
+            sortOrder: this.config.sortOrder,
+            lexicographicOptions: this.config.sortOrderLexicographicOptions,
+        };
+    }
+    registerView(contextProvider) {
+        this.view = contextProvider;
+    }
+    getContext(respectMultiSelection, ignoreNestedChildren = false) {
+        if (!this.view) {
+            return [];
+        }
+        const items = ( new Set(this.view.getContext(respectMultiSelection)));
+        items.forEach(item => {
+            try {
+                if (respectMultiSelection && !ignoreNestedChildren && this.view?.isItemCollapsed(item) && item.nestedChildren) {
+                    for (const child of item.nestedChildren) {
+                        items.add(child);
+                    }
+                }
+            }
+            catch {
+                return;
+            }
+        });
+        return [...items];
+    }
+    async applyBulkEdit(edit, options) {
+        const cancellationTokenSource = ( new CancellationTokenSource());
+        const promise = this.progressService.withProgress({
+            location: options.progressLocation || 10 ,
+            title: options.progressLabel,
+            cancellable: edit.length > 1,
+            delay: 500,
+        }, async (progress) => {
+            await this.bulkEditService.apply(edit, {
+                undoRedoSource: UNDO_REDO_SOURCE,
+                label: options.undoLabel,
+                code: 'undoredo.explorerOperation',
+                progress,
+                token: cancellationTokenSource.token,
+                confirmBeforeUndo: options.confirmBeforeUndo
+            });
+        }, () => cancellationTokenSource.cancel());
+        await this.progressService.withProgress({ location: 1 , delay: 500 }, () => promise);
+        cancellationTokenSource.dispose();
+    }
+    hasViewFocus() {
+        return !!this.view && this.view.hasFocus();
+    }
+    findClosest(resource) {
+        return this.model.findClosest(resource);
+    }
+    findClosestRoot(resource) {
+        const parentRoots = this.model.roots.filter(r => this.uriIdentityService.extUri.isEqualOrParent(resource, r.resource))
+            .sort((first, second) => second.resource.path.length - first.resource.path.length);
+        return parentRoots.length ? parentRoots[0] : null;
+    }
+    async setEditable(stat, data) {
+        if (!this.view) {
+            return;
+        }
+        if (!data) {
+            this.editable = undefined;
+        }
+        else {
+            this.editable = { stat, data };
+        }
+        const isEditing = this.isEditable(stat);
+        await this.view.setEditable(stat, isEditing);
+        if (!this.editable && this.fileChangeEvents.length && !this.onFileChangesScheduler.isScheduled()) {
+            this.onFileChangesScheduler.schedule();
+        }
+    }
+    async setToCopy(items, cut) {
+        const previouslyCutItems = this.cutItems;
+        this.cutItems = cut ? items : undefined;
+        await this.clipboardService.writeResources(( items.map(s => s.resource)));
+        this.view?.itemsCopied(items, cut, previouslyCutItems);
+    }
+    isCut(item) {
+        return !!this.cutItems && ( this.cutItems.some(i => this.uriIdentityService.extUri.isEqual(i.resource, item.resource)));
+    }
+    getEditable() {
+        return this.editable;
+    }
+    getEditableData(stat) {
+        return this.editable && this.editable.stat === stat ? this.editable.data : undefined;
+    }
+    isEditable(stat) {
+        return !!this.editable && (this.editable.stat === stat || !stat);
+    }
+    async select(resource, reveal) {
+        if (!this.view) {
+            return;
+        }
+        const ignoreRevealExcludes = reveal === 'force';
+        const fileStat = this.findClosest(resource);
+        if (fileStat) {
+            if (!this.shouldAutoRevealItem(fileStat, ignoreRevealExcludes)) {
+                return;
+            }
+            await this.view.selectResource(fileStat.resource, reveal);
+            return Promise.resolve(undefined);
+        }
+        const options = { resolveTo: [resource], resolveMetadata: this.config.sortOrder === "modified"  };
+        const root = this.findClosestRoot(resource);
+        if (!root) {
+            return undefined;
+        }
+        try {
+            const stat = await this.fileService.resolve(root.resource, options);
+            const modelStat = ExplorerItem.create(this.fileService, this.configurationService, stat, undefined, options.resolveTo);
+            ExplorerItem.mergeLocalWithDisk(modelStat, root);
+            const item = root.find(resource);
+            await this.view.refresh(true, root);
+            if (item && !this.shouldAutoRevealItem(item, ignoreRevealExcludes)) {
+                return;
+            }
+            await this.view.selectResource(item ? item.resource : undefined, reveal);
+        }
+        catch (error) {
+            root.error = error;
+            await this.view.refresh(false, root);
+        }
+    }
+    async refresh(reveal = true) {
+        this.model.roots.forEach(r => r.forgetChildren());
+        if (this.view) {
+            await this.view.refresh(true);
+            const resource = this.editorService.activeEditor?.resource;
+            const autoReveal = this.configurationService.getValue().explorer.autoReveal;
+            if (reveal && resource && autoReveal) {
+                this.select(resource, autoReveal);
+            }
+        }
+    }
+    async onDidRunOperation(e) {
+        const shouldDeepRefresh = this.config.fileNesting.enabled;
+        if (e.isOperation(0 ) || e.isOperation(3 )) {
+            const addedElement = e.target;
+            const parentResource = dirname(addedElement.resource);
+            const parents = this.model.findAll(parentResource);
+            if (parents.length) {
+                await Promise.all(( parents.map(async (p) => {
+                    const resolveMetadata = this.config.sortOrder === `modified`;
+                    if (!p.isDirectoryResolved) {
+                        const stat = await this.fileService.resolve(p.resource, { resolveMetadata });
+                        if (stat) {
+                            const modelStat = ExplorerItem.create(this.fileService, this.configurationService, stat, p.parent);
+                            ExplorerItem.mergeLocalWithDisk(modelStat, p);
+                        }
+                    }
+                    const childElement = ExplorerItem.create(this.fileService, this.configurationService, addedElement, p.parent);
+                    p.removeChild(childElement);
+                    p.addChild(childElement);
+                    await this.view?.refresh(shouldDeepRefresh, p);
+                })));
+            }
+        }
+        else if (e.isOperation(2 )) {
+            const oldResource = e.resource;
+            const newElement = e.target;
+            const oldParentResource = dirname(oldResource);
+            const newParentResource = dirname(newElement.resource);
+            const modelElements = this.model.findAll(oldResource);
+            const sameParentMove = modelElements.every(e => !e.nestedParent) && this.uriIdentityService.extUri.isEqual(oldParentResource, newParentResource);
+            if (sameParentMove) {
+                await Promise.all(( modelElements.map(async (modelElement) => {
+                    modelElement.rename(newElement);
+                    await this.view?.refresh(shouldDeepRefresh, modelElement.parent);
+                })));
+            }
+            else {
+                const newParents = this.model.findAll(newParentResource);
+                if (newParents.length && modelElements.length) {
+                    await Promise.all(( modelElements.map(async (modelElement, index) => {
+                        const oldParent = modelElement.parent;
+                        const oldNestedParent = modelElement.nestedParent;
+                        modelElement.move(newParents[index]);
+                        if (oldNestedParent) {
+                            await this.view?.refresh(false, oldNestedParent);
+                        }
+                        await this.view?.refresh(false, oldParent);
+                        await this.view?.refresh(shouldDeepRefresh, newParents[index]);
+                    })));
+                }
+            }
+        }
+        else if (e.isOperation(1 )) {
+            const modelElements = this.model.findAll(e.resource);
+            await Promise.all(( modelElements.map(async (modelElement) => {
+                if (modelElement.parent) {
+                    const parent = modelElement.parent;
+                    parent.removeChild(modelElement);
+                    const oldNestedParent = modelElement.nestedParent;
+                    if (oldNestedParent) {
+                        oldNestedParent.removeChild(modelElement);
+                        await this.view?.refresh(false, oldNestedParent);
+                    }
+                    await this.view?.refresh(shouldDeepRefresh, parent);
+                }
+            })));
+        }
+    }
+    shouldAutoRevealItem(item, ignore) {
+        if (item === undefined || ignore) {
+            return true;
+        }
+        if (this.revealExcludeMatcher.matches(item.resource, name => !!(item.parent && item.parent.getChild(name)))) {
+            return false;
+        }
+        const root = item.root;
+        let currentItem = item.parent;
+        while (currentItem !== root) {
+            if (currentItem === undefined) {
+                return true;
+            }
+            if (this.revealExcludeMatcher.matches(currentItem.resource)) {
+                return false;
+            }
+            currentItem = currentItem.parent;
+        }
+        return true;
+    }
+    async onConfigurationUpdated(event) {
+        if (!event.affectsConfiguration('explorer')) {
+            return;
+        }
+        let shouldRefresh = false;
+        if (event.affectsConfiguration('explorer.fileNesting')) {
+            shouldRefresh = true;
+        }
+        const configuration = this.configurationService.getValue();
+        const configSortOrder = configuration?.explorer?.sortOrder || "default" ;
+        if (this.config.sortOrder !== configSortOrder) {
+            shouldRefresh = this.config.sortOrder !== undefined;
+        }
+        const configLexicographicOptions = configuration?.explorer?.sortOrderLexicographicOptions || "default" ;
+        if (this.config.sortOrderLexicographicOptions !== configLexicographicOptions) {
+            shouldRefresh = shouldRefresh || this.config.sortOrderLexicographicOptions !== undefined;
+        }
+        this.config = configuration.explorer;
+        if (shouldRefresh) {
+            await this.refresh();
+        }
+    }
+    dispose() {
+        this.disposables.dispose();
+    }
+};
+ExplorerService.EXPLORER_FILE_CHANGES_REACT_DELAY = 500;
+ExplorerService = ( __decorate([
+    ( __param(0, IFileService)),
+    ( __param(1, IConfigurationService)),
+    ( __param(2, IWorkspaceContextService)),
+    ( __param(3, IClipboardService)),
+    ( __param(4, IEditorService)),
+    ( __param(5, IUriIdentityService)),
+    ( __param(6, IBulkEditService)),
+    ( __param(7, IProgressService)),
+    ( __param(8, IHostService))
+], ExplorerService));
+function doesFileEventAffect(item, view, events, types) {
+    for (const [_name, child] of item.children) {
+        if (view.isItemVisible(child)) {
+            if (( events.some(e => e.contains(child.resource, ...types)))) {
+                return true;
+            }
+            if (child.isDirectory && child.isDirectoryResolved) {
+                if (doesFileEventAffect(child, view, events, types)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+function getRevealExcludes(configuration) {
+    const revealExcludes = configuration && configuration.explorer && configuration.explorer.autoRevealExclude;
+    if (!revealExcludes) {
+        return {};
+    }
+    return revealExcludes;
+}
+export { ExplorerService, UNDO_REDO_SOURCE };