@codingame/monaco-vscode-working-copy-service-override 4.1.0 → 4.1.2

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 'vscode/vscode/vs/nls';
+import { Limiter, GlobalIdleValue } from 'vscode/vscode/vs/base/common/async';
+import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { ResourceMap } from 'vscode/vscode/vs/base/common/map';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { IUndoRedoService } from 'vscode/vscode/vs/platform/undoRedo/common/undoRedo';
+import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
+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 'vscode/vscode/vs/base/common/network';
+import { ResourceGlobMatcher } from 'vscode/vscode/vs/workbench/common/resources';
+import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
+
+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

@@ -1,10 +1,10 @@
 import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
-import { BrowserWorkingCopyBackupService } from 'vscode/vscode/vs/workbench/services/workingCopy/browser/workingCopyBackupService';
+import { BrowserWorkingCopyBackupService } from './vscode/src/vs/workbench/services/workingCopy/browser/workingCopyBackupService.js';
 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/vscode/vs/workbench/services/workingCopy/browser/workingCopyHistoryService';
+import { BrowserWorkingCopyHistoryService } from './vscode/src/vs/workbench/services/workingCopy/browser/workingCopyHistoryService.js';
 import getServiceOverride$1 from '@codingame/monaco-vscode-files-service-override';
 
 function getServiceOverride() {