@codingame/monaco-vscode-api 6.0.2 → 7.0.0

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

@@ -7,11 +7,13 @@ import { constObservable } from '../../../../base/common/observableInternal/util
 import '../../../../base/common/cancellation.js';
 import { MouseTargetType } from '../../../browser/editorBrowser.js';
 import { EditorOption } from '../../../common/config/editorOptions.js';
-import { HoverForeignElementAnchor, HoverAnchorType } from '../../hover/browser/hoverTypes.js';
+import { HoverForeignElementAnchor, RenderedHoverParts, HoverAnchorType } from '../../hover/browser/hoverTypes.js';
 import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
 import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.service.js';
 import { InlineEditController } from './inlineEditController.js';
 import { InlineEditHintsContentWidget } from './inlineEditHintsWidget.js';
+import { localizeWithPath } from '../../../../nls.js';
+const _moduleId = "vs/editor/contrib/inlineEdit/browser/hoverParticipant";
 class InlineEditHover {
     constructor(owner, range, controller) {
         this.owner = owner;
@@ -41,32 +43,38 @@ let InlineEditHoverParticipant = class InlineEditHoverParticipant {
             const viewZoneData = target.detail;
             if (controller.shouldShowHoverAtViewZone(viewZoneData.viewZoneId)) {
                 const range = target.range;
-                return ( new HoverForeignElementAnchor(1000, this, range, mouseEvent.event.posx, mouseEvent.event.posy, false));
+                return (
+                     (new HoverForeignElementAnchor(1000, this, range, mouseEvent.event.posx, mouseEvent.event.posy, false))
+                );
             }
         }
         if (target.type === MouseTargetType.CONTENT_EMPTY) {
             if (controller.shouldShowHoverAt(target.range)) {
-                return ( new HoverForeignElementAnchor(
-                    1000,
-                    this,
-                    target.range,
-                    mouseEvent.event.posx,
-                    mouseEvent.event.posy,
-                    false
-                ));
+                return (
+                     (new HoverForeignElementAnchor(
+                        1000,
+                        this,
+                        target.range,
+                        mouseEvent.event.posx,
+                        mouseEvent.event.posy,
+                        false
+                    ))
+                );
             }
         }
         if (target.type === MouseTargetType.CONTENT_TEXT) {
             const mightBeForeignElement = target.detail.mightBeForeignElement;
             if (mightBeForeignElement && controller.shouldShowHoverAt(target.range)) {
-                return ( new HoverForeignElementAnchor(
-                    1000,
-                    this,
-                    target.range,
-                    mouseEvent.event.posx,
-                    mouseEvent.event.posy,
-                    false
-                ));
+                return (
+                     (new HoverForeignElementAnchor(
+                        1000,
+                        this,
+                        target.range,
+                        mouseEvent.event.posx,
+                        mouseEvent.event.posy,
+                        false
+                    ))
+                );
             }
         }
         return null;
@@ -77,21 +85,31 @@ let InlineEditHoverParticipant = class InlineEditHoverParticipant {
         }
         const controller = InlineEditController.get(this._editor);
         if (controller && controller.shouldShowHoverAt(anchor.range)) {
-            return [( new InlineEditHover(this, anchor.range, controller))];
+            return [( (new InlineEditHover(this, anchor.range, controller)))];
         }
         return [];
     }
     renderHoverParts(context, hoverParts) {
-        const disposableStore = ( new DisposableStore());
+        const disposables = ( (new DisposableStore()));
         this._telemetryService.publicLog2('inlineEditHover.shown');
         const w = this._instantiationService.createInstance(InlineEditHintsContentWidget, this._editor, false, constObservable(null));
-        context.fragment.appendChild(w.getDomNode());
-        disposableStore.add(w);
-        return disposableStore;
+        disposables.add(w);
+        const widgetNode = w.getDomNode();
+        const renderedHoverPart = {
+            hoverPart: hoverParts[0],
+            hoverElement: widgetNode,
+            dispose: () => disposables.dispose()
+        };
+        return (
+             (new RenderedHoverParts([renderedHoverPart]))
+        );
+    }
+    getAccessibleContent(hoverPart) {
+        return ( localizeWithPath(_moduleId, 0, 'There are inline edits here.'));
     }
 };
-InlineEditHoverParticipant = ( __decorate([
-    ( __param(1, IInstantiationService)),
-    ( __param(2, ITelemetryService))
-], InlineEditHoverParticipant));
+InlineEditHoverParticipant = ( (__decorate([
+    ( (__param(1, IInstantiationService))),
+    ( (__param(2, ITelemetryService)))
+], InlineEditHoverParticipant)));
 export { InlineEditHover, InlineEditHoverParticipant };

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

@@ -54,9 +54,9 @@ let InlineEditController = class InlineEditController extends Disposable {
         this._isCursorAtInlineEditContext = InlineEditController_1.cursorAtInlineEditContext.bindTo(this.contextKeyService);
         this._currentEdit = this._register(disposableObservableValue(this, undefined));
         this._isAccepting = observableValue(this, false);
-        this._enabled = observableFromEvent(this.editor.onDidChangeConfiguration, () => this.editor.getOption(EditorOption.inlineEdit).enabled);
-        this._fontFamily = observableFromEvent(this.editor.onDidChangeConfiguration, () => this.editor.getOption(EditorOption.inlineEdit).fontFamily);
-        this._backgroundColoring = observableFromEvent(this.editor.onDidChangeConfiguration, () => this.editor.getOption(EditorOption.inlineEdit).backgroundColoring);
+        this._enabled = observableFromEvent(this, this.editor.onDidChangeConfiguration, () => this.editor.getOption(EditorOption.inlineEdit).enabled);
+        this._fontFamily = observableFromEvent(this, this.editor.onDidChangeConfiguration, () => this.editor.getOption(EditorOption.inlineEdit).fontFamily);
+        this._backgroundColoring = observableFromEvent(this, this.editor.onDidChangeConfiguration, () => this.editor.getOption(EditorOption.inlineEdit).backgroundColoring);
         const modelChangedSignal = observableSignalFromEvent('InlineEditController.modelContentChangedSignal', editor.onDidChangeModelContent);
         this._register(autorun(reader => {
             if (!this._enabled.read(reader)) {
@@ -68,7 +68,7 @@ let InlineEditController = class InlineEditController extends Disposable {
             }
             this.getInlineEdit(editor, true);
         }));
-        const cursorPosition = observableFromEvent(editor.onDidChangeCursorPosition, () => editor.getPosition());
+        const cursorPosition = observableFromEvent(this, editor.onDidChangeCursorPosition, () => editor.getPosition());
         this._register(autorun(reader => {
             if (!this._enabled.read(reader)) {
                 return;

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

@@ -31,7 +31,7 @@ let InlineEditHintsWidget = class InlineEditHintsWidget extends Disposable {
         this.editor = editor;
         this.model = model;
         this.instantiationService = instantiationService;
-        this.alwaysShowToolbar = observableFromEvent(this.editor.onDidChangeConfiguration, () => this.editor.getOption(EditorOption.inlineEdit).showToolbar === 'always');
+        this.alwaysShowToolbar = observableFromEvent(this, this.editor.onDidChangeConfiguration, () => this.editor.getOption(EditorOption.inlineEdit).showToolbar === 'always');
         this.sessionPosition = undefined;
         this.position = derived(this, reader => {
             const ghostText = this.model.read(reader)?.widget.model.ghostText.read(reader);

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

@@ -0,0 +1,126 @@
+import { Codicon } from '../../../../base/common/codicons.js';
+import { KeyMod as KeyMod$1, KeyCode } from '../../../../base/common/keyCodes.js';
+import { transaction, asyncTransaction } from '../../../../base/common/observableInternal/base.js';
+import '../../../../base/common/observableInternal/derived.js';
+import '../../../../base/common/observableInternal/autorun.js';
+import '../../../../base/common/observableInternal/utils.js';
+import '../../../../base/common/cancellation.js';
+import '../../../../base/common/arrays.js';
+import { EditorAction } from '../../../browser/editorExtensions.js';
+import { EmbeddedCodeEditorWidget } from '../../../browser/widget/codeEditor/embeddedCodeEditorWidget.js';
+import { EditorContextKeys } from '../../../common/editorContextKeys.js';
+import { showNextInlineEditActionId, inlineEditVisible, showPreviousInlineEditActionId, inlineEditAcceptId } from './consts.js';
+import { InlineEditsController } from './inlineEditsController.js';
+import { localize2WithPath, localizeWithPath } from '../../../../nls.js';
+import { MenuId } from '../../../../platform/actions/common/actions.js';
+import { ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
+const _moduleId = "vs/editor/contrib/inlineEdits/browser/commands";
+function labelAndAlias(str) {
+    return {
+        label: str.value,
+        alias: str.original,
+    };
+}
+class ShowNextInlineEditAction extends EditorAction {
+    static { this.ID = showNextInlineEditActionId; }
+    constructor() {
+        super({
+            id: ShowNextInlineEditAction.ID,
+            ...labelAndAlias(( localize2WithPath(_moduleId, 0, "Show Next Inline Edit"))),
+            precondition: ( (ContextKeyExpr.and(EditorContextKeys.writable, inlineEditVisible))),
+            kbOpts: {
+                weight: 100,
+                primary: KeyMod$1.Alt | KeyCode.BracketRight,
+            },
+        });
+    }
+    async run(accessor, editor) {
+        const controller = InlineEditsController.get(editor);
+        controller?.model.get()?.next();
+    }
+}
+class ShowPreviousInlineEditAction extends EditorAction {
+    static { this.ID = showPreviousInlineEditActionId; }
+    constructor() {
+        super({
+            id: ShowPreviousInlineEditAction.ID,
+            ...labelAndAlias(( localize2WithPath(_moduleId, 1, "Show Previous Inline Edit"))),
+            precondition: ( (ContextKeyExpr.and(EditorContextKeys.writable, inlineEditVisible))),
+            kbOpts: {
+                weight: 100,
+                primary: KeyMod$1.Alt | KeyCode.BracketLeft,
+            },
+        });
+    }
+    async run(accessor, editor) {
+        const controller = InlineEditsController.get(editor);
+        controller?.model.get()?.previous();
+    }
+}
+class TriggerInlineEditAction extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.action.inlineEdits.trigger',
+            ...labelAndAlias(( localize2WithPath(_moduleId, 2, "Trigger Inline Edit"))),
+            precondition: EditorContextKeys.writable
+        });
+    }
+    async run(accessor, editor) {
+        const controller = InlineEditsController.get(editor);
+        await asyncTransaction(async (tx) => {
+            await controller?.model.get()?.triggerExplicitly(tx);
+        });
+    }
+}
+class AcceptInlineEdit extends EditorAction {
+    constructor() {
+        super({
+            id: inlineEditAcceptId,
+            ...labelAndAlias(( localize2WithPath(_moduleId, 3, "Accept Inline Edit"))),
+            precondition: inlineEditVisible,
+            menuOpts: {
+                menuId: MenuId.InlineEditsActions,
+                title: ( localizeWithPath(_moduleId, 4, "Accept Inline Edit")),
+                group: 'primary',
+                order: 1,
+                icon: Codicon.check,
+            },
+            kbOpts: {
+                primary: KeyMod$1.CtrlCmd | KeyCode.Space,
+                weight: 20000,
+                kbExpr: inlineEditVisible,
+            }
+        });
+    }
+    async run(accessor, editor) {
+        if (editor instanceof EmbeddedCodeEditorWidget) {
+            editor = editor.getParentEditor();
+        }
+        const controller = InlineEditsController.get(editor);
+        if (controller) {
+            controller.model.get()?.accept(controller.editor);
+            controller.editor.focus();
+        }
+    }
+}
+class HideInlineEdit extends EditorAction {
+    static { this.ID = 'editor.action.inlineEdits.hide'; }
+    constructor() {
+        super({
+            id: HideInlineEdit.ID,
+            ...labelAndAlias(( localize2WithPath(_moduleId, 5, "Hide Inline Edit"))),
+            precondition: inlineEditVisible,
+            kbOpts: {
+                weight: 100,
+                primary: KeyCode.Escape,
+            }
+        });
+    }
+    async run(accessor, editor) {
+        const controller = InlineEditsController.get(editor);
+        transaction(tx => {
+            controller?.model.get()?.stop(tx);
+        });
+    }
+}
+export { AcceptInlineEdit, HideInlineEdit, ShowNextInlineEditAction, ShowPreviousInlineEditAction, TriggerInlineEditAction };

package/vscode/src/vs/editor/contrib/inlineEdits/browser/consts.js

@@ -0,0 +1,9 @@
+import { localizeWithPath } from '../../../../nls.js';
+import { RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
+const _moduleId = "vs/editor/contrib/inlineEdits/browser/consts";
+const inlineEditAcceptId = 'editor.action.inlineEdits.accept';
+const showPreviousInlineEditActionId = 'editor.action.inlineEdits.showPrevious';
+const showNextInlineEditActionId = 'editor.action.inlineEdits.showNext';
+const inlineEditVisible = ( (new RawContextKey('inlineEditsVisible', false, ( localizeWithPath(_moduleId, 0, "Whether an inline edit is visible")))));
+const isPinnedContextKey = ( (new RawContextKey('inlineEditsIsPinned', false, ( localizeWithPath(_moduleId, 1, "Whether an inline edit is visible")))));
+export { inlineEditAcceptId, inlineEditVisible, isPinnedContextKey, showNextInlineEditActionId, showPreviousInlineEditActionId };

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

@@ -0,0 +1,9 @@
+import { registerEditorContribution, registerEditorAction, EditorContributionInstantiation } from '../../../browser/editorExtensions.js';
+import { TriggerInlineEditAction, ShowNextInlineEditAction, ShowPreviousInlineEditAction, AcceptInlineEdit, HideInlineEdit } from './commands.js';
+import { InlineEditsController } from './inlineEditsController.js';
+registerEditorContribution(InlineEditsController.ID, InlineEditsController, EditorContributionInstantiation.Eventually);
+registerEditorAction(TriggerInlineEditAction);
+registerEditorAction(ShowNextInlineEditAction);
+registerEditorAction(ShowPreviousInlineEditAction);
+registerEditorAction(AcceptInlineEdit);
+registerEditorAction(HideInlineEdit);

package/vscode/src/vs/editor/contrib/inlineEdits/browser/inlineEditsController.js

@@ -0,0 +1,82 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { observableValue } from '../../../../base/common/observableInternal/base.js';
+import { derived, derivedDisposable, derivedWithSetter } from '../../../../base/common/observableInternal/derived.js';
+import '../../../../base/common/observableInternal/autorun.js';
+import { derivedObservableWithCache } from '../../../../base/common/observableInternal/utils.js';
+import '../../../../base/common/cancellation.js';
+import '../../../../base/common/arrays.js';
+import { observableCodeEditor } from '../../../browser/observableCodeEditor.js';
+import { readHotReloadableExport } from '../../../browser/widget/diffEditor/utils.js';
+import { Selection } from '../../../common/core/selection.js';
+import { ILanguageFeatureDebounceService } from '../../../common/services/languageFeatureDebounce.js';
+import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';
+import { inlineEditVisible, isPinnedContextKey } from './consts.js';
+import { InlineEditsModel } from './inlineEditsModel.js';
+import { InlineEditsWidget } from './inlineEditsWidget.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.service.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { observableConfigValue, bindContextKey } from '../../../../platform/observable/common/platformObservableUtils.js';
+var InlineEditsController_1;
+let InlineEditsController = class InlineEditsController extends Disposable {
+    static { InlineEditsController_1 = this; }
+    static { this.ID = 'editor.contrib.inlineEditsController'; }
+    static get(editor) {
+        return editor.getContribution(InlineEditsController_1.ID);
+    }
+    constructor(editor, _instantiationService, _contextKeyService, _debounceService, _languageFeaturesService, _configurationService) {
+        super();
+        this.editor = editor;
+        this._instantiationService = _instantiationService;
+        this._contextKeyService = _contextKeyService;
+        this._debounceService = _debounceService;
+        this._languageFeaturesService = _languageFeaturesService;
+        this._configurationService = _configurationService;
+        this._enabled = observableConfigValue('editor.inlineEdits.enabled', false, this._configurationService);
+        this._editorObs = observableCodeEditor(this.editor);
+        this._selection = derived(this, reader => this._editorObs.cursorSelection.read(reader) ?? ( new Selection(1, 1, 1, 1)));
+        this._debounceValue = this._debounceService.for(this._languageFeaturesService.inlineCompletionsProvider, 'InlineEditsDebounce', { min: 50, max: 50 });
+        this.model = derivedDisposable(this, reader => {
+            if (!this._enabled.read(reader)) {
+                return undefined;
+            }
+            if (this._editorObs.isReadonly.read(reader)) {
+                return undefined;
+            }
+            const textModel = this._editorObs.model.read(reader);
+            if (!textModel) {
+                return undefined;
+            }
+            const model = this._instantiationService.createInstance(readHotReloadableExport(InlineEditsModel, reader), textModel, this._editorObs.versionId, this._selection, this._debounceValue);
+            return model;
+        });
+        this._hadInlineEdit = derivedObservableWithCache(this, (reader, lastValue) => lastValue || this.model.read(reader)?.inlineEdit.read(reader) !== undefined);
+        this._widget = derivedDisposable(this, reader => {
+            if (!this._hadInlineEdit.read(reader)) {
+                return undefined;
+            }
+            return this._instantiationService.createInstance(readHotReloadableExport(InlineEditsWidget, reader), this.editor, ( this.model.map((m, reader) => m?.inlineEdit.read(reader))), flattenSettableObservable((reader) => this.model.read(reader)?.userPrompt ?? observableValue('empty', '')));
+        });
+        this._register(bindContextKey(inlineEditVisible, this._contextKeyService, r => !!this.model.read(r)?.inlineEdit.read(r)));
+        this._register(bindContextKey(isPinnedContextKey, this._contextKeyService, r => !!this.model.read(r)?.isPinned.read(r)));
+        this.model.recomputeInitiallyAndOnChange(this._store);
+        this._widget.recomputeInitiallyAndOnChange(this._store);
+    }
+};
+InlineEditsController = InlineEditsController_1 = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IContextKeyService)),
+    ( __param(3, ILanguageFeatureDebounceService)),
+    ( __param(4, ILanguageFeaturesService)),
+    ( __param(5, IConfigurationService))
+], InlineEditsController));
+function flattenSettableObservable(fn) {
+    return derivedWithSetter(undefined, reader => {
+        const obs = fn(reader);
+        return obs.read(reader);
+    }, (value, tx) => {
+        fn(undefined).set(value, tx);
+    });
+}
+export { InlineEditsController };

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

@@ -0,0 +1,240 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { timeout } from '../../../../base/common/async.js';
+import { CancellationToken, cancelOnDispose } from '../../../../base/common/cancellation.js';
+import { structuralEquals, itemsEquals } from '../../../../base/common/equals.js';
+import { BugIndicatingError } from '../../../../base/common/errors.js';
+import { Disposable, DisposableStore, toDisposable } from '../../../../base/common/lifecycle.js';
+import { observableValue, disposableObservableValue, subtransaction } from '../../../../base/common/observableInternal/base.js';
+import { derivedDisposable, derived, derivedOpts, derivedHandleChanges } from '../../../../base/common/observableInternal/derived.js';
+import '../../../../base/common/observableInternal/autorun.js';
+import { observableSignal, recomputeInitiallyAndOnChange } from '../../../../base/common/observableInternal/utils.js';
+import { ObservablePromise } from '../../../../base/common/observableInternal/promise.js';
+import { URI } from '../../../../base/common/uri.js';
+import { IDiffProviderFactoryService } from '../../../browser/widget/diffEditor/diffProviderFactoryService.js';
+import { LineRange } from '../../../common/core/lineRange.js';
+import { InlineCompletionTriggerKind } from '../../../common/languages.js';
+import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';
+import { IModelService } from '../../../common/services/model.js';
+import { provideInlineCompletions } from '../../inlineCompletions/browser/provideInlineCompletions.js';
+import { InlineEdit } from './inlineEditsWidget.js';
+var InlineEditsModel_1;
+let InlineEditsModel = class InlineEditsModel extends Disposable {
+    static { InlineEditsModel_1 = this; }
+    static { this._modelId = 0; }
+    static _createUniqueUri() {
+        return ( URI.from({ scheme: 'inline-edits', path: ( ( new Date()).toString()) + String(InlineEditsModel_1._modelId++) }));
+    }
+    constructor(textModel, _textModelVersionId, _selection, _debounceValue, languageFeaturesService, _diffProviderFactoryService, _modelService) {
+        super();
+        this.textModel = textModel;
+        this._textModelVersionId = _textModelVersionId;
+        this._selection = _selection;
+        this._debounceValue = _debounceValue;
+        this.languageFeaturesService = languageFeaturesService;
+        this._diffProviderFactoryService = _diffProviderFactoryService;
+        this._modelService = _modelService;
+        this._forceUpdateExplicitlySignal = observableSignal(this);
+        this._selectedInlineCompletionId = observableValue(this, undefined);
+        this._isActive = observableValue(this, false);
+        this._originalModel = derivedDisposable(() => this._modelService.createModel('', null, InlineEditsModel_1._createUniqueUri())).keepObserved(this._store);
+        this._modifiedModel = derivedDisposable(() => this._modelService.createModel('', null, InlineEditsModel_1._createUniqueUri())).keepObserved(this._store);
+        this._pinnedRange = ( new TrackedRange(this.textModel, this._textModelVersionId));
+        this.isPinned = ( this._pinnedRange.range.map(range => !!range));
+        this.userPrompt = observableValue(this, undefined);
+        this.inlineEdit = derived(this, reader => {
+            return this._inlineEdit.read(reader)?.promiseResult.read(reader)?.data;
+        });
+        this._inlineEdit = derived(this, reader => {
+            const edit = this.selectedInlineEdit.read(reader);
+            if (!edit) {
+                return undefined;
+            }
+            const range = edit.inlineCompletion.range;
+            if (edit.inlineCompletion.insertText.trim() === '') {
+                return undefined;
+            }
+            let newLines = edit.inlineCompletion.insertText.split(/\r\n|\r|\n/);
+            function removeIndentation(lines) {
+                const indentation = lines[0].match(/^\s*/)?.[0] ?? '';
+                return ( lines.map(l => l.replace(( new RegExp('^' + indentation)), '')));
+            }
+            newLines = removeIndentation(newLines);
+            const existing = this.textModel.getValueInRange(range);
+            let existingLines = existing.split(/\r\n|\r|\n/);
+            existingLines = removeIndentation(existingLines);
+            this._originalModel.get().setValue(existingLines.join('\n'));
+            this._modifiedModel.get().setValue(newLines.join('\n'));
+            const d = this._diffProviderFactoryService.createDiffProvider({ diffAlgorithm: 'advanced' });
+            return ObservablePromise.fromFn(async () => {
+                const result = await d.computeDiff(this._originalModel.get(), this._modifiedModel.get(), {
+                    computeMoves: false,
+                    ignoreTrimWhitespace: false,
+                    maxComputationTimeMs: 1000,
+                }, CancellationToken.None);
+                if (result.identical) {
+                    return undefined;
+                }
+                return ( new InlineEdit(
+                    LineRange.fromRangeInclusive(range),
+                    removeIndentation(newLines),
+                    result.changes
+                ));
+            });
+        });
+        this._fetchStore = this._register(( new DisposableStore()));
+        this._inlineEditsFetchResult = disposableObservableValue(this, undefined);
+        this._inlineEdits = derivedOpts({ owner: this, equalsFn: structuralEquals }, reader => {
+            return this._inlineEditsFetchResult.read(reader)?.completions.map(c => ( new InlineEditData(c))) ?? [];
+        });
+        this._fetchInlineEditsPromise = derivedHandleChanges({
+            owner: this,
+            createEmptyChangeSummary: () => ({
+                inlineCompletionTriggerKind: InlineCompletionTriggerKind.Automatic
+            }),
+            handleChange: (ctx, changeSummary) => {
+                if (ctx.didChange(this._forceUpdateExplicitlySignal)) {
+                    changeSummary.inlineCompletionTriggerKind = InlineCompletionTriggerKind.Explicit;
+                }
+                return true;
+            },
+        }, async (reader, changeSummary) => {
+            this._fetchStore.clear();
+            this._forceUpdateExplicitlySignal.read(reader);
+            this._textModelVersionId.read(reader);
+            function mapValue(value, fn) {
+                return fn(value);
+            }
+            const selection = this._pinnedRange.range.read(reader) ?? mapValue(this._selection.read(reader), v => v.isEmpty() ? undefined : v);
+            if (!selection) {
+                this._inlineEditsFetchResult.set(undefined, undefined);
+                this.userPrompt.set(undefined, undefined);
+                return undefined;
+            }
+            const context = {
+                triggerKind: changeSummary.inlineCompletionTriggerKind,
+                selectedSuggestionInfo: undefined,
+                userPrompt: this.userPrompt.read(reader),
+            };
+            const token = cancelOnDispose(this._fetchStore);
+            await timeout(200, token);
+            const result = await provideInlineCompletions(this.languageFeaturesService.inlineCompletionsProvider, selection, this.textModel, context, token);
+            if (token.isCancellationRequested) {
+                return;
+            }
+            this._inlineEditsFetchResult.set(result, undefined);
+        });
+        this._filteredInlineEditItems = derivedOpts({ owner: this, equalsFn: itemsEquals() }, reader => {
+            return this._inlineEdits.read(reader);
+        });
+        this.selectedInlineCompletionIndex = derived(this, (reader) => {
+            const selectedInlineCompletionId = this._selectedInlineCompletionId.read(reader);
+            const filteredCompletions = this._filteredInlineEditItems.read(reader);
+            const idx = this._selectedInlineCompletionId === undefined ? -1
+                : filteredCompletions.findIndex(v => v.semanticId === selectedInlineCompletionId);
+            if (idx === -1) {
+                this._selectedInlineCompletionId.set(undefined, undefined);
+                return 0;
+            }
+            return idx;
+        });
+        this.selectedInlineEdit = derived(this, (reader) => {
+            const filteredCompletions = this._filteredInlineEditItems.read(reader);
+            const idx = this.selectedInlineCompletionIndex.read(reader);
+            return filteredCompletions[idx];
+        });
+        this.activeCommands = derivedOpts({ owner: this, equalsFn: itemsEquals() }, r => this.selectedInlineEdit.read(r)?.inlineCompletion.source.inlineCompletions.commands ?? []);
+        this._register(recomputeInitiallyAndOnChange(this._fetchInlineEditsPromise));
+    }
+    async trigger(tx) {
+        this._isActive.set(true, tx);
+        await this._fetchInlineEditsPromise.get();
+    }
+    async triggerExplicitly(tx) {
+        subtransaction(tx, tx => {
+            this._isActive.set(true, tx);
+            this._forceUpdateExplicitlySignal.trigger(tx);
+        });
+        await this._fetchInlineEditsPromise.get();
+    }
+    stop(tx) {
+        subtransaction(tx, tx => {
+            this.userPrompt.set(undefined, tx);
+            this._isActive.set(false, tx);
+            this._inlineEditsFetchResult.set(undefined, tx);
+            this._pinnedRange.setRange(undefined, tx);
+        });
+    }
+    async _deltaSelectedInlineCompletionIndex(delta) {
+        await this.triggerExplicitly();
+        const completions = this._filteredInlineEditItems.get() || [];
+        if (completions.length > 0) {
+            const newIdx = (this.selectedInlineCompletionIndex.get() + delta + completions.length) % completions.length;
+            this._selectedInlineCompletionId.set(completions[newIdx].semanticId, undefined);
+        }
+        else {
+            this._selectedInlineCompletionId.set(undefined, undefined);
+        }
+    }
+    async next() {
+        await this._deltaSelectedInlineCompletionIndex(1);
+    }
+    async previous() {
+        await this._deltaSelectedInlineCompletionIndex(-1);
+    }
+    togglePin() {
+        if (this.isPinned.get()) {
+            this._pinnedRange.setRange(undefined, undefined);
+        }
+        else {
+            this._pinnedRange.setRange(this._selection.get(), undefined);
+        }
+    }
+    async accept(editor) {
+        if (editor.getModel() !== this.textModel) {
+            throw ( new BugIndicatingError());
+        }
+        const edit = this.selectedInlineEdit.get();
+        if (!edit) {
+            return;
+        }
+        editor.pushUndoStop();
+        editor.executeEdits('inlineSuggestion.accept', [
+            edit.inlineCompletion.toSingleTextEdit().toSingleEditOperation()
+        ]);
+        this.stop();
+    }
+};
+InlineEditsModel = InlineEditsModel_1 = ( __decorate([
+    ( __param(4, ILanguageFeaturesService)),
+    ( __param(5, IDiffProviderFactoryService)),
+    ( __param(6, IModelService))
+], InlineEditsModel));
+class InlineEditData {
+    constructor(inlineCompletion) {
+        this.inlineCompletion = inlineCompletion;
+        this.semanticId = this.inlineCompletion.hash();
+    }
+}
+class TrackedRange extends Disposable {
+    constructor(_textModel, _versionId) {
+        super();
+        this._textModel = _textModel;
+        this._versionId = _versionId;
+        this._decorations = observableValue(this, []);
+        this.range = derived(this, reader => {
+            this._versionId.read(reader);
+            const deco = this._decorations.read(reader)[0];
+            if (!deco) {
+                return null;
+            }
+            return this._textModel.getDecorationRange(deco) ?? null;
+        });
+        this._register(toDisposable(() => {
+            this._textModel.deltaDecorations(this._decorations.get(), []);
+        }));
+    }
+    setRange(range, tx) {
+        this._decorations.set(this._textModel.deltaDecorations(this._decorations.get(), range ? [{ range, options: { description: 'trackedRange' } }] : []), tx);
+    }
+}
+export { InlineEditsModel };

package/vscode/src/vs/editor/contrib/inlineEdits/browser/inlineEditsWidget.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-editor div.inline-edits-widget{--widget-color:var(--vscode-notifications-background);.promptEditor .monaco-editor{--vscode-editor-placeholder-foreground:var(--vscode-editorGhostText-foreground)}.promptEditor,.toolbar{opacity:0;transition:opacity .2s ease-in-out}&.focused,&:hover{.promptEditor,.toolbar{opacity:1}}.preview .monaco-editor{--vscode-editor-background:var(--widget-color);.mtk1{color:var(--vscode-editorGhostText-foreground)}.current-line-margin,.view-overlays .current-line-exact{border:none}}svg{.gradient-start{stop-color:var(--vscode-editor-background)}.gradient-stop{stop-color:var(--widget-color)}}}";
+n(css,{});
+export { css, css as default };