@codingame/monaco-vscode-api 6.0.3 → 7.0.1

package/vscode/src/vs/editor/contrib/inlineEdits/browser/inlineEditsWidget.js

@@ -0,0 +1,322 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { h, svgElem } from '../../../../base/browser/dom.js';
+import { DEFAULT_FONT_FAMILY } from '../../../../base/browser/fonts.js';
+import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import '../../../../base/common/arrays.js';
+import { derived, derivedWithSetter } from '../../../../base/common/observableInternal/derived.js';
+import { autorun } from '../../../../base/common/observableInternal/autorun.js';
+import { constObservable } from '../../../../base/common/observableInternal/utils.js';
+import '../../../../base/common/cancellation.js';
+import './inlineEditsWidget.css.js';
+import { EditorExtensionsRegistry } from '../../../browser/editorExtensions.js';
+import { observableCodeEditor } from '../../../browser/observableCodeEditor.js';
+import { EmbeddedCodeEditorWidget } from '../../../browser/widget/codeEditor/embeddedCodeEditorWidget.js';
+import { diffLineDeleteDecorationBackgroundWithIndicator, diffLineAddDecorationBackgroundWithIndicator, diffWholeLineDeleteDecoration, diffWholeLineAddDecoration, diffDeleteDecorationEmpty, diffDeleteDecoration, diffAddDecorationEmpty, diffAddDecoration } from '../../../browser/widget/diffEditor/registrations.contribution.js';
+import { applyStyle, appendRemoveOnDispose } from '../../../browser/widget/diffEditor/utils.js';
+import { EditorOption } from '../../../common/config/editorOptions.js';
+import { PLAINTEXT_LANGUAGE_ID } from '../../../common/languages/modesRegistry.js';
+import { TextModel } from '../../../common/model/textModel.js';
+import { ContextMenuController } from '../../contextmenu/browser/contextmenu.js';
+import { PlaceholderTextContribution } from '../../placeholderText/browser/placeholderText.contribution.js';
+import { SuggestController } from '../../suggest/browser/suggestController.js';
+import { MenuWorkbenchToolBar } from '../../../../platform/actions/browser/toolbar.js';
+import { MenuId } from '../../../../platform/actions/common/actions.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+class InlineEdit {
+    constructor(range, newLines, changes) {
+        this.range = range;
+        this.newLines = newLines;
+        this.changes = changes;
+    }
+}
+let InlineEditsWidget = class InlineEditsWidget extends Disposable {
+    constructor(_editor, _edit, _userPrompt, _instantiationService) {
+        super();
+        this._editor = _editor;
+        this._edit = _edit;
+        this._userPrompt = _userPrompt;
+        this._instantiationService = _instantiationService;
+        this._editorObs = observableCodeEditor(this._editor);
+        this._elements = h('div.inline-edits-widget', {
+            style: {
+                position: 'absolute',
+                overflow: 'visible',
+                top: '0px',
+                left: '0px',
+            },
+        }, [
+            h('div@editorContainer', { style: { position: 'absolute', top: '0px', left: '0px', width: '500px', height: '500px', } }, [
+                h('div.toolbar@toolbar', { style: { position: 'absolute', top: '-25px', left: '0px' } }),
+                h('div.promptEditor@promptEditor', { style: { position: 'absolute', top: '-25px', left: '80px', width: '300px', height: '22px' } }),
+                h('div.preview@editor', { style: { position: 'absolute', top: '0px', left: '0px' } }),
+            ]),
+            svgElem('svg', { style: { overflow: 'visible', pointerEvents: 'none' }, }, [
+                svgElem('defs', [
+                    svgElem('linearGradient', {
+                        id: 'Gradient2',
+                        x1: '0',
+                        y1: '0',
+                        x2: '1',
+                        y2: '0',
+                    }, [
+                        svgElem('stop', { offset: '0%', class: 'gradient-stop', }),
+                        svgElem('stop', { offset: '100%', class: 'gradient-stop', }),
+                    ]),
+                ]),
+                svgElem('path@path', {
+                    d: '',
+                    fill: 'url(#Gradient2)',
+                }),
+            ]),
+        ]);
+        this._toolbar = this._register(this._instantiationService.createInstance(MenuWorkbenchToolBar, this._elements.toolbar, MenuId.InlineEditsActions, {
+            toolbarOptions: {
+                primaryGroup: g => g.startsWith('primary'),
+            },
+        }));
+        this._previewTextModel = this._register(this._instantiationService.createInstance(TextModel, '', PLAINTEXT_LANGUAGE_ID, TextModel.DEFAULT_CREATION_OPTIONS, null));
+        this._setText = derived(reader => {
+            const edit = this._edit.read(reader);
+            if (!edit) {
+                return;
+            }
+            this._previewTextModel.setValue(edit.newLines.join('\n'));
+        }).recomputeInitiallyAndOnChange(this._store);
+        this._promptTextModel = this._register(this._instantiationService.createInstance(TextModel, '', PLAINTEXT_LANGUAGE_ID, TextModel.DEFAULT_CREATION_OPTIONS, null));
+        this._promptEditor = this._register(this._instantiationService.createInstance(EmbeddedCodeEditorWidget, this._elements.promptEditor, {
+            glyphMargin: false,
+            lineNumbers: 'off',
+            minimap: { enabled: false },
+            guides: {
+                indentation: false,
+                bracketPairs: false,
+                bracketPairsHorizontal: false,
+                highlightActiveIndentation: false,
+            },
+            folding: false,
+            selectOnLineNumbers: false,
+            selectionHighlight: false,
+            columnSelection: false,
+            overviewRulerBorder: false,
+            overviewRulerLanes: 0,
+            lineDecorationsWidth: 0,
+            lineNumbersMinChars: 0,
+            placeholder: 'Describe the change you want...',
+            fontFamily: DEFAULT_FONT_FAMILY,
+        }, {
+            contributions: EditorExtensionsRegistry.getSomeEditorContributions([
+                SuggestController.ID,
+                PlaceholderTextContribution.ID,
+                ContextMenuController.ID,
+            ]),
+            isSimpleWidget: true
+        }, this._editor));
+        this._previewEditor = this._register(this._instantiationService.createInstance(EmbeddedCodeEditorWidget, this._elements.editor, {
+            glyphMargin: false,
+            lineNumbers: 'off',
+            minimap: { enabled: false },
+            guides: {
+                indentation: false,
+                bracketPairs: false,
+                bracketPairsHorizontal: false,
+                highlightActiveIndentation: false,
+            },
+            folding: false,
+            selectOnLineNumbers: false,
+            selectionHighlight: false,
+            columnSelection: false,
+            overviewRulerBorder: false,
+            overviewRulerLanes: 0,
+            lineDecorationsWidth: 0,
+            lineNumbersMinChars: 0,
+        }, { contributions: [], }, this._editor));
+        this._previewEditorObs = observableCodeEditor(this._previewEditor);
+        this._decorations = derived(this, (reader) => {
+            this._setText.read(reader);
+            const diff = this._edit.read(reader)?.changes;
+            if (!diff) {
+                return [];
+            }
+            const originalDecorations = [];
+            const modifiedDecorations = [];
+            if (diff.length === 1 && diff[0].innerChanges[0].modifiedRange.equalsRange(this._previewTextModel.getFullModelRange())) {
+                return [];
+            }
+            for (const m of diff) {
+                if (!m.original.isEmpty) {
+                    originalDecorations.push({ range: m.original.toInclusiveRange(), options: diffLineDeleteDecorationBackgroundWithIndicator });
+                }
+                if (!m.modified.isEmpty) {
+                    modifiedDecorations.push({ range: m.modified.toInclusiveRange(), options: diffLineAddDecorationBackgroundWithIndicator });
+                }
+                if (m.modified.isEmpty || m.original.isEmpty) {
+                    if (!m.original.isEmpty) {
+                        originalDecorations.push({ range: m.original.toInclusiveRange(), options: diffWholeLineDeleteDecoration });
+                    }
+                    if (!m.modified.isEmpty) {
+                        modifiedDecorations.push({ range: m.modified.toInclusiveRange(), options: diffWholeLineAddDecoration });
+                    }
+                }
+                else {
+                    for (const i of m.innerChanges || []) {
+                        if (m.original.contains(i.originalRange.startLineNumber)) {
+                            originalDecorations.push({ range: i.originalRange, options: i.originalRange.isEmpty() ? diffDeleteDecorationEmpty : diffDeleteDecoration });
+                        }
+                        if (m.modified.contains(i.modifiedRange.startLineNumber)) {
+                            modifiedDecorations.push({ range: i.modifiedRange, options: i.modifiedRange.isEmpty() ? diffAddDecorationEmpty : diffAddDecoration });
+                        }
+                    }
+                }
+            }
+            return modifiedDecorations;
+        });
+        this._layout1 = derived(this, reader => {
+            const model = this._editor.getModel();
+            const inlineEdit = this._edit.read(reader);
+            if (!inlineEdit) {
+                return null;
+            }
+            const range = inlineEdit.range;
+            let maxLeft = 0;
+            for (let i = range.startLineNumber; i < range.endLineNumberExclusive; i++) {
+                const column = model.getLineMaxColumn(i);
+                const left = this._editor.getOffsetForColumn(i, column);
+                maxLeft = Math.max(maxLeft, left);
+            }
+            const layoutInfo = this._editor.getLayoutInfo();
+            const contentLeft = layoutInfo.contentLeft;
+            return { left: contentLeft + maxLeft };
+        });
+        this._layout = derived(this, (reader) => {
+            const inlineEdit = this._edit.read(reader);
+            if (!inlineEdit) {
+                return null;
+            }
+            const range = inlineEdit.range;
+            const scrollLeft = this._editorObs.scrollLeft.read(reader);
+            const left = this._layout1.read(reader).left + 20 - scrollLeft;
+            const selectionTop = this._editor.getTopForLineNumber(range.startLineNumber) - this._editorObs.scrollTop.read(reader);
+            const selectionBottom = this._editor.getTopForLineNumber(range.endLineNumberExclusive) - this._editorObs.scrollTop.read(reader);
+            const topCode = ( new Point(left, selectionTop));
+            const bottomCode = ( new Point(left, selectionBottom));
+            const codeHeight = selectionBottom - selectionTop;
+            const codeEditDist = 50;
+            const editHeight = this._editor.getOption(EditorOption.lineHeight) * inlineEdit.newLines.length;
+            const difference = codeHeight - editHeight;
+            const topEdit = ( new Point(left + codeEditDist, selectionTop + (difference / 2)));
+            const bottomEdit = ( new Point(left + codeEditDist, selectionBottom - (difference / 2)));
+            return {
+                topCode,
+                bottomCode,
+                codeHeight,
+                topEdit,
+                bottomEdit,
+                editHeight,
+            };
+        });
+        const visible = derived(this, reader => this._edit.read(reader) !== undefined || this._userPrompt.read(reader) !== undefined);
+        this._register(applyStyle(this._elements.root, {
+            display: derived(this, reader => visible.read(reader) ? 'block' : 'none')
+        }));
+        this._register(appendRemoveOnDispose(this._editor.getDomNode(), this._elements.root));
+        this._register(observableCodeEditor(_editor).createOverlayWidget({
+            domNode: this._elements.root,
+            position: constObservable(null),
+            allowEditorOverflow: false,
+            minContentWidthInPx: derived(reader => {
+                const x = this._layout1.read(reader)?.left;
+                if (x === undefined) {
+                    return 0;
+                }
+                const width = this._previewEditorObs.contentWidth.read(reader);
+                return x + width;
+            }),
+        }));
+        this._previewEditor.setModel(this._previewTextModel);
+        this._register(this._previewEditorObs.setDecorations(this._decorations));
+        this._register(autorun(reader => {
+            const layoutInfo = this._layout.read(reader);
+            if (!layoutInfo) {
+                return;
+            }
+            const { topCode, bottomCode, topEdit, bottomEdit, editHeight } = layoutInfo;
+            const straightWidthCode = 10;
+            const straightWidthEdit = 0;
+            const bezierDist = 40;
+            const path = ( new PathBuilder())
+                .moveTo(topCode)
+                .lineTo(topCode.deltaX(straightWidthCode))
+                .curveTo(topCode.deltaX(straightWidthCode + bezierDist), topEdit.deltaX(-bezierDist - straightWidthEdit), topEdit.deltaX(-straightWidthEdit))
+                .lineTo(topEdit)
+                .lineTo(bottomEdit)
+                .lineTo(bottomEdit.deltaX(-straightWidthEdit))
+                .curveTo(bottomEdit.deltaX(-bezierDist - straightWidthEdit), bottomCode.deltaX(straightWidthCode + bezierDist), bottomCode.deltaX(straightWidthCode))
+                .lineTo(bottomCode)
+                .build();
+            this._elements.path.setAttribute('d', path);
+            this._elements.editorContainer.style.top = `${topEdit.y}px`;
+            this._elements.editorContainer.style.left = `${topEdit.x}px`;
+            this._elements.editorContainer.style.height = `${editHeight}px`;
+            const width = this._previewEditorObs.contentWidth.read(reader);
+            this._previewEditor.layout({ height: editHeight, width });
+        }));
+        this._promptEditor.setModel(this._promptTextModel);
+        this._promptEditor.layout();
+        this._register(createTwoWaySync(mapSettableObservable(this._userPrompt, v => v ?? '', v => v), observableCodeEditor(this._promptEditor).value));
+        this._register(autorun(reader => {
+            const isFocused = observableCodeEditor(this._promptEditor).isFocused.read(reader);
+            this._elements.root.classList.toggle('focused', isFocused);
+        }));
+    }
+};
+InlineEditsWidget = ( __decorate([
+    ( __param(3, IInstantiationService))
+], InlineEditsWidget));
+function mapSettableObservable(obs, fn1, fn2) {
+    return derivedWithSetter(undefined, reader => fn1(obs.read(reader)), (value, tx) => obs.set(fn2(value), tx));
+}
+class Point {
+    constructor(x, y) {
+        this.x = x;
+        this.y = y;
+    }
+    add(other) {
+        return ( new Point(this.x + other.x, this.y + other.y));
+    }
+    deltaX(delta) {
+        return ( new Point(this.x + delta, this.y));
+    }
+}
+class PathBuilder {
+    constructor() {
+        this._data = '';
+    }
+    moveTo(point) {
+        this._data += `M ${point.x} ${point.y} `;
+        return this;
+    }
+    lineTo(point) {
+        this._data += `L ${point.x} ${point.y} `;
+        return this;
+    }
+    curveTo(cp1, cp2, to) {
+        this._data += `C ${cp1.x} ${cp1.y} ${cp2.x} ${cp2.y} ${to.x} ${to.y} `;
+        return this;
+    }
+    build() {
+        return this._data;
+    }
+}
+function createTwoWaySync(main, target) {
+    const store = ( new DisposableStore());
+    store.add(autorun(reader => {
+        const value = main.read(reader);
+        target.set(value, undefined);
+    }));
+    store.add(autorun(reader => {
+        const value = target.read(reader);
+        main.set(value, undefined);
+    }));
+    return store;
+}
+export { InlineEdit, InlineEditsWidget };

package/vscode/src/vs/editor/contrib/inlineProgress/browser/inlineProgress.js

@@ -83,11 +83,15 @@ let InlineProgressManager = class InlineProgressManager extends Disposable {
         this._instantiationService = _instantiationService;
         this._showDelay = 500;
         this._showPromise = this._register(( new MutableDisposable()));
-        this._currentWidget = ( new MutableDisposable());
+        this._currentWidget = this._register(( new MutableDisposable()));
         this._operationIdPool = 0;
         this._currentDecorations = _editor.createDecorationsCollection();
     }
-    async showWhile(position, title, promise) {
+    dispose() {
+        super.dispose();
+        this._currentDecorations.clear();
+    }
+    async showWhile(position, title, promise, delegate, delayOverride) {
         const operationId = this._operationIdPool++;
         this._currentOperation = operationId;
         this.clear();
@@ -98,9 +102,9 @@ let InlineProgressManager = class InlineProgressManager extends Disposable {
                     options: inlineProgressDecoration,
                 }]);
             if (decorationIds.length > 0) {
-                this._currentWidget.value = this._instantiationService.createInstance(InlineProgressWidget, this.id, this._editor, range, title, promise);
+                this._currentWidget.value = this._instantiationService.createInstance(InlineProgressWidget, this.id, this._editor, range, title, delegate);
             }
-        }, this._showDelay);
+        }, delayOverride ?? this._showDelay);
         try {
             return await promise;
         }

package/vscode/src/vs/editor/contrib/linesOperations/browser/linesOperations.js

@@ -5,6 +5,7 @@ import { ReplaceCommandThatSelectsText, ReplaceCommand, ReplaceCommandThatPreser
 import { TrimTrailingWhitespaceCommand } from '../../../common/commands/trimTrailingWhitespaceCommand.js';
 import { EditorOption } from '../../../common/config/editorOptions.js';
 import { TypeOperations } from '../../../common/cursor/cursorTypeOperations.js';
+import { EnterOperation } from '../../../common/cursor/cursorTypeEditOperations.js';
 import { EditOperation } from '../../../common/core/editOperation.js';
 import { Position } from '../../../common/core/position.js';
 import { Range } from '../../../common/core/range.js';
@@ -490,7 +491,7 @@ class InsertLineBeforeAction extends EditorAction {
             return;
         }
         editor.pushUndoStop();
-        editor.executeCommands(this.id, TypeOperations.lineInsertBefore(viewModel.cursorConfig, editor.getModel(), editor.getSelections()));
+        editor.executeCommands(this.id, EnterOperation.lineInsertBefore(viewModel.cursorConfig, editor.getModel(), editor.getSelections()));
     }
 }
 class InsertLineAfterAction extends EditorAction {
@@ -513,7 +514,7 @@ class InsertLineAfterAction extends EditorAction {
             return;
         }
         editor.pushUndoStop();
-        editor.executeCommands(this.id, TypeOperations.lineInsertAfter(viewModel.cursorConfig, editor.getModel(), editor.getSelections()));
+        editor.executeCommands(this.id, EnterOperation.lineInsertAfter(viewModel.cursorConfig, editor.getModel(), editor.getSelections()));
     }
 }
 class AbstractDeleteAllToBoundaryAction extends EditorAction {

package/vscode/src/vs/editor/contrib/parameterHints/browser/parameterHintsWidget.js

@@ -311,5 +311,5 @@ ParameterHintsWidget = ParameterHintsWidget_1 = ( (__decorate([
     ( (__param(4, ILanguageService))),
     ( (__param(5, ITelemetryService)))
 ], ParameterHintsWidget)));
-registerColor('editorHoverWidget.highlightForeground', { dark: listHighlightForeground, light: listHighlightForeground, hcDark: listHighlightForeground, hcLight: listHighlightForeground }, ( localizeWithPath(_moduleId, 3, 'Foreground color of the active item in the parameter hint.')));
+registerColor('editorHoverWidget.highlightForeground', listHighlightForeground, ( localizeWithPath(_moduleId, 3, 'Foreground color of the active item in the parameter hint.')));
 export { ParameterHintsWidget };

package/vscode/src/vs/editor/contrib/peekView/browser/peekView.js

@@ -243,8 +243,8 @@ registerColor('peekViewResult.selectionForeground', { dark: Color.white, light:
     'Foreground color of the selected entry in the peek view result list.'
 )));
 const peekViewEditorBackground = registerColor('peekViewEditor.background', { dark: '#001F33', light: '#F2F8FC', hcDark: Color.black, hcLight: Color.white }, ( localizeWithPath(_moduleId, 11, 'Background color of the peek view editor.')));
-registerColor('peekViewEditorGutter.background', { dark: peekViewEditorBackground, light: peekViewEditorBackground, hcDark: peekViewEditorBackground, hcLight: peekViewEditorBackground }, ( localizeWithPath(_moduleId, 12, 'Background color of the gutter in the peek view editor.')));
-registerColor('peekViewEditorStickyScroll.background', { dark: peekViewEditorBackground, light: peekViewEditorBackground, hcDark: peekViewEditorBackground, hcLight: peekViewEditorBackground }, ( localizeWithPath(
+registerColor('peekViewEditorGutter.background', peekViewEditorBackground, ( localizeWithPath(_moduleId, 12, 'Background color of the gutter in the peek view editor.')));
+registerColor('peekViewEditorStickyScroll.background', peekViewEditorBackground, ( localizeWithPath(
     _moduleId,
     13,
     'Background color of sticky scroll in the peek view editor.'

package/vscode/src/vs/editor/contrib/placeholderText/browser/placeholderText.contribution.js

@@ -0,0 +1,60 @@
+import { structuralEquals } from '../../../../base/common/equals.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { derivedOpts, derived } from '../../../../base/common/observableInternal/derived.js';
+import '../../../../base/common/observableInternal/autorun.js';
+import '../../../../base/common/observableInternal/utils.js';
+import '../../../../base/common/cancellation.js';
+import './placeholderText.css.js';
+import { registerEditorContribution, EditorContributionInstantiation } from '../../../browser/editorExtensions.js';
+import { observableCodeEditor } from '../../../browser/observableCodeEditor.js';
+import { EditorOption } from '../../../common/config/editorOptions.js';
+import { ghostTextForeground } from '../../../common/core/editorColorRegistry.js';
+import { Range } from '../../../common/core/range.js';
+import { InjectedTextCursorStops } from '../../../common/model.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { registerColor } from '../../../../platform/theme/common/colorUtils.js';
+const _moduleId = "vs/editor/contrib/placeholderText/browser/placeholderText.contribution";
+class PlaceholderTextContribution extends Disposable {
+    static get(editor) {
+        return editor.getContribution(PlaceholderTextContribution.ID);
+    }
+    static { this.ID = 'editor.contrib.placeholderText'; }
+    constructor(_editor) {
+        super();
+        this._editor = _editor;
+        this._editorObs = observableCodeEditor(this._editor);
+        this._placeholderText = this._editorObs.getOption(EditorOption.placeholder);
+        this._decorationOptions = derivedOpts({ owner: this, equalsFn: structuralEquals }, reader => {
+            const p = this._placeholderText.read(reader);
+            if (!p) {
+                return undefined;
+            }
+            if (!this._editorObs.valueIsEmpty.read(reader)) {
+                return undefined;
+            }
+            return { placeholder: p };
+        });
+        this._decorations = derived(this, (reader) => {
+            const options = this._decorationOptions.read(reader);
+            if (!options) {
+                return [];
+            }
+            return [{
+                    range: ( (new Range(1, 1, 1, 1))),
+                    options: {
+                        description: 'placeholder',
+                        showIfCollapsed: true,
+                        after: {
+                            content: options.placeholder,
+                            cursorStops: InjectedTextCursorStops.None,
+                            inlineClassName: 'placeholder-text'
+                        }
+                    }
+                }];
+        });
+        this._register(this._editorObs.setDecorations(this._decorations));
+    }
+}
+registerEditorContribution(PlaceholderTextContribution.ID, PlaceholderTextContribution, EditorContributionInstantiation.Eager);
+registerColor('editor.placeholder.foreground', { dark: ghostTextForeground, light: ghostTextForeground, hcDark: ghostTextForeground, hcLight: ghostTextForeground }, ( localizeWithPath(_moduleId, 0, 'Foreground color of the placeholder text in the editor.')));
+export { PlaceholderTextContribution };

package/vscode/src/vs/editor/contrib/placeholderText/browser/placeholderText.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-editor{--vscode-editor-placeholder-foreground:var(--vscode-editorGhostText-foreground)}.monaco-editor .placeholder-text{color:var(--vscode-editor-placeholder-foreground)}";
+n(css,{});
+export { css, css as default };

package/vscode/src/vs/editor/contrib/rename/browser/renameWidget.js

@@ -613,7 +613,7 @@ class InputWithButton {
             this._buttonNode.setAttribute('tabindex', '0');
             this._buttonGenHoverText = ( localizeWithPath(_moduleId, 5, "Generate new name suggestions"));
             this._buttonCancelHoverText = ( localizeWithPath(_moduleId, 6, "Cancel"));
-            this._buttonHover = getBaseLayerHoverDelegate().setupUpdatableHover(getDefaultHoverDelegate('element'), this._buttonNode, this._buttonGenHoverText);
+            this._buttonHover = getBaseLayerHoverDelegate().setupManagedHover(getDefaultHoverDelegate('element'), this._buttonNode, this._buttonGenHoverText);
             this._disposables.add(this._buttonHover);
             this._domNode.appendChild(this._buttonNode);
             this._disposables.add(addDisposableListener(this.input, EventType.INPUT, () => this._onDidInputChange.fire()));

package/vscode/src/vs/editor/contrib/stickyScroll/browser/stickyScroll.css.js

@@ -1,4 +1,4 @@
 import n from '../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
-var css = ".monaco-editor .sticky-widget{overflow:hidden}.monaco-editor .sticky-widget-line-numbers{background-color:inherit;float:left}.monaco-editor .sticky-widget-lines-scrollable{background-color:inherit;display:inline-block;overflow:hidden;position:absolute;width:var(--vscode-editorStickyScroll-scrollableWidth)}.monaco-editor .sticky-widget-lines{background-color:inherit;position:absolute}.monaco-editor .sticky-line-content,.monaco-editor .sticky-line-number{background-color:inherit;color:var(--vscode-editorLineNumber-foreground);display:inline-block;position:absolute;white-space:nowrap}.monaco-editor .sticky-line-number .codicon-folding-collapsed,.monaco-editor .sticky-line-number .codicon-folding-expanded{float:right;transition:var(--vscode-editorStickyScroll-foldingOpacityTransition)}.monaco-editor .sticky-line-content{background-color:inherit;white-space:nowrap;width:var(--vscode-editorStickyScroll-scrollableWidth)}.monaco-editor .sticky-line-number-inner{display:inline-block;text-align:right}.monaco-editor .sticky-widget{border-bottom:1px solid var(--vscode-editorStickyScroll-border)}.monaco-editor .sticky-line-content:hover{background-color:var(--vscode-editorStickyScrollHover-background);cursor:pointer}.monaco-editor .sticky-widget{background-color:var(--vscode-editorStickyScroll-background);box-shadow:var(--vscode-editorStickyScroll-shadow) 0 3px 2px -2px;right:auto!important;width:100%;z-index:4}.monaco-editor .sticky-widget.peek{background-color:var(--vscode-peekViewEditorStickyScroll-background)}";
+var css = ".monaco-editor .sticky-widget{overflow:hidden}.monaco-editor .sticky-widget-line-numbers{background-color:inherit;float:left}.monaco-editor .sticky-widget-lines-scrollable{background-color:inherit;display:inline-block;overflow:hidden;position:absolute;width:var(--vscode-editorStickyScroll-scrollableWidth)}.monaco-editor .sticky-widget-lines{background-color:inherit;position:absolute}.monaco-editor .sticky-line-content,.monaco-editor .sticky-line-number{background-color:inherit;color:var(--vscode-editorLineNumber-foreground);display:inline-block;position:absolute;white-space:nowrap}.monaco-editor .sticky-line-number .codicon-folding-collapsed,.monaco-editor .sticky-line-number .codicon-folding-expanded{float:right;transition:var(--vscode-editorStickyScroll-foldingOpacityTransition)}.monaco-editor .sticky-line-content{background-color:inherit;white-space:nowrap;width:var(--vscode-editorStickyScroll-scrollableWidth)}.monaco-editor .sticky-line-number-inner{display:inline-block;text-align:right}.monaco-editor .sticky-widget{border-bottom:1px solid var(--vscode-editorStickyScroll-border)}.monaco-editor .sticky-line-content:hover{background-color:var(--vscode-editorStickyScrollHover-background);cursor:pointer}.monaco-editor .sticky-widget{background-color:var(--vscode-editorStickyScroll-background);box-shadow:var(--vscode-editorStickyScroll-shadow) 0 4px 2px -2px;right:auto!important;width:100%;z-index:4}.monaco-editor .sticky-widget.peek{background-color:var(--vscode-peekViewEditorStickyScroll-background)}";
 n(css,{});
 export { css, css as default };

package/vscode/src/vs/editor/contrib/stickyScroll/browser/stickyScrollController.js

@@ -36,7 +36,6 @@ let StickyScrollController = class StickyScrollController extends Disposable {
         this._instaService = _instaService;
         this._contextKeyService = _contextKeyService;
         this._sessionStore = ( new DisposableStore());
-        this._foldingModel = null;
         this._maxStickyLines = Number.MAX_SAFE_INTEGER;
         this._candidateDefinitionsLength = -1;
         this._focusedStickyElementIndex = -1;
@@ -45,12 +44,11 @@ let StickyScrollController = class StickyScrollController extends Disposable {
         this._positionRevealed = false;
         this._onMouseDown = false;
         this._endLineNumbers = [];
-        this._showEndForLine = null;
         this._stickyScrollWidget = ( new StickyScrollWidget(this._editor));
         this._stickyLineCandidateProvider = ( new StickyLineCandidateProvider(this._editor, _languageFeaturesService, _languageConfigurationService));
         this._register(this._stickyScrollWidget);
         this._register(this._stickyLineCandidateProvider);
-        this._widgetState = ( new StickyScrollWidgetState([], [], 0));
+        this._widgetState = StickyScrollWidgetState.Empty;
         this._onDidResize();
         this._readConfiguration();
         const stickyScrollDomNode = this._stickyScrollWidget.getDomNode();
@@ -229,14 +227,14 @@ let StickyScrollController = class StickyScrollController extends Disposable {
                 this._renderStickyScroll();
                 return;
             }
-            if (this._showEndForLine !== null) {
-                this._showEndForLine = null;
+            if (this._showEndForLine !== undefined) {
+                this._showEndForLine = undefined;
                 this._renderStickyScroll();
             }
         }));
         this._register(addDisposableListener(stickyScrollWidgetDomNode, EventType.MOUSE_LEAVE, (e) => {
-            if (this._showEndForLine !== null) {
-                this._showEndForLine = null;
+            if (this._showEndForLine !== undefined) {
+                this._showEndForLine = undefined;
                 this._renderStickyScroll();
             }
         }));
@@ -345,14 +343,14 @@ let StickyScrollController = class StickyScrollController extends Disposable {
             this._editor.addOverlayWidget(this._stickyScrollWidget);
             this._sessionStore.add(this._editor.onDidScrollChange((e) => {
                 if (e.scrollTopChanged) {
-                    this._showEndForLine = null;
+                    this._showEndForLine = undefined;
                     this._renderStickyScroll();
                 }
             }));
             this._sessionStore.add(this._editor.onDidLayoutChange(() => this._onDidResize()));
             this._sessionStore.add(this._editor.onDidChangeModelTokens((e) => this._onTokensChange(e)));
             this._sessionStore.add(this._stickyLineCandidateProvider.onDidChangeStickyScroll(() => {
-                this._showEndForLine = null;
+                this._showEndForLine = undefined;
                 this._renderStickyScroll();
             }));
             this._enabled = true;
@@ -360,7 +358,7 @@ let StickyScrollController = class StickyScrollController extends Disposable {
         const lineNumberOption = this._editor.getOption(EditorOption.lineNumbers);
         if (lineNumberOption.renderType === RenderLineNumbersType.Relative) {
             this._sessionStore.add(this._editor.onDidChangeCursorPosition(() => {
-                this._showEndForLine = null;
+                this._showEndForLine = undefined;
                 this._renderStickyScroll(0);
             }));
         }
@@ -401,21 +399,19 @@ let StickyScrollController = class StickyScrollController extends Disposable {
     async _renderStickyScroll(rebuildFromLine) {
         const model = this._editor.getModel();
         if (!model || model.isTooLargeForTokenization()) {
-            this._foldingModel = null;
-            this._stickyScrollWidget.setState(undefined, null);
+            this._resetState();
             return;
         }
-        const stickyLineVersion = this._stickyLineCandidateProvider.getVersionId();
-        if (stickyLineVersion === undefined || stickyLineVersion === model.getVersionId()) {
-            this._foldingModel = (await FoldingController.get(this._editor)?.getFoldingModel()) ?? null;
-            this._widgetState = this.findScrollWidgetState();
-            this._stickyScrollVisibleContextKey.set(!(this._widgetState.startLineNumbers.length === 0));
+        const nextRebuildFromLine = this._updateAndGetMinRebuildFromLine(rebuildFromLine);
+        const stickyWidgetVersion = this._stickyLineCandidateProvider.getVersionId();
+        const shouldUpdateState = stickyWidgetVersion === undefined || stickyWidgetVersion === model.getVersionId();
+        if (shouldUpdateState) {
             if (!this._focused) {
-                this._stickyScrollWidget.setState(this._widgetState, this._foldingModel, rebuildFromLine);
+                await this._updateState(nextRebuildFromLine);
             }
             else {
                 if (this._focusedStickyElementIndex === -1) {
-                    this._stickyScrollWidget.setState(this._widgetState, this._foldingModel, rebuildFromLine);
+                    await this._updateState(nextRebuildFromLine);
                     this._focusedStickyElementIndex = this._stickyScrollWidget.lineNumberCount - 1;
                     if (this._focusedStickyElementIndex !== -1) {
                         this._stickyScrollWidget.focusLineWithIndex(this._focusedStickyElementIndex);
@@ -423,7 +419,7 @@ let StickyScrollController = class StickyScrollController extends Disposable {
                 }
                 else {
                     const focusedStickyElementLineNumber = this._stickyScrollWidget.lineNumbers[this._focusedStickyElementIndex];
-                    this._stickyScrollWidget.setState(this._widgetState, this._foldingModel, rebuildFromLine);
+                    await this._updateState(nextRebuildFromLine);
                     if (this._stickyScrollWidget.lineNumberCount === 0) {
                         this._focusedStickyElementIndex = -1;
                     }
@@ -438,6 +434,28 @@ let StickyScrollController = class StickyScrollController extends Disposable {
             }
         }
     }
+    _updateAndGetMinRebuildFromLine(rebuildFromLine) {
+        if (rebuildFromLine !== undefined) {
+            const minRebuildFromLineOrInfinity = this._minRebuildFromLine !== undefined ? this._minRebuildFromLine : Infinity;
+            this._minRebuildFromLine = Math.min(rebuildFromLine, minRebuildFromLineOrInfinity);
+        }
+        return this._minRebuildFromLine;
+    }
+    async _updateState(rebuildFromLine) {
+        this._minRebuildFromLine = undefined;
+        this._foldingModel = (await FoldingController.get(this._editor)?.getFoldingModel()) ?? undefined;
+        this._widgetState = this.findScrollWidgetState();
+        const stickyWidgetHasLines = this._widgetState.startLineNumbers.length > 0;
+        this._stickyScrollVisibleContextKey.set(stickyWidgetHasLines);
+        this._stickyScrollWidget.setState(this._widgetState, this._foldingModel, rebuildFromLine);
+    }
+    async _resetState() {
+        this._minRebuildFromLine = undefined;
+        this._foldingModel = undefined;
+        this._widgetState = StickyScrollWidgetState.Empty;
+        this._stickyScrollVisibleContextKey.set(false);
+        this._stickyScrollWidget.setState(undefined, undefined);
+    }
     findScrollWidgetState() {
         const lineHeight = this._editor.getOption(EditorOption.lineHeight);
         const maxNumberStickyLines = Math.min(this._maxStickyLines, this._editor.getOption(EditorOption.stickyScroll).maxLineCount);

package/vscode/src/vs/editor/contrib/stickyScroll/browser/stickyScrollWidget.js

@@ -27,6 +27,9 @@ class StickyScrollWidgetState {
             && equals(this.startLineNumbers, other.startLineNumbers)
             && equals(this.endLineNumbers, other.endLineNumbers);
     }
+    static get Empty() {
+        return ( new StickyScrollWidgetState([], [], 0));
+    }
 }
 const _ttPolicy = createTrustedTypesPolicy('stickyScrollViewLayer', { createHTML: value => value });
 const STICKY_INDEX_ATTR = 'data-sticky-line-index';