@codingame/monaco-vscode-api 9.0.3 → 10.0.1

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/view/inlineEdits/inlineEditsView.js

@@ -0,0 +1,357 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { h } from '../../../../../../base/browser/dom.js';
+import { renderIcon } from '../../../../../../base/browser/ui/iconLabel/iconLabels.js';
+import { numberComparator } from '../../../../../../base/common/arrays.js';
+import { findFirstMin } from '../../../../../../base/common/arraysFind.js';
+import { Codicon } from '../../../../../../base/common/codicons.js';
+import { createHotClass } from '../../../../../../base/common/hotReloadHelpers.js';
+import { Disposable } from '../../../../../../base/common/lifecycle.js';
+import '../../../../../../base/common/event.js';
+import { autorun } from '../../../../../../base/common/observableInternal/autorun.js';
+import { derivedDisposable, derived } from '../../../../../../base/common/observableInternal/derived.js';
+import { ObservablePromise } from '../../../../../../base/common/observableInternal/promise.js';
+import { derivedWithCancellationToken } from '../../../../../../base/common/observableInternal/utilsCancellation.js';
+import { constObservable, observableFromEvent } from '../../../../../../base/common/observableInternal/utils.js';
+import { splitLines, getIndentationLength } from '../../../../../../base/common/strings.js';
+import { MenuWorkbenchToolBar } from '../../../../../../platform/actions/browser/toolbar.js';
+import { MenuId, MenuItemAction } from '../../../../../../platform/actions/common/actions.js';
+import { IInstantiationService } from '../../../../../../platform/instantiation/common/instantiation.js';
+import { observableCodeEditor } from '../../../../../browser/observableCodeEditor.js';
+import { EmbeddedCodeEditorWidget } from '../../../../../browser/widget/codeEditor/embeddedCodeEditorWidget.js';
+import { IDiffProviderFactoryService } from '../../../../../browser/widget/diffEditor/diffProviderFactoryService.js';
+import { diffWholeLineDeleteDecoration, diffWholeLineAddDecoration, diffDeleteDecorationEmpty, diffAddDecorationEmpty, diffAddDecoration } from '../../../../../browser/widget/diffEditor/registrations.contribution.js';
+import { applyStyle, appendRemoveOnDispose } from '../../../../../browser/widget/diffEditor/utils.js';
+import { LineRange } from '../../../../../common/core/lineRange.js';
+import { OffsetRange } from '../../../../../common/core/offsetRange.js';
+import { Position } from '../../../../../common/core/position.js';
+import { Range } from '../../../../../common/core/range.js';
+import { TextEdit, SingleTextEdit, ArrayText } from '../../../../../common/core/textEdit.js';
+import { TextLength } from '../../../../../common/core/textLength.js';
+import { RangeMapping, lineRangeMappingFromRangeMappings } from '../../../../../common/diff/rangeMapping.js';
+import { TextModel } from '../../../../../common/model/textModel.js';
+import { TextModelText } from '../../../../../common/model/textModelText.js';
+import { IModelService } from '../../../../../common/services/model.js';
+import './inlineEditsView.css.js';
+import { UniqueUriGenerator, StatusBarViewItem, maxLeftInRange, applyEditToModifiedRangeMappings, Point } from './utils.js';
+var InlineEditsViewAndDiffProducer_1;
+let InlineEditsViewAndDiffProducer = class InlineEditsViewAndDiffProducer extends Disposable {
+    static { InlineEditsViewAndDiffProducer_1 = this; }
+    static { this.hot = createHotClass(InlineEditsViewAndDiffProducer_1); }
+    constructor(_editor, _edit, _instantiationService, _diffProviderFactoryService, _modelService) {
+        super();
+        this._editor = _editor;
+        this._edit = _edit;
+        this._instantiationService = _instantiationService;
+        this._diffProviderFactoryService = _diffProviderFactoryService;
+        this._modelService = _modelService;
+        this._modelUriGenerator = ( new UniqueUriGenerator('inline-edits'));
+        this._originalModel = derivedDisposable(() => this._modelService.createModel('', null, this._modelUriGenerator.getUniqueUri())).keepObserved(this._store);
+        this._modifiedModel = derivedDisposable(() => this._modelService.createModel('', null, this._modelUriGenerator.getUniqueUri())).keepObserved(this._store);
+        this._inlineEditPromise = derivedWithCancellationToken(this, (reader, token) => {
+            const edit = this._edit.read(reader);
+            if (!edit) {
+                return undefined;
+            }
+            const range = edit.range;
+            if (edit.text.trim() === '') {
+                return undefined;
+            }
+            this._originalModel.get().setValue(this._editor.getModel().getValueInRange(range));
+            this._modifiedModel.get().setValue(edit.text);
+            const d = this._diffProviderFactoryService.createDiffProvider({ diffAlgorithm: 'advanced' });
+            return ObservablePromise.fromFn(async () => {
+                const result = await d.computeDiff(this._originalModel.get(), this._modifiedModel.get(), {
+                    computeMoves: false,
+                    ignoreTrimWhitespace: false,
+                    maxComputationTimeMs: 1000,
+                }, token);
+                if (result.identical) {
+                    return undefined;
+                }
+                const rangeStartPos = Range.lift(edit.range).getStartPosition();
+                const innerChanges = result.changes.flatMap(c => c.innerChanges);
+                function addRangeToPos(pos, range) {
+                    const start = TextLength.fromPosition(range.getStartPosition());
+                    return TextLength.ofRange(range).createRange(start.addToPosition(pos));
+                }
+                const edits = ( innerChanges.map(c => ( new SingleTextEdit(
+                    addRangeToPos(rangeStartPos, c.originalRange),
+                    this._modifiedModel.get().getValueInRange(c.modifiedRange)
+                ))));
+                return ( new InlineEditWithChanges(( new TextEdit(edits))));
+            });
+        });
+        this._inlineEdit = ( this._inlineEditPromise.map((p, reader) => p?.promiseResult?.read(reader)?.data));
+        this._register(( new InlineEditsView(this._editor, this._inlineEdit, this._instantiationService)));
+    }
+};
+InlineEditsViewAndDiffProducer = InlineEditsViewAndDiffProducer_1 = ( __decorate([
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IDiffProviderFactoryService)),
+    ( __param(4, IModelService))
+], InlineEditsViewAndDiffProducer));
+class InlineEditWithChanges {
+    constructor(diffedTextEdit) {
+        this.diffedTextEdit = diffedTextEdit;
+        this.originalLineRange = LineRange.fromRangeInclusive(RangeMapping.fromEditJoin(this.diffedTextEdit).originalRange);
+        this.modifiedLineRange = LineRange.fromRangeInclusive(RangeMapping.fromEditJoin(this.diffedTextEdit).modifiedRange);
+    }
+}
+let InlineEditsView = class InlineEditsView extends Disposable {
+    constructor(_editor, _edit, _instantiationService) {
+        super();
+        this._editor = _editor;
+        this._edit = _edit;
+        this._instantiationService = _instantiationService;
+        this._editorObs = observableCodeEditor(this._editor);
+        this._elements = h('div.inline-edits-view', {
+            style: {
+                position: 'absolute',
+                overflow: 'visible',
+                top: '0px',
+                left: '0px',
+            },
+        }, [
+            h('div.editorContainer@editorContainer', { style: { position: 'absolute' } }, [
+                h('div.preview@editor', { style: {} }),
+                h('div.toolbar@toolbar', { style: {} }),
+            ]),
+        ]);
+        this._indicator = h('div.inline-edits-view-indicator', {
+            style: {
+                position: 'absolute',
+                overflow: 'visible',
+            },
+        }, [
+            h('div.icon', {}, [
+                renderIcon(Codicon.arrowLeft),
+            ]),
+            h('div.label', {}, [
+                ' inline edit'
+            ])
+        ]);
+        this._previewEditorWidth = derived(this, reader => {
+            const edit = this._edit.read(reader);
+            if (!edit) {
+                return 0;
+            }
+            return maxLeftInRange(this._previewEditorObs, edit.modifiedLineRange, reader);
+        });
+        this._uiState = derived(this, reader => {
+            const edit = this._edit.read(reader);
+            if (!edit) {
+                return undefined;
+            }
+            let newText = edit.diffedTextEdit.apply(( new TextModelText(this._editor.getModel())));
+            let mappings = RangeMapping.fromEdit(edit.diffedTextEdit);
+            const newLines = splitLines(newText);
+            function offsetRangeToRange(offsetRange, startPos) {
+                return ( new Range(
+                    startPos.lineNumber,
+                    startPos.column + offsetRange.start,
+                    startPos.lineNumber,
+                    startPos.column + offsetRange.endExclusive
+                ));
+            }
+            const edits = [];
+            const minIndent = findFirstMin(edit.modifiedLineRange.mapToLineArray(l => getIndentationLength(newLines[l - 1])), numberComparator);
+            edit.modifiedLineRange.forEach(lineNumber => {
+                edits.push(( new SingleTextEdit(offsetRangeToRange(( new OffsetRange(0, minIndent)), ( new Position(lineNumber, 1))), '')));
+            });
+            const indentationAdjustmentEdit = ( new TextEdit(edits));
+            newText = indentationAdjustmentEdit.applyToString(newText);
+            mappings = applyEditToModifiedRangeMappings(mappings, indentationAdjustmentEdit);
+            const diff = lineRangeMappingFromRangeMappings(mappings, ( new TextModelText(this._editor.getModel())), ( new ArrayText(newLines)));
+            return {
+                diff,
+                edit,
+                newText,
+                newTextLineCount: edit.modifiedLineRange.length,
+            };
+        });
+        this._toolbar = this._register(this._instantiationService.createInstance(MenuWorkbenchToolBar, this._elements.toolbar, MenuId.InlineEditsActions, {
+            menuOptions: { renderShortTitle: true },
+            toolbarOptions: {
+                primaryGroup: g => g.startsWith('primary'),
+            },
+            actionViewItemProvider: (action, options) => {
+                if (action instanceof MenuItemAction) {
+                    return this._instantiationService.createInstance(StatusBarViewItem, action, undefined);
+                }
+                return undefined;
+            },
+        }));
+        this._previewTextModel = this._register(this._instantiationService.createInstance(TextModel, '', this._editor.getModel().getLanguageId(), { ...TextModel.DEFAULT_CREATION_OPTIONS, bracketPairColorizationOptions: { enabled: true, independentColorPoolPerBracketType: false } }, null));
+        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,
+            bracketPairColorization: { enabled: true, independentColorPoolPerBracketType: false },
+            scrollBeyondLastLine: false,
+            scrollbar: {
+                vertical: 'hidden',
+                horizontal: 'hidden',
+            },
+            readOnly: true,
+        }, { contributions: [], }, this._editor));
+        this._previewEditorObs = observableCodeEditor(this._previewEditor);
+        this._ensureModelTextIsSet = derived(reader => {
+            const uiState = this._uiState.read(reader);
+            if (!uiState) {
+                return;
+            }
+            this._previewTextModel.setValue(uiState.newText);
+            const range = uiState.edit.originalLineRange;
+            this._previewEditor.setHiddenAreas([
+                ( new Range(1, 1, range.startLineNumber - 1, 1)),
+                ( new Range(
+                    range.startLineNumber + uiState.newTextLineCount,
+                    1,
+                    this._previewTextModel.getLineCount() + 1,
+                    1
+                )),
+            ], undefined, true);
+        }).recomputeInitiallyAndOnChange(this._store);
+        this._decorations = derived(this, (reader) => {
+            this._ensureModelTextIsSet.read(reader);
+            const s = this._uiState.read(reader);
+            if (!s) {
+                return undefined;
+            }
+            const diff = s.diff;
+            const originalDecorations = [];
+            const modifiedDecorations = [];
+            for (const m of diff) {
+                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 : {
+                                    className: 'char-delete',
+                                    description: 'char-delete',
+                                    shouldFillLineOnLineBreak: false,
+                                }
+                            });
+                        }
+                        if (m.modified.contains(i.modifiedRange.startLineNumber)) {
+                            modifiedDecorations.push({ range: i.modifiedRange, options: i.modifiedRange.isEmpty() ? diffAddDecorationEmpty : diffAddDecoration });
+                        }
+                    }
+                }
+            }
+            return { originalDecorations, modifiedDecorations };
+        });
+        this._layout1 = derived(this, reader => {
+            const inlineEdit = this._edit.read(reader);
+            if (!inlineEdit) {
+                return null;
+            }
+            const maxLeft = maxLeftInRange(this._editorObs, inlineEdit.originalLineRange, reader);
+            const contentLeft = this._editorObs.layoutInfoContentLeft.read(reader);
+            return { left: contentLeft + maxLeft };
+        });
+        this._layout = derived(this, (reader) => {
+            const inlineEdit = this._edit.read(reader);
+            if (!inlineEdit) {
+                return null;
+            }
+            const range = inlineEdit.originalLineRange;
+            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(69 ) * inlineEdit.modifiedLineRange.length;
+            const topEdit = ( new Point(left + codeEditDist, selectionTop));
+            const bottomEdit = ( new Point(left + codeEditDist, selectionBottom));
+            return {
+                topCode,
+                bottomCode,
+                codeHeight,
+                topEdit,
+                bottomEdit,
+                editHeight,
+            };
+        });
+        const visible = derived(this, reader => this._edit.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._previewEditorWidth.read(reader);
+                return x + width;
+            }),
+        }));
+        this._register(observableCodeEditor(_editor).createOverlayWidget({
+            domNode: this._indicator.root,
+            position: constObservable(null),
+            allowEditorOverflow: false,
+            minContentWidthInPx: constObservable(0),
+        }));
+        this._previewEditor.setModel(this._previewTextModel);
+        this._register(this._previewEditorObs.setDecorations(( this._decorations.map(d => d?.modifiedDecorations ?? []))));
+        this._register(observableCodeEditor(_editor).setDecorations(( this._decorations.map(d => d?.originalDecorations ?? []))));
+        this._register(autorun(reader => {
+            const layoutInfo = this._layout.read(reader);
+            if (!layoutInfo) {
+                this._indicator.root.style.visibility = 'hidden';
+                return;
+            }
+            this._indicator.root.style.visibility = '';
+            const { topEdit, editHeight } = layoutInfo;
+            this._elements.editorContainer.style.top = `${topEdit.y}px`;
+            this._elements.editorContainer.style.left = `${topEdit.x}px`;
+            const width = this._previewEditorWidth.read(reader);
+            this._previewEditor.layout({ height: editHeight, width });
+            const i = this._editorObs.layoutInfo.read(reader);
+            const range = ( new OffsetRange(0, i.height - 30));
+            this._indicator.root.classList.toggle('top', topEdit.y < range.start);
+            this._indicator.root.classList.toggle('bottom', topEdit.y > range.endExclusive);
+            this._indicator.root.classList.toggle('contained', range.contains(topEdit.y));
+            this._indicator.root.style.top = `${range.clip(topEdit.y)}px`;
+            this._indicator.root.style.right = `${i.minimap.minimapWidth + i.verticalScrollbarWidth}px`;
+        }));
+        const toolbarDropdownVisible = observableFromEvent(this, this._toolbar.onDidChangeDropdownVisibility, (e) => e ?? false);
+        this._register(autorun(reader => {
+            this._elements.root.classList.toggle('toolbarDropdownVisible', toolbarDropdownVisible.read(reader));
+        }));
+    }
+};
+InlineEditsView = ( __decorate([
+    ( __param(2, IInstantiationService))
+], InlineEditsView));
+export { InlineEditWithChanges, InlineEditsView, InlineEditsViewAndDiffProducer };

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/view/inlineEdits/utils.js

@@ -0,0 +1,70 @@
+import { h } from '../../../../../../base/browser/dom.js';
+import { KeybindingLabel, unthemedKeybindingLabelOptions } from '../../../../../../base/browser/ui/keybindingLabel/keybindingLabel.js';
+import { OS } from '../../../../../../base/common/platform.js';
+import { URI } from '../../../../../../base/common/uri.js';
+import { MenuEntryActionViewItem } from '../../../../../../platform/actions/browser/menuEntryActionViewItem.js';
+import { RangeMapping } from '../../../../../common/diff/rangeMapping.js';
+function maxLeftInRange(editor, range, reader) {
+    editor.layoutInfo.read(reader);
+    editor.value.read(reader);
+    const model = editor.model.get();
+    if (!model) {
+        return 0;
+    }
+    let maxLeft = 0;
+    editor.scrollTop.read(reader);
+    for (let i = range.startLineNumber; i < range.endLineNumberExclusive; i++) {
+        const column = model.getLineMaxColumn(i);
+        const left = editor.editor.getOffsetForColumn(i, column);
+        maxLeft = Math.max(maxLeft, left);
+    }
+    return maxLeft;
+}
+class StatusBarViewItem extends MenuEntryActionViewItem {
+    updateLabel() {
+        const kb = this._keybindingService.lookupKeybinding(this._action.id, this._contextKeyService);
+        if (!kb) {
+            return super.updateLabel();
+        }
+        if (this.label) {
+            const div = h('div.keybinding').root;
+            const keybindingLabel = this._register(( new KeybindingLabel(div, OS, { disableTitle: true, ...unthemedKeybindingLabelOptions })));
+            keybindingLabel.set(kb);
+            this.label.textContent = this._action.label;
+            this.label.appendChild(div);
+            this.label.classList.add('inlineSuggestionStatusBarItemLabel');
+        }
+    }
+    updateTooltip() {
+    }
+}
+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 UniqueUriGenerator {
+    static { this._modelId = 0; }
+    constructor(scheme) {
+        this.scheme = scheme;
+    }
+    getUniqueUri() {
+        return ( URI.from({ scheme: this.scheme, path: ( ( new Date()).toString()) + String(UniqueUriGenerator._modelId++) }));
+    }
+}
+function applyEditToModifiedRangeMappings(rangeMapping, edit) {
+    const updatedMappings = [];
+    for (const m of rangeMapping) {
+        const updatedRange = edit.mapRange(m.modifiedRange);
+        updatedMappings.push(( new RangeMapping(m.originalRange, updatedRange)));
+    }
+    return updatedMappings;
+}
+export { Point, StatusBarViewItem, UniqueUriGenerator, applyEditToModifiedRangeMappings, maxLeftInRange };

package/vscode/src/vs/editor/contrib/inlineEdit/browser/commands.js

@@ -1,11 +1,9 @@
-import { KeyCode, KeyMod as KeyMod$1 } from '../../../../base/common/keyCodes.js';
 import { EditorAction } from '../../../browser/editorExtensions.js';
 import { EditorContextKeys } from '../../../common/editorContextKeys.js';
 import { inlineEditAcceptId, inlineEditJumpToId, inlineEditJumpBackId, inlineEditRejectId } from './commandIds.js';
 import { InlineEditController } from './inlineEditController.js';
 import { MenuId } from '../../../../platform/actions/common/actions.js';
 import { ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
-import { KeybindingWeight } from '../../../../platform/keybinding/common/keybindingsRegistry.js';
 class AcceptInlineEdit extends EditorAction {
     constructor() {
         super({
@@ -15,8 +13,8 @@ class AcceptInlineEdit extends EditorAction {
             precondition: ( ContextKeyExpr.and(EditorContextKeys.writable, InlineEditController.inlineEditVisibleContext)),
             kbOpts: [
                 {
-                    weight: KeybindingWeight.EditorContrib + 1,
-                    primary: KeyCode.Tab,
+                    weight: 100  + 1,
+                    primary: 2 ,
                     kbExpr: ( ContextKeyExpr.and(
                         EditorContextKeys.writable,
                         InlineEditController.inlineEditVisibleContext,
@@ -49,8 +47,8 @@ class TriggerInlineEdit extends EditorAction {
             alias: 'Trigger Inline Edit',
             precondition: activeExpr,
             kbOpts: {
-                weight: KeybindingWeight.EditorContrib + 1,
-                primary: KeyMod$1.CtrlCmd | KeyMod$1.Alt | KeyCode.Equal,
+                weight: 100  + 1,
+                primary: 2048  | 512  | 86 ,
                 kbExpr: activeExpr
             },
         });
@@ -73,8 +71,8 @@ class JumpToInlineEdit extends EditorAction {
             alias: 'Jump to Inline Edit',
             precondition: activeExpr,
             kbOpts: {
-                weight: KeybindingWeight.EditorContrib + 1,
-                primary: KeyMod$1.CtrlCmd | KeyMod$1.Alt | KeyCode.Equal,
+                weight: 100  + 1,
+                primary: 2048  | 512  | 86 ,
                 kbExpr: activeExpr
             },
             menuOpts: [{
@@ -100,8 +98,8 @@ class JumpBackInlineEdit extends EditorAction {
             alias: 'Jump Back from Inline Edit',
             precondition: activeExpr,
             kbOpts: {
-                weight: KeybindingWeight.EditorContrib + 10,
-                primary: KeyMod$1.CtrlCmd | KeyMod$1.Alt | KeyCode.Equal,
+                weight: 100  + 10,
+                primary: 2048  | 512  | 86 ,
                 kbExpr: activeExpr
             },
             menuOpts: [{
@@ -127,8 +125,8 @@ class RejectInlineEdit extends EditorAction {
             alias: 'Reject Inline Edit',
             precondition: activeExpr,
             kbOpts: {
-                weight: KeybindingWeight.EditorContrib,
-                primary: KeyCode.Escape,
+                weight: 100 ,
+                primary: 9 ,
                 kbExpr: activeExpr
             },
             menuOpts: [{

package/vscode/src/vs/editor/contrib/inlineEdit/browser/ghostTextWidget.js

@@ -1,30 +1,33 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { Disposable, toDisposable } from '../../../../base/common/lifecycle.js';
 import { observableValue } from '../../../../base/common/observableInternal/base.js';
-import { derived } from '../../../../base/common/observableInternal/derived.js';
+import '../../../../base/common/arrays.js';
+import '../../../../base/common/event.js';
 import '../../../../base/common/observableInternal/autorun.js';
-import { observableFromEvent } from '../../../../base/common/observableInternal/utils.js';
+import { derived } from '../../../../base/common/observableInternal/derived.js';
 import '../../../../base/common/cancellation.js';
-import '../../../../base/common/arrays.js';
+import { observableFromEvent } from '../../../../base/common/observableInternal/utils.js';
 import './inlineEdit.css.js';
 import { Position } from '../../../common/core/position.js';
 import { Range } from '../../../common/core/range.js';
 import { ILanguageService } from '../../../common/languages/language.js';
 import { InjectedTextCursorStops } from '../../../common/model.js';
 import { LineDecoration } from '../../../common/viewLayout/lineDecorations.js';
-import { InlineDecorationType } from '../../../common/viewModel.js';
-import { AdditionalLinesWidget } from '../../inlineCompletions/browser/view/ghostTextView.js';
-import { ColumnRange, applyObservableDecorations } from '../../inlineCompletions/browser/utils.js';
+import { AdditionalLinesWidget } from '../../inlineCompletions/browser/view/ghostText/ghostTextView.js';
+import { ColumnRange } from '../../inlineCompletions/browser/utils.js';
 import { diffDeleteDecoration, diffLineDeleteDecorationBackgroundWithIndicator } from '../../../browser/widget/diffEditor/registrations.contribution.js';
+import { LineTokens } from '../../../common/tokens/lineTokens.js';
+import { observableCodeEditor } from '../../../browser/observableCodeEditor.js';
 const INLINE_EDIT_DESCRIPTION = 'inline-edit';
 let GhostTextWidget = class GhostTextWidget extends Disposable {
-    constructor(editor, model, languageService) {
+    constructor(_editor, model, languageService) {
         super();
-        this.editor = editor;
+        this._editor = _editor;
         this.model = model;
         this.languageService = languageService;
         this.isDisposed = observableValue(this, false);
-        this.currentTextModel = observableFromEvent(this, this.editor.onDidChangeModel, () =>  this.editor.getModel());
+        this.currentTextModel = observableFromEvent(this, this._editor.onDidChangeModel, () =>  this._editor.getModel());
+        this._editorObs = observableCodeEditor(this._editor);
         this.uiState = derived(this, reader => {
             if (this.isDisposed.read(reader)) {
                 return undefined;
@@ -53,7 +56,7 @@ let GhostTextWidget = class GhostTextWidget extends Disposable {
                             lastLine.content.length + 1,
                             lastLine.content.length + 1 + lines[0].length,
                             className,
-                            InlineDecorationType.Regular
+                            0
                         )));
                     }
                     lastLine.content += lines[0];
@@ -62,7 +65,7 @@ let GhostTextWidget = class GhostTextWidget extends Disposable {
                 for (const line of lines) {
                     additionalLines.push({
                         content: line,
-                        decorations: className ? [( new LineDecoration(1, line.length + 1, className, InlineDecorationType.Regular))] : []
+                        decorations: className ? [( new LineDecoration(1, line.length + 1, className, 0 ))] : []
                     });
                 }
             }
@@ -166,17 +169,20 @@ let GhostTextWidget = class GhostTextWidget extends Disposable {
             }
             return decorations;
         });
-        this.additionalLinesWidget = this._register(( new AdditionalLinesWidget(this.editor, this.languageService.languageIdCodec, derived(reader => {
+        this.additionalLinesWidget = this._register(( new AdditionalLinesWidget(this._editor, derived(reader => {
             const uiState = this.uiState.read(reader);
             return uiState && !uiState.isPureRemove && (uiState.isSingleLine || !uiState.range) ? {
                 lineNumber: uiState.lineNumber,
-                additionalLines: uiState.additionalLines,
+                additionalLines: ( uiState.additionalLines.map(l => ({
+                    content: LineTokens.createEmpty(l.content, this.languageService.languageIdCodec),
+                    decorations: l.decorations
+                }))),
                 minReservedLineCount: uiState.additionalReservedLineCount,
                 targetTextModel: uiState.targetTextModel,
             } : undefined;
         }))));
         this._register(toDisposable(() => { this.isDisposed.set(true, undefined); }));
-        this._register(applyObservableDecorations(this.editor, this.decorations));
+        this._register(this._editorObs.setDecorations(this.decorations));
     }
     ownsViewZone(viewZoneId) {
         return this.additionalLinesWidget.viewZoneId === viewZoneId;

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

@@ -1,4 +1,4 @@
-import { registerEditorAction, registerEditorContribution, EditorContributionInstantiation } from '../../../browser/editorExtensions.js';
+import { registerEditorAction, registerEditorContribution } from '../../../browser/editorExtensions.js';
 import { AcceptInlineEdit, RejectInlineEdit, JumpToInlineEdit, JumpBackInlineEdit, TriggerInlineEdit } from './commands.js';
 import { InlineEditController } from './inlineEditController.js';
 registerEditorAction(AcceptInlineEdit);
@@ -6,4 +6,4 @@ registerEditorAction(RejectInlineEdit);
 registerEditorAction(JumpToInlineEdit);
 registerEditorAction(JumpBackInlineEdit);
 registerEditorAction(TriggerInlineEdit);
-registerEditorContribution(InlineEditController.ID, InlineEditController, EditorContributionInstantiation.Eventually);
+registerEditorContribution(InlineEditController.ID, InlineEditController, 3 );