@codingame/monaco-vscode-working-copy-service-override 7.0.11 → 7.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-working-copy-service-override",
-  "version": "7.0.11",
+  "version": "7.1.1",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -26,7 +26,7 @@
     }
   },
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@7.0.11",
-    "@codingame/monaco-vscode-files-service-override": "7.0.11"
+    "vscode": "npm:@codingame/monaco-vscode-api@7.1.1",
+    "@codingame/monaco-vscode-files-service-override": "7.1.1"
   }
 }

package/vscode/src/vs/workbench/services/workingCopy/common/workingCopyHistoryService.js

@@ -1,5 +1,5 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { localize } from 'vscode/vscode/vs/nls';
 import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
 import { assertIsDefined } from 'vscode/vscode/vs/base/common/types';
 import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
@@ -30,10 +30,9 @@ import { lastOrDefault, distinct } from 'vscode/vscode/vs/base/common/arrays';
 import { escapeRegExpCharacters } from 'vscode/vscode/vs/base/common/strings';
 
 var WorkingCopyHistoryService_1, NativeWorkingCopyHistoryService_1;
-const _moduleId = "vs/workbench/services/workingCopy/common/workingCopyHistoryService";
 class WorkingCopyHistoryModel {
     static { this.ENTRIES_FILE = 'entries.json'; }
-    static { this.FILE_SAVED_SOURCE = SaveSourceRegistry.registerSource('default.source', ( localizeWithPath(_moduleId, 0, "File Saved"))); }
+    static { this.FILE_SAVED_SOURCE = SaveSourceRegistry.registerSource('default.source', ( localize(8524, "File Saved"))); }
     static { this.SETTINGS = {
         MAX_ENTRIES: 'workbench.localHistory.maxFileEntries',
         MERGE_PERIOD: 'workbench.localHistory.mergeWindow'
@@ -379,8 +378,8 @@ class WorkingCopyHistoryModel {
 }
 let WorkingCopyHistoryService = class WorkingCopyHistoryService extends Disposable {
     static { WorkingCopyHistoryService_1 = this; }
-    static { this.FILE_MOVED_SOURCE = SaveSourceRegistry.registerSource('moved.source', ( localizeWithPath(_moduleId, 1, "File Moved"))); }
-    static { this.FILE_RENAMED_SOURCE = SaveSourceRegistry.registerSource('renamed.source', ( localizeWithPath(_moduleId, 2, "File Renamed"))); }
+    static { this.FILE_MOVED_SOURCE = SaveSourceRegistry.registerSource('moved.source', ( localize(8525, "File Moved"))); }
+    static { this.FILE_RENAMED_SOURCE = SaveSourceRegistry.registerSource('renamed.source', ( localize(8526, "File Renamed"))); }
     constructor(fileService, remoteAgentService, environmentService, uriIdentityService, labelService, logService, configurationService) {
         super();
         this.fileService = fileService;
@@ -597,7 +596,7 @@ let NativeWorkingCopyHistoryService = class NativeWorkingCopyHistoryService exte
     onWillShutdown(e) {
         this.storeAllScheduler.dispose();
         this.storeAllCts.dispose(true);
-        e.join(this.storeAll(e.token), { id: 'join.workingCopyHistory', label: ( localizeWithPath(_moduleId, 3, "Saving local history")) });
+        e.join(this.storeAll(e.token), { id: 'join.workingCopyHistory', label: ( localize(8527, "Saving local history")) });
     }
     onDidChangeModels() {
         if (!this.storeAllScheduler.isScheduled()) {

package/vscode/src/vs/workbench/services/workingCopy/common/workingCopyHistoryTracker.js

@@ -1,5 +1,5 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { localize } from 'vscode/vscode/vs/nls';
 import { Limiter, GlobalIdleValue } from 'vscode/vscode/vs/base/common/async';
 import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
@@ -20,7 +20,6 @@ import { FileOperation } from 'vscode/vscode/vs/platform/files/common/files';
 import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
 
 var WorkingCopyHistoryTracker_1;
-const _moduleId = "vs/workbench/services/workingCopy/common/workingCopyHistoryTracker";
 let WorkingCopyHistoryTracker = class WorkingCopyHistoryTracker extends Disposable {
     static { WorkingCopyHistoryTracker_1 = this; }
     static { this.SETTINGS = {
@@ -28,7 +27,7 @@ let WorkingCopyHistoryTracker = class WorkingCopyHistoryTracker extends Disposab
         SIZE_LIMIT: 'workbench.localHistory.maxFileSize',
         EXCLUDES: 'workbench.localHistory.exclude'
     }; }
-    static { this.UNDO_REDO_SAVE_SOURCE = SaveSourceRegistry.registerSource('undoRedo.source', ( localizeWithPath(_moduleId, 0, "Undo / Redo"))); }
+    static { this.UNDO_REDO_SAVE_SOURCE = SaveSourceRegistry.registerSource('undoRedo.source', ( localize(10832, "Undo / Redo"))); }
     constructor(workingCopyService, workingCopyHistoryService, uriIdentityService, pathService, configurationService, undoRedoService, contextService, fileService) {
         super();
         this.workingCopyService = workingCopyService;

package/workingCopy.js

@@ -1,5 +1,5 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
 import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
-import { BrowserWorkingCopyBackupService } from './vscode/src/vs/workbench/services/workingCopy/browser/workingCopyBackupService.js';
 import { IWorkingCopyBackupService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyBackup.service';
 import { WorkingCopyService } from './vscode/src/vs/workbench/services/workingCopy/common/workingCopyService.js';
 import { IWorkingCopyService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyService.service';
@@ -7,12 +7,33 @@ import { WorkingCopyEditorService } from './vscode/src/vs/workbench/services/wor
 import { IWorkingCopyEditorService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyEditorService.service';
 import { IWorkingCopyHistoryService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyHistory.service';
 import { BrowserWorkingCopyHistoryService } from './vscode/src/vs/workbench/services/workingCopy/browser/workingCopyHistoryService.js';
+import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace.service';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService.service';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
+import { joinPath } from 'vscode/vscode/vs/base/common/resources';
+import { WorkingCopyBackupService } from './vscode/src/vs/workbench/services/workingCopy/common/workingCopyBackupService.js';
 import getServiceOverride$1 from '@codingame/monaco-vscode-files-service-override';
 
-function getServiceOverride() {
+let BrowserWorkingCopyBackupService = class BrowserWorkingCopyBackupService extends WorkingCopyBackupService {
+    constructor(memory, contextService, environmentService, fileService, logService) {
+        super(memory ? undefined : joinPath(environmentService.userRoamingDataHome, 'Backups', contextService.getWorkspace().id), fileService, logService);
+    }
+};
+BrowserWorkingCopyBackupService = __decorate([
+    ( __param(1, IWorkspaceContextService)),
+    ( __param(2, IWorkbenchEnvironmentService)),
+    ( __param(3, IFileService)),
+    ( __param(4, ILogService))
+], BrowserWorkingCopyBackupService);
+function getServiceOverride({ storage = 'userData' } = {}) {
     return {
         ...getServiceOverride$1(),
-        [( IWorkingCopyBackupService.toString())]: new SyncDescriptor(BrowserWorkingCopyBackupService, [], false),
+        ...(storage != null
+            ? {
+                [( IWorkingCopyBackupService.toString())]: new SyncDescriptor(BrowserWorkingCopyBackupService, [storage === 'memory'], false)
+            }
+            : {}),
         [( IWorkingCopyService.toString())]: new SyncDescriptor(WorkingCopyService, [], false),
         [( IWorkingCopyEditorService.toString())]: new SyncDescriptor(WorkingCopyEditorService, [], false),
         [( IWorkingCopyHistoryService.toString())]: new SyncDescriptor(BrowserWorkingCopyHistoryService, [], false)

package/vscode/src/vs/workbench/services/workingCopy/browser/workingCopyBackupService.js

@@ -1,26 +0,0 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
-import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
-import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService.service';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
-import { WorkingCopyBackupService } from '../common/workingCopyBackupService.js';
-import 'vscode/vscode/vs/platform/instantiation/common/extensions';
-import 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { joinPath } from 'vscode/vscode/vs/base/common/resources';
-import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace.service';
-import { registerWorkbenchContribution2, WorkbenchPhase } from 'vscode/vscode/vs/workbench/common/contributions';
-import { BrowserWorkingCopyBackupTracker } from './workingCopyBackupTracker.js';
-
-let BrowserWorkingCopyBackupService = class BrowserWorkingCopyBackupService extends WorkingCopyBackupService {
-    constructor(contextService, environmentService, fileService, logService) {
-        super(joinPath(environmentService.userRoamingDataHome, 'Backups', contextService.getWorkspace().id), fileService, logService);
-    }
-};
-BrowserWorkingCopyBackupService = ( __decorate([
-    ( __param(0, IWorkspaceContextService)),
-    ( __param(1, IWorkbenchEnvironmentService)),
-    ( __param(2, IFileService)),
-    ( __param(3, ILogService))
-], BrowserWorkingCopyBackupService));
-registerWorkbenchContribution2(BrowserWorkingCopyBackupTracker.ID, BrowserWorkingCopyBackupTracker, WorkbenchPhase.BlockStartup);
-
-export { BrowserWorkingCopyBackupService };

package/vscode/src/vs/workbench/services/workingCopy/browser/workingCopyBackupTracker.js

@@ -1,45 +0,0 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
-import { IWorkingCopyBackupService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyBackup.service';
-import { IFilesConfigurationService } from 'vscode/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService.service';
-import { IWorkingCopyService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyService.service';
-import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
-import { WorkingCopyBackupTracker } from '../common/workingCopyBackupTracker.js';
-import { IWorkingCopyEditorService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyEditorService.service';
-import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
-import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
-
-let BrowserWorkingCopyBackupTracker = class BrowserWorkingCopyBackupTracker extends WorkingCopyBackupTracker {
-    static { this.ID = 'workbench.contrib.browserWorkingCopyBackupTracker'; }
-    constructor(workingCopyBackupService, filesConfigurationService, workingCopyService, lifecycleService, logService, workingCopyEditorService, editorService, editorGroupService) {
-        super(workingCopyBackupService, workingCopyService, logService, lifecycleService, filesConfigurationService, workingCopyEditorService, editorService, editorGroupService);
-    }
-    onFinalBeforeShutdown(reason) {
-        const modifiedWorkingCopies = this.workingCopyService.modifiedWorkingCopies;
-        if (!modifiedWorkingCopies.length) {
-            return false;
-        }
-        if (!this.filesConfigurationService.isHotExitEnabled) {
-            return true;
-        }
-        for (const modifiedWorkingCopy of modifiedWorkingCopies) {
-            if (!this.workingCopyBackupService.hasBackupSync(modifiedWorkingCopy, this.getContentVersion(modifiedWorkingCopy))) {
-                this.logService.warn('Unload veto: pending backups');
-                return true;
-            }
-        }
-        return false;
-    }
-};
-BrowserWorkingCopyBackupTracker = ( __decorate([
-    ( __param(0, IWorkingCopyBackupService)),
-    ( __param(1, IFilesConfigurationService)),
-    ( __param(2, IWorkingCopyService)),
-    ( __param(3, ILifecycleService)),
-    ( __param(4, ILogService)),
-    ( __param(5, IWorkingCopyEditorService)),
-    ( __param(6, IEditorService)),
-    ( __param(7, IEditorGroupsService))
-], BrowserWorkingCopyBackupTracker));
-
-export { BrowserWorkingCopyBackupTracker };

package/vscode/src/vs/workbench/services/workingCopy/common/workingCopyBackupTracker.js

@@ -1,258 +0,0 @@
-import { Disposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { WorkingCopyCapabilities } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopy';
-import { LifecyclePhase } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
-import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
-import { Promises } from 'vscode/vscode/vs/base/common/async';
-import { EditorsOrder } from 'vscode/vscode/vs/workbench/common/editor';
-
-class WorkingCopyBackupTracker extends Disposable {
-    constructor(workingCopyBackupService, workingCopyService, logService, lifecycleService, filesConfigurationService, workingCopyEditorService, editorService, editorGroupService) {
-        super();
-        this.workingCopyBackupService = workingCopyBackupService;
-        this.workingCopyService = workingCopyService;
-        this.logService = logService;
-        this.lifecycleService = lifecycleService;
-        this.filesConfigurationService = filesConfigurationService;
-        this.workingCopyEditorService = workingCopyEditorService;
-        this.editorService = editorService;
-        this.editorGroupService = editorGroupService;
-        this.mapWorkingCopyToContentVersion = ( new Map());
-        this.pendingBackupOperations = ( new Map());
-        this.suspended = false;
-        this.unrestoredBackups = ( new Set());
-        this.whenReady = this.resolveBackupsToRestore();
-        this._isReady = false;
-        for (const workingCopy of this.workingCopyService.modifiedWorkingCopies) {
-            this.onDidRegister(workingCopy);
-        }
-        this.registerListeners();
-    }
-    registerListeners() {
-        this._register(this.workingCopyService.onDidRegister(workingCopy => this.onDidRegister(workingCopy)));
-        this._register(this.workingCopyService.onDidUnregister(workingCopy => this.onDidUnregister(workingCopy)));
-        this._register(this.workingCopyService.onDidChangeDirty(workingCopy => this.onDidChangeDirty(workingCopy)));
-        this._register(this.workingCopyService.onDidChangeContent(workingCopy => this.onDidChangeContent(workingCopy)));
-        this._register(this.lifecycleService.onBeforeShutdown(event => event.finalVeto(() => this.onFinalBeforeShutdown(event.reason), 'veto.backups')));
-        this._register(this.lifecycleService.onWillShutdown(() => this.onWillShutdown()));
-        this._register(this.workingCopyEditorService.onDidRegisterHandler(handler => this.restoreBackups(handler)));
-    }
-    onWillShutdown() {
-        this.cancelBackupOperations();
-        this.suspendBackupOperations();
-    }
-    static { this.DEFAULT_BACKUP_SCHEDULE_DELAYS = {
-        ['default']: 1000,
-        ['delayed']: 2000
-    }; }
-    onDidRegister(workingCopy) {
-        if (this.suspended) {
-            this.logService.warn(`[backup tracker] suspended, ignoring register event`, ( workingCopy.resource.toString()), workingCopy.typeId);
-            return;
-        }
-        if (workingCopy.isModified()) {
-            this.scheduleBackup(workingCopy);
-        }
-    }
-    onDidUnregister(workingCopy) {
-        this.mapWorkingCopyToContentVersion.delete(workingCopy);
-        if (this.suspended) {
-            this.logService.warn(`[backup tracker] suspended, ignoring unregister event`, ( workingCopy.resource.toString()), workingCopy.typeId);
-            return;
-        }
-        this.discardBackup(workingCopy);
-    }
-    onDidChangeDirty(workingCopy) {
-        if (this.suspended) {
-            this.logService.warn(`[backup tracker] suspended, ignoring dirty change event`, ( workingCopy.resource.toString()), workingCopy.typeId);
-            return;
-        }
-        if (workingCopy.isDirty()) {
-            this.scheduleBackup(workingCopy);
-        }
-        else {
-            this.discardBackup(workingCopy);
-        }
-    }
-    onDidChangeContent(workingCopy) {
-        const contentVersionId = this.getContentVersion(workingCopy);
-        this.mapWorkingCopyToContentVersion.set(workingCopy, contentVersionId + 1);
-        if (this.suspended) {
-            this.logService.warn(`[backup tracker] suspended, ignoring content change event`, ( workingCopy.resource.toString()), workingCopy.typeId);
-            return;
-        }
-        if (workingCopy.isModified()) {
-            this.scheduleBackup(workingCopy);
-        }
-    }
-    scheduleBackup(workingCopy) {
-        this.cancelBackupOperation(workingCopy);
-        this.logService.trace(`[backup tracker] scheduling backup`, ( workingCopy.resource.toString()), workingCopy.typeId);
-        const workingCopyIdentifier = { resource: workingCopy.resource, typeId: workingCopy.typeId };
-        const cts = ( new CancellationTokenSource());
-        const handle = setTimeout(async () => {
-            if (cts.token.isCancellationRequested) {
-                return;
-            }
-            if (workingCopy.isModified()) {
-                this.logService.trace(`[backup tracker] creating backup`, ( workingCopy.resource.toString()), workingCopy.typeId);
-                try {
-                    const backup = await workingCopy.backup(cts.token);
-                    if (cts.token.isCancellationRequested) {
-                        return;
-                    }
-                    if (workingCopy.isModified()) {
-                        this.logService.trace(`[backup tracker] storing backup`, ( workingCopy.resource.toString()), workingCopy.typeId);
-                        await this.workingCopyBackupService.backup(workingCopy, backup.content, this.getContentVersion(workingCopy), backup.meta, cts.token);
-                    }
-                }
-                catch (error) {
-                    this.logService.error(error);
-                }
-            }
-            if (!cts.token.isCancellationRequested) {
-                this.doClearPendingBackupOperation(workingCopyIdentifier);
-            }
-        }, this.getBackupScheduleDelay(workingCopy));
-        this.pendingBackupOperations.set(workingCopyIdentifier, {
-            cancel: () => {
-                this.logService.trace(`[backup tracker] clearing pending backup creation`, ( workingCopy.resource.toString()), workingCopy.typeId);
-                cts.cancel();
-            },
-            disposable: toDisposable(() => {
-                cts.dispose();
-                clearTimeout(handle);
-            })
-        });
-    }
-    getBackupScheduleDelay(workingCopy) {
-        if (typeof workingCopy.backupDelay === 'number') {
-            return workingCopy.backupDelay;
-        }
-        let backupScheduleDelay;
-        if (workingCopy.capabilities & WorkingCopyCapabilities.Untitled) {
-            backupScheduleDelay = 'default';
-        }
-        else {
-            backupScheduleDelay = this.filesConfigurationService.hasShortAutoSaveDelay(workingCopy.resource) ? 'delayed' : 'default';
-        }
-        return WorkingCopyBackupTracker.DEFAULT_BACKUP_SCHEDULE_DELAYS[backupScheduleDelay];
-    }
-    getContentVersion(workingCopy) {
-        return this.mapWorkingCopyToContentVersion.get(workingCopy) || 0;
-    }
-    discardBackup(workingCopy) {
-        this.cancelBackupOperation(workingCopy);
-        const workingCopyIdentifier = { resource: workingCopy.resource, typeId: workingCopy.typeId };
-        const cts = ( new CancellationTokenSource());
-        this.doDiscardBackup(workingCopyIdentifier, cts);
-        this.pendingBackupOperations.set(workingCopyIdentifier, {
-            cancel: () => {
-                this.logService.trace(`[backup tracker] clearing pending backup discard`, ( workingCopy.resource.toString()), workingCopy.typeId);
-                cts.cancel();
-            },
-            disposable: cts
-        });
-    }
-    async doDiscardBackup(workingCopyIdentifier, cts) {
-        this.logService.trace(`[backup tracker] discarding backup`, ( workingCopyIdentifier.resource.toString()), workingCopyIdentifier.typeId);
-        try {
-            await this.workingCopyBackupService.discardBackup(workingCopyIdentifier, cts.token);
-        }
-        catch (error) {
-            this.logService.error(error);
-        }
-        if (!cts.token.isCancellationRequested) {
-            this.doClearPendingBackupOperation(workingCopyIdentifier);
-        }
-    }
-    cancelBackupOperation(workingCopy) {
-        let workingCopyIdentifier = undefined;
-        for (const [identifier] of this.pendingBackupOperations) {
-            if (( identifier.resource.toString()) === ( workingCopy.resource.toString()) && identifier.typeId === workingCopy.typeId) {
-                workingCopyIdentifier = identifier;
-                break;
-            }
-        }
-        if (workingCopyIdentifier) {
-            this.doClearPendingBackupOperation(workingCopyIdentifier, { cancel: true });
-        }
-    }
-    doClearPendingBackupOperation(workingCopyIdentifier, options) {
-        const pendingBackupOperation = this.pendingBackupOperations.get(workingCopyIdentifier);
-        if (!pendingBackupOperation) {
-            return;
-        }
-        if (options?.cancel) {
-            pendingBackupOperation.cancel();
-        }
-        pendingBackupOperation.disposable.dispose();
-        this.pendingBackupOperations.delete(workingCopyIdentifier);
-    }
-    cancelBackupOperations() {
-        for (const [, operation] of this.pendingBackupOperations) {
-            operation.cancel();
-            operation.disposable.dispose();
-        }
-        this.pendingBackupOperations.clear();
-    }
-    suspendBackupOperations() {
-        this.suspended = true;
-        return { resume: () => this.suspended = false };
-    }
-    get isReady() { return this._isReady; }
-    async resolveBackupsToRestore() {
-        await this.lifecycleService.when(LifecyclePhase.Restored);
-        for (const backup of await this.workingCopyBackupService.getBackups()) {
-            this.unrestoredBackups.add(backup);
-        }
-        this._isReady = true;
-    }
-    async restoreBackups(handler) {
-        await this.whenReady;
-        const openedEditorsForBackups = ( new Set());
-        const nonOpenedEditorsForBackups = ( new Set());
-        const restoredBackups = ( new Set());
-        for (const unrestoredBackup of this.unrestoredBackups) {
-            const canHandleUnrestoredBackup = await handler.handles(unrestoredBackup);
-            if (!canHandleUnrestoredBackup) {
-                continue;
-            }
-            let hasOpenedEditorForBackup = false;
-            for (const { editor } of this.editorService.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)) {
-                const isUnrestoredBackupOpened = handler.isOpen(unrestoredBackup, editor);
-                if (isUnrestoredBackupOpened) {
-                    openedEditorsForBackups.add(editor);
-                    hasOpenedEditorForBackup = true;
-                }
-            }
-            if (!hasOpenedEditorForBackup) {
-                nonOpenedEditorsForBackups.add(await handler.createEditor(unrestoredBackup));
-            }
-            restoredBackups.add(unrestoredBackup);
-        }
-        if (nonOpenedEditorsForBackups.size > 0) {
-            await this.editorGroupService.activeGroup.openEditors(( [...nonOpenedEditorsForBackups].map(nonOpenedEditorForBackup => ({
-                editor: nonOpenedEditorForBackup,
-                options: {
-                    pinned: true,
-                    preserveFocus: true,
-                    inactive: true
-                }
-            }))));
-            for (const nonOpenedEditorForBackup of nonOpenedEditorsForBackups) {
-                openedEditorsForBackups.add(nonOpenedEditorForBackup);
-            }
-        }
-        await Promises.settled(( [...openedEditorsForBackups].map(async (openedEditorForBackup) => {
-            if (this.editorService.isVisible(openedEditorForBackup)) {
-                return;
-            }
-            return openedEditorForBackup.resolve();
-        })));
-        for (const restoredBackup of restoredBackups) {
-            this.unrestoredBackups.delete(restoredBackup);
-        }
-    }
-}
-
-export { WorkingCopyBackupTracker };