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

package/dist/vscode/vs/workbench/services/workingCopy/common/workingCopyBackupService.js

@@ -0,0 +1,414 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { basename, isEqual, joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { deepClone, equals } from 'monaco-editor/esm/vs/base/common/objects.js';
+import { ResourceQueue, Promises } from 'monaco-editor/esm/vs/base/common/async.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { isReadableStream, peekStream } from '../../../../base/common/stream.js';
+import { VSBuffer, prefixedBufferStream, prefixedBufferReadable, bufferToStream, streamToBuffer, readableToBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { hash } from 'monaco-editor/esm/vs/base/common/hash.js';
+import { isEmptyObject } from 'monaco-editor/esm/vs/base/common/types.js';
+import { NO_TYPE_ID } from './workingCopy.js';
+class WorkingCopyBackupsModel {
+    static async create(backupRoot, fileService) {
+        const model = ( (new WorkingCopyBackupsModel(backupRoot, fileService)));
+        await model.resolve();
+        return model;
+    }
+    constructor(backupRoot, fileService) {
+        this.backupRoot = backupRoot;
+        this.fileService = fileService;
+        this.cache = ( (new ResourceMap()));
+    }
+    async resolve() {
+        try {
+            const backupRootStat = await this.fileService.resolve(this.backupRoot);
+            if (backupRootStat.children) {
+                await Promises.settled(( (backupRootStat.children
+                    .filter(child => child.isDirectory)
+                    .map(async (backupSchemaFolder) => {
+                    const backupSchemaFolderStat = await this.fileService.resolve(backupSchemaFolder.resource);
+                    if (backupSchemaFolderStat.children) {
+                        for (const backupForSchema of backupSchemaFolderStat.children) {
+                            if (!backupForSchema.isDirectory) {
+                                this.add(backupForSchema.resource);
+                            }
+                        }
+                    }
+                }))));
+            }
+        }
+        catch (error) {
+        }
+    }
+    add(resource, versionId = 0, meta) {
+        this.cache.set(resource, {
+            versionId,
+            meta: deepClone(meta)
+        });
+    }
+    update(resource, meta) {
+        const entry = this.cache.get(resource);
+        if (entry) {
+            entry.meta = deepClone(meta);
+        }
+    }
+    count() {
+        return this.cache.size;
+    }
+    has(resource, versionId, meta) {
+        const entry = this.cache.get(resource);
+        if (!entry) {
+            return false;
+        }
+        if (typeof versionId === 'number' && versionId !== entry.versionId) {
+            return false;
+        }
+        if (meta && !equals(meta, entry.meta)) {
+            return false;
+        }
+        return true;
+    }
+    get() {
+        return Array.from(( (this.cache.keys())));
+    }
+    remove(resource) {
+        this.cache.delete(resource);
+    }
+    move(source, target) {
+        const entry = this.cache.get(source);
+        if (entry) {
+            this.cache.delete(source);
+            this.cache.set(target, entry);
+        }
+    }
+    clear() {
+        this.cache.clear();
+    }
+}
+let WorkingCopyBackupServiceImpl = class WorkingCopyBackupServiceImpl extends Disposable {
+    constructor(backupWorkspaceHome, fileService, logService) {
+        super();
+        this.backupWorkspaceHome = backupWorkspaceHome;
+        this.fileService = fileService;
+        this.logService = logService;
+        this.ioOperationQueues = this._register(( (new ResourceQueue())));
+        this.model = undefined;
+        this.initialize(backupWorkspaceHome);
+    }
+    initialize(backupWorkspaceResource) {
+        this.backupWorkspaceHome = backupWorkspaceResource;
+        this.ready = this.doInitialize();
+    }
+    async doInitialize() {
+        this.model = await WorkingCopyBackupsModel.create(this.backupWorkspaceHome, this.fileService);
+        for (const backupResource of this.model.get()) {
+            if (basename(backupResource).length !== 32) {
+                continue;
+            }
+            try {
+                const identifier = await this.resolveIdentifier(backupResource, this.model);
+                if (!identifier) {
+                    this.logService.warn(`Backup: Unable to read target URI of backup ${backupResource} for migration to new hash.`);
+                    continue;
+                }
+                const expectedBackupResource = this.toBackupResource(identifier);
+                if (!isEqual(expectedBackupResource, backupResource)) {
+                    await this.fileService.move(backupResource, expectedBackupResource, true);
+                    this.model.move(backupResource, expectedBackupResource);
+                }
+            }
+            catch (error) {
+                this.logService.error(`Backup: Unable to migrate backup ${backupResource} to new hash.`);
+            }
+        }
+        return this.model;
+    }
+    async hasBackups() {
+        const model = await this.ready;
+        return model.count() > 0;
+    }
+    hasBackupSync(identifier, versionId, meta) {
+        if (!this.model) {
+            return false;
+        }
+        const backupResource = this.toBackupResource(identifier);
+        return this.model.has(backupResource, versionId, meta);
+    }
+    async backup(identifier, content, versionId, meta, token) {
+        const model = await this.ready;
+        if (token?.isCancellationRequested) {
+            return;
+        }
+        const backupResource = this.toBackupResource(identifier);
+        if (model.has(backupResource, versionId, meta)) {
+            return;
+        }
+        return this.ioOperationQueues.queueFor(backupResource).queue(async () => {
+            if (token?.isCancellationRequested) {
+                return;
+            }
+            if (model.has(backupResource, versionId, meta)) {
+                return;
+            }
+            let preamble = this.createPreamble(identifier, meta);
+            if (preamble.length >= WorkingCopyBackupServiceImpl.PREAMBLE_MAX_LENGTH) {
+                preamble = this.createPreamble(identifier);
+            }
+            const preambleBuffer = VSBuffer.fromString(preamble);
+            let backupBuffer;
+            if (isReadableStream(content)) {
+                backupBuffer = prefixedBufferStream(preambleBuffer, content);
+            }
+            else if (content) {
+                backupBuffer = prefixedBufferReadable(preambleBuffer, content);
+            }
+            else {
+                backupBuffer = VSBuffer.concat([preambleBuffer, VSBuffer.fromString('')]);
+            }
+            await this.fileService.writeFile(backupResource, backupBuffer);
+            model.add(backupResource, versionId, meta);
+        });
+    }
+    createPreamble(identifier, meta) {
+        return `${( ( identifier.resource.toString()))}${WorkingCopyBackupServiceImpl.PREAMBLE_META_SEPARATOR}${JSON.stringify({ ...meta, typeId: identifier.typeId })}${WorkingCopyBackupServiceImpl.PREAMBLE_END_MARKER}`;
+    }
+    async discardBackups(filter) {
+        const model = await this.ready;
+        const except = filter?.except;
+        if (Array.isArray(except) && except.length > 0) {
+            const exceptMap = ( (new ResourceMap()));
+            for (const exceptWorkingCopy of except) {
+                exceptMap.set(this.toBackupResource(exceptWorkingCopy), true);
+            }
+            await Promises.settled(( (model.get().map(async (backupResource) => {
+                if (!exceptMap.has(backupResource)) {
+                    await this.doDiscardBackup(backupResource);
+                }
+            }))));
+        }
+        else {
+            await this.deleteIgnoreFileNotFound(this.backupWorkspaceHome);
+            model.clear();
+        }
+    }
+    discardBackup(identifier, token) {
+        const backupResource = this.toBackupResource(identifier);
+        return this.doDiscardBackup(backupResource, token);
+    }
+    async doDiscardBackup(backupResource, token) {
+        const model = await this.ready;
+        if (token?.isCancellationRequested) {
+            return;
+        }
+        return this.ioOperationQueues.queueFor(backupResource).queue(async () => {
+            if (token?.isCancellationRequested) {
+                return;
+            }
+            await this.deleteIgnoreFileNotFound(backupResource);
+            model.remove(backupResource);
+        });
+    }
+    async deleteIgnoreFileNotFound(backupResource) {
+        try {
+            await this.fileService.del(backupResource, { recursive: true });
+        }
+        catch (error) {
+            if (error.fileOperationResult !== 1 ) {
+                throw error;
+            }
+        }
+    }
+    async getBackups() {
+        const model = await this.ready;
+        const backups = await Promise.all(( (model.get().map(backupResource => this.resolveIdentifier(backupResource, model)))));
+        return coalesce(backups);
+    }
+    async resolveIdentifier(backupResource, model) {
+        const backupPreamble = await this.readToMatchingString(backupResource, WorkingCopyBackupServiceImpl.PREAMBLE_END_MARKER, WorkingCopyBackupServiceImpl.PREAMBLE_MAX_LENGTH);
+        if (!backupPreamble) {
+            return undefined;
+        }
+        const metaStartIndex = backupPreamble.indexOf(WorkingCopyBackupServiceImpl.PREAMBLE_META_SEPARATOR);
+        let resourcePreamble;
+        let metaPreamble;
+        if (metaStartIndex > 0) {
+            resourcePreamble = backupPreamble.substring(0, metaStartIndex);
+            metaPreamble = backupPreamble.substr(metaStartIndex + 1);
+        }
+        else {
+            resourcePreamble = backupPreamble;
+            metaPreamble = undefined;
+        }
+        const { typeId, meta } = this.parsePreambleMeta(metaPreamble);
+        model.update(backupResource, meta);
+        return {
+            typeId: typeId ?? NO_TYPE_ID,
+            resource: ( (URI.parse(resourcePreamble)))
+        };
+    }
+    async readToMatchingString(backupResource, matchingString, maximumBytesToRead) {
+        const contents = ( ((await this.fileService.readFile(backupResource, { length: maximumBytesToRead })).value.toString()));
+        const matchingStringIndex = contents.indexOf(matchingString);
+        if (matchingStringIndex >= 0) {
+            return contents.substr(0, matchingStringIndex);
+        }
+        return undefined;
+    }
+    async resolve(identifier) {
+        const backupResource = this.toBackupResource(identifier);
+        const model = await this.ready;
+        if (!model.has(backupResource)) {
+            return undefined;
+        }
+        const backupStream = await this.fileService.readFileStream(backupResource);
+        const peekedBackupStream = await peekStream(backupStream.value, 1);
+        const firstBackupChunk = VSBuffer.concat(peekedBackupStream.buffer);
+        const preambleEndIndex = firstBackupChunk.buffer.indexOf(WorkingCopyBackupServiceImpl.PREAMBLE_END_MARKER_CHARCODE);
+        if (preambleEndIndex === -1) {
+            this.logService.trace(`Backup: Could not find meta end marker in ${backupResource}. The file is probably corrupt (filesize: ${backupStream.size}).`);
+            return undefined;
+        }
+        const preambelRaw = ( (firstBackupChunk.slice(0, preambleEndIndex).toString()));
+        let meta;
+        const metaStartIndex = preambelRaw.indexOf(WorkingCopyBackupServiceImpl.PREAMBLE_META_SEPARATOR);
+        if (metaStartIndex !== -1) {
+            meta = this.parsePreambleMeta(preambelRaw.substr(metaStartIndex + 1)).meta;
+        }
+        model.update(backupResource, meta);
+        const firstBackupChunkWithoutPreamble = firstBackupChunk.slice(preambleEndIndex + 1);
+        let value;
+        if (peekedBackupStream.ended) {
+            value = bufferToStream(firstBackupChunkWithoutPreamble);
+        }
+        else {
+            value = prefixedBufferStream(firstBackupChunkWithoutPreamble, peekedBackupStream.stream);
+        }
+        return { value, meta };
+    }
+    parsePreambleMeta(preambleMetaRaw) {
+        let typeId = undefined;
+        let meta = undefined;
+        if (preambleMetaRaw) {
+            try {
+                meta = JSON.parse(preambleMetaRaw);
+                typeId = meta?.typeId;
+                if (typeof meta?.typeId === 'string') {
+                    delete meta.typeId;
+                    if (isEmptyObject(meta)) {
+                        meta = undefined;
+                    }
+                }
+            }
+            catch (error) {
+            }
+        }
+        return { typeId, meta };
+    }
+    toBackupResource(identifier) {
+        return joinPath(this.backupWorkspaceHome, identifier.resource.scheme, hashIdentifier(identifier));
+    }
+    joinBackups() {
+        return this.ioOperationQueues.whenDrained();
+    }
+};
+WorkingCopyBackupServiceImpl.PREAMBLE_END_MARKER = '\n';
+WorkingCopyBackupServiceImpl.PREAMBLE_END_MARKER_CHARCODE = '\n'.charCodeAt(0);
+WorkingCopyBackupServiceImpl.PREAMBLE_META_SEPARATOR = ' ';
+WorkingCopyBackupServiceImpl.PREAMBLE_MAX_LENGTH = 10000;
+WorkingCopyBackupServiceImpl = ( (__decorate([
+    ( (__param(1, IFileService))),
+    ( (__param(2, ILogService)))
+], WorkingCopyBackupServiceImpl)));
+class InMemoryWorkingCopyBackupService {
+    constructor() {
+        this.backups = ( (new ResourceMap()));
+    }
+    async hasBackups() {
+        return this.backups.size > 0;
+    }
+    hasBackupSync(identifier, versionId) {
+        const backupResource = this.toBackupResource(identifier);
+        return this.backups.has(backupResource);
+    }
+    async backup(identifier, content, versionId, meta, token) {
+        const backupResource = this.toBackupResource(identifier);
+        this.backups.set(backupResource, {
+            typeId: identifier.typeId,
+            content: content instanceof VSBuffer ? content : content ? isReadableStream(content) ? await streamToBuffer(content) : readableToBuffer(content) : VSBuffer.fromString(''),
+            meta
+        });
+    }
+    async resolve(identifier) {
+        const backupResource = this.toBackupResource(identifier);
+        const backup = this.backups.get(backupResource);
+        if (backup) {
+            return { value: bufferToStream(backup.content), meta: backup.meta };
+        }
+        return undefined;
+    }
+    async getBackups() {
+        return (
+             (Array.from(this.backups.entries()).map(([resource, backup]) => ({ typeId: backup.typeId, resource })))
+        );
+    }
+    async discardBackup(identifier) {
+        this.backups.delete(this.toBackupResource(identifier));
+    }
+    async discardBackups(filter) {
+        const except = filter?.except;
+        if (Array.isArray(except) && except.length > 0) {
+            const exceptMap = ( (new ResourceMap()));
+            for (const exceptWorkingCopy of except) {
+                exceptMap.set(this.toBackupResource(exceptWorkingCopy), true);
+            }
+            for (const backup of await this.getBackups()) {
+                if (!exceptMap.has(this.toBackupResource(backup))) {
+                    await this.discardBackup(backup);
+                }
+            }
+        }
+        else {
+            this.backups.clear();
+        }
+    }
+    toBackupResource(identifier) {
+        return (
+             (URI.from({ scheme: Schemas.inMemory, path: hashIdentifier(identifier) }))
+        );
+    }
+    async joinBackups() {
+        return;
+    }
+}
+function hashIdentifier(identifier) {
+    let resource;
+    if (identifier.typeId.length > 0) {
+        const typeIdHash = hashString(identifier.typeId);
+        if (identifier.resource.path) {
+            resource = joinPath(identifier.resource, typeIdHash);
+        }
+        else {
+            resource = identifier.resource.with({ path: typeIdHash });
+        }
+    }
+    else {
+        resource = identifier.resource;
+    }
+    return hashPath(resource);
+}
+function hashPath(resource) {
+    const str = resource.scheme === Schemas.file || resource.scheme === Schemas.untitled ? resource.fsPath : ( (resource.toString()));
+    return hashString(str);
+}
+function hashString(str) {
+    return (
+         (hash(str).toString(16))
+    );
+}
+export { InMemoryWorkingCopyBackupService, WorkingCopyBackupsModel, hashIdentifier };

package/dist/vscode/vs/workbench/services/workingCopy/common/workingCopyFileOperationParticipant.js

@@ -0,0 +1,39 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { LinkedList } from 'monaco-editor/esm/vs/base/common/linkedList.js';
+let WorkingCopyFileOperationParticipant = class WorkingCopyFileOperationParticipant extends Disposable {
+    constructor(logService, configurationService) {
+        super();
+        this.logService = logService;
+        this.configurationService = configurationService;
+        this.participants = ( new LinkedList());
+    }
+    addFileOperationParticipant(participant) {
+        const remove = this.participants.push(participant);
+        return toDisposable(() => remove());
+    }
+    async participate(files, operation, undoInfo, token) {
+        const timeout = this.configurationService.getValue('files.participants.timeout');
+        if (typeof timeout !== 'number' || timeout <= 0) {
+            return;
+        }
+        for (const participant of this.participants) {
+            try {
+                await participant.participate(files, operation, undoInfo, timeout, token);
+            }
+            catch (err) {
+                this.logService.warn(err);
+            }
+        }
+    }
+    dispose() {
+        this.participants.clear();
+    }
+};
+WorkingCopyFileOperationParticipant = ( __decorate([
+    ( __param(0, ILogService)),
+    ( __param(1, IConfigurationService))
+], WorkingCopyFileOperationParticipant));
+export { WorkingCopyFileOperationParticipant };

package/dist/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService.js

@@ -0,0 +1,181 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { createDecorator, IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { AsyncEmitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Promises } from 'monaco-editor/esm/vs/base/common/async.js';
+import { insert } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { IWorkingCopyService } from './workingCopyService.js';
+import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.js';
+import { WorkingCopyFileOperationParticipant } from './workingCopyFileOperationParticipant.js';
+import { StoredFileWorkingCopySaveParticipant } from './storedFileWorkingCopySaveParticipant.js';
+const IWorkingCopyFileService = ( createDecorator('workingCopyFileService'));
+let WorkingCopyFileService = class WorkingCopyFileService extends Disposable {
+    constructor(fileService, workingCopyService, instantiationService, uriIdentityService) {
+        super();
+        this.fileService = fileService;
+        this.workingCopyService = workingCopyService;
+        this.instantiationService = instantiationService;
+        this.uriIdentityService = uriIdentityService;
+        this._onWillRunWorkingCopyFileOperation = this._register(( new AsyncEmitter()));
+        this.onWillRunWorkingCopyFileOperation = this._onWillRunWorkingCopyFileOperation.event;
+        this._onDidFailWorkingCopyFileOperation = this._register(( new AsyncEmitter()));
+        this.onDidFailWorkingCopyFileOperation = this._onDidFailWorkingCopyFileOperation.event;
+        this._onDidRunWorkingCopyFileOperation = this._register(( new AsyncEmitter()));
+        this.onDidRunWorkingCopyFileOperation = this._onDidRunWorkingCopyFileOperation.event;
+        this.correlationIds = 0;
+        this.fileOperationParticipants = this._register(this.instantiationService.createInstance(WorkingCopyFileOperationParticipant));
+        this.saveParticipants = this._register(this.instantiationService.createInstance(StoredFileWorkingCopySaveParticipant));
+        this.workingCopyProviders = [];
+        this._register(this.registerWorkingCopyProvider(resource => {
+            return this.workingCopyService.workingCopies.filter(workingCopy => {
+                if (this.fileService.hasProvider(resource)) {
+                    return this.uriIdentityService.extUri.isEqualOrParent(workingCopy.resource, resource);
+                }
+                return this.uriIdentityService.extUri.isEqual(workingCopy.resource, resource);
+            });
+        }));
+    }
+    create(operations, token, undoInfo) {
+        return this.doCreateFileOrFolder(operations, true, token, undoInfo);
+    }
+    createFolder(operations, token, undoInfo) {
+        return this.doCreateFileOrFolder(operations, false, token, undoInfo);
+    }
+    async doCreateFileOrFolder(operations, isFile, token, undoInfo) {
+        if (operations.length === 0) {
+            return [];
+        }
+        if (isFile) {
+            const validateCreates = await Promises.settled(( operations.map(
+                operation => this.fileService.canCreateFile(operation.resource, { overwrite: operation.overwrite })
+            )));
+            const error = validateCreates.find(validateCreate => validateCreate instanceof Error);
+            if (error instanceof Error) {
+                throw error;
+            }
+        }
+        const files = ( operations.map(operation => ({ target: operation.resource })));
+        await this.runFileOperationParticipants(files, 0 , undoInfo, token);
+        const event = { correlationId: this.correlationIds++, operation: 0 , files };
+        await this._onWillRunWorkingCopyFileOperation.fireAsync(event, CancellationToken.None );
+        let stats;
+        try {
+            if (isFile) {
+                stats = await Promises.settled(( operations.map(
+                    operation => this.fileService.createFile(operation.resource, operation.contents, { overwrite: operation.overwrite })
+                )));
+            }
+            else {
+                stats = await Promises.settled(( operations.map(operation => this.fileService.createFolder(operation.resource))));
+            }
+        }
+        catch (error) {
+            await this._onDidFailWorkingCopyFileOperation.fireAsync(event, CancellationToken.None );
+            throw error;
+        }
+        await this._onDidRunWorkingCopyFileOperation.fireAsync(event, CancellationToken.None );
+        return stats;
+    }
+    async move(operations, token, undoInfo) {
+        return this.doMoveOrCopy(operations, true, token, undoInfo);
+    }
+    async copy(operations, token, undoInfo) {
+        return this.doMoveOrCopy(operations, false, token, undoInfo);
+    }
+    async doMoveOrCopy(operations, move, token, undoInfo) {
+        const stats = [];
+        for (const { file: { source, target }, overwrite } of operations) {
+            const validateMoveOrCopy = await (move ? this.fileService.canMove(source, target, overwrite) : this.fileService.canCopy(source, target, overwrite));
+            if (validateMoveOrCopy instanceof Error) {
+                throw validateMoveOrCopy;
+            }
+        }
+        const files = ( operations.map(o => o.file));
+        await this.runFileOperationParticipants(files, move ? 2  : 3 , undoInfo, token);
+        const event = { correlationId: this.correlationIds++, operation: move ? 2  : 3 , files };
+        await this._onWillRunWorkingCopyFileOperation.fireAsync(event, CancellationToken.None );
+        try {
+            for (const { file: { source, target }, overwrite } of operations) {
+                if (!this.uriIdentityService.extUri.isEqual(source, target)) {
+                    const dirtyWorkingCopies = (move ? [...this.getDirty(source), ...this.getDirty(target)] : this.getDirty(target));
+                    await Promises.settled(( dirtyWorkingCopies.map(dirtyWorkingCopy => dirtyWorkingCopy.revert({ soft: true }))));
+                }
+                if (move) {
+                    stats.push(await this.fileService.move(source, target, overwrite));
+                }
+                else {
+                    stats.push(await this.fileService.copy(source, target, overwrite));
+                }
+            }
+        }
+        catch (error) {
+            await this._onDidFailWorkingCopyFileOperation.fireAsync(event, CancellationToken.None );
+            throw error;
+        }
+        await this._onDidRunWorkingCopyFileOperation.fireAsync(event, CancellationToken.None );
+        return stats;
+    }
+    async delete(operations, token, undoInfo) {
+        for (const operation of operations) {
+            const validateDelete = await this.fileService.canDelete(operation.resource, { recursive: operation.recursive, useTrash: operation.useTrash });
+            if (validateDelete instanceof Error) {
+                throw validateDelete;
+            }
+        }
+        const files = ( operations.map(operation => ({ target: operation.resource })));
+        await this.runFileOperationParticipants(files, 1 , undoInfo, token);
+        const event = { correlationId: this.correlationIds++, operation: 1 , files };
+        await this._onWillRunWorkingCopyFileOperation.fireAsync(event, CancellationToken.None );
+        for (const operation of operations) {
+            const dirtyWorkingCopies = this.getDirty(operation.resource);
+            await Promises.settled(( dirtyWorkingCopies.map(dirtyWorkingCopy => dirtyWorkingCopy.revert({ soft: true }))));
+        }
+        try {
+            for (const operation of operations) {
+                await this.fileService.del(operation.resource, { recursive: operation.recursive, useTrash: operation.useTrash });
+            }
+        }
+        catch (error) {
+            await this._onDidFailWorkingCopyFileOperation.fireAsync(event, CancellationToken.None );
+            throw error;
+        }
+        await this._onDidRunWorkingCopyFileOperation.fireAsync(event, CancellationToken.None );
+    }
+    addFileOperationParticipant(participant) {
+        return this.fileOperationParticipants.addFileOperationParticipant(participant);
+    }
+    runFileOperationParticipants(files, operation, undoInfo, token) {
+        return this.fileOperationParticipants.participate(files, operation, undoInfo, token);
+    }
+    get hasSaveParticipants() { return this.saveParticipants.length > 0; }
+    addSaveParticipant(participant) {
+        return this.saveParticipants.addSaveParticipant(participant);
+    }
+    runSaveParticipants(workingCopy, context, token) {
+        return this.saveParticipants.participate(workingCopy, context, token);
+    }
+    registerWorkingCopyProvider(provider) {
+        const remove = insert(this.workingCopyProviders, provider);
+        return toDisposable(remove);
+    }
+    getDirty(resource) {
+        const dirtyWorkingCopies = ( new Set());
+        for (const provider of this.workingCopyProviders) {
+            for (const workingCopy of provider(resource)) {
+                if (workingCopy.isDirty()) {
+                    dirtyWorkingCopies.add(workingCopy);
+                }
+            }
+        }
+        return Array.from(dirtyWorkingCopies);
+    }
+};
+WorkingCopyFileService = ( __decorate([
+    ( __param(0, IFileService)),
+    ( __param(1, IWorkingCopyService)),
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IUriIdentityService))
+], WorkingCopyFileService));
+export { IWorkingCopyFileService, WorkingCopyFileService };