@codingame/monaco-vscode-bulk-edit-service-override 1.83.8 → 1.83.10-next.0

package/bulkEdit.js

@@ -0,0 +1,11 @@
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { IBulkEditService } from 'monaco-editor/esm/vs/editor/browser/services/bulkEditService.js';
+import { BulkEditService } from './vscode/src/vs/workbench/contrib/bulkEdit/browser/bulkEditService.js';
+
+function getServiceOverride() {
+    return {
+        [( IBulkEditService.toString())]: new SyncDescriptor(BulkEditService, [], true)
+    };
+}
+
+export { getServiceOverride as default };

package/external/tslib/tslib.es6.js

@@ -0,0 +1,11 @@
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+export { __decorate, __param };

package/index.js

@@ -1 +1 @@
-export { default } from 'vscode/service-override/bulkEdit';
+export { default } from './bulkEdit.js';

package/override/vs/platform/dialogs/common/dialogs.js

@@ -0,0 +1,8 @@
+var ConfirmResult;
+( (function(ConfirmResult) {
+    ConfirmResult[ConfirmResult["SAVE"] = 0] = "SAVE";
+    ConfirmResult[ConfirmResult["DONT_SAVE"] = 1] = "DONT_SAVE";
+    ConfirmResult[ConfirmResult["CANCEL"] = 2] = "CANCEL";
+})(ConfirmResult || (ConfirmResult = {})));
+
+export { ConfirmResult };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-bulk-edit-service-override",
-  "version": "1.83.8",
+  "version": "1.83.10-next.0",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,7 +18,7 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@1.83.8",
+    "vscode": "npm:@codingame/monaco-vscode-api@1.83.10-next.0",
     "monaco-editor": "0.44.0"
   }
 }

package/vscode/src/vs/workbench/contrib/bulkEdit/browser/bulkEditService.js

@@ -0,0 +1,360 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { LinkedList } from 'monaco-editor/esm/vs/base/common/linkedList.js';
+import { ResourceMap, ResourceSet } from 'monaco-editor/esm/vs/base/common/map.js';
+import { isCodeEditor, isDiffEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
+import { ResourceTextEdit, ResourceFileEdit } from 'monaco-editor/esm/vs/editor/browser/services/bulkEditService.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { Progress } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { UndoRedoGroup } from 'monaco-editor/esm/vs/platform/undoRedo/common/undoRedo.js';
+import { ResourceNotebookCellEdit, BulkCellEdits } from 'vscode/vscode/vs/workbench/contrib/bulkEdit/browser/bulkCellEdits';
+import { BulkFileEdits } from './bulkFileEdits.js';
+import { BulkTextEdits } from './bulkTextEdits.js';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
+import { IWorkingCopyService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyService';
+import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
+function liftEdits(edits) {
+    return ( edits.map(edit => {
+        if (ResourceTextEdit.is(edit)) {
+            return ResourceTextEdit.lift(edit);
+        }
+        if (ResourceFileEdit.is(edit)) {
+            return ResourceFileEdit.lift(edit);
+        }
+        if (ResourceNotebookCellEdit.is(edit)) {
+            return ResourceNotebookCellEdit.lift(edit);
+        }
+        throw new Error('Unsupported edit');
+    }));
+}
+let BulkEdit = class BulkEdit {
+    constructor(_label, _code, _editor, _progress, _token, _edits, _undoRedoGroup, _undoRedoSource, _confirmBeforeUndo, _instaService, _logService) {
+        this._label = _label;
+        this._code = _code;
+        this._editor = _editor;
+        this._progress = _progress;
+        this._token = _token;
+        this._edits = _edits;
+        this._undoRedoGroup = _undoRedoGroup;
+        this._undoRedoSource = _undoRedoSource;
+        this._confirmBeforeUndo = _confirmBeforeUndo;
+        this._instaService = _instaService;
+        this._logService = _logService;
+    }
+    ariaMessage() {
+        const otherResources = ( new ResourceMap());
+        const textEditResources = ( new ResourceMap());
+        let textEditCount = 0;
+        for (const edit of this._edits) {
+            if (edit instanceof ResourceTextEdit) {
+                textEditCount += 1;
+                textEditResources.set(edit.resource, true);
+            }
+            else if (edit instanceof ResourceFileEdit) {
+                otherResources.set(edit.oldResource ?? edit.newResource, true);
+            }
+        }
+        if (this._edits.length === 0) {
+            return ( localizeWithPath(
+                'vs/workbench/contrib/bulkEdit/browser/bulkEditService',
+                'summary.0',
+                "Made no edits"
+            ));
+        }
+        else if (otherResources.size === 0) {
+            if (textEditCount > 1 && textEditResources.size > 1) {
+                return ( localizeWithPath(
+                    'vs/workbench/contrib/bulkEdit/browser/bulkEditService',
+                    'summary.nm',
+                    "Made {0} text edits in {1} files",
+                    textEditCount,
+                    textEditResources.size
+                ));
+            }
+            else {
+                return ( localizeWithPath(
+                    'vs/workbench/contrib/bulkEdit/browser/bulkEditService',
+                    'summary.n0',
+                    "Made {0} text edits in one file",
+                    textEditCount
+                ));
+            }
+        }
+        else {
+            return ( localizeWithPath(
+                'vs/workbench/contrib/bulkEdit/browser/bulkEditService',
+                'summary.textFiles',
+                "Made {0} text edits in {1} files, also created or deleted {2} files",
+                textEditCount,
+                textEditResources.size,
+                otherResources.size
+            ));
+        }
+    }
+    async perform() {
+        if (this._edits.length === 0) {
+            return [];
+        }
+        const ranges = [1];
+        for (let i = 1; i < this._edits.length; i++) {
+            if (Object.getPrototypeOf(this._edits[i - 1]) === Object.getPrototypeOf(this._edits[i])) {
+                ranges[ranges.length - 1]++;
+            }
+            else {
+                ranges.push(1);
+            }
+        }
+        const increment = this._edits.length > 1 ? 0 : undefined;
+        this._progress.report({ increment, total: 100 });
+        const progress = { report: _ => this._progress.report({ increment: 100 / this._edits.length }) };
+        const resources = [];
+        let index = 0;
+        for (const range of ranges) {
+            if (this._token.isCancellationRequested) {
+                break;
+            }
+            const group = this._edits.slice(index, index + range);
+            if (group[0] instanceof ResourceFileEdit) {
+                resources.push(await this._performFileEdits(group, this._undoRedoGroup, this._undoRedoSource, this._confirmBeforeUndo, progress));
+            }
+            else if (group[0] instanceof ResourceTextEdit) {
+                resources.push(await this._performTextEdits(group, this._undoRedoGroup, this._undoRedoSource, progress));
+            }
+            else if (group[0] instanceof ResourceNotebookCellEdit) {
+                resources.push(await this._performCellEdits(group, this._undoRedoGroup, this._undoRedoSource, progress));
+            }
+            else {
+                console.log('UNKNOWN EDIT');
+            }
+            index = index + range;
+        }
+        return resources.flat();
+    }
+    async _performFileEdits(edits, undoRedoGroup, undoRedoSource, confirmBeforeUndo, progress) {
+        this._logService.debug('_performFileEdits', JSON.stringify(edits));
+        const model = this._instaService.createInstance(BulkFileEdits, this._label || ( localizeWithPath(
+            'vs/workbench/contrib/bulkEdit/browser/bulkEditService',
+            'workspaceEdit',
+            "Workspace Edit"
+        )), this._code || 'undoredo.workspaceEdit', undoRedoGroup, undoRedoSource, confirmBeforeUndo, progress, this._token, edits);
+        return await model.apply();
+    }
+    async _performTextEdits(edits, undoRedoGroup, undoRedoSource, progress) {
+        this._logService.debug('_performTextEdits', JSON.stringify(edits));
+        const model = this._instaService.createInstance(BulkTextEdits, this._label || ( localizeWithPath(
+            'vs/workbench/contrib/bulkEdit/browser/bulkEditService',
+            'workspaceEdit',
+            "Workspace Edit"
+        )), this._code || 'undoredo.workspaceEdit', this._editor, undoRedoGroup, undoRedoSource, progress, this._token, edits);
+        return await model.apply();
+    }
+    async _performCellEdits(edits, undoRedoGroup, undoRedoSource, progress) {
+        this._logService.debug('_performCellEdits', JSON.stringify(edits));
+        const model = this._instaService.createInstance(BulkCellEdits, undoRedoGroup, undoRedoSource, progress, this._token, edits);
+        return await model.apply();
+    }
+};
+BulkEdit = ( __decorate([
+    ( __param(9, IInstantiationService)),
+    ( __param(10, ILogService))
+], BulkEdit));
+let BulkEditService = class BulkEditService {
+    constructor(_instaService, _logService, _editorService, _lifecycleService, _dialogService, _workingCopyService, _configService) {
+        this._instaService = _instaService;
+        this._logService = _logService;
+        this._editorService = _editorService;
+        this._lifecycleService = _lifecycleService;
+        this._dialogService = _dialogService;
+        this._workingCopyService = _workingCopyService;
+        this._configService = _configService;
+        this._activeUndoRedoGroups = ( new LinkedList());
+    }
+    setPreviewHandler(handler) {
+        this._previewHandler = handler;
+        return toDisposable(() => {
+            if (this._previewHandler === handler) {
+                this._previewHandler = undefined;
+            }
+        });
+    }
+    hasPreviewHandler() {
+        return Boolean(this._previewHandler);
+    }
+    async apply(editsIn, options) {
+        let edits = liftEdits(Array.isArray(editsIn) ? editsIn : editsIn.edits);
+        if (edits.length === 0) {
+            return { ariaSummary: ( localizeWithPath(
+                'vs/workbench/contrib/bulkEdit/browser/bulkEditService',
+                'nothing',
+                "Made no edits"
+            )), isApplied: false };
+        }
+        if (this._previewHandler && (options?.showPreview || ( edits.some(value => value.metadata?.needsConfirmation)))) {
+            edits = await this._previewHandler(edits, options);
+        }
+        let codeEditor = options?.editor;
+        if (!codeEditor) {
+            const candidate = this._editorService.activeTextEditorControl;
+            if (isCodeEditor(candidate)) {
+                codeEditor = candidate;
+            }
+            else if (isDiffEditor(candidate)) {
+                codeEditor = candidate.getModifiedEditor();
+            }
+        }
+        if (codeEditor && codeEditor.getOption(90 )) {
+            codeEditor = undefined;
+        }
+        let undoRedoGroup;
+        let undoRedoGroupRemove = () => { };
+        if (typeof options?.undoRedoGroupId === 'number') {
+            for (const candidate of this._activeUndoRedoGroups) {
+                if (candidate.id === options.undoRedoGroupId) {
+                    undoRedoGroup = candidate;
+                    break;
+                }
+            }
+        }
+        if (!undoRedoGroup) {
+            undoRedoGroup = ( new UndoRedoGroup());
+            undoRedoGroupRemove = this._activeUndoRedoGroups.push(undoRedoGroup);
+        }
+        const label = options?.quotableLabel || options?.label;
+        const bulkEdit = this._instaService.createInstance(BulkEdit, label, options?.code, codeEditor, options?.progress ?? Progress.None, options?.token ?? CancellationToken.None, edits, undoRedoGroup, options?.undoRedoSource, !!options?.confirmBeforeUndo);
+        let listener;
+        try {
+            listener = this._lifecycleService.onBeforeShutdown(e => e.veto(this._shouldVeto(label, e.reason), 'veto.blukEditService'));
+            const resources = await bulkEdit.perform();
+            if (options?.respectAutoSaveConfig && this._configService.getValue(autoSaveSetting) === true && resources.length > 1) {
+                await this._saveAll(resources);
+            }
+            return { ariaSummary: bulkEdit.ariaMessage(), isApplied: edits.length > 0 };
+        }
+        catch (err) {
+            this._logService.error(err);
+            throw err;
+        }
+        finally {
+            listener?.dispose();
+            undoRedoGroupRemove();
+        }
+    }
+    async _saveAll(resources) {
+        const set = ( new ResourceSet(resources));
+        const saves = ( this._workingCopyService.dirtyWorkingCopies.map(async (copy) => {
+            if (( set.has(copy.resource))) {
+                await copy.save();
+            }
+        }));
+        const result = await Promise.allSettled(saves);
+        for (const item of result) {
+            if (item.status === 'rejected') {
+                this._logService.warn(item.reason);
+            }
+        }
+    }
+    async _shouldVeto(label, reason) {
+        let message;
+        let primaryButton;
+        switch (reason) {
+            case 1 :
+                message = ( localizeWithPath(
+                    'vs/workbench/contrib/bulkEdit/browser/bulkEditService',
+                    'closeTheWindow.message',
+                    "Are you sure you want to close the window?"
+                ));
+                primaryButton = ( localizeWithPath(
+                    'vs/workbench/contrib/bulkEdit/browser/bulkEditService',
+                    { key: 'closeTheWindow', comment: ['&& denotes a mnemonic'] },
+                    "&&Close Window"
+                ));
+                break;
+            case 4 :
+                message = ( localizeWithPath(
+                    'vs/workbench/contrib/bulkEdit/browser/bulkEditService',
+                    'changeWorkspace.message',
+                    "Are you sure you want to change the workspace?"
+                ));
+                primaryButton = ( localizeWithPath(
+                    'vs/workbench/contrib/bulkEdit/browser/bulkEditService',
+                    { key: 'changeWorkspace', comment: ['&& denotes a mnemonic'] },
+                    "Change &&Workspace"
+                ));
+                break;
+            case 3 :
+                message = ( localizeWithPath(
+                    'vs/workbench/contrib/bulkEdit/browser/bulkEditService',
+                    'reloadTheWindow.message',
+                    "Are you sure you want to reload the window?"
+                ));
+                primaryButton = ( localizeWithPath(
+                    'vs/workbench/contrib/bulkEdit/browser/bulkEditService',
+                    { key: 'reloadTheWindow', comment: ['&& denotes a mnemonic'] },
+                    "&&Reload Window"
+                ));
+                break;
+            default:
+                message = ( localizeWithPath(
+                    'vs/workbench/contrib/bulkEdit/browser/bulkEditService',
+                    'quit.message',
+                    "Are you sure you want to quit?"
+                ));
+                primaryButton = ( localizeWithPath(
+                    'vs/workbench/contrib/bulkEdit/browser/bulkEditService',
+                    { key: 'quit', comment: ['&& denotes a mnemonic'] },
+                    "&&Quit"
+                ));
+                break;
+        }
+        const result = await this._dialogService.confirm({
+            message,
+            detail: ( localizeWithPath(
+                'vs/workbench/contrib/bulkEdit/browser/bulkEditService',
+                'areYouSureQuiteBulkEdit.detail',
+                "'{0}' is in progress.",
+                label || ( localizeWithPath(
+                    'vs/workbench/contrib/bulkEdit/browser/bulkEditService',
+                    'fileOperation',
+                    "File operation"
+                ))
+            )),
+            primaryButton
+        });
+        return !result.confirmed;
+    }
+};
+BulkEditService = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, ILogService)),
+    ( __param(2, IEditorService)),
+    ( __param(3, ILifecycleService)),
+    ( __param(4, IDialogService)),
+    ( __param(5, IWorkingCopyService)),
+    ( __param(6, IConfigurationService))
+], BulkEditService));
+const autoSaveSetting = 'files.refactoring.autoSave';
+( Registry.as(Extensions.Configuration)).registerConfiguration({
+    id: 'files',
+    properties: {
+        [autoSaveSetting]: {
+            description: ( localizeWithPath(
+                'vs/workbench/contrib/bulkEdit/browser/bulkEditService',
+                'refactoring.autoSave',
+                "Controls if files that were part of a refactoring are saved automatically"
+            )),
+            default: true,
+            type: 'boolean'
+        }
+    }
+});
+
+export { BulkEditService };

package/vscode/src/vs/workbench/contrib/bulkEdit/browser/bulkFileEdits.js

@@ -0,0 +1,364 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IWorkingCopyFileService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService';
+import { IUndoRedoService } from 'monaco-editor/esm/vs/platform/undoRedo/common/undoRedo.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { tail } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { ITextFileService } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+
+var RenameOperation_1;
+class Noop {
+    constructor() {
+        this.uris = [];
+    }
+    async perform() { return this; }
+    toString() {
+        return '(noop)';
+    }
+}
+class RenameEdit {
+    constructor(newUri, oldUri, options) {
+        this.newUri = newUri;
+        this.oldUri = oldUri;
+        this.options = options;
+        this.type = 'rename';
+    }
+}
+let RenameOperation = RenameOperation_1 = class RenameOperation {
+    constructor(_edits, _undoRedoInfo, _workingCopyFileService, _fileService) {
+        this._edits = _edits;
+        this._undoRedoInfo = _undoRedoInfo;
+        this._workingCopyFileService = _workingCopyFileService;
+        this._fileService = _fileService;
+    }
+    get uris() {
+        return ( this._edits.map(edit => [edit.newUri, edit.oldUri])).flat();
+    }
+    async perform(token) {
+        const moves = [];
+        const undoes = [];
+        for (const edit of this._edits) {
+            const skip = edit.options.overwrite === undefined && edit.options.ignoreIfExists && (await this._fileService.exists(edit.newUri));
+            if (!skip) {
+                moves.push({
+                    file: { source: edit.oldUri, target: edit.newUri },
+                    overwrite: edit.options.overwrite
+                });
+                undoes.push(( new RenameEdit(edit.oldUri, edit.newUri, edit.options)));
+            }
+        }
+        if (moves.length === 0) {
+            return ( new Noop());
+        }
+        await this._workingCopyFileService.move(moves, token, this._undoRedoInfo);
+        return ( new RenameOperation_1(
+            undoes,
+            { isUndoing: true },
+            this._workingCopyFileService,
+            this._fileService
+        ));
+    }
+    toString() {
+        return `(rename ${( this._edits.map(edit => `${edit.oldUri} to ${edit.newUri}`)).join(', ')})`;
+    }
+};
+RenameOperation = RenameOperation_1 = ( __decorate([
+    ( __param(2, IWorkingCopyFileService)),
+    ( __param(3, IFileService))
+], RenameOperation));
+class CopyEdit {
+    constructor(newUri, oldUri, options) {
+        this.newUri = newUri;
+        this.oldUri = oldUri;
+        this.options = options;
+        this.type = 'copy';
+    }
+}
+let CopyOperation = class CopyOperation {
+    constructor(_edits, _undoRedoInfo, _workingCopyFileService, _fileService, _instaService) {
+        this._edits = _edits;
+        this._undoRedoInfo = _undoRedoInfo;
+        this._workingCopyFileService = _workingCopyFileService;
+        this._fileService = _fileService;
+        this._instaService = _instaService;
+    }
+    get uris() {
+        return ( this._edits.map(edit => [edit.newUri, edit.oldUri])).flat();
+    }
+    async perform(token) {
+        const copies = [];
+        for (const edit of this._edits) {
+            const skip = edit.options.overwrite === undefined && edit.options.ignoreIfExists && (await this._fileService.exists(edit.newUri));
+            if (!skip) {
+                copies.push({ file: { source: edit.oldUri, target: edit.newUri }, overwrite: edit.options.overwrite });
+            }
+        }
+        if (copies.length === 0) {
+            return ( new Noop());
+        }
+        const stats = await this._workingCopyFileService.copy(copies, token, this._undoRedoInfo);
+        const undoes = [];
+        for (let i = 0; i < stats.length; i++) {
+            const stat = stats[i];
+            const edit = this._edits[i];
+            undoes.push(( new DeleteEdit(
+                stat.resource,
+                { recursive: true, folder: this._edits[i].options.folder || stat.isDirectory, ...edit.options },
+                false
+            )));
+        }
+        return this._instaService.createInstance(DeleteOperation, undoes, { isUndoing: true });
+    }
+    toString() {
+        return `(copy ${( this._edits.map(edit => `${edit.oldUri} to ${edit.newUri}`)).join(', ')})`;
+    }
+};
+CopyOperation = ( __decorate([
+    ( __param(2, IWorkingCopyFileService)),
+    ( __param(3, IFileService)),
+    ( __param(4, IInstantiationService))
+], CopyOperation));
+class CreateEdit {
+    constructor(newUri, options, contents) {
+        this.newUri = newUri;
+        this.options = options;
+        this.contents = contents;
+        this.type = 'create';
+    }
+}
+let CreateOperation = class CreateOperation {
+    constructor(_edits, _undoRedoInfo, _fileService, _workingCopyFileService, _instaService, _textFileService) {
+        this._edits = _edits;
+        this._undoRedoInfo = _undoRedoInfo;
+        this._fileService = _fileService;
+        this._workingCopyFileService = _workingCopyFileService;
+        this._instaService = _instaService;
+        this._textFileService = _textFileService;
+    }
+    get uris() {
+        return ( this._edits.map(edit => edit.newUri));
+    }
+    async perform(token) {
+        const folderCreates = [];
+        const fileCreates = [];
+        const undoes = [];
+        for (const edit of this._edits) {
+            if (edit.newUri.scheme === Schemas.untitled) {
+                continue;
+            }
+            if (edit.options.overwrite === undefined && edit.options.ignoreIfExists && (await this._fileService.exists(edit.newUri))) {
+                continue;
+            }
+            if (edit.options.folder) {
+                folderCreates.push({ resource: edit.newUri });
+            }
+            else {
+                const encodedReadable = typeof edit.contents !== 'undefined' ? edit.contents : await this._textFileService.getEncodedReadable(edit.newUri);
+                fileCreates.push({ resource: edit.newUri, contents: encodedReadable, overwrite: edit.options.overwrite });
+            }
+            undoes.push(( new DeleteEdit(edit.newUri, edit.options, !edit.options.folder && !edit.contents)));
+        }
+        if (folderCreates.length === 0 && fileCreates.length === 0) {
+            return ( new Noop());
+        }
+        await this._workingCopyFileService.createFolder(folderCreates, token, this._undoRedoInfo);
+        await this._workingCopyFileService.create(fileCreates, token, this._undoRedoInfo);
+        return this._instaService.createInstance(DeleteOperation, undoes, { isUndoing: true });
+    }
+    toString() {
+        return `(create ${( this._edits.map(
+            edit => edit.options.folder ? `folder ${edit.newUri}` : `file ${edit.newUri} with ${edit.contents?.byteLength || 0} bytes`
+        )).join(', ')})`;
+    }
+};
+CreateOperation = ( __decorate([
+    ( __param(2, IFileService)),
+    ( __param(3, IWorkingCopyFileService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, ITextFileService))
+], CreateOperation));
+class DeleteEdit {
+    constructor(oldUri, options, undoesCreate) {
+        this.oldUri = oldUri;
+        this.options = options;
+        this.undoesCreate = undoesCreate;
+        this.type = 'delete';
+    }
+}
+let DeleteOperation = class DeleteOperation {
+    constructor(_edits, _undoRedoInfo, _workingCopyFileService, _fileService, _configurationService, _instaService, _logService) {
+        this._edits = _edits;
+        this._undoRedoInfo = _undoRedoInfo;
+        this._workingCopyFileService = _workingCopyFileService;
+        this._fileService = _fileService;
+        this._configurationService = _configurationService;
+        this._instaService = _instaService;
+        this._logService = _logService;
+    }
+    get uris() {
+        return ( this._edits.map(edit => edit.oldUri));
+    }
+    async perform(token) {
+        const deletes = [];
+        const undoes = [];
+        for (const edit of this._edits) {
+            let fileStat;
+            try {
+                fileStat = await this._fileService.resolve(edit.oldUri, { resolveMetadata: true });
+            }
+            catch (err) {
+                if (!edit.options.ignoreIfNotExists) {
+                    throw new Error(`${edit.oldUri} does not exist and can not be deleted`);
+                }
+                continue;
+            }
+            deletes.push({
+                resource: edit.oldUri,
+                recursive: edit.options.recursive,
+                useTrash: !edit.options.skipTrashBin && this._fileService.hasCapability(edit.oldUri, 4096 ) && this._configurationService.getValue('files.enableTrash')
+            });
+            let fileContent;
+            if (!edit.undoesCreate && !edit.options.folder && !(typeof edit.options.maxSize === 'number' && fileStat.size > edit.options.maxSize)) {
+                try {
+                    fileContent = await this._fileService.readFile(edit.oldUri);
+                }
+                catch (err) {
+                    this._logService.error(err);
+                }
+            }
+            if (fileContent !== undefined) {
+                undoes.push(( new CreateEdit(edit.oldUri, edit.options, fileContent.value)));
+            }
+        }
+        if (deletes.length === 0) {
+            return ( new Noop());
+        }
+        await this._workingCopyFileService.delete(deletes, token, this._undoRedoInfo);
+        if (undoes.length === 0) {
+            return ( new Noop());
+        }
+        return this._instaService.createInstance(CreateOperation, undoes, { isUndoing: true });
+    }
+    toString() {
+        return `(delete ${( this._edits.map(edit => edit.oldUri)).join(', ')})`;
+    }
+};
+DeleteOperation = ( __decorate([
+    ( __param(2, IWorkingCopyFileService)),
+    ( __param(3, IFileService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IInstantiationService)),
+    ( __param(6, ILogService))
+], DeleteOperation));
+class FileUndoRedoElement {
+    constructor(label, code, operations, confirmBeforeUndo) {
+        this.label = label;
+        this.code = code;
+        this.operations = operations;
+        this.confirmBeforeUndo = confirmBeforeUndo;
+        this.type = 1 ;
+        this.resources = ( operations.map(op => op.uris)).flat();
+    }
+    async undo() {
+        await this._reverse();
+    }
+    async redo() {
+        await this._reverse();
+    }
+    async _reverse() {
+        for (let i = 0; i < this.operations.length; i++) {
+            const op = this.operations[i];
+            const undo = await op.perform(CancellationToken.None);
+            this.operations[i] = undo;
+        }
+    }
+    toString() {
+        return ( this.operations.map(op => String(op))).join(', ');
+    }
+}
+let BulkFileEdits = class BulkFileEdits {
+    constructor(_label, _code, _undoRedoGroup, _undoRedoSource, _confirmBeforeUndo, _progress, _token, _edits, _instaService, _undoRedoService) {
+        this._label = _label;
+        this._code = _code;
+        this._undoRedoGroup = _undoRedoGroup;
+        this._undoRedoSource = _undoRedoSource;
+        this._confirmBeforeUndo = _confirmBeforeUndo;
+        this._progress = _progress;
+        this._token = _token;
+        this._edits = _edits;
+        this._instaService = _instaService;
+        this._undoRedoService = _undoRedoService;
+    }
+    async apply() {
+        const undoOperations = [];
+        const undoRedoInfo = { undoRedoGroupId: this._undoRedoGroup.id };
+        const edits = [];
+        for (const edit of this._edits) {
+            if (edit.newResource && edit.oldResource && !edit.options?.copy) {
+                edits.push(( new RenameEdit(edit.newResource, edit.oldResource, edit.options ?? {})));
+            }
+            else if (edit.newResource && edit.oldResource && edit.options?.copy) {
+                edits.push(( new CopyEdit(edit.newResource, edit.oldResource, edit.options ?? {})));
+            }
+            else if (!edit.newResource && edit.oldResource) {
+                edits.push(( new DeleteEdit(edit.oldResource, edit.options ?? {}, false)));
+            }
+            else if (edit.newResource && !edit.oldResource) {
+                edits.push(( new CreateEdit(edit.newResource, edit.options ?? {}, await edit.options.contents)));
+            }
+        }
+        if (edits.length === 0) {
+            return [];
+        }
+        const groups = [];
+        groups[0] = [edits[0]];
+        for (let i = 1; i < edits.length; i++) {
+            const edit = edits[i];
+            const lastGroup = tail(groups);
+            if (lastGroup[0].type === edit.type) {
+                lastGroup.push(edit);
+            }
+            else {
+                groups.push([edit]);
+            }
+        }
+        for (const group of groups) {
+            if (this._token.isCancellationRequested) {
+                break;
+            }
+            let op;
+            switch (group[0].type) {
+                case 'rename':
+                    op = this._instaService.createInstance(RenameOperation, group, undoRedoInfo);
+                    break;
+                case 'copy':
+                    op = this._instaService.createInstance(CopyOperation, group, undoRedoInfo);
+                    break;
+                case 'delete':
+                    op = this._instaService.createInstance(DeleteOperation, group, undoRedoInfo);
+                    break;
+                case 'create':
+                    op = this._instaService.createInstance(CreateOperation, group, undoRedoInfo);
+                    break;
+            }
+            if (op) {
+                const undoOp = await op.perform(this._token);
+                undoOperations.push(undoOp);
+            }
+            this._progress.report(undefined);
+        }
+        const undoRedoElement = ( new FileUndoRedoElement(this._label, this._code, undoOperations, this._confirmBeforeUndo));
+        this._undoRedoService.pushElement(undoRedoElement, this._undoRedoGroup, this._undoRedoSource);
+        return undoRedoElement.resources;
+    }
+};
+BulkFileEdits = ( __decorate([
+    ( __param(8, IInstantiationService)),
+    ( __param(9, IUndoRedoService))
+], BulkFileEdits));
+
+export { BulkFileEdits };

package/vscode/src/vs/workbench/contrib/bulkEdit/browser/bulkTextEdits.js

@@ -0,0 +1,267 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { EditOperation } from 'monaco-editor/esm/vs/editor/common/core/editOperation.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import { IEditorWorkerService } from 'monaco-editor/esm/vs/editor/common/services/editorWorker.js';
+import { IUndoRedoService } from 'monaco-editor/esm/vs/platform/undoRedo/common/undoRedo.js';
+import { SingleModelEditStackElement, MultiModelEditStackElement } from 'monaco-editor/esm/vs/editor/common/model/editStack.js';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { ResourceTextEdit } from 'monaco-editor/esm/vs/editor/browser/services/bulkEditService.js';
+import { SnippetController2 } from 'monaco-editor/esm/vs/editor/contrib/snippet/browser/snippetController2.js';
+import { SnippetParser } from 'monaco-editor/esm/vs/editor/contrib/snippet/browser/snippetParser.js';
+
+class ModelEditTask {
+    constructor(_modelReference) {
+        this._modelReference = _modelReference;
+        this.model = this._modelReference.object.textEditorModel;
+        this._edits = [];
+    }
+    dispose() {
+        this._modelReference.dispose();
+    }
+    isNoOp() {
+        if (this._edits.length > 0) {
+            return false;
+        }
+        if (this._newEol !== undefined && this._newEol !== this.model.getEndOfLineSequence()) {
+            return false;
+        }
+        return true;
+    }
+    addEdit(resourceEdit) {
+        this._expectedModelVersionId = resourceEdit.versionId;
+        const { textEdit } = resourceEdit;
+        if (typeof textEdit.eol === 'number') {
+            this._newEol = textEdit.eol;
+        }
+        if (!textEdit.range && !textEdit.text) {
+            return;
+        }
+        if (Range.isEmpty(textEdit.range) && !textEdit.text) {
+            return;
+        }
+        let range;
+        if (!textEdit.range) {
+            range = this.model.getFullModelRange();
+        }
+        else {
+            range = Range.lift(textEdit.range);
+        }
+        this._edits.push({ ...EditOperation.replaceMove(range, textEdit.text), insertAsSnippet: textEdit.insertAsSnippet });
+    }
+    validate() {
+        if (typeof this._expectedModelVersionId === 'undefined' || this.model.getVersionId() === this._expectedModelVersionId) {
+            return { canApply: true };
+        }
+        return { canApply: false, reason: this.model.uri };
+    }
+    getBeforeCursorState() {
+        return null;
+    }
+    apply() {
+        if (this._edits.length > 0) {
+            this._edits = (
+            this._edits
+                .map(this._transformSnippetStringToInsertText, this))
+                .sort((a, b) => Range.compareRangesUsingStarts(a.range, b.range));
+            this.model.pushEditOperations(null, this._edits, () => null);
+        }
+        if (this._newEol !== undefined) {
+            this.model.pushEOL(this._newEol);
+        }
+    }
+    _transformSnippetStringToInsertText(edit) {
+        if (!edit.insertAsSnippet) {
+            return edit;
+        }
+        if (!edit.text) {
+            return edit;
+        }
+        const text = SnippetParser.asInsertText(edit.text);
+        return { ...edit, insertAsSnippet: false, text };
+    }
+}
+class EditorEditTask extends ModelEditTask {
+    constructor(modelReference, editor) {
+        super(modelReference);
+        this._editor = editor;
+    }
+    getBeforeCursorState() {
+        return this._canUseEditor() ? this._editor.getSelections() : null;
+    }
+    apply() {
+        if (!this._canUseEditor()) {
+            super.apply();
+            return;
+        }
+        if (this._edits.length > 0) {
+            const snippetCtrl = SnippetController2.get(this._editor);
+            if (snippetCtrl && ( this._edits.some(edit => edit.insertAsSnippet))) {
+                const snippetEdits = [];
+                for (const edit of this._edits) {
+                    if (edit.range && edit.text !== null) {
+                        snippetEdits.push({
+                            range: Range.lift(edit.range),
+                            template: edit.insertAsSnippet ? edit.text : SnippetParser.escape(edit.text)
+                        });
+                    }
+                }
+                snippetCtrl.apply(snippetEdits, { undoStopBefore: false, undoStopAfter: false });
+            }
+            else {
+                this._edits = (
+                this._edits
+                    .map(this._transformSnippetStringToInsertText, this))
+                    .sort((a, b) => Range.compareRangesUsingStarts(a.range, b.range));
+                this._editor.executeEdits('', this._edits);
+            }
+        }
+        if (this._newEol !== undefined) {
+            if (this._editor.hasModel()) {
+                this._editor.getModel().pushEOL(this._newEol);
+            }
+        }
+    }
+    _canUseEditor() {
+        return this._editor?.getModel()?.uri.toString() === ( this.model.uri.toString());
+    }
+}
+let BulkTextEdits = class BulkTextEdits {
+    constructor(_label, _code, _editor, _undoRedoGroup, _undoRedoSource, _progress, _token, edits, _editorWorker, _modelService, _textModelResolverService, _undoRedoService) {
+        this._label = _label;
+        this._code = _code;
+        this._editor = _editor;
+        this._undoRedoGroup = _undoRedoGroup;
+        this._undoRedoSource = _undoRedoSource;
+        this._progress = _progress;
+        this._token = _token;
+        this._editorWorker = _editorWorker;
+        this._modelService = _modelService;
+        this._textModelResolverService = _textModelResolverService;
+        this._undoRedoService = _undoRedoService;
+        this._edits = ( new ResourceMap());
+        for (const edit of edits) {
+            let array = this._edits.get(edit.resource);
+            if (!array) {
+                array = [];
+                this._edits.set(edit.resource, array);
+            }
+            array.push(edit);
+        }
+    }
+    _validateBeforePrepare() {
+        for (const array of ( this._edits.values())) {
+            for (const edit of array) {
+                if (typeof edit.versionId === 'number') {
+                    const model = this._modelService.getModel(edit.resource);
+                    if (model && model.getVersionId() !== edit.versionId) {
+                        throw new Error(`${model.uri.toString()} has changed in the meantime`);
+                    }
+                }
+            }
+        }
+    }
+    async _createEditsTasks() {
+        const tasks = [];
+        const promises = [];
+        for (const [key, edits] of this._edits) {
+            const promise = this._textModelResolverService.createModelReference(key).then(async (ref) => {
+                let task;
+                let makeMinimal = false;
+                if (this._editor?.getModel()?.uri.toString() === ( ref.object.textEditorModel.uri.toString())) {
+                    task = ( new EditorEditTask(ref, this._editor));
+                    makeMinimal = true;
+                }
+                else {
+                    task = ( new ModelEditTask(ref));
+                }
+                tasks.push(task);
+                if (!makeMinimal) {
+                    edits.forEach(task.addEdit, task);
+                    return;
+                }
+                const makeGroupMoreMinimal = async (start, end) => {
+                    const oldEdits = edits.slice(start, end);
+                    const newEdits = await this._editorWorker.computeMoreMinimalEdits(ref.object.textEditorModel.uri, ( oldEdits.map(e => e.textEdit)), false);
+                    if (!newEdits) {
+                        oldEdits.forEach(task.addEdit, task);
+                    }
+                    else {
+                        newEdits.forEach(edit => task.addEdit(( new ResourceTextEdit(ref.object.textEditorModel.uri, edit, undefined, undefined))));
+                    }
+                };
+                let start = 0;
+                let i = 0;
+                for (; i < edits.length; i++) {
+                    if (edits[i].textEdit.insertAsSnippet || edits[i].metadata) {
+                        await makeGroupMoreMinimal(start, i);
+                        task.addEdit(edits[i]);
+                        start = i + 1;
+                    }
+                }
+                await makeGroupMoreMinimal(start, i);
+            });
+            promises.push(promise);
+        }
+        await Promise.all(promises);
+        return tasks;
+    }
+    _validateTasks(tasks) {
+        for (const task of tasks) {
+            const result = task.validate();
+            if (!result.canApply) {
+                return result;
+            }
+        }
+        return { canApply: true };
+    }
+    async apply() {
+        this._validateBeforePrepare();
+        const tasks = await this._createEditsTasks();
+        try {
+            if (this._token.isCancellationRequested) {
+                return [];
+            }
+            const resources = [];
+            const validation = this._validateTasks(tasks);
+            if (!validation.canApply) {
+                throw new Error(`${validation.reason.toString()} has changed in the meantime`);
+            }
+            if (tasks.length === 1) {
+                const task = tasks[0];
+                if (!task.isNoOp()) {
+                    const singleModelEditStackElement = ( new SingleModelEditStackElement(this._label, this._code, task.model, task.getBeforeCursorState()));
+                    this._undoRedoService.pushElement(singleModelEditStackElement, this._undoRedoGroup, this._undoRedoSource);
+                    task.apply();
+                    singleModelEditStackElement.close();
+                    resources.push(task.model.uri);
+                }
+                this._progress.report(undefined);
+            }
+            else {
+                const multiModelEditStackElement = ( new MultiModelEditStackElement(this._label, this._code, ( tasks.map(t => ( new SingleModelEditStackElement(this._label, this._code, t.model, t.getBeforeCursorState()))))));
+                this._undoRedoService.pushElement(multiModelEditStackElement, this._undoRedoGroup, this._undoRedoSource);
+                for (const task of tasks) {
+                    task.apply();
+                    this._progress.report(undefined);
+                    resources.push(task.model.uri);
+                }
+                multiModelEditStackElement.close();
+            }
+            return resources;
+        }
+        finally {
+            dispose(tasks);
+        }
+    }
+};
+BulkTextEdits = ( __decorate([
+    ( __param(8, IEditorWorkerService)),
+    ( __param(9, IModelService)),
+    ( __param(10, ITextModelService)),
+    ( __param(11, IUndoRedoService))
+], BulkTextEdits));
+
+export { BulkTextEdits };