@codingame/monaco-vscode-api 1.83.1 → 1.83.3-next.0

package/vscode/src/vs/workbench/services/untitled/common/untitledTextEditorService.js

@@ -8,7 +8,7 @@ import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
 import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
 import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 var UntitledTextEditorService_1;
-const IUntitledTextEditorService = ( (createDecorator('untitledTextEditorService')));
+const IUntitledTextEditorService = ( createDecorator('untitledTextEditorService'));
 let UntitledTextEditorService = class UntitledTextEditorService extends Disposable {
     static { UntitledTextEditorService_1 = this; }
     static { this.UNTITLED_WITHOUT_ASSOCIATED_RESOURCE_REGEX = /Untitled-\d+/; }
@@ -16,15 +16,15 @@ let UntitledTextEditorService = class UntitledTextEditorService extends Disposab
         super();
         this.instantiationService = instantiationService;
         this.configurationService = configurationService;
-        this._onDidChangeDirty = this._register(( (new Emitter())));
+        this._onDidChangeDirty = this._register(( new Emitter()));
         this.onDidChangeDirty = this._onDidChangeDirty.event;
-        this._onDidChangeEncoding = this._register(( (new Emitter())));
+        this._onDidChangeEncoding = this._register(( new Emitter()));
         this.onDidChangeEncoding = this._onDidChangeEncoding.event;
-        this._onWillDispose = this._register(( (new Emitter())));
+        this._onWillDispose = this._register(( new Emitter()));
         this.onWillDispose = this._onWillDispose.event;
-        this._onDidChangeLabel = this._register(( (new Emitter())));
+        this._onDidChangeLabel = this._register(( new Emitter()));
         this.onDidChangeLabel = this._onDidChangeLabel.event;
-        this.mapResourceToModel = ( (new ResourceMap()));
+        this.mapResourceToModel = ( new ResourceMap());
     }
     get(resource) {
         return this.mapResourceToModel.get(resource);
@@ -42,7 +42,7 @@ let UntitledTextEditorService = class UntitledTextEditorService extends Disposab
     }
     doCreateOrGet(options = Object.create(null)) {
         const massagedOptions = this.massageOptions(options);
-        if (massagedOptions.untitledResource && ( (this.mapResourceToModel.has(massagedOptions.untitledResource)))) {
+        if (massagedOptions.untitledResource && ( this.mapResourceToModel.has(massagedOptions.untitledResource))) {
             return this.mapResourceToModel.get(massagedOptions.untitledResource);
         }
         return this.doCreate(massagedOptions);
@@ -50,13 +50,13 @@ let UntitledTextEditorService = class UntitledTextEditorService extends Disposab
     massageOptions(options) {
         const massagedOptions = Object.create(null);
         if (options.associatedResource) {
-            massagedOptions.untitledResource = ( (URI.from({
+            massagedOptions.untitledResource = ( URI.from({
                 scheme: Schemas.untitled,
                 authority: options.associatedResource.authority,
                 fragment: options.associatedResource.fragment,
                 path: options.associatedResource.path,
                 query: options.associatedResource.query
-            })));
+            }));
             massagedOptions.associatedResource = options.associatedResource;
         }
         else {
@@ -82,16 +82,16 @@ let UntitledTextEditorService = class UntitledTextEditorService extends Disposab
         if (!untitledResource) {
             let counter = 1;
             do {
-                untitledResource = ( ( URI.from({ scheme: Schemas.untitled, path: `Untitled-${counter}` })));
+                untitledResource = ( URI.from({ scheme: Schemas.untitled, path: `Untitled-${counter}` }));
                 counter++;
-            } while (( (this.mapResourceToModel.has(untitledResource))));
+            } while (( this.mapResourceToModel.has(untitledResource)));
         }
         const model = this._register(this.instantiationService.createInstance(UntitledTextEditorModel, untitledResource, !!options.associatedResource, options.initialValue, options.languageId, options.encoding));
         this.registerModel(model);
         return model;
     }
     registerModel(model) {
-        const modelListeners = ( (new DisposableStore()));
+        const modelListeners = ( new DisposableStore());
         modelListeners.add(model.onDidChangeDirty(() => this._onDidChangeDirty.fire(model)));
         modelListeners.add(model.onDidChangeName(() => this._onDidChangeLabel.fire(model)));
         modelListeners.add(model.onDidChangeEncoding(() => this._onDidChangeEncoding.fire(model)));
@@ -109,8 +109,8 @@ let UntitledTextEditorService = class UntitledTextEditorService extends Disposab
         return resource.scheme === Schemas.untitled && resource.path.length > 1 && !UntitledTextEditorService_1.UNTITLED_WITHOUT_ASSOCIATED_RESOURCE_REGEX.test(resource.path);
     }
 };
-UntitledTextEditorService = UntitledTextEditorService_1 = ( (__decorate([
-    ( (__param(0, IInstantiationService))),
-    ( (__param(1, IConfigurationService)))
-], UntitledTextEditorService)));
+UntitledTextEditorService = UntitledTextEditorService_1 = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IConfigurationService))
+], UntitledTextEditorService));
 export { IUntitledTextEditorService, UntitledTextEditorService };

package/vscode/src/vs/workbench/services/userDataProfile/common/userDataProfile.js

@@ -1,10 +1,13 @@
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
 import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
 import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
 const IUserDataProfileService = ( createDecorator('IUserDataProfileService'));
 const IUserDataProfileImportExportService = ( createDecorator('IUserDataProfileImportExportService'));
-const defaultUserDataProfileIcon = registerIcon('defaultProfile-icon', Codicon.settings, ( localize('defaultProfileIcon', 'Icon for Default Profile.')));
+const defaultUserDataProfileIcon = registerIcon('defaultProfile-icon', Codicon.settings, localizeWithPath('vs/workbench/services/userDataProfile/common/userDataProfile', 'defaultProfileIcon', 'Icon for Default Profile.'));
+({ value: localizeWithPath('vs/workbench/services/userDataProfile/common/userDataProfile', 'profiles', "Profiles"), original: 'Profiles' });
+const PROFILE_EXTENSION = 'code-profile';
+[{ name: localizeWithPath('vs/workbench/services/userDataProfile/common/userDataProfile', 'profile', "Profile"), extensions: [PROFILE_EXTENSION] }];
 const CURRENT_PROFILE_CONTEXT = ( new RawContextKey('currentProfile', ''));
-export { CURRENT_PROFILE_CONTEXT, IUserDataProfileImportExportService, IUserDataProfileService, defaultUserDataProfileIcon };
+export { CURRENT_PROFILE_CONTEXT, IUserDataProfileImportExportService, IUserDataProfileService, PROFILE_EXTENSION, defaultUserDataProfileIcon };

package/vscode/src/vs/workbench/services/userDataSync/common/userDataSync.js

@@ -1,7 +1,19 @@
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { ContextKeyExpr, RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
 import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+import { Categories } from 'monaco-editor/esm/vs/platform/action/common/actionCommonCategories.js';
 const IUserDataSyncWorkbenchService = ( createDecorator('IUserDataSyncWorkbenchService'));
-registerIcon('settings-sync-view-icon', Codicon.sync, ( localize('syncViewIcon', 'View icon of the Settings Sync view.')));
-export { IUserDataSyncWorkbenchService };
+localizeWithPath('vs/workbench/services/userDataSync/common/userDataSync', 'sync category', "Settings Sync");
+registerIcon('settings-sync-view-icon', Codicon.sync, localizeWithPath('vs/workbench/services/userDataSync/common/userDataSync', 'syncViewIcon', 'View icon of the Settings Sync view.'));
+const CONTEXT_SYNC_STATE = ( new RawContextKey('syncStatus', "uninitialized" ));
+const CONTEXT_ACCOUNT_STATE = ( new RawContextKey('userDataSyncAccountStatus', "unavailable" ));
+({
+    id: 'workbench.userDataSync.actions.downloadSyncActivity',
+    title: { original: 'Download Settings Sync Activity', value: localizeWithPath('vs/workbench/services/userDataSync/common/userDataSync', 'download sync activity title', "Download Settings Sync Activity") },
+    category: Categories.Developer,
+    f1: true,
+    precondition: ( ContextKeyExpr.and(( CONTEXT_ACCOUNT_STATE.isEqualTo("available" )), ( CONTEXT_SYNC_STATE.notEqualsTo("uninitialized" ))))
+});
+export { CONTEXT_ACCOUNT_STATE, CONTEXT_SYNC_STATE, IUserDataSyncWorkbenchService };

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

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { raceCancellation } from 'monaco-editor/esm/vs/base/common/async.js';
 import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
 import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
@@ -21,7 +21,7 @@ let StoredFileWorkingCopySaveParticipant = class StoredFileWorkingCopySavePartic
     participate(workingCopy, context, token) {
         const cts = ( new CancellationTokenSource(token));
         return this.progressService.withProgress({
-            title: ( localize('saveParticipants', "Saving '{0}'", workingCopy.name)),
+            title: localizeWithPath('vs/workbench/services/workingCopy/common/storedFileWorkingCopySaveParticipant', 'saveParticipants', "Saving '{0}'", workingCopy.name),
             location: 15 ,
             cancellable: true,
             delay: workingCopy.isDirty() ? 3000 : 5000

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

@@ -17,20 +17,20 @@ import { NO_TYPE_ID } from './workingCopy.js';
 var WorkingCopyBackupServiceImpl_1;
 class WorkingCopyBackupsModel {
     static async create(backupRoot, fileService) {
-        const model = ( (new WorkingCopyBackupsModel(backupRoot, fileService)));
+        const model = ( new WorkingCopyBackupsModel(backupRoot, fileService));
         await model.resolve();
         return model;
     }
     constructor(backupRoot, fileService) {
         this.backupRoot = backupRoot;
         this.fileService = fileService;
-        this.cache = ( (new ResourceMap()));
+        this.cache = ( new ResourceMap());
     }
     async resolve() {
         try {
             const backupRootStat = await this.fileService.resolve(this.backupRoot);
             if (backupRootStat.children) {
-                await Promises.settled(( (backupRootStat.children
+                await Promises.settled(( backupRootStat.children
                     .filter(child => child.isDirectory)
                     .map(async (backupSchemaFolder) => {
                     const backupSchemaFolderStat = await this.fileService.resolve(backupSchemaFolder.resource);
@@ -41,7 +41,7 @@ class WorkingCopyBackupsModel {
                             }
                         }
                     }
-                }))));
+                })));
             }
         }
         catch (error) {
@@ -76,7 +76,7 @@ class WorkingCopyBackupsModel {
         return true;
     }
     get() {
-        return Array.from(( (this.cache.keys())));
+        return Array.from(( this.cache.keys()));
     }
     remove(resource) {
         this.cache.delete(resource);
@@ -96,7 +96,7 @@ let WorkingCopyBackupServiceImpl = class WorkingCopyBackupServiceImpl extends Di
         this.backupWorkspaceHome = backupWorkspaceHome;
         this.fileService = fileService;
         this.logService = logService;
-        this.ioOperationQueues = this._register(( (new ResourceQueue())));
+        this.ioOperationQueues = this._register(( new ResourceQueue()));
         this.model = undefined;
         this.initialize(backupWorkspaceHome);
     }
@@ -118,9 +118,7 @@ let WorkingCopyBackupServiceImpl = class WorkingCopyBackupServiceImpl extends Di
             return false;
         }
         const backupResource = this.toBackupResource(identifier);
-        return (
-             (this.model.has(backupResource, versionId, meta))
-        );
+        return ( this.model.has(backupResource, versionId, meta));
     }
     async backup(identifier, content, versionId, meta, token) {
         const model = await this.ready;
@@ -128,14 +126,14 @@ let WorkingCopyBackupServiceImpl = class WorkingCopyBackupServiceImpl extends Di
             return;
         }
         const backupResource = this.toBackupResource(identifier);
-        if (( (model.has(backupResource, versionId, meta)))) {
+        if (( model.has(backupResource, versionId, meta))) {
             return;
         }
         return this.ioOperationQueues.queueFor(backupResource).queue(async () => {
             if (token?.isCancellationRequested) {
                 return;
             }
-            if (( (model.has(backupResource, versionId, meta)))) {
+            if (( model.has(backupResource, versionId, meta))) {
                 return;
             }
             let preamble = this.createPreamble(identifier, meta);
@@ -158,21 +156,21 @@ let WorkingCopyBackupServiceImpl = class WorkingCopyBackupServiceImpl extends Di
         });
     }
     createPreamble(identifier, meta) {
-        return `${( ( identifier.resource.toString()))}${WorkingCopyBackupServiceImpl_1.PREAMBLE_META_SEPARATOR}${JSON.stringify({ ...meta, typeId: identifier.typeId })}${WorkingCopyBackupServiceImpl_1.PREAMBLE_END_MARKER}`;
+        return `${( identifier.resource.toString())}${WorkingCopyBackupServiceImpl_1.PREAMBLE_META_SEPARATOR}${JSON.stringify({ ...meta, typeId: identifier.typeId })}${WorkingCopyBackupServiceImpl_1.PREAMBLE_END_MARKER}`;
     }
     async discardBackups(filter) {
         const model = await this.ready;
         const except = filter?.except;
         if (Array.isArray(except) && except.length > 0) {
-            const exceptMap = ( (new ResourceMap()));
+            const exceptMap = ( new ResourceMap());
             for (const exceptWorkingCopy of except) {
                 exceptMap.set(this.toBackupResource(exceptWorkingCopy), true);
             }
-            await Promises.settled(( (model.get().map(async (backupResource) => {
-                if (!( (exceptMap.has(backupResource)))) {
+            await Promises.settled(( model.get().map(async (backupResource) => {
+                if (!( exceptMap.has(backupResource))) {
                     await this.doDiscardBackup(backupResource);
                 }
-            }))));
+            })));
         }
         else {
             await this.deleteIgnoreFileNotFound(this.backupWorkspaceHome);
@@ -209,13 +207,13 @@ let WorkingCopyBackupServiceImpl = class WorkingCopyBackupServiceImpl extends Di
     async getBackups() {
         const model = await this.ready;
         await this.joinBackups();
-        const backups = await Promise.all(( (model.get().map(backupResource => this.resolveIdentifier(backupResource, model)))));
+        const backups = await Promise.all(( model.get().map(backupResource => this.resolveIdentifier(backupResource, model))));
         return coalesce(backups);
     }
     async resolveIdentifier(backupResource, model) {
         let res = undefined;
         await this.ioOperationQueues.queueFor(backupResource).queue(async () => {
-            if (!( (model.has(backupResource)))) {
+            if (!( model.has(backupResource))) {
                 return;
             }
             const backupPreamble = await this.readToMatchingString(backupResource, WorkingCopyBackupServiceImpl_1.PREAMBLE_END_MARKER, WorkingCopyBackupServiceImpl_1.PREAMBLE_MAX_LENGTH);
@@ -237,13 +235,13 @@ let WorkingCopyBackupServiceImpl = class WorkingCopyBackupServiceImpl extends Di
             model.update(backupResource, meta);
             res = {
                 typeId: typeId ?? NO_TYPE_ID,
-                resource: ( (URI.parse(resourcePreamble)))
+                resource: ( URI.parse(resourcePreamble))
             };
         });
         return res;
     }
     async readToMatchingString(backupResource, matchingString, maximumBytesToRead) {
-        const contents = ( ((await this.fileService.readFile(backupResource, { length: maximumBytesToRead })).value.toString()));
+        const contents = ( (await this.fileService.readFile(backupResource, { length: maximumBytesToRead })).value.toString());
         const matchingStringIndex = contents.indexOf(matchingString);
         if (matchingStringIndex >= 0) {
             return contents.substr(0, matchingStringIndex);
@@ -255,7 +253,7 @@ let WorkingCopyBackupServiceImpl = class WorkingCopyBackupServiceImpl extends Di
         const model = await this.ready;
         let res = undefined;
         await this.ioOperationQueues.queueFor(backupResource).queue(async () => {
-            if (!( (model.has(backupResource)))) {
+            if (!( model.has(backupResource))) {
                 return;
             }
             const backupStream = await this.fileService.readFileStream(backupResource);
@@ -266,7 +264,7 @@ let WorkingCopyBackupServiceImpl = class WorkingCopyBackupServiceImpl extends Di
                 this.logService.trace(`Backup: Could not find meta end marker in ${backupResource}. The file is probably corrupt (filesize: ${backupStream.size}).`);
                 return undefined;
             }
-            const preambelRaw = ( (firstBackupChunk.slice(0, preambleEndIndex).toString()));
+            const preambelRaw = ( firstBackupChunk.slice(0, preambleEndIndex).toString());
             let meta;
             const metaStartIndex = preambelRaw.indexOf(WorkingCopyBackupServiceImpl_1.PREAMBLE_META_SEPARATOR);
             if (metaStartIndex !== -1) {
@@ -311,23 +309,21 @@ let WorkingCopyBackupServiceImpl = class WorkingCopyBackupServiceImpl extends Di
         return this.ioOperationQueues.whenDrained();
     }
 };
-WorkingCopyBackupServiceImpl = WorkingCopyBackupServiceImpl_1 = ( (__decorate([
-    ( (__param(1, IFileService))),
-    ( (__param(2, ILogService)))
-], WorkingCopyBackupServiceImpl)));
+WorkingCopyBackupServiceImpl = WorkingCopyBackupServiceImpl_1 = ( __decorate([
+    ( __param(1, IFileService)),
+    ( __param(2, ILogService))
+], WorkingCopyBackupServiceImpl));
 class InMemoryWorkingCopyBackupService extends Disposable {
     constructor() {
         super();
-        this.backups = ( (new ResourceMap()));
+        this.backups = ( new ResourceMap());
     }
     async hasBackups() {
         return this.backups.size > 0;
     }
     hasBackupSync(identifier, versionId) {
         const backupResource = this.toBackupResource(identifier);
-        return (
-             (this.backups.has(backupResource))
-        );
+        return ( this.backups.has(backupResource));
     }
     async backup(identifier, content, versionId, meta, token) {
         const backupResource = this.toBackupResource(identifier);
@@ -346,9 +342,7 @@ class InMemoryWorkingCopyBackupService extends Disposable {
         return undefined;
     }
     async getBackups() {
-        return (
-             (Array.from(this.backups.entries()).map(([resource, backup]) => ({ typeId: backup.typeId, resource })))
-        );
+        return ( Array.from(this.backups.entries()).map(([resource, backup]) => ({ typeId: backup.typeId, resource })));
     }
     async discardBackup(identifier) {
         this.backups.delete(this.toBackupResource(identifier));
@@ -356,12 +350,12 @@ class InMemoryWorkingCopyBackupService extends Disposable {
     async discardBackups(filter) {
         const except = filter?.except;
         if (Array.isArray(except) && except.length > 0) {
-            const exceptMap = ( (new ResourceMap()));
+            const exceptMap = ( new ResourceMap());
             for (const exceptWorkingCopy of except) {
                 exceptMap.set(this.toBackupResource(exceptWorkingCopy), true);
             }
             for (const backup of await this.getBackups()) {
-                if (!( (exceptMap.has(this.toBackupResource(backup))))) {
+                if (!( exceptMap.has(this.toBackupResource(backup)))) {
                     await this.discardBackup(backup);
                 }
             }
@@ -371,9 +365,7 @@ class InMemoryWorkingCopyBackupService extends Disposable {
         }
     }
     toBackupResource(identifier) {
-        return (
-             (URI.from({ scheme: Schemas.inMemory, path: hashIdentifier(identifier) }))
-        );
+        return ( URI.from({ scheme: Schemas.inMemory, path: hashIdentifier(identifier) }));
     }
     async joinBackups() {
         return;
@@ -396,12 +388,10 @@ function hashIdentifier(identifier) {
     return hashPath(resource);
 }
 function hashPath(resource) {
-    const str = resource.scheme === Schemas.file || resource.scheme === Schemas.untitled ? resource.fsPath : ( (resource.toString()));
+    const str = resource.scheme === Schemas.file || resource.scheme === Schemas.untitled ? resource.fsPath : ( resource.toString());
     return hashString(str);
 }
 function hashString(str) {
-    return (
-         (hash(str).toString(16))
-    );
+    return ( hash(str).toString(16));
 }
 export { InMemoryWorkingCopyBackupService, WorkingCopyBackupsModel, hashIdentifier };