@codingame/monaco-vscode-api 23.2.2 → 24.1.0

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

@@ -1,9 +1,9 @@
 
-import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { registerCss } from '../../../../../../../../../css.js';
 import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
 import { $ } from '../../../../../../base/browser/dom.js';
-import { equalsIfDefined, itemEquals } from '../../../../../../base/common/equals.js';
-import { onUnexpectedError, BugIndicatingError } from '../../../../../../base/common/errors.js';
+import { itemsEquals } from '../../../../../../base/common/equals.js';
+import { BugIndicatingError, onUnexpectedError } 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';
@@ -17,135 +17,139 @@ import { StringText } from '../../../../../common/core/text/abstractText.js';
 import { TextLength } from '../../../../../common/core/text/textLength.js';
 import { RangeMapping, lineRangeMappingFromRangeMappings } from '../../../../../common/diff/rangeMapping.js';
 import { TextModel } from '../../../../../common/model/textModel.js';
-import { InlineEditItem } from '../../model/inlineSuggestionItem.js';
-import { InlineEditsGutterIndicator } from './components/gutterIndicatorView.js';
-import { InlineEditsOnboardingExperience } from './inlineEditsNewUsers.js';
-import { InlineEditTabAction, InlineCompletionViewKind } from './inlineEditsViewInterface.js';
+import { InlineEditTabAction, InlineCompletionViewKind, InlineCompletionViewData } from './inlineEditsViewInterface.js';
 import { InlineEditsCollapsedView } from './inlineEditsViews/inlineEditsCollapsedView.js';
 import { InlineEditsCustomView } from './inlineEditsViews/inlineEditsCustomView.js';
 import { InlineEditsDeletionView } from './inlineEditsViews/inlineEditsDeletionView.js';
 import { InlineEditsInsertionView } from './inlineEditsViews/inlineEditsInsertionView.js';
 import { InlineEditsLineReplacementView } from './inlineEditsViews/inlineEditsLineReplacementView.js';
+import { InlineEditsLongDistanceHint } from './inlineEditsViews/longDistanceHint/inlineEditsLongDistanceHint.js';
 import { InlineEditsSideBySideView } from './inlineEditsViews/inlineEditsSideBySideView.js';
-import { InlineEditsWordReplacementView } from './inlineEditsViews/inlineEditsWordReplacementView.js';
+import { WordReplacementsViewData, InlineEditsWordReplacementView } from './inlineEditsViews/inlineEditsWordReplacementView.js';
 import { OriginalEditorInlineDiffView } from './inlineEditsViews/originalEditorInlineDiffView.js';
 import { createReindentEdit, applyEditToModifiedRangeMappings } from './utils/utils.js';
 import * as view from './view.css';
+import { JumpToView } from './inlineEditsViews/jumpToView.js';
+import { StringEdit } from '../../../../../common/core/edits/stringEdit.js';
+import { OffsetRange } from '../../../../../common/core/ranges/offsetRange.js';
+import { getPositionOffsetTransformerFromTextModel } from '../../../../../common/core/text/getPositionOffsetTransformerFromTextModel.js';
 import { derived, derivedOpts } from '../../../../../../base/common/observableInternal/observables/derived.js';
 import { observableValue } from '../../../../../../base/common/observableInternal/observables/observableValue.js';
 import { mapObservableArrayCached } from '../../../../../../base/common/observableInternal/utils/utils.js';
-import { autorunWithStore, autorun } from '../../../../../../base/common/observableInternal/reactions/autorun.js';
+import { autorun } from '../../../../../../base/common/observableInternal/reactions/autorun.js';
 
 registerCss(view);
 let InlineEditsView = class InlineEditsView extends Disposable {
-    constructor(_editor, _host, _model, _ghostTextIndicator, _focusIsInMenu, _instantiationService) {
+    constructor(_editor, _model, _simpleModel, _inlineSuggestInfo, _showCollapsed, _instantiationService) {
         super();
         this._editor = _editor;
-        this._host = _host;
         this._model = _model;
-        this._ghostTextIndicator = _ghostTextIndicator;
-        this._focusIsInMenu = _focusIsInMenu;
+        this._simpleModel = _simpleModel;
+        this._inlineSuggestInfo = _inlineSuggestInfo;
+        this._showCollapsed = _showCollapsed;
         this._instantiationService = _instantiationService;
-        this._editorObs = observableCodeEditor(this._editor);
         this._tabAction = derived(reader => this._model.read(reader)?.tabAction.read(reader) ?? InlineEditTabAction.Inactive);
-        this._constructorDone = observableValue(this, false);
+        this.displayRange = derived(this, reader => {
+            const state = this._uiState.read(reader);
+            if (!state) {
+                return undefined;
+            }
+            if (state.state?.kind === 'custom') {
+                const range = state.state.displayLocation?.range;
+                if (!range) {
+                    throw ( new BugIndicatingError('custom view should have a range'));
+                }
+                return ( new LineRange(range.startLineNumber, range.endLineNumber));
+            }
+            if (state.state?.kind === 'insertionMultiLine') {
+                return this._insertion.originalLines.read(reader);
+            }
+            return state.edit.displayRange;
+        });
+        this._currentInlineEditCache = undefined;
         this._uiState = derived(this, reader => {
             const model = this._model.read(reader);
-            if (!model || !this._constructorDone.read(reader)) {
+            const textModel = this._editorObs.model.read(reader);
+            if (!model || !textModel || !this._constructorDone.read(reader)) {
                 return undefined;
             }
             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)));
-            let state = this.determineRenderState(model, reader, diff, ( new StringText(newText)));
+            let diff;
+            let mappings;
+            let newText = undefined;
+            if (inlineEdit.edit) {
+                mappings = RangeMapping.fromEdit(inlineEdit.edit);
+                newText = ( new StringText(inlineEdit.edit.apply(inlineEdit.originalText)));
+                diff = lineRangeMappingFromRangeMappings(mappings, inlineEdit.originalText, newText);
+            }
+            else {
+                mappings = [];
+                diff = [];
+                newText = inlineEdit.originalText;
+            }
+            let state = this._determineRenderState(model, reader, diff, newText);
             if (!state) {
                 onUnexpectedError(( new Error(`unable to determine view: tried to render ${this._previousView?.view}`)));
                 return undefined;
             }
+            const longDistanceHint = this._getLongDistanceHintState(model, reader);
+            if (longDistanceHint && longDistanceHint.isVisible) {
+                state.viewData.setLongDistanceViewData(longDistanceHint.lineNumber, inlineEdit.lineEdit.lineRange.startLineNumber);
+            }
             if (state.kind === InlineCompletionViewKind.SideBySide) {
-                const indentationAdjustmentEdit = createReindentEdit(newText, inlineEdit.modifiedLineRange, textModel.getOptions().tabSize);
-                newText = indentationAdjustmentEdit.applyToString(newText);
+                const indentationAdjustmentEdit = createReindentEdit(newText.getValue(), inlineEdit.modifiedLineRange, textModel.getOptions().tabSize);
+                newText = ( new StringText(indentationAdjustmentEdit.applyToString(newText.getValue())));
                 mappings = applyEditToModifiedRangeMappings(mappings, indentationAdjustmentEdit);
-                diff = lineRangeMappingFromRangeMappings(mappings, inlineEdit.originalText, ( new StringText(newText)));
+                diff = lineRangeMappingFromRangeMappings(mappings, inlineEdit.originalText, newText);
+            }
+            const tm = this._editorObs.model.read(reader);
+            if (!tm) {
+                return undefined;
             }
-            this._previewTextModel.setLanguage(this._editor.getModel().getLanguageId());
+            this._previewTextModel.setLanguage(tm.getLanguageId());
             const previousNewText = this._previewTextModel.getValue();
-            if (previousNewText !== newText) {
-                this._previewTextModel.setValue(newText);
+            if (previousNewText !== newText.getValue()) {
+                this._previewTextModel.setEOL(tm.getEndOfLineSequence());
+                const updateOldValueEdit = StringEdit.replace(( new OffsetRange(0, previousNewText.length)), newText.getValue());
+                const updateOldValueEditSmall = updateOldValueEdit.removeCommonSuffixPrefix(previousNewText);
+                const textEdit = getPositionOffsetTransformerFromTextModel(this._previewTextModel).getTextEdit(updateOldValueEditSmall);
+                this._previewTextModel.edit(textEdit);
             }
-            if (model.showCollapsed.read(reader) && !this._indicator.read(reader)?.isHoverVisible.read(reader)) {
+            if (this._showCollapsed.read(reader)) {
                 state = { kind: InlineCompletionViewKind.Collapsed, viewData: state.viewData };
             }
-            model.handleInlineEditShown(state.kind, state.viewData);
+            model.handleInlineEditShownNextFrame(state.kind, state.viewData);
+            const nextCursorPosition = inlineEdit.action?.kind === 'jumpTo' ? inlineEdit.action.position : null;
             return {
                 state,
                 diff,
                 edit: inlineEdit,
-                newText,
+                newText: newText.getValue(),
                 newTextLineCount: inlineEdit.modifiedLineRange.length,
                 isInDiffEditor: model.isInDiffEditor,
+                longDistanceHint,
+                nextCursorPosition: nextCursorPosition,
             };
         });
-        this._previewTextModel = this._register(this._instantiationService.createInstance(TextModel, '', this._editor.getModel().getLanguageId(), { ...TextModel.DEFAULT_CREATION_OPTIONS, bracketPairColorizationOptions: { enabled: true, independentColorPoolPerBracketType: false } }, null));
-        this._indicatorCyclicDependencyCircuitBreaker = observableValue(this, false);
-        this._indicator = derived(this, (reader) => {
-            if (!this._indicatorCyclicDependencyCircuitBreaker.read(reader)) {
-                return undefined;
-            }
-            const indicatorDisplayRange = derivedOpts({ owner: this, equalsFn: equalsIfDefined(itemEquals()) }, reader => {
-                const ghostTextIndicator = this._ghostTextIndicator.read(reader);
-                if (ghostTextIndicator) {
-                    return ghostTextIndicator.lineRange;
-                }
-                const state = this._uiState.read(reader);
-                if (!state) {
-                    return undefined;
-                }
-                if (state.state?.kind === 'custom') {
-                    const range = state.state.displayLocation?.range;
-                    if (!range) {
-                        throw ( new BugIndicatingError('custom view should have a range'));
-                    }
-                    return ( new LineRange(range.startLineNumber, range.endLineNumber));
-                }
-                if (state.state?.kind === 'insertionMultiLine') {
-                    return this._insertion.originalLines.read(reader);
-                }
-                return state.edit.displayRange;
-            });
-            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 reader.store.add(this._instantiationService.createInstance(InlineEditsGutterIndicator, this._editorObs, indicatorDisplayRange, this._gutterIndicatorOffset, modelWithGhostTextSupport, this._inlineEditsIsHovered, this._focusIsInMenu));
-        });
-        this._inlineEditsIsHovered = derived(this, reader => {
+        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.isHovered.read(reader)
                 || this._insertion.isHovered.read(reader)
-                || this._customView.isHovered.read(reader);
+                || this._customView.isHovered.read(reader)
+                || ( this._longDistanceHint.map((v, r) => v?.isHovered.read(r) ?? false)).read(reader);
         });
-        this._gutterIndicatorOffset = derived(this, reader => {
+        this.gutterIndicatorOffset = derived(this, reader => {
             if (this._uiState.read(reader)?.state?.kind === 'insertionMultiLine') {
                 return this._insertion.startLineOffset.read(reader);
             }
-            const ghostTextIndicator = this._ghostTextIndicator.read(reader);
-            if (ghostTextIndicator) {
-                return getGhostTextTopOffset(ghostTextIndicator, this._editor);
-            }
             return 0;
         });
+        this._editorObs = observableCodeEditor(this._editor);
+        this._constructorDone = observableValue(this, false);
+        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(InlineEditsSideBySideView, this._editor, ( this._model.map(m => m?.inlineEdit)), this._previewTextModel, ( this._uiState.map(s => s && s.state?.kind === InlineCompletionViewKind.SideBySide ? ({
             newTextLineCount: s.newTextLineCount,
             isInDiffEditor: s.isInDiffEditor,
@@ -163,12 +167,33 @@ let InlineEditsView = class InlineEditsView extends Disposable {
                 inDiffEditor: s.isInDiffEditor,
             }) : undefined
         )), this._tabAction));
+        this._inlineCollapsedView = this._register(this._instantiationService.createInstance(InlineEditsCollapsedView, this._editor, ( this._model.map(
+            (m, reader) => this._uiState.read(reader)?.state?.kind === InlineCompletionViewKind.Collapsed ? m?.inlineEdit : undefined
+        ))));
+        this._customView = this._register(this._instantiationService.createInstance(InlineEditsCustomView, this._editor, ( this._model.map(
+            (m, reader) => this._uiState.read(reader)?.state?.kind === InlineCompletionViewKind.Custom ? m?.displayLocation : undefined
+        )), this._tabAction));
+        this._showLongDistanceHint = ( this._editorObs.getOption(EditorOption.inlineSuggest).map(this, s => s.edits.showLongDistanceHint));
+        this._longDistanceHint = derived(this, reader => {
+            if (!this._showLongDistanceHint.read(reader)) {
+                return undefined;
+            }
+            return reader.store.add(this._instantiationService.createInstance(InlineEditsLongDistanceHint, this._editor, ( this._uiState.map((s, reader) => s?.longDistanceHint ? ({
+                hint: s.longDistanceHint,
+                newTextLineCount: s.newTextLineCount,
+                edit: s.edit,
+                diff: s.diff,
+                model: this._simpleModel.read(reader),
+                inlineSuggestInfo: this._inlineSuggestInfo.read(reader),
+                nextCursorPosition: s.nextCursorPosition,
+            }) : undefined)), this._previewTextModel, this._tabAction));
+        }).recomputeInitiallyAndOnChange(this._store);
         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 === 'insertionMultiLine' || e.state.kind === 'collapsed' || e.state.kind === 'custom') {
+            if (e.state.kind === 'wordReplacements' || e.state.kind === 'insertionMultiLine' || e.state.kind === 'collapsed' || e.state.kind === 'custom' || e.state.kind === 'jumpTo') {
                 return undefined;
             }
             return {
@@ -179,15 +204,22 @@ let InlineEditsView = class InlineEditsView extends Disposable {
                 isInDiffEditor: e.isInDiffEditor,
             };
         });
-        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._customView = this._register(this._instantiationService.createInstance(InlineEditsCustomView, this._editor, ( this._model.map(
-            (m, reader) => this._uiState.read(reader)?.state?.kind === 'custom' ? m?.displayLocation : undefined
-        )), this._tabAction));
         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, this._tabAction));
+        this._jumpToView = this._register(this._instantiationService.createInstance(JumpToView, this._editorObs, { style: 'label' }, derived(reader => {
+            const s = this._uiState.read(reader);
+            if (s?.state?.kind === InlineCompletionViewKind.JumpTo) {
+                return { jumpToPosition: s.state.position };
+            }
+            return undefined;
+        })));
+        const wordReplacements = derivedOpts({
+            equalsFn: itemsEquals((a, b) => a.equals(b))
+        }, reader => {
+            const s = this._uiState.read(reader);
+            return s?.state?.kind === InlineCompletionViewKind.WordReplacements ? ( s.state.replacements.map(replacement => ( new WordReplacementsViewData(replacement, s.state?.alternativeAction)))) : [];
+        });
+        this._wordReplacementViews = mapObservableArrayCached(this, wordReplacements, (viewData, store) => {
+            return store.add(this._instantiationService.createInstance(InlineEditsWordReplacementView, this._editorObs, viewData, this._tabAction));
         });
         this._lineReplacementView = this._register(this._instantiationService.createInstance(InlineEditsLineReplacementView, this._editorObs, ( this._uiState.map(s => s?.state?.kind === InlineCompletionViewKind.LineReplacement ? ({
             originalRange: s.state.originalRange,
@@ -197,33 +229,33 @@ let InlineEditsView = class InlineEditsView extends Disposable {
         }) : undefined)), ( this._uiState.map(s => s?.isInDiffEditor ?? false)), 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._register(autorunWithStore((reader, store) => {
+        this._register(autorun((reader) => {
             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, this._customView.onDidClick)(e => {
+            reader.store.add(Event.any(this._sideBySide.onDidClick, this._lineReplacementView.onDidClick, this._insertion.onDidClick, ...( this._wordReplacementViews.read(reader).map(w => w.onDidClick)), this._inlineDiffView.onDidClick, this._customView.onDidClick)(clickEvent => {
                 if (this._viewHasBeenShownLongerThan(350)) {
-                    e.preventDefault();
-                    model.accept();
+                    clickEvent.event.preventDefault();
+                    model.accept(clickEvent.alternativeAction);
                 }
             }));
         }));
-        this._indicator.recomputeInitiallyAndOnChange(this._store);
         this._wordReplacementViews.recomputeInitiallyAndOnChange(this._store);
-        this._indicatorCyclicDependencyCircuitBreaker.set(true, undefined);
-        this._register(this._instantiationService.createInstance(InlineEditsOnboardingExperience, this._host, this._model, this._indicator, this._inlineCollapsedView));
         const minEditorScrollHeight = derived(this, reader => {
             return Math.max(...( this._wordReplacementViews.read(reader).map(v => v.minEditorScrollHeight.read(reader))), this._lineReplacementView.minEditorScrollHeight.read(reader), this._customView.minEditorScrollHeight.read(reader));
         }).recomputeInitiallyAndOnChange(this._store);
-        const textModel = this._editor.getModel();
         let viewZoneId;
         this._register(autorun(reader => {
             const minScrollHeight = minEditorScrollHeight.read(reader);
+            const textModel = this._editorObs.model.read(reader);
+            if (!textModel) {
+                return;
+            }
             this._editor.changeViewZones(accessor => {
                 const scrollHeight = this._editor.getScrollHeight();
                 const viewZoneHeight = minScrollHeight - scrollHeight + 1 ;
-                if (viewZoneHeight !== 0 && viewZoneId) {
+                if (viewZoneHeight !== 0 && viewZoneId !== undefined) {
                     accessor.removeZone(viewZoneId);
                     viewZoneId = undefined;
                 }
@@ -239,19 +271,42 @@ let InlineEditsView = class InlineEditsView extends Disposable {
         }));
         this._constructorDone.set(true, undefined);
     }
-    getCacheId(model) {
+    _getLongDistanceHintState(model, reader) {
+        if (model.inlineEdit.inlineCompletion.identity.jumpedTo.read(reader)) {
+            return undefined;
+        }
+        if (model.inlineEdit.action === undefined) {
+            return undefined;
+        }
+        if (this._currentInlineEditCache?.inlineSuggestionIdentity !== model.inlineEdit.inlineCompletion.identity) {
+            this._currentInlineEditCache = {
+                inlineSuggestionIdentity: model.inlineEdit.inlineCompletion.identity,
+                firstCursorLineNumber: model.inlineEdit.cursorPosition.lineNumber,
+            };
+        }
+        return {
+            lineNumber: this._currentInlineEditCache.firstCursorLineNumber,
+            isVisible: !model.inViewPort.read(reader),
+        };
+    }
+    _getCacheId(model) {
         return model.inlineEdit.inlineCompletion.identity.id;
     }
-    determineView(model, reader, diff, newText) {
+    _determineView(model, reader, diff, newText) {
         const inlineEdit = model.inlineEdit;
-        const canUseCache = this._previousView?.id === this.getCacheId(model) && !model.displayLocation?.jumpToEdit;
+        const canUseCache = this._previousView?.id === this._getCacheId(model);
         const reconsiderViewEditorWidthChange = this._previousView?.editorWidth !== this._editorObs.layoutInfoWidth.read(reader) &&
             (this._previousView?.view === InlineCompletionViewKind.SideBySide ||
                 this._previousView?.view === InlineCompletionViewKind.LineReplacement);
         if (canUseCache && !reconsiderViewEditorWidthChange) {
             return this._previousView.view;
         }
-        if (model.inlineEdit.inlineCompletion instanceof InlineEditItem && model.inlineEdit.inlineCompletion.uri) {
+        const action = model.inlineEdit.inlineCompletion.action;
+        if (action?.kind === 'edit' && action.alternativeAction) {
+            return InlineCompletionViewKind.WordReplacements;
+        }
+        const uri = action?.kind === 'edit' ? action.uri : undefined;
+        if (uri !== undefined) {
             return InlineCompletionViewKind.Custom;
         }
         if (model.displayLocation && !model.inlineEdit.inlineCompletion.identity.jumpedTo.read(reader)) {
@@ -309,9 +364,16 @@ let InlineEditsView = class InlineEditsView extends Disposable {
         }
         return InlineCompletionViewKind.SideBySide;
     }
-    determineRenderState(model, reader, diff, newText) {
+    _determineRenderState(model, reader, diff, newText) {
+        if (model.inlineEdit.action?.kind === 'jumpTo') {
+            return {
+                kind: InlineCompletionViewKind.JumpTo,
+                position: model.inlineEdit.action.position,
+                viewData: emptyViewData,
+            };
+        }
         const inlineEdit = model.inlineEdit;
-        let view = this.determineView(model, reader, diff, newText);
+        let view = this._determineView(model, reader, diff, newText);
         if (this._willRenderAboveCursor(reader, inlineEdit, view)) {
             switch (view) {
                 case InlineCompletionViewKind.LineReplacement:
@@ -320,7 +382,7 @@ let InlineEditsView = class InlineEditsView extends Disposable {
                     break;
             }
         }
-        this._previousView = { id: this.getCacheId(model), view, editorWidth: this._editor.getLayoutInfo().width, timestamp: Date.now() };
+        this._previousView = { id: this._getCacheId(model), view, editorWidth: this._editor.getLayoutInfo().width, timestamp: Date.now() };
         const inner = diff.flatMap(d => d.innerChanges ?? []);
         const textModel = this._editor.getModel();
         const stringChanges = ( inner.map(m => ({
@@ -329,18 +391,7 @@ let InlineEditsView = class InlineEditsView extends Disposable {
             original: textModel.getValueInRange(m.originalRange),
             modified: newText.getValueOfRange(m.modifiedRange)
         })));
-        const cursorPosition = inlineEdit.cursorPosition;
-        const startsWithEOL = stringChanges.length === 0 ? false : stringChanges[0].modified.startsWith(textModel.getEOL());
-        const viewData = {
-            cursorColumnDistance: inlineEdit.edit.replacements.length === 0 ? 0 : inlineEdit.edit.replacements[0].range.getStartPosition().column - cursorPosition.column,
-            cursorLineDistance: inlineEdit.lineEdit.lineRange.startLineNumber - cursorPosition.lineNumber + (startsWithEOL && inlineEdit.lineEdit.lineRange.startLineNumber >= cursorPosition.lineNumber ? 1 : 0),
-            lineCountOriginal: inlineEdit.lineEdit.lineRange.length,
-            lineCountModified: inlineEdit.lineEdit.newLines.length,
-            characterCountOriginal: stringChanges.reduce((acc, r) => acc + r.original.length, 0),
-            characterCountModified: stringChanges.reduce((acc, r) => acc + r.modified.length, 0),
-            disjointReplacements: stringChanges.length,
-            sameShapeReplacements: stringChanges.every(r => r.original === stringChanges[0].original && r.modified === stringChanges[0].modified),
-        };
+        const viewData = getViewData(inlineEdit, stringChanges, textModel);
         switch (view) {
             case InlineCompletionViewKind.InsertionInline: return { kind: InlineCompletionViewKind.InsertionInline, viewData };
             case InlineCompletionViewKind.SideBySide: return { kind: InlineCompletionViewKind.SideBySide, viewData };
@@ -377,6 +428,7 @@ let InlineEditsView = class InlineEditsView extends Disposable {
             return {
                 kind: InlineCompletionViewKind.WordReplacements,
                 replacements: grownEdits,
+                alternativeAction: model.inlineEdit.action?.alternativeAction,
                 viewData,
             };
         }
@@ -422,6 +474,25 @@ let InlineEditsView = class InlineEditsView extends Disposable {
 InlineEditsView = ( __decorate([
     ( __param(5, IInstantiationService))
 ], InlineEditsView));
+const emptyViewData = ( new InlineCompletionViewData(-1, -1, -1, -1, -1, -1, -1, true));
+function getViewData(inlineEdit, stringChanges, textModel) {
+    if (!inlineEdit.edit) {
+        return emptyViewData;
+    }
+    const cursorPosition = inlineEdit.cursorPosition;
+    const startsWithEOL = stringChanges.length === 0 ? false : stringChanges[0].modified.startsWith(textModel.getEOL());
+    const viewData = ( new InlineCompletionViewData(
+        inlineEdit.edit.replacements.length === 0 ? 0 : inlineEdit.edit.replacements[0].range.getStartPosition().column - cursorPosition.column,
+        inlineEdit.lineEdit.lineRange.startLineNumber - cursorPosition.lineNumber + (startsWithEOL && inlineEdit.lineEdit.lineRange.startLineNumber >= cursorPosition.lineNumber ? 1 : 0),
+        inlineEdit.lineEdit.lineRange.length,
+        inlineEdit.lineEdit.newLines.length,
+        stringChanges.reduce((acc, r) => acc + r.original.length, 0),
+        stringChanges.reduce((acc, r) => acc + r.modified.length, 0),
+        stringChanges.length,
+        stringChanges.every(r => r.original === stringChanges[0].original && r.modified === stringChanges[0].modified)
+    ));
+    return viewData;
+}
 function isSingleLineInsertion(diff) {
     return diff.every(m => m.innerChanges.every(r => isWordInsertion(r)));
     function isWordInsertion(r) {
@@ -522,34 +593,5 @@ function _growEdits(replacements, originalText, fn) {
     }
     return result;
 }
-function getGhostTextTopOffset(ghostTextIndicator, editor) {
-    const replacements = ghostTextIndicator.model.inlineEdit.edit.replacements;
-    if (replacements.length !== 1) {
-        return 0;
-    }
-    const textModel = editor.getModel();
-    if (!textModel) {
-        return 0;
-    }
-    const EOL = textModel.getEOL();
-    const replacement = replacements[0];
-    if (replacement.range.isEmpty() && replacement.text.startsWith(EOL)) {
-        const lineHeight = editor.getLineHeightForPosition(replacement.range.getStartPosition());
-        return countPrefixRepeats(replacement.text, EOL) * lineHeight;
-    }
-    return 0;
-}
-function countPrefixRepeats(str, prefix) {
-    if (!prefix.length) {
-        return 0;
-    }
-    let count = 0;
-    let i = 0;
-    while (str.startsWith(prefix, i)) {
-        count++;
-        i += prefix.length;
-    }
-    return count;
-}
 
 export { InlineEditsView };

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

@@ -1,35 +1,21 @@
 import { IMouseEvent } from "../../../../../../base/browser/mouseEvent.js";
 import { Event } from "../../../../../../base/common/event.js";
 import { IObservable } from "../../../../../../base/common/observable.js";
-import { Command, InlineCompletionCommand } from "../../../../../common/languages.js";
-import { InlineSuggestHint } from "../../model/inlineSuggestionItem.js";
-import { InlineEditWithChanges } from "./inlineEditWithChanges.js";
 export declare enum InlineEditTabAction {
     Jump = "jump",
     Accept = "accept",
     Inactive = "inactive"
 }
+export declare class InlineEditClickEvent {
+    readonly event: IMouseEvent;
+    readonly alternativeAction: boolean;
+    static create(event: PointerEvent | MouseEvent, alternativeAction?: boolean): InlineEditClickEvent;
+    constructor(event: IMouseEvent, alternativeAction?: boolean);
+}
 export interface IInlineEditsView {
     isHovered: IObservable<boolean>;
     minEditorScrollHeight?: IObservable<number>;
-    readonly onDidClick: Event<IMouseEvent>;
-}
-export interface IInlineEditHost {
-    readonly onDidAccept: Event<void>;
-    inAcceptFlow: IObservable<boolean>;
-}
-export interface IInlineEditModel {
-    displayName: string;
-    action: Command | undefined;
-    extensionCommands: InlineCompletionCommand[];
-    isInDiffEditor: boolean;
-    inlineEdit: InlineEditWithChanges;
-    tabAction: IObservable<InlineEditTabAction>;
-    showCollapsed: IObservable<boolean>;
-    displayLocation: InlineSuggestHint | undefined;
-    handleInlineEditShown(viewKind: string, viewData?: InlineCompletionViewData): void;
-    accept(): void;
-    jump(): void;
+    readonly onDidClick: Event<InlineEditClickEvent>;
 }
 export declare enum InlineCompletionViewKind {
     GhostText = "ghostText",
@@ -40,15 +26,32 @@ export declare enum InlineCompletionViewKind {
     InsertionMultiLine = "insertionMultiLine",
     WordReplacements = "wordReplacements",
     LineReplacement = "lineReplacement",
-    Collapsed = "collapsed"
+    Collapsed = "collapsed",
+    JumpTo = "jumpTo"
+}
+export declare class InlineCompletionViewData {
+    readonly cursorColumnDistance: number;
+    readonly cursorLineDistance: number;
+    readonly lineCountOriginal: number;
+    readonly lineCountModified: number;
+    readonly characterCountOriginal: number;
+    readonly characterCountModified: number;
+    readonly disjointReplacements: number;
+    readonly sameShapeReplacements?: boolean | undefined;
+    longDistanceHintVisible: boolean | undefined;
+    longDistanceHintDistance: number | undefined;
+    constructor(cursorColumnDistance: number, cursorLineDistance: number, lineCountOriginal: number, lineCountModified: number, characterCountOriginal: number, characterCountModified: number, disjointReplacements: number, sameShapeReplacements?: boolean | undefined);
+    setLongDistanceViewData(lineNumber: number, inlineEditLineNumber: number): void;
+    getData(): {
+        cursorColumnDistance: number;
+        cursorLineDistance: number;
+        lineCountOriginal: number;
+        lineCountModified: number;
+        characterCountOriginal: number;
+        characterCountModified: number;
+        disjointReplacements: number;
+        sameShapeReplacements: boolean | undefined;
+        longDistanceHintVisible: boolean | undefined;
+        longDistanceHintDistance: number | undefined;
+    };
 }
-export type InlineCompletionViewData = {
-    cursorColumnDistance: number;
-    cursorLineDistance: number;
-    lineCountOriginal: number;
-    lineCountModified: number;
-    characterCountOriginal: number;
-    characterCountModified: number;
-    disjointReplacements: number;
-    sameShapeReplacements?: boolean;
-};

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

@@ -1,4 +1,6 @@
 
+import { getWindow } from '../../../../../../base/browser/dom.js';
+import { StandardMouseEvent } from '../../../../../../base/browser/mouseEvent.js';
 
 var InlineEditTabAction;
 (function (InlineEditTabAction) {
@@ -6,6 +8,15 @@ var InlineEditTabAction;
     InlineEditTabAction["Accept"] = "accept";
     InlineEditTabAction["Inactive"] = "inactive";
 })(InlineEditTabAction || (InlineEditTabAction = {}));
+class InlineEditClickEvent {
+    static create(event, alternativeAction = false) {
+        return ( new InlineEditClickEvent(( new StandardMouseEvent(getWindow(event), event)), alternativeAction));
+    }
+    constructor(event, alternativeAction = false) {
+        this.event = event;
+        this.alternativeAction = alternativeAction;
+    }
+}
 var InlineCompletionViewKind;
 (function (InlineCompletionViewKind) {
     InlineCompletionViewKind["GhostText"] = "ghostText";
@@ -17,6 +28,39 @@ var InlineCompletionViewKind;
     InlineCompletionViewKind["WordReplacements"] = "wordReplacements";
     InlineCompletionViewKind["LineReplacement"] = "lineReplacement";
     InlineCompletionViewKind["Collapsed"] = "collapsed";
+    InlineCompletionViewKind["JumpTo"] = "jumpTo";
 })(InlineCompletionViewKind || (InlineCompletionViewKind = {}));
+class InlineCompletionViewData {
+    constructor(cursorColumnDistance, cursorLineDistance, lineCountOriginal, lineCountModified, characterCountOriginal, characterCountModified, disjointReplacements, sameShapeReplacements) {
+        this.cursorColumnDistance = cursorColumnDistance;
+        this.cursorLineDistance = cursorLineDistance;
+        this.lineCountOriginal = lineCountOriginal;
+        this.lineCountModified = lineCountModified;
+        this.characterCountOriginal = characterCountOriginal;
+        this.characterCountModified = characterCountModified;
+        this.disjointReplacements = disjointReplacements;
+        this.sameShapeReplacements = sameShapeReplacements;
+        this.longDistanceHintVisible = undefined;
+        this.longDistanceHintDistance = undefined;
+    }
+    setLongDistanceViewData(lineNumber, inlineEditLineNumber) {
+        this.longDistanceHintVisible = true;
+        this.longDistanceHintDistance = Math.abs(inlineEditLineNumber - lineNumber);
+    }
+    getData() {
+        return {
+            cursorColumnDistance: this.cursorColumnDistance,
+            cursorLineDistance: this.cursorLineDistance,
+            lineCountOriginal: this.lineCountOriginal,
+            lineCountModified: this.lineCountModified,
+            characterCountOriginal: this.characterCountOriginal,
+            characterCountModified: this.characterCountModified,
+            disjointReplacements: this.disjointReplacements,
+            sameShapeReplacements: this.sameShapeReplacements,
+            longDistanceHintVisible: this.longDistanceHintVisible,
+            longDistanceHintDistance: this.longDistanceHintDistance
+        };
+    }
+}
 
-export { InlineCompletionViewKind, InlineEditTabAction };
+export { InlineCompletionViewData, InlineCompletionViewKind, InlineEditClickEvent, InlineEditTabAction };