@codingame/monaco-vscode-api 7.0.11 → 7.1.1

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

@@ -1,9 +1,9 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { Disposable } from '../../../../base/common/lifecycle.js';
-import { disposableObservableValue, observableValue, transaction } from '../../../../base/common/observableInternal/base.js';
-import '../../../../base/common/observableInternal/derived.js';
+import { observableValue, transaction } from '../../../../base/common/observableInternal/base.js';
+import { derivedDisposable } from '../../../../base/common/observableInternal/derived.js';
 import { autorun } from '../../../../base/common/observableInternal/autorun.js';
-import { observableFromEvent, constObservable, observableSignalFromEvent } from '../../../../base/common/observableInternal/utils.js';
+import { observableFromEvent, observableSignalFromEvent, constObservable } from '../../../../base/common/observableInternal/utils.js';
 import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
 import '../../../../base/common/arrays.js';
 import { onUnexpectedExternalError } from '../../../../base/common/errors.js';
@@ -22,27 +22,21 @@ import { InlineEditHintsWidget } from './inlineEditHintsWidget.js';
 import { EditorOption } from '../../../common/config/editorOptions.js';
 import { createStyleSheet2 } from '../../../../base/browser/dom.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
+import { InlineEditSideBySideWidget } from './inlineEditSideBySideWidget.js';
+import { IDiffProviderFactoryService } from '../../../browser/widget/diffEditor/diffProviderFactoryService.js';
+import { IModelService } from '../../../common/services/model.js';
 var InlineEditController_1;
-class InlineEditWidget {
-    constructor(widget, edit) {
-        this.widget = widget;
-        this.edit = edit;
-    }
-    dispose() {
-        this.widget.dispose();
-    }
-}
 let InlineEditController = class InlineEditController extends Disposable {
     static { InlineEditController_1 = this; }
     static { this.ID = 'editor.contrib.inlineEditController'; }
     static { this.inlineEditVisibleKey = 'inlineEditVisible'; }
-    static { this.inlineEditVisibleContext = ( new RawContextKey(InlineEditController_1.inlineEditVisibleKey, false)); }
+    static { this.inlineEditVisibleContext = ( new RawContextKey(this.inlineEditVisibleKey, false)); }
     static { this.cursorAtInlineEditKey = 'cursorAtInlineEdit'; }
-    static { this.cursorAtInlineEditContext = ( new RawContextKey(InlineEditController_1.cursorAtInlineEditKey, false)); }
+    static { this.cursorAtInlineEditContext = ( new RawContextKey(this.cursorAtInlineEditKey, false)); }
     static get(editor) {
         return editor.getContribution(InlineEditController_1.ID);
     }
-    constructor(editor, instantiationService, contextKeyService, languageFeaturesService, _commandService, _configurationService) {
+    constructor(editor, instantiationService, contextKeyService, languageFeaturesService, _commandService, _configurationService, _diffProviderFactoryService, _modelService) {
         super();
         this.editor = editor;
         this.instantiationService = instantiationService;
@@ -50,13 +44,36 @@ let InlineEditController = class InlineEditController extends Disposable {
         this.languageFeaturesService = languageFeaturesService;
         this._commandService = _commandService;
         this._configurationService = _configurationService;
+        this._diffProviderFactoryService = _diffProviderFactoryService;
+        this._modelService = _modelService;
         this._isVisibleContext = InlineEditController_1.inlineEditVisibleContext.bindTo(this.contextKeyService);
         this._isCursorAtInlineEditContext = InlineEditController_1.cursorAtInlineEditContext.bindTo(this.contextKeyService);
-        this._currentEdit = this._register(disposableObservableValue(this, undefined));
+        this._currentEdit = observableValue(this, undefined);
+        this._currentWidget = derivedDisposable(this._currentEdit, (reader) => {
+            const edit = this._currentEdit.read(reader);
+            if (!edit) {
+                return undefined;
+            }
+            const line = edit.range.endLineNumber;
+            const column = edit.range.endColumn;
+            const textToDisplay = edit.text.endsWith('\n') && !(edit.range.startLineNumber === edit.range.endLineNumber && edit.range.startColumn === edit.range.endColumn) ? edit.text.slice(0, -1) : edit.text;
+            const ghostText = ( new GhostText(line, [( new GhostTextPart(column, textToDisplay, false))]));
+            const isSingleLine = edit.range.startLineNumber === edit.range.endLineNumber && ghostText.parts.length === 1 && ghostText.parts[0].lines.length === 1;
+            const isPureRemoval = edit.text === '';
+            if (!isSingleLine && !isPureRemoval) {
+                return undefined;
+            }
+            const instance = this.instantiationService.createInstance(GhostTextWidget, this.editor, {
+                ghostText: constObservable(ghostText),
+                minReservedLineCount: constObservable(0),
+                targetTextModel: constObservable(this.editor.getModel() ?? undefined),
+                range: constObservable(edit.range)
+            });
+            return instance;
+        });
         this._isAccepting = observableValue(this, false);
         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)) {
@@ -122,14 +139,21 @@ let InlineEditController = class InlineEditController extends Disposable {
 	font-family: ${fontFamily};
 }`);
         }));
-        this._register(( new InlineEditHintsWidget(this.editor, this._currentEdit, this.instantiationService)));
+        this._register(( new InlineEditHintsWidget(this.editor, this._currentWidget, this.instantiationService)));
+        this._register(( new InlineEditSideBySideWidget(
+            this.editor,
+            this._currentEdit,
+            this.instantiationService,
+            this._diffProviderFactoryService,
+            this._modelService
+        )));
     }
     checkCursorPosition(position) {
         if (!this._currentEdit) {
             this._isCursorAtInlineEditContext.set(false);
             return;
         }
-        const gt = this._currentEdit.get()?.edit;
+        const gt = this._currentEdit.get();
         if (!gt) {
             this._isCursorAtInlineEditContext.set(false);
             return;
@@ -194,18 +218,7 @@ let InlineEditController = class InlineEditController extends Disposable {
         if (!edit) {
             return;
         }
-        const line = edit.range.endLineNumber;
-        const column = edit.range.endColumn;
-        const textToDisplay = edit.text.endsWith('\n') && !(edit.range.startLineNumber === edit.range.endLineNumber && edit.range.startColumn === edit.range.endColumn) ? edit.text.slice(0, -1) : edit.text;
-        const ghostText = ( new GhostText(line, [( new GhostTextPart(column, textToDisplay, false))]));
-        const instance = this.instantiationService.createInstance(GhostTextWidget, this.editor, {
-            ghostText: constObservable(ghostText),
-            minReservedLineCount: constObservable(0),
-            targetTextModel: constObservable(this.editor.getModel() ?? undefined),
-            range: constObservable(edit.range),
-            backgroundColoring: this._backgroundColoring
-        });
-        this._currentEdit.set(( new InlineEditWidget(instance, edit)), undefined);
+        this._currentEdit.set(edit, undefined);
     }
     async trigger() {
         await this.getInlineEdit(this.editor, false);
@@ -219,7 +232,7 @@ let InlineEditController = class InlineEditController extends Disposable {
     }
     async accept() {
         this._isAccepting.set(true, undefined);
-        const data = this._currentEdit.get()?.edit;
+        const data = this._currentEdit.get();
         if (!data) {
             return;
         }
@@ -242,7 +255,7 @@ let InlineEditController = class InlineEditController extends Disposable {
     }
     jumpToCurrent() {
         this._jumpBackPosition = this.editor.getSelection()?.getStartPosition();
-        const data = this._currentEdit.get()?.edit;
+        const data = this._currentEdit.get();
         if (!data) {
             return;
         }
@@ -251,7 +264,7 @@ let InlineEditController = class InlineEditController extends Disposable {
         this.editor.revealPositionInCenterIfOutsideViewport(position);
     }
     async clear(sendRejection = true) {
-        const edit = this._currentEdit.get()?.edit;
+        const edit = this._currentEdit.get();
         if (edit && edit?.rejected && sendRejection) {
             await this._commandService
                 .executeCommand(edit.rejected.id, ...(edit.rejected.arguments || []))
@@ -275,11 +288,15 @@ let InlineEditController = class InlineEditController extends Disposable {
     }
     shouldShowHoverAt(range) {
         const currentEdit = this._currentEdit.get();
+        const currentWidget = this._currentWidget.get();
         if (!currentEdit) {
             return false;
         }
-        const edit = currentEdit.edit;
-        const model = currentEdit.widget.model;
+        if (!currentWidget) {
+            return false;
+        }
+        const edit = currentEdit;
+        const model = currentWidget.model;
         const overReplaceRange = Range.containsPosition(edit.range, range.getStartPosition()) || Range.containsPosition(edit.range, range.getEndPosition());
         if (overReplaceRange) {
             return true;
@@ -291,7 +308,7 @@ let InlineEditController = class InlineEditController extends Disposable {
         return false;
     }
     shouldShowHoverAtViewZone(viewZoneId) {
-        return this._currentEdit.get()?.widget.ownsViewZone(viewZoneId) ?? false;
+        return this._currentWidget.get()?.ownsViewZone(viewZoneId) ?? false;
     }
 };
 InlineEditController = InlineEditController_1 = ( __decorate([
@@ -299,7 +316,9 @@ InlineEditController = InlineEditController_1 = ( __decorate([
     ( __param(2, IContextKeyService)),
     ( __param(3, ILanguageFeaturesService)),
     ( __param(4, ICommandService)),
-    ( __param(5, IConfigurationService))
+    ( __param(5, IConfigurationService)),
+    ( __param(6, IDiffProviderFactoryService)),
+    ( __param(7, IModelService))
 ], InlineEditController));
 function wait(ms, cancellationToken) {
     return ( new Promise(resolve => {
@@ -321,4 +340,4 @@ function wait(ms, cancellationToken) {
         }
     }));
 }
-export { InlineEditController, InlineEditWidget };
+export { InlineEditController };

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

@@ -34,7 +34,7 @@ let InlineEditHintsWidget = class InlineEditHintsWidget extends Disposable {
         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);
+            const ghostText = this.model.read(reader)?.model.ghostText.read(reader);
             if (!this.alwaysShowToolbar.read(reader) || !ghostText || ghostText.parts.length === 0) {
                 this.sessionPosition = undefined;
                 return null;

package/vscode/src/vs/editor/contrib/inlineEdit/browser/inlineEditSideBySideWidget.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-editor .inlineEditSideBySide{background-color:var(--vscode-editorHoverWidget-background);border:1px solid var(--vscode-editorHoverWidget-border);color:var(--vscode-editorHoverWidget-foreground);white-space:pre;z-index:39}";
+n(css,{});
+export { css, css as default };

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

@@ -0,0 +1,301 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { $ } from '../../../../base/browser/dom.js';
+import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { Disposable, toDisposable } from '../../../../base/common/lifecycle.js';
+import '../../../../base/common/arrays.js';
+import { derived, derivedDisposable } from '../../../../base/common/observableInternal/derived.js';
+import { autorunWithStore, autorun } from '../../../../base/common/observableInternal/autorun.js';
+import { observableSignalFromEvent } from '../../../../base/common/observableInternal/utils.js';
+import { ObservablePromise } from '../../../../base/common/observableInternal/promise.js';
+import { URI } from '../../../../base/common/uri.js';
+import './inlineEditSideBySideWidget.css.js';
+import { observableCodeEditor } from '../../../browser/observableCodeEditor.js';
+import { EmbeddedCodeEditorWidget } from '../../../browser/widget/codeEditor/embeddedCodeEditorWidget.js';
+import { IDiffProviderFactoryService } from '../../../browser/widget/diffEditor/diffProviderFactoryService.js';
+import { diffLineDeleteDecorationBackgroundWithIndicator, diffLineAddDecorationBackgroundWithIndicator, diffWholeLineDeleteDecoration, diffWholeLineAddDecoration, diffDeleteDecorationEmpty, diffDeleteDecoration, diffAddDecorationEmpty, diffAddDecoration } from '../../../browser/widget/diffEditor/registrations.contribution.js';
+import { EditorOption } from '../../../common/config/editorOptions.js';
+import { Position } from '../../../common/core/position.js';
+import { Range } from '../../../common/core/range.js';
+import { PLAINTEXT_LANGUAGE_ID } from '../../../common/languages/modesRegistry.js';
+import { TextModel } from '../../../common/model/textModel.js';
+import { IModelService } from '../../../common/services/model.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+var InlineEditSideBySideWidget_1, InlineEditSideBySideContentWidget_1;
+function* range(start, end, step = 1) {
+    if (end === undefined) {
+        [end, start] = [start, 0];
+    }
+    for (let n = start; n < end; n += step) {
+        yield n;
+    }
+}
+function removeIndentation(lines) {
+    const indentation = lines[0].match(/^\s*/)?.[0] ?? '';
+    const length = indentation.length;
+    return {
+        text: ( lines.map(l => l.replace(( new RegExp('^' + indentation)), ''))),
+        shift: length
+    };
+}
+let InlineEditSideBySideWidget = class InlineEditSideBySideWidget extends Disposable {
+    static { InlineEditSideBySideWidget_1 = this; }
+    static { this._modelId = 0; }
+    static _createUniqueUri() {
+        return ( URI.from({ scheme: 'inline-edit-widget', path: ( ( new Date()).toString()) + String(InlineEditSideBySideWidget_1._modelId++) }));
+    }
+    constructor(_editor, _model, _instantiationService, _diffProviderFactoryService, _modelService) {
+        super();
+        this._editor = _editor;
+        this._model = _model;
+        this._instantiationService = _instantiationService;
+        this._diffProviderFactoryService = _diffProviderFactoryService;
+        this._modelService = _modelService;
+        this._position = derived(this, reader => {
+            const ghostText = this._model.read(reader);
+            if (!ghostText || ghostText.text.length === 0) {
+                return null;
+            }
+            if (ghostText.range.startLineNumber === ghostText.range.endLineNumber && !(ghostText.range.startColumn === ghostText.range.endColumn && ghostText.range.startColumn === 1)) {
+                return null;
+            }
+            const editorModel = this._editor.getModel();
+            if (!editorModel) {
+                return null;
+            }
+            const lines = Array.from(range(ghostText.range.startLineNumber, ghostText.range.endLineNumber + 1));
+            const lengths = ( lines.map(lineNumber => editorModel.getLineLastNonWhitespaceColumn(lineNumber)));
+            const maxColumn = Math.max(...lengths);
+            const lineOfMaxColumn = lines[lengths.indexOf(maxColumn)];
+            const position = ( new Position(lineOfMaxColumn, maxColumn));
+            const pos = {
+                top: ghostText.range.startLineNumber,
+                left: position
+            };
+            return pos;
+        });
+        this._text = derived(this, reader => {
+            const ghostText = this._model.read(reader);
+            if (!ghostText) {
+                return { text: '', shift: 0 };
+            }
+            const t = removeIndentation(ghostText.text.split('\n'));
+            return {
+                text: t.text.join('\n'),
+                shift: t.shift
+            };
+        });
+        this._originalModel = derivedDisposable(() => this._modelService.createModel('', null, InlineEditSideBySideWidget_1._createUniqueUri())).keepObserved(this._store);
+        this._modifiedModel = derivedDisposable(() => this._modelService.createModel('', null, InlineEditSideBySideWidget_1._createUniqueUri())).keepObserved(this._store);
+        this._diff = derived(this, reader => {
+            return this._diffPromise.read(reader)?.promiseResult.read(reader)?.data;
+        });
+        this._diffPromise = derived(this, reader => {
+            const ghostText = this._model.read(reader);
+            if (!ghostText) {
+                return;
+            }
+            const editorModel = this._editor.getModel();
+            if (!editorModel) {
+                return;
+            }
+            const originalText = removeIndentation(editorModel.getValueInRange(ghostText.range).split('\n')).text.join('\n');
+            const modifiedText = removeIndentation(ghostText.text.split('\n')).text.join('\n');
+            this._originalModel.get().setValue(originalText);
+            this._modifiedModel.get().setValue(modifiedText);
+            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 result.changes;
+            });
+        });
+        this._register(autorunWithStore((reader, store) => {
+            const model = this._model.read(reader);
+            if (!model) {
+                return;
+            }
+            if (this._position.get() === null) {
+                return;
+            }
+            const contentWidget = store.add(this._instantiationService.createInstance(InlineEditSideBySideContentWidget, this._editor, this._position, ( this._text.map(t => t.text)), ( this._text.map(t => t.shift)), this._diff));
+            _editor.addOverlayWidget(contentWidget);
+            store.add(toDisposable(() => _editor.removeOverlayWidget(contentWidget)));
+        }));
+    }
+};
+InlineEditSideBySideWidget = InlineEditSideBySideWidget_1 = ( __decorate([
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IDiffProviderFactoryService)),
+    ( __param(4, IModelService))
+], InlineEditSideBySideWidget));
+let InlineEditSideBySideContentWidget = class InlineEditSideBySideContentWidget extends Disposable {
+    static { InlineEditSideBySideContentWidget_1 = this; }
+    static { this._dropDownVisible = false; }
+    static get dropDownVisible() { return this._dropDownVisible; }
+    static { this.id = 0; }
+    constructor(_editor, _position, _text, _shift, _diff, _instantiationService) {
+        super();
+        this._editor = _editor;
+        this._position = _position;
+        this._text = _text;
+        this._shift = _shift;
+        this._diff = _diff;
+        this._instantiationService = _instantiationService;
+        this.id = `InlineEditSideBySideContentWidget${InlineEditSideBySideContentWidget_1.id++}`;
+        this.allowEditorOverflow = false;
+        this._nodes = $('div.inlineEditSideBySide', undefined);
+        this._scrollChanged = observableSignalFromEvent('editor.onDidScrollChange', this._editor.onDidScrollChange);
+        this._previewEditor = this._register(this._instantiationService.createInstance(EmbeddedCodeEditorWidget, this._nodes, {
+            glyphMargin: false,
+            lineNumbers: 'off',
+            minimap: { enabled: false },
+            guides: {
+                indentation: false,
+                bracketPairs: false,
+                bracketPairsHorizontal: false,
+                highlightActiveIndentation: false,
+            },
+            folding: false,
+            selectOnLineNumbers: false,
+            selectionHighlight: false,
+            columnSelection: false,
+            overviewRulerBorder: false,
+            overviewRulerLanes: 0,
+            lineDecorationsWidth: 0,
+            lineNumbersMinChars: 0,
+            scrollbar: { vertical: 'hidden', horizontal: 'hidden', alwaysConsumeMouseWheel: false, handleMouseWheel: false },
+            readOnly: true,
+            wordWrap: 'off',
+            wordWrapOverride1: 'off',
+            wordWrapOverride2: 'off',
+            wrappingIndent: 'none',
+            wrappingStrategy: undefined,
+        }, { contributions: [], isSimpleWidget: true }, this._editor));
+        this._previewEditorObs = observableCodeEditor(this._previewEditor);
+        this._editorObs = observableCodeEditor(this._editor);
+        this._previewTextModel = this._register(this._instantiationService.createInstance(TextModel, '', this._editor.getModel()?.getLanguageId() ?? PLAINTEXT_LANGUAGE_ID, TextModel.DEFAULT_CREATION_OPTIONS, null));
+        this._setText = derived(reader => {
+            const edit = this._text.read(reader);
+            if (!edit) {
+                return;
+            }
+            this._previewTextModel.setValue(edit);
+        }).recomputeInitiallyAndOnChange(this._store);
+        this._decorations = derived(this, (reader) => {
+            this._setText.read(reader);
+            const position = this._position.read(reader);
+            if (!position) {
+                return { org: [], mod: [] };
+            }
+            const diff = this._diff.read(reader);
+            if (!diff) {
+                return { org: [], mod: [] };
+            }
+            const originalDecorations = [];
+            const modifiedDecorations = [];
+            if (diff.length === 1 && diff[0].innerChanges[0].modifiedRange.equalsRange(this._previewTextModel.getFullModelRange())) {
+                return { org: [], mod: [] };
+            }
+            const shift = this._shift.get();
+            const moveRange = (range) => {
+                return ( new Range(
+                    range.startLineNumber + position.top - 1,
+                    range.startColumn + shift,
+                    range.endLineNumber + position.top - 1,
+                    range.endColumn + shift
+                ));
+            };
+            for (const m of diff) {
+                if (!m.original.isEmpty) {
+                    originalDecorations.push({ range: moveRange(m.original.toInclusiveRange()), options: diffLineDeleteDecorationBackgroundWithIndicator });
+                }
+                if (!m.modified.isEmpty) {
+                    modifiedDecorations.push({ range: m.modified.toInclusiveRange(), options: diffLineAddDecorationBackgroundWithIndicator });
+                }
+                if (m.modified.isEmpty || m.original.isEmpty) {
+                    if (!m.original.isEmpty) {
+                        originalDecorations.push({ range: moveRange(m.original.toInclusiveRange()), options: diffWholeLineDeleteDecoration });
+                    }
+                    if (!m.modified.isEmpty) {
+                        modifiedDecorations.push({ range: m.modified.toInclusiveRange(), options: diffWholeLineAddDecoration });
+                    }
+                }
+                else {
+                    for (const i of m.innerChanges || []) {
+                        if (m.original.contains(i.originalRange.startLineNumber)) {
+                            originalDecorations.push({ range: moveRange(i.originalRange), options: i.originalRange.isEmpty() ? diffDeleteDecorationEmpty : diffDeleteDecoration });
+                        }
+                        if (m.modified.contains(i.modifiedRange.startLineNumber)) {
+                            modifiedDecorations.push({ range: i.modifiedRange, options: i.modifiedRange.isEmpty() ? diffAddDecorationEmpty : diffAddDecoration });
+                        }
+                    }
+                }
+            }
+            return { org: originalDecorations, mod: modifiedDecorations };
+        });
+        this._originalDecorations = derived(this, reader => {
+            return this._decorations.read(reader).org;
+        });
+        this._modifiedDecorations = derived(this, reader => {
+            return this._decorations.read(reader).mod;
+        });
+        this._previewEditor.setModel(this._previewTextModel);
+        this._register(this._editorObs.setDecorations(this._originalDecorations));
+        this._register(this._previewEditorObs.setDecorations(this._modifiedDecorations));
+        this._register(autorun(reader => {
+            const width = this._previewEditorObs.contentWidth.read(reader);
+            const lines = this._text.read(reader).split('\n').length - 1;
+            const height = this._editor.getOption(EditorOption.lineHeight) * lines;
+            if (width <= 0) {
+                return;
+            }
+            this._previewEditor.layout({ height: height, width: width });
+        }));
+        this._register(autorun(reader => {
+            this._position.read(reader);
+            this._editor.layoutOverlayWidget(this);
+        }));
+        this._register(autorun(reader => {
+            this._scrollChanged.read(reader);
+            const position = this._position.read(reader);
+            if (!position) {
+                return;
+            }
+            this._editor.layoutOverlayWidget(this);
+        }));
+    }
+    getId() { return this.id; }
+    getDomNode() {
+        return this._nodes;
+    }
+    getPosition() {
+        const position = this._position.get();
+        if (!position) {
+            return null;
+        }
+        const layoutInfo = this._editor.getLayoutInfo();
+        const visibPos = this._editor.getScrolledVisiblePosition(( new Position(position.top, 1)));
+        if (!visibPos) {
+            return null;
+        }
+        const top = visibPos.top - 1;
+        const offset = this._editor.getOffsetForColumn(position.left.lineNumber, position.left.column);
+        const left = layoutInfo.contentLeft + offset + 10;
+        return {
+            preference: {
+                left,
+                top,
+            }
+        };
+    }
+};
+InlineEditSideBySideContentWidget = InlineEditSideBySideContentWidget_1 = ( __decorate([
+    ( __param(5, IInstantiationService))
+], InlineEditSideBySideContentWidget));
+export { InlineEditSideBySideWidget };

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

@@ -11,10 +11,9 @@ import { EmbeddedCodeEditorWidget } from '../../../browser/widget/codeEditor/emb
 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 { localize2, localize } 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,
@@ -26,7 +25,7 @@ class ShowNextInlineEditAction extends EditorAction {
     constructor() {
         super({
             id: ShowNextInlineEditAction.ID,
-            ...labelAndAlias(( localize2WithPath(_moduleId, 0, "Show Next Inline Edit"))),
+            ...labelAndAlias(( localize2(5234, "Show Next Inline Edit"))),
             precondition: ( (ContextKeyExpr.and(EditorContextKeys.writable, inlineEditVisible))),
             kbOpts: {
                 weight: 100,
@@ -44,7 +43,7 @@ class ShowPreviousInlineEditAction extends EditorAction {
     constructor() {
         super({
             id: ShowPreviousInlineEditAction.ID,
-            ...labelAndAlias(( localize2WithPath(_moduleId, 1, "Show Previous Inline Edit"))),
+            ...labelAndAlias(( localize2(5235, "Show Previous Inline Edit"))),
             precondition: ( (ContextKeyExpr.and(EditorContextKeys.writable, inlineEditVisible))),
             kbOpts: {
                 weight: 100,
@@ -61,7 +60,7 @@ class TriggerInlineEditAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.inlineEdits.trigger',
-            ...labelAndAlias(( localize2WithPath(_moduleId, 2, "Trigger Inline Edit"))),
+            ...labelAndAlias(( localize2(5236, "Trigger Inline Edit"))),
             precondition: EditorContextKeys.writable
         });
     }
@@ -76,11 +75,11 @@ class AcceptInlineEdit extends EditorAction {
     constructor() {
         super({
             id: inlineEditAcceptId,
-            ...labelAndAlias(( localize2WithPath(_moduleId, 3, "Accept Inline Edit"))),
+            ...labelAndAlias(( localize2(5237, "Accept Inline Edit"))),
             precondition: inlineEditVisible,
             menuOpts: {
                 menuId: MenuId.InlineEditsActions,
-                title: ( localizeWithPath(_moduleId, 4, "Accept Inline Edit")),
+                title: ( localize(5238, "Accept Inline Edit")),
                 group: 'primary',
                 order: 1,
                 icon: Codicon.check,
@@ -108,7 +107,7 @@ class HideInlineEdit extends EditorAction {
     constructor() {
         super({
             id: HideInlineEdit.ID,
-            ...labelAndAlias(( localize2WithPath(_moduleId, 5, "Hide Inline Edit"))),
+            ...labelAndAlias(( localize2(5239, "Hide Inline Edit"))),
             precondition: inlineEditVisible,
             kbOpts: {
                 weight: 100,

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

@@ -1,9 +1,8 @@
-import { localizeWithPath } from '../../../../nls.js';
+import { localize } 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")))));
+const inlineEditVisible = ( (new RawContextKey('inlineEditsVisible', false, ( localize(9891, "Whether an inline edit is visible")))));
+const isPinnedContextKey = ( (new RawContextKey('inlineEditsIsPinned', false, ( localize(9892, "Whether an inline edit is visible")))));
 export { inlineEditAcceptId, inlineEditVisible, isPinnedContextKey, showNextInlineEditActionId, showPreviousInlineEditActionId };

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

@@ -7,7 +7,7 @@ import { derivedObservableWithCache } from '../../../../base/common/observableIn
 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 { readHotReloadableExport } from '../../../../base/common/hotReloadHelpers.js';
 import { Selection } from '../../../common/core/selection.js';
 import { ILanguageFeatureDebounceService } from '../../../common/services/languageFeatureDebounce.js';
 import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';

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

@@ -17,7 +17,7 @@ import { EditorOption } from '../../../common/config/editorOptions.js';
 import { PLAINTEXT_LANGUAGE_ID } from '../../../common/languages/modesRegistry.js';
 import { TextModel } from '../../../common/model/textModel.js';
 import { ContextMenuController } from '../../contextmenu/browser/contextmenu.js';
-import { PlaceholderTextContribution } from '../../placeholderText/browser/placeholderText.contribution.js';
+import { PlaceholderTextContribution } from '../../placeholderText/browser/placeholderTextContribution.js';
 import { SuggestController } from '../../suggest/browser/suggestController.js';
 import { MenuWorkbenchToolBar } from '../../../../platform/actions/browser/toolbar.js';
 import { MenuId } from '../../../../platform/actions/common/actions.js';

package/vscode/src/vs/editor/contrib/lineSelection/browser/lineSelection.js

@@ -3,14 +3,13 @@ import { registerEditorAction, EditorAction } from '../../../browser/editorExten
 import { CursorChangeReason } from '../../../common/cursorEvents.js';
 import { CursorMoveCommands } from '../../../common/cursor/cursorMoveCommands.js';
 import { EditorContextKeys } from '../../../common/editorContextKeys.js';
-import { localizeWithPath } from '../../../../nls.js';
+import { localize } from '../../../../nls.js';
 import { KeybindingWeight } from '../../../../platform/keybinding/common/keybindingsRegistry.js';
-const _moduleId = "vs/editor/contrib/lineSelection/browser/lineSelection";
 class ExpandLineSelectionAction extends EditorAction {
     constructor() {
         super({
             id: 'expandLineSelection',
-            label: ( localizeWithPath(_moduleId, 0, "Expand Line Selection")),
+            label: ( localize(1799, "Expand Line Selection")),
             alias: 'Expand Line Selection',
             precondition: undefined,
             kbOpts: {