inputFeatures.ts

import * as vscode from 'vscode';

function isInteractiveInput(editor: vscode.TextEditor | undefined): editor is vscode.TextEditor {
    return (
        editor?.document.uri.scheme === 'vscode-interactive-input' &&
        editor.document.languageId === 'r'
    );
}

function formattingOptions(editor: vscode.TextEditor): vscode.FormattingOptions {
    return {
        tabSize: typeof editor.options.tabSize === 'number' ? editor.options.tabSize : 4,
        insertSpaces:
            typeof editor.options.insertSpaces === 'boolean' ? editor.options.insertSpaces : true,
    };
}

// The native Interactive editor omits automatic formatting contributions.
// Ask VS Code's registered providers to supply the missing formatting behavior.
export class InteractiveInputFeatures implements vscode.Disposable {
    private readonly listeners: vscode.Disposable[];
    private disposed = false;
    private pasteDepth = 0;

    constructor(private readonly contextForEditor: (editor: vscode.TextEditor) => unknown) {
        this.listeners = [
            // Forward every paste to the built-in command, including other editors.
            // Unlike text-change events, this also identifies single-character pastes.
            vscode.commands.registerCommand('paste', (args: unknown) => this.paste(args)),
            vscode.workspace.onDidChangeTextDocument((event) => {
                void this.formatOnType(event).catch((error: unknown) => {
                    console.warn('R Interactive on-type formatting failed', error);
                });
            }),
        ];
    }

    private async formatOnType(event: vscode.TextDocumentChangeEvent): Promise<void> {
        const document = event.document,
            editor = vscode.window.activeTextEditor;
        if (
            this.disposed ||
            this.pasteDepth > 0 ||
            !isInteractiveInput(editor) ||
            editor.document !== document ||
            event.reason !== undefined ||
            event.contentChanges.length !== 1 ||
            editor.selections.length !== 1 ||
            !vscode.workspace.getConfiguration('editor', document).get<boolean>('formatOnType')
        ) {
            return;
        }
        const change = event.contentChanges[0];
        // Typing over an auto-inserted closing bracket replaces that character
        // with itself. VS Code still reports a one-character replacement.
        if (change.rangeLength !== 0 && (change.rangeLength !== 1 || change.text.length !== 1)) {
            return;
        }
        // Enter may also insert the indentation supplied by the language rules.
        const ch = /^\r?\n[\t ]*$/.test(change.text) ? '\n' : change.text;
        if (ch.length !== 1) {
            return;
        }
        const context = this.contextForEditor(editor);
        const version = document.version;
        // VS Code checks the provider's trigger characters and minimizes its
        // edits, preserving the cursor even for whole-expression replacements.
        const edits = await vscode.commands.executeCommand<vscode.TextEdit[]>(
            'vscode.executeFormatOnTypeProvider',
            document.uri,
            document.positionAt(change.rangeOffset + change.text.length),
            ch,
            formattingOptions(editor),
        );
        if (
            !edits?.length ||
            this.disposed ||
            document.isClosed ||
            document.version !== version ||
            vscode.window.activeTextEditor !== editor ||
            this.contextForEditor(editor) !== context ||
            !vscode.workspace.getConfiguration('editor', document).get<boolean>('formatOnType')
        ) {
            return;
        }
        await editor.edit(
            (builder) => edits.forEach((edit) => builder.replace(edit.range, edit.newText)),
            { undoStopBefore: false, undoStopAfter: false },
        );
    }

    private async nativePaste(args: unknown): Promise<void> {
        // Single-character pastes emit the same document changes as typing.
        // Suppress them even when format-on-paste is disabled.
        this.pasteDepth++;
        try {
            await vscode.commands.executeCommand('default:paste', args);
        } finally {
            this.pasteDepth--;
        }
    }

    private async paste(args: unknown): Promise<void> {
        const editor = vscode.window.activeTextEditor;
        if (
            !isInteractiveInput(editor) ||
            !vscode.workspace
                .getConfiguration('editor', editor.document)
                .get<boolean>('formatOnPaste')
        ) {
            await this.nativePaste(args);
            return;
        }
        const context = this.contextForEditor(editor),
            document = editor.document;
        const changes: vscode.TextDocumentContentChangeEvent[] = [];
        const listener = vscode.workspace.onDidChangeTextDocument((event) => {
            if (event.document === document && event.reason === undefined) {
                changes.push(...event.contentChanges);
            }
        });
        try {
            await this.nativePaste(args);
        } finally {
            listener.dispose();
        }
        if (
            this.disposed ||
            document.isClosed ||
            vscode.window.activeTextEditor !== editor ||
            editor.selections.length !== 1 ||
            changes.length !== 1 ||
            !changes[0].text ||
            this.contextForEditor(editor) !== context
        ) {
            return;
        }
        const version = document.version,
            change = changes[0];
        const range = new vscode.Range(
            document.positionAt(change.rangeOffset),
            document.positionAt(change.rangeOffset + change.text.length),
        );
        const edits = await vscode.commands.executeCommand<vscode.TextEdit[]>(
            'vscode.executeFormatRangeProvider',
            document.uri,
            range,
            formattingOptions(editor),
        );
        if (
            !edits?.length ||
            this.disposed ||
            document.isClosed ||
            document.version !== version ||
            vscode.window.activeTextEditor !== editor ||
            this.contextForEditor(editor) !== context ||
            !vscode.workspace.getConfiguration('editor', document).get<boolean>('formatOnPaste')
        ) {
            return;
        }
        // Native format-on-paste is a separate undo step: first undo the
        // formatting, then undo the paste. Keep the same behavior here.
        await editor.edit((builder) => {
            edits.forEach((edit) => builder.replace(edit.range, edit.newText));
        });
    }

    dispose(): void {
        this.disposed = true;
        this.listeners.forEach((listener) => {
            listener.dispose();
        });
    }
}