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

package/vscode/src/vs/workbench/contrib/localHistory/browser/localHistoryCommands.js

@@ -0,0 +1,637 @@
+import { localize2WithPath, localizeWithPath } from 'vscode/vscode/vs/nls';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { toErrorMessage } from 'vscode/vscode/vs/base/common/errorMessage';
+import { CancellationToken, CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
+import { IWorkingCopyHistoryService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyHistory';
+import { API_OPEN_DIFF_EDITOR_COMMAND_ID } from 'vscode/vscode/vs/workbench/browser/parts/editor/editorCommands';
+import { LocalHistoryFileSystemProvider } from './localHistoryFileSystemProvider.js';
+import { RawContextKey, IContextKeyService, ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { registerAction2, Action2, MenuId, MenuRegistry } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { basenameOrAuthority, basename, dirname } from 'vscode/vscode/vs/base/common/resources';
+import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
+import { SaveSourceRegistry, EditorResourceAccessor, SideBySideEditor } from 'vscode/vscode/vs/workbench/common/editor';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
+import { IWorkingCopyService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyService';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { ResourceContextKey, ActiveEditorContext } from 'vscode/vscode/vs/workbench/common/contextkeys';
+import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/quickInput';
+import { getIconClasses } from 'vscode/vscode/vs/editor/common/services/getIconClasses';
+import { IModelService } from 'vscode/vscode/vs/editor/common/services/model';
+import { ILanguageService } from 'vscode/vscode/vs/editor/common/languages/language';
+import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label';
+import { firstOrDefault } from 'vscode/vscode/vs/base/common/arrays';
+import { LOCAL_HISTORY_MENU_CONTEXT_KEY, LOCAL_HISTORY_ICON_RESTORE, getLocalHistoryDateFormatter } from './localHistory.js';
+import { IPathService } from 'vscode/vscode/vs/workbench/services/path/common/pathService';
+import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
+const LOCAL_HISTORY_CATEGORY = ( localize2WithPath(
+    'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
+    'localHistory.category',
+    'Local History'
+));
+const COMPARE_WITH_FILE_LABEL = ( localize2WithPath(
+    'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
+    'localHistory.compareWithFile',
+    'Compare with File'
+));
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.localHistory.compareWithFile',
+            title: COMPARE_WITH_FILE_LABEL,
+            menu: {
+                id: MenuId.TimelineItemContext,
+                group: '1_compare',
+                order: 1,
+                when: LOCAL_HISTORY_MENU_CONTEXT_KEY
+            }
+        });
+    }
+    async run(accessor, item) {
+        const commandService = accessor.get(ICommandService);
+        const workingCopyHistoryService = accessor.get(IWorkingCopyHistoryService);
+        const { entry } = await findLocalHistoryEntry(workingCopyHistoryService, item);
+        if (entry) {
+            return commandService.executeCommand(API_OPEN_DIFF_EDITOR_COMMAND_ID, ...toDiffEditorArguments(entry, entry.workingCopy.resource));
+        }
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.localHistory.compareWithPrevious',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
+                'localHistory.compareWithPrevious',
+                'Compare with Previous'
+            )),
+            menu: {
+                id: MenuId.TimelineItemContext,
+                group: '1_compare',
+                order: 2,
+                when: LOCAL_HISTORY_MENU_CONTEXT_KEY
+            }
+        });
+    }
+    async run(accessor, item) {
+        const commandService = accessor.get(ICommandService);
+        const workingCopyHistoryService = accessor.get(IWorkingCopyHistoryService);
+        const editorService = accessor.get(IEditorService);
+        const { entry, previous } = await findLocalHistoryEntry(workingCopyHistoryService, item);
+        if (entry) {
+            if (!previous) {
+                return openEntry(entry, editorService);
+            }
+            return commandService.executeCommand(API_OPEN_DIFF_EDITOR_COMMAND_ID, ...toDiffEditorArguments(previous, entry));
+        }
+    }
+});
+let itemSelectedForCompare = undefined;
+const LocalHistoryItemSelectedForCompare = ( new RawContextKey('localHistoryItemSelectedForCompare', false, true));
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.localHistory.selectForCompare',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
+                'localHistory.selectForCompare',
+                'Select for Compare'
+            )),
+            menu: {
+                id: MenuId.TimelineItemContext,
+                group: '2_compare_with',
+                order: 2,
+                when: LOCAL_HISTORY_MENU_CONTEXT_KEY
+            }
+        });
+    }
+    async run(accessor, item) {
+        const workingCopyHistoryService = accessor.get(IWorkingCopyHistoryService);
+        const contextKeyService = accessor.get(IContextKeyService);
+        const { entry } = await findLocalHistoryEntry(workingCopyHistoryService, item);
+        if (entry) {
+            itemSelectedForCompare = item;
+            LocalHistoryItemSelectedForCompare.bindTo(contextKeyService).set(true);
+        }
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.localHistory.compareWithSelected',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
+                'localHistory.compareWithSelected',
+                'Compare with Selected'
+            )),
+            menu: {
+                id: MenuId.TimelineItemContext,
+                group: '2_compare_with',
+                order: 1,
+                when: ( ContextKeyExpr.and(LOCAL_HISTORY_MENU_CONTEXT_KEY, LocalHistoryItemSelectedForCompare))
+            }
+        });
+    }
+    async run(accessor, item) {
+        const workingCopyHistoryService = accessor.get(IWorkingCopyHistoryService);
+        const commandService = accessor.get(ICommandService);
+        if (!itemSelectedForCompare) {
+            return;
+        }
+        const selectedEntry = (await findLocalHistoryEntry(workingCopyHistoryService, itemSelectedForCompare)).entry;
+        if (!selectedEntry) {
+            return;
+        }
+        const { entry } = await findLocalHistoryEntry(workingCopyHistoryService, item);
+        if (entry) {
+            return commandService.executeCommand(API_OPEN_DIFF_EDITOR_COMMAND_ID, ...toDiffEditorArguments(selectedEntry, entry));
+        }
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.localHistory.open',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
+                'localHistory.open',
+                'Show Contents'
+            )),
+            menu: {
+                id: MenuId.TimelineItemContext,
+                group: '3_contents',
+                order: 1,
+                when: LOCAL_HISTORY_MENU_CONTEXT_KEY
+            }
+        });
+    }
+    async run(accessor, item) {
+        const workingCopyHistoryService = accessor.get(IWorkingCopyHistoryService);
+        const editorService = accessor.get(IEditorService);
+        const { entry } = await findLocalHistoryEntry(workingCopyHistoryService, item);
+        if (entry) {
+            return openEntry(entry, editorService);
+        }
+    }
+});
+const RESTORE_CONTENTS_LABEL = ( localize2WithPath(
+    'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
+    'localHistory.restore',
+    'Restore Contents'
+));
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.localHistory.restoreViaEditor',
+            title: RESTORE_CONTENTS_LABEL,
+            menu: {
+                id: MenuId.EditorTitle,
+                group: 'navigation',
+                order: -10,
+                when: ( ResourceContextKey.Scheme.isEqualTo(LocalHistoryFileSystemProvider.SCHEMA))
+            },
+            icon: LOCAL_HISTORY_ICON_RESTORE
+        });
+    }
+    async run(accessor, uri) {
+        const { associatedResource, location } = LocalHistoryFileSystemProvider.fromLocalHistoryFileSystem(uri);
+        return restore(accessor, { uri: associatedResource, handle: basenameOrAuthority(location) });
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.localHistory.restore',
+            title: RESTORE_CONTENTS_LABEL,
+            menu: {
+                id: MenuId.TimelineItemContext,
+                group: '3_contents',
+                order: 2,
+                when: LOCAL_HISTORY_MENU_CONTEXT_KEY
+            }
+        });
+    }
+    async run(accessor, item) {
+        return restore(accessor, item);
+    }
+});
+const restoreSaveSource = SaveSourceRegistry.registerSource('localHistoryRestore.source', ( localizeWithPath(
+    'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
+    'localHistoryRestore.source',
+    "File Restored"
+)));
+async function restore(accessor, item) {
+    const fileService = accessor.get(IFileService);
+    const dialogService = accessor.get(IDialogService);
+    const workingCopyService = accessor.get(IWorkingCopyService);
+    const workingCopyHistoryService = accessor.get(IWorkingCopyHistoryService);
+    const editorService = accessor.get(IEditorService);
+    const { entry } = await findLocalHistoryEntry(workingCopyHistoryService, item);
+    if (entry) {
+        const { confirmed } = await dialogService.confirm({
+            type: 'warning',
+            message: ( localizeWithPath(
+                'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
+                'confirmRestoreMessage',
+                "Do you want to restore the contents of '{0}'?",
+                basename(entry.workingCopy.resource)
+            )),
+            detail: ( localizeWithPath(
+                'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
+                'confirmRestoreDetail',
+                "Restoring will discard any unsaved changes."
+            )),
+            primaryButton: ( localizeWithPath(
+                'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
+                { key: 'restoreButtonLabel', comment: ['&& denotes a mnemonic'] },
+                "&&Restore"
+            ))
+        });
+        if (!confirmed) {
+            return;
+        }
+        const workingCopies = workingCopyService.getAll(entry.workingCopy.resource);
+        if (workingCopies) {
+            for (const workingCopy of workingCopies) {
+                if (workingCopy.isDirty()) {
+                    await workingCopy.revert({ soft: true });
+                }
+            }
+        }
+        try {
+            await fileService.cloneFile(entry.location, entry.workingCopy.resource);
+        }
+        catch (error) {
+            await dialogService.error(( localizeWithPath(
+                'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
+                'unableToRestore',
+                "Unable to restore '{0}'.",
+                basename(entry.workingCopy.resource)
+            )), toErrorMessage(error));
+            return;
+        }
+        if (workingCopies) {
+            for (const workingCopy of workingCopies) {
+                await workingCopy.revert({ force: true });
+            }
+        }
+        await editorService.openEditor({ resource: entry.workingCopy.resource });
+        await workingCopyHistoryService.addEntry({
+            resource: entry.workingCopy.resource,
+            source: restoreSaveSource
+        }, CancellationToken.None);
+        await closeEntry(entry, editorService);
+    }
+}
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.localHistory.restoreViaPicker',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
+                'localHistory.restoreViaPicker',
+                'Find Entry to Restore'
+            )),
+            f1: true,
+            category: LOCAL_HISTORY_CATEGORY
+        });
+    }
+    async run(accessor) {
+        const workingCopyHistoryService = accessor.get(IWorkingCopyHistoryService);
+        const quickInputService = accessor.get(IQuickInputService);
+        const modelService = accessor.get(IModelService);
+        const languageService = accessor.get(ILanguageService);
+        const labelService = accessor.get(ILabelService);
+        const editorService = accessor.get(IEditorService);
+        const fileService = accessor.get(IFileService);
+        const commandService = accessor.get(ICommandService);
+        const resourcePicker = quickInputService.createQuickPick();
+        let cts = ( new CancellationTokenSource());
+        resourcePicker.onDidHide(() => cts.dispose(true));
+        resourcePicker.busy = true;
+        resourcePicker.show();
+        const resources = await workingCopyHistoryService.getAll(cts.token);
+        resourcePicker.busy = false;
+        resourcePicker.placeholder = ( localizeWithPath(
+            'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
+            'restoreViaPicker.filePlaceholder',
+            "Select the file to show local history for"
+        ));
+        resourcePicker.matchOnLabel = true;
+        resourcePicker.matchOnDescription = true;
+        resourcePicker.items = ( resources.map(resource => ({
+            resource,
+            label: basenameOrAuthority(resource),
+            description: labelService.getUriLabel(dirname(resource), { relative: true }),
+            iconClasses: getIconClasses(modelService, languageService, resource)
+        }))).sort((r1, r2) => r1.resource.fsPath < r2.resource.fsPath ? -1 : 1);
+        await Event.toPromise(resourcePicker.onDidAccept);
+        resourcePicker.dispose();
+        const resource = firstOrDefault(resourcePicker.selectedItems)?.resource;
+        if (!resource) {
+            return;
+        }
+        const entryPicker = quickInputService.createQuickPick();
+        cts = ( new CancellationTokenSource());
+        entryPicker.onDidHide(() => cts.dispose(true));
+        entryPicker.busy = true;
+        entryPicker.show();
+        const entries = await workingCopyHistoryService.getEntries(resource, cts.token);
+        entryPicker.busy = false;
+        entryPicker.placeholder = ( localizeWithPath(
+            'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
+            'restoreViaPicker.entryPlaceholder',
+            "Select the local history entry to open"
+        ));
+        entryPicker.matchOnLabel = true;
+        entryPicker.matchOnDescription = true;
+        entryPicker.items = ( Array.from(entries).reverse().map(entry => ({
+            entry,
+            label: `$(circle-outline) ${SaveSourceRegistry.getSourceLabel(entry.source)}`,
+            description: toLocalHistoryEntryDateLabel(entry.timestamp)
+        })));
+        await Event.toPromise(entryPicker.onDidAccept);
+        entryPicker.dispose();
+        const selectedItem = firstOrDefault(entryPicker.selectedItems);
+        if (!selectedItem) {
+            return;
+        }
+        const resourceExists = await fileService.exists(selectedItem.entry.workingCopy.resource);
+        if (resourceExists) {
+            return commandService.executeCommand(API_OPEN_DIFF_EDITOR_COMMAND_ID, ...toDiffEditorArguments(selectedItem.entry, selectedItem.entry.workingCopy.resource));
+        }
+        return openEntry(selectedItem.entry, editorService);
+    }
+});
+MenuRegistry.appendMenuItem(MenuId.TimelineTitle, { command: { id: 'workbench.action.localHistory.restoreViaPicker', title: ( localize2WithPath(
+    'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
+    'localHistory.restoreViaPickerMenu',
+    'Local History: Find Entry to Restore...'
+)) }, group: 'submenu', order: 1 });
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.localHistory.rename',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
+                'localHistory.rename',
+                'Rename'
+            )),
+            menu: {
+                id: MenuId.TimelineItemContext,
+                group: '5_edit',
+                order: 1,
+                when: LOCAL_HISTORY_MENU_CONTEXT_KEY
+            }
+        });
+    }
+    async run(accessor, item) {
+        const workingCopyHistoryService = accessor.get(IWorkingCopyHistoryService);
+        const quickInputService = accessor.get(IQuickInputService);
+        const { entry } = await findLocalHistoryEntry(workingCopyHistoryService, item);
+        if (entry) {
+            const inputBox = quickInputService.createInputBox();
+            inputBox.title = ( localizeWithPath(
+                'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
+                'renameLocalHistoryEntryTitle',
+                "Rename Local History Entry"
+            ));
+            inputBox.ignoreFocusOut = true;
+            inputBox.placeholder = ( localizeWithPath(
+                'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
+                'renameLocalHistoryPlaceholder',
+                "Enter the new name of the local history entry"
+            ));
+            inputBox.value = SaveSourceRegistry.getSourceLabel(entry.source);
+            inputBox.show();
+            inputBox.onDidAccept(() => {
+                if (inputBox.value) {
+                    workingCopyHistoryService.updateEntry(entry, { source: inputBox.value }, CancellationToken.None);
+                }
+                inputBox.dispose();
+            });
+        }
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.localHistory.delete',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
+                'localHistory.delete',
+                'Delete'
+            )),
+            menu: {
+                id: MenuId.TimelineItemContext,
+                group: '5_edit',
+                order: 2,
+                when: LOCAL_HISTORY_MENU_CONTEXT_KEY
+            }
+        });
+    }
+    async run(accessor, item) {
+        const workingCopyHistoryService = accessor.get(IWorkingCopyHistoryService);
+        const editorService = accessor.get(IEditorService);
+        const dialogService = accessor.get(IDialogService);
+        const { entry } = await findLocalHistoryEntry(workingCopyHistoryService, item);
+        if (entry) {
+            const { confirmed } = await dialogService.confirm({
+                type: 'warning',
+                message: ( localizeWithPath(
+                    'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
+                    'confirmDeleteMessage',
+                    "Do you want to delete the local history entry of '{0}' from {1}?",
+                    entry.workingCopy.name,
+                    toLocalHistoryEntryDateLabel(entry.timestamp)
+                )),
+                detail: ( localizeWithPath(
+                    'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
+                    'confirmDeleteDetail',
+                    "This action is irreversible!"
+                )),
+                primaryButton: ( localizeWithPath(
+                    'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
+                    { key: 'deleteButtonLabel', comment: ['&& denotes a mnemonic'] },
+                    "&&Delete"
+                )),
+            });
+            if (!confirmed) {
+                return;
+            }
+            await workingCopyHistoryService.removeEntry(entry, CancellationToken.None);
+            await closeEntry(entry, editorService);
+        }
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.localHistory.deleteAll',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
+                'localHistory.deleteAll',
+                'Delete All'
+            )),
+            f1: true,
+            category: LOCAL_HISTORY_CATEGORY
+        });
+    }
+    async run(accessor) {
+        const dialogService = accessor.get(IDialogService);
+        const workingCopyHistoryService = accessor.get(IWorkingCopyHistoryService);
+        const { confirmed } = await dialogService.confirm({
+            type: 'warning',
+            message: ( localizeWithPath(
+                'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
+                'confirmDeleteAllMessage',
+                "Do you want to delete all entries of all files in local history?"
+            )),
+            detail: ( localizeWithPath(
+                'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
+                'confirmDeleteAllDetail',
+                "This action is irreversible!"
+            )),
+            primaryButton: ( localizeWithPath(
+                'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
+                { key: 'deleteAllButtonLabel', comment: ['&& denotes a mnemonic'] },
+                "&&Delete All"
+            )),
+        });
+        if (!confirmed) {
+            return;
+        }
+        await workingCopyHistoryService.removeAll(CancellationToken.None);
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.localHistory.create',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
+                'localHistory.create',
+                'Create Entry'
+            )),
+            f1: true,
+            category: LOCAL_HISTORY_CATEGORY,
+            precondition: ActiveEditorContext
+        });
+    }
+    async run(accessor) {
+        const workingCopyHistoryService = accessor.get(IWorkingCopyHistoryService);
+        const quickInputService = accessor.get(IQuickInputService);
+        const editorService = accessor.get(IEditorService);
+        const labelService = accessor.get(ILabelService);
+        const pathService = accessor.get(IPathService);
+        const resource = EditorResourceAccessor.getOriginalUri(editorService.activeEditor, { supportSideBySide: SideBySideEditor.PRIMARY });
+        if (resource?.scheme !== pathService.defaultUriScheme && resource?.scheme !== Schemas.vscodeUserData) {
+            return;
+        }
+        const inputBox = quickInputService.createInputBox();
+        inputBox.title = ( localizeWithPath(
+            'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
+            'createLocalHistoryEntryTitle',
+            "Create Local History Entry"
+        ));
+        inputBox.ignoreFocusOut = true;
+        inputBox.placeholder = ( localizeWithPath(
+            'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
+            'createLocalHistoryPlaceholder',
+            "Enter the new name of the local history entry for '{0}'",
+            labelService.getUriBasenameLabel(resource)
+        ));
+        inputBox.show();
+        inputBox.onDidAccept(async () => {
+            const entrySource = inputBox.value;
+            inputBox.dispose();
+            if (entrySource) {
+                await workingCopyHistoryService.addEntry({ resource, source: inputBox.value }, CancellationToken.None);
+            }
+        });
+    }
+});
+async function openEntry(entry, editorService) {
+    const resource = LocalHistoryFileSystemProvider.toLocalHistoryFileSystem({ location: entry.location, associatedResource: entry.workingCopy.resource });
+    await editorService.openEditor({
+        resource,
+        label: ( localizeWithPath(
+            'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
+            'localHistoryEditorLabel',
+            "{0} ({1} • {2})",
+            entry.workingCopy.name,
+            SaveSourceRegistry.getSourceLabel(entry.source),
+            toLocalHistoryEntryDateLabel(entry.timestamp)
+        ))
+    });
+}
+async function closeEntry(entry, editorService) {
+    const resource = LocalHistoryFileSystemProvider.toLocalHistoryFileSystem({ location: entry.location, associatedResource: entry.workingCopy.resource });
+    const editors = editorService.findEditors(resource, { supportSideBySide: SideBySideEditor.ANY });
+    await editorService.closeEditors(editors, { preserveFocus: true });
+}
+function toDiffEditorArguments(arg1, arg2) {
+    const originalResource = LocalHistoryFileSystemProvider.toLocalHistoryFileSystem({ location: arg1.location, associatedResource: arg1.workingCopy.resource });
+    let label;
+    let modifiedResource;
+    if (URI.isUri(arg2)) {
+        const resource = arg2;
+        modifiedResource = resource;
+        label = ( localizeWithPath(
+            'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
+            'localHistoryCompareToFileEditorLabel',
+            "{0} ({1} • {2}) ↔ {3}",
+            arg1.workingCopy.name,
+            SaveSourceRegistry.getSourceLabel(arg1.source),
+            toLocalHistoryEntryDateLabel(arg1.timestamp),
+            arg1.workingCopy.name
+        ));
+    }
+    else {
+        const modified = arg2;
+        modifiedResource = LocalHistoryFileSystemProvider.toLocalHistoryFileSystem({ location: modified.location, associatedResource: modified.workingCopy.resource });
+        label = ( localizeWithPath(
+            'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
+            'localHistoryCompareToPreviousEditorLabel',
+            "{0} ({1} • {2}) ↔ {3} ({4} • {5})",
+            arg1.workingCopy.name,
+            SaveSourceRegistry.getSourceLabel(arg1.source),
+            toLocalHistoryEntryDateLabel(arg1.timestamp),
+            modified.workingCopy.name,
+            SaveSourceRegistry.getSourceLabel(modified.source),
+            toLocalHistoryEntryDateLabel(modified.timestamp)
+        ));
+    }
+    return [
+        originalResource,
+        modifiedResource,
+        label,
+        undefined
+    ];
+}
+async function findLocalHistoryEntry(workingCopyHistoryService, descriptor) {
+    const entries = await workingCopyHistoryService.getEntries(descriptor.uri, CancellationToken.None);
+    let currentEntry = undefined;
+    let previousEntry = undefined;
+    for (let i = 0; i < entries.length; i++) {
+        const entry = entries[i];
+        if (entry.id === descriptor.handle) {
+            currentEntry = entry;
+            previousEntry = entries[i - 1];
+            break;
+        }
+    }
+    return {
+        entry: currentEntry,
+        previous: previousEntry
+    };
+}
+const SEP = /\//g;
+function toLocalHistoryEntryDateLabel(timestamp) {
+    return `${getLocalHistoryDateFormatter().format(timestamp).replace(SEP, '-')}`;
+}
+
+export { COMPARE_WITH_FILE_LABEL, findLocalHistoryEntry, toDiffEditorArguments };