@codingame/monaco-vscode-api 13.1.6 → 14.0.0

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

@@ -0,0 +1,365 @@
+
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from '../../../../../../base/common/lifecycle.js';
+import '../../../../../../base/common/arrays.js';
+import '../../../../../../base/common/event.js';
+import { autorunWithStore } from '../../../../../../base/common/observableInternal/autorun.js';
+import { derived } from '../../../../../../base/common/observableInternal/derived.js';
+import '../../../../../../base/common/cancellation.js';
+import { mapObservableArrayCached } from '../../../../../../base/common/observableInternal/utils.js';
+import { IInstantiationService } from '../../../../../../platform/instantiation/common/instantiation.js';
+import { observableCodeEditor } from '../../../../../browser/observableCodeEditor.js';
+import { EditorOption } from '../../../../../common/config/editorOptions.js';
+import { LineRange } from '../../../../../common/core/lineRange.js';
+import { Range } from '../../../../../common/core/range.js';
+import { StringText, SingleTextEdit } 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 { InlineEditsDeletionView } from './deletionView.js';
+import { InlineEditsGutterIndicator } from './gutterIndicatorView.js';
+import { InlineEditsIndicator } from './indicatorView.js';
+import { OriginalEditorInlineDiffView } from './inlineDiffView.js';
+import { InlineEditsInsertionView } from './insertionView.js';
+import { InlineEditsSideBySideDiff } from './sideBySideDiff.js';
+import { createReindentEdit, applyEditToModifiedRangeMappings } from './utils.js';
+import './view.css.js';
+import { WordReplacementView, LineReplacementView } from './wordReplacementView.js';
+
+let InlineEditsView = class InlineEditsView extends Disposable {
+    constructor(_editor, _edit, _model, _focusIsInMenu, _instantiationService) {
+        super();
+        this._editor = _editor;
+        this._edit = _edit;
+        this._model = _model;
+        this._focusIsInMenu = _focusIsInMenu;
+        this._instantiationService = _instantiationService;
+        this._editorObs = observableCodeEditor(this._editor);
+        this._useMixedLinesDiff = ( observableCodeEditor(this._editor).getOption(EditorOption.inlineSuggest).map(s => s.edits.useMixedLinesDiff));
+        this._useInterleavedLinesDiff = ( observableCodeEditor(this._editor).getOption(EditorOption.inlineSuggest).map(s => s.edits.useInterleavedLinesDiff));
+        this._useCodeShifting = ( observableCodeEditor(this._editor).getOption(EditorOption.inlineSuggest).map(s => s.edits.codeShifting));
+        this._renderSideBySide = ( observableCodeEditor(this._editor).getOption(EditorOption.inlineSuggest).map(s => s.edits.renderSideBySide));
+        this._useMultiLineGhostText = ( observableCodeEditor(this._editor).getOption(EditorOption.inlineSuggest).map(s => s.edits.useMultiLineGhostText));
+        this._uiState = derived(this, reader => {
+            const edit = this._edit.read(reader);
+            if (!edit) {
+                return undefined;
+            }
+            this._model.get()?.handleInlineCompletionShown(edit.inlineCompletion);
+            let mappings = RangeMapping.fromEdit(edit.edit);
+            let newText = edit.edit.apply(edit.originalText);
+            let diff = lineRangeMappingFromRangeMappings(mappings, edit.originalText, ( new StringText(newText)));
+            const state = this.determineRenderState(edit, reader, diff, ( new StringText(newText)));
+            if (!state) {
+                this._model.get()?.stop();
+                return undefined;
+            }
+            if (state.kind === 'sideBySide') {
+                const indentationAdjustmentEdit = createReindentEdit(newText, edit.modifiedLineRange);
+                newText = indentationAdjustmentEdit.applyToString(newText);
+                mappings = applyEditToModifiedRangeMappings(mappings, indentationAdjustmentEdit);
+                diff = lineRangeMappingFromRangeMappings(mappings, edit.originalText, ( new StringText(newText)));
+            }
+            const originalDisplayRange = edit.originalText.lineRange.intersect(edit.originalLineRange.join(LineRange.ofLength(edit.originalLineRange.startLineNumber, edit.lineEdit.newLines.length)));
+            this._previewTextModel.setLanguage(this._editor.getModel().getLanguageId());
+            const previousNewText = this._previewTextModel.getValue();
+            if (previousNewText !== newText) {
+                this._previewTextModel.setValue(newText);
+            }
+            return {
+                state,
+                diff,
+                edit,
+                newText,
+                newTextLineCount: edit.modifiedLineRange.length,
+                originalDisplayRange: originalDisplayRange,
+            };
+        });
+        this._previewTextModel = this._register(this._instantiationService.createInstance(TextModel, '', this._editor.getModel().getLanguageId(), { ...TextModel.DEFAULT_CREATION_OPTIONS, bracketPairColorizationOptions: { enabled: true, independentColorPoolPerBracketType: false } }, null));
+        this._sideBySide = this._register(this._instantiationService.createInstance(InlineEditsSideBySideDiff, this._editor, this._edit, this._previewTextModel, ( this._uiState.map(s => s && s.state?.kind === 'sideBySide' ? ({
+            edit: s.edit,
+            newTextLineCount: s.newTextLineCount,
+            originalDisplayRange: s.originalDisplayRange,
+        }) : undefined))));
+        this._deletion = this._register(this._instantiationService.createInstance(InlineEditsDeletionView, this._editor, this._edit, ( this._uiState.map(s => s && s.state?.kind === 'deletion' ? ({
+            originalRange: s.state.originalRange,
+            deletions: s.state.deletions,
+        }) : undefined))));
+        this._insertion = this._register(this._instantiationService.createInstance(InlineEditsInsertionView, this._editor, ( this._uiState.map(s => s && s.state?.kind === 'insertionMultiLine' ? ({
+            lineNumber: s.state.lineNumber,
+            startColumn: s.state.column,
+            text: s.state.text,
+        }) : undefined))));
+        this._inlineDiffViewState = derived(this, reader => {
+            const e = this._uiState.read(reader);
+            if (!e || !e.state) {
+                return undefined;
+            }
+            if (e.state.kind === 'wordReplacements' || e.state.kind === 'lineReplacement' || e.state.kind === 'insertionMultiLine') {
+                return undefined;
+            }
+            return {
+                modifiedText: ( new StringText(e.newText)),
+                diff: e.diff,
+                mode: e.state.kind === 'collapsed' ? 'sideBySide' : e.state.kind,
+                modifiedCodeEditor: this._sideBySide.previewEditor,
+            };
+        });
+        this._inlineDiffView = this._register(( new OriginalEditorInlineDiffView(this._editor, this._inlineDiffViewState, this._previewTextModel)));
+        this._wordReplacementViews = mapObservableArrayCached(this, ( this._uiState.map(s => s?.state?.kind === 'wordReplacements' ? s.state.replacements : [])), (e, store) => {
+            return store.add(this._instantiationService.createInstance(WordReplacementView, this._editorObs, e, [e]));
+        }).recomputeInitiallyAndOnChange(this._store);
+        this._lineReplacementView = mapObservableArrayCached(this, ( this._uiState.map(s => s?.state?.kind === 'lineReplacement' ? [s.state] : [])), (e, store) => {
+            return store.add(this._instantiationService.createInstance(LineReplacementView, this._editorObs, e.originalRange, e.modifiedRange, e.modifiedLines, e.replacements));
+        }).recomputeInitiallyAndOnChange(this._store);
+        this._useGutterIndicator = ( observableCodeEditor(this._editor).getOption(EditorOption.inlineSuggest).map(s => s.edits.useGutterIndicator));
+        this._inlineEditsIsHovered = derived(this, reader => {
+            return this._sideBySide.isHovered.read(reader)
+                || ( this._wordReplacementViews.read(reader).some(v => v.isHovered.read(reader)))
+                || this._deletion.isHovered.read(reader)
+                || this._inlineDiffView.isHovered.read(reader)
+                || ( this._lineReplacementView.read(reader).some(v => v.isHovered.read(reader)));
+        });
+        this._gutterIndicatorOffset = derived(this, reader => {
+            if (this._uiState.read(reader)?.state?.kind === 'insertionMultiLine') {
+                return this._insertion.startLineOffset.read(reader);
+            }
+            return 0;
+        });
+        this._originalDisplayRange = derived(this, reader => {
+            const state = this._uiState.read(reader);
+            if (state?.state?.kind === 'insertionMultiLine') {
+                return this._insertion.originalLines.read(reader);
+            }
+            return state?.originalDisplayRange;
+        });
+        this._indicator = this._register(autorunWithStore((reader, store) => {
+            if (this._useGutterIndicator.read(reader)) {
+                store.add(this._instantiationService.createInstance(InlineEditsGutterIndicator, this._editorObs, this._originalDisplayRange, this._gutterIndicatorOffset, this._model, this._inlineEditsIsHovered, this._focusIsInMenu));
+            }
+            else {
+                store.add(( new InlineEditsIndicator(this._editorObs, derived(reader => {
+                    const state = this._uiState.read(reader);
+                    const range = this._originalDisplayRange.read(reader);
+                    if (!state || !state.state || !range) {
+                        return undefined;
+                    }
+                    const top = this._editor.getTopForLineNumber(range.startLineNumber) - this._editorObs.scrollTop.read(reader) + this._gutterIndicatorOffset.read(reader);
+                    return { editTop: top, showAlways: state.state.kind !== 'sideBySide' };
+                }), this._model)));
+            }
+        }));
+    }
+    determineView(edit, reader, diff, newText) {
+        const canUseCache = this._previousView?.id === edit.inlineCompletion.id;
+        const reconsiderViewAfterJump = edit.userJumpedToIt !== this._previousView?.userJumpedToIt &&
+            ((this._useMixedLinesDiff.read(reader) === 'afterJumpWhenPossible' && this._previousView?.view !== 'mixedLines') ||
+                (this._useInterleavedLinesDiff.read(reader) === 'afterJump' && this._previousView?.view !== 'interleavedLines'));
+        const reconsiderViewEditorWidthChange = this._previousView?.editorWidth !== this._editor.getLayoutInfo().width &&
+            (this._previousView?.view === 'sideBySide' ||
+                this._previousView?.view === 'lineReplacement');
+        if (canUseCache && !reconsiderViewAfterJump && !reconsiderViewEditorWidthChange) {
+            return this._previousView.view;
+        }
+        if (edit.isCollapsed) {
+            return 'collapsed';
+        }
+        const inner = diff.flatMap(d => d.innerChanges ?? []);
+        const isSingleInnerEdit = inner.length === 1;
+        if (isSingleInnerEdit && (this._useMixedLinesDiff.read(reader) === 'forStableInsertions'
+            && this._useCodeShifting.read(reader)
+            && isSingleLineInsertionAfterPosition(diff, edit.cursorPosition)
+            || isSingleLineDeletion(diff))) {
+            return 'insertionInline';
+        }
+        const innerValues = ( inner.map(
+            m => ({ original: edit.originalText.getValueOfRange(m.originalRange), modified: newText.getValueOfRange(m.modifiedRange) })
+        ));
+        if (innerValues.every(({ original, modified }) => modified.trim() === '' && original.length > 0 && (original.length > modified.length || original.trim() !== ''))) {
+            return 'deletion';
+        }
+        if (isSingleMultiLineInsertion(diff) && this._useMultiLineGhostText.read(reader) && this._useCodeShifting.read(reader)) {
+            return 'insertionMultiLine';
+        }
+        const numOriginalLines = edit.originalLineRange.length;
+        const numModifiedLines = edit.modifiedLineRange.length;
+        const allInnerChangesNotTooLong = inner.every(m => TextLength.ofRange(m.originalRange).columnCount < WordReplacementView.MAX_LENGTH && TextLength.ofRange(m.modifiedRange).columnCount < WordReplacementView.MAX_LENGTH);
+        if (allInnerChangesNotTooLong && isSingleInnerEdit && numOriginalLines === 1 && numModifiedLines === 1) {
+            if (!( inner.some(m => m.originalRange.isEmpty())) ||
+                !( growEditsUntilWhitespace(( inner.map(m => ( new SingleTextEdit(m.originalRange, '')))), edit.originalText).some(
+                    e => e.range.isEmpty() && TextLength.ofRange(e.range).columnCount < WordReplacementView.MAX_LENGTH
+                ))) {
+                return 'wordReplacements';
+            }
+        }
+        if (numOriginalLines > 0 && numModifiedLines > 0) {
+            if (this._renderSideBySide.read(reader) !== 'never' && InlineEditsSideBySideDiff.fitsInsideViewport(this._editor, edit, reader)) {
+                return 'sideBySide';
+            }
+            return 'lineReplacement';
+        }
+        if ((this._useMixedLinesDiff.read(reader) === 'whenPossible' || (edit.userJumpedToIt && this._useMixedLinesDiff.read(reader) === 'afterJumpWhenPossible'))
+            && diff.every(m => OriginalEditorInlineDiffView.supportsInlineDiffRendering(m))) {
+            return 'mixedLines';
+        }
+        if (this._useInterleavedLinesDiff.read(reader) === 'always' || (edit.userJumpedToIt && this._useInterleavedLinesDiff.read(reader) === 'afterJump')) {
+            return 'interleavedLines';
+        }
+        return 'sideBySide';
+    }
+    determineRenderState(edit, reader, diff, newText) {
+        const view = this.determineView(edit, reader, diff, newText);
+        this._previousView = { id: edit.inlineCompletion.id, view, userJumpedToIt: edit.userJumpedToIt, editorWidth: this._editor.getLayoutInfo().width };
+        switch (view) {
+            case 'collapsed': return { kind: 'collapsed' };
+            case 'insertionInline': return { kind: 'insertionInline' };
+            case 'mixedLines': return { kind: 'mixedLines' };
+            case 'interleavedLines': return { kind: 'interleavedLines' };
+            case 'sideBySide': return { kind: 'sideBySide' };
+        }
+        const inner = diff.flatMap(d => d.innerChanges ?? []);
+        if (view === 'deletion') {
+            return {
+                kind: 'deletion',
+                originalRange: edit.originalLineRange,
+                deletions: ( inner.map(m => m.originalRange)),
+            };
+        }
+        if (view === 'insertionMultiLine') {
+            const change = inner[0];
+            return {
+                kind: 'insertionMultiLine',
+                lineNumber: change.originalRange.startLineNumber,
+                column: change.originalRange.startColumn,
+                text: newText.getValueOfRange(change.modifiedRange),
+            };
+        }
+        const replacements = ( inner.map(m => ( new SingleTextEdit(m.originalRange, newText.getValueOfRange(m.modifiedRange)))));
+        if (replacements.length === 0) {
+            return undefined;
+        }
+        if (view === 'wordReplacements') {
+            let grownEdits = growEditsToEntireWord(replacements, edit.originalText);
+            if (( grownEdits.some(e => e.range.isEmpty()))) {
+                grownEdits = growEditsUntilWhitespace(replacements, edit.originalText);
+            }
+            return {
+                kind: 'wordReplacements',
+                replacements: grownEdits,
+            };
+        }
+        if (view === 'lineReplacement') {
+            return {
+                kind: 'lineReplacement',
+                originalRange: edit.originalLineRange,
+                modifiedRange: edit.modifiedLineRange,
+                modifiedLines: edit.modifiedLineRange.mapToLineArray(line => newText.getLineAt(line)),
+                replacements: ( inner.map(m => ({ originalRange: m.originalRange, modifiedRange: m.modifiedRange }))),
+            };
+        }
+        return undefined;
+    }
+};
+InlineEditsView = ( __decorate([
+    ( __param(4, IInstantiationService))
+], InlineEditsView));
+function isSingleLineInsertionAfterPosition(diff, position) {
+    if (!position) {
+        return false;
+    }
+    const pos = position;
+    return diff.every(m => m.innerChanges.every(r => isStableWordInsertion(r)));
+    function isStableWordInsertion(r) {
+        if (!r.originalRange.isEmpty()) {
+            return false;
+        }
+        const isInsertionWithinLine = r.modifiedRange.startLineNumber === r.modifiedRange.endLineNumber;
+        if (!isInsertionWithinLine) {
+            return false;
+        }
+        const insertPosition = r.originalRange.getStartPosition();
+        if (pos.isBeforeOrEqual(insertPosition)) {
+            return true;
+        }
+        if (insertPosition.lineNumber < pos.lineNumber) {
+            return true;
+        }
+        return false;
+    }
+}
+function isSingleMultiLineInsertion(diff) {
+    const inner = diff.flatMap(d => d.innerChanges ?? []);
+    if (inner.length !== 1) {
+        return false;
+    }
+    const change = inner[0];
+    if (!change.originalRange.isEmpty()) {
+        return false;
+    }
+    if (change.modifiedRange.startLineNumber === change.modifiedRange.endLineNumber) {
+        return false;
+    }
+    return true;
+}
+function isSingleLineDeletion(diff) {
+    return diff.every(m => m.innerChanges.every(r => isDeletion(r)));
+    function isDeletion(r) {
+        if (!r.modifiedRange.isEmpty()) {
+            return false;
+        }
+        const isDeletionWithinLine = r.originalRange.startLineNumber === r.originalRange.endLineNumber;
+        if (!isDeletionWithinLine) {
+            return false;
+        }
+        return true;
+    }
+}
+function growEditsToEntireWord(replacements, originalText) {
+    return _growEdits(replacements, originalText, (char) => /^[a-zA-Z]$/.test(char));
+}
+function growEditsUntilWhitespace(replacements, originalText) {
+    return _growEdits(replacements, originalText, (char) => !(/^\s$/.test(char)));
+}
+function _growEdits(replacements, originalText, fn) {
+    const result = [];
+    replacements.sort((a, b) => Range.compareRangesUsingStarts(a.range, b.range));
+    for (const edit of replacements) {
+        let startIndex = edit.range.startColumn - 1;
+        let endIndex = edit.range.endColumn - 2;
+        let prefix = '';
+        let suffix = '';
+        const startLineContent = originalText.getLineAt(edit.range.startLineNumber);
+        const endLineContent = originalText.getLineAt(edit.range.endLineNumber);
+        if (isIncluded(startLineContent[startIndex])) {
+            while (isIncluded(startLineContent[startIndex - 1])) {
+                prefix = startLineContent[startIndex - 1] + prefix;
+                startIndex--;
+            }
+        }
+        if (isIncluded(endLineContent[endIndex]) || endIndex < startIndex) {
+            while (isIncluded(endLineContent[endIndex + 1])) {
+                suffix += endLineContent[endIndex + 1];
+                endIndex++;
+            }
+        }
+        let newEdit = ( new SingleTextEdit(( new Range(
+            edit.range.startLineNumber,
+            startIndex + 1,
+            edit.range.endLineNumber,
+            endIndex + 2
+        )), prefix + edit.text + suffix));
+        if (result.length > 0 && Range.areIntersectingOrTouching(result[result.length - 1].range, newEdit.range)) {
+            newEdit = SingleTextEdit.joinEdits([result.pop(), newEdit], originalText);
+        }
+        result.push(newEdit);
+    }
+    function isIncluded(c) {
+        if (c === undefined) {
+            return false;
+        }
+        return fn(c);
+    }
+    return result;
+}
+
+export { InlineEditsView };

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/view/inlineEdits/{inlineEditsViewAndDiffProducer.d.ts → viewAndDiffProducer.d.ts}

@@ -1,12 +1,11 @@
 import { Disposable } from "../../../../../../base/common/lifecycle.js";
-import { IObservable } from "../../../../../../base/common/observable.js";
+import { IObservable, ISettableObservable } from "../../../../../../base/common/observable.js";
 import { IInstantiationService } from "../../../../../../platform/instantiation/common/instantiation.js";
 import { ICodeEditor } from "../../../../../browser/editorBrowser.js";
-import { IDiffProviderFactoryService } from "../../../../../browser/widget/diffEditor/diffProviderFactoryService.js";
 import { SingleLineEdit } from "../../../../../common/core/lineEdit.js";
+import { Position } from "../../../../../common/core/position.js";
 import { TextEdit, AbstractText } from "../../../../../common/core/textEdit.js";
 import { Command } from "../../../../../common/languages.js";
-import { IModelService } from "../../../../../common/services/model.js";
 import { InlineCompletionsModel } from "../../model/inlineCompletionsModel.js";
 import { InlineEdit } from "../../model/inlineEdit.js";
 import { InlineCompletionItem } from "../../model/provideInlineCompletions.js";
@@ -14,28 +13,23 @@ export declare class InlineEditsViewAndDiffProducer extends Disposable {
     private readonly _editor;
     private readonly _edit;
     private readonly _model;
+    private readonly _focusIsInMenu;
     private readonly _instantiationService;
-    private readonly _diffProviderFactoryService;
-    private readonly _modelService;
-    static readonly hot: IObservable<typeof InlineEditsViewAndDiffProducer, unknown>;
-    private readonly _modelUriGenerator;
-    private readonly _originalModel;
-    private readonly _modifiedModel;
-    private readonly _differ;
-    private readonly _inlineEditPromise;
+    static readonly hot: IObservable<typeof InlineEditsViewAndDiffProducer>;
     private readonly _inlineEdit;
-    constructor(_editor: ICodeEditor, _edit: IObservable<InlineEdit | undefined>, _model: IObservable<InlineCompletionsModel | undefined>, _instantiationService: IInstantiationService, _diffProviderFactoryService: IDiffProviderFactoryService, _modelService: IModelService);
+    constructor(_editor: ICodeEditor, _edit: IObservable<InlineEdit | undefined>, _model: IObservable<InlineCompletionsModel | undefined>, _focusIsInMenu: ISettableObservable<boolean>, _instantiationService: IInstantiationService);
 }
 export declare class InlineEditWithChanges {
     readonly originalText: AbstractText;
     readonly edit: TextEdit;
     readonly isCollapsed: boolean;
+    readonly cursorPosition: Position;
     readonly userJumpedToIt: boolean;
     readonly commands: readonly Command[];
     readonly inlineCompletion: InlineCompletionItem;
     readonly lineEdit: SingleLineEdit;
     readonly originalLineRange: import("../../../../../common/core/lineRange.js").LineRange;
     readonly modifiedLineRange: import("../../../../../common/core/lineRange.js").LineRange;
-    constructor(originalText: AbstractText, edit: TextEdit, isCollapsed: boolean, userJumpedToIt: boolean, commands: readonly Command[], inlineCompletion: InlineCompletionItem);
+    constructor(originalText: AbstractText, edit: TextEdit, isCollapsed: boolean, cursorPosition: Position, userJumpedToIt: boolean, commands: readonly Command[], inlineCompletion: InlineCompletionItem);
     equals(other: InlineEditWithChanges): boolean;
 }

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

@@ -0,0 +1,92 @@
+
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { createHotClass } from '../../../../../../base/common/hotReloadHelpers.js';
+import { Disposable } from '../../../../../../base/common/lifecycle.js';
+import '../../../../../../base/common/arrays.js';
+import '../../../../../../base/common/event.js';
+import '../../../../../../base/common/observableInternal/autorun.js';
+import { derived } from '../../../../../../base/common/observableInternal/derived.js';
+import '../../../../../../base/common/cancellation.js';
+import '../../../../../../base/common/observableInternal/utils.js';
+import { IInstantiationService } from '../../../../../../platform/instantiation/common/instantiation.js';
+import { SingleLineEdit } from '../../../../../common/core/lineEdit.js';
+import { Range } from '../../../../../common/core/range.js';
+import { SingleTextEdit, TextEdit } from '../../../../../common/core/textEdit.js';
+import { TextModelText } from '../../../../../common/model/textModelText.js';
+import { InlineEditsView } from './view.js';
+
+var InlineEditsViewAndDiffProducer_1;
+let InlineEditsViewAndDiffProducer = class InlineEditsViewAndDiffProducer extends Disposable {
+    static { InlineEditsViewAndDiffProducer_1 = this; }
+    static { this.hot = createHotClass(InlineEditsViewAndDiffProducer_1); }
+    constructor(_editor, _edit, _model, _focusIsInMenu, _instantiationService) {
+        super();
+        this._editor = _editor;
+        this._edit = _edit;
+        this._model = _model;
+        this._focusIsInMenu = _focusIsInMenu;
+        this._instantiationService = _instantiationService;
+        this._inlineEdit = derived(this, (reader) => {
+            const model = this._model.read(reader);
+            if (!model) {
+                return undefined;
+            }
+            const inlineEdit = this._edit.read(reader);
+            if (!inlineEdit) {
+                return undefined;
+            }
+            const textModel = this._editor.getModel();
+            if (!textModel) {
+                return undefined;
+            }
+            const editOffset = model.inlineEditState.get()?.inlineCompletion.inlineEdit.read(reader);
+            if (!editOffset) {
+                return undefined;
+            }
+            const edits = ( editOffset.edits.map(e => {
+                const innerEditRange = Range.fromPositions(textModel.getPositionAt(e.replaceRange.start), textModel.getPositionAt(e.replaceRange.endExclusive));
+                return ( new SingleTextEdit(innerEditRange, e.newText));
+            }));
+            const diffEdits = ( new TextEdit(edits));
+            const text = ( new TextModelText(textModel));
+            return ( new InlineEditWithChanges(
+                text,
+                diffEdits,
+                inlineEdit.isCollapsed,
+                model.primaryPosition.get(),
+                inlineEdit.renderExplicitly,
+                inlineEdit.commands,
+                inlineEdit.inlineCompletion
+            ));
+        });
+        this._register(this._instantiationService.createInstance(InlineEditsView, this._editor, this._inlineEdit, this._model, this._focusIsInMenu));
+    }
+};
+InlineEditsViewAndDiffProducer = InlineEditsViewAndDiffProducer_1 = ( __decorate([
+    ( __param(4, IInstantiationService))
+], InlineEditsViewAndDiffProducer));
+class InlineEditWithChanges {
+    constructor(originalText, edit, isCollapsed, cursorPosition, userJumpedToIt, commands, inlineCompletion) {
+        this.originalText = originalText;
+        this.edit = edit;
+        this.isCollapsed = isCollapsed;
+        this.cursorPosition = cursorPosition;
+        this.userJumpedToIt = userJumpedToIt;
+        this.commands = commands;
+        this.inlineCompletion = inlineCompletion;
+        this.lineEdit = SingleLineEdit.fromSingleTextEdit(this.edit.toSingle(this.originalText), this.originalText);
+        this.originalLineRange = this.lineEdit.lineRange;
+        this.modifiedLineRange = this.lineEdit.toLineEdit().getNewLineRanges()[0];
+    }
+    equals(other) {
+        return this.originalText.getValue() === other.originalText.getValue() &&
+            this.edit.equals(other.edit) &&
+            this.isCollapsed === other.isCollapsed &&
+            this.cursorPosition.equals(other.cursorPosition) &&
+            this.userJumpedToIt === other.userJumpedToIt &&
+            this.commands === other.commands &&
+            this.inlineCompletion === other.inlineCompletion;
+    }
+}
+
+export { InlineEditWithChanges, InlineEditsViewAndDiffProducer };

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/view/inlineEdits/wordReplacementView.d.ts

@@ -0,0 +1,58 @@
+import { Disposable } from "../../../../../../base/common/lifecycle.js";
+import { ObservableCodeEditor } from "../../../../../browser/observableCodeEditor.js";
+import { SingleTextEdit } from "../../../../../common/core/textEdit.js";
+import { ILanguageService } from "../../../../../common/languages/language.js";
+import { IInlineEditsView } from "./sideBySideDiff.js";
+import { Range } from "../../../../../common/core/range.js";
+import { LineRange } from "../../../../../common/core/lineRange.js";
+export declare const transparentHoverBackground: string;
+export declare class WordReplacementView extends Disposable implements IInlineEditsView {
+    private readonly _editor;
+    private readonly _edit;
+    private readonly _innerEdits;
+    private readonly _languageService;
+    static MAX_LENGTH: number;
+    private readonly _start;
+    private readonly _end;
+    private readonly _line;
+    private readonly _text;
+    private readonly _editLocations;
+    private readonly _layout;
+    private readonly _div;
+    readonly isHovered: import("../../../../../../base/common/observable.js").IObservable<boolean>;
+    constructor(_editor: ObservableCodeEditor, _edit: SingleTextEdit, _innerEdits: SingleTextEdit[], _languageService: ILanguageService);
+}
+export declare class LineReplacementView extends Disposable implements IInlineEditsView {
+    private readonly _editor;
+    private readonly _originalRange;
+    private readonly _modifiedRange;
+    private readonly _modifiedLines;
+    private readonly _replacements;
+    private readonly _languageService;
+    private readonly _originalBubblesDecorationCollection;
+    private readonly _originalBubblesDecorationOptions;
+    private readonly _maxPrefixTrim;
+    private readonly _modifiedLineElements;
+    private readonly _viewZoneInfo;
+    private readonly _layout;
+    private _previousViewZoneInfo;
+    protected readonly _viewZone: import("../../../../../../base/common/observable.js").IObservable<void>;
+    private removePreviousViewZone;
+    private addViewZone;
+    private readonly _div;
+    readonly isHovered: import("../../../../../../base/common/observable.js").IObservable<boolean>;
+    constructor(_editor: ObservableCodeEditor, _originalRange: LineRange, _modifiedRange: LineRange, _modifiedLines: string[], _replacements: readonly Replacement[], _languageService: ILanguageService);
+}
+export interface Replacement {
+    originalRange: Range;
+    modifiedRange: Range;
+}
+export declare class WordInsertView extends Disposable implements IInlineEditsView {
+    private readonly _editor;
+    private readonly _edit;
+    private readonly _start;
+    private readonly _layout;
+    private readonly _div;
+    readonly isHovered: import("../../../../../../base/common/observable.js").IObservable<boolean>;
+    constructor(_editor: ObservableCodeEditor, _edit: SingleTextEdit);
+}