@codingame/monaco-vscode-search-service-override 4.1.0 → 4.1.2

package/vscode/src/vs/workbench/contrib/search/browser/replaceService.js

@@ -0,0 +1,232 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { IReplaceService } from 'vscode/vscode/vs/workbench/contrib/search/browser/replace';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { IModelService } from 'vscode/vscode/vs/editor/common/services/model';
+import { ILanguageService } from 'vscode/vscode/vs/editor/common/languages/language';
+import { Match, MatchInNotebook, FileMatch, ISearchViewModelWorkbenchService } from 'vscode/vscode/vs/workbench/contrib/search/browser/searchModel';
+import { ITextModelService } from 'vscode/vscode/vs/editor/common/services/resolverService';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { createTextBufferFactoryFromSnapshot } from 'vscode/vscode/vs/editor/common/model/textModel';
+import { ITextFileService } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles';
+import { ResourceTextEdit, IBulkEditService } from 'vscode/vscode/vs/editor/browser/services/bulkEditService';
+import { Range } from 'vscode/vscode/vs/editor/common/core/range';
+import { EditOperation } from 'vscode/vscode/vs/editor/common/core/editOperation';
+import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label';
+import { dirname } from 'vscode/vscode/vs/base/common/resources';
+import { Promises } from 'vscode/vscode/vs/base/common/async';
+import { SaveSourceRegistry } from 'vscode/vscode/vs/workbench/common/editor';
+import { CellUri } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { INotebookEditorModelResolverService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookEditorModelResolverService';
+
+var ReplaceService_1;
+const REPLACE_PREVIEW = 'replacePreview';
+const toReplaceResource = (fileResource) => {
+    return fileResource.with({ scheme: Schemas.internal, fragment: REPLACE_PREVIEW, query: JSON.stringify({ scheme: fileResource.scheme }) });
+};
+const toFileResource = (replaceResource) => {
+    return replaceResource.with({ scheme: JSON.parse(replaceResource.query)['scheme'], fragment: '', query: '' });
+};
+let ReplacePreviewContentProvider = class ReplacePreviewContentProvider {
+    static { this.ID = 'workbench.contrib.replacePreviewContentProvider'; }
+    constructor(instantiationService, textModelResolverService) {
+        this.instantiationService = instantiationService;
+        this.textModelResolverService = textModelResolverService;
+        this.textModelResolverService.registerTextModelContentProvider(Schemas.internal, this);
+    }
+    provideTextContent(uri) {
+        if (uri.fragment === REPLACE_PREVIEW) {
+            return this.instantiationService.createInstance(ReplacePreviewModel).resolve(uri);
+        }
+        return null;
+    }
+};
+ReplacePreviewContentProvider = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, ITextModelService))
+], ReplacePreviewContentProvider));
+let ReplacePreviewModel = class ReplacePreviewModel extends Disposable {
+    constructor(modelService, languageService, textModelResolverService, replaceService, searchWorkbenchService) {
+        super();
+        this.modelService = modelService;
+        this.languageService = languageService;
+        this.textModelResolverService = textModelResolverService;
+        this.replaceService = replaceService;
+        this.searchWorkbenchService = searchWorkbenchService;
+    }
+    async resolve(replacePreviewUri) {
+        const fileResource = toFileResource(replacePreviewUri);
+        const fileMatch = this.searchWorkbenchService.searchModel.searchResult.matches().filter(match => ( match.resource.toString()) === ( fileResource.toString()))[0];
+        const ref = this._register(await this.textModelResolverService.createModelReference(fileResource));
+        const sourceModel = ref.object.textEditorModel;
+        const sourceModelLanguageId = sourceModel.getLanguageId();
+        const replacePreviewModel = this.modelService.createModel(createTextBufferFactoryFromSnapshot(sourceModel.createSnapshot()), this.languageService.createById(sourceModelLanguageId), replacePreviewUri);
+        this._register(fileMatch.onChange(({ forceUpdateModel }) => this.update(sourceModel, replacePreviewModel, fileMatch, forceUpdateModel)));
+        this._register(this.searchWorkbenchService.searchModel.onReplaceTermChanged(() => this.update(sourceModel, replacePreviewModel, fileMatch)));
+        this._register(fileMatch.onDispose(() => replacePreviewModel.dispose()));
+        this._register(replacePreviewModel.onWillDispose(() => this.dispose()));
+        this._register(sourceModel.onWillDispose(() => this.dispose()));
+        return replacePreviewModel;
+    }
+    update(sourceModel, replacePreviewModel, fileMatch, override = false) {
+        if (!sourceModel.isDisposed() && !replacePreviewModel.isDisposed()) {
+            this.replaceService.updateReplacePreview(fileMatch, override);
+        }
+    }
+};
+ReplacePreviewModel = ( __decorate([
+    ( __param(0, IModelService)),
+    ( __param(1, ILanguageService)),
+    ( __param(2, ITextModelService)),
+    ( __param(3, IReplaceService)),
+    ( __param(4, ISearchViewModelWorkbenchService))
+], ReplacePreviewModel));
+let ReplaceService = class ReplaceService {
+    static { ReplaceService_1 = this; }
+    static { this.REPLACE_SAVE_SOURCE = SaveSourceRegistry.registerSource('searchReplace.source', ( localizeWithPath(
+        'vs/workbench/contrib/search/browser/replaceService',
+        'searchReplace.source',
+        "Search and Replace"
+    ))); }
+    constructor(textFileService, editorService, textModelResolverService, bulkEditorService, labelService, notebookEditorModelResolverService) {
+        this.textFileService = textFileService;
+        this.editorService = editorService;
+        this.textModelResolverService = textModelResolverService;
+        this.bulkEditorService = bulkEditorService;
+        this.labelService = labelService;
+        this.notebookEditorModelResolverService = notebookEditorModelResolverService;
+    }
+    async replace(arg, progress = undefined, resource = null) {
+        const edits = this.createEdits(arg, resource);
+        await this.bulkEditorService.apply(edits, { progress });
+        const rawTextPromises = ( edits.map(async (e) => {
+            if (e.resource.scheme === Schemas.vscodeNotebookCell) {
+                const notebookResource = CellUri.parse(e.resource)?.notebook;
+                if (notebookResource) {
+                    let ref;
+                    try {
+                        ref = await this.notebookEditorModelResolverService.resolve(notebookResource);
+                        await ref.object.save({ source: ReplaceService_1.REPLACE_SAVE_SOURCE });
+                    }
+                    finally {
+                        ref?.dispose();
+                    }
+                }
+                return;
+            }
+            else {
+                return this.textFileService.files.get(e.resource)?.save({ source: ReplaceService_1.REPLACE_SAVE_SOURCE });
+            }
+        }));
+        return Promises.settled(rawTextPromises);
+    }
+    async openReplacePreview(element, preserveFocus, sideBySide, pinned) {
+        const fileMatch = element instanceof Match ? element.parent() : element;
+        const editor = await this.editorService.openEditor({
+            original: { resource: fileMatch.resource },
+            modified: { resource: toReplaceResource(fileMatch.resource) },
+            label: ( localizeWithPath(
+                'vs/workbench/contrib/search/browser/replaceService',
+                'fileReplaceChanges',
+                "{0} ↔ {1} (Replace Preview)",
+                fileMatch.name(),
+                fileMatch.name()
+            )),
+            description: this.labelService.getUriLabel(dirname(fileMatch.resource), { relative: true }),
+            options: {
+                preserveFocus,
+                pinned,
+                revealIfVisible: true
+            }
+        });
+        const input = editor?.input;
+        const disposable = fileMatch.onDispose(() => {
+            input?.dispose();
+            disposable.dispose();
+        });
+        await this.updateReplacePreview(fileMatch);
+        if (editor) {
+            const editorControl = editor.getControl();
+            if (element instanceof Match && editorControl) {
+                editorControl.revealLineInCenter(element.range().startLineNumber, 1 );
+            }
+        }
+    }
+    async updateReplacePreview(fileMatch, override = false) {
+        const replacePreviewUri = toReplaceResource(fileMatch.resource);
+        const [sourceModelRef, replaceModelRef] = await Promise.all([this.textModelResolverService.createModelReference(fileMatch.resource), this.textModelResolverService.createModelReference(replacePreviewUri)]);
+        const sourceModel = sourceModelRef.object.textEditorModel;
+        const replaceModel = replaceModelRef.object.textEditorModel;
+        try {
+            if (sourceModel && replaceModel) {
+                if (override) {
+                    replaceModel.setValue(sourceModel.getValue());
+                }
+                else {
+                    replaceModel.undo();
+                }
+                this.applyEditsToPreview(fileMatch, replaceModel);
+            }
+        }
+        finally {
+            sourceModelRef.dispose();
+            replaceModelRef.dispose();
+        }
+    }
+    applyEditsToPreview(fileMatch, replaceModel) {
+        const resourceEdits = this.createEdits(fileMatch, replaceModel.uri);
+        const modelEdits = [];
+        for (const resourceEdit of resourceEdits) {
+            modelEdits.push(EditOperation.replaceMove(Range.lift(resourceEdit.textEdit.range), resourceEdit.textEdit.text));
+        }
+        replaceModel.pushEditOperations([], modelEdits.sort((a, b) => Range.compareRangesUsingStarts(a.range, b.range)), () => []);
+    }
+    createEdits(arg, resource = null) {
+        const edits = [];
+        if (arg instanceof Match) {
+            if (arg instanceof MatchInNotebook) {
+                if (!arg.isReadonly()) {
+                    const match = arg;
+                    edits.push(this.createEdit(match, match.replaceString, match.cell?.uri));
+                }
+            }
+            else {
+                const match = arg;
+                edits.push(this.createEdit(match, match.replaceString, resource));
+            }
+        }
+        if (arg instanceof FileMatch) {
+            arg = [arg];
+        }
+        if (arg instanceof Array) {
+            arg.forEach(element => {
+                const fileMatch = element;
+                if (fileMatch.count() > 0) {
+                    edits.push(...fileMatch.matches().flatMap(match => this.createEdits(match, resource)));
+                }
+            });
+        }
+        return edits;
+    }
+    createEdit(match, text, resource = null) {
+        const fileMatch = match.parent();
+        return ( new ResourceTextEdit(
+            resource ?? fileMatch.resource,
+            { range: match.range(), text },
+            undefined,
+            undefined
+        ));
+    }
+};
+ReplaceService = ReplaceService_1 = ( __decorate([
+    ( __param(0, ITextFileService)),
+    ( __param(1, IEditorService)),
+    ( __param(2, ITextModelService)),
+    ( __param(3, IBulkEditService)),
+    ( __param(4, ILabelService)),
+    ( __param(5, INotebookEditorModelResolverService))
+], ReplaceService));
+
+export { ReplacePreviewContentProvider, ReplaceService };