@codingame/monaco-vscode-api 1.83.2 → 1.83.3

package/vscode/src/vs/workbench/services/themes/common/tokenClassificationExtensionPoint.js

@@ -1,45 +1,30 @@
 import * as nls from 'monaco-editor/esm/vs/nls.js';
 import { ExtensionsRegistry } from '../../extensions/common/extensionsRegistry.js';
-import { getTokenClassificationRegistry, typeAndModifierIdPattern } from '../../../../platform/theme/common/tokenClassificationRegistry.js';
+import { typeAndModifierIdPattern, getTokenClassificationRegistry } from '../../../../platform/theme/common/tokenClassificationRegistry.js';
 const tokenClassificationRegistry = getTokenClassificationRegistry();
 const tokenTypeExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'semanticTokenTypes',
     jsonSchema: {
-        description: ( nls.localize('contributes.semanticTokenTypes', 'Contributes semantic token types.')),
+        description: nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'contributes.semanticTokenTypes', 'Contributes semantic token types.'),
         type: 'array',
         items: {
             type: 'object',
             properties: {
                 id: {
                     type: 'string',
-                    description: ( nls.localize(
-                        'contributes.semanticTokenTypes.id',
-                        'The identifier of the semantic token type'
-                    )),
+                    description: nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'contributes.semanticTokenTypes.id', 'The identifier of the semantic token type'),
                     pattern: typeAndModifierIdPattern,
-                    patternErrorMessage: ( nls.localize(
-                        'contributes.semanticTokenTypes.id.format',
-                        'Identifiers should be in the form letterOrDigit[_-letterOrDigit]*'
-                    )),
+                    patternErrorMessage: nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'contributes.semanticTokenTypes.id.format', 'Identifiers should be in the form letterOrDigit[_-letterOrDigit]*'),
                 },
                 superType: {
                     type: 'string',
-                    description: ( nls.localize(
-                        'contributes.semanticTokenTypes.superType',
-                        'The super type of the semantic token type'
-                    )),
+                    description: nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'contributes.semanticTokenTypes.superType', 'The super type of the semantic token type'),
                     pattern: typeAndModifierIdPattern,
-                    patternErrorMessage: ( nls.localize(
-                        'contributes.semanticTokenTypes.superType.format',
-                        'Super types should be in the form letterOrDigit[_-letterOrDigit]*'
-                    )),
+                    patternErrorMessage: nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'contributes.semanticTokenTypes.superType.format', 'Super types should be in the form letterOrDigit[_-letterOrDigit]*'),
                 },
                 description: {
                     type: 'string',
-                    description: ( nls.localize(
-                        'contributes.color.description',
-                        'The description of the semantic token type'
-                    )),
+                    description: nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'contributes.color.description', 'The description of the semantic token type'),
                 }
             }
         }
@@ -48,31 +33,19 @@ const tokenTypeExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
 const tokenModifierExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'semanticTokenModifiers',
     jsonSchema: {
-        description: ( nls.localize(
-            'contributes.semanticTokenModifiers',
-            'Contributes semantic token modifiers.'
-        )),
+        description: nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'contributes.semanticTokenModifiers', 'Contributes semantic token modifiers.'),
         type: 'array',
         items: {
             type: 'object',
             properties: {
                 id: {
                     type: 'string',
-                    description: ( nls.localize(
-                        'contributes.semanticTokenModifiers.id',
-                        'The identifier of the semantic token modifier'
-                    )),
+                    description: nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'contributes.semanticTokenModifiers.id', 'The identifier of the semantic token modifier'),
                     pattern: typeAndModifierIdPattern,
-                    patternErrorMessage: ( nls.localize(
-                        'contributes.semanticTokenModifiers.id.format',
-                        'Identifiers should be in the form letterOrDigit[_-letterOrDigit]*'
-                    ))
+                    patternErrorMessage: nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'contributes.semanticTokenModifiers.id.format', 'Identifiers should be in the form letterOrDigit[_-letterOrDigit]*')
                 },
                 description: {
-                    description: ( nls.localize(
-                        'contributes.semanticTokenModifiers.description',
-                        'The description of the semantic token modifier'
-                    ))
+                    description: nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'contributes.semanticTokenModifiers.description', 'The description of the semantic token modifier')
                 }
             }
         }
@@ -81,26 +54,17 @@ const tokenModifierExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
 const tokenStyleDefaultsExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'semanticTokenScopes',
     jsonSchema: {
-        description: ( nls.localize(
-            'contributes.semanticTokenScopes',
-            'Contributes semantic token scope maps.'
-        )),
+        description: nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'contributes.semanticTokenScopes', 'Contributes semantic token scope maps.'),
         type: 'array',
         items: {
             type: 'object',
             properties: {
                 language: {
-                    description: ( nls.localize(
-                        'contributes.semanticTokenScopes.languages',
-                        'Lists the languge for which the defaults are.'
-                    )),
+                    description: nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'contributes.semanticTokenScopes.languages', 'Lists the languge for which the defaults are.'),
                     type: 'string'
                 },
                 scopes: {
-                    description: ( nls.localize(
-                        'contributes.semanticTokenScopes.scopes',
-                        'Maps a semantic token (described by semantic token selector) to one or more textMate scopes used to represent that token.'
-                    )),
+                    description: nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'contributes.semanticTokenScopes.scopes', 'Maps a semantic token (described by semantic token selector) to one or more textMate scopes used to represent that token.'),
                     type: 'object',
                     additionalProperties: {
                         type: 'array',
@@ -117,36 +81,20 @@ class TokenClassificationExtensionPoints {
     constructor() {
         function validateTypeOrModifier(contribution, extensionPoint, collector) {
             if (typeof contribution.id !== 'string' || contribution.id.length === 0) {
-                collector.error(( nls.localize(
-                    'invalid.id',
-                    "'configuration.{0}.id' must be defined and can not be empty",
-                    extensionPoint
-                )));
+                collector.error(nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'invalid.id', "'configuration.{0}.id' must be defined and can not be empty", extensionPoint));
                 return false;
             }
             if (!contribution.id.match(typeAndModifierIdPattern)) {
-                collector.error(( nls.localize(
-                    'invalid.id.format',
-                    "'configuration.{0}.id' must follow the pattern letterOrDigit[-_letterOrDigit]*",
-                    extensionPoint
-                )));
+                collector.error(nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'invalid.id.format', "'configuration.{0}.id' must follow the pattern letterOrDigit[-_letterOrDigit]*", extensionPoint));
                 return false;
             }
             const superType = contribution.superType;
             if (superType && !superType.match(typeAndModifierIdPattern)) {
-                collector.error(( nls.localize(
-                    'invalid.superType.format',
-                    "'configuration.{0}.superType' must follow the pattern letterOrDigit[-_letterOrDigit]*",
-                    extensionPoint
-                )));
+                collector.error(nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'invalid.superType.format', "'configuration.{0}.superType' must follow the pattern letterOrDigit[-_letterOrDigit]*", extensionPoint));
                 return false;
             }
             if (typeof contribution.description !== 'string' || contribution.id.length === 0) {
-                collector.error(( nls.localize(
-                    'invalid.description',
-                    "'configuration.{0}.description' must be defined and can not be empty",
-                    extensionPoint
-                )));
+                collector.error(nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'invalid.description', "'configuration.{0}.description' must be defined and can not be empty", extensionPoint));
                 return false;
             }
             return true;
@@ -156,10 +104,7 @@ class TokenClassificationExtensionPoints {
                 const extensionValue = extension.value;
                 const collector = extension.collector;
                 if (!extensionValue || !Array.isArray(extensionValue)) {
-                    collector.error(( nls.localize(
-                        'invalid.semanticTokenTypeConfiguration',
-                        "'configuration.semanticTokenType' must be an array"
-                    )));
+                    collector.error(nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'invalid.semanticTokenTypeConfiguration', "'configuration.semanticTokenType' must be an array"));
                     return;
                 }
                 for (const contribution of extensionValue) {
@@ -180,10 +125,7 @@ class TokenClassificationExtensionPoints {
                 const extensionValue = extension.value;
                 const collector = extension.collector;
                 if (!extensionValue || !Array.isArray(extensionValue)) {
-                    collector.error(( nls.localize(
-                        'invalid.semanticTokenModifierConfiguration',
-                        "'configuration.semanticTokenModifier' must be an array"
-                    )));
+                    collector.error(nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'invalid.semanticTokenModifierConfiguration', "'configuration.semanticTokenModifier' must be an array"));
                     return;
                 }
                 for (const contribution of extensionValue) {
@@ -204,34 +146,22 @@ class TokenClassificationExtensionPoints {
                 const extensionValue = extension.value;
                 const collector = extension.collector;
                 if (!extensionValue || !Array.isArray(extensionValue)) {
-                    collector.error(( nls.localize(
-                        'invalid.semanticTokenScopes.configuration',
-                        "'configuration.semanticTokenScopes' must be an array"
-                    )));
+                    collector.error(nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'invalid.semanticTokenScopes.configuration', "'configuration.semanticTokenScopes' must be an array"));
                     return;
                 }
                 for (const contribution of extensionValue) {
                     if (contribution.language && typeof contribution.language !== 'string') {
-                        collector.error(( nls.localize(
-                            'invalid.semanticTokenScopes.language',
-                            "'configuration.semanticTokenScopes.language' must be a string"
-                        )));
+                        collector.error(nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'invalid.semanticTokenScopes.language', "'configuration.semanticTokenScopes.language' must be a string"));
                         continue;
                     }
                     if (!contribution.scopes || typeof contribution.scopes !== 'object') {
-                        collector.error(( nls.localize(
-                            'invalid.semanticTokenScopes.scopes',
-                            "'configuration.semanticTokenScopes.scopes' must be defined as an object"
-                        )));
+                        collector.error(nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'invalid.semanticTokenScopes.scopes', "'configuration.semanticTokenScopes.scopes' must be defined as an object"));
                         continue;
                     }
                     for (const selectorString in contribution.scopes) {
                         const tmScopes = contribution.scopes[selectorString];
                         if (!Array.isArray(tmScopes) || ( tmScopes.some(l => typeof l !== 'string'))) {
-                            collector.error(( nls.localize(
-                                'invalid.semanticTokenScopes.scopes.value',
-                                "'configuration.semanticTokenScopes.scopes' values must be an array of strings"
-                            )));
+                            collector.error(nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'invalid.semanticTokenScopes.scopes.value', "'configuration.semanticTokenScopes.scopes' values must be an array of strings"));
                             continue;
                         }
                         try {
@@ -239,11 +169,7 @@ class TokenClassificationExtensionPoints {
                             tokenClassificationRegistry.registerTokenStyleDefault(selector, { scopesToProbe: ( tmScopes.map(s => s.split(' '))) });
                         }
                         catch (e) {
-                            collector.error(( nls.localize(
-                                'invalid.semanticTokenScopes.scopes.selector',
-                                "configuration.semanticTokenScopes.scopes': Problems parsing selector {0}.",
-                                selectorString
-                            )));
+                            collector.error(nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'invalid.semanticTokenScopes.scopes.selector', "configuration.semanticTokenScopes.scopes': Problems parsing selector {0}.", selectorString));
                         }
                     }
                 }

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