@codingame/monaco-vscode-working-copy-service-override 1.83.13

package/external/tslib/tslib.es6.js

@@ -0,0 +1,11 @@
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+export { __decorate, __param };

package/index.d.ts

@@ -0,0 +1 @@
+export { default } from './workingCopy.js';

package/index.js

@@ -0,0 +1 @@
+export { default } from './workingCopy.js';

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@codingame/monaco-vscode-working-copy-service-override",
+  "version": "1.83.13",
+  "keywords": [],
+  "author": {
+    "name": "CodinGame",
+    "url": "http://www.codingame.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/CodinGame/monaco-vscode-api.git"
+  },
+  "type": "module",
+  "private": false,
+  "description": "VSCode public API plugged on the monaco editor - working-copy service-override",
+  "main": "index.js",
+  "module": "index.js",
+  "types": "index.d.ts",
+  "dependencies": {
+    "vscode": "npm:@codingame/monaco-vscode-api@1.83.13",
+    "monaco-editor": "0.44.0",
+    "@codingame/monaco-vscode-files-service-override": "1.83.13"
+  }
+}

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

@@ -0,0 +1,25 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { WorkingCopyBackupService } from '../common/workingCopyBackupService.js';
+import { joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } 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));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(BrowserWorkingCopyBackupTracker, 1 );
+
+export { BrowserWorkingCopyBackupService };

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

@@ -0,0 +1,44 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { IWorkingCopyBackupService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyBackup';
+import { IFilesConfigurationService } from 'vscode/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService';
+import { IWorkingCopyService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyService';
+import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { WorkingCopyBackupTracker } from '../common/workingCopyBackupTracker.js';
+import { IWorkingCopyEditorService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyEditorService';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
+
+let BrowserWorkingCopyBackupTracker = class BrowserWorkingCopyBackupTracker extends WorkingCopyBackupTracker {
+    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/workingCopyBackupService.js

@@ -0,0 +1,454 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { deepClone, equals } from 'monaco-editor/esm/vs/base/common/objects.js';
+import { ResourceQueue, Promises } from 'monaco-editor/esm/vs/base/common/async.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { isReadableStream, peekStream } from 'monaco-editor/esm/vs/base/common/stream.js';
+import { VSBuffer, prefixedBufferStream, prefixedBufferReadable, bufferToStream, streamToBuffer, readableToBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { hash } from 'monaco-editor/esm/vs/base/common/hash.js';
+import { isEmptyObject } from 'monaco-editor/esm/vs/base/common/types.js';
+import { NO_TYPE_ID } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopy';
+
+var WorkingCopyBackupServiceImpl_1;
+class WorkingCopyBackupsModel {
+    static async create(backupRoot, fileService) {
+        const model = ( new WorkingCopyBackupsModel(backupRoot, fileService));
+        await model.resolve();
+        return model;
+    }
+    constructor(backupRoot, fileService) {
+        this.backupRoot = backupRoot;
+        this.fileService = fileService;
+        this.cache = ( new ResourceMap());
+    }
+    async resolve() {
+        try {
+            const backupRootStat = await this.fileService.resolve(this.backupRoot);
+            if (backupRootStat.children) {
+                await Promises.settled(( backupRootStat.children
+                    .filter(child => child.isDirectory)
+                    .map(async (backupSchemaFolder) => {
+                    const backupSchemaFolderStat = await this.fileService.resolve(backupSchemaFolder.resource);
+                    if (backupSchemaFolderStat.children) {
+                        for (const backupForSchema of backupSchemaFolderStat.children) {
+                            if (!backupForSchema.isDirectory) {
+                                this.add(backupForSchema.resource);
+                            }
+                        }
+                    }
+                })));
+            }
+        }
+        catch (error) {
+        }
+    }
+    add(resource, versionId = 0, meta) {
+        this.cache.set(resource, {
+            versionId,
+            meta: deepClone(meta)
+        });
+    }
+    update(resource, meta) {
+        const entry = this.cache.get(resource);
+        if (entry) {
+            entry.meta = deepClone(meta);
+        }
+    }
+    count() {
+        return this.cache.size;
+    }
+    has(resource, versionId, meta) {
+        const entry = this.cache.get(resource);
+        if (!entry) {
+            return false;
+        }
+        if (typeof versionId === 'number' && versionId !== entry.versionId) {
+            return false;
+        }
+        if (meta && !equals(meta, entry.meta)) {
+            return false;
+        }
+        return true;
+    }
+    get() {
+        return Array.from(( this.cache.keys()));
+    }
+    remove(resource) {
+        this.cache.delete(resource);
+    }
+    clear() {
+        this.cache.clear();
+    }
+}
+let WorkingCopyBackupService = class WorkingCopyBackupService extends Disposable {
+    constructor(backupWorkspaceHome, fileService, logService) {
+        super();
+        this.fileService = fileService;
+        this.logService = logService;
+        this.impl = this._register(this.initialize(backupWorkspaceHome));
+    }
+    initialize(backupWorkspaceHome) {
+        if (backupWorkspaceHome) {
+            return ( new WorkingCopyBackupServiceImpl(backupWorkspaceHome, this.fileService, this.logService));
+        }
+        return ( new InMemoryWorkingCopyBackupService());
+    }
+    reinitialize(backupWorkspaceHome) {
+        if (this.impl instanceof WorkingCopyBackupServiceImpl) {
+            if (backupWorkspaceHome) {
+                this.impl.initialize(backupWorkspaceHome);
+            }
+            else {
+                this.impl = ( new InMemoryWorkingCopyBackupService());
+            }
+        }
+    }
+    hasBackups() {
+        return this.impl.hasBackups();
+    }
+    hasBackupSync(identifier, versionId, meta) {
+        return this.impl.hasBackupSync(identifier, versionId, meta);
+    }
+    backup(identifier, content, versionId, meta, token) {
+        return this.impl.backup(identifier, content, versionId, meta, token);
+    }
+    discardBackup(identifier, token) {
+        return this.impl.discardBackup(identifier, token);
+    }
+    discardBackups(filter) {
+        return this.impl.discardBackups(filter);
+    }
+    getBackups() {
+        return this.impl.getBackups();
+    }
+    resolve(identifier) {
+        return this.impl.resolve(identifier);
+    }
+    toBackupResource(identifier) {
+        return this.impl.toBackupResource(identifier);
+    }
+    joinBackups() {
+        return this.impl.joinBackups();
+    }
+};
+WorkingCopyBackupService = ( __decorate([
+    ( __param(1, IFileService)),
+    ( __param(2, ILogService))
+], WorkingCopyBackupService));
+let WorkingCopyBackupServiceImpl = class WorkingCopyBackupServiceImpl extends Disposable {
+    static { WorkingCopyBackupServiceImpl_1 = this; }
+    static { this.PREAMBLE_END_MARKER = '\n'; }
+    static { this.PREAMBLE_END_MARKER_CHARCODE = '\n'.charCodeAt(0); }
+    static { this.PREAMBLE_META_SEPARATOR = ' '; }
+    static { this.PREAMBLE_MAX_LENGTH = 10000; }
+    constructor(backupWorkspaceHome, fileService, logService) {
+        super();
+        this.backupWorkspaceHome = backupWorkspaceHome;
+        this.fileService = fileService;
+        this.logService = logService;
+        this.ioOperationQueues = this._register(( new ResourceQueue()));
+        this.model = undefined;
+        this.initialize(backupWorkspaceHome);
+    }
+    initialize(backupWorkspaceResource) {
+        this.backupWorkspaceHome = backupWorkspaceResource;
+        this.ready = this.doInitialize();
+    }
+    async doInitialize() {
+        this.model = await WorkingCopyBackupsModel.create(this.backupWorkspaceHome, this.fileService);
+        return this.model;
+    }
+    async hasBackups() {
+        const model = await this.ready;
+        await this.joinBackups();
+        return model.count() > 0;
+    }
+    hasBackupSync(identifier, versionId, meta) {
+        if (!this.model) {
+            return false;
+        }
+        const backupResource = this.toBackupResource(identifier);
+        return ( this.model.has(backupResource, versionId, meta));
+    }
+    async backup(identifier, content, versionId, meta, token) {
+        const model = await this.ready;
+        if (token?.isCancellationRequested) {
+            return;
+        }
+        const backupResource = this.toBackupResource(identifier);
+        if (( model.has(backupResource, versionId, meta))) {
+            return;
+        }
+        return this.ioOperationQueues.queueFor(backupResource).queue(async () => {
+            if (token?.isCancellationRequested) {
+                return;
+            }
+            if (( model.has(backupResource, versionId, meta))) {
+                return;
+            }
+            let preamble = this.createPreamble(identifier, meta);
+            if (preamble.length >= WorkingCopyBackupServiceImpl_1.PREAMBLE_MAX_LENGTH) {
+                preamble = this.createPreamble(identifier);
+            }
+            const preambleBuffer = VSBuffer.fromString(preamble);
+            let backupBuffer;
+            if (isReadableStream(content)) {
+                backupBuffer = prefixedBufferStream(preambleBuffer, content);
+            }
+            else if (content) {
+                backupBuffer = prefixedBufferReadable(preambleBuffer, content);
+            }
+            else {
+                backupBuffer = VSBuffer.concat([preambleBuffer, VSBuffer.fromString('')]);
+            }
+            await this.fileService.writeFile(backupResource, backupBuffer);
+            model.add(backupResource, versionId, meta);
+        });
+    }
+    createPreamble(identifier, meta) {
+        return `${( identifier.resource.toString())}${WorkingCopyBackupServiceImpl_1.PREAMBLE_META_SEPARATOR}${JSON.stringify({ ...meta, typeId: identifier.typeId })}${WorkingCopyBackupServiceImpl_1.PREAMBLE_END_MARKER}`;
+    }
+    async discardBackups(filter) {
+        const model = await this.ready;
+        const except = filter?.except;
+        if (Array.isArray(except) && except.length > 0) {
+            const exceptMap = ( new ResourceMap());
+            for (const exceptWorkingCopy of except) {
+                exceptMap.set(this.toBackupResource(exceptWorkingCopy), true);
+            }
+            await Promises.settled(( model.get().map(async (backupResource) => {
+                if (!( exceptMap.has(backupResource))) {
+                    await this.doDiscardBackup(backupResource);
+                }
+            })));
+        }
+        else {
+            await this.deleteIgnoreFileNotFound(this.backupWorkspaceHome);
+            model.clear();
+        }
+    }
+    discardBackup(identifier, token) {
+        const backupResource = this.toBackupResource(identifier);
+        return this.doDiscardBackup(backupResource, token);
+    }
+    async doDiscardBackup(backupResource, token) {
+        const model = await this.ready;
+        if (token?.isCancellationRequested) {
+            return;
+        }
+        return this.ioOperationQueues.queueFor(backupResource).queue(async () => {
+            if (token?.isCancellationRequested) {
+                return;
+            }
+            await this.deleteIgnoreFileNotFound(backupResource);
+            model.remove(backupResource);
+        });
+    }
+    async deleteIgnoreFileNotFound(backupResource) {
+        try {
+            await this.fileService.del(backupResource, { recursive: true });
+        }
+        catch (error) {
+            if (error.fileOperationResult !== 1 ) {
+                throw error;
+            }
+        }
+    }
+    async getBackups() {
+        const model = await this.ready;
+        await this.joinBackups();
+        const backups = await Promise.all(( model.get().map(backupResource => this.resolveIdentifier(backupResource, model))));
+        return coalesce(backups);
+    }
+    async resolveIdentifier(backupResource, model) {
+        let res = undefined;
+        await this.ioOperationQueues.queueFor(backupResource).queue(async () => {
+            if (!( model.has(backupResource))) {
+                return;
+            }
+            const backupPreamble = await this.readToMatchingString(backupResource, WorkingCopyBackupServiceImpl_1.PREAMBLE_END_MARKER, WorkingCopyBackupServiceImpl_1.PREAMBLE_MAX_LENGTH);
+            if (!backupPreamble) {
+                return;
+            }
+            const metaStartIndex = backupPreamble.indexOf(WorkingCopyBackupServiceImpl_1.PREAMBLE_META_SEPARATOR);
+            let resourcePreamble;
+            let metaPreamble;
+            if (metaStartIndex > 0) {
+                resourcePreamble = backupPreamble.substring(0, metaStartIndex);
+                metaPreamble = backupPreamble.substr(metaStartIndex + 1);
+            }
+            else {
+                resourcePreamble = backupPreamble;
+                metaPreamble = undefined;
+            }
+            const { typeId, meta } = this.parsePreambleMeta(metaPreamble);
+            model.update(backupResource, meta);
+            res = {
+                typeId: typeId ?? NO_TYPE_ID,
+                resource: ( URI.parse(resourcePreamble))
+            };
+        });
+        return res;
+    }
+    async readToMatchingString(backupResource, matchingString, maximumBytesToRead) {
+        const contents = ( (await this.fileService.readFile(backupResource, { length: maximumBytesToRead })).value.toString());
+        const matchingStringIndex = contents.indexOf(matchingString);
+        if (matchingStringIndex >= 0) {
+            return contents.substr(0, matchingStringIndex);
+        }
+        return undefined;
+    }
+    async resolve(identifier) {
+        const backupResource = this.toBackupResource(identifier);
+        const model = await this.ready;
+        let res = undefined;
+        await this.ioOperationQueues.queueFor(backupResource).queue(async () => {
+            if (!( model.has(backupResource))) {
+                return;
+            }
+            const backupStream = await this.fileService.readFileStream(backupResource);
+            const peekedBackupStream = await peekStream(backupStream.value, 1);
+            const firstBackupChunk = VSBuffer.concat(peekedBackupStream.buffer);
+            const preambleEndIndex = firstBackupChunk.buffer.indexOf(WorkingCopyBackupServiceImpl_1.PREAMBLE_END_MARKER_CHARCODE);
+            if (preambleEndIndex === -1) {
+                this.logService.trace(`Backup: Could not find meta end marker in ${backupResource}. The file is probably corrupt (filesize: ${backupStream.size}).`);
+                return undefined;
+            }
+            const preambelRaw = ( firstBackupChunk.slice(0, preambleEndIndex).toString());
+            let meta;
+            const metaStartIndex = preambelRaw.indexOf(WorkingCopyBackupServiceImpl_1.PREAMBLE_META_SEPARATOR);
+            if (metaStartIndex !== -1) {
+                meta = this.parsePreambleMeta(preambelRaw.substr(metaStartIndex + 1)).meta;
+            }
+            model.update(backupResource, meta);
+            const firstBackupChunkWithoutPreamble = firstBackupChunk.slice(preambleEndIndex + 1);
+            let value;
+            if (peekedBackupStream.ended) {
+                value = bufferToStream(firstBackupChunkWithoutPreamble);
+            }
+            else {
+                value = prefixedBufferStream(firstBackupChunkWithoutPreamble, peekedBackupStream.stream);
+            }
+            res = { value, meta };
+        });
+        return res;
+    }
+    parsePreambleMeta(preambleMetaRaw) {
+        let typeId = undefined;
+        let meta = undefined;
+        if (preambleMetaRaw) {
+            try {
+                meta = JSON.parse(preambleMetaRaw);
+                typeId = meta?.typeId;
+                if (typeof meta?.typeId === 'string') {
+                    delete meta.typeId;
+                    if (isEmptyObject(meta)) {
+                        meta = undefined;
+                    }
+                }
+            }
+            catch (error) {
+            }
+        }
+        return { typeId, meta };
+    }
+    toBackupResource(identifier) {
+        return joinPath(this.backupWorkspaceHome, identifier.resource.scheme, hashIdentifier(identifier));
+    }
+    joinBackups() {
+        return this.ioOperationQueues.whenDrained();
+    }
+};
+WorkingCopyBackupServiceImpl = WorkingCopyBackupServiceImpl_1 = ( __decorate([
+    ( __param(1, IFileService)),
+    ( __param(2, ILogService))
+], WorkingCopyBackupServiceImpl));
+class InMemoryWorkingCopyBackupService extends Disposable {
+    constructor() {
+        super();
+        this.backups = ( new ResourceMap());
+    }
+    async hasBackups() {
+        return this.backups.size > 0;
+    }
+    hasBackupSync(identifier, versionId) {
+        const backupResource = this.toBackupResource(identifier);
+        return ( this.backups.has(backupResource));
+    }
+    async backup(identifier, content, versionId, meta, token) {
+        const backupResource = this.toBackupResource(identifier);
+        this.backups.set(backupResource, {
+            typeId: identifier.typeId,
+            content: content instanceof VSBuffer ? content : content ? isReadableStream(content) ? await streamToBuffer(content) : readableToBuffer(content) : VSBuffer.fromString(''),
+            meta
+        });
+    }
+    async resolve(identifier) {
+        const backupResource = this.toBackupResource(identifier);
+        const backup = this.backups.get(backupResource);
+        if (backup) {
+            return { value: bufferToStream(backup.content), meta: backup.meta };
+        }
+        return undefined;
+    }
+    async getBackups() {
+        return ( Array.from(this.backups.entries()).map(([resource, backup]) => ({ typeId: backup.typeId, resource })));
+    }
+    async discardBackup(identifier) {
+        this.backups.delete(this.toBackupResource(identifier));
+    }
+    async discardBackups(filter) {
+        const except = filter?.except;
+        if (Array.isArray(except) && except.length > 0) {
+            const exceptMap = ( new ResourceMap());
+            for (const exceptWorkingCopy of except) {
+                exceptMap.set(this.toBackupResource(exceptWorkingCopy), true);
+            }
+            for (const backup of await this.getBackups()) {
+                if (!( exceptMap.has(this.toBackupResource(backup)))) {
+                    await this.discardBackup(backup);
+                }
+            }
+        }
+        else {
+            this.backups.clear();
+        }
+    }
+    toBackupResource(identifier) {
+        return ( URI.from({ scheme: Schemas.inMemory, path: hashIdentifier(identifier) }));
+    }
+    async joinBackups() {
+        return;
+    }
+}
+function hashIdentifier(identifier) {
+    let resource;
+    if (identifier.typeId.length > 0) {
+        const typeIdHash = hashString(identifier.typeId);
+        if (identifier.resource.path) {
+            resource = joinPath(identifier.resource, typeIdHash);
+        }
+        else {
+            resource = identifier.resource.with({ path: typeIdHash });
+        }
+    }
+    else {
+        resource = identifier.resource;
+    }
+    return hashPath(resource);
+}
+function hashPath(resource) {
+    const str = resource.scheme === Schemas.file || resource.scheme === Schemas.untitled ? resource.fsPath : ( resource.toString());
+    return hashString(str);
+}
+function hashString(str) {
+    return ( hash(str).toString(16));
+}
+
+export { InMemoryWorkingCopyBackupService, WorkingCopyBackupService, WorkingCopyBackupsModel, hashIdentifier };

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

@@ -0,0 +1,255 @@
+import { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { Promises } from 'monaco-editor/esm/vs/base/common/async.js';
+
+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 = {
+        [0 ]: 1000,
+        [3 ]: 1000,
+        [4 ]: 1000,
+        [1 ]: 2000,
+        [2 ]: 1000
+    }; }
+    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 autoSaveMode = this.filesConfigurationService.getAutoSaveMode();
+        if (workingCopy.capabilities & 2 ) {
+            autoSaveMode = 0 ;
+        }
+        return WorkingCopyBackupTracker.DEFAULT_BACKUP_SCHEDULE_DELAYS[autoSaveMode];
+    }
+    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(3 );
+        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(0 )) {
+                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 };

package/workingCopy.d.ts

@@ -0,0 +1,5 @@
+import { IEditorOverrideServices } from 'vscode/vscode/vs/editor/standalone/browser/standaloneServices';
+
+declare function getServiceOverride(): IEditorOverrideServices;
+
+export { getServiceOverride as default };

package/workingCopy.js

@@ -0,0 +1,13 @@
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { BrowserWorkingCopyBackupService } from './vscode/src/vs/workbench/services/workingCopy/browser/workingCopyBackupService.js';
+import { IWorkingCopyBackupService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyBackup';
+import getServiceOverride$1 from '@codingame/monaco-vscode-files-service-override';
+
+function getServiceOverride() {
+    return {
+        ...getServiceOverride$1(),
+        [( IWorkingCopyBackupService.toString())]: new SyncDescriptor(BrowserWorkingCopyBackupService, [], false)
+    };
+}
+
+export { getServiceOverride as default };