@codingame/monaco-vscode-api 3.0.0 → 3.1.1

package/vscode/src/vs/workbench/contrib/logs/common/defaultLogLevels.js

@@ -0,0 +1,140 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { getLogLevel, ILogService, ILoggerService, LogLevelToString, parseLogLevel } from '../../../../platform/log/common/log.js';
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.js';
+import { toFileOperationResult, IFileService } from '../../../../platform/files/common/files.js';
+import { IJSONEditingService } from '../../../services/configuration/common/jsonEditing.js';
+import { isUndefined, isString } from '../../../../base/common/types.js';
+import { EXTENSION_IDENTIFIER_WITH_LOG_REGEX } from '../../../../platform/environment/common/environmentService.js';
+import { parse } from '../../../../base/common/json.js';
+const IDefaultLogLevelsService = ( createDecorator('IDefaultLogLevelsService'));
+let DefaultLogLevelsService = class DefaultLogLevelsService {
+    constructor(environmentService, fileService, jsonEditingService, logService, loggerService) {
+        this.environmentService = environmentService;
+        this.fileService = fileService;
+        this.jsonEditingService = jsonEditingService;
+        this.logService = logService;
+        this.loggerService = loggerService;
+    }
+    async getDefaultLogLevels() {
+        const argvLogLevel = await this._parseLogLevelsFromArgv();
+        return {
+            default: argvLogLevel?.default ?? this._getDefaultLogLevelFromEnv(),
+            extensions: argvLogLevel?.extensions ?? this._getExtensionsDefaultLogLevelsFromEnv()
+        };
+    }
+    async setDefaultLogLevel(defaultLogLevel, extensionId) {
+        const argvLogLevel = (await this._parseLogLevelsFromArgv()) ?? {};
+        if (extensionId) {
+            extensionId = extensionId.toLowerCase();
+            const argvLogLevel = (await this._parseLogLevelsFromArgv()) ?? {};
+            const currentDefaultLogLevel = this._getDefaultLogLevel(argvLogLevel, extensionId);
+            argvLogLevel.extensions = argvLogLevel.extensions ?? [];
+            const extension = argvLogLevel.extensions.find(([extension]) => extension === extensionId);
+            if (extension) {
+                extension[1] = defaultLogLevel;
+            }
+            else {
+                argvLogLevel.extensions.push([extensionId, defaultLogLevel]);
+            }
+            await this._writeLogLevelsToArgv(argvLogLevel);
+            const extensionLoggers = [...this.loggerService.getRegisteredLoggers()].filter(logger => logger.extensionId && logger.extensionId.toLowerCase() === extensionId);
+            for (const { resource } of extensionLoggers) {
+                if (this.loggerService.getLogLevel(resource) === currentDefaultLogLevel) {
+                    this.loggerService.setLogLevel(resource, defaultLogLevel);
+                }
+            }
+        }
+        else {
+            const currentLogLevel = this._getDefaultLogLevel(argvLogLevel);
+            argvLogLevel.default = defaultLogLevel;
+            await this._writeLogLevelsToArgv(argvLogLevel);
+            if (this.loggerService.getLogLevel() === currentLogLevel) {
+                this.loggerService.setLogLevel(defaultLogLevel);
+            }
+        }
+    }
+    _getDefaultLogLevel(argvLogLevels, extension) {
+        if (extension) {
+            const extensionLogLevel = argvLogLevels.extensions?.find(([extensionId]) => extensionId === extension);
+            if (extensionLogLevel) {
+                return extensionLogLevel[1];
+            }
+        }
+        return argvLogLevels.default ?? getLogLevel(this.environmentService);
+    }
+    async _writeLogLevelsToArgv(logLevels) {
+        const logLevelsValue = [];
+        if (!isUndefined(logLevels.default)) {
+            logLevelsValue.push(LogLevelToString(logLevels.default));
+        }
+        for (const [extension, logLevel] of logLevels.extensions ?? []) {
+            logLevelsValue.push(`${extension}=${LogLevelToString(logLevel)}`);
+        }
+        await this.jsonEditingService.write(this.environmentService.argvResource, [{ path: ['log-level'], value: logLevelsValue.length ? logLevelsValue : undefined }], true);
+    }
+    async _parseLogLevelsFromArgv() {
+        const result = { extensions: [] };
+        const logLevels = await this._readLogLevelsFromArgv();
+        for (const extensionLogLevel of logLevels) {
+            const matches = EXTENSION_IDENTIFIER_WITH_LOG_REGEX.exec(extensionLogLevel);
+            if (matches && matches[1] && matches[2]) {
+                const logLevel = parseLogLevel(matches[2]);
+                if (!isUndefined(logLevel)) {
+                    result.extensions?.push([matches[1].toLowerCase(), logLevel]);
+                }
+            }
+            else {
+                const logLevel = parseLogLevel(extensionLogLevel);
+                if (!isUndefined(logLevel)) {
+                    result.default = logLevel;
+                }
+            }
+        }
+        return !isUndefined(result.default) || result.extensions?.length ? result : undefined;
+    }
+    async migrateLogLevels() {
+        const logLevels = await this._readLogLevelsFromArgv();
+        const regex = /^([^.]+\..+):(.+)$/;
+        if (( logLevels.some(extensionLogLevel => regex.test(extensionLogLevel)))) {
+            const argvLogLevel = await this._parseLogLevelsFromArgv();
+            if (argvLogLevel) {
+                await this._writeLogLevelsToArgv(argvLogLevel);
+            }
+        }
+    }
+    async _readLogLevelsFromArgv() {
+        try {
+            const content = await this.fileService.readFile(this.environmentService.argvResource);
+            const argv = parse(( content.value.toString()));
+            return isString(argv['log-level']) ? [argv['log-level']] : Array.isArray(argv['log-level']) ? argv['log-level'] : [];
+        }
+        catch (error) {
+            if (toFileOperationResult(error) !== 1 ) {
+                this.logService.error(error);
+            }
+        }
+        return [];
+    }
+    _getDefaultLogLevelFromEnv() {
+        return getLogLevel(this.environmentService);
+    }
+    _getExtensionsDefaultLogLevelsFromEnv() {
+        const result = [];
+        for (const [extension, logLevelValue] of this.environmentService.extensionLogLevel ?? []) {
+            const logLevel = parseLogLevel(logLevelValue);
+            if (!isUndefined(logLevel)) {
+                result.push([extension, logLevel]);
+            }
+        }
+        return result;
+    }
+};
+DefaultLogLevelsService = ( __decorate([
+    ( __param(0, IWorkbenchEnvironmentService)),
+    ( __param(1, IFileService)),
+    ( __param(2, IJSONEditingService)),
+    ( __param(3, ILogService)),
+    ( __param(4, ILoggerService))
+], DefaultLogLevelsService));
+export { DefaultLogLevelsService, IDefaultLogLevelsService };

package/vscode/src/vs/workbench/services/workspaces/common/workspaceIdentityService.js

@@ -0,0 +1,102 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { VSBuffer } from '../../../../base/common/buffer.js';
+import { isEqualOrParent, relativePath, joinPath } from '../../../../base/common/resources.js';
+import { URI } from '../../../../base/common/uri.js';
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+import { EditSessionIdentityMatch, IEditSessionIdentityService } from '../../../../platform/workspace/common/editSessions.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
+const IWorkspaceIdentityService = ( createDecorator('IWorkspaceIdentityService'));
+let WorkspaceIdentityService = class WorkspaceIdentityService {
+    constructor(workspaceContextService, editSessionIdentityService) {
+        this.workspaceContextService = workspaceContextService;
+        this.editSessionIdentityService = editSessionIdentityService;
+    }
+    async getWorkspaceStateFolders(cancellationToken) {
+        const workspaceStateFolders = [];
+        for (const workspaceFolder of this.workspaceContextService.getWorkspace().folders) {
+            const workspaceFolderIdentity = await this.editSessionIdentityService.getEditSessionIdentifier(workspaceFolder, cancellationToken);
+            if (!workspaceFolderIdentity) {
+                continue;
+            }
+            workspaceStateFolders.push({ resourceUri: ( workspaceFolder.uri.toString()), workspaceFolderIdentity });
+        }
+        return workspaceStateFolders;
+    }
+    async matches(incomingWorkspaceFolders, cancellationToken) {
+        const incomingToCurrentWorkspaceFolderUris = {};
+        const incomingIdentitiesToIncomingWorkspaceFolders = {};
+        for (const workspaceFolder of incomingWorkspaceFolders) {
+            incomingIdentitiesToIncomingWorkspaceFolders[workspaceFolder.workspaceFolderIdentity] = workspaceFolder.resourceUri;
+        }
+        const currentWorkspaceFoldersToIdentities = ( new Map());
+        for (const workspaceFolder of this.workspaceContextService.getWorkspace().folders) {
+            const workspaceFolderIdentity = await this.editSessionIdentityService.getEditSessionIdentifier(workspaceFolder, cancellationToken);
+            if (!workspaceFolderIdentity) {
+                continue;
+            }
+            currentWorkspaceFoldersToIdentities.set(workspaceFolder, workspaceFolderIdentity);
+        }
+        for (const [currentWorkspaceFolder, currentWorkspaceFolderIdentity] of currentWorkspaceFoldersToIdentities.entries()) {
+            const incomingWorkspaceFolder = incomingIdentitiesToIncomingWorkspaceFolders[currentWorkspaceFolderIdentity];
+            if (incomingWorkspaceFolder) {
+                incomingToCurrentWorkspaceFolderUris[incomingWorkspaceFolder] = ( currentWorkspaceFolder.uri.toString());
+                continue;
+            }
+            let hasCompleteMatch = false;
+            for (const [incomingIdentity, incomingFolder] of Object.entries(incomingIdentitiesToIncomingWorkspaceFolders)) {
+                if ((await this.editSessionIdentityService.provideEditSessionIdentityMatch(currentWorkspaceFolder, currentWorkspaceFolderIdentity, incomingIdentity, cancellationToken)) === EditSessionIdentityMatch.Complete) {
+                    incomingToCurrentWorkspaceFolderUris[incomingFolder] = ( currentWorkspaceFolder.uri.toString());
+                    hasCompleteMatch = true;
+                    break;
+                }
+            }
+            if (hasCompleteMatch) {
+                continue;
+            }
+            return false;
+        }
+        const convertUri = (uriToConvert) => {
+            for (const incomingFolderUriKey of ( Object.keys(incomingToCurrentWorkspaceFolderUris))) {
+                const incomingFolderUri = ( URI.parse(incomingFolderUriKey));
+                if (isEqualOrParent(incomingFolderUri, uriToConvert)) {
+                    const currentWorkspaceFolderUri = incomingToCurrentWorkspaceFolderUris[incomingFolderUriKey];
+                    const relativeFilePath = relativePath(incomingFolderUri, uriToConvert);
+                    if (relativeFilePath) {
+                        return joinPath(( URI.parse(currentWorkspaceFolderUri)), relativeFilePath);
+                    }
+                }
+            }
+            return uriToConvert;
+        };
+        const uriReplacer = (obj, depth = 0) => {
+            if (!obj || depth > 200) {
+                return obj;
+            }
+            if (obj instanceof VSBuffer || obj instanceof Uint8Array) {
+                return obj;
+            }
+            if (URI.isUri(obj)) {
+                return convertUri(obj);
+            }
+            if (Array.isArray(obj)) {
+                for (let i = 0; i < obj.length; ++i) {
+                    obj[i] = uriReplacer(obj[i], depth + 1);
+                }
+            }
+            else {
+                for (const key in obj) {
+                    if (Object.hasOwnProperty.call(obj, key)) {
+                        obj[key] = uriReplacer(obj[key], depth + 1);
+                    }
+                }
+            }
+            return obj;
+        };
+        return uriReplacer;
+    }
+};
+WorkspaceIdentityService = ( __decorate([
+    ( __param(0, IWorkspaceContextService)),
+    ( __param(1, IEditSessionIdentityService))
+], WorkspaceIdentityService));
+export { IWorkspaceIdentityService, WorkspaceIdentityService };

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

@@ -1,430 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Event } from '../../../../base/common/event.js';
-import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
-import { DisposableStore } from '../../../../base/common/lifecycle.js';
-import { ExplorerModel, ExplorerItem } from '../common/explorerModel.js';
-import { IFileService } from '../../../../platform/files/common/files.js';
-import { dirname, basename } from '../../../../base/common/resources.js';
-import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
-import { IClipboardService } from '../../../../platform/clipboard/common/clipboardService.js';
-import { IEditorService } from '../../../services/editor/common/editorService.js';
-import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.js';
-import { IBulkEditService } from '../../../../editor/browser/services/bulkEditService.js';
-import { UndoRedoSource } from '../../../../platform/undoRedo/common/undoRedo.js';
-import { IProgressService } from '../../../../platform/progress/common/progress.js';
-import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
-import { RunOnceScheduler } from '../../../../base/common/async.js';
-import { IHostService } from '../../../services/host/browser/host.js';
-import { ResourceGlobMatcher } from '../../../common/resources.js';
-import { IFilesConfigurationService } from '../../../services/filesConfiguration/common/filesConfigurationService.js';
-import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
-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 };