@codingame/monaco-vscode-api 1.85.4 → 2.0.0-rework-ci.1

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

@@ -0,0 +1,306 @@
+import './selections.css.js';
+import { DynamicViewOverlay } from '../../view/dynamicViewOverlay.js';
+import { editorSelectionForeground } from '../../../../platform/theme/common/colorRegistry.js';
+import { registerThemingParticipant } from '../../../../platform/theme/common/themeService.js';
+class HorizontalRangeWithStyle {
+    constructor(other) {
+        this.left = other.left;
+        this.width = other.width;
+        this.startStyle = null;
+        this.endStyle = null;
+    }
+}
+class LineVisibleRangesWithStyle {
+    constructor(lineNumber, ranges) {
+        this.lineNumber = lineNumber;
+        this.ranges = ranges;
+    }
+}
+function toStyledRange(item) {
+    return ( new HorizontalRangeWithStyle(item));
+}
+function toStyled(item) {
+    return ( new LineVisibleRangesWithStyle(item.lineNumber, ( item.ranges.map(toStyledRange))));
+}
+class SelectionsOverlay extends DynamicViewOverlay {
+    static { this.SELECTION_CLASS_NAME = 'selected-text'; }
+    static { this.SELECTION_TOP_LEFT = 'top-left-radius'; }
+    static { this.SELECTION_BOTTOM_LEFT = 'bottom-left-radius'; }
+    static { this.SELECTION_TOP_RIGHT = 'top-right-radius'; }
+    static { this.SELECTION_BOTTOM_RIGHT = 'bottom-right-radius'; }
+    static { this.EDITOR_BACKGROUND_CLASS_NAME = 'monaco-editor-background'; }
+    static { this.ROUNDED_PIECE_WIDTH = 10; }
+    constructor(context) {
+        super();
+        this._previousFrameVisibleRangesWithStyle = [];
+        this._context = context;
+        const options = this._context.configuration.options;
+        this._lineHeight = options.get(66 );
+        this._roundedSelection = options.get(100 );
+        this._typicalHalfwidthCharacterWidth = options.get(50 ).typicalHalfwidthCharacterWidth;
+        this._selections = [];
+        this._renderResult = null;
+        this._context.addEventHandler(this);
+    }
+    dispose() {
+        this._context.removeEventHandler(this);
+        this._renderResult = null;
+        super.dispose();
+    }
+    onConfigurationChanged(e) {
+        const options = this._context.configuration.options;
+        this._lineHeight = options.get(66 );
+        this._roundedSelection = options.get(100 );
+        this._typicalHalfwidthCharacterWidth = options.get(50 ).typicalHalfwidthCharacterWidth;
+        return true;
+    }
+    onCursorStateChanged(e) {
+        this._selections = e.selections.slice(0);
+        return true;
+    }
+    onDecorationsChanged(e) {
+        return true;
+    }
+    onFlushed(e) {
+        return true;
+    }
+    onLinesChanged(e) {
+        return true;
+    }
+    onLinesDeleted(e) {
+        return true;
+    }
+    onLinesInserted(e) {
+        return true;
+    }
+    onScrollChanged(e) {
+        return e.scrollTopChanged;
+    }
+    onZonesChanged(e) {
+        return true;
+    }
+    _visibleRangesHaveGaps(linesVisibleRanges) {
+        for (let i = 0, len = linesVisibleRanges.length; i < len; i++) {
+            const lineVisibleRanges = linesVisibleRanges[i];
+            if (lineVisibleRanges.ranges.length > 1) {
+                return true;
+            }
+        }
+        return false;
+    }
+    _enrichVisibleRangesWithStyle(viewport, linesVisibleRanges, previousFrame) {
+        const epsilon = this._typicalHalfwidthCharacterWidth / 4;
+        let previousFrameTop = null;
+        let previousFrameBottom = null;
+        if (previousFrame && previousFrame.length > 0 && linesVisibleRanges.length > 0) {
+            const topLineNumber = linesVisibleRanges[0].lineNumber;
+            if (topLineNumber === viewport.startLineNumber) {
+                for (let i = 0; !previousFrameTop && i < previousFrame.length; i++) {
+                    if (previousFrame[i].lineNumber === topLineNumber) {
+                        previousFrameTop = previousFrame[i].ranges[0];
+                    }
+                }
+            }
+            const bottomLineNumber = linesVisibleRanges[linesVisibleRanges.length - 1].lineNumber;
+            if (bottomLineNumber === viewport.endLineNumber) {
+                for (let i = previousFrame.length - 1; !previousFrameBottom && i >= 0; i--) {
+                    if (previousFrame[i].lineNumber === bottomLineNumber) {
+                        previousFrameBottom = previousFrame[i].ranges[0];
+                    }
+                }
+            }
+            if (previousFrameTop && !previousFrameTop.startStyle) {
+                previousFrameTop = null;
+            }
+            if (previousFrameBottom && !previousFrameBottom.startStyle) {
+                previousFrameBottom = null;
+            }
+        }
+        for (let i = 0, len = linesVisibleRanges.length; i < len; i++) {
+            const curLineRange = linesVisibleRanges[i].ranges[0];
+            const curLeft = curLineRange.left;
+            const curRight = curLineRange.left + curLineRange.width;
+            const startStyle = {
+                top: 0 ,
+                bottom: 0
+            };
+            const endStyle = {
+                top: 0 ,
+                bottom: 0
+            };
+            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 ;
+                }
+                else if (curLeft > prevLeft) {
+                    startStyle.top = 1 ;
+                }
+                if (abs(curRight - prevRight) < epsilon) {
+                    endStyle.top = 2 ;
+                }
+                else if (prevLeft < curRight && curRight < prevRight) {
+                    endStyle.top = 1 ;
+                }
+            }
+            else if (previousFrameTop) {
+                startStyle.top = previousFrameTop.startStyle.top;
+                endStyle.top = previousFrameTop.endStyle.top;
+            }
+            if (i + 1 < len) {
+                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 ;
+                }
+                else if (nextLeft < curLeft && curLeft < nextRight) {
+                    startStyle.bottom = 1 ;
+                }
+                if (abs(curRight - nextRight) < epsilon) {
+                    endStyle.bottom = 2 ;
+                }
+                else if (curRight < nextRight) {
+                    endStyle.bottom = 1 ;
+                }
+            }
+            else if (previousFrameBottom) {
+                startStyle.bottom = previousFrameBottom.startStyle.bottom;
+                endStyle.bottom = previousFrameBottom.endStyle.bottom;
+            }
+            curLineRange.startStyle = startStyle;
+            curLineRange.endStyle = endStyle;
+        }
+    }
+    _getVisibleRangesWithStyle(selection, ctx, previousFrame) {
+        const _linesVisibleRanges = ctx.linesVisibleRangesForRange(selection, true) || [];
+        const linesVisibleRanges = ( _linesVisibleRanges.map(toStyled));
+        const visibleRangesHaveGaps = this._visibleRangesHaveGaps(linesVisibleRanges);
+        if (!visibleRangesHaveGaps && this._roundedSelection) {
+            this._enrichVisibleRangesWithStyle(ctx.visibleRange, linesVisibleRanges, previousFrame);
+        }
+        return linesVisibleRanges;
+    }
+    _createSelectionPiece(top, height, className, left, width) {
+        return ('<div class="cslr '
+            + className
+            + '" style="top:'
+            + ( top.toString())
+            + 'px;left:'
+            + ( left.toString())
+            + 'px;width:'
+            + ( width.toString())
+            + 'px;height:'
+            + height + 'px;"></div>');
+    }
+    _actualRenderOneSelection(output2, visibleStartLineNumber, hasMultipleSelections, visibleRanges) {
+        if (visibleRanges.length === 0) {
+            return;
+        }
+        const visibleRangesHaveStyle = !!visibleRanges[0].ranges[0].startStyle;
+        const fullLineHeight = ( (this._lineHeight).toString());
+        const reducedLineHeight = ( (this._lineHeight - 1).toString());
+        const firstLineNumber = visibleRanges[0].lineNumber;
+        const lastLineNumber = visibleRanges[visibleRanges.length - 1].lineNumber;
+        for (let i = 0, len = visibleRanges.length; i < len; i++) {
+            const lineVisibleRanges = visibleRanges[i];
+            const lineNumber = lineVisibleRanges.lineNumber;
+            const lineIndex = lineNumber - visibleStartLineNumber;
+            const lineHeight = hasMultipleSelections ? (lineNumber === lastLineNumber || lineNumber === firstLineNumber ? reducedLineHeight : fullLineHeight) : fullLineHeight;
+            const top = hasMultipleSelections ? (lineNumber === firstLineNumber ? 1 : 0) : 0;
+            let innerCornerOutput = '';
+            let restOfSelectionOutput = '';
+            for (let j = 0, lenJ = lineVisibleRanges.ranges.length; j < lenJ; j++) {
+                const visibleRange = lineVisibleRanges.ranges[j];
+                if (visibleRangesHaveStyle) {
+                    const startStyle = visibleRange.startStyle;
+                    const endStyle = visibleRange.endStyle;
+                    if (startStyle.top === 1  || startStyle.bottom === 1 ) {
+                        innerCornerOutput += this._createSelectionPiece(top, lineHeight, 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 ) {
+                            className += ' ' + SelectionsOverlay.SELECTION_TOP_RIGHT;
+                        }
+                        if (startStyle.bottom === 1 ) {
+                            className += ' ' + SelectionsOverlay.SELECTION_BOTTOM_RIGHT;
+                        }
+                        innerCornerOutput += this._createSelectionPiece(top, lineHeight, className, visibleRange.left - SelectionsOverlay.ROUNDED_PIECE_WIDTH, SelectionsOverlay.ROUNDED_PIECE_WIDTH);
+                    }
+                    if (endStyle.top === 1  || endStyle.bottom === 1 ) {
+                        innerCornerOutput += this._createSelectionPiece(top, lineHeight, SelectionsOverlay.SELECTION_CLASS_NAME, visibleRange.left + visibleRange.width, SelectionsOverlay.ROUNDED_PIECE_WIDTH);
+                        let className = SelectionsOverlay.EDITOR_BACKGROUND_CLASS_NAME;
+                        if (endStyle.top === 1 ) {
+                            className += ' ' + SelectionsOverlay.SELECTION_TOP_LEFT;
+                        }
+                        if (endStyle.bottom === 1 ) {
+                            className += ' ' + SelectionsOverlay.SELECTION_BOTTOM_LEFT;
+                        }
+                        innerCornerOutput += this._createSelectionPiece(top, lineHeight, className, visibleRange.left + visibleRange.width, SelectionsOverlay.ROUNDED_PIECE_WIDTH);
+                    }
+                }
+                let className = SelectionsOverlay.SELECTION_CLASS_NAME;
+                if (visibleRangesHaveStyle) {
+                    const startStyle = visibleRange.startStyle;
+                    const endStyle = visibleRange.endStyle;
+                    if (startStyle.top === 0 ) {
+                        className += ' ' + SelectionsOverlay.SELECTION_TOP_LEFT;
+                    }
+                    if (startStyle.bottom === 0 ) {
+                        className += ' ' + SelectionsOverlay.SELECTION_BOTTOM_LEFT;
+                    }
+                    if (endStyle.top === 0 ) {
+                        className += ' ' + SelectionsOverlay.SELECTION_TOP_RIGHT;
+                    }
+                    if (endStyle.bottom === 0 ) {
+                        className += ' ' + SelectionsOverlay.SELECTION_BOTTOM_RIGHT;
+                    }
+                }
+                restOfSelectionOutput += this._createSelectionPiece(top, lineHeight, className, visibleRange.left, visibleRange.width);
+            }
+            output2[lineIndex][0] += innerCornerOutput;
+            output2[lineIndex][1] += restOfSelectionOutput;
+        }
+    }
+    prepareRender(ctx) {
+        const output = [];
+        const visibleStartLineNumber = ctx.visibleRange.startLineNumber;
+        const visibleEndLineNumber = ctx.visibleRange.endLineNumber;
+        for (let lineNumber = visibleStartLineNumber; lineNumber <= visibleEndLineNumber; lineNumber++) {
+            const lineIndex = lineNumber - visibleStartLineNumber;
+            output[lineIndex] = ['', ''];
+        }
+        const thisFrameVisibleRangesWithStyle = [];
+        for (let i = 0, len = this._selections.length; i < len; i++) {
+            const selection = this._selections[i];
+            if (selection.isEmpty()) {
+                thisFrameVisibleRangesWithStyle[i] = null;
+                continue;
+            }
+            const visibleRangesWithStyle = this._getVisibleRangesWithStyle(selection, ctx, this._previousFrameVisibleRangesWithStyle[i]);
+            thisFrameVisibleRangesWithStyle[i] = visibleRangesWithStyle;
+            this._actualRenderOneSelection(output, visibleStartLineNumber, this._selections.length > 1, visibleRangesWithStyle);
+        }
+        this._previousFrameVisibleRangesWithStyle = thisFrameVisibleRangesWithStyle;
+        this._renderResult = ( output.map(([internalCorners, restOfSelection]) => internalCorners + restOfSelection));
+    }
+    render(startLineNumber, lineNumber) {
+        if (!this._renderResult) {
+            return '';
+        }
+        const lineIndex = lineNumber - startLineNumber;
+        if (lineIndex < 0 || lineIndex >= this._renderResult.length) {
+            return '';
+        }
+        return this._renderResult[lineIndex];
+    }
+}
+registerThemingParticipant((theme, collector) => {
+    const editorSelectionForegroundColor = theme.getColor(editorSelectionForeground);
+    if (editorSelectionForegroundColor && !editorSelectionForegroundColor.isTransparent()) {
+        collector.addRule(`.monaco-editor .view-line span.inline-selected-text { color: ${editorSelectionForegroundColor}; }`);
+    }
+});
+function abs(n) {
+    return n < 0 ? -n : n;
+}
+export { SelectionsOverlay };

package/vscode/src/vs/editor/browser/viewParts/viewCursors/viewCursor.js

@@ -0,0 +1,188 @@
+import { getWindow, computeScreenAwareSize } from '../../../../base/browser/dom.js';
+import { createFastDomNode } from '../../../../base/browser/fastDomNode.js';
+import { getCharContainingOffset } from '../../../../base/common/strings.js';
+import { applyFontInfo } from '../../config/domFontInfo.js';
+import { TextEditorCursorStyle } from '../../../common/config/editorOptions.js';
+import { Position } from '../../../common/core/position.js';
+import { Range } from '../../../common/core/range.js';
+import { MOUSE_CURSOR_TEXT_CSS_CLASS_NAME } from '../../../../base/browser/ui/mouseCursor/mouseCursor.js';
+class ViewCursorRenderData {
+    constructor(top, left, paddingLeft, width, height, textContent, textContentClassName) {
+        this.top = top;
+        this.left = left;
+        this.paddingLeft = paddingLeft;
+        this.width = width;
+        this.height = height;
+        this.textContent = textContent;
+        this.textContentClassName = textContentClassName;
+    }
+}
+class ViewCursor {
+    constructor(context) {
+        this._context = context;
+        const options = this._context.configuration.options;
+        const fontInfo = options.get(50 );
+        this._cursorStyle = options.get(28 );
+        this._lineHeight = options.get(66 );
+        this._typicalHalfwidthCharacterWidth = fontInfo.typicalHalfwidthCharacterWidth;
+        this._lineCursorWidth = Math.min(options.get(31 ), this._typicalHalfwidthCharacterWidth);
+        this._isVisible = true;
+        this._domNode = createFastDomNode(document.createElement('div'));
+        this._domNode.setClassName(`cursor ${MOUSE_CURSOR_TEXT_CSS_CLASS_NAME}`);
+        this._domNode.setHeight(this._lineHeight);
+        this._domNode.setTop(0);
+        this._domNode.setLeft(0);
+        applyFontInfo(this._domNode, fontInfo);
+        this._domNode.setDisplay('none');
+        this._position = ( new Position(1, 1));
+        this._lastRenderedContent = '';
+        this._renderData = null;
+    }
+    getDomNode() {
+        return this._domNode;
+    }
+    getPosition() {
+        return this._position;
+    }
+    show() {
+        if (!this._isVisible) {
+            this._domNode.setVisibility('inherit');
+            this._isVisible = true;
+        }
+    }
+    hide() {
+        if (this._isVisible) {
+            this._domNode.setVisibility('hidden');
+            this._isVisible = false;
+        }
+    }
+    onConfigurationChanged(e) {
+        const options = this._context.configuration.options;
+        const fontInfo = options.get(50 );
+        this._cursorStyle = options.get(28 );
+        this._lineHeight = options.get(66 );
+        this._typicalHalfwidthCharacterWidth = fontInfo.typicalHalfwidthCharacterWidth;
+        this._lineCursorWidth = Math.min(options.get(31 ), this._typicalHalfwidthCharacterWidth);
+        applyFontInfo(this._domNode, fontInfo);
+        return true;
+    }
+    onCursorPositionChanged(position, pauseAnimation) {
+        if (pauseAnimation) {
+            this._domNode.domNode.style.transitionProperty = 'none';
+        }
+        else {
+            this._domNode.domNode.style.transitionProperty = '';
+        }
+        this._position = position;
+        return true;
+    }
+    _getGraphemeAwarePosition() {
+        const { lineNumber, column } = this._position;
+        const lineContent = this._context.viewModel.getLineContent(lineNumber);
+        const [startOffset, endOffset] = getCharContainingOffset(lineContent, column - 1);
+        return [( new Position(lineNumber, startOffset + 1)), lineContent.substring(startOffset, endOffset)];
+    }
+    _prepareRender(ctx) {
+        let textContent = '';
+        let textContentClassName = '';
+        const [position, nextGrapheme] = this._getGraphemeAwarePosition();
+        if (this._cursorStyle === TextEditorCursorStyle.Line || this._cursorStyle === TextEditorCursorStyle.LineThin) {
+            const visibleRange = ctx.visibleRangeForPosition(position);
+            if (!visibleRange || visibleRange.outsideRenderedLine) {
+                return null;
+            }
+            const window = getWindow(this._domNode.domNode);
+            let width;
+            if (this._cursorStyle === TextEditorCursorStyle.Line) {
+                width = computeScreenAwareSize(window, this._lineCursorWidth > 0 ? this._lineCursorWidth : 2);
+                if (width > 2) {
+                    textContent = nextGrapheme;
+                    textContentClassName = this._getTokenClassName(position);
+                }
+            }
+            else {
+                width = computeScreenAwareSize(window, 1);
+            }
+            let left = visibleRange.left;
+            let paddingLeft = 0;
+            if (width >= 2 && left >= 1) {
+                paddingLeft = 1;
+                left -= paddingLeft;
+            }
+            const top = ctx.getVerticalOffsetForLineNumber(position.lineNumber) - ctx.bigNumbersDelta;
+            return ( new ViewCursorRenderData(
+                top,
+                left,
+                paddingLeft,
+                width,
+                this._lineHeight,
+                textContent,
+                textContentClassName
+            ));
+        }
+        const visibleRangeForCharacter = ctx.linesVisibleRangesForRange(( new Range(
+            position.lineNumber,
+            position.column,
+            position.lineNumber,
+            position.column + nextGrapheme.length
+        )), false);
+        if (!visibleRangeForCharacter || visibleRangeForCharacter.length === 0) {
+            return null;
+        }
+        const firstVisibleRangeForCharacter = visibleRangeForCharacter[0];
+        if (firstVisibleRangeForCharacter.outsideRenderedLine || firstVisibleRangeForCharacter.ranges.length === 0) {
+            return null;
+        }
+        const range = firstVisibleRangeForCharacter.ranges[0];
+        const width = (nextGrapheme === '\t'
+            ? this._typicalHalfwidthCharacterWidth
+            : (range.width < 1
+                ? this._typicalHalfwidthCharacterWidth
+                : range.width));
+        if (this._cursorStyle === TextEditorCursorStyle.Block) {
+            textContent = nextGrapheme;
+            textContentClassName = this._getTokenClassName(position);
+        }
+        let top = ctx.getVerticalOffsetForLineNumber(position.lineNumber) - ctx.bigNumbersDelta;
+        let height = this._lineHeight;
+        if (this._cursorStyle === TextEditorCursorStyle.Underline || this._cursorStyle === TextEditorCursorStyle.UnderlineThin) {
+            top += this._lineHeight - 2;
+            height = 2;
+        }
+        return ( new ViewCursorRenderData(top, range.left, 0, width, height, textContent, textContentClassName));
+    }
+    _getTokenClassName(position) {
+        const lineData = this._context.viewModel.getViewLineData(position.lineNumber);
+        const tokenIndex = lineData.tokens.findTokenIndexAtOffset(position.column - 1);
+        return lineData.tokens.getClassName(tokenIndex);
+    }
+    prepareRender(ctx) {
+        this._renderData = this._prepareRender(ctx);
+    }
+    render(ctx) {
+        if (!this._renderData) {
+            this._domNode.setDisplay('none');
+            return null;
+        }
+        if (this._lastRenderedContent !== this._renderData.textContent) {
+            this._lastRenderedContent = this._renderData.textContent;
+            this._domNode.domNode.textContent = this._lastRenderedContent;
+        }
+        this._domNode.setClassName(`cursor ${MOUSE_CURSOR_TEXT_CSS_CLASS_NAME} ${this._renderData.textContentClassName}`);
+        this._domNode.setDisplay('block');
+        this._domNode.setTop(this._renderData.top);
+        this._domNode.setLeft(this._renderData.left);
+        this._domNode.setPaddingLeft(this._renderData.paddingLeft);
+        this._domNode.setWidth(this._renderData.width);
+        this._domNode.setLineHeight(this._renderData.height);
+        this._domNode.setHeight(this._renderData.height);
+        return {
+            domNode: this._domNode.domNode,
+            position: this._position,
+            contentLeft: this._renderData.left,
+            height: this._renderData.height,
+            width: 2
+        };
+    }
+}
+export { ViewCursor };

package/vscode/src/vs/editor/browser/viewParts/viewCursors/viewCursors.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-editor .cursors-layer{position:absolute;top:0}.monaco-editor .cursors-layer>.cursor{box-sizing:border-box;overflow:hidden;position:absolute}.monaco-editor .cursors-layer.cursor-smooth-caret-animation>.cursor{transition:all 80ms}.monaco-editor .cursors-layer.cursor-block-outline-style>.cursor{background:transparent!important;border-style:solid;border-width:1px}.monaco-editor .cursors-layer.cursor-underline-style>.cursor{background:transparent!important;border-bottom-style:solid;border-bottom-width:2px}.monaco-editor .cursors-layer.cursor-underline-thin-style>.cursor{background:transparent!important;border-bottom-style:solid;border-bottom-width:1px}@keyframes monaco-cursor-smooth{0%,20%{opacity:1}60%,to{opacity:0}}@keyframes monaco-cursor-phase{0%,20%{opacity:1}90%,to{opacity:0}}@keyframes monaco-cursor-expand{0%,20%{transform:scaleY(1)}80%,to{transform:scaleY(0)}}.cursor-smooth{animation:monaco-cursor-smooth .5s ease-in-out 0s 20 alternate}.cursor-phase{animation:monaco-cursor-phase .5s ease-in-out 0s 20 alternate}.cursor-expand>.cursor{animation:monaco-cursor-expand .5s ease-in-out 0s 20 alternate}";
+n(css,{});
+export { css, css as default };