@codingame/monaco-vscode-working-copy-service-override 1.85.2 → 1.85.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-working-copy-service-override",
-  "version": "1.85.2",
+  "version": "1.85.4",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,8 +18,8 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@1.85.2",
+    "vscode": "npm:@codingame/monaco-vscode-api@1.85.4",
     "monaco-editor": "0.45.0",
-    "@codingame/monaco-vscode-files-service-override": "1.85.2"
+    "@codingame/monaco-vscode-files-service-override": "1.85.4"
   }
 }

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

@@ -0,0 +1,29 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IRemoteAgentService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteAgentService';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { WorkingCopyHistoryService } from '../common/workingCopyHistoryService.js';
+
+let BrowserWorkingCopyHistoryService = class BrowserWorkingCopyHistoryService extends WorkingCopyHistoryService {
+    constructor(fileService, remoteAgentService, environmentService, uriIdentityService, labelService, logService, configurationService) {
+        super(fileService, remoteAgentService, environmentService, uriIdentityService, labelService, logService, configurationService);
+    }
+    getModelOptions() {
+        return { flushOnChange: true  };
+    }
+};
+BrowserWorkingCopyHistoryService = ( __decorate([
+    ( __param(0, IFileService)),
+    ( __param(1, IRemoteAgentService)),
+    ( __param(2, IWorkbenchEnvironmentService)),
+    ( __param(3, IUriIdentityService)),
+    ( __param(4, ILabelService)),
+    ( __param(5, ILogService)),
+    ( __param(6, IConfigurationService))
+], BrowserWorkingCopyHistoryService));
+
+export { BrowserWorkingCopyHistoryService };

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

@@ -0,0 +1,618 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
+import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
+import { WorkingCopyHistoryTracker } from './workingCopyHistoryTracker.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { MAX_PARALLEL_HISTORY_IO_OPS } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyHistory';
+import { FileOperationError, IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IRemoteAgentService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteAgentService';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { Limiter, DeferredPromise, RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
+import { extname, joinPath, isEqual, dirname } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
+import { hash } from 'monaco-editor/esm/vs/base/common/hash.js';
+import { randomPath, indexOfPath } from 'monaco-editor/esm/vs/base/common/extpath.js';
+import { CancellationToken, CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { SaveSourceRegistry } from 'vscode/vscode/vs/workbench/common/editor';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { lastOrDefault } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { escapeRegExpCharacters } from 'monaco-editor/esm/vs/base/common/strings.js';
+
+var WorkingCopyHistoryService_1, NativeWorkingCopyHistoryService_1;
+class WorkingCopyHistoryModel {
+    static { this.ENTRIES_FILE = 'entries.json'; }
+    static { this.FILE_SAVED_SOURCE = SaveSourceRegistry.registerSource('default.source', ( localizeWithPath(
+        'vs/workbench/services/workingCopy/common/workingCopyHistoryService',
+        'default.source',
+        "File Saved"
+    ))); }
+    static { this.SETTINGS = {
+        MAX_ENTRIES: 'workbench.localHistory.maxFileEntries',
+        MERGE_PERIOD: 'workbench.localHistory.mergeWindow'
+    }; }
+    constructor(workingCopyResource, historyHome, entryAddedEmitter, entryChangedEmitter, entryReplacedEmitter, entryRemovedEmitter, options, fileService, labelService, logService, configurationService) {
+        this.historyHome = historyHome;
+        this.entryAddedEmitter = entryAddedEmitter;
+        this.entryChangedEmitter = entryChangedEmitter;
+        this.entryReplacedEmitter = entryReplacedEmitter;
+        this.entryRemovedEmitter = entryRemovedEmitter;
+        this.options = options;
+        this.fileService = fileService;
+        this.labelService = labelService;
+        this.logService = logService;
+        this.configurationService = configurationService;
+        this.entries = [];
+        this.whenResolved = undefined;
+        this.workingCopyResource = undefined;
+        this.workingCopyName = undefined;
+        this.historyEntriesFolder = undefined;
+        this.historyEntriesListingFile = undefined;
+        this.historyEntriesNameMatcher = undefined;
+        this.versionId = 0;
+        this.storedVersionId = this.versionId;
+        this.storeLimiter = ( new Limiter(1));
+        this.setWorkingCopy(workingCopyResource);
+    }
+    setWorkingCopy(workingCopyResource) {
+        this.workingCopyResource = workingCopyResource;
+        this.workingCopyName = this.labelService.getUriBasenameLabel(workingCopyResource);
+        this.historyEntriesNameMatcher = ( new RegExp(`[A-Za-z0-9]{4}${escapeRegExpCharacters(extname(workingCopyResource))}`));
+        this.historyEntriesFolder = this.toHistoryEntriesFolder(this.historyHome, workingCopyResource);
+        this.historyEntriesListingFile = joinPath(this.historyEntriesFolder, WorkingCopyHistoryModel.ENTRIES_FILE);
+        this.entries = [];
+        this.whenResolved = undefined;
+    }
+    toHistoryEntriesFolder(historyHome, workingCopyResource) {
+        return joinPath(historyHome, ( hash(( workingCopyResource.toString())).toString(16)));
+    }
+    async addEntry(source = WorkingCopyHistoryModel.FILE_SAVED_SOURCE, timestamp = Date.now(), token) {
+        let entryToReplace = undefined;
+        const lastEntry = lastOrDefault(this.entries);
+        if (lastEntry && lastEntry.source === source) {
+            const configuredReplaceInterval = this.configurationService.getValue(WorkingCopyHistoryModel.SETTINGS.MERGE_PERIOD, { resource: this.workingCopyResource });
+            if (timestamp - lastEntry.timestamp <= ((configuredReplaceInterval * 1000) )) {
+                entryToReplace = lastEntry;
+            }
+        }
+        let entry;
+        if (entryToReplace) {
+            entry = await this.doReplaceEntry(entryToReplace, timestamp, token);
+        }
+        else {
+            entry = await this.doAddEntry(source, timestamp, token);
+        }
+        if (this.options.flushOnChange && !token.isCancellationRequested) {
+            await this.store(token);
+        }
+        return entry;
+    }
+    async doAddEntry(source, timestamp, token) {
+        const workingCopyResource = assertIsDefined(this.workingCopyResource);
+        const workingCopyName = assertIsDefined(this.workingCopyName);
+        const historyEntriesFolder = assertIsDefined(this.historyEntriesFolder);
+        const id = `${randomPath(undefined, undefined, 4)}${extname(workingCopyResource)}`;
+        const location = joinPath(historyEntriesFolder, id);
+        await this.fileService.cloneFile(workingCopyResource, location);
+        const entry = {
+            id,
+            workingCopy: { resource: workingCopyResource, name: workingCopyName },
+            location,
+            timestamp,
+            source
+        };
+        this.entries.push(entry);
+        this.versionId++;
+        this.entryAddedEmitter.fire({ entry });
+        return entry;
+    }
+    async doReplaceEntry(entry, timestamp, token) {
+        const workingCopyResource = assertIsDefined(this.workingCopyResource);
+        await this.fileService.cloneFile(workingCopyResource, entry.location);
+        entry.timestamp = timestamp;
+        this.versionId++;
+        this.entryReplacedEmitter.fire({ entry });
+        return entry;
+    }
+    async removeEntry(entry, token) {
+        await this.resolveEntriesOnce();
+        if (token.isCancellationRequested) {
+            return false;
+        }
+        const index = this.entries.indexOf(entry);
+        if (index === -1) {
+            return false;
+        }
+        await this.deleteEntry(entry);
+        this.entries.splice(index, 1);
+        this.versionId++;
+        this.entryRemovedEmitter.fire({ entry });
+        if (this.options.flushOnChange && !token.isCancellationRequested) {
+            await this.store(token);
+        }
+        return true;
+    }
+    async updateEntry(entry, properties, token) {
+        await this.resolveEntriesOnce();
+        if (token.isCancellationRequested) {
+            return;
+        }
+        const index = this.entries.indexOf(entry);
+        if (index === -1) {
+            return;
+        }
+        entry.source = properties.source;
+        this.versionId++;
+        this.entryChangedEmitter.fire({ entry });
+        if (this.options.flushOnChange && !token.isCancellationRequested) {
+            await this.store(token);
+        }
+    }
+    async getEntries() {
+        await this.resolveEntriesOnce();
+        const configuredMaxEntries = this.configurationService.getValue(WorkingCopyHistoryModel.SETTINGS.MAX_ENTRIES, { resource: this.workingCopyResource });
+        if (this.entries.length > configuredMaxEntries) {
+            return this.entries.slice(this.entries.length - configuredMaxEntries);
+        }
+        return this.entries;
+    }
+    async hasEntries(skipResolve) {
+        if (!skipResolve) {
+            await this.resolveEntriesOnce();
+        }
+        return this.entries.length > 0;
+    }
+    resolveEntriesOnce() {
+        if (!this.whenResolved) {
+            this.whenResolved = this.doResolveEntries();
+        }
+        return this.whenResolved;
+    }
+    async doResolveEntries() {
+        const entries = await this.resolveEntriesFromDisk();
+        for (const entry of this.entries) {
+            entries.set(entry.id, entry);
+        }
+        this.entries = Array.from(( entries.values())).sort((entryA, entryB) => entryA.timestamp - entryB.timestamp);
+    }
+    async resolveEntriesFromDisk() {
+        const workingCopyResource = assertIsDefined(this.workingCopyResource);
+        const workingCopyName = assertIsDefined(this.workingCopyName);
+        const [entryListing, entryStats] = await Promise.all([
+            this.readEntriesFile(),
+            this.readEntriesFolder()
+        ]);
+        const entries = ( new Map());
+        if (entryStats) {
+            for (const entryStat of entryStats) {
+                entries.set(entryStat.name, {
+                    id: entryStat.name,
+                    workingCopy: { resource: workingCopyResource, name: workingCopyName },
+                    location: entryStat.resource,
+                    timestamp: entryStat.mtime,
+                    source: WorkingCopyHistoryModel.FILE_SAVED_SOURCE
+                });
+            }
+        }
+        if (entryListing) {
+            for (const entry of entryListing.entries) {
+                const existingEntry = entries.get(entry.id);
+                if (existingEntry) {
+                    entries.set(entry.id, {
+                        ...existingEntry,
+                        timestamp: entry.timestamp,
+                        source: entry.source ?? existingEntry.source
+                    });
+                }
+            }
+        }
+        return entries;
+    }
+    async moveEntries(targetWorkingCopyResource, source, token) {
+        await this.store(token);
+        if (token.isCancellationRequested) {
+            return undefined;
+        }
+        const sourceHistoryEntriesFolder = assertIsDefined(this.historyEntriesFolder);
+        const targetHistoryFolder = this.toHistoryEntriesFolder(this.historyHome, targetWorkingCopyResource);
+        try {
+            await this.fileService.move(sourceHistoryEntriesFolder, targetHistoryFolder, true);
+        }
+        catch (error) {
+            if (!((error instanceof FileOperationError && error.fileOperationResult === 1) )) {
+                this.traceError(error);
+            }
+        }
+        this.setWorkingCopy(targetWorkingCopyResource);
+        await this.addEntry(source, undefined, token);
+        await this.store(token);
+    }
+    async store(token) {
+        if (!this.shouldStore()) {
+            return;
+        }
+        await this.storeLimiter.queue(async () => {
+            if (token.isCancellationRequested || !this.shouldStore()) {
+                return;
+            }
+            return this.doStore(token);
+        });
+    }
+    shouldStore() {
+        return this.storedVersionId !== this.versionId;
+    }
+    async doStore(token) {
+        const historyEntriesFolder = assertIsDefined(this.historyEntriesFolder);
+        await this.resolveEntriesOnce();
+        if (token.isCancellationRequested) {
+            return undefined;
+        }
+        await this.cleanUpEntries();
+        const storedVersion = this.versionId;
+        if (this.entries.length === 0) {
+            try {
+                await this.fileService.del(historyEntriesFolder, { recursive: true });
+            }
+            catch (error) {
+                this.traceError(error);
+            }
+        }
+        else {
+            await this.writeEntriesFile();
+        }
+        this.storedVersionId = storedVersion;
+    }
+    async cleanUpEntries() {
+        const configuredMaxEntries = this.configurationService.getValue(WorkingCopyHistoryModel.SETTINGS.MAX_ENTRIES, { resource: this.workingCopyResource });
+        if (this.entries.length <= configuredMaxEntries) {
+            return;
+        }
+        const entriesToDelete = this.entries.slice(0, this.entries.length - configuredMaxEntries);
+        const entriesToKeep = this.entries.slice(this.entries.length - configuredMaxEntries);
+        for (const entryToDelete of entriesToDelete) {
+            await this.deleteEntry(entryToDelete);
+        }
+        this.entries = entriesToKeep;
+        for (const entry of entriesToDelete) {
+            this.entryRemovedEmitter.fire({ entry });
+        }
+    }
+    async deleteEntry(entry) {
+        try {
+            await this.fileService.del(entry.location);
+        }
+        catch (error) {
+            this.traceError(error);
+        }
+    }
+    async writeEntriesFile() {
+        const workingCopyResource = assertIsDefined(this.workingCopyResource);
+        const historyEntriesListingFile = assertIsDefined(this.historyEntriesListingFile);
+        const serializedModel = {
+            version: 1,
+            resource: ( workingCopyResource.toString()),
+            entries: ( this.entries.map(entry => {
+                return {
+                    id: entry.id,
+                    source: entry.source !== WorkingCopyHistoryModel.FILE_SAVED_SOURCE ? entry.source : undefined,
+                    timestamp: entry.timestamp
+                };
+            }))
+        };
+        await this.fileService.writeFile(historyEntriesListingFile, VSBuffer.fromString(JSON.stringify(serializedModel)));
+    }
+    async readEntriesFile() {
+        const historyEntriesListingFile = assertIsDefined(this.historyEntriesListingFile);
+        let serializedModel = undefined;
+        try {
+            serializedModel = JSON.parse(( (await this.fileService.readFile(historyEntriesListingFile)).value.toString()));
+        }
+        catch (error) {
+            if (!((error instanceof FileOperationError && error.fileOperationResult === 1) )) {
+                this.traceError(error);
+            }
+        }
+        return serializedModel;
+    }
+    async readEntriesFolder() {
+        const historyEntriesFolder = assertIsDefined(this.historyEntriesFolder);
+        const historyEntriesNameMatcher = assertIsDefined(this.historyEntriesNameMatcher);
+        let rawEntries = undefined;
+        try {
+            rawEntries = (await this.fileService.resolve(historyEntriesFolder, { resolveMetadata: true })).children;
+        }
+        catch (error) {
+            if (!((error instanceof FileOperationError && error.fileOperationResult === 1) )) {
+                this.traceError(error);
+            }
+        }
+        if (!rawEntries) {
+            return undefined;
+        }
+        return rawEntries.filter(entry => !isEqual(entry.resource, this.historyEntriesListingFile) &&
+            historyEntriesNameMatcher.test(entry.name)
+        );
+    }
+    traceError(error) {
+        this.logService.trace('[Working Copy History Service]', error);
+    }
+}
+let WorkingCopyHistoryService = class WorkingCopyHistoryService extends Disposable {
+    static { WorkingCopyHistoryService_1 = this; }
+    static { this.FILE_MOVED_SOURCE = SaveSourceRegistry.registerSource('moved.source', ( localizeWithPath(
+        'vs/workbench/services/workingCopy/common/workingCopyHistoryService',
+        'moved.source',
+        "File Moved"
+    ))); }
+    static { this.FILE_RENAMED_SOURCE = SaveSourceRegistry.registerSource('renamed.source', ( localizeWithPath(
+        'vs/workbench/services/workingCopy/common/workingCopyHistoryService',
+        'renamed.source',
+        "File Renamed"
+    ))); }
+    constructor(fileService, remoteAgentService, environmentService, uriIdentityService, labelService, logService, configurationService) {
+        super();
+        this.fileService = fileService;
+        this.remoteAgentService = remoteAgentService;
+        this.environmentService = environmentService;
+        this.uriIdentityService = uriIdentityService;
+        this.labelService = labelService;
+        this.logService = logService;
+        this.configurationService = configurationService;
+        this._onDidAddEntry = this._register(( new Emitter()));
+        this.onDidAddEntry = this._onDidAddEntry.event;
+        this._onDidChangeEntry = this._register(( new Emitter()));
+        this.onDidChangeEntry = this._onDidChangeEntry.event;
+        this._onDidReplaceEntry = this._register(( new Emitter()));
+        this.onDidReplaceEntry = this._onDidReplaceEntry.event;
+        this._onDidMoveEntries = this._register(( new Emitter()));
+        this.onDidMoveEntries = this._onDidMoveEntries.event;
+        this._onDidRemoveEntry = this._register(( new Emitter()));
+        this.onDidRemoveEntry = this._onDidRemoveEntry.event;
+        this._onDidRemoveEntries = this._register(( new Emitter()));
+        this.onDidRemoveEntries = this._onDidRemoveEntries.event;
+        this.localHistoryHome = ( new DeferredPromise());
+        this.models = ( new ResourceMap(resource => this.uriIdentityService.extUri.getComparisonKey(resource)));
+        this.resolveLocalHistoryHome();
+    }
+    async resolveLocalHistoryHome() {
+        let historyHome = undefined;
+        try {
+            const remoteEnv = await this.remoteAgentService.getEnvironment();
+            if (remoteEnv) {
+                historyHome = remoteEnv.localHistoryHome;
+            }
+        }
+        catch (error) {
+            this.logService.trace(error);
+        }
+        if (!historyHome) {
+            historyHome = this.environmentService.localHistoryHome;
+        }
+        this.localHistoryHome.complete(historyHome);
+    }
+    async moveEntries(source, target) {
+        const limiter = ( new Limiter(MAX_PARALLEL_HISTORY_IO_OPS));
+        const promises = [];
+        for (const [resource, model] of this.models) {
+            if (!this.uriIdentityService.extUri.isEqualOrParent(resource, source)) {
+                continue;
+            }
+            let targetResource;
+            if (this.uriIdentityService.extUri.isEqual(source, resource)) {
+                targetResource = target;
+            }
+            else {
+                const index = indexOfPath(resource.path, source.path);
+                targetResource = joinPath(target, resource.path.substr(index + source.path.length + 1));
+            }
+            let saveSource;
+            if (this.uriIdentityService.extUri.isEqual(dirname(resource), dirname(targetResource))) {
+                saveSource = WorkingCopyHistoryService_1.FILE_RENAMED_SOURCE;
+            }
+            else {
+                saveSource = WorkingCopyHistoryService_1.FILE_MOVED_SOURCE;
+            }
+            promises.push(limiter.queue(() => this.doMoveEntries(model, saveSource, resource, targetResource)));
+        }
+        if (!promises.length) {
+            return [];
+        }
+        const resources = await Promise.all(promises);
+        this._onDidMoveEntries.fire();
+        return resources;
+    }
+    async doMoveEntries(model, source, sourceWorkingCopyResource, targetWorkingCopyResource) {
+        await model.moveEntries(targetWorkingCopyResource, source, CancellationToken.None);
+        this.models.delete(sourceWorkingCopyResource);
+        this.models.set(targetWorkingCopyResource, model);
+        return targetWorkingCopyResource;
+    }
+    async addEntry({ resource, source, timestamp }, token) {
+        if (!this.fileService.hasProvider(resource)) {
+            return undefined;
+        }
+        const model = await this.getModel(resource);
+        if (token.isCancellationRequested) {
+            return undefined;
+        }
+        return model.addEntry(source, timestamp, token);
+    }
+    async updateEntry(entry, properties, token) {
+        const model = await this.getModel(entry.workingCopy.resource);
+        if (token.isCancellationRequested) {
+            return;
+        }
+        return model.updateEntry(entry, properties, token);
+    }
+    async removeEntry(entry, token) {
+        const model = await this.getModel(entry.workingCopy.resource);
+        if (token.isCancellationRequested) {
+            return false;
+        }
+        return model.removeEntry(entry, token);
+    }
+    async removeAll(token) {
+        const historyHome = await this.localHistoryHome.p;
+        if (token.isCancellationRequested) {
+            return;
+        }
+        this.models.clear();
+        await this.fileService.del(historyHome, { recursive: true });
+        this._onDidRemoveEntries.fire();
+    }
+    async getEntries(resource, token) {
+        const model = await this.getModel(resource);
+        if (token.isCancellationRequested) {
+            return [];
+        }
+        const entries = await model.getEntries();
+        return entries ?? [];
+    }
+    async getAll(token) {
+        const historyHome = await this.localHistoryHome.p;
+        if (token.isCancellationRequested) {
+            return [];
+        }
+        const all = ( new ResourceMap());
+        for (const [resource, model] of this.models) {
+            const hasInMemoryEntries = await model.hasEntries(true );
+            if (hasInMemoryEntries) {
+                all.set(resource, true);
+            }
+        }
+        try {
+            const resolvedHistoryHome = await this.fileService.resolve(historyHome);
+            if (resolvedHistoryHome.children) {
+                const limiter = ( new Limiter(MAX_PARALLEL_HISTORY_IO_OPS));
+                const promises = [];
+                for (const child of resolvedHistoryHome.children) {
+                    promises.push(limiter.queue(async () => {
+                        if (token.isCancellationRequested) {
+                            return;
+                        }
+                        try {
+                            const serializedModel = JSON.parse(( (await this.fileService.readFile(joinPath(child.resource, WorkingCopyHistoryModel.ENTRIES_FILE))).value.toString()));
+                            if (serializedModel.entries.length > 0) {
+                                all.set(( URI.parse(serializedModel.resource)), true);
+                            }
+                        }
+                        catch (error) {
+                        }
+                    }));
+                }
+                await Promise.all(promises);
+            }
+        }
+        catch (error) {
+        }
+        return Array.from(( all.keys()));
+    }
+    async getModel(resource) {
+        const historyHome = await this.localHistoryHome.p;
+        let model = this.models.get(resource);
+        if (!model) {
+            model = ( new WorkingCopyHistoryModel(
+                resource,
+                historyHome,
+                this._onDidAddEntry,
+                this._onDidChangeEntry,
+                this._onDidReplaceEntry,
+                this._onDidRemoveEntry,
+                this.getModelOptions(),
+                this.fileService,
+                this.labelService,
+                this.logService,
+                this.configurationService
+            ));
+            this.models.set(resource, model);
+        }
+        return model;
+    }
+};
+WorkingCopyHistoryService = WorkingCopyHistoryService_1 = ( __decorate([
+    ( __param(0, IFileService)),
+    ( __param(1, IRemoteAgentService)),
+    ( __param(2, IWorkbenchEnvironmentService)),
+    ( __param(3, IUriIdentityService)),
+    ( __param(4, ILabelService)),
+    ( __param(5, ILogService)),
+    ( __param(6, IConfigurationService))
+], WorkingCopyHistoryService));
+let NativeWorkingCopyHistoryService = class NativeWorkingCopyHistoryService extends WorkingCopyHistoryService {
+    static { NativeWorkingCopyHistoryService_1 = this; }
+    static { this.STORE_ALL_INTERVAL = 5 * 60 * 1000; }
+    constructor(fileService, remoteAgentService, environmentService, uriIdentityService, labelService, lifecycleService, logService, configurationService) {
+        super(fileService, remoteAgentService, environmentService, uriIdentityService, labelService, logService, configurationService);
+        this.lifecycleService = lifecycleService;
+        this.isRemotelyStored = typeof this.environmentService.remoteAuthority === 'string';
+        this.storeAllCts = this._register(( new CancellationTokenSource()));
+        this.storeAllScheduler = this._register(( new RunOnceScheduler(
+            () => this.storeAll(this.storeAllCts.token),
+            NativeWorkingCopyHistoryService_1.STORE_ALL_INTERVAL
+        )));
+        this.registerListeners();
+    }
+    registerListeners() {
+        if (!this.isRemotelyStored) {
+            this._register(this.lifecycleService.onWillShutdown(e => this.onWillShutdown(e)));
+            this._register(Event.any(this.onDidAddEntry, this.onDidChangeEntry, this.onDidReplaceEntry, this.onDidRemoveEntry)(() => this.onDidChangeModels()));
+        }
+    }
+    getModelOptions() {
+        return { flushOnChange: this.isRemotelyStored  };
+    }
+    onWillShutdown(e) {
+        this.storeAllScheduler.dispose();
+        this.storeAllCts.dispose(true);
+        e.join(this.storeAll(e.token), { id: 'join.workingCopyHistory', label: ( localizeWithPath(
+            'vs/workbench/services/workingCopy/common/workingCopyHistoryService',
+            'join.workingCopyHistory',
+            "Saving local history"
+        )) });
+    }
+    onDidChangeModels() {
+        if (!this.storeAllScheduler.isScheduled()) {
+            this.storeAllScheduler.schedule();
+        }
+    }
+    async storeAll(token) {
+        const limiter = ( new Limiter(MAX_PARALLEL_HISTORY_IO_OPS));
+        const promises = [];
+        const models = Array.from(( this.models.values()));
+        for (const model of models) {
+            promises.push(limiter.queue(async () => {
+                if (token.isCancellationRequested) {
+                    return;
+                }
+                try {
+                    await model.store(token);
+                }
+                catch (error) {
+                    this.logService.trace(error);
+                }
+            }));
+        }
+        await Promise.all(promises);
+    }
+};
+NativeWorkingCopyHistoryService = NativeWorkingCopyHistoryService_1 = ( __decorate([
+    ( __param(0, IFileService)),
+    ( __param(1, IRemoteAgentService)),
+    ( __param(2, IWorkbenchEnvironmentService)),
+    ( __param(3, IUriIdentityService)),
+    ( __param(4, ILabelService)),
+    ( __param(5, ILifecycleService)),
+    ( __param(6, ILogService)),
+    ( __param(7, IConfigurationService))
+], NativeWorkingCopyHistoryService));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(WorkingCopyHistoryTracker, 3 );
+
+export { NativeWorkingCopyHistoryService, WorkingCopyHistoryModel, WorkingCopyHistoryService };

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

@@ -0,0 +1,164 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { Limiter, GlobalIdleValue } from 'monaco-editor/esm/vs/base/common/async.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IUndoRedoService } from 'monaco-editor/esm/vs/platform/undoRedo/common/undoRedo.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { SaveSourceRegistry } from 'vscode/vscode/vs/workbench/common/editor';
+import { IPathService } from 'vscode/vscode/vs/workbench/services/path/common/pathService';
+import { isStoredFileWorkingCopySaveEvent } from 'vscode/vscode/vs/workbench/services/workingCopy/common/storedFileWorkingCopy';
+import { MAX_PARALLEL_HISTORY_IO_OPS, IWorkingCopyHistoryService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyHistory';
+import { IWorkingCopyService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyService';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { ResourceGlobMatcher } from 'vscode/vscode/vs/workbench/common/resources';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+
+var WorkingCopyHistoryTracker_1;
+let WorkingCopyHistoryTracker = class WorkingCopyHistoryTracker extends Disposable {
+    static { WorkingCopyHistoryTracker_1 = this; }
+    static { this.SETTINGS = {
+        ENABLED: 'workbench.localHistory.enabled',
+        SIZE_LIMIT: 'workbench.localHistory.maxFileSize',
+        EXCLUDES: 'workbench.localHistory.exclude'
+    }; }
+    static { this.UNDO_REDO_SAVE_SOURCE = SaveSourceRegistry.registerSource('undoRedo.source', ( localizeWithPath(
+        'vs/workbench/services/workingCopy/common/workingCopyHistoryTracker',
+        'undoRedo.source',
+        "Undo / Redo"
+    ))); }
+    constructor(workingCopyService, workingCopyHistoryService, uriIdentityService, pathService, configurationService, undoRedoService, contextService, fileService) {
+        super();
+        this.workingCopyService = workingCopyService;
+        this.workingCopyHistoryService = workingCopyHistoryService;
+        this.uriIdentityService = uriIdentityService;
+        this.pathService = pathService;
+        this.configurationService = configurationService;
+        this.undoRedoService = undoRedoService;
+        this.contextService = contextService;
+        this.fileService = fileService;
+        this.limiter = this._register(( new Limiter(MAX_PARALLEL_HISTORY_IO_OPS)));
+        this.resourceExcludeMatcher = this._register(( new GlobalIdleValue(() => {
+            const matcher = this._register(( new ResourceGlobMatcher(
+                root => this.configurationService.getValue(WorkingCopyHistoryTracker_1.SETTINGS.EXCLUDES, { resource: root }),
+                event => event.affectsConfiguration(WorkingCopyHistoryTracker_1.SETTINGS.EXCLUDES),
+                this.contextService,
+                this.configurationService
+            )));
+            return matcher;
+        })));
+        this.pendingAddHistoryEntryOperations = ( new ResourceMap(resource => this.uriIdentityService.extUri.getComparisonKey(resource)));
+        this.workingCopyContentVersion = ( new ResourceMap(resource => this.uriIdentityService.extUri.getComparisonKey(resource)));
+        this.historyEntryContentVersion = ( new ResourceMap(resource => this.uriIdentityService.extUri.getComparisonKey(resource)));
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.fileService.onDidRunOperation(e => this.onDidRunFileOperation(e)));
+        this._register(this.workingCopyService.onDidChangeContent(workingCopy => this.onDidChangeContent(workingCopy)));
+        this._register(this.workingCopyService.onDidSave(e => this.onDidSave(e)));
+    }
+    async onDidRunFileOperation(e) {
+        if (!this.shouldTrackHistoryFromFileOperationEvent(e)) {
+            return;
+        }
+        const source = e.resource;
+        const target = e.target.resource;
+        const resources = await this.workingCopyHistoryService.moveEntries(source, target);
+        for (const resource of resources) {
+            const contentVersion = this.getContentVersion(resource);
+            this.historyEntryContentVersion.set(resource, contentVersion);
+        }
+    }
+    onDidChangeContent(workingCopy) {
+        const contentVersionId = this.getContentVersion(workingCopy.resource);
+        this.workingCopyContentVersion.set(workingCopy.resource, contentVersionId + 1);
+    }
+    getContentVersion(resource) {
+        return this.workingCopyContentVersion.get(resource) || 0;
+    }
+    onDidSave(e) {
+        if (!this.shouldTrackHistoryFromSaveEvent(e)) {
+            return;
+        }
+        const contentVersion = this.getContentVersion(e.workingCopy.resource);
+        if (this.historyEntryContentVersion.get(e.workingCopy.resource) === contentVersion) {
+            return;
+        }
+        this.pendingAddHistoryEntryOperations.get(e.workingCopy.resource)?.dispose(true);
+        const cts = ( new CancellationTokenSource());
+        this.pendingAddHistoryEntryOperations.set(e.workingCopy.resource, cts);
+        this.limiter.queue(async () => {
+            if (cts.token.isCancellationRequested) {
+                return;
+            }
+            const contentVersion = this.getContentVersion(e.workingCopy.resource);
+            let source = e.source;
+            if (!e.source) {
+                source = this.resolveSourceFromUndoRedo(e);
+            }
+            await this.workingCopyHistoryService.addEntry({ resource: e.workingCopy.resource, source, timestamp: e.stat.mtime }, cts.token);
+            this.historyEntryContentVersion.set(e.workingCopy.resource, contentVersion);
+            if (cts.token.isCancellationRequested) {
+                return;
+            }
+            this.pendingAddHistoryEntryOperations.delete(e.workingCopy.resource);
+        });
+    }
+    resolveSourceFromUndoRedo(e) {
+        const lastStackElement = this.undoRedoService.getLastElement(e.workingCopy.resource);
+        if (lastStackElement) {
+            if (lastStackElement.code === 'undoredo.textBufferEdit') {
+                return undefined;
+            }
+            return lastStackElement.label;
+        }
+        const allStackElements = this.undoRedoService.getElements(e.workingCopy.resource);
+        if (allStackElements.future.length > 0 || allStackElements.past.length > 0) {
+            return WorkingCopyHistoryTracker_1.UNDO_REDO_SAVE_SOURCE;
+        }
+        return undefined;
+    }
+    shouldTrackHistoryFromSaveEvent(e) {
+        if (!isStoredFileWorkingCopySaveEvent(e)) {
+            return false;
+        }
+        return this.shouldTrackHistory(e.workingCopy.resource, e.stat);
+    }
+    shouldTrackHistoryFromFileOperationEvent(e) {
+        if (!e.isOperation(2 )) {
+            return false;
+        }
+        return this.shouldTrackHistory(e.target.resource, e.target);
+    }
+    shouldTrackHistory(resource, stat) {
+        if (resource.scheme !== this.pathService.defaultUriScheme &&
+            resource.scheme !== Schemas.vscodeUserData &&
+            resource.scheme !== Schemas.inMemory
+        ) {
+            return false;
+        }
+        const configuredMaxFileSizeInBytes = 1024 * this.configurationService.getValue(WorkingCopyHistoryTracker_1.SETTINGS.SIZE_LIMIT, { resource });
+        if (stat.size > configuredMaxFileSizeInBytes) {
+            return false;
+        }
+        if (this.configurationService.getValue(WorkingCopyHistoryTracker_1.SETTINGS.ENABLED, { resource }) === false) {
+            return false;
+        }
+        return !this.resourceExcludeMatcher.value.matches(resource);
+    }
+};
+WorkingCopyHistoryTracker = WorkingCopyHistoryTracker_1 = ( __decorate([
+    ( __param(0, IWorkingCopyService)),
+    ( __param(1, IWorkingCopyHistoryService)),
+    ( __param(2, IUriIdentityService)),
+    ( __param(3, IPathService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IUndoRedoService)),
+    ( __param(6, IWorkspaceContextService)),
+    ( __param(7, IFileService))
+], WorkingCopyHistoryTracker));
+
+export { WorkingCopyHistoryTracker };

package/workingCopy.js

@@ -3,6 +3,8 @@ import { BrowserWorkingCopyBackupService } from './vscode/src/vs/workbench/servi
 import { IWorkingCopyBackupService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyBackup';
 import { IWorkingCopyService, WorkingCopyService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyService';
 import { IWorkingCopyEditorService, WorkingCopyEditorService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyEditorService';
+import { IWorkingCopyHistoryService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyHistory';
+import { BrowserWorkingCopyHistoryService } from './vscode/src/vs/workbench/services/workingCopy/browser/workingCopyHistoryService.js';
 import getServiceOverride$1 from '@codingame/monaco-vscode-files-service-override';
 
 function getServiceOverride() {
@@ -10,7 +12,8 @@ function getServiceOverride() {
         ...getServiceOverride$1(),
         [( IWorkingCopyBackupService.toString())]: new SyncDescriptor(BrowserWorkingCopyBackupService, [], false),
         [( IWorkingCopyService.toString())]: new SyncDescriptor(WorkingCopyService, [], false),
-        [( IWorkingCopyEditorService.toString())]: new SyncDescriptor(WorkingCopyEditorService, [], false)
+        [( IWorkingCopyEditorService.toString())]: new SyncDescriptor(WorkingCopyEditorService, [], false),
+        [( IWorkingCopyHistoryService.toString())]: new SyncDescriptor(BrowserWorkingCopyHistoryService, [], false)
     };
 }