monaco-editor11 1.1.0 → 1.1.2

package/dist/workers/editorConfigurationSchema.js

@@ -0,0 +1,338 @@
+import { diffEditorDefaultOptions } from './diffEditor.js';
+import { editorOptionsRegistry } from './editorOptions.js';
+import { EDITOR_MODEL_DEFAULTS } from '../core/misc/textModelDefaults.js';
+import { localize } from '../../../nls.js';
+import { Extensions } from '../../../platform/configuration/common/configurationRegistry.js';
+import { Registry } from '../../../platform/registry/common/platform.js';
+
+const editorConfigurationBaseNode = Object.freeze({
+    id: 'editor',
+    order: 5,
+    type: 'object',
+    title: localize(147, "Editor"),
+    scope: 6 /* ConfigurationScope.LANGUAGE_OVERRIDABLE */,
+});
+const editorConfiguration = {
+    ...editorConfigurationBaseNode,
+    properties: {
+        'editor.tabSize': {
+            type: 'number',
+            default: EDITOR_MODEL_DEFAULTS.tabSize,
+            minimum: 1,
+            maximum: 100,
+            markdownDescription: localize(148, "The number of spaces a tab is equal to. This setting is overridden based on the file contents when {0} is on.", '`#editor.detectIndentation#`')
+        },
+        'editor.indentSize': {
+            'anyOf': [
+                {
+                    type: 'string',
+                    enum: ['tabSize']
+                },
+                {
+                    type: 'number',
+                    minimum: 1
+                }
+            ],
+            default: 'tabSize',
+            markdownDescription: localize(149, "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: localize(150, "Insert spaces when pressing `Tab`. This setting is overridden based on the file contents when {0} is on.", '`#editor.detectIndentation#`')
+        },
+        'editor.detectIndentation': {
+            type: 'boolean',
+            default: EDITOR_MODEL_DEFAULTS.detectIndentation,
+            markdownDescription: localize(151, "Controls whether {0} and {1} will be automatically detected when a file is opened based on the file contents.", '`#editor.tabSize#`', '`#editor.insertSpaces#`')
+        },
+        'editor.trimAutoWhitespace': {
+            type: 'boolean',
+            default: EDITOR_MODEL_DEFAULTS.trimAutoWhitespace,
+            description: localize(152, "Remove trailing auto inserted whitespace.")
+        },
+        'editor.largeFileOptimizations': {
+            type: 'boolean',
+            default: EDITOR_MODEL_DEFAULTS.largeFileOptimizations,
+            description: localize(153, "Special handling for large files to disable certain memory intensive features.")
+        },
+        'editor.wordBasedSuggestions': {
+            enum: ['off', 'currentDocument', 'matchingDocuments', 'allDocuments'],
+            default: 'matchingDocuments',
+            enumDescriptions: [
+                localize(154, 'Turn off Word Based Suggestions.'),
+                localize(155, 'Only suggest words from the active document.'),
+                localize(156, 'Suggest words from all open documents of the same language.'),
+                localize(157, 'Suggest words from all open documents.')
+            ],
+            description: localize(158, "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: [
+                localize(159, 'Semantic highlighting enabled for all color themes.'),
+                localize(160, 'Semantic highlighting disabled for all color themes.'),
+                localize(161, 'Semantic highlighting is configured by the current color theme\'s `semanticHighlighting` setting.')
+            ],
+            default: 'configuredByTheme',
+            description: localize(162, "Controls whether the semanticHighlighting is shown for the languages that support it.")
+        },
+        'editor.stablePeek': {
+            type: 'boolean',
+            default: false,
+            markdownDescription: localize(163, "Keep peek editors open even when double-clicking their content or when hitting `Escape`.")
+        },
+        'editor.maxTokenizationLineLength': {
+            type: 'integer',
+            default: 20_000,
+            description: localize(164, "Lines above this length will not be tokenized for performance reasons")
+        },
+        'editor.experimental.asyncTokenization': {
+            type: 'boolean',
+            default: true,
+            description: localize(165, "Controls whether the tokenization should happen asynchronously on a web worker."),
+            tags: ['experimental'],
+        },
+        'editor.experimental.asyncTokenizationLogging': {
+            type: 'boolean',
+            default: false,
+            description: localize(166, "Controls whether async tokenization should be logged. For debugging only."),
+        },
+        'editor.experimental.asyncTokenizationVerification': {
+            type: 'boolean',
+            default: false,
+            description: localize(167, "Controls whether async tokenization should be verified against legacy background tokenization. Might slow down tokenization. For debugging only."),
+            tags: ['experimental'],
+        },
+        'editor.experimental.treeSitterTelemetry': {
+            type: 'boolean',
+            default: false,
+            markdownDescription: localize(168, "Controls whether tree sitter parsing should be turned on and telemetry collected. Setting `#editor.experimental.preferTreeSitter#` for specific languages will take precedence."),
+            tags: ['experimental'],
+            experiment: {
+                mode: 'auto'
+            }
+        },
+        'editor.experimental.preferTreeSitter.css': {
+            type: 'boolean',
+            default: false,
+            markdownDescription: localize(169, "Controls whether tree sitter parsing should be turned on for css. This will take precedence over `#editor.experimental.treeSitterTelemetry#` for css."),
+            tags: ['experimental'],
+            experiment: {
+                mode: 'auto'
+            }
+        },
+        'editor.experimental.preferTreeSitter.typescript': {
+            type: 'boolean',
+            default: false,
+            markdownDescription: localize(170, "Controls whether tree sitter parsing should be turned on for typescript. This will take precedence over `#editor.experimental.treeSitterTelemetry#` for typescript."),
+            tags: ['experimental'],
+            experiment: {
+                mode: 'auto'
+            }
+        },
+        'editor.experimental.preferTreeSitter.ini': {
+            type: 'boolean',
+            default: false,
+            markdownDescription: localize(171, "Controls whether tree sitter parsing should be turned on for ini. This will take precedence over `#editor.experimental.treeSitterTelemetry#` for ini."),
+            tags: ['experimental'],
+            experiment: {
+                mode: 'auto'
+            }
+        },
+        'editor.experimental.preferTreeSitter.regex': {
+            type: 'boolean',
+            default: false,
+            markdownDescription: localize(172, "Controls whether tree sitter parsing should be turned on for regex. This will take precedence over `#editor.experimental.treeSitterTelemetry#` for regex."),
+            tags: ['experimental'],
+            experiment: {
+                mode: 'auto'
+            }
+        },
+        'editor.language.brackets': {
+            type: ['array', 'null'],
+            default: null, // We want to distinguish the empty array from not configured.
+            description: localize(173, 'Defines the bracket symbols that increase or decrease the indentation.'),
+            items: {
+                type: 'array',
+                items: [
+                    {
+                        type: 'string',
+                        description: localize(174, 'The opening bracket character or string sequence.')
+                    },
+                    {
+                        type: 'string',
+                        description: localize(175, 'The closing bracket character or string sequence.')
+                    }
+                ]
+            }
+        },
+        'editor.language.colorizedBracketPairs': {
+            type: ['array', 'null'],
+            default: null, // We want to distinguish the empty array from not configured.
+            description: localize(176, 'Defines the bracket pairs that are colorized by their nesting level if bracket pair colorization is enabled.'),
+            items: {
+                type: 'array',
+                items: [
+                    {
+                        type: 'string',
+                        description: localize(177, 'The opening bracket character or string sequence.')
+                    },
+                    {
+                        type: 'string',
+                        description: localize(178, 'The closing bracket character or string sequence.')
+                    }
+                ]
+            }
+        },
+        'diffEditor.maxComputationTime': {
+            type: 'number',
+            default: diffEditorDefaultOptions.maxComputationTime,
+            description: localize(179, "Timeout in milliseconds after which diff computation is cancelled. Use 0 for no timeout.")
+        },
+        'diffEditor.maxFileSize': {
+            type: 'number',
+            default: diffEditorDefaultOptions.maxFileSize,
+            description: localize(180, "Maximum file size in MB for which to compute diffs. Use 0 for no limit.")
+        },
+        'diffEditor.renderSideBySide': {
+            type: 'boolean',
+            default: diffEditorDefaultOptions.renderSideBySide,
+            description: localize(181, "Controls whether the diff editor shows the diff side by side or inline.")
+        },
+        'diffEditor.renderSideBySideInlineBreakpoint': {
+            type: 'number',
+            default: diffEditorDefaultOptions.renderSideBySideInlineBreakpoint,
+            description: localize(182, "If the diff editor width is smaller than this value, the inline view is used.")
+        },
+        'diffEditor.useInlineViewWhenSpaceIsLimited': {
+            type: 'boolean',
+            default: diffEditorDefaultOptions.useInlineViewWhenSpaceIsLimited,
+            description: localize(183, "If enabled and the editor width is too small, the inline view is used.")
+        },
+        'diffEditor.renderMarginRevertIcon': {
+            type: 'boolean',
+            default: diffEditorDefaultOptions.renderMarginRevertIcon,
+            description: localize(184, "When enabled, the diff editor shows arrows in its glyph margin to revert changes.")
+        },
+        'diffEditor.renderGutterMenu': {
+            type: 'boolean',
+            default: diffEditorDefaultOptions.renderGutterMenu,
+            description: localize(185, "When enabled, the diff editor shows a special gutter for revert and stage actions.")
+        },
+        'diffEditor.ignoreTrimWhitespace': {
+            type: 'boolean',
+            default: diffEditorDefaultOptions.ignoreTrimWhitespace,
+            description: localize(186, "When enabled, the diff editor ignores changes in leading or trailing whitespace.")
+        },
+        'diffEditor.renderIndicators': {
+            type: 'boolean',
+            default: diffEditorDefaultOptions.renderIndicators,
+            description: localize(187, "Controls whether the diff editor shows +/- indicators for added/removed changes.")
+        },
+        'diffEditor.codeLens': {
+            type: 'boolean',
+            default: diffEditorDefaultOptions.diffCodeLens,
+            description: localize(188, "Controls whether the editor shows CodeLens.")
+        },
+        'diffEditor.wordWrap': {
+            type: 'string',
+            enum: ['off', 'on', 'inherit'],
+            default: diffEditorDefaultOptions.diffWordWrap,
+            markdownEnumDescriptions: [
+                localize(189, "Lines will never wrap."),
+                localize(190, "Lines will wrap at the viewport width."),
+                localize(191, "Lines will wrap according to the {0} setting.", '`#editor.wordWrap#`'),
+            ]
+        },
+        'diffEditor.diffAlgorithm': {
+            type: 'string',
+            enum: ['legacy', 'advanced'],
+            default: diffEditorDefaultOptions.diffAlgorithm,
+            markdownEnumDescriptions: [
+                localize(192, "Uses the legacy diffing algorithm."),
+                localize(193, "Uses the advanced diffing algorithm."),
+            ]
+        },
+        'diffEditor.hideUnchangedRegions.enabled': {
+            type: 'boolean',
+            default: diffEditorDefaultOptions.hideUnchangedRegions.enabled,
+            markdownDescription: localize(194, "Controls whether the diff editor shows unchanged regions."),
+        },
+        'diffEditor.hideUnchangedRegions.revealLineCount': {
+            type: 'integer',
+            default: diffEditorDefaultOptions.hideUnchangedRegions.revealLineCount,
+            markdownDescription: localize(195, "Controls how many lines are used for unchanged regions."),
+            minimum: 1,
+        },
+        'diffEditor.hideUnchangedRegions.minimumLineCount': {
+            type: 'integer',
+            default: diffEditorDefaultOptions.hideUnchangedRegions.minimumLineCount,
+            markdownDescription: localize(196, "Controls how many lines are used as a minimum for unchanged regions."),
+            minimum: 1,
+        },
+        'diffEditor.hideUnchangedRegions.contextLineCount': {
+            type: 'integer',
+            default: diffEditorDefaultOptions.hideUnchangedRegions.contextLineCount,
+            markdownDescription: localize(197, "Controls how many lines are used as context when comparing unchanged regions."),
+            minimum: 1,
+        },
+        'diffEditor.experimental.showMoves': {
+            type: 'boolean',
+            default: diffEditorDefaultOptions.experimental.showMoves,
+            markdownDescription: localize(198, "Controls whether the diff editor should show detected code moves.")
+        },
+        'diffEditor.experimental.showEmptyDecorations': {
+            type: 'boolean',
+            default: diffEditorDefaultOptions.experimental.showEmptyDecorations,
+            description: localize(199, "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(200, "If enabled and the editor uses the inline view, word changes are rendered inline."),
+        },
+    }
+};
+function isConfigurationPropertySchema(x) {
+    return (typeof x.type !== 'undefined' || typeof x.anyOf !== 'undefined');
+}
+// Add properties from the Editor Option Registry
+for (const editorOption of editorOptionsRegistry) {
+    const schema = editorOption.schema;
+    if (typeof schema !== 'undefined') {
+        if (isConfigurationPropertySchema(schema)) {
+            // This is a single schema contribution
+            editorConfiguration.properties[`editor.${editorOption.name}`] = schema;
+        }
+        else {
+            for (const key in schema) {
+                if (Object.hasOwnProperty.call(schema, key)) {
+                    editorConfiguration.properties[key] = schema[key];
+                }
+            }
+        }
+    }
+}
+let cachedEditorConfigurationKeys = null;
+function getEditorConfigurationKeys() {
+    if (cachedEditorConfigurationKeys === null) {
+        cachedEditorConfigurationKeys = Object.create(null);
+        Object.keys(editorConfiguration.properties).forEach((prop) => {
+            cachedEditorConfigurationKeys[prop] = true;
+        });
+    }
+    return cachedEditorConfigurationKeys;
+}
+function isEditorConfigurationKey(key) {
+    const editorConfigurationKeys = getEditorConfigurationKeys();
+    return (editorConfigurationKeys[`editor.${key}`] || false);
+}
+function isDiffEditorConfigurationKey(key) {
+    const editorConfigurationKeys = getEditorConfigurationKeys();
+    return (editorConfigurationKeys[`diffEditor.${key}`] || false);
+}
+const configurationRegistry = Registry.as(Extensions.Configuration);
+configurationRegistry.registerConfiguration(editorConfiguration);
+
+export { editorConfigurationBaseNode, isDiffEditorConfigurationKey, isEditorConfigurationKey };

package/dist/workers/editorContextKeys.js

@@ -0,0 +1,84 @@
+import { localize } from '../../nls.js';
+import { RawContextKey } from '../../platform/contextkey/common/contextkey.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var EditorContextKeys;
+(function (EditorContextKeys) {
+    EditorContextKeys.editorSimpleInput = new RawContextKey('editorSimpleInput', false, true);
+    /**
+     * A context key that is set when the editor's text has focus (cursor is blinking).
+     * Is false when focus is in simple editor widgets (repl input, scm commit input).
+     */
+    EditorContextKeys.editorTextFocus = new RawContextKey('editorTextFocus', false, localize(681, "Whether the editor text has focus (cursor is blinking)"));
+    /**
+     * A context key that is set when the editor's text or an editor's widget has focus.
+     */
+    EditorContextKeys.focus = new RawContextKey('editorFocus', false, localize(682, "Whether the editor or an editor widget has focus (e.g. focus is in the find widget)"));
+    /**
+     * A context key that is set when any editor input has focus (regular editor, repl input...).
+     */
+    EditorContextKeys.textInputFocus = new RawContextKey('textInputFocus', false, localize(683, "Whether an editor or a rich text input has focus (cursor is blinking)"));
+    EditorContextKeys.readOnly = new RawContextKey('editorReadonly', false, localize(684, "Whether the editor is read-only"));
+    EditorContextKeys.inDiffEditor = new RawContextKey('inDiffEditor', false, localize(685, "Whether the context is a diff editor"));
+    EditorContextKeys.isEmbeddedDiffEditor = new RawContextKey('isEmbeddedDiffEditor', false, localize(686, "Whether the context is an embedded diff editor"));
+    EditorContextKeys.inMultiDiffEditor = new RawContextKey('inMultiDiffEditor', false, localize(687, "Whether the context is a multi diff editor"));
+    EditorContextKeys.multiDiffEditorAllCollapsed = new RawContextKey('multiDiffEditorAllCollapsed', undefined, localize(688, "Whether all files in multi diff editor are collapsed"));
+    EditorContextKeys.hasChanges = new RawContextKey('diffEditorHasChanges', false, localize(689, "Whether the diff editor has changes"));
+    EditorContextKeys.comparingMovedCode = new RawContextKey('comparingMovedCode', false, localize(690, "Whether a moved code block is selected for comparison"));
+    EditorContextKeys.accessibleDiffViewerVisible = new RawContextKey('accessibleDiffViewerVisible', false, localize(691, "Whether the accessible diff viewer is visible"));
+    EditorContextKeys.diffEditorRenderSideBySideInlineBreakpointReached = new RawContextKey('diffEditorRenderSideBySideInlineBreakpointReached', false, localize(692, "Whether the diff editor render side by side inline breakpoint is reached"));
+    EditorContextKeys.diffEditorInlineMode = new RawContextKey('diffEditorInlineMode', false, localize(693, "Whether inline mode is active"));
+    EditorContextKeys.diffEditorOriginalWritable = new RawContextKey('diffEditorOriginalWritable', false, localize(694, "Whether modified is writable in the diff editor"));
+    EditorContextKeys.diffEditorModifiedWritable = new RawContextKey('diffEditorModifiedWritable', false, localize(695, "Whether modified is writable in the diff editor"));
+    EditorContextKeys.diffEditorOriginalUri = new RawContextKey('diffEditorOriginalUri', '', localize(696, "The uri of the original document"));
+    EditorContextKeys.diffEditorModifiedUri = new RawContextKey('diffEditorModifiedUri', '', localize(697, "The uri of the modified document"));
+    EditorContextKeys.columnSelection = new RawContextKey('editorColumnSelection', false, localize(698, "Whether `editor.columnSelection` is enabled"));
+    EditorContextKeys.writable = EditorContextKeys.readOnly.toNegated();
+    EditorContextKeys.hasNonEmptySelection = new RawContextKey('editorHasSelection', false, localize(699, "Whether the editor has text selected"));
+    EditorContextKeys.hasOnlyEmptySelection = EditorContextKeys.hasNonEmptySelection.toNegated();
+    EditorContextKeys.hasMultipleSelections = new RawContextKey('editorHasMultipleSelections', false, localize(700, "Whether the editor has multiple selections"));
+    EditorContextKeys.hasSingleSelection = EditorContextKeys.hasMultipleSelections.toNegated();
+    EditorContextKeys.tabMovesFocus = new RawContextKey('editorTabMovesFocus', false, localize(701, "Whether `Tab` will move focus out of the editor"));
+    EditorContextKeys.tabDoesNotMoveFocus = EditorContextKeys.tabMovesFocus.toNegated();
+    EditorContextKeys.isInEmbeddedEditor = new RawContextKey('isInEmbeddedEditor', false, true);
+    EditorContextKeys.canUndo = new RawContextKey('canUndo', false, true);
+    EditorContextKeys.canRedo = new RawContextKey('canRedo', false, true);
+    EditorContextKeys.hoverVisible = new RawContextKey('editorHoverVisible', false, localize(702, "Whether the editor hover is visible"));
+    EditorContextKeys.hoverFocused = new RawContextKey('editorHoverFocused', false, localize(703, "Whether the editor hover is focused"));
+    EditorContextKeys.stickyScrollFocused = new RawContextKey('stickyScrollFocused', false, localize(704, "Whether the sticky scroll is focused"));
+    EditorContextKeys.stickyScrollVisible = new RawContextKey('stickyScrollVisible', false, localize(705, "Whether the sticky scroll is visible"));
+    EditorContextKeys.standaloneColorPickerVisible = new RawContextKey('standaloneColorPickerVisible', false, localize(706, "Whether the standalone color picker is visible"));
+    EditorContextKeys.standaloneColorPickerFocused = new RawContextKey('standaloneColorPickerFocused', false, localize(707, "Whether the standalone color picker is focused"));
+    /**
+     * A context key that is set when an editor is part of a larger editor, like notebooks or
+     * (future) a diff editor
+     */
+    EditorContextKeys.inCompositeEditor = new RawContextKey('inCompositeEditor', undefined, localize(708, "Whether the editor is part of a larger editor (e.g. notebooks)"));
+    EditorContextKeys.notInCompositeEditor = EditorContextKeys.inCompositeEditor.toNegated();
+    // -- mode context keys
+    EditorContextKeys.languageId = new RawContextKey('editorLangId', '', localize(709, "The language identifier of the editor"));
+    EditorContextKeys.hasCompletionItemProvider = new RawContextKey('editorHasCompletionItemProvider', false, localize(710, "Whether the editor has a completion item provider"));
+    EditorContextKeys.hasCodeActionsProvider = new RawContextKey('editorHasCodeActionsProvider', false, localize(711, "Whether the editor has a code actions provider"));
+    EditorContextKeys.hasCodeLensProvider = new RawContextKey('editorHasCodeLensProvider', false, localize(712, "Whether the editor has a code lens provider"));
+    EditorContextKeys.hasDefinitionProvider = new RawContextKey('editorHasDefinitionProvider', false, localize(713, "Whether the editor has a definition provider"));
+    EditorContextKeys.hasDeclarationProvider = new RawContextKey('editorHasDeclarationProvider', false, localize(714, "Whether the editor has a declaration provider"));
+    EditorContextKeys.hasImplementationProvider = new RawContextKey('editorHasImplementationProvider', false, localize(715, "Whether the editor has an implementation provider"));
+    EditorContextKeys.hasTypeDefinitionProvider = new RawContextKey('editorHasTypeDefinitionProvider', false, localize(716, "Whether the editor has a type definition provider"));
+    EditorContextKeys.hasHoverProvider = new RawContextKey('editorHasHoverProvider', false, localize(717, "Whether the editor has a hover provider"));
+    EditorContextKeys.hasDocumentHighlightProvider = new RawContextKey('editorHasDocumentHighlightProvider', false, localize(718, "Whether the editor has a document highlight provider"));
+    EditorContextKeys.hasDocumentSymbolProvider = new RawContextKey('editorHasDocumentSymbolProvider', false, localize(719, "Whether the editor has a document symbol provider"));
+    EditorContextKeys.hasReferenceProvider = new RawContextKey('editorHasReferenceProvider', false, localize(720, "Whether the editor has a reference provider"));
+    EditorContextKeys.hasRenameProvider = new RawContextKey('editorHasRenameProvider', false, localize(721, "Whether the editor has a rename provider"));
+    EditorContextKeys.hasSignatureHelpProvider = new RawContextKey('editorHasSignatureHelpProvider', false, localize(722, "Whether the editor has a signature help provider"));
+    EditorContextKeys.hasInlayHintsProvider = new RawContextKey('editorHasInlayHintsProvider', false, localize(723, "Whether the editor has an inline hints provider"));
+    // -- mode context keys: formatting
+    EditorContextKeys.hasDocumentFormattingProvider = new RawContextKey('editorHasDocumentFormattingProvider', false, localize(724, "Whether the editor has a document formatting provider"));
+    EditorContextKeys.hasDocumentSelectionFormattingProvider = new RawContextKey('editorHasDocumentSelectionFormattingProvider', false, localize(725, "Whether the editor has a document selection formatting provider"));
+    EditorContextKeys.hasMultipleDocumentFormattingProvider = new RawContextKey('editorHasMultipleDocumentFormattingProvider', false, localize(726, "Whether the editor has multiple document formatting providers"));
+    EditorContextKeys.hasMultipleDocumentSelectionFormattingProvider = new RawContextKey('editorHasMultipleDocumentSelectionFormattingProvider', false, localize(727, "Whether the editor has multiple document selection formatting providers"));
+})(EditorContextKeys || (EditorContextKeys = {}));
+
+export { EditorContextKeys };