@codingame/monaco-vscode-base-service-override 25.1.2 → 26.0.1

package/vscode/src/vs/workbench/services/userAttention/browser/userAttentionBrowser.js

@@ -24,7 +24,11 @@ let UserAttentionService = class UserAttentionService extends Disposable {
         const hostAdapter = this._register(instantiationService.createInstance(UserAttentionServiceEnv));
         this.isVsCodeFocused = hostAdapter.isVsCodeFocused;
         this.isUserActive = hostAdapter.isUserActive;
-        this._isTracingEnabled = observableFromEvent(this, this._logService.onDidChangeLogLevel, () => this._logService.getLevel() === LogLevel.Trace);
+        this._isTracingEnabled = observableFromEvent(
+            this,
+            this._logService.onDidChangeLogLevel,
+            () => this._logService.getLevel() === LogLevel.Trace
+        );
         const hadRecentActivity = wasTrueRecently(this.isUserActive, USER_ATTENTION_TIMEOUT_MS, this._store);
         this.hasUserAttention = derived(this, reader => {
             return hadRecentActivity.read(reader);
@@ -51,10 +55,7 @@ let UserAttentionService = class UserAttentionService extends Disposable {
         return this._timeKeeper.totalTimeMs();
     }
 };
-UserAttentionService = ( __decorate([
-    ( __param(0, IInstantiationService)),
-    ( __param(1, ILogService))
-], UserAttentionService));
+UserAttentionService = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, ILogService))], UserAttentionService));
 let UserAttentionServiceEnv = class UserAttentionServiceEnv extends Disposable {
     constructor(_hostService, _logService) {
         super();
@@ -66,12 +67,28 @@ let UserAttentionServiceEnv = class UserAttentionServiceEnv extends Disposable {
         const onActivity = () => {
             this._markUserActivity();
         };
-        this._register(Event.runAndSubscribe(onDidRegisterWindow, ({ window, disposables }) => {
-            disposables.add(addDisposableListener(window.document, 'keydown', onActivity, eventListenerOptions));
-            disposables.add(addDisposableListener(window.document, 'mousemove', onActivity, eventListenerOptions));
-            disposables.add(addDisposableListener(window.document, 'mousedown', onActivity, eventListenerOptions));
-            disposables.add(addDisposableListener(window.document, 'touchstart', onActivity, eventListenerOptions));
-        }, { window: mainWindow, disposables: this._store }));
+        this._register(Event.runAndSubscribe(onDidRegisterWindow, (
+            {
+                window,
+                disposables
+            }
+        ) => {
+            disposables.add(
+                addDisposableListener(window.document, "keydown", onActivity, eventListenerOptions)
+            );
+            disposables.add(
+                addDisposableListener(window.document, "mousemove", onActivity, eventListenerOptions)
+            );
+            disposables.add(
+                addDisposableListener(window.document, "mousedown", onActivity, eventListenerOptions)
+            );
+            disposables.add(
+                addDisposableListener(window.document, "touchstart", onActivity, eventListenerOptions)
+            );
+        }, {
+            window: mainWindow,
+            disposables: this._store
+        }));
         if (this._hostService.hasFocus) {
             this._markUserActivity();
         }
@@ -79,9 +96,8 @@ let UserAttentionServiceEnv = class UserAttentionServiceEnv extends Disposable {
     _markUserActivity() {
         if (this._activityDebounceTimeout !== undefined) {
             clearTimeout(this._activityDebounceTimeout);
-        }
-        else {
-            this._logService.trace('[UserAttentionService] User activity detected');
+        } else {
+            this._logService.trace("[UserAttentionService] User activity detected");
             this._isUserActive.set(true, undefined);
         }
         this._activityDebounceTimeout = setTimeout(() => {
@@ -90,13 +106,10 @@ let UserAttentionServiceEnv = class UserAttentionServiceEnv extends Disposable {
         }, 500);
     }
 };
-UserAttentionServiceEnv = ( __decorate([
-    ( __param(0, IHostService)),
-    ( __param(1, ILogService))
-], UserAttentionServiceEnv));
+UserAttentionServiceEnv = ( __decorate([( __param(0, IHostService)), ( __param(1, ILogService))], UserAttentionServiceEnv));
 const eventListenerOptions = {
     passive: true,
-    capture: true,
+    capture: true
 };
 
 export { UserAttentionService, UserAttentionServiceEnv };

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

@@ -12,7 +12,9 @@ import { NotificationPriority } from '@codingame/monaco-vscode-api/vscode/vs/pla
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 
 let StoredFileWorkingCopySaveParticipant = class StoredFileWorkingCopySaveParticipant extends Disposable {
-    get length() { return this.saveParticipants.size; }
+    get length() {
+        return this.saveParticipants.size;
+    }
     constructor(logService, progressService) {
         super();
         this.logService = logService;
@@ -27,15 +29,15 @@ let StoredFileWorkingCopySaveParticipant = class StoredFileWorkingCopySavePartic
         const cts = ( new CancellationTokenSource(token));
         workingCopy.model?.pushStackElement();
         progress.report({
-            message: ( localize(14653, "Running Code Actions and Formatters..."))
+            message: ( localize(15050, "Running Code Actions and Formatters..."))
         });
         let bubbleCancel = false;
         await this.progressService.withProgress({
             priority: NotificationPriority.URGENT,
             location: ProgressLocation.Notification,
-            cancellable: ( localize(14654, "Skip")),
+            cancellable: ( localize(15051, "Skip")),
             delay: workingCopy.isDirty() ? 5000 : 3000
-        }, async (progress) => {
+        }, async progress => {
             const participants = Array.from(this.saveParticipants).sort((a, b) => {
                 const aValue = a.ordinal ?? 0;
                 const bValue = b.ordinal ?? 0;
@@ -48,12 +50,10 @@ let StoredFileWorkingCopySaveParticipant = class StoredFileWorkingCopySavePartic
                 try {
                     const promise = saveParticipant.participate(workingCopy, context, progress, cts.token);
                     await raceCancellation(promise, cts.token);
-                }
-                catch (err) {
+                } catch (err) {
                     if (!isCancellationError(err)) {
                         this.logService.error(err);
-                    }
-                    else if (!cts.token.isCancellationRequested) {
+                    } else if (!cts.token.isCancellationRequested) {
                         cts.cancel();
                         bubbleCancel = true;
                     }
@@ -73,9 +73,6 @@ let StoredFileWorkingCopySaveParticipant = class StoredFileWorkingCopySavePartic
         super.dispose();
     }
 };
-StoredFileWorkingCopySaveParticipant = ( __decorate([
-    ( __param(0, ILogService)),
-    ( __param(1, IProgressService))
-], StoredFileWorkingCopySaveParticipant));
+StoredFileWorkingCopySaveParticipant = ( __decorate([( __param(0, ILogService)), ( __param(1, IProgressService))], StoredFileWorkingCopySaveParticipant));
 
 export { StoredFileWorkingCopySaveParticipant };

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

@@ -17,15 +17,14 @@ let WorkingCopyFileOperationParticipant = class WorkingCopyFileOperationParticip
         return toDisposable(() => remove());
     }
     async participate(files, operation, undoInfo, token) {
-        const timeout = this.configurationService.getValue('files.participants.timeout');
-        if (typeof timeout !== 'number' || timeout <= 0) {
+        const timeout = this.configurationService.getValue("files.participants.timeout");
+        if (typeof timeout !== "number" || timeout <= 0) {
             return;
         }
         for (const participant of this.participants) {
             try {
                 await participant.participate(files, operation, undoInfo, timeout, token);
-            }
-            catch (err) {
+            } catch (err) {
                 this.logService.warn(err);
             }
         }
@@ -35,9 +34,6 @@ let WorkingCopyFileOperationParticipant = class WorkingCopyFileOperationParticip
         super.dispose();
     }
 };
-WorkingCopyFileOperationParticipant = ( __decorate([
-    ( __param(0, ILogService)),
-    ( __param(1, IConfigurationService))
-], WorkingCopyFileOperationParticipant));
+WorkingCopyFileOperationParticipant = ( __decorate([( __param(0, ILogService)), ( __param(1, IConfigurationService))], WorkingCopyFileOperationParticipant));
 
 export { WorkingCopyFileOperationParticipant };

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

@@ -50,34 +50,49 @@ let WorkingCopyFileService = class WorkingCopyFileService extends Disposable {
             return [];
         }
         if (isFile) {
-            const validateCreates = await Promises.settled(( operations.map(
-                operation => this.fileService.canCreateFile(operation.resource, { overwrite: operation.overwrite })
-            )));
+            const validateCreates = await Promises.settled(( operations.map(operation => this.fileService.canCreateFile(operation.resource, {
+                overwrite: operation.overwrite
+            }))));
             const error = validateCreates.find(validateCreate => validateCreate instanceof Error);
             if (error instanceof Error) {
                 throw error;
             }
         }
-        const files = ( operations.map(operation => ({ target: operation.resource })));
+        const files = ( operations.map(operation => ({
+            target: operation.resource
+        })));
         await this.runFileOperationParticipants(files, FileOperation.CREATE, undoInfo, token);
-        const event = { correlationId: this.correlationIds++, operation: FileOperation.CREATE, files };
-        await this._onWillRunWorkingCopyFileOperation.fireAsync(event, CancellationToken.None );
+        const event = {
+            correlationId: this.correlationIds++,
+            operation: FileOperation.CREATE,
+            files
+        };
+        await this._onWillRunWorkingCopyFileOperation.fireAsync(
+            event,
+            CancellationToken.None
+        );
         let stats;
         try {
             if (isFile) {
                 stats = await Promises.settled(( operations.map(
-                    operation => this.fileService.createFile(operation.resource, operation.contents, { overwrite: operation.overwrite })
+                    operation => this.fileService.createFile(operation.resource, operation.contents, {
+                        overwrite: operation.overwrite
+                    })
                 )));
-            }
-            else {
+            } else {
                 stats = await Promises.settled(( operations.map(operation => this.fileService.createFolder(operation.resource))));
             }
-        }
-        catch (error) {
-            await this._onDidFailWorkingCopyFileOperation.fireAsync(event, CancellationToken.None );
+        } catch (error) {
+            await this._onDidFailWorkingCopyFileOperation.fireAsync(
+                event,
+                CancellationToken.None
+            );
             throw error;
         }
-        await this._onDidRunWorkingCopyFileOperation.fireAsync(event, CancellationToken.None );
+        await this._onDidRunWorkingCopyFileOperation.fireAsync(
+            event,
+            CancellationToken.None
+        );
         return stats;
     }
     async move(operations, token, undoInfo) {
@@ -88,7 +103,13 @@ let WorkingCopyFileService = class WorkingCopyFileService extends Disposable {
     }
     async doMoveOrCopy(operations, move, token, undoInfo) {
         const stats = [];
-        for (const { file: { source, target }, overwrite } of operations) {
+        for (const {
+            file: {
+                source,
+                target
+            },
+            overwrite
+        } of operations) {
             const validateMoveOrCopy = await (move ? this.fileService.canMove(source, target, overwrite) : this.fileService.canCopy(source, target, overwrite));
             if (validateMoveOrCopy instanceof Error) {
                 throw validateMoveOrCopy;
@@ -96,54 +117,95 @@ let WorkingCopyFileService = class WorkingCopyFileService extends Disposable {
         }
         const files = ( operations.map(o => o.file));
         await this.runFileOperationParticipants(files, move ? FileOperation.MOVE : FileOperation.COPY, undoInfo, token);
-        const event = { correlationId: this.correlationIds++, operation: move ? FileOperation.MOVE : FileOperation.COPY, files };
-        await this._onWillRunWorkingCopyFileOperation.fireAsync(event, CancellationToken.None );
+        const event = {
+            correlationId: this.correlationIds++,
+            operation: move ? FileOperation.MOVE : FileOperation.COPY,
+            files
+        };
+        await this._onWillRunWorkingCopyFileOperation.fireAsync(
+            event,
+            CancellationToken.None
+        );
         try {
-            for (const { file: { source, target }, overwrite } of operations) {
+            for (const {
+                file: {
+                    source,
+                    target
+                },
+                overwrite
+            } of operations) {
                 if (!this.uriIdentityService.extUri.isEqual(source, target)) {
                     const dirtyWorkingCopies = (move ? [...this.getDirty(source), ...this.getDirty(target)] : this.getDirty(target));
-                    await Promises.settled(( dirtyWorkingCopies.map(dirtyWorkingCopy => dirtyWorkingCopy.revert({ soft: true }))));
+                    await Promises.settled(( dirtyWorkingCopies.map(dirtyWorkingCopy => dirtyWorkingCopy.revert({
+                        soft: true
+                    }))));
                 }
                 if (move) {
                     stats.push(await this.fileService.move(source, target, overwrite));
-                }
-                else {
+                } else {
                     stats.push(await this.fileService.copy(source, target, overwrite));
                 }
             }
-        }
-        catch (error) {
-            await this._onDidFailWorkingCopyFileOperation.fireAsync(event, CancellationToken.None );
+        } catch (error) {
+            await this._onDidFailWorkingCopyFileOperation.fireAsync(
+                event,
+                CancellationToken.None
+            );
             throw error;
         }
-        await this._onDidRunWorkingCopyFileOperation.fireAsync(event, CancellationToken.None );
+        await this._onDidRunWorkingCopyFileOperation.fireAsync(
+            event,
+            CancellationToken.None
+        );
         return stats;
     }
     async delete(operations, token, undoInfo) {
         for (const operation of operations) {
-            const validateDelete = await this.fileService.canDelete(operation.resource, { recursive: operation.recursive, useTrash: operation.useTrash });
+            const validateDelete = await this.fileService.canDelete(operation.resource, {
+                recursive: operation.recursive,
+                useTrash: operation.useTrash
+            });
             if (validateDelete instanceof Error) {
                 throw validateDelete;
             }
         }
-        const files = ( operations.map(operation => ({ target: operation.resource })));
+        const files = ( operations.map(operation => ({
+            target: operation.resource
+        })));
         await this.runFileOperationParticipants(files, FileOperation.DELETE, undoInfo, token);
-        const event = { correlationId: this.correlationIds++, operation: FileOperation.DELETE, files };
-        await this._onWillRunWorkingCopyFileOperation.fireAsync(event, CancellationToken.None );
+        const event = {
+            correlationId: this.correlationIds++,
+            operation: FileOperation.DELETE,
+            files
+        };
+        await this._onWillRunWorkingCopyFileOperation.fireAsync(
+            event,
+            CancellationToken.None
+        );
         for (const operation of operations) {
             const dirtyWorkingCopies = this.getDirty(operation.resource);
-            await Promises.settled(( dirtyWorkingCopies.map(dirtyWorkingCopy => dirtyWorkingCopy.revert({ soft: true }))));
+            await Promises.settled(( dirtyWorkingCopies.map(dirtyWorkingCopy => dirtyWorkingCopy.revert({
+                soft: true
+            }))));
         }
         try {
             for (const operation of operations) {
-                await this.fileService.del(operation.resource, { recursive: operation.recursive, useTrash: operation.useTrash });
+                await this.fileService.del(operation.resource, {
+                    recursive: operation.recursive,
+                    useTrash: operation.useTrash
+                });
             }
-        }
-        catch (error) {
-            await this._onDidFailWorkingCopyFileOperation.fireAsync(event, CancellationToken.None );
+        } catch (error) {
+            await this._onDidFailWorkingCopyFileOperation.fireAsync(
+                event,
+                CancellationToken.None
+            );
             throw error;
         }
-        await this._onDidRunWorkingCopyFileOperation.fireAsync(event, CancellationToken.None );
+        await this._onDidRunWorkingCopyFileOperation.fireAsync(
+            event,
+            CancellationToken.None
+        );
     }
     addFileOperationParticipant(participant) {
         return this.fileOperationParticipants.addFileOperationParticipant(participant);
@@ -151,7 +213,9 @@ let WorkingCopyFileService = class WorkingCopyFileService extends Disposable {
     runFileOperationParticipants(files, operation, undoInfo, token) {
         return this.fileOperationParticipants.participate(files, operation, undoInfo, token);
     }
-    get hasSaveParticipants() { return this.saveParticipants.length > 0; }
+    get hasSaveParticipants() {
+        return this.saveParticipants.length > 0;
+    }
     addSaveParticipant(participant) {
         return this.saveParticipants.addSaveParticipant(participant);
     }
@@ -174,11 +238,6 @@ let WorkingCopyFileService = class WorkingCopyFileService extends Disposable {
         return Array.from(dirtyWorkingCopies);
     }
 };
-WorkingCopyFileService = ( __decorate([
-    ( __param(0, IFileService)),
-    ( __param(1, IWorkingCopyService)),
-    ( __param(2, IInstantiationService)),
-    ( __param(3, IUriIdentityService))
-], WorkingCopyFileService));
+WorkingCopyFileService = ( __decorate([( __param(0, IFileService)), ( __param(1, IWorkingCopyService)), ( __param(2, IInstantiationService)), ( __param(3, IUriIdentityService))], WorkingCopyFileService));
 
 export { WorkingCopyFileService };