@codingame/monaco-vscode-api 2.2.2 → 3.0.0

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

@@ -0,0 +1,145 @@
+import { EditorAction } from '../../../browser/editorExtensions.js';
+import { EditorContextKeys } from '../../../common/editorContextKeys.js';
+import { inlineEditAcceptId, inlineEditJumpToId, inlineEditJumpBackId, inlineEditRejectId } from './commandIds.js';
+import { InlineEditController } from './inlineEditController.js';
+import { MenuId } from '../../../../platform/actions/common/actions.js';
+import { ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
+class AcceptInlineEdit extends EditorAction {
+    constructor() {
+        super({
+            id: inlineEditAcceptId,
+            label: 'Accept Inline Edit',
+            alias: 'Accept Inline Edit',
+            precondition: ( ContextKeyExpr.and(EditorContextKeys.writable, InlineEditController.inlineEditVisibleContext)),
+            kbOpts: [
+                {
+                    weight: 100  + 1,
+                    primary: 2 ,
+                    kbExpr: ( ContextKeyExpr.and(
+                        EditorContextKeys.writable,
+                        InlineEditController.inlineEditVisibleContext,
+                        InlineEditController.cursorAtInlineEditContext
+                    ))
+                }
+            ],
+            menuOpts: [{
+                    menuId: MenuId.InlineEditToolbar,
+                    title: 'Accept',
+                    group: 'primary',
+                    order: 1,
+                }],
+        });
+    }
+    async run(accessor, editor) {
+        const controller = InlineEditController.get(editor);
+        controller?.accept();
+    }
+}
+class TriggerInlineEdit extends EditorAction {
+    constructor() {
+        const activeExpr = ( ContextKeyExpr.and(
+            EditorContextKeys.writable,
+            ContextKeyExpr.not(InlineEditController.inlineEditVisibleKey)
+        ));
+        super({
+            id: 'editor.action.inlineEdit.trigger',
+            label: 'Trigger Inline Edit',
+            alias: 'Trigger Inline Edit',
+            precondition: activeExpr,
+            kbOpts: {
+                weight: 100  + 1,
+                primary: 2048  | 512  | 86 ,
+                kbExpr: activeExpr
+            },
+        });
+    }
+    async run(accessor, editor) {
+        const controller = InlineEditController.get(editor);
+        controller?.trigger();
+    }
+}
+class JumpToInlineEdit extends EditorAction {
+    constructor() {
+        const activeExpr = ( ContextKeyExpr.and(
+            EditorContextKeys.writable,
+            InlineEditController.inlineEditVisibleContext,
+            ContextKeyExpr.not(InlineEditController.cursorAtInlineEditKey)
+        ));
+        super({
+            id: inlineEditJumpToId,
+            label: 'Jump to Inline Edit',
+            alias: 'Jump to Inline Edit',
+            precondition: activeExpr,
+            kbOpts: {
+                weight: 100  + 1,
+                primary: 2048  | 512  | 86 ,
+                kbExpr: activeExpr
+            },
+            menuOpts: [{
+                    menuId: MenuId.InlineEditToolbar,
+                    title: 'Jump To Edit',
+                    group: 'primary',
+                    order: 3,
+                    when: activeExpr
+                }],
+        });
+    }
+    async run(accessor, editor) {
+        const controller = InlineEditController.get(editor);
+        controller?.jumpToCurrent();
+    }
+}
+class JumpBackInlineEdit extends EditorAction {
+    constructor() {
+        const activeExpr = ( ContextKeyExpr.and(EditorContextKeys.writable, InlineEditController.cursorAtInlineEditContext));
+        super({
+            id: inlineEditJumpBackId,
+            label: 'Jump Back from Inline Edit',
+            alias: 'Jump Back from Inline Edit',
+            precondition: activeExpr,
+            kbOpts: {
+                weight: 100  + 10,
+                primary: 2048  | 512  | 86 ,
+                kbExpr: activeExpr
+            },
+            menuOpts: [{
+                    menuId: MenuId.InlineEditToolbar,
+                    title: 'Jump Back',
+                    group: 'primary',
+                    order: 3,
+                    when: activeExpr
+                }],
+        });
+    }
+    async run(accessor, editor) {
+        const controller = InlineEditController.get(editor);
+        controller?.jumpBack();
+    }
+}
+class RejectInlineEdit extends EditorAction {
+    constructor() {
+        const activeExpr = ( ContextKeyExpr.and(EditorContextKeys.writable, InlineEditController.inlineEditVisibleContext));
+        super({
+            id: inlineEditRejectId,
+            label: 'Reject Inline Edit',
+            alias: 'Reject Inline Edit',
+            precondition: activeExpr,
+            kbOpts: {
+                weight: 100 ,
+                primary: 9 ,
+                kbExpr: activeExpr
+            },
+            menuOpts: [{
+                    menuId: MenuId.InlineEditToolbar,
+                    title: 'Reject',
+                    group: 'secondary',
+                    order: 2,
+                }],
+        });
+    }
+    async run(accessor, editor) {
+        const controller = InlineEditController.get(editor);
+        controller?.clear();
+    }
+}
+export { AcceptInlineEdit, JumpBackInlineEdit, JumpToInlineEdit, RejectInlineEdit, TriggerInlineEdit };

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

@@ -0,0 +1,188 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable, toDisposable } from '../../../../base/common/lifecycle.js';
+import './inlineEdit.css.js';
+import { Position } from '../../../common/core/position.js';
+import { Range } from '../../../common/core/range.js';
+import { ILanguageService } from '../../../common/languages/language.js';
+import { InjectedTextCursorStops } from '../../../common/model.js';
+import { LineDecoration } from '../../../common/viewLayout/lineDecorations.js';
+import { AdditionalLinesWidget } from '../../inlineCompletions/browser/ghostTextWidget.js';
+import { ColumnRange, applyObservableDecorations } from '../../inlineCompletions/browser/utils.js';
+import { observableValue } from '../../../../base/common/observableInternal/base.js';
+import { observableFromEvent } from '../../../../base/common/observableInternal/utils.js';
+import { derived } from '../../../../base/common/observableInternal/derived.js';
+const INLINE_EDIT_DESCRIPTION = 'inline-edit';
+let GhostTextWidget = class GhostTextWidget extends Disposable {
+    constructor(editor, model, languageService) {
+        super();
+        this.editor = editor;
+        this.model = model;
+        this.languageService = languageService;
+        this.isDisposed = observableValue(this, false);
+        this.currentTextModel = observableFromEvent(this.editor.onDidChangeModel, () =>  this.editor.getModel());
+        this.uiState = derived(this, reader => {
+            if (this.isDisposed.read(reader)) {
+                return undefined;
+            }
+            const textModel = this.currentTextModel.read(reader);
+            if (textModel !== this.model.targetTextModel.read(reader)) {
+                return undefined;
+            }
+            const ghostText = this.model.ghostText.read(reader);
+            if (!ghostText) {
+                return undefined;
+            }
+            let range = this.model.range?.read(reader);
+            if (range && range.startLineNumber === range.endLineNumber && range.startColumn === range.endColumn) {
+                range = undefined;
+            }
+            const isSingleLine = (range ? range.startLineNumber === range.endLineNumber : true) && ghostText.parts.length === 1 && ghostText.parts[0].lines.length === 1;
+            const isPureRemove = ghostText.parts.length === 1 && ghostText.parts[0].lines.every(l => l.length === 0);
+            const inlineTexts = [];
+            const additionalLines = [];
+            function addToAdditionalLines(lines, className) {
+                if (additionalLines.length > 0) {
+                    const lastLine = additionalLines[additionalLines.length - 1];
+                    if (className) {
+                        lastLine.decorations.push(( new LineDecoration(
+                            lastLine.content.length + 1,
+                            lastLine.content.length + 1 + lines[0].length,
+                            className,
+                            0
+                        )));
+                    }
+                    lastLine.content += lines[0];
+                    lines = lines.slice(1);
+                }
+                for (const line of lines) {
+                    additionalLines.push({
+                        content: line,
+                        decorations: className ? [( new LineDecoration(1, line.length + 1, className, 0 ))] : []
+                    });
+                }
+            }
+            const textBufferLine = textModel.getLineContent(ghostText.lineNumber);
+            let hiddenTextStartColumn = undefined;
+            let lastIdx = 0;
+            if (!isPureRemove) {
+                for (const part of ghostText.parts) {
+                    let lines = part.lines;
+                    if (range && !isSingleLine) {
+                        addToAdditionalLines(lines, INLINE_EDIT_DESCRIPTION);
+                        lines = [];
+                    }
+                    if (hiddenTextStartColumn === undefined) {
+                        inlineTexts.push({
+                            column: part.column,
+                            text: lines[0],
+                            preview: part.preview,
+                        });
+                        lines = lines.slice(1);
+                    }
+                    else {
+                        addToAdditionalLines([textBufferLine.substring(lastIdx, part.column - 1)], undefined);
+                    }
+                    if (lines.length > 0) {
+                        addToAdditionalLines(lines, INLINE_EDIT_DESCRIPTION);
+                        if (hiddenTextStartColumn === undefined && part.column <= textBufferLine.length) {
+                            hiddenTextStartColumn = part.column;
+                        }
+                    }
+                    lastIdx = part.column - 1;
+                }
+                if (hiddenTextStartColumn !== undefined) {
+                    addToAdditionalLines([textBufferLine.substring(lastIdx)], undefined);
+                }
+            }
+            const hiddenRange = hiddenTextStartColumn !== undefined ? ( new ColumnRange(hiddenTextStartColumn, textBufferLine.length + 1)) : undefined;
+            const lineNumber = (isSingleLine || !range) ? ghostText.lineNumber : range.endLineNumber - 1;
+            return {
+                inlineTexts,
+                additionalLines,
+                hiddenRange,
+                lineNumber,
+                additionalReservedLineCount: this.model.minReservedLineCount.read(reader),
+                targetTextModel: textModel,
+                range,
+                isSingleLine,
+                isPureRemove,
+                backgroundColoring: this.model.backgroundColoring.read(reader)
+            };
+        });
+        this.decorations = derived(this, reader => {
+            const uiState = this.uiState.read(reader);
+            if (!uiState) {
+                return [];
+            }
+            const decorations = [];
+            if (uiState.hiddenRange) {
+                decorations.push({
+                    range: uiState.hiddenRange.toRange(uiState.lineNumber),
+                    options: { inlineClassName: 'inline-edit-hidden', description: 'inline-edit-hidden', }
+                });
+            }
+            if (uiState.range) {
+                const ranges = [];
+                if (uiState.isSingleLine) {
+                    ranges.push(uiState.range);
+                }
+                else if (uiState.isPureRemove) {
+                    const lines = uiState.range.endLineNumber - uiState.range.startLineNumber;
+                    for (let i = 0; i < lines; i++) {
+                        const line = uiState.range.startLineNumber + i;
+                        const firstNonWhitespace = uiState.targetTextModel.getLineFirstNonWhitespaceColumn(line);
+                        const lastNonWhitespace = uiState.targetTextModel.getLineLastNonWhitespaceColumn(line);
+                        const range = ( new Range(line, firstNonWhitespace, line, lastNonWhitespace));
+                        ranges.push(range);
+                    }
+                }
+                else {
+                    const lines = uiState.range.endLineNumber - uiState.range.startLineNumber;
+                    for (let i = 0; i <= lines; i++) {
+                        const line = uiState.range.startLineNumber + i;
+                        const firstNonWhitespace = uiState.targetTextModel.getLineFirstNonWhitespaceColumn(line);
+                        const lastNonWhitespace = uiState.targetTextModel.getLineLastNonWhitespaceColumn(line);
+                        const range = ( new Range(line, firstNonWhitespace, line, lastNonWhitespace));
+                        ranges.push(range);
+                    }
+                }
+                const className = uiState.backgroundColoring ? 'inline-edit-remove backgroundColoring' : 'inline-edit-remove';
+                for (const range of ranges) {
+                    decorations.push({
+                        range,
+                        options: { inlineClassName: className, description: 'inline-edit-remove', }
+                    });
+                }
+            }
+            for (const p of uiState.inlineTexts) {
+                decorations.push({
+                    range: Range.fromPositions(( new Position(uiState.lineNumber, p.column))),
+                    options: {
+                        description: INLINE_EDIT_DESCRIPTION,
+                        after: { content: p.text, inlineClassName: p.preview ? 'inline-edit-decoration-preview' : 'inline-edit-decoration', cursorStops: InjectedTextCursorStops.Left },
+                        showIfCollapsed: true,
+                    }
+                });
+            }
+            return decorations;
+        });
+        this.additionalLinesWidget = this._register(( new AdditionalLinesWidget(this.editor, this.languageService.languageIdCodec, derived(reader => {
+            const uiState = this.uiState.read(reader);
+            return uiState && !uiState.isPureRemove ? {
+                lineNumber: uiState.lineNumber,
+                additionalLines: uiState.additionalLines,
+                minReservedLineCount: uiState.additionalReservedLineCount,
+                targetTextModel: uiState.targetTextModel,
+            } : undefined;
+        }))));
+        this._register(toDisposable(() => { this.isDisposed.set(true, undefined); }));
+        this._register(applyObservableDecorations(this.editor, this.decorations));
+    }
+    ownsViewZone(viewZoneId) {
+        return this.additionalLinesWidget.viewZoneId === viewZoneId;
+    }
+};
+GhostTextWidget = ( __decorate([
+    ( __param(2, ILanguageService))
+], GhostTextWidget));
+export { GhostTextWidget, INLINE_EDIT_DESCRIPTION };

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

@@ -0,0 +1,91 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { DisposableStore } from '../../../../base/common/lifecycle.js';
+import { HoverForeignElementAnchor } from '../../hover/browser/hoverTypes.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
+import { InlineEditController } from './inlineEditController.js';
+import { InlineEditHintsContentWidget } from './inlineEditHintsWidget.js';
+import { constObservable } from '../../../../base/common/observableInternal/utils.js';
+class InlineEditHover {
+    constructor(owner, range, controller) {
+        this.owner = owner;
+        this.range = range;
+        this.controller = controller;
+    }
+    isValidForHoverAnchor(anchor) {
+        return (anchor.type === 1
+            && this.range.startColumn <= anchor.range.startColumn
+            && this.range.endColumn >= anchor.range.endColumn);
+    }
+}
+let InlineEditHoverParticipant = class InlineEditHoverParticipant {
+    constructor(_editor, _instantiationService, _telemetryService) {
+        this._editor = _editor;
+        this._instantiationService = _instantiationService;
+        this._telemetryService = _telemetryService;
+        this.hoverOrdinal = 5;
+    }
+    suggestHoverAnchor(mouseEvent) {
+        const controller = InlineEditController.get(this._editor);
+        if (!controller) {
+            return null;
+        }
+        const target = mouseEvent.target;
+        if (target.type === 8 ) {
+            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));
+            }
+        }
+        if (target.type === 7 ) {
+            if (controller.shouldShowHoverAt(target.range)) {
+                return ( new HoverForeignElementAnchor(
+                    1000,
+                    this,
+                    target.range,
+                    mouseEvent.event.posx,
+                    mouseEvent.event.posy,
+                    false
+                ));
+            }
+        }
+        if (target.type === 6 ) {
+            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 null;
+    }
+    computeSync(anchor, lineDecorations) {
+        if (this._editor.getOption(63 ).showToolbar !== 'onHover') {
+            return [];
+        }
+        const controller = InlineEditController.get(this._editor);
+        if (controller && controller.shouldShowHoverAt(anchor.range)) {
+            return [( new InlineEditHover(this, anchor.range, controller))];
+        }
+        return [];
+    }
+    renderHoverParts(context, hoverParts) {
+        const disposableStore = ( 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;
+    }
+};
+InlineEditHoverParticipant = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, ITelemetryService))
+], InlineEditHoverParticipant));
+export { InlineEditHover, InlineEditHoverParticipant };

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

@@ -0,0 +1,12 @@
+import { registerEditorAction, registerEditorContribution } from '../../../browser/editorExtensions.js';
+import { HoverParticipantRegistry } from '../../hover/browser/hoverTypes.js';
+import { AcceptInlineEdit, RejectInlineEdit, JumpToInlineEdit, JumpBackInlineEdit, TriggerInlineEdit } from './commands.js';
+import { InlineEditHoverParticipant } from './hoverParticipant.js';
+import { InlineEditController } from './inlineEditController.js';
+registerEditorAction(AcceptInlineEdit);
+registerEditorAction(RejectInlineEdit);
+registerEditorAction(JumpToInlineEdit);
+registerEditorAction(JumpBackInlineEdit);
+registerEditorAction(TriggerInlineEdit);
+registerEditorContribution(InlineEditController.ID, InlineEditController, 3 );
+HoverParticipantRegistry.register(InlineEditHoverParticipant);

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

@@ -0,0 +1,4 @@
+import n from '../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-editor .inline-edit-remove{background-color:var(--vscode-editorGhostText-background);font-style:italic;text-decoration:line-through}.monaco-editor .inline-edit-remove.backgroundColoring{background-color:var(--vscode-diffEditor-removedLineBackground)}.monaco-editor .inline-edit-hidden{font-size:0;opacity:0}.monaco-editor .inline-edit-decoration,.monaco-editor .suggest-preview-text .inline-edit{font-style:italic}.monaco-editor .inline-completion-text-to-replace{text-decoration:underline;text-underline-position:under}.monaco-editor .inline-edit-decoration,.monaco-editor .inline-edit-decoration-preview,.monaco-editor .suggest-preview-text .inline-edit{background-color:var(--vscode-editorGhostText-background);border:1px solid var(--vscode-editorGhostText-border);color:var(--vscode-editorGhostText-foreground)!important}";
+n(css,{});
+export { css, css as default };