@codingame/monaco-vscode-working-copy-service-override 4.5.1 → 5.0.0

package/package.json

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

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

@@ -29,13 +29,10 @@ import { lastOrDefault } from 'vscode/vscode/vs/base/common/arrays';
 import { escapeRegExpCharacters } from 'vscode/vscode/vs/base/common/strings';
 
 var WorkingCopyHistoryService_1, NativeWorkingCopyHistoryService_1;
+const _moduleId = "vs/workbench/services/workingCopy/common/workingCopyHistoryService";
 class WorkingCopyHistoryModel {
     static { this.ENTRIES_FILE = 'entries.json'; }
-    static { this.FILE_SAVED_SOURCE = SaveSourceRegistry.registerSource('default.source', ( localizeWithPath(
-        'vs/workbench/services/workingCopy/common/workingCopyHistoryService',
-        'default.source',
-        "File Saved"
-    ))); }
+    static { this.FILE_SAVED_SOURCE = SaveSourceRegistry.registerSource('default.source', ( localizeWithPath(_moduleId, 0, "File Saved"))); }
     static { this.SETTINGS = {
         MAX_ENTRIES: 'workbench.localHistory.maxFileEntries',
         MERGE_PERIOD: 'workbench.localHistory.mergeWindow'
@@ -60,20 +57,20 @@ class WorkingCopyHistoryModel {
         this.historyEntriesNameMatcher = undefined;
         this.versionId = 0;
         this.storedVersionId = this.versionId;
-        this.storeLimiter = ( new Limiter(1));
+        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.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)));
+        return joinPath(historyHome, ( (hash(( (workingCopyResource.toString()))).toString(16))));
     }
     async addEntry(source = WorkingCopyHistoryModel.FILE_SAVED_SOURCE, timestamp = Date.now(), token) {
         let entryToReplace = undefined;
@@ -182,7 +179,7 @@ class WorkingCopyHistoryModel {
         for (const entry of this.entries) {
             entries.set(entry.id, entry);
         }
-        this.entries = Array.from(( entries.values())).sort((entryA, entryB) => entryA.timestamp - entryB.timestamp);
+        this.entries = Array.from(( (entries.values()))).sort((entryA, entryB) => entryA.timestamp - entryB.timestamp);
     }
     async resolveEntriesFromDisk() {
         const workingCopyResource = assertIsDefined(this.workingCopyResource);
@@ -191,7 +188,7 @@ class WorkingCopyHistoryModel {
             this.readEntriesFile(),
             this.readEntriesFolder()
         ]);
-        const entries = ( new Map());
+        const entries = ( (new Map()));
         if (entryStats) {
             for (const entryStat of entryStats) {
                 entries.set(entryStat.name, {
@@ -299,14 +296,14 @@ class WorkingCopyHistoryModel {
         const historyEntriesListingFile = assertIsDefined(this.historyEntriesListingFile);
         const serializedModel = {
             version: 1,
-            resource: ( workingCopyResource.toString()),
-            entries: ( this.entries.map(entry => {
+            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)));
     }
@@ -314,7 +311,7 @@ class WorkingCopyHistoryModel {
         const historyEntriesListingFile = assertIsDefined(this.historyEntriesListingFile);
         let serializedModel = undefined;
         try {
-            serializedModel = JSON.parse(( (await this.fileService.readFile(historyEntriesListingFile)).value.toString()));
+            serializedModel = JSON.parse(( ((await this.fileService.readFile(historyEntriesListingFile)).value.toString())));
         }
         catch (error) {
             if (!((error instanceof FileOperationError && error.fileOperationResult === 1) )) {
@@ -348,16 +345,8 @@ class WorkingCopyHistoryModel {
 }
 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"
-    ))); }
+    static { this.FILE_MOVED_SOURCE = SaveSourceRegistry.registerSource('moved.source', ( localizeWithPath(_moduleId, 1, "File Moved"))); }
+    static { this.FILE_RENAMED_SOURCE = SaveSourceRegistry.registerSource('renamed.source', ( localizeWithPath(_moduleId, 2, "File Renamed"))); }
     constructor(fileService, remoteAgentService, environmentService, uriIdentityService, labelService, logService, configurationService) {
         super();
         this.fileService = fileService;
@@ -367,20 +356,20 @@ let WorkingCopyHistoryService = class WorkingCopyHistoryService extends Disposab
         this.labelService = labelService;
         this.logService = logService;
         this.configurationService = configurationService;
-        this._onDidAddEntry = this._register(( new Emitter()));
+        this._onDidAddEntry = this._register(( (new Emitter())));
         this.onDidAddEntry = this._onDidAddEntry.event;
-        this._onDidChangeEntry = this._register(( new Emitter()));
+        this._onDidChangeEntry = this._register(( (new Emitter())));
         this.onDidChangeEntry = this._onDidChangeEntry.event;
-        this._onDidReplaceEntry = this._register(( new Emitter()));
+        this._onDidReplaceEntry = this._register(( (new Emitter())));
         this.onDidReplaceEntry = this._onDidReplaceEntry.event;
-        this._onDidMoveEntries = this._register(( new Emitter()));
+        this._onDidMoveEntries = this._register(( (new Emitter())));
         this.onDidMoveEntries = this._onDidMoveEntries.event;
-        this._onDidRemoveEntry = this._register(( new Emitter()));
+        this._onDidRemoveEntry = this._register(( (new Emitter())));
         this.onDidRemoveEntry = this._onDidRemoveEntry.event;
-        this._onDidRemoveEntries = this._register(( new Emitter()));
+        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.localHistoryHome = ( (new DeferredPromise()));
+        this.models = ( (new ResourceMap(resource => this.uriIdentityService.extUri.getComparisonKey(resource))));
         this.resolveLocalHistoryHome();
     }
     async resolveLocalHistoryHome() {
@@ -400,7 +389,7 @@ let WorkingCopyHistoryService = class WorkingCopyHistoryService extends Disposab
         this.localHistoryHome.complete(historyHome);
     }
     async moveEntries(source, target) {
-        const limiter = ( new Limiter(MAX_PARALLEL_HISTORY_IO_OPS));
+        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)) {
@@ -482,7 +471,7 @@ let WorkingCopyHistoryService = class WorkingCopyHistoryService extends Disposab
         if (token.isCancellationRequested) {
             return [];
         }
-        const all = ( new ResourceMap());
+        const all = ( (new ResourceMap()));
         for (const [resource, model] of this.models) {
             const hasInMemoryEntries = await model.hasEntries(true );
             if (hasInMemoryEntries) {
@@ -492,7 +481,7 @@ let WorkingCopyHistoryService = class WorkingCopyHistoryService extends Disposab
         try {
             const resolvedHistoryHome = await this.fileService.resolve(historyHome);
             if (resolvedHistoryHome.children) {
-                const limiter = ( new Limiter(MAX_PARALLEL_HISTORY_IO_OPS));
+                const limiter = ( (new Limiter(MAX_PARALLEL_HISTORY_IO_OPS)));
                 const promises = [];
                 for (const child of resolvedHistoryHome.children) {
                     promises.push(limiter.queue(async () => {
@@ -500,9 +489,9 @@ let WorkingCopyHistoryService = class WorkingCopyHistoryService extends Disposab
                             return;
                         }
                         try {
-                            const serializedModel = JSON.parse(( (await this.fileService.readFile(joinPath(child.resource, WorkingCopyHistoryModel.ENTRIES_FILE))).value.toString()));
+                            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);
+                                all.set(( (URI.parse(serializedModel.resource))), true);
                             }
                         }
                         catch (error) {
@@ -514,13 +503,13 @@ let WorkingCopyHistoryService = class WorkingCopyHistoryService extends Disposab
         }
         catch (error) {
         }
-        return Array.from(( all.keys()));
+        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(
+            model = ( (new WorkingCopyHistoryModel(
                 resource,
                 historyHome,
                 this._onDidAddEntry,
@@ -532,21 +521,21 @@ let WorkingCopyHistoryService = class WorkingCopyHistoryService extends Disposab
                 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));
+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; }
@@ -554,11 +543,11 @@ let NativeWorkingCopyHistoryService = class NativeWorkingCopyHistoryService exte
         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.storeAllCts = this._register(( (new CancellationTokenSource())));
+        this.storeAllScheduler = this._register(( (new RunOnceScheduler(
             () => this.storeAll(this.storeAllCts.token),
             NativeWorkingCopyHistoryService_1.STORE_ALL_INTERVAL
-        )));
+        ))));
         this.registerListeners();
     }
     registerListeners() {
@@ -573,11 +562,7 @@ let NativeWorkingCopyHistoryService = class NativeWorkingCopyHistoryService exte
     onWillShutdown(e) {
         this.storeAllScheduler.dispose();
         this.storeAllCts.dispose(true);
-        e.join(this.storeAll(e.token), { id: 'join.workingCopyHistory', label: ( localizeWithPath(
-            'vs/workbench/services/workingCopy/common/workingCopyHistoryService',
-            'join.workingCopyHistory',
-            "Saving local history"
-        )) });
+        e.join(this.storeAll(e.token), { id: 'join.workingCopyHistory', label: ( localizeWithPath(_moduleId, 3, "Saving local history")) });
     }
     onDidChangeModels() {
         if (!this.storeAllScheduler.isScheduled()) {
@@ -585,9 +570,9 @@ let NativeWorkingCopyHistoryService = class NativeWorkingCopyHistoryService exte
         }
     }
     async storeAll(token) {
-        const limiter = ( new Limiter(MAX_PARALLEL_HISTORY_IO_OPS));
+        const limiter = ( (new Limiter(MAX_PARALLEL_HISTORY_IO_OPS)));
         const promises = [];
-        const models = Array.from(( this.models.values()));
+        const models = Array.from(( (this.models.values())));
         for (const model of models) {
             promises.push(limiter.queue(async () => {
                 if (token.isCancellationRequested) {
@@ -604,16 +589,16 @@ let NativeWorkingCopyHistoryService = class NativeWorkingCopyHistoryService exte
         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 );
+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

@@ -19,6 +19,7 @@ import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/co
 import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
 
 var WorkingCopyHistoryTracker_1;
+const _moduleId = "vs/workbench/services/workingCopy/common/workingCopyHistoryTracker";
 let WorkingCopyHistoryTracker = class WorkingCopyHistoryTracker extends Disposable {
     static { WorkingCopyHistoryTracker_1 = this; }
     static { this.SETTINGS = {
@@ -26,11 +27,7 @@ let WorkingCopyHistoryTracker = class WorkingCopyHistoryTracker extends Disposab
         SIZE_LIMIT: 'workbench.localHistory.maxFileSize',
         EXCLUDES: 'workbench.localHistory.exclude'
     }; }
-    static { this.UNDO_REDO_SAVE_SOURCE = SaveSourceRegistry.registerSource('undoRedo.source', ( localizeWithPath(
-        'vs/workbench/services/workingCopy/common/workingCopyHistoryTracker',
-        'undoRedo.source',
-        "Undo / Redo"
-    ))); }
+    static { this.UNDO_REDO_SAVE_SOURCE = SaveSourceRegistry.registerSource('undoRedo.source', ( localizeWithPath(_moduleId, 0, "Undo / Redo"))); }
     constructor(workingCopyService, workingCopyHistoryService, uriIdentityService, pathService, configurationService, undoRedoService, contextService, fileService) {
         super();
         this.workingCopyService = workingCopyService;
@@ -41,19 +38,19 @@ let WorkingCopyHistoryTracker = class WorkingCopyHistoryTracker extends Disposab
         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(
+        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.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() {
@@ -89,7 +86,7 @@ let WorkingCopyHistoryTracker = class WorkingCopyHistoryTracker extends Disposab
             return;
         }
         this.pendingAddHistoryEntryOperations.get(e.workingCopy.resource)?.dispose(true);
-        const cts = ( new CancellationTokenSource());
+        const cts = ( (new CancellationTokenSource()));
         this.pendingAddHistoryEntryOperations.set(e.workingCopy.resource, cts);
         this.limiter.queue(async () => {
             if (cts.token.isCancellationRequested) {
@@ -151,15 +148,15 @@ let WorkingCopyHistoryTracker = class WorkingCopyHistoryTracker extends Disposab
         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));
+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/vscode/src/vs/workbench/services/workingCopy/common/workingCopyService.js

@@ -25,7 +25,9 @@ class WorkingCopyService extends Disposable {
     registerWorkingCopy(workingCopy) {
         let workingCopiesForResource = this.mapResourceToWorkingCopies.get(workingCopy.resource);
         if (workingCopiesForResource?.has(workingCopy.typeId)) {
-            throw new Error(`Cannot register more than one working copy with the same resource ${workingCopy.resource.toString()} and type ${workingCopy.typeId}.`);
+            throw ( new Error(
+                `Cannot register more than one working copy with the same resource ${( workingCopy.resource.toString())} and type ${workingCopy.typeId}.`
+            ));
         }
         this._workingCopies.add(workingCopy);
         if (!workingCopiesForResource) {