monaco-editor-core 0.54.0-dev-20251004 → 0.54.0-dev-20251006

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

@@ -5,6 +5,7 @@
 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';
@@ -85,12 +86,11 @@ function applyUpdate(value, update) {
  * @internal
  */
 class ComputedEditorOption {
-    constructor(id) {
+    constructor(id, defaultValue) {
         this.schema = undefined;
         this.id = id;
         this.name = '_never_';
-        // eslint-disable-next-line local/code-no-any-casts
-        this.defaultValue = undefined;
+        this.defaultValue = defaultValue;
     }
     applyUpdate(value, update) {
         return applyUpdate(value, update);
@@ -109,13 +109,6 @@ class SimpleEditorOption {
     applyUpdate(value, update) {
         return applyUpdate(value, update);
     }
-    validate(input) {
-        if (typeof input === 'undefined') {
-            return this.defaultValue;
-        }
-        // eslint-disable-next-line local/code-no-any-casts
-        return input;
-    }
     compute(env, options, value) {
         return value;
     }
@@ -149,13 +142,13 @@ class EditorBooleanOption extends SimpleEditorOption {
  * @internal
  */
 export function clampedInt(value, defaultValue, minimum, maximum) {
-    if (typeof value === 'undefined') {
-        return defaultValue;
+    if (typeof value === 'string') {
+        value = parseInt(value, 10);
     }
-    let r = parseInt(value, 10);
-    if (isNaN(r)) {
+    if (typeof value !== 'number' || isNaN(value)) {
         return defaultValue;
     }
+    let r = value;
     r = Math.max(minimum, r);
     r = Math.min(maximum, r);
     return r | 0;
@@ -200,14 +193,13 @@ class EditorFloatOption extends SimpleEditorOption {
         return n;
     }
     static float(value, defaultValue) {
-        if (typeof value === 'number') {
-            return value;
+        if (typeof value === 'string') {
+            value = parseFloat(value);
         }
-        if (typeof value === 'undefined') {
+        if (typeof value !== 'number' || isNaN(value)) {
             return defaultValue;
         }
-        const r = parseFloat(value);
-        return (isNaN(r) ? defaultValue : r);
+        return value;
     }
     constructor(id, name, defaultValue, validationFn, schema, minimum, maximum) {
         if (typeof schema !== 'undefined') {
@@ -262,8 +254,7 @@ class EditorStringEnumOption extends SimpleEditorOption {
     constructor(id, name, defaultValue, allowedValues, schema = undefined) {
         if (typeof schema !== 'undefined') {
             schema.type = 'string';
-            // eslint-disable-next-line local/code-no-any-casts
-            schema.enum = allowedValues;
+            schema.enum = allowedValues.slice(0);
             schema.default = defaultValue;
         }
         super(id, name, defaultValue, schema);
@@ -291,7 +282,6 @@ class EditorEnumOption extends BaseEditorOption {
         if (this._allowedValues.indexOf(input) === -1) {
             return this.defaultValue;
         }
-        // eslint-disable-next-line local/code-no-any-casts
         return this._convert(input);
     }
 }
@@ -430,7 +420,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'];
@@ -557,11 +547,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),
@@ -621,9 +611,9 @@ export class EditorFontLigatures extends BaseEditorOption {
  */
 export class EditorFontVariations extends BaseEditorOption {
     // Text is laid out using default settings.
-    static { this.OFF = 'normal'; }
+    static { this.OFF = FONT_VARIATION_OFF; }
     // Translate `fontWeight` config to the `font-variation-settings` CSS property.
-    static { this.TRANSLATE = 'translate'; }
+    static { this.TRANSLATE = FONT_VARIATION_TRANSLATE; }
     constructor() {
         super(63 /* EditorOption.fontVariations */, 'fontVariations', EditorFontVariations.OFF, {
             anyOf: [
@@ -668,7 +658,24 @@ export class EditorFontVariations extends BaseEditorOption {
 //#region fontInfo
 class EditorFontInfo extends ComputedEditorOption {
     constructor() {
-        super(59 /* EditorOption.fontInfo */);
+        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));
     }
     compute(env, options, _) {
         return env.fontInfo;
@@ -678,7 +685,7 @@ class EditorFontInfo extends ComputedEditorOption {
 //#region effectiveCursorStyle
 class EffectiveCursorStyle extends ComputedEditorOption {
     constructor() {
-        super(161 /* EditorOption.effectiveCursorStyle */);
+        super(161 /* EditorOption.effectiveCursorStyle */, TextEditorCursorStyle.Line);
     }
     compute(env, options, _) {
         return env.inputMode === 'overtype' ?
@@ -690,7 +697,7 @@ class EffectiveCursorStyle extends ComputedEditorOption {
 //#region effectiveExperimentalEditContext
 class EffectiveEditContextEnabled extends ComputedEditorOption {
     constructor() {
-        super(170 /* EditorOption.effectiveEditContext */);
+        super(170 /* EditorOption.effectiveEditContext */, false);
     }
     compute(env, options) {
         return env.editContextSupported && options.get(44 /* EditorOption.editContext */);
@@ -700,7 +707,7 @@ class EffectiveEditContextEnabled extends ComputedEditorOption {
 //#region effectiveAllowVariableFonts
 class EffectiveAllowVariableFonts extends ComputedEditorOption {
     constructor() {
-        super(172 /* EditorOption.effectiveAllowVariableFonts */);
+        super(172 /* EditorOption.effectiveAllowVariableFonts */, false);
     }
     compute(env, options) {
         const accessibilitySupport = env.accessibilitySupport;
@@ -862,12 +869,12 @@ class EditorGoToLocation extends BaseEditorOption {
         const input = _input;
         return {
             multiple: stringSet(input.multiple, this.defaultValue.multiple, ['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']),
+            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']),
             alternativeDefinitionCommand: EditorStringOption.string(input.alternativeDefinitionCommand, this.defaultValue.alternativeDefinitionCommand),
             alternativeTypeDefinitionCommand: EditorStringOption.string(input.alternativeTypeDefinitionCommand, this.defaultValue.alternativeTypeDefinitionCommand),
             alternativeDeclarationCommand: EditorStringOption.string(input.alternativeDeclarationCommand, this.defaultValue.alternativeDeclarationCommand),
@@ -936,7 +943,44 @@ class EditorHover extends BaseEditorOption {
  */
 export class EditorLayoutInfoComputer extends ComputedEditorOption {
     constructor() {
-        super(165 /* EditorOption.layoutInfo */);
+        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
+            }
+        });
     }
     compute(env, options, _) {
         return EditorLayoutInfoComputer.computeLayout(options, {
@@ -1555,7 +1599,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');
@@ -1575,8 +1619,8 @@ class EditorMinimap extends BaseEditorOption {
             showRegionSectionHeaders: boolean(input.showRegionSectionHeaders, this.defaultValue.showRegionSectionHeaders),
             showMarkSectionHeaders: boolean(input.showMarkSectionHeaders, this.defaultValue.showMarkSectionHeaders),
             markSectionHeaderRegex: markSectionHeaderRegex,
-            sectionHeaderFontSize: EditorFloatOption.clamp(input.sectionHeaderFontSize ?? this.defaultValue.sectionHeaderFontSize, 4, 32),
-            sectionHeaderLetterSpacing: EditorFloatOption.clamp(input.sectionHeaderLetterSpacing ?? this.defaultValue.sectionHeaderLetterSpacing, 0, 5),
+            sectionHeaderFontSize: EditorFloatOption.clamp(EditorFloatOption.float(input.sectionHeaderFontSize, this.defaultValue.sectionHeaderFontSize), 4, 32),
+            sectionHeaderLetterSpacing: EditorFloatOption.clamp(EditorFloatOption.float(input.sectionHeaderLetterSpacing, this.defaultValue.sectionHeaderLetterSpacing), 0, 5),
         };
     }
 }
@@ -1652,7 +1696,7 @@ class EditorParameterHints extends BaseEditorOption {
 //#region pixelRatio
 class EditorPixelRatio extends ComputedEditorOption {
     constructor() {
-        super(163 /* EditorOption.pixelRatio */);
+        super(163 /* EditorOption.pixelRatio */, 1);
     }
     compute(env, options, _) {
         return env.pixelRatio;
@@ -2097,8 +2141,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) {
@@ -2264,18 +2308,32 @@ 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: {
-                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']),
-            },
+            edits: this._validateEdits(input.edits),
             triggerCommandOnProviderChange: boolean(input.triggerCommandOnProviderChange, this.defaultValue.triggerCommandOnProviderChange),
-            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),
-            },
+            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),
         };
     }
 }
@@ -2385,7 +2443,6 @@ class GuideOptions extends BaseEditorOption {
     }
 }
 function primitiveSet(value, defaultValue, allowedValues) {
-    // eslint-disable-next-line local/code-no-any-casts
     const idx = allowedValues.indexOf(value);
     if (idx === -1) {
         return defaultValue;
@@ -2826,7 +2883,12 @@ class WrappingIndentOption extends BaseEditorOption {
 }
 class EditorWrappingInfoComputer extends ComputedEditorOption {
     constructor() {
-        super(166 /* EditorOption.wrappingInfo */);
+        super(166 /* EditorOption.wrappingInfo */, {
+            isDominatedByLongLines: false,
+            isWordWrapMinified: false,
+            isViewportWrapping: false,
+            wrappingColumn: -1
+        });
     }
     compute(env, options, _) {
         const layoutInfo = options.get(165 /* EditorOption.layoutInfo */);
@@ -2909,19 +2971,6 @@ 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
  */