@codingame/monaco-vscode-api 15.0.2 → 16.0.0

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

@@ -2,10 +2,9 @@ import { Disposable } from "../../../../../../base/common/lifecycle.js";
 import { IObservable, ISettableObservable } from "../../../../../../base/common/observable.js";
 import { IInstantiationService } from "../../../../../../platform/instantiation/common/instantiation.js";
 import { ICodeEditor } from "../../../../../browser/editorBrowser.js";
-import { InlineCompletionsModel } from "../../model/inlineCompletionsModel.js";
 import { InlineEditsGutterIndicator } from "./components/gutterIndicatorView.js";
-import { InlineEditsIndicator } from "./components/indicatorView.js";
-import { InlineEditWithChanges } from "./inlineEditWithChanges.js";
+import { GhostTextIndicator, InlineEditHost, InlineEditModel } from "./inlineEditsModel.js";
+import { InlineEditsCollapsedView } from "./inlineEditsViews/inlineEditsCollapsedView.js";
 import { InlineEditsDeletionView } from "./inlineEditsViews/inlineEditsDeletionView.js";
 import { InlineEditsInsertionView } from "./inlineEditsViews/inlineEditsInsertionView.js";
 import { InlineEditsLineReplacementView } from "./inlineEditsViews/inlineEditsLineReplacementView.js";
@@ -13,35 +12,35 @@ import { InlineEditsWordReplacementView } from "./inlineEditsViews/inlineEditsWo
 import { OriginalEditorInlineDiffView } from "./inlineEditsViews/originalEditorInlineDiffView.js";
 export declare class InlineEditsView extends Disposable {
     private readonly _editor;
-    private readonly _edit;
+    private readonly _host;
     private readonly _model;
+    private readonly _ghostTextIndicator;
     private readonly _focusIsInMenu;
     private readonly _instantiationService;
     private readonly _editorObs;
-    private readonly _useMixedLinesDiff;
-    private readonly _useInterleavedLinesDiff;
     private readonly _useCodeShifting;
     private readonly _renderSideBySide;
-    private readonly _showCollapsed;
     private readonly _useMultiLineGhostText;
+    private readonly _tabAction;
     private _previousView;
-    constructor(_editor: ICodeEditor, _edit: IObservable<InlineEditWithChanges | undefined>, _model: IObservable<InlineCompletionsModel | undefined>, _focusIsInMenu: ISettableObservable<boolean>, _instantiationService: IInstantiationService);
+    constructor(_editor: ICodeEditor, _host: IObservable<InlineEditHost | undefined>, _model: IObservable<InlineEditModel | undefined>, _ghostTextIndicator: IObservable<GhostTextIndicator | undefined>, _focusIsInMenu: ISettableObservable<boolean>, _instantiationService: IInstantiationService);
+    private readonly _constructorDone;
     private readonly _uiState;
     private readonly _previewTextModel;
-    private readonly _host;
-    private readonly _useGutterIndicator;
     private readonly _indicatorCyclicDependencyCircuitBreaker;
-    protected readonly _indicator: IObservable<InlineEditsGutterIndicator | InlineEditsIndicator | undefined>;
+    protected readonly _indicator: IObservable<InlineEditsGutterIndicator | undefined>;
     private readonly _inlineEditsIsHovered;
     private readonly _gutterIndicatorOffset;
     private readonly _sideBySide;
     protected readonly _deletion: InlineEditsDeletionView;
     protected readonly _insertion: InlineEditsInsertionView;
     private readonly _inlineDiffViewState;
+    protected readonly _inlineCollapsedView: InlineEditsCollapsedView;
     protected readonly _inlineDiffView: OriginalEditorInlineDiffView;
     protected readonly _wordReplacementViews: IObservable<readonly InlineEditsWordReplacementView[]>;
     protected readonly _lineReplacementView: InlineEditsLineReplacementView;
     private getCacheId;
     private determineView;
     private determineRenderState;
+    private _viewHasBeenShownLongerThan;
 }

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

@@ -1,10 +1,10 @@
 
 import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
 import { equalsIfDefined, itemEquals } from '../../../../../../base/common/equals.js';
+import { BugIndicatingError } from '../../../../../../base/common/errors.js';
 import { Event } from '../../../../../../base/common/event.js';
 import { Disposable } from '../../../../../../base/common/lifecycle.js';
 import '../../../../../../base/common/observableInternal/index.js';
-import { localize } from '../../../../../../nls.js';
 import { IInstantiationService } from '../../../../../../platform/instantiation/common/instantiation.js';
 import { observableCodeEditor } from '../../../../../browser/observableCodeEditor.js';
 import { EditorOption } from '../../../../../common/config/editorOptions.js';
@@ -15,118 +15,82 @@ import { TextLength } from '../../../../../common/core/textLength.js';
 import { RangeMapping, lineRangeMappingFromRangeMappings } from '../../../../../common/diff/rangeMapping.js';
 import { TextModel } from '../../../../../common/model/textModel.js';
 import { InlineEditsGutterIndicator } from './components/gutterIndicatorView.js';
-import { InlineEditsIndicator } from './components/indicatorView.js';
+import { InlineEditTabAction } from './inlineEditsViewInterface.js';
+import { InlineEditsCollapsedView } from './inlineEditsViews/inlineEditsCollapsedView.js';
 import { InlineEditsDeletionView } from './inlineEditsViews/inlineEditsDeletionView.js';
 import { InlineEditsInsertionView } from './inlineEditsViews/inlineEditsInsertionView.js';
 import { InlineEditsLineReplacementView } from './inlineEditsViews/inlineEditsLineReplacementView.js';
 import { InlineEditsSideBySideView } from './inlineEditsViews/inlineEditsSideBySideView.js';
 import { InlineEditsWordReplacementView } from './inlineEditsViews/inlineEditsWordReplacementView.js';
 import { OriginalEditorInlineDiffView } from './inlineEditsViews/originalEditorInlineDiffView.js';
-import { createReindentEdit, applyEditToModifiedRangeMappings, InlineEditTabAction } from './utils/utils.js';
-import './view.css.js';
-import { derivedObservableWithCache, mapObservableArrayCached } from '../../../../../../base/common/observableInternal/utils.js';
+import { createReindentEdit, applyEditToModifiedRangeMappings } from './utils/utils.js';
+import './view.css';
+import { mapObservableArrayCached } from '../../../../../../base/common/observableInternal/utils.js';
 import { derived, derivedWithStore, derivedOpts } from '../../../../../../base/common/observableInternal/derived.js';
 import { observableValue } from '../../../../../../base/common/observableInternal/base.js';
 import { autorunWithStore } from '../../../../../../base/common/observableInternal/autorun.js';
 
 let InlineEditsView = class InlineEditsView extends Disposable {
-    constructor(_editor, _edit, _model, _focusIsInMenu, _instantiationService) {
+    constructor(_editor, _host, _model, _ghostTextIndicator, _focusIsInMenu, _instantiationService) {
         super();
         this._editor = _editor;
-        this._edit = _edit;
+        this._host = _host;
         this._model = _model;
+        this._ghostTextIndicator = _ghostTextIndicator;
         this._focusIsInMenu = _focusIsInMenu;
         this._instantiationService = _instantiationService;
         this._editorObs = observableCodeEditor(this._editor);
-        this._useMixedLinesDiff = ( this._editorObs.getOption(EditorOption.inlineSuggest).map(s => s.edits.useMixedLinesDiff));
-        this._useInterleavedLinesDiff = ( this._editorObs.getOption(EditorOption.inlineSuggest).map(s => s.edits.useInterleavedLinesDiff));
-        this._useCodeShifting = ( this._editorObs.getOption(EditorOption.inlineSuggest).map(s => s.edits.codeShifting));
-        this._renderSideBySide = ( this._editorObs.getOption(EditorOption.inlineSuggest).map(s => s.edits.renderSideBySide));
-        this._showCollapsed = ( this._editorObs.getOption(EditorOption.inlineSuggest).map(s => s.edits.showCollapsed));
-        this._useMultiLineGhostText = ( this._editorObs.getOption(EditorOption.inlineSuggest).map(s => s.edits.useMultiLineGhostText));
+        this._tabAction = derived(reader => this._model.read(reader)?.tabAction.read(reader) ?? InlineEditTabAction.Inactive);
+        this._constructorDone = observableValue(this, false);
         this._uiState = derived(this, reader => {
-            const edit = this._edit.read(reader);
-            if (!edit) {
+            const model = this._model.read(reader);
+            if (!model || !this._constructorDone.read(reader)) {
                 return undefined;
             }
-            this._model.get()?.handleInlineEditShown(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 originalDisplayRange = edit.originalText.lineRange.intersect(edit.originalLineRange.join(LineRange.ofLength(edit.originalLineRange.startLineNumber, edit.lineEdit.newLines.length)));
-            let state = this.determineRenderState(edit, reader, diff, ( new StringText(newText)), originalDisplayRange);
+            model.handleInlineEditShown();
+            const inlineEdit = model.inlineEdit;
+            let mappings = RangeMapping.fromEdit(inlineEdit.edit);
+            let newText = inlineEdit.edit.apply(inlineEdit.originalText);
+            let diff = lineRangeMappingFromRangeMappings(mappings, inlineEdit.originalText, ( new StringText(newText)));
+            const originalDisplayRange = inlineEdit.originalText.lineRange.intersect(inlineEdit.originalLineRange.join(LineRange.ofLength(inlineEdit.originalLineRange.startLineNumber, inlineEdit.lineEdit.newLines.length)));
+            let state = this.determineRenderState(model, reader, diff, ( new StringText(newText)), originalDisplayRange);
             if (!state) {
-                this._model.get()?.stop();
+                model.abort(`unable to determine view: tried to render ${this._previousView?.view}`);
                 return undefined;
             }
             if (state.kind === 'sideBySide') {
-                const indentationAdjustmentEdit = createReindentEdit(newText, edit.modifiedLineRange);
+                const indentationAdjustmentEdit = createReindentEdit(newText, inlineEdit.modifiedLineRange);
                 newText = indentationAdjustmentEdit.applyToString(newText);
                 mappings = applyEditToModifiedRangeMappings(mappings, indentationAdjustmentEdit);
-                diff = lineRangeMappingFromRangeMappings(mappings, edit.originalText, ( new StringText(newText)));
+                diff = lineRangeMappingFromRangeMappings(mappings, inlineEdit.originalText, ( new StringText(newText)));
             }
             this._previewTextModel.setLanguage(this._editor.getModel().getLanguageId());
             const previousNewText = this._previewTextModel.getValue();
             if (previousNewText !== newText) {
                 this._previewTextModel.setValue(newText);
             }
-            if (this._showCollapsed.read(reader) && this._host.tabAction.read(reader) !== InlineEditTabAction.Accept && !this._indicator.read(reader)?.isHoverVisible.read(reader) && !this._model.get().inAcceptFlow.read(reader)) {
-                state = { kind: 'hidden' };
+            if (model.showCollapsed.read(reader) && !this._indicator.read(reader)?.isHoverVisible.read(reader)) {
+                state = { kind: 'collapsed' };
             }
             return {
                 state,
                 diff,
-                edit,
+                edit: inlineEdit,
                 newText,
-                newTextLineCount: edit.modifiedLineRange.length,
+                newTextLineCount: inlineEdit.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._host = {
-            displayName: derivedObservableWithCache(this, (reader, previousDisplayName) => {
-                const state = this._model.read(reader)?.inlineEditState;
-                const item = state?.read(reader);
-                const completionSource = item?.inlineCompletion?.source;
-                return completionSource?.inlineCompletions?.edits?.[0]?.provider?.displayName ?? previousDisplayName
-                    ?? completionSource?.provider.displayName ?? ( localize(1252, "Inline Edit"));
-            }),
-            tabAction: derived(this, reader => {
-                const m = this._model.read(reader);
-                if (this._editorObs.isFocused.read(reader)) {
-                    if (m && m.tabShouldJumpToInlineEdit.read(reader)) {
-                        return InlineEditTabAction.Jump;
-                    }
-                    if (m && m.tabShouldAcceptInlineEdit.read(reader)) {
-                        return InlineEditTabAction.Accept;
-                    }
-                    if (m && m.inlineCompletionState.read(reader)?.inlineCompletion?.sourceInlineCompletion.showInlineEditMenu) {
-                        return InlineEditTabAction.Accept;
-                    }
-                }
-                return InlineEditTabAction.Inactive;
-            }),
-            action: ( this._model.map((m, r) => m?.state.read(r)?.inlineCompletion?.inlineCompletion.action)),
-            extensionCommands: ( this._model.map(
-                (m, r) => m?.state.read(r)?.inlineCompletion?.source.inlineCompletions.commands ?? []
-            )),
-            accept: () => {
-                this._model.get()?.accept();
-            },
-            jump: () => {
-                this._model.get()?.jump();
-            }
-        };
-        this._useGutterIndicator = ( observableCodeEditor(this._editor).getOption(EditorOption.inlineSuggest).map(s => s.edits.useGutterIndicator));
         this._indicatorCyclicDependencyCircuitBreaker = observableValue(this, false);
         this._indicator = derivedWithStore(this, (reader, store) => {
             if (!this._indicatorCyclicDependencyCircuitBreaker.read(reader)) {
                 return undefined;
             }
             const indicatorDisplayRange = derivedOpts({ owner: this, equalsFn: equalsIfDefined(itemEquals()) }, reader => {
-                const s = this._model.read(reader)?.inlineCompletionState.read(reader);
-                if (s && s.inlineCompletion?.sourceInlineCompletion.showInlineEditMenu) {
-                    return LineRange.ofLength(s.primaryGhostText.lineNumber, 1);
+                const ghostTextIndicator = this._ghostTextIndicator.read(reader);
+                if (ghostTextIndicator) {
+                    return ghostTextIndicator.lineRange;
                 }
                 const state = this._uiState.read(reader);
                 if (state?.state?.kind === 'insertionMultiLine') {
@@ -134,20 +98,18 @@ let InlineEditsView = class InlineEditsView extends Disposable {
                 }
                 return state?.originalDisplayRange;
             });
-            if (this._useGutterIndicator.read(reader)) {
-                return store.add(this._instantiationService.createInstance(InlineEditsGutterIndicator, this._editorObs, indicatorDisplayRange, this._gutterIndicatorOffset, this._host, this._inlineEditsIsHovered, this._focusIsInMenu));
-            }
-            else {
-                return store.add(( new InlineEditsIndicator(this._editorObs, derived(reader => {
-                    const state = this._uiState.read(reader);
-                    const range = indicatorDisplayRange.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)));
-            }
+            const modelWithGhostTextSupport = derived(this, reader => {
+                const model = this._model.read(reader);
+                if (model) {
+                    return model;
+                }
+                const ghostTextIndicator = this._ghostTextIndicator.read(reader);
+                if (ghostTextIndicator) {
+                    return ghostTextIndicator.model;
+                }
+                return model;
+            });
+            return store.add(this._instantiationService.createInstance(InlineEditsGutterIndicator, this._editorObs, indicatorDisplayRange, this._gutterIndicatorOffset, this._host, modelWithGhostTextSupport, this._inlineEditsIsHovered, this._focusIsInMenu));
         });
         this._inlineEditsIsHovered = derived(this, reader => {
             return this._sideBySide.isHovered.read(reader)
@@ -163,26 +125,25 @@ let InlineEditsView = class InlineEditsView extends Disposable {
             }
             return 0;
         });
-        this._sideBySide = this._register(this._instantiationService.createInstance(InlineEditsSideBySideView, this._editor, this._edit, this._previewTextModel, ( this._uiState.map(s => s && s.state?.kind === 'sideBySide' ? ({
-            edit: s.edit,
+        this._sideBySide = this._register(this._instantiationService.createInstance(InlineEditsSideBySideView, this._editor, ( this._model.map(m => m?.inlineEdit)), this._previewTextModel, ( this._uiState.map(s => s && s.state?.kind === 'sideBySide' ? ({
             newTextLineCount: s.newTextLineCount,
             originalDisplayRange: s.originalDisplayRange,
-        }) : undefined)), this._host));
-        this._deletion = this._register(this._instantiationService.createInstance(InlineEditsDeletionView, this._editor, this._edit, ( this._uiState.map(s => s && s.state?.kind === 'deletion' ? ({
+        }) : undefined)), this._tabAction));
+        this._deletion = this._register(this._instantiationService.createInstance(InlineEditsDeletionView, this._editor, ( this._model.map(m => m?.inlineEdit)), ( this._uiState.map(s => s && s.state?.kind === 'deletion' ? ({
             originalRange: s.state.originalRange,
             deletions: s.state.deletions,
-        }) : undefined)), this._host));
+        }) : undefined)), this._tabAction));
         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._host));
+        }) : undefined)), this._tabAction));
         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' || e.state.kind === 'hidden') {
+            if (e.state.kind === 'wordReplacements' || e.state.kind === 'lineReplacement' || e.state.kind === 'insertionMultiLine' || e.state.kind === 'collapsed') {
                 return undefined;
             }
             return {
@@ -192,100 +153,104 @@ let InlineEditsView = class InlineEditsView extends Disposable {
                 modifiedCodeEditor: this._sideBySide.previewEditor,
             };
         });
+        this._inlineCollapsedView = this._register(this._instantiationService.createInstance(InlineEditsCollapsedView, this._editor, ( this._model.map(
+            (m, reader) => this._uiState.read(reader)?.state?.kind === 'collapsed' ? m?.inlineEdit : undefined
+        ))));
         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(InlineEditsWordReplacementView, this._editorObs, e, [e], this._host));
+            return store.add(this._instantiationService.createInstance(InlineEditsWordReplacementView, this._editorObs, e, this._tabAction));
         });
         this._lineReplacementView = this._register(this._instantiationService.createInstance(InlineEditsLineReplacementView, this._editorObs, ( this._uiState.map(s => s?.state?.kind === 'lineReplacement' ? ({
             originalRange: s.state.originalRange,
             modifiedRange: s.state.modifiedRange,
             modifiedLines: s.state.modifiedLines,
             replacements: s.state.replacements,
-        }) : undefined)), this._host));
+        }) : undefined)), this._tabAction));
+        this._useCodeShifting = ( this._editorObs.getOption(EditorOption.inlineSuggest).map(s => s.edits.allowCodeShifting));
+        this._renderSideBySide = ( this._editorObs.getOption(EditorOption.inlineSuggest).map(s => s.edits.renderSideBySide));
+        this._useMultiLineGhostText = ( this._editorObs.getOption(EditorOption.inlineSuggest).map(s => s.edits.useMultiLineGhostText));
         this._register(autorunWithStore((reader, store) => {
+            const model = this._model.read(reader);
+            if (!model) {
+                return;
+            }
             store.add(Event.any(this._sideBySide.onDidClick, this._deletion.onDidClick, this._lineReplacementView.onDidClick, this._insertion.onDidClick, ...( this._wordReplacementViews.read(reader).map(w => w.onDidClick)), this._inlineDiffView.onDidClick)(e => {
-                e.preventDefault();
-                this._host.accept();
+                if (this._viewHasBeenShownLongerThan(350)) {
+                    e.preventDefault();
+                    model.accept();
+                }
             }));
         }));
         this._indicator.recomputeInitiallyAndOnChange(this._store);
         this._wordReplacementViews.recomputeInitiallyAndOnChange(this._store);
         this._indicatorCyclicDependencyCircuitBreaker.set(true, undefined);
+        this._constructorDone.set(true, undefined);
     }
-    getCacheId(edit) {
-        if (this._model.get()?.inAcceptPartialFlow.get()) {
-            return `${edit.inlineCompletion.id}_${( edit.edit.edits.map(edit => ( edit.range.toString()) + edit.text)).join(',')}`;
+    getCacheId(model) {
+        const inlineEdit = model.inlineEdit;
+        if (this._host.get()?.inPartialAcceptFlow.get()) {
+            return `${inlineEdit.inlineCompletion.id}_${( inlineEdit.edit.edits.map(innerEdit => ( innerEdit.range.toString()) + innerEdit.text)).join(',')}`;
         }
-        return edit.inlineCompletion.id;
+        return inlineEdit.inlineCompletion.id;
     }
-    determineView(edit, reader, diff, newText, originalDisplayRange) {
-        const canUseCache = this._previousView?.id === this.getCacheId(edit);
-        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'));
+    determineView(model, reader, diff, newText, originalDisplayRange) {
+        const inlineEdit = model.inlineEdit;
+        const canUseCache = this._previousView?.id === this.getCacheId(model);
         const reconsiderViewEditorWidthChange = this._previousView?.editorWidth !== this._editorObs.layoutInfoWidth.read(reader) &&
             (this._previousView?.view === 'sideBySide' ||
                 this._previousView?.view === 'lineReplacement');
-        if (canUseCache && !reconsiderViewAfterJump && !reconsiderViewEditorWidthChange) {
+        if (canUseCache && !reconsiderViewEditorWidthChange) {
             return this._previousView.view;
         }
         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))) {
+        if (isSingleInnerEdit
+            && this._useCodeShifting.read(reader) !== 'never'
+            && isSingleLineInsertionAfterPosition(diff, inlineEdit.cursorPosition)) {
             return 'insertionInline';
         }
         const innerValues = ( inner.map(
-            m => ({ original: edit.originalText.getValueOfRange(m.originalRange), modified: newText.getValueOfRange(m.modifiedRange) })
+            m => ({ original: inlineEdit.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)) {
+        if (isSingleMultiLineInsertion(diff) && this._useMultiLineGhostText.read(reader) && this._useCodeShifting.read(reader) === 'always') {
             return 'insertionMultiLine';
         }
-        const numOriginalLines = edit.originalLineRange.length;
-        const numModifiedLines = edit.modifiedLineRange.length;
+        const numOriginalLines = inlineEdit.originalLineRange.length;
+        const numModifiedLines = inlineEdit.modifiedLineRange.length;
         const allInnerChangesNotTooLong = inner.every(m => TextLength.ofRange(m.originalRange).columnCount < InlineEditsWordReplacementView.MAX_LENGTH && TextLength.ofRange(m.modifiedRange).columnCount < InlineEditsWordReplacementView.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(
+                !( growEditsUntilWhitespace(( inner.map(m => ( new SingleTextEdit(m.originalRange, '')))), inlineEdit.originalText).some(
                     e => e.range.isEmpty() && TextLength.ofRange(e.range).columnCount < InlineEditsWordReplacementView.MAX_LENGTH
                 ))) {
                 return 'wordReplacements';
             }
         }
         if (numOriginalLines > 0 && numModifiedLines > 0) {
-            if (this._renderSideBySide.read(reader) !== 'never' && InlineEditsSideBySideView.fitsInsideViewport(this._editor, edit, originalDisplayRange, reader)) {
+            if (this._renderSideBySide.read(reader) !== 'never' && InlineEditsSideBySideView.fitsInsideViewport(this._editor, this._previewTextModel, inlineEdit, originalDisplayRange, 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, originalDisplayRange) {
-        const view = this.determineView(edit, reader, diff, newText, originalDisplayRange);
-        this._previousView = { id: this.getCacheId(edit), view, userJumpedToIt: edit.userJumpedToIt, editorWidth: this._editor.getLayoutInfo().width };
+    determineRenderState(model, reader, diff, newText, originalDisplayRange) {
+        const inlineEdit = model.inlineEdit;
+        const view = this.determineView(model, reader, diff, newText, originalDisplayRange);
+        this._previousView = { id: this.getCacheId(model), view, editorWidth: this._editor.getLayoutInfo().width, timestamp: Date.now() };
         switch (view) {
             case 'insertionInline': return { kind: 'insertionInline' };
-            case 'mixedLines': return { kind: 'mixedLines' };
-            case 'interleavedLines': return { kind: 'interleavedLines' };
             case 'sideBySide': return { kind: 'sideBySide' };
-            case 'hidden': return { kind: 'hidden' };
+            case 'collapsed': return { kind: 'collapsed' };
         }
         const inner = diff.flatMap(d => d.innerChanges ?? []);
         if (view === 'deletion') {
             return {
                 kind: 'deletion',
-                originalRange: edit.originalLineRange,
+                originalRange: inlineEdit.originalLineRange,
                 deletions: ( inner.map(m => m.originalRange)),
             };
         }
@@ -303,9 +268,9 @@ let InlineEditsView = class InlineEditsView extends Disposable {
             return undefined;
         }
         if (view === 'wordReplacements') {
-            let grownEdits = growEditsToEntireWord(replacements, edit.originalText);
+            let grownEdits = growEditsToEntireWord(replacements, inlineEdit.originalText);
             if (( grownEdits.some(e => e.range.isEmpty()))) {
-                grownEdits = growEditsUntilWhitespace(replacements, edit.originalText);
+                grownEdits = growEditsUntilWhitespace(replacements, inlineEdit.originalText);
             }
             return {
                 kind: 'wordReplacements',
@@ -315,17 +280,25 @@ let InlineEditsView = class InlineEditsView extends Disposable {
         if (view === 'lineReplacement') {
             return {
                 kind: 'lineReplacement',
-                originalRange: edit.originalLineRange,
-                modifiedRange: edit.modifiedLineRange,
-                modifiedLines: edit.modifiedLineRange.mapToLineArray(line => newText.getLineAt(line)),
+                originalRange: inlineEdit.originalLineRange,
+                modifiedRange: inlineEdit.modifiedLineRange,
+                modifiedLines: inlineEdit.modifiedLineRange.mapToLineArray(line => newText.getLineAt(line)),
                 replacements: ( inner.map(m => ({ originalRange: m.originalRange, modifiedRange: m.modifiedRange }))),
             };
         }
         return undefined;
     }
+    _viewHasBeenShownLongerThan(durationMs) {
+        const viewCreationTime = this._previousView?.timestamp;
+        if (!viewCreationTime) {
+            throw ( new BugIndicatingError('viewHasBeenShownLongThan called before a view has been shown'));
+        }
+        const currentTime = Date.now();
+        return (currentTime - viewCreationTime) >= durationMs;
+    }
 };
 InlineEditsView = ( __decorate([
-    ( __param(4, IInstantiationService))
+    ( __param(5, IInstantiationService))
 ], InlineEditsView));
 function isSingleLineInsertionAfterPosition(diff, position) {
     if (!position) {

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

@@ -2,16 +2,29 @@ import { IMouseEvent } from "../../../../../../base/browser/mouseEvent.js";
 import { Event } from "../../../../../../base/common/event.js";
 import { IObservable } from "../../../../../../base/common/observable.js";
 import { Command } from "../../../../../common/languages.js";
-import { InlineEditTabAction } from "./utils/utils.js";
+import { InlineEditWithChanges } from "./inlineEditWithChanges.js";
+export declare enum InlineEditTabAction {
+    Jump = "jump",
+    Accept = "accept",
+    Inactive = "inactive"
+}
 export interface IInlineEditsView {
     isHovered: IObservable<boolean>;
     onDidClick: Event<IMouseEvent>;
 }
-export interface IInlineEditsViewHost {
-    displayName: IObservable<string>;
-    action: IObservable<Command | undefined>;
+export interface IInlineEditHost {
+    inAcceptFlow: IObservable<boolean>;
+    inPartialAcceptFlow: IObservable<boolean>;
+}
+export interface IInlineEditModel {
+    displayName: string;
+    action: Command | undefined;
+    extensionCommands: Command[];
+    inlineEdit: InlineEditWithChanges;
     tabAction: IObservable<InlineEditTabAction>;
-    extensionCommands: IObservable<readonly Command[] | undefined>;
+    showCollapsed: IObservable<boolean>;
+    handleInlineEditShown(): void;
     accept(): void;
     jump(): void;
+    abort(reason: string): void;
 }

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

@@ -0,0 +1,10 @@
+
+
+var InlineEditTabAction;
+(function (InlineEditTabAction) {
+    InlineEditTabAction["Jump"] = "jump";
+    InlineEditTabAction["Accept"] = "accept";
+    InlineEditTabAction["Inactive"] = "inactive";
+})(InlineEditTabAction || (InlineEditTabAction = {}));
+
+export { InlineEditTabAction };

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

@@ -9,8 +9,11 @@ export declare class InlineEditsViewAndDiffProducer extends Disposable {
     private readonly _edit;
     private readonly _model;
     private readonly _focusIsInMenu;
-    private readonly _instantiationService;
     static readonly hot: IObservable<typeof InlineEditsViewAndDiffProducer>;
+    private readonly _editorObs;
     private readonly _inlineEdit;
-    constructor(_editor: ICodeEditor, _edit: IObservable<InlineEdit | undefined>, _model: IObservable<InlineCompletionsModel | undefined>, _focusIsInMenu: ISettableObservable<boolean>, _instantiationService: IInstantiationService);
+    private readonly _inlineEditModel;
+    private readonly _inlineEditHost;
+    private readonly _ghostTextIndicator;
+    constructor(_editor: ICodeEditor, _edit: IObservable<InlineEdit | undefined>, _model: IObservable<InlineCompletionsModel | undefined>, _focusIsInMenu: ISettableObservable<boolean>, instantiationService: IInstantiationService);
 }