@codingame/monaco-vscode-api 7.1.0 → 8.0.0

package/vscode/src/vs/editor/common/config/editorConfigurationSchema.js

@@ -1,15 +1,14 @@
 import { diffEditorDefaultOptions } from './diffEditor.js';
 import { editorOptionsRegistry } from './editorOptions.js';
 import { EDITOR_MODEL_DEFAULTS } from '../core/textModelDefaults.js';
-import { localizeWithPath } from '../../../nls.js';
+import { localize } from '../../../nls.js';
 import { ConfigurationScope, Extensions } from '../../../platform/configuration/common/configurationRegistry.js';
 import { Registry } from '../../../platform/registry/common/platform.js';
-const _moduleId = "vs/editor/common/config/editorConfigurationSchema";
 const editorConfigurationBaseNode = ( (Object.freeze({
     id: 'editor',
     order: 5,
     type: 'object',
-    title: ( localizeWithPath(_moduleId, 0, "Editor")),
+    title: ( localize(1119, "Editor")),
     scope: ConfigurationScope.LANGUAGE_OVERRIDABLE,
 })));
 const editorConfiguration = {
@@ -19,9 +18,8 @@ const editorConfiguration = {
             type: 'number',
             default: EDITOR_MODEL_DEFAULTS.tabSize,
             minimum: 1,
-            markdownDescription: ( localizeWithPath(
-                _moduleId,
-                1,
+            markdownDescription: ( localize(
+                1120,
                 "The number of spaces a tab is equal to. This setting is overridden based on the file contents when {0} is on.",
                 '`#editor.detectIndentation#`'
             ))
@@ -38,18 +36,16 @@ const editorConfiguration = {
                 }
             ],
             default: 'tabSize',
-            markdownDescription: ( localizeWithPath(
-                _moduleId,
-                2,
+            markdownDescription: ( localize(
+                1121,
                 "The number of spaces used for indentation or `\"tabSize\"` to use the value from `#editor.tabSize#`. This setting is overridden based on the file contents when `#editor.detectIndentation#` is on."
             ))
         },
         'editor.insertSpaces': {
             type: 'boolean',
             default: EDITOR_MODEL_DEFAULTS.insertSpaces,
-            markdownDescription: ( localizeWithPath(
-                _moduleId,
-                3,
+            markdownDescription: ( localize(
+                1122,
                 "Insert spaces when pressing `Tab`. This setting is overridden based on the file contents when {0} is on.",
                 '`#editor.detectIndentation#`'
             ))
@@ -57,9 +53,8 @@ const editorConfiguration = {
         'editor.detectIndentation': {
             type: 'boolean',
             default: EDITOR_MODEL_DEFAULTS.detectIndentation,
-            markdownDescription: ( localizeWithPath(
-                _moduleId,
-                4,
+            markdownDescription: ( localize(
+                1123,
                 "Controls whether {0} and {1} will be automatically detected when a file is opened based on the file contents.",
                 '`#editor.tabSize#`',
                 '`#editor.insertSpaces#`'
@@ -68,14 +63,13 @@ const editorConfiguration = {
         'editor.trimAutoWhitespace': {
             type: 'boolean',
             default: EDITOR_MODEL_DEFAULTS.trimAutoWhitespace,
-            description: ( localizeWithPath(_moduleId, 5, "Remove trailing auto inserted whitespace."))
+            description: ( localize(1124, "Remove trailing auto inserted whitespace."))
         },
         'editor.largeFileOptimizations': {
             type: 'boolean',
             default: EDITOR_MODEL_DEFAULTS.largeFileOptimizations,
-            description: ( localizeWithPath(
-                _moduleId,
-                6,
+            description: ( localize(
+                1125,
                 "Special handling for large files to disable certain memory intensive features."
             ))
         },
@@ -83,63 +77,53 @@ const editorConfiguration = {
             enum: ['off', 'currentDocument', 'matchingDocuments', 'allDocuments'],
             default: 'matchingDocuments',
             enumDescriptions: [
-                ( localizeWithPath(_moduleId, 7, 'Turn off Word Based Suggestions.')),
-                ( localizeWithPath(_moduleId, 8, 'Only suggest words from the active document.')),
-                ( localizeWithPath(
-                    _moduleId,
-                    9,
-                    'Suggest words from all open documents of the same language.'
-                )),
-                ( localizeWithPath(_moduleId, 10, 'Suggest words from all open documents.'))
+                ( localize(1126, 'Turn off Word Based Suggestions.')),
+                ( localize(1127, 'Only suggest words from the active document.')),
+                ( localize(1128, 'Suggest words from all open documents of the same language.')),
+                ( localize(1129, 'Suggest words from all open documents.'))
             ],
-            description: ( localizeWithPath(
-                _moduleId,
-                11,
+            description: ( localize(
+                1130,
                 "Controls whether completions should be computed based on words in the document and from which documents they are computed."
             ))
         },
         'editor.semanticHighlighting.enabled': {
             enum: [true, false, 'configuredByTheme'],
             enumDescriptions: [
-                ( localizeWithPath(_moduleId, 12, 'Semantic highlighting enabled for all color themes.')),
-                ( localizeWithPath(_moduleId, 13, 'Semantic highlighting disabled for all color themes.')),
-                ( localizeWithPath(
-                    _moduleId,
-                    14,
+                ( localize(1131, 'Semantic highlighting enabled for all color themes.')),
+                ( localize(1132, 'Semantic highlighting disabled for all color themes.')),
+                ( localize(
+                    1133,
                     'Semantic highlighting is configured by the current color theme\'s `semanticHighlighting` setting.'
                 ))
             ],
             default: 'configuredByTheme',
-            description: ( localizeWithPath(
-                _moduleId,
-                15,
+            description: ( localize(
+                1134,
                 "Controls whether the semanticHighlighting is shown for the languages that support it."
             ))
         },
         'editor.stablePeek': {
             type: 'boolean',
             default: false,
-            markdownDescription: ( localizeWithPath(
-                _moduleId,
-                16,
+            markdownDescription: ( localize(
+                1135,
                 "Keep peek editors open even when double-clicking their content or when hitting `Escape`."
             ))
         },
         'editor.maxTokenizationLineLength': {
             type: 'integer',
             default: 20_000,
-            description: ( localizeWithPath(
-                _moduleId,
-                17,
+            description: ( localize(
+                1136,
                 "Lines above this length will not be tokenized for performance reasons"
             ))
         },
         'editor.experimental.asyncTokenization': {
             type: 'boolean',
             default: false,
-            description: ( localizeWithPath(
-                _moduleId,
-                18,
+            description: ( localize(
+                1137,
                 "Controls whether the tokenization should happen asynchronously on a web worker."
             )),
             tags: ['experimental'],
@@ -147,18 +131,16 @@ const editorConfiguration = {
         'editor.experimental.asyncTokenizationLogging': {
             type: 'boolean',
             default: false,
-            description: ( localizeWithPath(
-                _moduleId,
-                19,
+            description: ( localize(
+                1138,
                 "Controls whether async tokenization should be logged. For debugging only."
             )),
         },
         'editor.experimental.asyncTokenizationVerification': {
             type: 'boolean',
             default: false,
-            description: ( localizeWithPath(
-                _moduleId,
-                20,
+            description: ( localize(
+                1139,
                 "Controls whether async tokenization should be verified against legacy background tokenization. Might slow down tokenization. For debugging only."
             )),
             tags: ['experimental'],
@@ -166,9 +148,8 @@ const editorConfiguration = {
         'editor.language.brackets': {
             type: ['array', 'null'],
             default: null,
-            description: ( localizeWithPath(
-                _moduleId,
-                21,
+            description: ( localize(
+                1140,
                 'Defines the bracket symbols that increase or decrease the indentation.'
             )),
             items: {
@@ -176,11 +157,11 @@ const editorConfiguration = {
                 items: [
                     {
                         type: 'string',
-                        description: ( localizeWithPath(_moduleId, 22, 'The opening bracket character or string sequence.'))
+                        description: ( localize(1141, 'The opening bracket character or string sequence.'))
                     },
                     {
                         type: 'string',
-                        description: ( localizeWithPath(_moduleId, 23, 'The closing bracket character or string sequence.'))
+                        description: ( localize(1142, 'The closing bracket character or string sequence.'))
                     }
                 ]
             }
@@ -188,9 +169,8 @@ const editorConfiguration = {
         'editor.language.colorizedBracketPairs': {
             type: ['array', 'null'],
             default: null,
-            description: ( localizeWithPath(
-                _moduleId,
-                24,
+            description: ( localize(
+                1143,
                 'Defines the bracket pairs that are colorized by their nesting level if bracket pair colorization is enabled.'
             )),
             items: {
@@ -198,11 +178,11 @@ const editorConfiguration = {
                 items: [
                     {
                         type: 'string',
-                        description: ( localizeWithPath(_moduleId, 22, 'The opening bracket character or string sequence.'))
+                        description: ( localize(1143, 'The opening bracket character or string sequence.'))
                     },
                     {
                         type: 'string',
-                        description: ( localizeWithPath(_moduleId, 23, 'The closing bracket character or string sequence.'))
+                        description: ( localize(1143, 'The closing bracket character or string sequence.'))
                     }
                 ]
             }
@@ -210,99 +190,89 @@ const editorConfiguration = {
         'diffEditor.maxComputationTime': {
             type: 'number',
             default: diffEditorDefaultOptions.maxComputationTime,
-            description: ( localizeWithPath(
-                _moduleId,
-                25,
+            description: ( localize(
+                1144,
                 "Timeout in milliseconds after which diff computation is cancelled. Use 0 for no timeout."
             ))
         },
         'diffEditor.maxFileSize': {
             type: 'number',
             default: diffEditorDefaultOptions.maxFileSize,
-            description: ( localizeWithPath(
-                _moduleId,
-                26,
+            description: ( localize(
+                1145,
                 "Maximum file size in MB for which to compute diffs. Use 0 for no limit."
             ))
         },
         'diffEditor.renderSideBySide': {
             type: 'boolean',
             default: diffEditorDefaultOptions.renderSideBySide,
-            description: ( localizeWithPath(
-                _moduleId,
-                27,
+            description: ( localize(
+                1146,
                 "Controls whether the diff editor shows the diff side by side or inline."
             ))
         },
         'diffEditor.renderSideBySideInlineBreakpoint': {
             type: 'number',
             default: diffEditorDefaultOptions.renderSideBySideInlineBreakpoint,
-            description: ( localizeWithPath(
-                _moduleId,
-                28,
+            description: ( localize(
+                1147,
                 "If the diff editor width is smaller than this value, the inline view is used."
             ))
         },
         'diffEditor.useInlineViewWhenSpaceIsLimited': {
             type: 'boolean',
             default: diffEditorDefaultOptions.useInlineViewWhenSpaceIsLimited,
-            description: ( localizeWithPath(
-                _moduleId,
-                29,
+            description: ( localize(
+                1148,
                 "If enabled and the editor width is too small, the inline view is used."
             ))
         },
         'diffEditor.renderMarginRevertIcon': {
             type: 'boolean',
             default: diffEditorDefaultOptions.renderMarginRevertIcon,
-            description: ( localizeWithPath(
-                _moduleId,
-                30,
+            description: ( localize(
+                1149,
                 "When enabled, the diff editor shows arrows in its glyph margin to revert changes."
             ))
         },
         'diffEditor.renderGutterMenu': {
             type: 'boolean',
             default: diffEditorDefaultOptions.renderGutterMenu,
-            description: ( localizeWithPath(
-                _moduleId,
-                31,
+            description: ( localize(
+                1150,
                 "When enabled, the diff editor shows a special gutter for revert and stage actions."
             ))
         },
         'diffEditor.ignoreTrimWhitespace': {
             type: 'boolean',
             default: diffEditorDefaultOptions.ignoreTrimWhitespace,
-            description: ( localizeWithPath(
-                _moduleId,
-                32,
+            description: ( localize(
+                1151,
                 "When enabled, the diff editor ignores changes in leading or trailing whitespace."
             ))
         },
         'diffEditor.renderIndicators': {
             type: 'boolean',
             default: diffEditorDefaultOptions.renderIndicators,
-            description: ( localizeWithPath(
-                _moduleId,
-                33,
+            description: ( localize(
+                1152,
                 "Controls whether the diff editor shows +/- indicators for added/removed changes."
             ))
         },
         'diffEditor.codeLens': {
             type: 'boolean',
             default: diffEditorDefaultOptions.diffCodeLens,
-            description: ( localizeWithPath(_moduleId, 34, "Controls whether the editor shows CodeLens."))
+            description: ( localize(1153, "Controls whether the editor shows CodeLens."))
         },
         'diffEditor.wordWrap': {
             type: 'string',
             enum: ['off', 'on', 'inherit'],
             default: diffEditorDefaultOptions.diffWordWrap,
             markdownEnumDescriptions: [
-                ( localizeWithPath(_moduleId, 35, "Lines will never wrap.")),
-                ( localizeWithPath(_moduleId, 36, "Lines will wrap at the viewport width.")),
-                ( localizeWithPath(
-                    _moduleId,
-                    37,
+                ( localize(1154, "Lines will never wrap.")),
+                ( localize(1155, "Lines will wrap at the viewport width.")),
+                ( localize(
+                    1156,
                     "Lines will wrap according to the {0} setting.",
                     '`#editor.wordWrap#`'
                 )),
@@ -313,28 +283,27 @@ const editorConfiguration = {
             enum: ['legacy', 'advanced'],
             default: diffEditorDefaultOptions.diffAlgorithm,
             markdownEnumDescriptions: [
-                ( localizeWithPath(_moduleId, 38, "Uses the legacy diffing algorithm.")),
-                ( localizeWithPath(_moduleId, 39, "Uses the advanced diffing algorithm.")),
+                ( localize(1157, "Uses the legacy diffing algorithm.")),
+                ( localize(1158, "Uses the advanced diffing algorithm.")),
             ],
             tags: ['experimental'],
         },
         'diffEditor.hideUnchangedRegions.enabled': {
             type: 'boolean',
             default: diffEditorDefaultOptions.hideUnchangedRegions.enabled,
-            markdownDescription: ( localizeWithPath(_moduleId, 40, "Controls whether the diff editor shows unchanged regions.")),
+            markdownDescription: ( localize(1159, "Controls whether the diff editor shows unchanged regions.")),
         },
         'diffEditor.hideUnchangedRegions.revealLineCount': {
             type: 'integer',
             default: diffEditorDefaultOptions.hideUnchangedRegions.revealLineCount,
-            markdownDescription: ( localizeWithPath(_moduleId, 41, "Controls how many lines are used for unchanged regions.")),
+            markdownDescription: ( localize(1160, "Controls how many lines are used for unchanged regions.")),
             minimum: 1,
         },
         'diffEditor.hideUnchangedRegions.minimumLineCount': {
             type: 'integer',
             default: diffEditorDefaultOptions.hideUnchangedRegions.minimumLineCount,
-            markdownDescription: ( localizeWithPath(
-                _moduleId,
-                42,
+            markdownDescription: ( localize(
+                1161,
                 "Controls how many lines are used as a minimum for unchanged regions."
             )),
             minimum: 1,
@@ -342,9 +311,8 @@ const editorConfiguration = {
         'diffEditor.hideUnchangedRegions.contextLineCount': {
             type: 'integer',
             default: diffEditorDefaultOptions.hideUnchangedRegions.contextLineCount,
-            markdownDescription: ( localizeWithPath(
-                _moduleId,
-                43,
+            markdownDescription: ( localize(
+                1162,
                 "Controls how many lines are used as context when comparing unchanged regions."
             )),
             minimum: 1,
@@ -352,21 +320,24 @@ const editorConfiguration = {
         'diffEditor.experimental.showMoves': {
             type: 'boolean',
             default: diffEditorDefaultOptions.experimental.showMoves,
-            markdownDescription: ( localizeWithPath(
-                _moduleId,
-                44,
-                "Controls whether the diff editor should show detected code moves."
-            ))
+            markdownDescription: ( localize(1163, "Controls whether the diff editor should show detected code moves."))
         },
         'diffEditor.experimental.showEmptyDecorations': {
             type: 'boolean',
             default: diffEditorDefaultOptions.experimental.showEmptyDecorations,
-            description: ( localizeWithPath(
-                _moduleId,
-                45,
+            description: ( localize(
+                1164,
                 "Controls whether the diff editor shows empty decorations to see where characters got inserted or deleted."
             )),
-        }
+        },
+        'diffEditor.experimental.useTrueInlineView': {
+            type: 'boolean',
+            default: diffEditorDefaultOptions.experimental.useTrueInlineView,
+            description: ( localize(
+                1165,
+                "If enabled and the editor uses the inline view, word changes are rendered inline."
+            )),
+        },
     }
 };
 function isConfigurationPropertySchema(x) {

package/vscode/src/vs/editor/common/config/editorOptions.d.ts

@@ -753,6 +753,11 @@ interface IDiffEditorBaseOptions {
      * and the diff editor has a width less than `renderSideBySideInlineBreakpoint`, the inline view is used.
      */
     useInlineViewWhenSpaceIsLimited?: boolean;
+    /**
+     * If set, the diff editor is optimized for small views.
+     * Defaults to `false`.
+    */
+    compactMode?: boolean;
     /**
      * Timeout in milliseconds after which diff computation is cancelled.
      * Defaults to 5000.
@@ -815,6 +820,10 @@ interface IDiffEditorBaseOptions {
          */
         showMoves?: boolean;
         showEmptyDecorations?: boolean;
+        /**
+         * Only applies when `renderSideBySide` is set to false.
+        */
+        useTrueInlineView?: boolean;
     };
     /**
      * Is the diff editor inside another editor
@@ -890,11 +899,13 @@ interface IGotoLocationOptions {
     multipleDeclarations?: GoToLocationValues;
     multipleImplementations?: GoToLocationValues;
     multipleReferences?: GoToLocationValues;
+    multipleTests?: GoToLocationValues;
     alternativeDefinitionCommand?: string;
     alternativeTypeDefinitionCommand?: string;
     alternativeDeclarationCommand?: string;
     alternativeImplementationCommand?: string;
     alternativeReferenceCommand?: string;
+    alternativeTestsCommand?: string;
 }
 /**
  * Configuration options for editor hover
@@ -1242,7 +1253,6 @@ interface IInlineEditOptions {
      * Does not clear active inline suggestions when the editor loses focus.
      */
     keepOnBlur?: boolean;
-    backgroundColoring?: boolean;
 }
 interface IBracketPairColorizationOptions {
     /**