@codingame/monaco-vscode-api 19.1.4 → 20.0.1

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/model/provideInlineCompletions.d.ts

@@ -23,6 +23,8 @@ export type InlineSuggestRequestInfo = {
     editorType: InlineCompletionEditorType;
     languageId: string;
     reason: string;
+    typingInterval: number;
+    typingIntervalCharacterCount: number;
 };
 export type InlineSuggestViewData = {
     editorType: InlineCompletionEditorType;
@@ -50,6 +52,7 @@ export declare class InlineSuggestData {
     private _viewData;
     private _didReportEndOfLife;
     private _lastSetEndOfLifeReason;
+    private _isPreceeded;
     private _partiallyAcceptedCount;
     constructor(range: Range, insertText: string, snippetInfo: SnippetInfo | undefined, displayLocation: IDisplayLocation | undefined, additionalTextEdits: readonly ISingleEditOperation[], sourceInlineCompletion: InlineCompletion, source: InlineSuggestionList, context: InlineCompletionContext, isInlineEdit: boolean, _requestInfo: InlineSuggestRequestInfo);
     get showInlineEditMenu(): boolean;
@@ -58,6 +61,7 @@ export declare class InlineSuggestData {
     reportPartialAccept(acceptedCharacters: number, info: PartialAcceptInfo): void;
     reportEndOfLife(reason?: InlineCompletionEndOfLifeReason): void;
     reportInlineEditError(message: string): void;
+    setIsPreceeded(): void;
     setEndOfLifeReason(reason: InlineCompletionEndOfLifeReason): void;
     private updateShownDuration;
     private reportInlineEditHidden;
@@ -72,7 +76,8 @@ export interface IDisplayLocation {
 }
 export declare enum InlineCompletionEditorType {
     TextEditor = "textEditor",
-    DiffEditor = "diffEditor"
+    DiffEditor = "diffEditor",
+    Notebook = "notebook"
 }
 export declare class InlineSuggestionList {
     readonly inlineSuggestions: InlineCompletions;

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/model/provideInlineCompletions.js

@@ -74,6 +74,9 @@ function provideInlineCompletions(providers, position, model, context, requestIn
             runWhenCancelled(cancellationTokenSource.token, () => {
                 return list.removeRef(cancelReason);
             });
+            if (cancellationTokenSource.token.isCancellationRequested) {
+                return undefined;
+            }
             for (const item of result.items) {
                 data.push(toInlineSuggestData(item, list, defaultReplaceRange, model, languageConfigurationService, contextWithUuid, requestInfo));
             }
@@ -196,6 +199,7 @@ class InlineSuggestData {
         this._showUncollapsedDuration = 0;
         this._didReportEndOfLife = false;
         this._lastSetEndOfLifeReason = undefined;
+        this._isPreceeded = false;
         this._partiallyAcceptedCount = 0;
         this._viewData = { editorType: _requestInfo.editorType };
     }
@@ -240,12 +244,15 @@ class InlineSuggestData {
                 shown: this._didShow,
                 shownDuration: this._shownDuration,
                 shownDurationUncollapsed: this._showUncollapsedDuration,
+                preceeded: this._isPreceeded,
                 timeUntilShown: this._timeUntilShown,
                 editorType: this._viewData.editorType,
                 languageId: this._requestInfo.languageId,
                 requestReason: this._requestInfo.reason,
                 viewKind: this._viewData.viewKind,
                 error: this._viewData.error,
+                typingInterval: this._requestInfo.typingInterval,
+                typingIntervalCharacterCount: this._requestInfo.typingIntervalCharacterCount,
                 ...this._viewData.renderData,
             };
             this.source.provider.handleEndOfLifetime(this.source.inlineSuggestions, this.sourceInlineCompletion, reason, summary);
@@ -259,6 +266,9 @@ class InlineSuggestData {
             this._viewData.error = message;
         }
     }
+    setIsPreceeded() {
+        this._isPreceeded = true;
+    }
     setEndOfLifeReason(reason) {
         this.reportInlineEditHidden();
         this._lastSetEndOfLifeReason = reason;
@@ -294,6 +304,7 @@ var InlineCompletionEditorType;
 (function (InlineCompletionEditorType) {
     InlineCompletionEditorType["TextEditor"] = "textEditor";
     InlineCompletionEditorType["DiffEditor"] = "diffEditor";
+    InlineCompletionEditorType["Notebook"] = "notebook";
 })(InlineCompletionEditorType || (InlineCompletionEditorType = {}));
 class InlineSuggestionList {
     constructor(inlineSuggestions, inlineSuggestionsData, provider) {

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/model/typingSpeed.d.ts

@@ -0,0 +1,32 @@
+import { Disposable } from "../../../../../base/common/lifecycle.js";
+import { ITextModel } from "../../../../common/model.js";
+interface TypingIntervalResult {
+    averageInterval: number;
+    characterCount: number;
+}
+export declare class TypingInterval extends Disposable {
+    private readonly _textModel;
+    private readonly _typingSessions;
+    private _currentSession;
+    private _lastChangeTime;
+    private _cachedTypingIntervalResult;
+    private _cacheInvalidated;
+    private static readonly MAX_SESSION_GAP_MS;
+    private static readonly MIN_SESSION_DURATION_MS;
+    private static readonly SESSION_HISTORY_LIMIT;
+    private static readonly TYPING_SPEED_WINDOW_MS;
+    private static readonly MIN_CHARS_FOR_RELIABLE_SPEED;
+    getTypingInterval(): TypingIntervalResult;
+    constructor(_textModel: ITextModel);
+    private _updateTypingSpeed;
+    private _calculateEffectiveCharacterCount;
+    private _getActualCharacterCount;
+    private _isUserTyping;
+    private _isUserTypingReason;
+    private _finalizeCurrentSession;
+    private _calculateTypingInterval;
+    private _calculateSpeedFromSessions;
+    reset(): void;
+    dispose(): void;
+}
+export {};

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/model/typingSpeed.js

@@ -0,0 +1,145 @@
+
+import { sum } from '../../../../../base/common/arrays.js';
+import { Disposable } from '../../../../../base/common/lifecycle.js';
+
+class TypingInterval extends Disposable {
+    static { this.MAX_SESSION_GAP_MS = 3_000; }
+    static { this.MIN_SESSION_DURATION_MS = 1_000; }
+    static { this.SESSION_HISTORY_LIMIT = 50; }
+    static { this.TYPING_SPEED_WINDOW_MS = 300_000; }
+    static { this.MIN_CHARS_FOR_RELIABLE_SPEED = 20; }
+    getTypingInterval() {
+        if (this._cacheInvalidated || this._cachedTypingIntervalResult === null) {
+            this._cachedTypingIntervalResult = this._calculateTypingInterval();
+            this._cacheInvalidated = false;
+        }
+        return this._cachedTypingIntervalResult;
+    }
+    constructor(_textModel) {
+        super();
+        this._textModel = _textModel;
+        this._typingSessions = [];
+        this._currentSession = null;
+        this._lastChangeTime = 0;
+        this._cachedTypingIntervalResult = null;
+        this._cacheInvalidated = true;
+        this._register(this._textModel.onDidChangeContent(e => this._updateTypingSpeed(e)));
+    }
+    _updateTypingSpeed(change) {
+        const now = Date.now();
+        const characterCount = this._calculateEffectiveCharacterCount(change);
+        if (this._currentSession && (now - this._lastChangeTime) > TypingInterval.MAX_SESSION_GAP_MS) {
+            this._finalizeCurrentSession();
+        }
+        if (!this._currentSession) {
+            this._currentSession = {
+                startTime: now,
+                endTime: now,
+                characterCount: 0
+            };
+        }
+        this._currentSession.endTime = now;
+        this._currentSession.characterCount += characterCount;
+        this._lastChangeTime = now;
+        this._cacheInvalidated = true;
+    }
+    _calculateEffectiveCharacterCount(change) {
+        const actualCharCount = this._getActualCharacterCount(change);
+        if (this._isUserTyping(change)) {
+            return actualCharCount;
+        }
+        return actualCharCount > 0 ? 1 : 0;
+    }
+    _getActualCharacterCount(change) {
+        let totalChars = 0;
+        for (const c of change.changes) {
+            totalChars += Math.max(c.text.length, c.rangeLength);
+        }
+        return totalChars;
+    }
+    _isUserTyping(change) {
+        if (!change.detailedReasons || change.detailedReasons.length === 0) {
+            return true;
+        }
+        for (const reason of change.detailedReasons) {
+            if (this._isUserTypingReason(reason)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    _isUserTypingReason(reason) {
+        if (reason.metadata.isUndoing || reason.metadata.isRedoing) {
+            return false;
+        }
+        switch (reason.metadata.source) {
+            case 'cursor': {
+                const kind = reason.metadata.kind;
+                return kind === 'type' || kind === 'compositionType' || kind === 'compositionEnd';
+            }
+            default:
+                return false;
+        }
+    }
+    _finalizeCurrentSession() {
+        if (!this._currentSession) {
+            return;
+        }
+        const sessionDuration = this._currentSession.endTime - this._currentSession.startTime;
+        if (sessionDuration >= TypingInterval.MIN_SESSION_DURATION_MS && this._currentSession.characterCount > 0) {
+            this._typingSessions.push(this._currentSession);
+            if (this._typingSessions.length > TypingInterval.SESSION_HISTORY_LIMIT) {
+                this._typingSessions.shift();
+            }
+        }
+        this._currentSession = null;
+    }
+    _calculateTypingInterval() {
+        if (this._currentSession) {
+            const tempSession = { ...this._currentSession };
+            const sessionDuration = tempSession.endTime - tempSession.startTime;
+            if (sessionDuration >= TypingInterval.MIN_SESSION_DURATION_MS && tempSession.characterCount > 0) {
+                const allSessions = [...this._typingSessions, tempSession];
+                return this._calculateSpeedFromSessions(allSessions);
+            }
+        }
+        return this._calculateSpeedFromSessions(this._typingSessions);
+    }
+    _calculateSpeedFromSessions(sessions) {
+        if (sessions.length === 0) {
+            return { averageInterval: 0, characterCount: 0 };
+        }
+        const sortedSessions = [...sessions].sort((a, b) => b.endTime - a.endTime);
+        const cutoffTime = Date.now() - TypingInterval.TYPING_SPEED_WINDOW_MS;
+        const recentSessions = sortedSessions.filter(session => session.endTime > cutoffTime);
+        const olderSessions = sortedSessions.splice(recentSessions.length);
+        let totalChars = sum(( recentSessions.map(session => session.characterCount)));
+        for (let i = 0; i < olderSessions.length && totalChars < TypingInterval.MIN_CHARS_FOR_RELIABLE_SPEED; i++) {
+            recentSessions.push(olderSessions[i]);
+            totalChars += olderSessions[i].characterCount;
+        }
+        const totalTime = sum(( recentSessions.map(session => session.endTime - session.startTime)));
+        if (totalTime === 0 || totalChars <= 1) {
+            return { averageInterval: 0, characterCount: totalChars };
+        }
+        const keystrokeIntervals = Math.max(1, totalChars - 1);
+        const avgMsBetweenKeystrokes = totalTime / keystrokeIntervals;
+        return {
+            averageInterval: Math.round(avgMsBetweenKeystrokes),
+            characterCount: totalChars
+        };
+    }
+    reset() {
+        this._typingSessions.length = 0;
+        this._currentSession = null;
+        this._lastChangeTime = 0;
+        this._cachedTypingIntervalResult = null;
+        this._cacheInvalidated = true;
+    }
+    dispose() {
+        this._finalizeCurrentSession();
+        super.dispose();
+    }
+}
+
+export { TypingInterval };

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

@@ -2,12 +2,10 @@
 import { Permutation, compareBy } from '../../../../base/common/arrays.js';
 import '../../../../base/common/observableInternal/index.js';
 import { bindContextKey } from '../../../../platform/observable/common/platformObservableUtils.js';
-import { Position } from '../../../common/core/position.js';
 import '../../../common/core/text/positionToOffset.js';
 import { Range } from '../../../common/core/range.js';
 import { TextEdit } from '../../../common/core/edits/textEdit.js';
 import { getPositionOffsetTransformerFromTextModel } from '../../../common/core/text/getPositionOffsetTransformerFromTextModel.js';
-import { PositionOffsetTransformer } from '../../../common/core/text/positionToOffsetImpl.js';
 import { observableValue } from '../../../../base/common/observableInternal/observables/observableValue.js';
 import { autorun } from '../../../../base/common/observableInternal/reactions/autorun.js';
 import { transaction } from '../../../../base/common/observableInternal/transaction.js';
@@ -16,23 +14,6 @@ const array = [];
 function getReadonlyEmptyArray() {
     return array;
 }
-function addPositions(pos1, pos2) {
-    return ( new Position(
-        pos1.lineNumber + pos2.lineNumber - 1,
-        pos2.lineNumber === 1 ? pos1.column + pos2.column - 1 : pos2.column
-    ));
-}
-function subtractPositions(pos1, pos2) {
-    return ( new Position(
-        pos1.lineNumber - pos2.lineNumber + 1,
-        pos1.lineNumber - pos2.lineNumber === 0 ? pos1.column - pos2.column + 1 : pos1.column
-    ));
-}
-function substringPos(text, pos) {
-    const transformer = ( new PositionOffsetTransformer(text));
-    const offset = transformer.getOffset(pos);
-    return text.substring(offset);
-}
 function getEndPositionsAfterApplying(edits) {
     const newRanges = getModifiedRangesAfterApplying(edits);
     return ( newRanges.map(range => range.getEndPosition()));
@@ -48,7 +29,7 @@ function removeTextReplacementCommonSuffixPrefix(edits, textModel) {
     const text = textModel.getValue();
     const stringReplacements = ( edits.map(edit => transformer.getStringReplacement(edit)));
     const minimalStringReplacements = ( stringReplacements.map(replacement => replacement.removeCommonSuffixPrefix(text)));
-    return ( minimalStringReplacements.map(replacement => transformer.getSingleTextEdit(replacement)));
+    return ( minimalStringReplacements.map(replacement => transformer.getTextReplacement(replacement)));
 }
 function convertItemsToStableObservables(items, store) {
     const result = observableValue('result', []);
@@ -99,4 +80,4 @@ function wait(ms, cancellationToken) {
     }));
 }
 
-export { ObservableContextKeyService, addPositions, convertItemsToStableObservables, getEndPositionsAfterApplying, getModifiedRangesAfterApplying, getReadonlyEmptyArray, removeTextReplacementCommonSuffixPrefix, substringPos, subtractPositions, wait };
+export { ObservableContextKeyService, convertItemsToStableObservables, getEndPositionsAfterApplying, getModifiedRangesAfterApplying, getReadonlyEmptyArray, removeTextReplacementCommonSuffixPrefix, wait };

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

@@ -23,7 +23,6 @@ import { InjectedTextCursorStops, PositionAffinity } from '../../../../../common
 import { LineTokens } from '../../../../../common/tokens/lineTokens.js';
 import { LineDecoration } from '../../../../../common/viewLayout/lineDecorations.js';
 import { renderViewLine, RenderLineInput } from '../../../../../common/viewLayout/viewLineRenderer.js';
-import { InlineDecorationType } from '../../../../../common/viewModel.js';
 import { GhostTextReplacement } from '../../model/ghostText.js';
 import { RangeSingleLine } from '../../../../../common/core/ranges/rangeSingleLine.js';
 import { ColumnRange } from '../../../../../common/core/ranges/columnRange.js';
@@ -31,6 +30,8 @@ import * as ghostTextView from './ghostTextView.css';
 import { StandardMouseEvent } from '../../../../../../base/browser/mouseEvent.js';
 import { CodeEditorWidget } from '../../../../../browser/widget/codeEditor/codeEditorWidget.js';
 import { TokenWithTextArray } from '../../../../../common/tokens/tokenWithTextArray.js';
+import { InlineDecorationType } from '../../../../../common/viewModel/inlineDecorations.js';
+import { sum } from '../../../../../../base/common/arrays.js';
 import { observableValue } from '../../../../../../base/common/observableInternal/observables/observableValue.js';
 import { derived } from '../../../../../../base/common/observableInternal/observables/derived.js';
 import { autorunWithStore, autorun } from '../../../../../../base/common/observableInternal/reactions/autorun.js';
@@ -113,15 +114,17 @@ let GhostTextView = class GhostTextView extends Disposable {
                 };
             }));
             const cursorColumn = this._editor.getSelection()?.getStartPosition().column;
+            const disjointInlineTexts = inlineTextsWithTokens.filter(inline => inline.text !== '');
+            const hasInsertionOnCurrentLine = disjointInlineTexts.length !== 0;
             const renderData = {
-                cursorColumnDistance: cursorColumn !== undefined ? Math.abs((inlineTextsWithTokens.length > 0 ? inlineTextsWithTokens[0].column : 1) - cursorColumn) : -1,
-                cursorLineDistance: inlineTextsWithTokens.length > 0 ? 0 : additionalLines.findIndex(line => line.content !== ''),
-                lineCountOriginal: inlineTextsWithTokens.length > 0 ? 1 : 0,
-                lineCountModified: additionalLines.length + (inlineTextsWithTokens.length > 0 ? 1 : 0),
+                cursorColumnDistance: (hasInsertionOnCurrentLine ? disjointInlineTexts[0].column : 1) - cursorColumn,
+                cursorLineDistance: hasInsertionOnCurrentLine ? 0 : (additionalLines.findIndex(line => line.content !== '') + 1),
+                lineCountOriginal: hasInsertionOnCurrentLine ? 1 : 0,
+                lineCountModified: additionalLines.length + (hasInsertionOnCurrentLine ? 1 : 0),
                 characterCountOriginal: 0,
-                characterCountModified: inlineTextsWithTokens.reduce((acc, inline) => acc + inline.text.length, 0) + tokenizedAdditionalLines.reduce((acc, line) => acc + line.content.getTextLength(), 0),
-                disjointReplacements: inlineTextsWithTokens.length + (additionalLines.length > 0 ? 1 : 0),
-                sameShapeReplacements: inlineTextsWithTokens.length > 1 && inlineTextsWithTokens.length === 0 ? inlineTextsWithTokens.every(inline => inline.text.length === inlineTextsWithTokens[0].text.length) : undefined,
+                characterCountModified: sum(( disjointInlineTexts.map(inline => inline.text.length))) + sum(( tokenizedAdditionalLines.map(line => line.content.getTextLength()))),
+                disjointReplacements: disjointInlineTexts.length + (additionalLines.length > 0 ? 1 : 0),
+                sameShapeReplacements: disjointInlineTexts.length > 1 && tokenizedAdditionalLines.length === 0 ? disjointInlineTexts.every(inline => inline.text === disjointInlineTexts[0].text) : undefined,
             };
             this._model.handleInlineCompletionShown.read(reader)?.(renderData);
             return {
@@ -449,7 +452,9 @@ function renderLines(domNode, tabSize, lines, opts, isClickable) {
             renderWhitespace,
             renderControlCharacters,
             fontLigatures !== EditorFontLigatures.OFF,
-            null
+            null,
+            null,
+            0
         )), sb);
         sb.appendString('</div>');
     }

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

@@ -64,13 +64,13 @@ let GutterIndicatorMenuContent = class GutterIndicatorMenuContent {
         const title = header(this._model.displayName);
         const gotoAndAccept = option(createOptionArgs({
             id: 'gotoAndAccept',
-            title: `${( localize(1285, "Go To"))} / ${( localize(1286, "Accept"))}`,
+            title: `${( localize(1296, "Go To"))} / ${( localize(1297, "Accept"))}`,
             icon: Codicon.check,
             commandId: inlineSuggestCommitId
         }));
         const reject = option(createOptionArgs({
             id: 'reject',
-            title: ( localize(1287, "Reject")),
+            title: ( localize(1298, "Reject")),
             icon: Codicon.close,
             commandId: hideInlineCompletionId
         }));
@@ -84,19 +84,19 @@ let GutterIndicatorMenuContent = class GutterIndicatorMenuContent {
         const toggleCollapsedMode = ( this._inlineEditsShowCollapsed.map(showCollapsed => showCollapsed ?
             option(createOptionArgs({
                 id: 'showExpanded',
-                title: ( localize(1288, "Show Expanded")),
+                title: ( localize(1299, "Show Expanded")),
                 icon: Codicon.expandAll,
                 commandId: toggleShowCollapsedId
             }))
             : option(createOptionArgs({
                 id: 'showCollapsed',
-                title: ( localize(1289, "Show Collapsed")),
+                title: ( localize(1300, "Show Collapsed")),
                 icon: Codicon.collapseAll,
                 commandId: toggleShowCollapsedId
             }))));
         const settings = option(createOptionArgs({
             id: 'settings',
-            title: ( localize(1290, "Settings")),
+            title: ( localize(1301, "Settings")),
             icon: Codicon.gear,
             commandId: 'workbench.action.openSettings',
             commandArgs: ['@tag:nextEditSuggestions']

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

@@ -14,7 +14,7 @@ class InlineEditModel {
         this.inlineEdit = inlineEdit;
         this.tabAction = tabAction;
         this.action = this.inlineEdit.inlineCompletion.action;
-        this.displayName = this.inlineEdit.inlineCompletion.source.provider.displayName ?? ( localize(1291, "Inline Edit"));
+        this.displayName = this.inlineEdit.inlineCompletion.source.provider.displayName ?? ( localize(1302, "Inline Edit"));
         this.extensionCommands = this.inlineEdit.inlineCompletion.source.inlineSuggestions.commands ?? [];
         this.isInDiffEditor = this._model.isInDiffEditor;
         this.displayLocation = this.inlineEdit.inlineCompletion.displayLocation;

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

@@ -289,15 +289,16 @@ let InlineEditsView = class InlineEditsView extends Disposable {
             modified: newText.getValueOfRange(m.modifiedRange)
         })));
         const cursorPosition = inlineEdit.cursorPosition;
+        const startsWithEOL = stringChanges[0].modified.startsWith(textModel.getEOL());
         const viewData = {
             cursorColumnDistance: inlineEdit.edit.replacements[0].range.getStartPosition().column - cursorPosition.column,
-            cursorLineDistance: inlineEdit.lineEdit.lineRange.startLineNumber - cursorPosition.lineNumber,
+            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.length > 1 ? stringChanges.every(r => r.original === stringChanges[0].original && r.modified === stringChanges[0].modified) : undefined,
+            sameShapeReplacements: stringChanges.every(r => r.original === stringChanges[0].original && r.modified === stringChanges[0].modified),
         };
         switch (view) {
             case InlineCompletionViewKind.InsertionInline: return { kind: InlineCompletionViewKind.InsertionInline, viewData };

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

@@ -16,6 +16,7 @@ export declare class InlineEditsCustomView extends Disposable implements IInline
     private readonly _viewRef;
     private readonly _editorObs;
     constructor(_editor: ICodeEditor, displayLocation: IObservable<InlineCompletionDisplayLocation | undefined>, tabAction: IObservable<InlineEditTabAction>, themeService: IThemeService, _languageService: ILanguageService);
+    private fitsInsideViewport;
     private getState;
     private getRendering;
 }

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

@@ -26,12 +26,18 @@ import { ILanguageService } from '../../../../../../common/languages/language.se
 import { TokenArray, LineTokens } from '../../../../../../common/tokens/lineTokens.js';
 import { InlineEditTabAction } from '../inlineEditsViewInterface.js';
 import { inlineEditIndicatorsuccessfulBackground, inlineEditIndicatorPrimaryBackground, inlineEditIndicatorSecondaryBackground, getEditorBlendedColor } from '../theme.js';
-import { maxContentWidthInRange, rectToProps } from '../utils/utils.js';
+import { maxContentWidthInRange, getContentRenderWidth, rectToProps } from '../utils/utils.js';
 import { observableValue } from '../../../../../../../base/common/observableInternal/observables/observableValue.js';
+import { derivedObservableWithCache } from '../../../../../../../base/common/observableInternal/utils/utils.js';
 import { constObservable } from '../../../../../../../base/common/observableInternal/observables/constObservable.js';
 import { autorun } from '../../../../../../../base/common/observableInternal/reactions/autorun.js';
 import { derived } from '../../../../../../../base/common/observableInternal/observables/derived.js';
 
+const MIN_END_OF_LINE_PADDING = 14;
+const PADDING_VERTICALLY = 0;
+const PADDING_HORIZONTALLY = 4;
+const HORIZONTAL_OFFSET_WHEN_ABOVE_BELOW = 4;
+const VERTICAL_OFFSET_WHEN_ABOVE_BELOW = 2;
 let InlineEditsCustomView = class InlineEditsCustomView extends Disposable {
     constructor(_editor, displayLocation, tabAction, themeService, _languageService) {
         super();
@@ -77,7 +83,17 @@ let InlineEditsCustomView = class InlineEditsCustomView extends Disposable {
             domNode: overlay.element,
             position: constObservable(null),
             allowEditorOverflow: false,
-            minContentWidthInPx: constObservable(0),
+            minContentWidthInPx: derivedObservableWithCache(this, (reader, prev) => {
+                const s = state.read(reader);
+                if (!s) {
+                    return prev ?? 0;
+                }
+                const current = ( s.rect.map(rect => rect.right)).read(reader)
+                    + this._editorObs.layoutInfoVerticalScrollbarWidth.read(reader)
+                    + PADDING_HORIZONTALLY
+                    - this._editorObs.layoutInfoContentLeft.read(reader);
+                return Math.max(prev ?? 0, current);
+            }).recomputeInitiallyAndOnChange(this._store),
         }));
         this._register(autorun((reader) => {
             const v = view.read(reader);
@@ -88,6 +104,16 @@ let InlineEditsCustomView = class InlineEditsCustomView extends Disposable {
             this._isHovered.set(overlay.isHovered.read(reader), undefined);
         }));
     }
+    fitsInsideViewport(range, displayLabel, reader) {
+        const editorWidth = this._editorObs.layoutInfoWidth.read(reader);
+        const editorContentLeft = this._editorObs.layoutInfoContentLeft.read(reader);
+        const editorVerticalScrollbar = this._editor.getLayoutInfo().verticalScrollbarWidth;
+        const minimapWidth = this._editorObs.layoutInfoMinimap.read(reader).minimapLeft !== 0 ? this._editorObs.layoutInfoMinimap.read(reader).minimapWidth : 0;
+        const maxOriginalContent = maxContentWidthInRange(this._editorObs, range, undefined);
+        const maxModifiedContent = getContentRenderWidth(displayLabel, this._editor, this._editor.getModel());
+        const padding = PADDING_HORIZONTALLY + MIN_END_OF_LINE_PADDING;
+        return maxOriginalContent + maxModifiedContent + padding < editorWidth - editorContentLeft - editorVerticalScrollbar - minimapWidth;
+    }
     getState(displayLocation) {
         const contentState = derived((reader) => {
             const startLineNumber = displayLocation.range.startLineNumber;
@@ -108,28 +134,24 @@ let InlineEditsCustomView = class InlineEditsCustomView extends Disposable {
                 endContentLeftOffset
             };
         });
-        const minEndOfLinePadding = 14;
-        const paddingVertically = 0;
-        const paddingHorizontally = 4;
-        const horizontalOffsetWhenAboveBelow = 4;
-        const verticalOffsetWhenAboveBelow = 2;
+        const startLineNumber = displayLocation.range.startLineNumber;
+        const endLineNumber = displayLocation.range.endLineNumber;
+        const fitsInsideViewport = this.fitsInsideViewport(( new LineRange(startLineNumber, endLineNumber + 1)), displayLocation.label, undefined);
         const rect = derived((reader) => {
             const w = this._editorObs.getOption(EditorOption.fontInfo).read(reader).typicalHalfwidthCharacterWidth;
-            const startLineNumber = displayLocation.range.startLineNumber;
-            const endLineNumber = displayLocation.range.endLineNumber;
             const { lineWidth, lineWidthBelow, lineWidthAbove, startContentLeftOffset, endContentLeftOffset } = contentState.read(reader);
             const contentLeft = this._editorObs.layoutInfoContentLeft.read(reader);
-            const lineHeight = this._editorObs.observeLineHeightForLine(startLineNumber).read(reader);
+            const lineHeight = this._editorObs.observeLineHeightForLine(startLineNumber).recomputeInitiallyAndOnChange(reader.store).read(reader);
             const scrollTop = this._editorObs.scrollTop.read(reader);
             const scrollLeft = this._editorObs.scrollLeft.read(reader);
             let position;
-            if (startLineNumber === endLineNumber && endContentLeftOffset + 5 * w >= lineWidth) {
+            if (startLineNumber === endLineNumber && endContentLeftOffset + 5 * w >= lineWidth && fitsInsideViewport) {
                 position = 'end';
             }
-            else if (lineWidthBelow !== undefined && lineWidthBelow + minEndOfLinePadding - horizontalOffsetWhenAboveBelow - paddingHorizontally < startContentLeftOffset) {
+            else if (lineWidthBelow !== undefined && lineWidthBelow + MIN_END_OF_LINE_PADDING - HORIZONTAL_OFFSET_WHEN_ABOVE_BELOW - PADDING_HORIZONTALLY < startContentLeftOffset) {
                 position = 'below';
             }
-            else if (lineWidthAbove !== undefined && lineWidthAbove + minEndOfLinePadding - horizontalOffsetWhenAboveBelow - paddingHorizontally < startContentLeftOffset) {
+            else if (lineWidthAbove !== undefined && lineWidthAbove + MIN_END_OF_LINE_PADDING - HORIZONTAL_OFFSET_WHEN_ABOVE_BELOW - PADDING_HORIZONTALLY < startContentLeftOffset) {
                 position = 'above';
             }
             else {
@@ -143,26 +165,26 @@ let InlineEditsCustomView = class InlineEditsCustomView extends Disposable {
                 case 'end': {
                     topOfLine = this._editorObs.editor.getTopForLineNumber(startLineNumber);
                     contentStartOffset = lineWidth;
-                    deltaX = paddingHorizontally + minEndOfLinePadding;
+                    deltaX = PADDING_HORIZONTALLY + MIN_END_OF_LINE_PADDING;
                     break;
                 }
                 case 'below': {
                     topOfLine = this._editorObs.editor.getTopForLineNumber(startLineNumber + 1);
                     contentStartOffset = startContentLeftOffset;
-                    deltaX = paddingHorizontally + horizontalOffsetWhenAboveBelow;
-                    deltaY = paddingVertically + verticalOffsetWhenAboveBelow;
+                    deltaX = PADDING_HORIZONTALLY + HORIZONTAL_OFFSET_WHEN_ABOVE_BELOW;
+                    deltaY = PADDING_VERTICALLY + VERTICAL_OFFSET_WHEN_ABOVE_BELOW;
                     break;
                 }
                 case 'above': {
                     topOfLine = this._editorObs.editor.getTopForLineNumber(startLineNumber - 1);
                     contentStartOffset = startContentLeftOffset;
-                    deltaX = paddingHorizontally + horizontalOffsetWhenAboveBelow;
-                    deltaY = -paddingVertically + verticalOffsetWhenAboveBelow;
+                    deltaX = PADDING_HORIZONTALLY + HORIZONTAL_OFFSET_WHEN_ABOVE_BELOW;
+                    deltaY = -PADDING_VERTICALLY + VERTICAL_OFFSET_WHEN_ABOVE_BELOW;
                     break;
                 }
             }
             const textRect = Rect.fromLeftTopWidthHeight(contentLeft + contentStartOffset - scrollLeft, topOfLine - scrollTop, w * displayLocation.label.length, lineHeight);
-            return textRect.withMargin(paddingVertically, paddingHorizontally).translateX(deltaX).translateY(deltaY);
+            return textRect.withMargin(PADDING_VERTICALLY, PADDING_HORIZONTALLY).translateX(deltaX).translateY(deltaY);
         });
         return {
             rect,
@@ -181,7 +203,7 @@ let InlineEditsCustomView = class InlineEditsCustomView extends Disposable {
         }
         const result = renderLines(( new LineSource([tokens])), RenderOptions.fromEditor(this._editor).withSetWidth(false).withScrollBeyondLastColumn(0), [], line, true);
         line.style.width = `${result.minWidthInPx}px`;
-        const rect = ( state.rect.map(r => r.withMargin(0, 4)));
+        const rect = ( state.rect.map(r => r.withMargin(0, PADDING_HORIZONTALLY)));
         return n.div({
             class: 'collapsedView',
             ref: this._viewRef,

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

@@ -25,7 +25,7 @@ import { LineRange } from '../../../../../../common/core/ranges/lineRange.js';
 import { OffsetRange } from '../../../../../../common/core/ranges/offsetRange.js';
 import { ILanguageService } from '../../../../../../common/languages/language.service.js';
 import { TokenArray, LineTokens } from '../../../../../../common/tokens/lineTokens.js';
-import { InlineDecoration, InlineDecorationType } from '../../../../../../common/viewModel.js';
+import { InlineDecoration, InlineDecorationType } from '../../../../../../common/viewModel/inlineDecorations.js';
 import { GhostText, GhostTextPart } from '../../../model/ghostText.js';
 import { GhostTextView } from '../../ghostText/ghostTextView.js';
 import { modifiedBackgroundColor, getModifiedBorderColor } from '../theme.js';

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

@@ -26,7 +26,7 @@ import { Range } from '../../../../../../common/core/range.js';
 import { OffsetRange } from '../../../../../../common/core/ranges/offsetRange.js';
 import { ILanguageService } from '../../../../../../common/languages/language.service.js';
 import { TokenArray, LineTokens } from '../../../../../../common/tokens/lineTokens.js';
-import { InlineDecoration, InlineDecorationType } from '../../../../../../common/viewModel.js';
+import { InlineDecoration, InlineDecorationType } from '../../../../../../common/viewModel/inlineDecorations.js';
 import { getModifiedBorderColor, getOriginalBorderColor, originalBackgroundColor, getEditorBlendedColor, modifiedChangedLineBackgroundColor } from '../theme.js';
 import { getPrefixTrim, mapOutFalsy, rectToProps, getEditorValidOverlayRect } from '../utils/utils.js';
 import { autorunDelta } from '../../../../../../../base/common/observableInternal/reactions/autorun.js';