@codingame/monaco-vscode-working-copy-service-override 18.1.2 → 18.1.3

package/index.js

@@ -12,29 +12,27 @@ import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs
 import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
 import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
-import { joinPath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import { WorkingCopyBackupService } from './vscode/src/vs/workbench/services/workingCopy/common/workingCopyBackupService.js';
+import { BrowserWorkingCopyBackupService } from './vscode/src/vs/workbench/services/workingCopy/browser/workingCopyBackupService.js';
 import getServiceOverride$1 from '@codingame/monaco-vscode-files-service-override';
 
-let BrowserWorkingCopyBackupService = class BrowserWorkingCopyBackupService extends WorkingCopyBackupService {
-    constructor(memory, contextService, environmentService, fileService, logService) {
-        super(memory
-            ? undefined
-            : joinPath(environmentService.userRoamingDataHome, 'Backups', contextService.getWorkspace().id), fileService, logService);
+let MemoryWorkingCopyBackupService = class MemoryWorkingCopyBackupService extends WorkingCopyBackupService {
+    constructor(contextService, environmentService, fileService, logService) {
+        super(undefined, fileService, logService);
     }
 };
-BrowserWorkingCopyBackupService = __decorate([
-    __param(1, IWorkspaceContextService),
-    __param(2, IWorkbenchEnvironmentService),
-    __param(3, IFileService),
-    __param(4, ILogService)
-], BrowserWorkingCopyBackupService);
+MemoryWorkingCopyBackupService = __decorate([
+    __param(0, IWorkspaceContextService),
+    __param(1, IWorkbenchEnvironmentService),
+    __param(2, IFileService),
+    __param(3, ILogService)
+], MemoryWorkingCopyBackupService);
 function getServiceOverride({ storage = 'userData' } = {}) {
     return {
         ...getServiceOverride$1(),
         ...(storage != null
             ? {
-                [IWorkingCopyBackupService.toString()]: new SyncDescriptor(BrowserWorkingCopyBackupService, [storage === 'memory'], false)
+                [IWorkingCopyBackupService.toString()]: new SyncDescriptor(storage === 'memory' ? MemoryWorkingCopyBackupService : BrowserWorkingCopyBackupService)
             }
             : {}),
         [IWorkingCopyService.toString()]: new SyncDescriptor(WorkingCopyService, [], false),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-working-copy-service-override",
-  "version": "18.1.2",
+  "version": "18.1.3",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - working-copy service-override",
   "keywords": [],
@@ -15,10 +15,10 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-a4683c2b-a0d2-5112-96ba-eedc605346d2-common": "18.1.2",
-    "@codingame/monaco-vscode-api": "18.1.2",
-    "@codingame/monaco-vscode-bba55be6-41a2-50cd-a3cc-8bafa35bfa89-common": "18.1.2",
-    "@codingame/monaco-vscode-files-service-override": "18.1.2"
+    "@codingame/monaco-vscode-a4683c2b-a0d2-5112-96ba-eedc605346d2-common": "18.1.3",
+    "@codingame/monaco-vscode-api": "18.1.3",
+    "@codingame/monaco-vscode-bba55be6-41a2-50cd-a3cc-8bafa35bfa89-common": "18.1.3",
+    "@codingame/monaco-vscode-files-service-override": "18.1.3"
   },
   "main": "index.js",
   "module": "index.js",

package/vscode/src/vs/workbench/services/workingCopy/browser/workingCopyBackupService.d.ts

@@ -0,0 +1,8 @@
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { IWorkbenchEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { WorkingCopyBackupService } from "../common/workingCopyBackupService.js";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+export declare class BrowserWorkingCopyBackupService extends WorkingCopyBackupService {
+    constructor(contextService: IWorkspaceContextService, environmentService: IWorkbenchEnvironmentService, fileService: IFileService, logService: ILogService);
+}

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

@@ -0,0 +1,27 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { WorkingCopyBackupService } from '../common/workingCopyBackupService.js';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { joinPath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/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.d.ts

@@ -0,0 +1,16 @@
+import { IWorkingCopyBackupService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/workingCopy/common/workingCopyBackup.service";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { IFilesConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService.service";
+import { IWorkingCopyService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/workingCopy/common/workingCopyService.service";
+import { ShutdownReason } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle";
+import { ILifecycleService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { WorkingCopyBackupTracker } from "../common/workingCopyBackupTracker.js";
+import { IWorkingCopyEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/workingCopy/common/workingCopyEditorService.service";
+import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IEditorGroupsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service";
+export declare class BrowserWorkingCopyBackupTracker extends WorkingCopyBackupTracker implements IWorkbenchContribution {
+    static readonly ID = "workbench.contrib.browserWorkingCopyBackupTracker";
+    constructor(workingCopyBackupService: IWorkingCopyBackupService, filesConfigurationService: IFilesConfigurationService, workingCopyService: IWorkingCopyService, lifecycleService: ILifecycleService, logService: ILogService, workingCopyEditorService: IWorkingCopyEditorService, editorService: IEditorService, editorGroupService: IEditorGroupsService);
+    protected onFinalBeforeShutdown(reason: ShutdownReason): boolean;
+}

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

@@ -0,0 +1,46 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { IWorkingCopyBackupService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/workingCopy/common/workingCopyBackup.service';
+import { IFilesConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService.service';
+import { IWorkingCopyService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/workingCopy/common/workingCopyService.service';
+import { ILifecycleService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { WorkingCopyBackupTracker } from '../common/workingCopyBackupTracker.js';
+import { IWorkingCopyEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/workingCopy/common/workingCopyEditorService.service';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { IEditorGroupsService } from '@codingame/monaco-vscode-api/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.d.ts

@@ -0,0 +1,54 @@
+import { IWorkingCopyBackupService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/workingCopy/common/workingCopyBackup.service";
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IWorkingCopyService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/workingCopy/common/workingCopyService.service";
+import { IWorkingCopy, IWorkingCopyIdentifier } from "@codingame/monaco-vscode-a4683c2b-a0d2-5112-96ba-eedc605346d2-common/vscode/vs/workbench/services/workingCopy/common/workingCopy";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { ShutdownReason } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle";
+import { ILifecycleService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service";
+import { IFilesConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService.service";
+import { IWorkingCopyEditorHandler } from "./workingCopyEditorService.js";
+import { IWorkingCopyEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/workingCopy/common/workingCopyEditorService.service";
+import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IEditorGroupsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service";
+export declare abstract class WorkingCopyBackupTracker extends Disposable {
+    protected readonly workingCopyBackupService: IWorkingCopyBackupService;
+    protected readonly workingCopyService: IWorkingCopyService;
+    protected readonly logService: ILogService;
+    private readonly lifecycleService;
+    protected readonly filesConfigurationService: IFilesConfigurationService;
+    private readonly workingCopyEditorService;
+    protected readonly editorService: IEditorService;
+    private readonly editorGroupService;
+    constructor(workingCopyBackupService: IWorkingCopyBackupService, workingCopyService: IWorkingCopyService, logService: ILogService, lifecycleService: ILifecycleService, filesConfigurationService: IFilesConfigurationService, workingCopyEditorService: IWorkingCopyEditorService, editorService: IEditorService, editorGroupService: IEditorGroupsService);
+    private registerListeners;
+    protected abstract onFinalBeforeShutdown(reason: ShutdownReason): boolean | Promise<boolean>;
+    private onWillShutdown;
+    private static readonly DEFAULT_BACKUP_SCHEDULE_DELAYS;
+    private readonly mapWorkingCopyToContentVersion;
+    protected readonly pendingBackupOperations: Map<IWorkingCopyIdentifier, {
+        disposable: IDisposable;
+        cancel: () => void;
+    }>;
+    private suspended;
+    private onDidRegister;
+    private onDidUnregister;
+    private onDidChangeDirty;
+    private onDidChangeContent;
+    private scheduleBackup;
+    protected getBackupScheduleDelay(workingCopy: IWorkingCopy): number;
+    protected getContentVersion(workingCopy: IWorkingCopy): number;
+    private discardBackup;
+    private doDiscardBackup;
+    private cancelBackupOperation;
+    private doClearPendingBackupOperation;
+    protected cancelBackupOperations(): void;
+    protected suspendBackupOperations(): {
+        resume: () => void;
+    };
+    protected readonly unrestoredBackups: Set<IWorkingCopyIdentifier>;
+    protected readonly whenReady: Promise<void>;
+    private _isReady;
+    protected get isReady(): boolean;
+    private resolveBackupsToRestore;
+    protected restoreBackups(handler: IWorkingCopyEditorHandler): Promise<void>;
+}

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

@@ -0,0 +1,259 @@
+
+import { Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { WorkingCopyCapabilities } from '@codingame/monaco-vscode-a4683c2b-a0d2-5112-96ba-eedc605346d2-common/vscode/vs/workbench/services/workingCopy/common/workingCopy';
+import { LifecyclePhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Promises } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { EditorsOrder } from '@codingame/monaco-vscode-api/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._isReady = false;
+        this.whenReady = this.resolveBackupsToRestore();
+        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 };