@codingame/monaco-vscode-api 1.78.8 → 1.79.0

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

@@ -0,0 +1,373 @@
+import { __decorate, __param } from '../../../../../../node_modules/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 '../../../services/workingCopy/common/workingCopyFileService.js';
+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 '../../../services/textfile/common/textfiles.js';
+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 = 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(
+                undoes,
+                { isUndoing: true },
+                this._workingCopyFileService,
+                this._fileService
+            ))
+        );
+    }
+    toString() {
+        return `(rename ${( ( this._edits.map(edit => `${edit.oldUri} to ${edit.newUri}`))).join(', ')})`;
+    }
+};
+RenameOperation = ( (__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.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/dist/vscode/vs/workbench/contrib/bulkEdit/browser/bulkTextEdits.js

@@ -0,0 +1,257 @@
+import { __decorate, __param } from '../../../../../../node_modules/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);
+            }
+            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, value] 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));
+                }
+                for (const edit of value) {
+                    if (makeMinimal && !edit.textEdit.insertAsSnippet) {
+                        const newEdits = await this._editorWorker.computeMoreMinimalEdits(edit.resource, [edit.textEdit]);
+                        if (!newEdits) {
+                            task.addEdit(edit);
+                        }
+                        else {
+                            for (const moreMinialEdit of newEdits) {
+                                task.addEdit(( new ResourceTextEdit(edit.resource, moreMinialEdit, edit.versionId, edit.metadata)));
+                            }
+                        }
+                    }
+                    else {
+                        task.addEdit(edit);
+                    }
+                }
+                tasks.push(task);
+            });
+            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 };