@codingame/monaco-vscode-views-service-override 2.1.4 → 2.2.0-next.2

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

@@ -1,432 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Event } from 'vscode/vscode/vs/base/common/event';
-import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace';
-import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
-import { ExplorerModel, ExplorerItem } from 'vscode/vscode/vs/workbench/contrib/files/common/explorerModel';
-import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
-import { dirname, basename } from 'vscode/vscode/vs/base/common/resources';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { IClipboardService } from 'vscode/vscode/vs/platform/clipboard/common/clipboardService';
-import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
-import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
-import { IBulkEditService } from 'vscode/vscode/vs/editor/browser/services/bulkEditService';
-import { UndoRedoSource } from 'vscode/vscode/vs/platform/undoRedo/common/undoRedo';
-import { IProgressService } from 'vscode/vscode/vs/platform/progress/common/progress';
-import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
-import { RunOnceScheduler } from 'vscode/vscode/vs/base/common/async';
-import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host';
-import { ResourceGlobMatcher } from 'vscode/vscode/vs/workbench/common/resources';
-import { IFilesConfigurationService } from 'vscode/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService';
-import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
-
-var ExplorerService_1;
-const UNDO_REDO_SOURCE = ( new UndoRedoSource());
-let ExplorerService = class ExplorerService {
-    static { ExplorerService_1 = this; }
-    static { this.EXPLORER_FILE_CHANGES_REACT_DELAY = 500; }
-    constructor(fileService, configurationService, contextService, clipboardService, editorService, uriIdentityService, bulkEditService, progressService, hostService, filesConfigurationService, telemetryService) {
-        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.filesConfigurationService = filesConfigurationService;
-        this.telemetryService = telemetryService;
-        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.filesConfigurationService
-        ));
-        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_1.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);
-        try {
-            await this.view.setEditable(stat, isEditing);
-        }
-        catch {
-            const parent = stat.parent;
-            const errorData = {
-                parentIsDirectory: parent?.isDirectory,
-                isDirectory: stat.isDirectory,
-                isReadonly: !!stat.isReadonly,
-                parentIsReadonly: !!parent?.isReadonly,
-                parentIsExcluded: parent?.isExcluded,
-                isExcluded: stat.isExcluded,
-                parentIsRoot: parent?.isRoot,
-                isRoot: stat.isRoot,
-                parentHasNests: parent?.hasNests,
-                hasNests: stat.hasNests,
-            };
-            this.telemetryService.publicLogError2('explorerView.setEditableError', errorData);
-            return;
-        }
-        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, this.filesConfigurationService, 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, this.filesConfigurationService, stat, p.parent);
-                            ExplorerItem.mergeLocalWithDisk(modelStat, p);
-                        }
-                    }
-                    const childElement = ExplorerItem.create(this.fileService, this.configurationService, this.filesConfigurationService, 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);
-                    this.view?.focusNext();
-                    const oldNestedParent = modelElement.nestedParent;
-                    if (oldNestedParent) {
-                        oldNestedParent.removeChild(modelElement);
-                        await this.view?.refresh(false, oldNestedParent);
-                    }
-                    await this.view?.refresh(shouldDeepRefresh, parent);
-                    if (this.view?.getFocus().length === 0) {
-                        this.view?.focusLast();
-                    }
-                }
-            })));
-        }
-    }
-    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 = ExplorerService_1 = ( __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)),
-    ( __param(9, IFilesConfigurationService)),
-    ( __param(10, ITelemetryService))
-], 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 };