monaco-editor-core 0.54.0-dev-20251005 → 0.54.0

package/esm/vs/editor/common/config/editorOptions.js

@@ -5,7 +5,6 @@
 import * as arrays from '../../../base/common/arrays.js';
 import * as objects from '../../../base/common/objects.js';
 import * as platform from '../../../base/common/platform.js';
-import { EDITOR_FONT_DEFAULTS, FONT_VARIATION_OFF, FONT_VARIATION_TRANSLATE, FontInfo } from './fontInfo.js';
 import { EDITOR_MODEL_DEFAULTS } from '../core/misc/textModelDefaults.js';
 import { USUAL_WORD_SEPARATORS } from '../core/wordHelper.js';
 import * as nls from '../../../nls.js';
@@ -86,11 +85,11 @@ function applyUpdate(value, update) {
  * @internal
  */
 class ComputedEditorOption {
-    constructor(id, defaultValue) {
+    constructor(id) {
         this.schema = undefined;
         this.id = id;
         this.name = '_never_';
-        this.defaultValue = defaultValue;
+        this.defaultValue = undefined;
     }
     applyUpdate(value, update) {
         return applyUpdate(value, update);
@@ -109,6 +108,12 @@ class SimpleEditorOption {
     applyUpdate(value, update) {
         return applyUpdate(value, update);
     }
+    validate(input) {
+        if (typeof input === 'undefined') {
+            return this.defaultValue;
+        }
+        return input;
+    }
     compute(env, options, value) {
         return value;
     }
@@ -142,13 +147,13 @@ class EditorBooleanOption extends SimpleEditorOption {
  * @internal
  */
 export function clampedInt(value, defaultValue, minimum, maximum) {
-    if (typeof value === 'string') {
-        value = parseInt(value, 10);
+    if (typeof value === 'undefined') {
+        return defaultValue;
     }
-    if (typeof value !== 'number' || isNaN(value)) {
+    let r = parseInt(value, 10);
+    if (isNaN(r)) {
         return defaultValue;
     }
-    let r = value;
     r = Math.max(minimum, r);
     r = Math.min(maximum, r);
     return r | 0;
@@ -193,13 +198,14 @@ class EditorFloatOption extends SimpleEditorOption {
         return n;
     }
     static float(value, defaultValue) {
-        if (typeof value === 'string') {
-            value = parseFloat(value);
+        if (typeof value === 'number') {
+            return value;
         }
-        if (typeof value !== 'number' || isNaN(value)) {
+        if (typeof value === 'undefined') {
             return defaultValue;
         }
-        return value;
+        const r = parseFloat(value);
+        return (isNaN(r) ? defaultValue : r);
     }
     constructor(id, name, defaultValue, validationFn, schema, minimum, maximum) {
         if (typeof schema !== 'undefined') {
@@ -254,7 +260,7 @@ class EditorStringEnumOption extends SimpleEditorOption {
     constructor(id, name, defaultValue, allowedValues, schema = undefined) {
         if (typeof schema !== 'undefined') {
             schema.type = 'string';
-            schema.enum = allowedValues.slice(0);
+            schema.enum = allowedValues;
             schema.default = defaultValue;
         }
         super(id, name, defaultValue, schema);
@@ -420,7 +426,7 @@ export function cursorStyleFromString(cursorStyle) {
 //#region editorClassName
 class EditorClassName extends ComputedEditorOption {
     constructor() {
-        super(162 /* EditorOption.editorClassName */, '');
+        super(162 /* EditorOption.editorClassName */);
     }
     compute(env, options, _) {
         const classNames = ['monaco-editor'];
@@ -547,11 +553,11 @@ class EditorFind extends BaseEditorOption {
         return {
             cursorMoveOnType: boolean(input.cursorMoveOnType, this.defaultValue.cursorMoveOnType),
             findOnType: boolean(input.findOnType, this.defaultValue.findOnType),
-            seedSearchStringFromSelection: typeof input.seedSearchStringFromSelection === 'boolean'
-                ? (input.seedSearchStringFromSelection ? 'always' : 'never')
+            seedSearchStringFromSelection: typeof _input.seedSearchStringFromSelection === 'boolean'
+                ? (_input.seedSearchStringFromSelection ? 'always' : 'never')
                 : stringSet(input.seedSearchStringFromSelection, this.defaultValue.seedSearchStringFromSelection, ['never', 'always', 'selection']),
-            autoFindInSelection: typeof input.autoFindInSelection === 'boolean'
-                ? (input.autoFindInSelection ? 'always' : 'never')
+            autoFindInSelection: typeof _input.autoFindInSelection === 'boolean'
+                ? (_input.autoFindInSelection ? 'always' : 'never')
                 : stringSet(input.autoFindInSelection, this.defaultValue.autoFindInSelection, ['never', 'always', 'multiline']),
             globalFindClipboard: boolean(input.globalFindClipboard, this.defaultValue.globalFindClipboard),
             addExtraSpaceOnTop: boolean(input.addExtraSpaceOnTop, this.defaultValue.addExtraSpaceOnTop),
@@ -611,9 +617,9 @@ export class EditorFontLigatures extends BaseEditorOption {
  */
 export class EditorFontVariations extends BaseEditorOption {
     // Text is laid out using default settings.
-    static { this.OFF = FONT_VARIATION_OFF; }
+    static { this.OFF = 'normal'; }
     // Translate `fontWeight` config to the `font-variation-settings` CSS property.
-    static { this.TRANSLATE = FONT_VARIATION_TRANSLATE; }
+    static { this.TRANSLATE = 'translate'; }
     constructor() {
         super(63 /* EditorOption.fontVariations */, 'fontVariations', EditorFontVariations.OFF, {
             anyOf: [
@@ -658,24 +664,7 @@ export class EditorFontVariations extends BaseEditorOption {
 //#region fontInfo
 class EditorFontInfo extends ComputedEditorOption {
     constructor() {
-        super(59 /* EditorOption.fontInfo */, new FontInfo({
-            pixelRatio: 0,
-            fontFamily: '',
-            fontWeight: '',
-            fontSize: 0,
-            fontFeatureSettings: '',
-            fontVariationSettings: '',
-            lineHeight: 0,
-            letterSpacing: 0,
-            isMonospace: false,
-            typicalHalfwidthCharacterWidth: 0,
-            typicalFullwidthCharacterWidth: 0,
-            canUseHalfwidthRightwardsArrow: false,
-            spaceWidth: 0,
-            middotWidth: 0,
-            wsmiddotWidth: 0,
-            maxDigitWidth: 0,
-        }, false));
+        super(59 /* EditorOption.fontInfo */);
     }
     compute(env, options, _) {
         return env.fontInfo;
@@ -685,7 +674,7 @@ class EditorFontInfo extends ComputedEditorOption {
 //#region effectiveCursorStyle
 class EffectiveCursorStyle extends ComputedEditorOption {
     constructor() {
-        super(161 /* EditorOption.effectiveCursorStyle */, TextEditorCursorStyle.Line);
+        super(161 /* EditorOption.effectiveCursorStyle */);
     }
     compute(env, options, _) {
         return env.inputMode === 'overtype' ?
@@ -697,7 +686,7 @@ class EffectiveCursorStyle extends ComputedEditorOption {
 //#region effectiveExperimentalEditContext
 class EffectiveEditContextEnabled extends ComputedEditorOption {
     constructor() {
-        super(170 /* EditorOption.effectiveEditContext */, false);
+        super(170 /* EditorOption.effectiveEditContext */);
     }
     compute(env, options) {
         return env.editContextSupported && options.get(44 /* EditorOption.editContext */);
@@ -707,7 +696,7 @@ class EffectiveEditContextEnabled extends ComputedEditorOption {
 //#region effectiveAllowVariableFonts
 class EffectiveAllowVariableFonts extends ComputedEditorOption {
     constructor() {
-        super(172 /* EditorOption.effectiveAllowVariableFonts */, false);
+        super(172 /* EditorOption.effectiveAllowVariableFonts */);
     }
     compute(env, options) {
         const accessibilitySupport = env.accessibilitySupport;
@@ -869,12 +858,12 @@ class EditorGoToLocation extends BaseEditorOption {
         const input = _input;
         return {
             multiple: stringSet(input.multiple, this.defaultValue.multiple, ['peek', 'gotoAndPeek', 'goto']),
-            multipleDefinitions: stringSet(input.multipleDefinitions, 'peek', ['peek', 'gotoAndPeek', 'goto']),
-            multipleTypeDefinitions: stringSet(input.multipleTypeDefinitions, 'peek', ['peek', 'gotoAndPeek', 'goto']),
-            multipleDeclarations: stringSet(input.multipleDeclarations, 'peek', ['peek', 'gotoAndPeek', 'goto']),
-            multipleImplementations: stringSet(input.multipleImplementations, 'peek', ['peek', 'gotoAndPeek', 'goto']),
-            multipleReferences: stringSet(input.multipleReferences, 'peek', ['peek', 'gotoAndPeek', 'goto']),
-            multipleTests: stringSet(input.multipleTests, 'peek', ['peek', 'gotoAndPeek', 'goto']),
+            multipleDefinitions: input.multipleDefinitions ?? stringSet(input.multipleDefinitions, 'peek', ['peek', 'gotoAndPeek', 'goto']),
+            multipleTypeDefinitions: input.multipleTypeDefinitions ?? stringSet(input.multipleTypeDefinitions, 'peek', ['peek', 'gotoAndPeek', 'goto']),
+            multipleDeclarations: input.multipleDeclarations ?? stringSet(input.multipleDeclarations, 'peek', ['peek', 'gotoAndPeek', 'goto']),
+            multipleImplementations: input.multipleImplementations ?? stringSet(input.multipleImplementations, 'peek', ['peek', 'gotoAndPeek', 'goto']),
+            multipleReferences: input.multipleReferences ?? stringSet(input.multipleReferences, 'peek', ['peek', 'gotoAndPeek', 'goto']),
+            multipleTests: input.multipleTests ?? stringSet(input.multipleTests, 'peek', ['peek', 'gotoAndPeek', 'goto']),
             alternativeDefinitionCommand: EditorStringOption.string(input.alternativeDefinitionCommand, this.defaultValue.alternativeDefinitionCommand),
             alternativeTypeDefinitionCommand: EditorStringOption.string(input.alternativeTypeDefinitionCommand, this.defaultValue.alternativeTypeDefinitionCommand),
             alternativeDeclarationCommand: EditorStringOption.string(input.alternativeDeclarationCommand, this.defaultValue.alternativeDeclarationCommand),
@@ -943,44 +932,7 @@ class EditorHover extends BaseEditorOption {
  */
 export class EditorLayoutInfoComputer extends ComputedEditorOption {
     constructor() {
-        super(165 /* EditorOption.layoutInfo */, {
-            width: 0,
-            height: 0,
-            glyphMarginLeft: 0,
-            glyphMarginWidth: 0,
-            glyphMarginDecorationLaneCount: 0,
-            lineNumbersLeft: 0,
-            lineNumbersWidth: 0,
-            decorationsLeft: 0,
-            decorationsWidth: 0,
-            contentLeft: 0,
-            contentWidth: 0,
-            minimap: {
-                renderMinimap: 0 /* RenderMinimap.None */,
-                minimapLeft: 0,
-                minimapWidth: 0,
-                minimapHeightIsEditorHeight: false,
-                minimapIsSampling: false,
-                minimapScale: 1,
-                minimapLineHeight: 1,
-                minimapCanvasInnerWidth: 0,
-                minimapCanvasInnerHeight: 0,
-                minimapCanvasOuterWidth: 0,
-                minimapCanvasOuterHeight: 0,
-            },
-            viewportColumn: 0,
-            isWordWrapMinified: false,
-            isViewportWrapping: false,
-            wrappingColumn: -1,
-            verticalScrollbarWidth: 0,
-            horizontalScrollbarHeight: 0,
-            overviewRuler: {
-                top: 0,
-                width: 0,
-                height: 0,
-                right: 0
-            }
-        });
+        super(165 /* EditorOption.layoutInfo */);
     }
     compute(env, options, _) {
         return EditorLayoutInfoComputer.computeLayout(options, {
@@ -1599,7 +1551,7 @@ class EditorMinimap extends BaseEditorOption {
         const input = _input;
         // Validate mark section header regex
         let markSectionHeaderRegex = this.defaultValue.markSectionHeaderRegex;
-        const inputRegex = input.markSectionHeaderRegex;
+        const inputRegex = _input.markSectionHeaderRegex;
         if (typeof inputRegex === 'string') {
             try {
                 new RegExp(inputRegex, 'd');
@@ -1619,8 +1571,8 @@ class EditorMinimap extends BaseEditorOption {
             showRegionSectionHeaders: boolean(input.showRegionSectionHeaders, this.defaultValue.showRegionSectionHeaders),
             showMarkSectionHeaders: boolean(input.showMarkSectionHeaders, this.defaultValue.showMarkSectionHeaders),
             markSectionHeaderRegex: markSectionHeaderRegex,
-            sectionHeaderFontSize: EditorFloatOption.clamp(EditorFloatOption.float(input.sectionHeaderFontSize, this.defaultValue.sectionHeaderFontSize), 4, 32),
-            sectionHeaderLetterSpacing: EditorFloatOption.clamp(EditorFloatOption.float(input.sectionHeaderLetterSpacing, this.defaultValue.sectionHeaderLetterSpacing), 0, 5),
+            sectionHeaderFontSize: EditorFloatOption.clamp(input.sectionHeaderFontSize ?? this.defaultValue.sectionHeaderFontSize, 4, 32),
+            sectionHeaderLetterSpacing: EditorFloatOption.clamp(input.sectionHeaderLetterSpacing ?? this.defaultValue.sectionHeaderLetterSpacing, 0, 5),
         };
     }
 }
@@ -1696,7 +1648,7 @@ class EditorParameterHints extends BaseEditorOption {
 //#region pixelRatio
 class EditorPixelRatio extends ComputedEditorOption {
     constructor() {
-        super(163 /* EditorOption.pixelRatio */, 1);
+        super(163 /* EditorOption.pixelRatio */);
     }
     compute(env, options, _) {
         return env.pixelRatio;
@@ -2141,8 +2093,8 @@ class UnicodeHighlight extends BaseEditorOption {
             ambiguousCharacters: boolean(input.ambiguousCharacters, this.defaultValue.ambiguousCharacters),
             includeComments: primitiveSet(input.includeComments, inUntrustedWorkspace, [true, false, inUntrustedWorkspace]),
             includeStrings: primitiveSet(input.includeStrings, inUntrustedWorkspace, [true, false, inUntrustedWorkspace]),
-            allowedCharacters: this.validateBooleanMap(input.allowedCharacters, this.defaultValue.allowedCharacters),
-            allowedLocales: this.validateBooleanMap(input.allowedLocales, this.defaultValue.allowedLocales),
+            allowedCharacters: this.validateBooleanMap(_input.allowedCharacters, this.defaultValue.allowedCharacters),
+            allowedLocales: this.validateBooleanMap(_input.allowedLocales, this.defaultValue.allowedLocales),
         };
     }
     validateBooleanMap(map, defaultValue) {
@@ -2172,7 +2124,7 @@ class InlineEditorSuggest extends BaseEditorOption {
             fontFamily: 'default',
             syntaxHighlightingEnabled: true,
             minShowDelay: 0,
-            suppressInSnippetMode: true,
+            suppressInSnippetMode: false,
             edits: {
                 enabled: true,
                 showCollapsed: false,
@@ -2308,32 +2260,18 @@ class InlineEditorSuggest extends BaseEditorOption {
             syntaxHighlightingEnabled: boolean(input.syntaxHighlightingEnabled, this.defaultValue.syntaxHighlightingEnabled),
             minShowDelay: EditorIntOption.clampedInt(input.minShowDelay, 0, 0, 10000),
             suppressInSnippetMode: boolean(input.suppressInSnippetMode, this.defaultValue.suppressInSnippetMode),
-            edits: this._validateEdits(input.edits),
+            edits: {
+                enabled: boolean(input.edits?.enabled, this.defaultValue.edits.enabled),
+                showCollapsed: boolean(input.edits?.showCollapsed, this.defaultValue.edits.showCollapsed),
+                allowCodeShifting: stringSet(input.edits?.allowCodeShifting, this.defaultValue.edits.allowCodeShifting, ['always', 'horizontal', 'never']),
+                renderSideBySide: stringSet(input.edits?.renderSideBySide, this.defaultValue.edits.renderSideBySide, ['never', 'auto']),
+            },
             triggerCommandOnProviderChange: boolean(input.triggerCommandOnProviderChange, this.defaultValue.triggerCommandOnProviderChange),
-            experimental: this._validateExperimental(input.experimental),
-        };
-    }
-    _validateEdits(_input) {
-        if (!_input || typeof _input !== 'object') {
-            return this.defaultValue.edits;
-        }
-        const input = _input;
-        return {
-            enabled: boolean(input.enabled, this.defaultValue.edits.enabled),
-            showCollapsed: boolean(input.showCollapsed, this.defaultValue.edits.showCollapsed),
-            allowCodeShifting: stringSet(input.allowCodeShifting, this.defaultValue.edits.allowCodeShifting, ['always', 'horizontal', 'never']),
-            renderSideBySide: stringSet(input.renderSideBySide, this.defaultValue.edits.renderSideBySide, ['never', 'auto']),
-        };
-    }
-    _validateExperimental(_input) {
-        if (!_input || typeof _input !== 'object') {
-            return this.defaultValue.experimental;
-        }
-        const input = _input;
-        return {
-            suppressInlineSuggestions: EditorStringOption.string(input.suppressInlineSuggestions, this.defaultValue.experimental.suppressInlineSuggestions),
-            showOnSuggestConflict: stringSet(input.showOnSuggestConflict, this.defaultValue.experimental.showOnSuggestConflict, ['always', 'never', 'whenSuggestListIsIncomplete']),
-            emptyResponseInformation: boolean(input.emptyResponseInformation, this.defaultValue.experimental.emptyResponseInformation),
+            experimental: {
+                suppressInlineSuggestions: EditorStringOption.string(input.experimental?.suppressInlineSuggestions, this.defaultValue.experimental.suppressInlineSuggestions),
+                showOnSuggestConflict: stringSet(input.experimental?.showOnSuggestConflict, this.defaultValue.experimental.showOnSuggestConflict, ['always', 'never', 'whenSuggestListIsIncomplete']),
+                emptyResponseInformation: boolean(input.experimental?.emptyResponseInformation, this.defaultValue.experimental.emptyResponseInformation),
+            },
         };
     }
 }
@@ -2883,12 +2821,7 @@ class WrappingIndentOption extends BaseEditorOption {
 }
 class EditorWrappingInfoComputer extends ComputedEditorOption {
     constructor() {
-        super(166 /* EditorOption.wrappingInfo */, {
-            isDominatedByLongLines: false,
-            isWordWrapMinified: false,
-            isViewportWrapping: false,
-            wrappingColumn: -1
-        });
+        super(166 /* EditorOption.wrappingInfo */);
     }
     compute(env, options, _) {
         const layoutInfo = options.get(165 /* EditorOption.layoutInfo */);
@@ -2971,6 +2904,19 @@ class EditorPasteAs extends BaseEditorOption {
     }
 }
 //#endregion
+const DEFAULT_WINDOWS_FONT_FAMILY = 'Consolas, \'Courier New\', monospace';
+const DEFAULT_MAC_FONT_FAMILY = 'Menlo, Monaco, \'Courier New\', monospace';
+const DEFAULT_LINUX_FONT_FAMILY = '\'Droid Sans Mono\', \'monospace\', monospace';
+/**
+ * @internal
+ */
+export const EDITOR_FONT_DEFAULTS = {
+    fontFamily: (platform.isMacintosh ? DEFAULT_MAC_FONT_FAMILY : (platform.isWindows ? DEFAULT_WINDOWS_FONT_FAMILY : DEFAULT_LINUX_FONT_FAMILY)),
+    fontWeight: 'normal',
+    fontSize: (platform.isMacintosh ? 12 : 14),
+    lineHeight: 0,
+    letterSpacing: 0,
+};
 /**
  * @internal
  */