@codingame/monaco-vscode-views-service-override 1.85.0 → 1.85.2

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/commands/devCommands.js

@@ -0,0 +1,240 @@
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
+import '../../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { MergeEditor } from '../view/mergeEditor.js';
+import { ctxIsMergeEditor } from 'vscode/vscode/vs/workbench/contrib/mergeEditor/common/mergeEditor';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { IFileDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
+const MERGE_EDITOR_CATEGORY = { value: ( localizeWithPath(
+    'vs/workbench/contrib/mergeEditor/browser/commands/devCommands',
+    'mergeEditor',
+    "Merge Editor (Dev)"
+)), original: 'Merge Editor (Dev)' };
+class MergeEditorCopyContentsToJSON extends Action2 {
+    constructor() {
+        super({
+            id: 'merge.dev.copyContentsJson',
+            category: MERGE_EDITOR_CATEGORY,
+            title: {
+                value: ( localizeWithPath(
+                    'vs/workbench/contrib/mergeEditor/browser/commands/devCommands',
+                    'merge.dev.copyState',
+                    'Copy Merge Editor State as JSON'
+                )),
+                original: 'Copy Merge Editor State as JSON',
+            },
+            icon: Codicon.layoutCentered,
+            f1: true,
+            precondition: ctxIsMergeEditor,
+        });
+    }
+    run(accessor) {
+        const { activeEditorPane } = accessor.get(IEditorService);
+        const clipboardService = accessor.get(IClipboardService);
+        const notificationService = accessor.get(INotificationService);
+        if (!(activeEditorPane instanceof MergeEditor)) {
+            notificationService.info({
+                name: ( localizeWithPath(
+                    'vs/workbench/contrib/mergeEditor/browser/commands/devCommands',
+                    'mergeEditor.name',
+                    'Merge Editor'
+                )),
+                message: ( localizeWithPath(
+                    'vs/workbench/contrib/mergeEditor/browser/commands/devCommands',
+                    'mergeEditor.noActiveMergeEditor',
+                    "No active merge editor"
+                ))
+            });
+            return;
+        }
+        const model = activeEditorPane.model;
+        if (!model) {
+            return;
+        }
+        const contents = {
+            languageId: model.resultTextModel.getLanguageId(),
+            base: model.base.getValue(),
+            input1: model.input1.textModel.getValue(),
+            input2: model.input2.textModel.getValue(),
+            result: model.resultTextModel.getValue(),
+            initialResult: model.getInitialResultValue(),
+        };
+        const jsonStr = JSON.stringify(contents, undefined, 4);
+        clipboardService.writeText(jsonStr);
+        notificationService.info({
+            name: ( localizeWithPath(
+                'vs/workbench/contrib/mergeEditor/browser/commands/devCommands',
+                'mergeEditor.name',
+                'Merge Editor'
+            )),
+            message: ( localizeWithPath(
+                'vs/workbench/contrib/mergeEditor/browser/commands/devCommands',
+                'mergeEditor.successfullyCopiedMergeEditorContents',
+                "Successfully copied merge editor state"
+            )),
+        });
+    }
+}
+class MergeEditorSaveContentsToFolder extends Action2 {
+    constructor() {
+        super({
+            id: 'merge.dev.saveContentsToFolder',
+            category: MERGE_EDITOR_CATEGORY,
+            title: {
+                value: ( localizeWithPath(
+                    'vs/workbench/contrib/mergeEditor/browser/commands/devCommands',
+                    'merge.dev.saveContentsToFolder',
+                    'Save Merge Editor State to Folder'
+                )),
+                original: 'Save Merge Editor State to Folder',
+            },
+            icon: Codicon.layoutCentered,
+            f1: true,
+            precondition: ctxIsMergeEditor,
+        });
+    }
+    async run(accessor) {
+        const { activeEditorPane } = accessor.get(IEditorService);
+        const notificationService = accessor.get(INotificationService);
+        const dialogService = accessor.get(IFileDialogService);
+        const fileService = accessor.get(IFileService);
+        const languageService = accessor.get(ILanguageService);
+        if (!(activeEditorPane instanceof MergeEditor)) {
+            notificationService.info({
+                name: ( localizeWithPath(
+                    'vs/workbench/contrib/mergeEditor/browser/commands/devCommands',
+                    'mergeEditor.name',
+                    'Merge Editor'
+                )),
+                message: ( localizeWithPath(
+                    'vs/workbench/contrib/mergeEditor/browser/commands/devCommands',
+                    'mergeEditor.noActiveMergeEditor',
+                    "No active merge editor"
+                ))
+            });
+            return;
+        }
+        const model = activeEditorPane.model;
+        if (!model) {
+            return;
+        }
+        const result = await dialogService.showOpenDialog({
+            canSelectFiles: false,
+            canSelectFolders: true,
+            canSelectMany: false,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/mergeEditor/browser/commands/devCommands',
+                'mergeEditor.selectFolderToSaveTo',
+                'Select folder to save to'
+            ))
+        });
+        if (!result) {
+            return;
+        }
+        const targetDir = result[0];
+        const extension = languageService.getExtensions(model.resultTextModel.getLanguageId())[0] || '';
+        async function write(fileName, source) {
+            await fileService.writeFile(URI.joinPath(targetDir, fileName + extension), VSBuffer.fromString(source), {});
+        }
+        await Promise.all([
+            write('base', model.base.getValue()),
+            write('input1', model.input1.textModel.getValue()),
+            write('input2', model.input2.textModel.getValue()),
+            write('result', model.resultTextModel.getValue()),
+            write('initialResult', model.getInitialResultValue()),
+        ]);
+        notificationService.info({
+            name: ( localizeWithPath(
+                'vs/workbench/contrib/mergeEditor/browser/commands/devCommands',
+                'mergeEditor.name',
+                'Merge Editor'
+            )),
+            message: ( localizeWithPath(
+                'vs/workbench/contrib/mergeEditor/browser/commands/devCommands',
+                'mergeEditor.successfullySavedMergeEditorContentsToFolder',
+                "Successfully saved merge editor state to folder"
+            )),
+        });
+    }
+}
+class MergeEditorLoadContentsFromFolder extends Action2 {
+    constructor() {
+        super({
+            id: 'merge.dev.loadContentsFromFolder',
+            category: MERGE_EDITOR_CATEGORY,
+            title: {
+                value: ( localizeWithPath(
+                    'vs/workbench/contrib/mergeEditor/browser/commands/devCommands',
+                    'merge.dev.loadContentsFromFolder',
+                    'Load Merge Editor State from Folder'
+                )),
+                original: 'Load Merge Editor State from Folder',
+            },
+            icon: Codicon.layoutCentered,
+            f1: true
+        });
+    }
+    async run(accessor, args) {
+        const dialogService = accessor.get(IFileDialogService);
+        const editorService = accessor.get(IEditorService);
+        const fileService = accessor.get(IFileService);
+        const quickInputService = accessor.get(IQuickInputService);
+        if (!args) {
+            args = {};
+        }
+        let targetDir;
+        if (!args.folderUri) {
+            const result = await dialogService.showOpenDialog({
+                canSelectFiles: false,
+                canSelectFolders: true,
+                canSelectMany: false,
+                title: ( localizeWithPath(
+                    'vs/workbench/contrib/mergeEditor/browser/commands/devCommands',
+                    'mergeEditor.selectFolderToSaveTo',
+                    'Select folder to save to'
+                ))
+            });
+            if (!result) {
+                return;
+            }
+            targetDir = result[0];
+        }
+        else {
+            targetDir = args.folderUri;
+        }
+        const targetDirInfo = await fileService.resolve(targetDir);
+        function findFile(name) {
+            return targetDirInfo.children.find(c => c.name.startsWith(name))?.resource;
+        }
+        const shouldOpenInitial = await promptOpenInitial(quickInputService, args.resultState);
+        const baseUri = findFile('base');
+        const input1Uri = findFile('input1');
+        const input2Uri = findFile('input2');
+        const resultUri = findFile(shouldOpenInitial ? 'initialResult' : 'result');
+        const input = {
+            base: { resource: baseUri },
+            input1: { resource: input1Uri, label: 'Input 1', description: 'Input 1', detail: '(from file)' },
+            input2: { resource: input2Uri, label: 'Input 2', description: 'Input 2', detail: '(from file)' },
+            result: { resource: resultUri },
+        };
+        editorService.openEditor(input);
+    }
+}
+async function promptOpenInitial(quickInputService, resultStateOverride) {
+    if (resultStateOverride) {
+        return resultStateOverride === 'initial';
+    }
+    const result = await quickInputService.pick([{ label: 'result', result: false }, { label: 'initial result', result: true }], { canPickMany: false });
+    return result?.result;
+}
+
+export { MergeEditorCopyContentsToJSON, MergeEditorLoadContentsFromFolder, MergeEditorSaveContentsToFolder };

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/mergeEditor.contribution.js

@@ -0,0 +1,77 @@
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { registerAction2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { EditorPaneDescriptor } from 'vscode/vscode/vs/workbench/browser/editor';
+import { Extensions as Extensions$1 } from 'vscode/vscode/vs/workbench/common/contributions';
+import { EditorExtensions } from 'vscode/vscode/vs/workbench/common/editor';
+import { OpenResultResource, SetMixedLayout, SetColumnLayout, OpenMergeEditor, OpenBaseFile, ShowNonConflictingChanges, ShowHideBase, ShowHideTopBase, ShowHideCenterBase, GoToNextUnhandledConflict, GoToPreviousUnhandledConflict, ToggleActiveConflictInput1, ToggleActiveConflictInput2, CompareInput1WithBaseCommand, CompareInput2WithBaseCommand, AcceptAllInput1, AcceptAllInput2, ResetToBaseAndAutoMergeCommand, AcceptMerge, ResetCloseWithConflictsChoice } from './commands/commands.js';
+import { MergeEditorCopyContentsToJSON, MergeEditorSaveContentsToFolder, MergeEditorLoadContentsFromFolder } from './commands/devCommands.js';
+import { MergeEditorInput } from 'vscode/vscode/vs/workbench/contrib/mergeEditor/browser/mergeEditorInput';
+import { MergeEditor, MergeEditorOpenHandlerContribution, MergeEditorResolverContribution } from './view/mergeEditor.js';
+import { MergeEditorSerializer } from './mergeEditorSerializer.js';
+
+( Registry.as(EditorExtensions.EditorPane)).registerEditorPane(EditorPaneDescriptor.create(MergeEditor, MergeEditor.ID, ( localizeWithPath(
+    'vs/workbench/contrib/mergeEditor/browser/mergeEditor.contribution',
+    'name',
+    "Merge Editor"
+))), [
+    ( new SyncDescriptor(MergeEditorInput))
+]);
+( Registry.as(EditorExtensions.EditorFactory)).registerEditorSerializer(MergeEditorInput.ID, MergeEditorSerializer);
+( Registry.as(Extensions.Configuration)).registerConfiguration({
+    properties: {
+        'mergeEditor.diffAlgorithm': {
+            type: 'string',
+            enum: ['legacy', 'advanced'],
+            default: 'advanced',
+            markdownEnumDescriptions: [
+                ( localizeWithPath(
+                    'vs/workbench/contrib/mergeEditor/browser/mergeEditor.contribution',
+                    'diffAlgorithm.legacy',
+                    "Uses the legacy diffing algorithm."
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/mergeEditor/browser/mergeEditor.contribution',
+                    'diffAlgorithm.advanced',
+                    "Uses the advanced diffing algorithm."
+                )),
+            ]
+        },
+        'mergeEditor.showDeletionMarkers': {
+            type: 'boolean',
+            default: true,
+            description: 'Controls if deletions in base or one of the inputs should be indicated by a vertical bar.',
+        },
+    }
+});
+registerAction2(OpenResultResource);
+registerAction2(SetMixedLayout);
+registerAction2(SetColumnLayout);
+registerAction2(OpenMergeEditor);
+registerAction2(OpenBaseFile);
+registerAction2(ShowNonConflictingChanges);
+registerAction2(ShowHideBase);
+registerAction2(ShowHideTopBase);
+registerAction2(ShowHideCenterBase);
+registerAction2(GoToNextUnhandledConflict);
+registerAction2(GoToPreviousUnhandledConflict);
+registerAction2(ToggleActiveConflictInput1);
+registerAction2(ToggleActiveConflictInput2);
+registerAction2(CompareInput1WithBaseCommand);
+registerAction2(CompareInput2WithBaseCommand);
+registerAction2(AcceptAllInput1);
+registerAction2(AcceptAllInput2);
+registerAction2(ResetToBaseAndAutoMergeCommand);
+registerAction2(AcceptMerge);
+registerAction2(ResetCloseWithConflictsChoice);
+registerAction2(MergeEditorCopyContentsToJSON);
+registerAction2(MergeEditorSaveContentsToFolder);
+registerAction2(MergeEditorLoadContentsFromFolder);
+( Registry
+    .as(Extensions$1.Workbench))
+    .registerWorkbenchContribution(MergeEditorOpenHandlerContribution, 3 );
+( Registry
+    .as(Extensions$1.Workbench))
+    .registerWorkbenchContribution(MergeEditorResolverContribution, 1 );

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/mergeEditorSerializer.js

@@ -0,0 +1,42 @@
+import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { parse } from 'monaco-editor/esm/vs/base/common/marshalling.js';
+import { MergeEditorInput, MergeEditorInputData } from 'vscode/vscode/vs/workbench/contrib/mergeEditor/browser/mergeEditorInput';
+
+class MergeEditorSerializer {
+    canSerialize() {
+        return true;
+    }
+    serialize(editor) {
+        return JSON.stringify(this.toJSON(editor));
+    }
+    toJSON(editor) {
+        return {
+            base: editor.base,
+            input1: editor.input1,
+            input2: editor.input2,
+            result: editor.result,
+        };
+    }
+    deserialize(instantiationService, raw) {
+        try {
+            const data = parse(raw);
+            return instantiationService.createInstance(MergeEditorInput, data.base, ( new MergeEditorInputData(
+                data.input1.uri,
+                data.input1.title,
+                data.input1.detail,
+                data.input1.description
+            )), ( new MergeEditorInputData(
+                data.input2.uri,
+                data.input2.title,
+                data.input2.detail,
+                data.input2.description
+            )), data.result);
+        }
+        catch (err) {
+            onUnexpectedError(err);
+            return undefined;
+        }
+    }
+}
+
+export { MergeEditorSerializer };

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/view/colors.js

@@ -0,0 +1,71 @@
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { registerColor, transparent, mergeCurrentHeaderBackground, mergeIncomingHeaderBackground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+
+registerColor('mergeEditor.change.background', { dark: '#9bb95533', light: '#9bb95533', hcDark: '#9bb95533', hcLight: '#9bb95533', }, ( localizeWithPath(
+ 'vs/workbench/contrib/mergeEditor/browser/view/colors',
+ 'mergeEditor.change.background',
+ 'The background color for changes.'
+)));
+registerColor('mergeEditor.change.word.background', { dark: '#9ccc2c33', light: '#9ccc2c66', hcDark: '#9ccc2c33', hcLight: '#9ccc2c66', }, ( localizeWithPath(
+ 'vs/workbench/contrib/mergeEditor/browser/view/colors',
+ 'mergeEditor.change.word.background',
+ 'The background color for word changes.'
+)));
+registerColor('mergeEditor.changeBase.background', { dark: '#4B1818FF', light: '#FFCCCCFF', hcDark: '#4B1818FF', hcLight: '#FFCCCCFF', }, ( localizeWithPath(
+ 'vs/workbench/contrib/mergeEditor/browser/view/colors',
+ 'mergeEditor.changeBase.background',
+ 'The background color for changes in base.'
+)));
+registerColor('mergeEditor.changeBase.word.background', { dark: '#6F1313FF', light: '#FFA3A3FF', hcDark: '#6F1313FF', hcLight: '#FFA3A3FF', }, ( localizeWithPath(
+ 'vs/workbench/contrib/mergeEditor/browser/view/colors',
+ 'mergeEditor.changeBase.word.background',
+ 'The background color for word changes in base.'
+)));
+registerColor('mergeEditor.conflict.unhandledUnfocused.border', { dark: '#ffa6007a', light: '#ffa600FF', hcDark: '#ffa6007a', hcLight: '#ffa6007a', }, ( localizeWithPath(
+ 'vs/workbench/contrib/mergeEditor/browser/view/colors',
+ 'mergeEditor.conflict.unhandledUnfocused.border',
+ 'The border color of unhandled unfocused conflicts.'
+)));
+registerColor('mergeEditor.conflict.unhandledFocused.border', { dark: '#ffa600', light: '#ffa600', hcDark: '#ffa600', hcLight: '#ffa600', }, ( localizeWithPath(
+ 'vs/workbench/contrib/mergeEditor/browser/view/colors',
+ 'mergeEditor.conflict.unhandledFocused.border',
+ 'The border color of unhandled focused conflicts.'
+)));
+registerColor('mergeEditor.conflict.handledUnfocused.border', { dark: '#86868649', light: '#86868649', hcDark: '#86868649', hcLight: '#86868649', }, ( localizeWithPath(
+ 'vs/workbench/contrib/mergeEditor/browser/view/colors',
+ 'mergeEditor.conflict.handledUnfocused.border',
+ 'The border color of handled unfocused conflicts.'
+)));
+registerColor('mergeEditor.conflict.handledFocused.border', { dark: '#c1c1c1cc', light: '#c1c1c1cc', hcDark: '#c1c1c1cc', hcLight: '#c1c1c1cc', }, ( localizeWithPath(
+ 'vs/workbench/contrib/mergeEditor/browser/view/colors',
+ 'mergeEditor.conflict.handledFocused.border',
+ 'The border color of handled focused conflicts.'
+)));
+const handledConflictMinimapOverViewRulerColor = registerColor('mergeEditor.conflict.handled.minimapOverViewRuler', { dark: '#adaca8ee', light: '#adaca8ee', hcDark: '#adaca8ee', hcLight: '#adaca8ee', }, ( localizeWithPath(
+ 'vs/workbench/contrib/mergeEditor/browser/view/colors',
+ 'mergeEditor.conflict.handled.minimapOverViewRuler',
+ 'The foreground color for changes in input 1.'
+)));
+const unhandledConflictMinimapOverViewRulerColor = registerColor('mergeEditor.conflict.unhandled.minimapOverViewRuler', { dark: '#fcba03FF', light: '#fcba03FF', hcDark: '#fcba03FF', hcLight: '#fcba03FF', }, ( localizeWithPath(
+ 'vs/workbench/contrib/mergeEditor/browser/view/colors',
+ 'mergeEditor.conflict.unhandled.minimapOverViewRuler',
+ 'The foreground color for changes in input 1.'
+)));
+registerColor('mergeEditor.conflictingLines.background', { dark: '#ffea0047', light: '#ffea0047', hcDark: '#ffea0047', hcLight: '#ffea0047', }, ( localizeWithPath(
+ 'vs/workbench/contrib/mergeEditor/browser/view/colors',
+ 'mergeEditor.conflictingLines.background',
+ 'The background of the "Conflicting Lines" text.'
+)));
+const contentTransparency = 0.4;
+registerColor('mergeEditor.conflict.input1.background', { dark: ( transparent(mergeCurrentHeaderBackground, contentTransparency)), light: ( transparent(mergeCurrentHeaderBackground, contentTransparency)), hcDark: ( transparent(mergeCurrentHeaderBackground, contentTransparency)), hcLight: ( transparent(mergeCurrentHeaderBackground, contentTransparency)) }, ( localizeWithPath(
+ 'vs/workbench/contrib/mergeEditor/browser/view/colors',
+ 'mergeEditor.conflict.input1.background',
+ 'The background color of decorations in input 1.'
+)));
+registerColor('mergeEditor.conflict.input2.background', { dark: ( transparent(mergeIncomingHeaderBackground, contentTransparency)), light: ( transparent(mergeIncomingHeaderBackground, contentTransparency)), hcDark: ( transparent(mergeIncomingHeaderBackground, contentTransparency)), hcLight: ( transparent(mergeIncomingHeaderBackground, contentTransparency)) }, ( localizeWithPath(
+ 'vs/workbench/contrib/mergeEditor/browser/view/colors',
+ 'mergeEditor.conflict.input2.background',
+ 'The background color of decorations in input 2.'
+)));
+
+export { handledConflictMinimapOverViewRulerColor, unhandledConflictMinimapOverViewRulerColor };