@codingame/monaco-vscode-api 5.3.0 → 6.0.0

package/vscode/src/vs/editor/browser/viewParts/minimap/minimapCharRendererFactory.js

@@ -1,5 +1,5 @@
 import { MinimapCharRenderer } from './minimapCharRenderer.js';
-import { allCharCodes } from './minimapCharSheet.js';
+import { Constants, allCharCodes } from './minimapCharSheet.js';
 import { prebakedMiniMaps } from './minimapPreBaked.js';
 import { toUint8 } from '../../../../base/common/uint.js';
 class MinimapCharRendererFactory {
@@ -21,22 +21,22 @@ class MinimapCharRendererFactory {
     static createSampleData(fontFamily) {
         const canvas = document.createElement('canvas');
         const ctx = canvas.getContext('2d');
-        canvas.style.height = `${16 }px`;
-        canvas.height = 16 ;
-        canvas.width = 96  * 10 ;
-        canvas.style.width = 96  * 10  + 'px';
+        canvas.style.height = `${Constants.SAMPLED_CHAR_HEIGHT}px`;
+        canvas.height = Constants.SAMPLED_CHAR_HEIGHT;
+        canvas.width = Constants.CHAR_COUNT * Constants.SAMPLED_CHAR_WIDTH;
+        canvas.style.width = Constants.CHAR_COUNT * Constants.SAMPLED_CHAR_WIDTH + 'px';
         ctx.fillStyle = '#ffffff';
-        ctx.font = `bold ${16 }px ${fontFamily}`;
+        ctx.font = `bold ${Constants.SAMPLED_CHAR_HEIGHT}px ${fontFamily}`;
         ctx.textBaseline = 'middle';
         let x = 0;
         for (const code of allCharCodes) {
-            ctx.fillText(String.fromCharCode(code), x, 16  / 2);
-            x += 10 ;
+            ctx.fillText(String.fromCharCode(code), x, Constants.SAMPLED_CHAR_HEIGHT / 2);
+            x += Constants.SAMPLED_CHAR_WIDTH;
         }
-        return ctx.getImageData(0, 0, 96  * 10 , 16 );
+        return ctx.getImageData(0, 0, Constants.CHAR_COUNT * Constants.SAMPLED_CHAR_WIDTH, Constants.SAMPLED_CHAR_HEIGHT);
     }
     static createFromSampleData(source, scale) {
-        const expectedLength = 16  * 10  * 4  * 96 ;
+        const expectedLength = Constants.SAMPLED_CHAR_HEIGHT * Constants.SAMPLED_CHAR_WIDTH * Constants.RGBA_CHANNELS_CNT * Constants.CHAR_COUNT;
         if (source.length !== expectedLength) {
             throw ( new Error('Unexpected source in MinimapCharRenderer'));
         }
@@ -44,24 +44,24 @@ class MinimapCharRendererFactory {
         return ( new MinimapCharRenderer(charData, scale));
     }
     static _downsampleChar(source, sourceOffset, dest, destOffset, scale) {
-        const width = 1  * scale;
-        const height = 2  * scale;
+        const width = Constants.BASE_CHAR_WIDTH * scale;
+        const height = Constants.BASE_CHAR_HEIGHT * scale;
         let targetIndex = destOffset;
         let brightest = 0;
         for (let y = 0; y < height; y++) {
-            const sourceY1 = (y / height) * 16 ;
-            const sourceY2 = ((y + 1) / height) * 16 ;
+            const sourceY1 = (y / height) * Constants.SAMPLED_CHAR_HEIGHT;
+            const sourceY2 = ((y + 1) / height) * Constants.SAMPLED_CHAR_HEIGHT;
             for (let x = 0; x < width; x++) {
-                const sourceX1 = (x / width) * 10 ;
-                const sourceX2 = ((x + 1) / width) * 10 ;
+                const sourceX1 = (x / width) * Constants.SAMPLED_CHAR_WIDTH;
+                const sourceX2 = ((x + 1) / width) * Constants.SAMPLED_CHAR_WIDTH;
                 let value = 0;
                 let samples = 0;
                 for (let sy = sourceY1; sy < sourceY2; sy++) {
-                    const sourceRow = sourceOffset + Math.floor(sy) * 3840 ;
+                    const sourceRow = sourceOffset + Math.floor(sy) * Constants.RGBA_SAMPLED_ROW_WIDTH;
                     const yBalance = 1 - (sy - Math.floor(sy));
                     for (let sx = sourceX1; sx < sourceX2; sx++) {
                         const xBalance = 1 - (sx - Math.floor(sx));
-                        const sourceIndex = sourceRow + Math.floor(sx) * 4 ;
+                        const sourceIndex = sourceRow + Math.floor(sx) * Constants.RGBA_CHANNELS_CNT;
                         const weight = xBalance * yBalance;
                         samples += weight;
                         value += ((source[sourceIndex] * source[sourceIndex + 3]) / 255) * weight;
@@ -75,16 +75,16 @@ class MinimapCharRendererFactory {
         return brightest;
     }
     static _downsample(data, scale) {
-        const pixelsPerCharacter = 2  * scale * 1  * scale;
-        const resultLen = pixelsPerCharacter * 96 ;
+        const pixelsPerCharacter = Constants.BASE_CHAR_HEIGHT * scale * Constants.BASE_CHAR_WIDTH * scale;
+        const resultLen = pixelsPerCharacter * Constants.CHAR_COUNT;
         const result = ( new Uint8ClampedArray(resultLen));
         let resultOffset = 0;
         let sourceOffset = 0;
         let brightest = 0;
-        for (let charIndex = 0; charIndex < 96 ; charIndex++) {
+        for (let charIndex = 0; charIndex < Constants.CHAR_COUNT; charIndex++) {
             brightest = Math.max(brightest, this._downsampleChar(data, sourceOffset, result, resultOffset, scale));
             resultOffset += pixelsPerCharacter;
-            sourceOffset += 10  * 4 ;
+            sourceOffset += Constants.SAMPLED_CHAR_WIDTH * Constants.RGBA_CHANNELS_CNT;
         }
         if (brightest > 0) {
             const adjust = 255 / brightest;

package/vscode/src/vs/editor/browser/viewParts/minimap/minimapCharSheet.js

@@ -1,19 +1,32 @@
+var Constants;
+( (function(Constants) {
+    Constants[Constants["START_CH_CODE"] = 32] = "START_CH_CODE";
+    Constants[Constants["END_CH_CODE"] = 126] = "END_CH_CODE";
+    Constants[Constants["UNKNOWN_CODE"] = 65533] = "UNKNOWN_CODE";
+    Constants[Constants["CHAR_COUNT"] = 96] = "CHAR_COUNT";
+    Constants[Constants["SAMPLED_CHAR_HEIGHT"] = 16] = "SAMPLED_CHAR_HEIGHT";
+    Constants[Constants["SAMPLED_CHAR_WIDTH"] = 10] = "SAMPLED_CHAR_WIDTH";
+    Constants[Constants["BASE_CHAR_HEIGHT"] = 2] = "BASE_CHAR_HEIGHT";
+    Constants[Constants["BASE_CHAR_WIDTH"] = 1] = "BASE_CHAR_WIDTH";
+    Constants[Constants["RGBA_CHANNELS_CNT"] = 4] = "RGBA_CHANNELS_CNT";
+    Constants[Constants["RGBA_SAMPLED_ROW_WIDTH"] = 3840] = "RGBA_SAMPLED_ROW_WIDTH";
+})(Constants || (Constants = {})));
 const allCharCodes = (() => {
     const v = [];
-    for (let i = 32 ; i <= 126 ; i++) {
+    for (let i = Constants.START_CH_CODE; i <= Constants.END_CH_CODE; i++) {
         v.push(i);
     }
-    v.push(65533 );
+    v.push(Constants.UNKNOWN_CODE);
     return v;
 })();
 const getCharIndex = (chCode, fontScale) => {
-    chCode -= 32 ;
-    if (chCode < 0 || chCode > 96 ) {
+    chCode -= Constants.START_CH_CODE;
+    if (chCode < 0 || chCode > Constants.CHAR_COUNT) {
         if (fontScale <= 2) {
-            return ((chCode + 96) ) % 96 ;
+            return (chCode + Constants.CHAR_COUNT) % Constants.CHAR_COUNT;
         }
-        return 96  - 1;
+        return Constants.CHAR_COUNT - 1;
     }
     return chCode;
 };
-export { allCharCodes, getCharIndex };
+export { Constants, allCharCodes, getCharIndex };

package/vscode/src/vs/editor/browser/viewParts/overlayWidgets/overlayWidgets.js

@@ -1,13 +1,15 @@
 import './overlayWidgets.css.js';
 import { createFastDomNode } from '../../../../base/browser/fastDomNode.js';
-import { ViewPart, PartFingerprints } from '../../view/viewPart.js';
+import { OverlayWidgetPositionPreference } from '../../editorBrowser.js';
+import { ViewPart, PartFingerprints, PartFingerprint } from '../../view/viewPart.js';
+import { EditorOption } from '../../../common/config/editorOptions.js';
 import { getDomNodePagePosition } from '../../../../base/browser/dom.js';
 class ViewOverlayWidgets extends ViewPart {
     constructor(context, viewDomNode) {
         super(context);
         this._viewDomNode = viewDomNode;
         const options = this._context.configuration.options;
-        const layoutInfo = options.get(145 );
+        const layoutInfo = options.get(EditorOption.layoutInfo);
         this._widgets = {};
         this._verticalScrollbarWidth = layoutInfo.verticalScrollbarWidth;
         this._minimapWidth = layoutInfo.minimap.minimapWidth;
@@ -16,10 +18,10 @@ class ViewOverlayWidgets extends ViewPart {
         this._editorWidth = layoutInfo.width;
         this._viewDomNodeRect = { top: 0, left: 0, width: 0, height: 0 };
         this._domNode = createFastDomNode(document.createElement('div'));
-        PartFingerprints.write(this._domNode, 4 );
+        PartFingerprints.write(this._domNode, PartFingerprint.OverlayWidgets);
         this._domNode.setClassName('overlayWidgets');
         this.overflowingOverlayWidgetsDomNode = createFastDomNode(document.createElement('div'));
-        PartFingerprints.write(this.overflowingOverlayWidgetsDomNode, 5 );
+        PartFingerprints.write(this.overflowingOverlayWidgetsDomNode, PartFingerprint.OverflowingOverlayWidgets);
         this.overflowingOverlayWidgetsDomNode.setClassName('overflowingOverlayWidgets');
     }
     dispose() {
@@ -31,7 +33,7 @@ class ViewOverlayWidgets extends ViewPart {
     }
     onConfigurationChanged(e) {
         const options = this._context.configuration.options;
-        const layoutInfo = options.get(145 );
+        const layoutInfo = options.get(EditorOption.layoutInfo);
         this._verticalScrollbarWidth = layoutInfo.verticalScrollbarWidth;
         this._minimapWidth = layoutInfo.minimap.minimapWidth;
         this._horizontalScrollbarHeight = layoutInfo.horizontalScrollbarHeight;
@@ -57,13 +59,16 @@ class ViewOverlayWidgets extends ViewPart {
         this.setShouldRender();
         this._updateMaxMinWidth();
     }
-    setWidgetPosition(widget, preference) {
+    setWidgetPosition(widget, position) {
         const widgetData = this._widgets[widget.getId()];
-        if (widgetData.preference === preference) {
+        const preference = position ? position.preference : null;
+        const stack = position?.stackOridinal;
+        if (widgetData.preference === preference && widgetData.stack === stack) {
             this._updateMaxMinWidth();
             return false;
         }
         widgetData.preference = preference;
+        widgetData.stack = stack;
         this.setShouldRender();
         this._updateMaxMinWidth();
         return true;
@@ -92,28 +97,42 @@ class ViewOverlayWidgets extends ViewPart {
         }
         this._context.viewLayout.setOverlayWidgetsMinWidth(maxMinWidth);
     }
-    _renderWidget(widgetData) {
+    _renderWidget(widgetData, stackCoordinates) {
         const domNode = widgetData.domNode;
         if (widgetData.preference === null) {
             domNode.setTop('');
             return;
         }
-        if (widgetData.preference === 0 ) {
-            domNode.setTop(0);
-            domNode.setRight((2 * this._verticalScrollbarWidth) + this._minimapWidth);
-        }
-        else if (widgetData.preference === 1 ) {
-            const widgetHeight = domNode.domNode.clientHeight;
-            domNode.setTop((this._editorHeight - widgetHeight - 2 * this._horizontalScrollbarHeight));
-            domNode.setRight((2 * this._verticalScrollbarWidth) + this._minimapWidth);
+        const maxRight = (2 * this._verticalScrollbarWidth) + this._minimapWidth;
+        if (widgetData.preference === OverlayWidgetPositionPreference.TOP_RIGHT_CORNER || widgetData.preference === OverlayWidgetPositionPreference.BOTTOM_RIGHT_CORNER) {
+            if (widgetData.preference === OverlayWidgetPositionPreference.BOTTOM_RIGHT_CORNER) {
+                const widgetHeight = domNode.domNode.clientHeight;
+                domNode.setTop((this._editorHeight - widgetHeight - 2 * this._horizontalScrollbarHeight));
+            }
+            else {
+                domNode.setTop(0);
+            }
+            if (widgetData.stack !== undefined) {
+                domNode.setTop(stackCoordinates[widgetData.preference]);
+                stackCoordinates[widgetData.preference] += domNode.domNode.clientWidth;
+            }
+            else {
+                domNode.setRight(maxRight);
+            }
         }
-        else if (widgetData.preference === 2 ) {
-            domNode.setTop(0);
+        else if (widgetData.preference === OverlayWidgetPositionPreference.TOP_CENTER) {
             domNode.domNode.style.right = '50%';
+            if (widgetData.stack !== undefined) {
+                domNode.setTop(stackCoordinates[OverlayWidgetPositionPreference.TOP_CENTER]);
+                stackCoordinates[OverlayWidgetPositionPreference.TOP_CENTER] += domNode.domNode.clientHeight;
+            }
+            else {
+                domNode.setTop(0);
+            }
         }
         else {
             const { top, left } = widgetData.preference;
-            const fixedOverflowWidgets = this._context.configuration.options.get(42 );
+            const fixedOverflowWidgets = this._context.configuration.options.get(EditorOption.fixedOverflowWidgets);
             if (fixedOverflowWidgets && widgetData.widget.allowEditorOverflow) {
                 const editorBoundingBox = this._viewDomNodeRect;
                 domNode.setTop(top + editorBoundingBox.top);
@@ -133,9 +152,11 @@ class ViewOverlayWidgets extends ViewPart {
     render(ctx) {
         this._domNode.setWidth(this._editorWidth);
         const keys = ( Object.keys(this._widgets));
+        const stackCoordinates = Array.from({ length: OverlayWidgetPositionPreference.TOP_CENTER + 1 }, () => 0);
+        keys.sort((a, b) => (this._widgets[a].stack || 0) - (this._widgets[b].stack || 0));
         for (let i = 0, len = keys.length; i < len; i++) {
             const widgetId = keys[i];
-            this._renderWidget(this._widgets[widgetId]);
+            this._renderWidget(this._widgets[widgetId], stackCoordinates);
         }
     }
 }

package/vscode/src/vs/editor/browser/viewParts/overviewRuler/decorationsOverviewRuler.js

@@ -4,18 +4,19 @@ import { ViewPart } from '../../view/viewPart.js';
 import { Position } from '../../../common/core/position.js';
 import { TokenizationRegistry } from '../../../common/languages.js';
 import { editorOverviewRulerBorder, editorCursorForeground, editorMultiCursorPrimaryForeground, editorMultiCursorSecondaryForeground, editorOverviewRulerBackground } from '../../../common/core/editorColorRegistry.js';
+import { EditorOption } from '../../../common/config/editorOptions.js';
 import { OverviewRulerDecorationsGroup } from '../../../common/viewModel.js';
 import { equals } from '../../../../base/common/arrays.js';
 class Settings {
     constructor(config, theme) {
         const options = config.options;
-        this.lineHeight = options.get(67 );
-        this.pixelRatio = options.get(143 );
-        this.overviewRulerLanes = options.get(83 );
-        this.renderBorder = options.get(82 );
+        this.lineHeight = options.get(EditorOption.lineHeight);
+        this.pixelRatio = options.get(EditorOption.pixelRatio);
+        this.overviewRulerLanes = options.get(EditorOption.overviewRulerLanes);
+        this.renderBorder = options.get(EditorOption.overviewRulerBorder);
         const borderColor = theme.getColor(editorOverviewRulerBorder);
         this.borderColor = borderColor ? ( borderColor.toString()) : null;
-        this.hideCursor = options.get(59 );
+        this.hideCursor = options.get(EditorOption.hideCursorInOverviewRuler);
         const cursorColorSingle = theme.getColor(editorCursorForeground);
         this.cursorColorSingle = cursorColorSingle ? ( ( cursorColorSingle.transparent(0.7)).toString()) : null;
         const cursorColorPrimary = theme.getColor(editorMultiCursorPrimaryForeground);
@@ -23,7 +24,7 @@ class Settings {
         const cursorColorSecondary = theme.getColor(editorMultiCursorSecondaryForeground);
         this.cursorColorSecondary = cursorColorSecondary ? ( ( cursorColorSecondary.transparent(0.7)).toString()) : null;
         this.themeType = theme.type;
-        const minimapOpts = options.get(73 );
+        const minimapOpts = options.get(EditorOption.minimap);
         const minimapEnabled = minimapOpts.enabled;
         const minimapSide = minimapOpts.side;
         const themeColor = theme.getColor(editorOverviewRulerBackground);
@@ -37,7 +38,7 @@ class Settings {
         else {
             this.backgroundColor = null;
         }
-        const layoutInfo = options.get(145 );
+        const layoutInfo = options.get(EditorOption.layoutInfo);
         const position = layoutInfo.overviewRuler;
         this.top = position.top;
         this.right = position.right;
@@ -159,10 +160,27 @@ class Settings {
             && this.canvasHeight === other.canvasHeight);
     }
 }
+var Constants;
+( (function(Constants) {
+    Constants[Constants["MIN_DECORATION_HEIGHT"] = 6] = "MIN_DECORATION_HEIGHT";
+})(Constants || (Constants = {})));
+var OverviewRulerLane;
+( (function(OverviewRulerLane) {
+    OverviewRulerLane[OverviewRulerLane["Left"] = 1] = "Left";
+    OverviewRulerLane[OverviewRulerLane["Center"] = 2] = "Center";
+    OverviewRulerLane[OverviewRulerLane["Right"] = 4] = "Right";
+    OverviewRulerLane[OverviewRulerLane["Full"] = 7] = "Full";
+})(OverviewRulerLane || (OverviewRulerLane = {})));
+var ShouldRenderValue;
+( (function(ShouldRenderValue) {
+    ShouldRenderValue[ShouldRenderValue["NotNeeded"] = 0] = "NotNeeded";
+    ShouldRenderValue[ShouldRenderValue["Maybe"] = 1] = "Maybe";
+    ShouldRenderValue[ShouldRenderValue["Needed"] = 2] = "Needed";
+})(ShouldRenderValue || (ShouldRenderValue = {})));
 class DecorationsOverviewRuler extends ViewPart {
     constructor(context) {
         super(context);
-        this._actualShouldRender = 0 ;
+        this._actualShouldRender = ShouldRenderValue.NotNeeded;
         this._renderedDecorations = [];
         this._renderedCursorPositions = [];
         this._domNode = createFastDomNode(document.createElement('canvas'));
@@ -201,11 +219,11 @@ class DecorationsOverviewRuler extends ViewPart {
         return true;
     }
     _markRenderingIsNeeded() {
-        this._actualShouldRender = 2 ;
+        this._actualShouldRender = ShouldRenderValue.Needed;
         return true;
     }
     _markRenderingIsMaybeNeeded() {
-        this._actualShouldRender = 1 ;
+        this._actualShouldRender = ShouldRenderValue.Maybe;
         return true;
     }
     onConfigurationChanged(e) {
@@ -248,7 +266,7 @@ class DecorationsOverviewRuler extends ViewPart {
     }
     render(editorCtx) {
         this._render();
-        this._actualShouldRender = 0 ;
+        this._actualShouldRender = ShouldRenderValue.NotNeeded;
     }
     _render() {
         const backgroundColor = this._settings.backgroundColor;
@@ -259,13 +277,13 @@ class DecorationsOverviewRuler extends ViewPart {
         }
         const decorations = this._context.viewModel.getAllOverviewRulerDecorations(this._context.theme);
         decorations.sort(OverviewRulerDecorationsGroup.compareByRenderingProps);
-        if (this._actualShouldRender === 1  && !OverviewRulerDecorationsGroup.equalsArr(this._renderedDecorations, decorations)) {
-            this._actualShouldRender = 2 ;
+        if (this._actualShouldRender === ShouldRenderValue.Maybe && !OverviewRulerDecorationsGroup.equalsArr(this._renderedDecorations, decorations)) {
+            this._actualShouldRender = ShouldRenderValue.Needed;
         }
-        if (this._actualShouldRender === 1  && !equals(this._renderedCursorPositions, this._cursorPositions, (a, b) => a.position.lineNumber === b.position.lineNumber && a.color === b.color)) {
-            this._actualShouldRender = 2 ;
+        if (this._actualShouldRender === ShouldRenderValue.Maybe && !equals(this._renderedCursorPositions, this._cursorPositions, (a, b) => a.position.lineNumber === b.position.lineNumber && a.color === b.color)) {
+            this._actualShouldRender = ShouldRenderValue.Needed;
         }
-        if (this._actualShouldRender === 1 ) {
+        if (this._actualShouldRender === ShouldRenderValue.Maybe) {
             return;
         }
         this._renderedDecorations = decorations;
@@ -277,7 +295,7 @@ class DecorationsOverviewRuler extends ViewPart {
         const viewLayout = this._context.viewLayout;
         const outerHeight = this._context.viewLayout.getScrollHeight();
         const heightRatio = canvasHeight / outerHeight;
-        const minDecorationHeight = (6  * this._settings.pixelRatio) | 0;
+        const minDecorationHeight = (Constants.MIN_DECORATION_HEIGHT * this._settings.pixelRatio) | 0;
         const halfMinDecorationHeight = (minDecorationHeight / 2) | 0;
         const canvasCtx = this._domNode.domNode.getContext('2d');
         if (backgroundColor) {
@@ -340,8 +358,8 @@ class DecorationsOverviewRuler extends ViewPart {
         if (!this._settings.hideCursor) {
             const cursorHeight = (2 * this._settings.pixelRatio) | 0;
             const halfCursorHeight = (cursorHeight / 2) | 0;
-            const cursorX = this._settings.x[7 ];
-            const cursorW = this._settings.w[7 ];
+            const cursorX = this._settings.x[OverviewRulerLane.Full];
+            const cursorW = this._settings.w[OverviewRulerLane.Full];
             let prevY1 = -100;
             let prevY2 = -100;
             let prevColor = null;

package/vscode/src/vs/editor/browser/viewParts/overviewRuler/overviewRuler.js

@@ -1,4 +1,5 @@
 import { createFastDomNode } from '../../../../base/browser/fastDomNode.js';
+import { EditorOption } from '../../../common/config/editorOptions.js';
 import { OverviewZoneManager } from '../../../common/viewModel/overviewZoneManager.js';
 import { ViewEventHandler } from '../../../common/viewEventHandler.js';
 class OverviewRuler extends ViewEventHandler {
@@ -17,8 +18,8 @@ class OverviewRuler extends ViewEventHandler {
         this._zoneManager.setDOMWidth(0);
         this._zoneManager.setDOMHeight(0);
         this._zoneManager.setOuterHeight(this._context.viewLayout.getScrollHeight());
-        this._zoneManager.setLineHeight(options.get(67 ));
-        this._zoneManager.setPixelRatio(options.get(143 ));
+        this._zoneManager.setLineHeight(options.get(EditorOption.lineHeight));
+        this._zoneManager.setPixelRatio(options.get(EditorOption.pixelRatio));
         this._context.addEventHandler(this);
     }
     dispose() {
@@ -27,12 +28,12 @@ class OverviewRuler extends ViewEventHandler {
     }
     onConfigurationChanged(e) {
         const options = this._context.configuration.options;
-        if (e.hasChanged(67 )) {
-            this._zoneManager.setLineHeight(options.get(67 ));
+        if (e.hasChanged(EditorOption.lineHeight)) {
+            this._zoneManager.setLineHeight(options.get(EditorOption.lineHeight));
             this._render();
         }
-        if (e.hasChanged(143 )) {
-            this._zoneManager.setPixelRatio(options.get(143 ));
+        if (e.hasChanged(EditorOption.pixelRatio)) {
+            this._zoneManager.setPixelRatio(options.get(EditorOption.pixelRatio));
             this._domNode.setWidth(this._zoneManager.getDOMWidth());
             this._domNode.setHeight(this._zoneManager.getDOMHeight());
             this._domNode.domNode.width = this._zoneManager.getCanvasWidth();

package/vscode/src/vs/editor/browser/viewParts/rulers/rulers.js

@@ -1,6 +1,7 @@
 import './rulers.css.js';
 import { createFastDomNode } from '../../../../base/browser/fastDomNode.js';
 import { ViewPart } from '../../view/viewPart.js';
+import { EditorOption } from '../../../common/config/editorOptions.js';
 class Rulers extends ViewPart {
     constructor(context) {
         super(context);
@@ -10,16 +11,16 @@ class Rulers extends ViewPart {
         this.domNode.setClassName('view-rulers');
         this._renderedRulers = [];
         const options = this._context.configuration.options;
-        this._rulers = options.get(102 );
-        this._typicalHalfwidthCharacterWidth = options.get(50 ).typicalHalfwidthCharacterWidth;
+        this._rulers = options.get(EditorOption.rulers);
+        this._typicalHalfwidthCharacterWidth = options.get(EditorOption.fontInfo).typicalHalfwidthCharacterWidth;
     }
     dispose() {
         super.dispose();
     }
     onConfigurationChanged(e) {
         const options = this._context.configuration.options;
-        this._rulers = options.get(102 );
-        this._typicalHalfwidthCharacterWidth = options.get(50 ).typicalHalfwidthCharacterWidth;
+        this._rulers = options.get(EditorOption.rulers);
+        this._typicalHalfwidthCharacterWidth = options.get(EditorOption.fontInfo).typicalHalfwidthCharacterWidth;
         return true;
     }
     onScrollChanged(e) {

package/vscode/src/vs/editor/browser/viewParts/scrollDecoration/scrollDecoration.js

@@ -1,6 +1,7 @@
 import './scrollDecoration.css.js';
 import { createFastDomNode } from '../../../../base/browser/fastDomNode.js';
 import { ViewPart } from '../../view/viewPart.js';
+import { EditorOption } from '../../../common/config/editorOptions.js';
 class ScrollDecorationViewPart extends ViewPart {
     constructor(context) {
         super(context);
@@ -9,7 +10,7 @@ class ScrollDecorationViewPart extends ViewPart {
         this._updateWidth();
         this._shouldShow = false;
         const options = this._context.configuration.options;
-        const scrollbar = options.get(103 );
+        const scrollbar = options.get(EditorOption.scrollbar);
         this._useShadows = scrollbar.useShadows;
         this._domNode = createFastDomNode(document.createElement('div'));
         this._domNode.setAttribute('role', 'presentation');
@@ -31,7 +32,7 @@ class ScrollDecorationViewPart extends ViewPart {
     }
     _updateWidth() {
         const options = this._context.configuration.options;
-        const layoutInfo = options.get(145 );
+        const layoutInfo = options.get(EditorOption.layoutInfo);
         if (layoutInfo.minimap.renderMinimap === 0 || (layoutInfo.minimap.minimapWidth > 0 && layoutInfo.minimap.minimapLeft === 0)) {
             this._width = layoutInfo.width;
         }
@@ -41,7 +42,7 @@ class ScrollDecorationViewPart extends ViewPart {
     }
     onConfigurationChanged(e) {
         const options = this._context.configuration.options;
-        const scrollbar = options.get(103 );
+        const scrollbar = options.get(EditorOption.scrollbar);
         this._useShadows = scrollbar.useShadows;
         this._updateWidth();
         this._updateShouldShow();

package/vscode/src/vs/editor/browser/viewParts/selections/selections.js

@@ -12,6 +12,13 @@ import '../../../../platform/theme/common/colors/miscColors.js';
 import '../../../../platform/theme/common/colors/quickpickColors.js';
 import '../../../../platform/theme/common/colors/searchColors.js';
 import { registerThemingParticipant } from '../../../../platform/theme/common/themeService.js';
+import { EditorOption } from '../../../common/config/editorOptions.js';
+var CornerStyle;
+( (function(CornerStyle) {
+    CornerStyle[CornerStyle["EXTERN"] = 0] = "EXTERN";
+    CornerStyle[CornerStyle["INTERN"] = 1] = "INTERN";
+    CornerStyle[CornerStyle["FLAT"] = 2] = "FLAT";
+})(CornerStyle || (CornerStyle = {})));
 class HorizontalRangeWithStyle {
     constructor(other) {
         this.left = other.left;
@@ -45,8 +52,8 @@ class SelectionsOverlay extends DynamicViewOverlay {
         this._previousFrameVisibleRangesWithStyle = [];
         this._context = context;
         const options = this._context.configuration.options;
-        this._roundedSelection = options.get(101 );
-        this._typicalHalfwidthCharacterWidth = options.get(50 ).typicalHalfwidthCharacterWidth;
+        this._roundedSelection = options.get(EditorOption.roundedSelection);
+        this._typicalHalfwidthCharacterWidth = options.get(EditorOption.fontInfo).typicalHalfwidthCharacterWidth;
         this._selections = [];
         this._renderResult = null;
         this._context.addEventHandler(this);
@@ -58,8 +65,8 @@ class SelectionsOverlay extends DynamicViewOverlay {
     }
     onConfigurationChanged(e) {
         const options = this._context.configuration.options;
-        this._roundedSelection = options.get(101 );
-        this._typicalHalfwidthCharacterWidth = options.get(50 ).typicalHalfwidthCharacterWidth;
+        this._roundedSelection = options.get(EditorOption.roundedSelection);
+        this._typicalHalfwidthCharacterWidth = options.get(EditorOption.fontInfo).typicalHalfwidthCharacterWidth;
         return true;
     }
     onCursorStateChanged(e) {
@@ -129,27 +136,27 @@ class SelectionsOverlay extends DynamicViewOverlay {
             const curLeft = curLineRange.left;
             const curRight = curLineRange.left + curLineRange.width;
             const startStyle = {
-                top: 0 ,
-                bottom: 0
+                top: CornerStyle.EXTERN,
+                bottom: CornerStyle.EXTERN
             };
             const endStyle = {
-                top: 0 ,
-                bottom: 0
+                top: CornerStyle.EXTERN,
+                bottom: CornerStyle.EXTERN
             };
             if (i > 0) {
                 const prevLeft = linesVisibleRanges[i - 1].ranges[0].left;
                 const prevRight = linesVisibleRanges[i - 1].ranges[0].left + linesVisibleRanges[i - 1].ranges[0].width;
                 if (abs(curLeft - prevLeft) < epsilon) {
-                    startStyle.top = 2 ;
+                    startStyle.top = CornerStyle.FLAT;
                 }
                 else if (curLeft > prevLeft) {
-                    startStyle.top = 1 ;
+                    startStyle.top = CornerStyle.INTERN;
                 }
                 if (abs(curRight - prevRight) < epsilon) {
-                    endStyle.top = 2 ;
+                    endStyle.top = CornerStyle.FLAT;
                 }
                 else if (prevLeft < curRight && curRight < prevRight) {
-                    endStyle.top = 1 ;
+                    endStyle.top = CornerStyle.INTERN;
                 }
             }
             else if (previousFrameTop) {
@@ -160,16 +167,16 @@ class SelectionsOverlay extends DynamicViewOverlay {
                 const nextLeft = linesVisibleRanges[i + 1].ranges[0].left;
                 const nextRight = linesVisibleRanges[i + 1].ranges[0].left + linesVisibleRanges[i + 1].ranges[0].width;
                 if (abs(curLeft - nextLeft) < epsilon) {
-                    startStyle.bottom = 2 ;
+                    startStyle.bottom = CornerStyle.FLAT;
                 }
                 else if (nextLeft < curLeft && curLeft < nextRight) {
-                    startStyle.bottom = 1 ;
+                    startStyle.bottom = CornerStyle.INTERN;
                 }
                 if (abs(curRight - nextRight) < epsilon) {
-                    endStyle.bottom = 2 ;
+                    endStyle.bottom = CornerStyle.FLAT;
                 }
                 else if (curRight < nextRight) {
-                    endStyle.bottom = 1 ;
+                    endStyle.bottom = CornerStyle.INTERN;
                 }
             }
             else if (previousFrameBottom) {
@@ -218,24 +225,24 @@ class SelectionsOverlay extends DynamicViewOverlay {
                 if (visibleRangesHaveStyle) {
                     const startStyle = visibleRange.startStyle;
                     const endStyle = visibleRange.endStyle;
-                    if (startStyle.top === 1  || startStyle.bottom === 1 ) {
+                    if (startStyle.top === CornerStyle.INTERN || startStyle.bottom === CornerStyle.INTERN) {
                         innerCornerOutput += this._createSelectionPiece(top, bottom, SelectionsOverlay.SELECTION_CLASS_NAME, visibleRange.left - SelectionsOverlay.ROUNDED_PIECE_WIDTH, SelectionsOverlay.ROUNDED_PIECE_WIDTH);
                         let className = SelectionsOverlay.EDITOR_BACKGROUND_CLASS_NAME;
-                        if (startStyle.top === 1 ) {
+                        if (startStyle.top === CornerStyle.INTERN) {
                             className += ' ' + SelectionsOverlay.SELECTION_TOP_RIGHT;
                         }
-                        if (startStyle.bottom === 1 ) {
+                        if (startStyle.bottom === CornerStyle.INTERN) {
                             className += ' ' + SelectionsOverlay.SELECTION_BOTTOM_RIGHT;
                         }
                         innerCornerOutput += this._createSelectionPiece(top, bottom, className, visibleRange.left - SelectionsOverlay.ROUNDED_PIECE_WIDTH, SelectionsOverlay.ROUNDED_PIECE_WIDTH);
                     }
-                    if (endStyle.top === 1  || endStyle.bottom === 1 ) {
+                    if (endStyle.top === CornerStyle.INTERN || endStyle.bottom === CornerStyle.INTERN) {
                         innerCornerOutput += this._createSelectionPiece(top, bottom, SelectionsOverlay.SELECTION_CLASS_NAME, visibleRange.left + visibleRange.width, SelectionsOverlay.ROUNDED_PIECE_WIDTH);
                         let className = SelectionsOverlay.EDITOR_BACKGROUND_CLASS_NAME;
-                        if (endStyle.top === 1 ) {
+                        if (endStyle.top === CornerStyle.INTERN) {
                             className += ' ' + SelectionsOverlay.SELECTION_TOP_LEFT;
                         }
-                        if (endStyle.bottom === 1 ) {
+                        if (endStyle.bottom === CornerStyle.INTERN) {
                             className += ' ' + SelectionsOverlay.SELECTION_BOTTOM_LEFT;
                         }
                         innerCornerOutput += this._createSelectionPiece(top, bottom, className, visibleRange.left + visibleRange.width, SelectionsOverlay.ROUNDED_PIECE_WIDTH);
@@ -245,16 +252,16 @@ class SelectionsOverlay extends DynamicViewOverlay {
                 if (visibleRangesHaveStyle) {
                     const startStyle = visibleRange.startStyle;
                     const endStyle = visibleRange.endStyle;
-                    if (startStyle.top === 0 ) {
+                    if (startStyle.top === CornerStyle.EXTERN) {
                         className += ' ' + SelectionsOverlay.SELECTION_TOP_LEFT;
                     }
-                    if (startStyle.bottom === 0 ) {
+                    if (startStyle.bottom === CornerStyle.EXTERN) {
                         className += ' ' + SelectionsOverlay.SELECTION_BOTTOM_LEFT;
                     }
-                    if (endStyle.top === 0 ) {
+                    if (endStyle.top === CornerStyle.EXTERN) {
                         className += ' ' + SelectionsOverlay.SELECTION_TOP_RIGHT;
                     }
-                    if (endStyle.bottom === 0 ) {
+                    if (endStyle.bottom === CornerStyle.EXTERN) {
                         className += ' ' + SelectionsOverlay.SELECTION_BOTTOM_RIGHT;
                     }
                 }