@adecore/editor-core 0.42.0 → 0.43.0

package/src/code-blocks.ts

@@ -0,0 +1,93 @@
+import type { EditSource } from './edit-source.ts';
+import { isBlank, textStart } from './line-text.ts';
+import { enclosingBraces, indentGuideAt, visualWidth } from './statements.ts';
+import type { Selection } from './types.ts';
+
+export interface CodeBlockOptions {
+    tabSize: number;
+    /* Whether the guides count as blocks too, which is the only block in a language without braces. */
+    guides: boolean;
+    /* The offset of the bracket that pairs with the one at an offset. */
+    mate(offset: number): number | undefined;
+}
+
+function guideTarget(source: EditSource, head: number, edge: 'start' | 'end', options: CodeBlockOptions): number | null {
+    const line = source.lineAt(head);
+    const info = source.line(line);
+    const column = visualWidth(info.text.slice(0, head - info.start), options.tabSize);
+    const guide = indentGuideAt(source, line, column, options.tabSize);
+
+    if (guide === null) {
+        return null;
+    }
+
+    if (edge === 'start') {
+        return guide.startLine === line ? null : textStart(source.line(guide.startLine));
+    }
+
+    if (guide.endLine >= source.lineCount) {
+        return source.line(source.lineCount - 1).end;
+    }
+
+    const last = source.line(guide.endLine);
+
+    return isBlank(last.text) ? last.end : textStart(last);
+}
+
+function braceTarget(source: EditSource, head: number, edge: 'start' | 'end', options: CodeBlockOptions): number | null {
+    if (edge === 'end') {
+        if (source.charAt(head) === '{') {
+            const mate = options.mate(head);
+
+            if (mate !== undefined && mate > head) {
+                return mate + 1;
+            }
+        }
+
+        for (const brace of enclosingBraces(source, head)) {
+            const mate = options.mate(brace);
+
+            // A caret already in front of the closer goes on to the block around it.
+            if (mate !== undefined && mate > head) {
+                return mate;
+            }
+        }
+
+        return null;
+    }
+
+    if (head > 0 && source.charAt(head - 1) === '}') {
+        const mate = options.mate(head - 1);
+
+        if (mate !== undefined && mate < head) {
+            return mate;
+        }
+    }
+
+    for (const brace of enclosingBraces(source, head)) {
+        if (brace + 1 < head) {
+            return brace + 1;
+        }
+    }
+
+    return null;
+}
+
+/* Where each caret goes for Code Block Start or End; a caret with no block around it stays. The selection extends from its anchor when `extend` is set. */
+export function planCodeBlock(
+    source: EditSource,
+    selections: readonly Selection[],
+    edge: 'start' | 'end',
+    extend: boolean,
+    options: CodeBlockOptions
+): Selection[] {
+    return selections.map((selection) => {
+        const target = (options.guides ? guideTarget(source, selection.head, edge, options) : null) ?? braceTarget(source, selection.head, edge, options);
+
+        if (target === null) {
+            return selection;
+        }
+
+        return { anchor: extend ? selection.anchor : target, head: target };
+    });
+}

package/src/complete-statement.ts

@@ -0,0 +1,231 @@
+import type { EditPlan, EditSource } from './edit-source.ts';
+import { continues, planEnter } from './enter.ts';
+import { isBraced, statementTerminator } from './lexical.ts';
+import { whitespaceOf } from './line-text.ts';
+import { BODIES, DECLARATION, declarationBody, METHOD, NOT_METHODS, statementStart } from './statements.ts';
+import type { Selection } from './types.ts';
+
+export interface CompleteStatementOptions {
+    language: string;
+    /* One level of indentation. */
+    unit: string;
+    tabSize: number;
+}
+
+/* A replacement of `[from, to)` and where the caret lands in its text. */
+interface Piece {
+    from: number;
+    to: number;
+    text: string;
+    caret: number;
+}
+
+const CONTROL = /^(?:else\s+if|elseif|if|for|foreach|while|switch|catch|with)\b/;
+const PYTHON_BLOCK = /^(?:async\s+)?(?:if|elif|else|for|while|def|class|try|except|finally|with|match|case)\b/;
+
+function startNewLine(source: EditSource, line: number, options: CompleteStatementOptions): Piece {
+    const end = source.line(line).end;
+
+    return planEnter(source, end, end, { ...options, smart: true, reach: false });
+}
+
+/* The offset a statement on this line ends at: before a trailing comment and the whitespace in front of it. Null where the line is not code. */
+function statementEnd(source: EditSource, line: number, caret: number): number | null {
+    const info = source.line(line);
+
+    if (/comment/.test(source.context(caret).mode)) {
+        return null;
+    }
+
+    const atEnd = source.context(info.end);
+    let end = info.end;
+
+    if (atEnd.mode === 'line-comment' && atEnd.commentStart !== undefined) {
+        end = atEnd.commentStart;
+    }
+
+    while (end > info.start && /\s/.test(source.charAt(end - 1))) {
+        end--;
+    }
+
+    if (end === info.start) {
+        return null;
+    }
+
+    const mode = source.context(end).mode;
+
+    return mode === 'code' || mode === 'quote' ? end : null;
+}
+
+/* The parenthesis of a control statement closes at the end of the text: `if (a)`, and no body after it. */
+function endsWithCondition(head: string): boolean {
+    const open = head.indexOf('(');
+
+    if (open < 0) {
+        return false;
+    }
+
+    let depth = 0;
+
+    for (let i = open; i < head.length; i++) {
+        depth += head[i] === '(' ? 1 : head[i] === ')' ? -1 : 0;
+
+        if (depth === 0) {
+            return i === head.length - 1;
+        }
+    }
+
+    return false;
+}
+
+function completeBraced(source: EditSource, lineIndex: number, caret: number, options: CompleteStatementOptions): Piece {
+    const line = source.line(lineIndex);
+    const end = statementEnd(source, lineIndex, caret);
+
+    if (end === null || (source.region(lineIndex) ?? 'script') !== 'script') {
+        return startNewLine(source, lineIndex, options);
+    }
+
+    const context = source.context(end);
+    const first = statementStart(source, lineIndex, options.language);
+    const firstStart = source.line(first).start;
+    const startsWithBrace = /^\s*\}/.test(line.text);
+    let inline = context.mode === 'quote' ? (context.quote ?? '') : '';
+    let open = context.bracket;
+
+    for (; open !== undefined && open.template !== true && !(open.close === '}' && open.block === true) && open.at >= firstStart; open = open.previous) {
+        inline += open.close;
+    }
+
+    const tail = source.slice(end, line.end);
+    const newline = source.newline(lineIndex);
+    const indent = whitespaceOf(startsWithBrace ? line.text : source.line(first).text);
+    const body = indent + options.unit;
+    const written = (startsWithBrace ? source.slice(line.start, end) : source.slice(firstStart, end)) + inline;
+    const head = (startsWithBrace ? written.trim().slice(1) : written).trim();
+    const nothing = (): Piece => startNewLine(source, lineIndex, options);
+
+    const replaceTail = (text: string, caretAt: number): Piece => ({ from: end, to: line.end, text, caret: caretAt });
+
+    // A block with its closer on a line of its own and the caret on the line between.
+    const block = (opener: string, closer = '}'): Piece => {
+        const opened = `${inline}${opener}${tail}${newline}${body}`;
+
+        return replaceTail(`${opened}${newline}${indent}${closer}`, opened.length);
+    };
+
+    if (inline === '' && head.endsWith('{}') && source.context(end - 1).bracket?.block === true) {
+        return { from: end - 1, to: line.end, text: `${newline}${body}${newline}${indent}}${tail}`, caret: newline.length + body.length };
+    }
+
+    if (inline === '' && head.endsWith('{')) {
+        if (tail === '') {
+            return startNewLine(source, lineIndex, options);
+        }
+
+        const opened = `${tail}${newline}${body}`;
+
+        return replaceTail(source.unclosedBrace(end - 1) ? `${opened}${newline}${indent}}` : opened, opened.length);
+    }
+
+    const control = CONTROL.exec(head);
+    const condition = control === null ? null : head.slice(control[0].length).trim();
+
+    if (control !== null && condition === '') {
+        return replaceTail(`${inline} () {${tail}${newline}${indent}}`, inline.length + 2);
+    }
+
+    if (control !== null && !(control[0] === 'while' && startsWithBrace) && condition!.startsWith('(') && endsWithCondition(condition!)) {
+        return block(' {');
+    }
+
+    if (/^(?:else|try|finally|do)$/.test(head)) {
+        return block(' {', head === 'do' ? '} while ();' : '}');
+    }
+
+    if ((/^case\b/.test(head) && head.length > 4 && !head.endsWith(':')) || head === 'default') {
+        const text = `${inline}:${tail}${newline}${body}`;
+
+        return replaceTail(text, text.length);
+    }
+
+    const declaring = declarationBody(source, end);
+    const declaration = DECLARATION.exec(head)?.[1];
+    const method = declaration === undefined && declaring === 'other' ? METHOD.exec(head)?.[1] : undefined;
+
+    if (declaring !== 'interface' && (declaration !== undefined || (method !== undefined && !NOT_METHODS.has(method)))) {
+        const bodiless = /^(?:\w+\s+)*?(?:abstract|declare)\s/.test(head) && !BODIES.has(declaration ?? '');
+
+        if (!bodiless) {
+            return block(' {');
+        }
+    }
+
+    const terminator = statementTerminator(options.language);
+    const last = head.at(-1);
+
+    const closedBlock = inline === '' && last === '}' && source.context(end - 1).bracket?.block === true;
+    const inExpression = open !== undefined && !(open.close === '}' && open.block === true);
+    const goesOn = inline === '' && continues(source.slice(line.start, end), context, options.language);
+
+    const ends = terminator !== null && head !== '' && !/^(?:@|#\[)/.test(head) && !';{,:'.includes(last!) && !closedBlock && !inExpression && !goesOn;
+
+    const added = inline + (ends ? terminator : '');
+
+    return added === '' ? nothing() : { from: end, to: end, text: added, caret: added.length };
+}
+
+function completePython(source: EditSource, lineIndex: number, caret: number, options: CompleteStatementOptions): Piece {
+    const line = source.line(lineIndex);
+    const end = statementEnd(source, lineIndex, caret);
+
+    if (end === null || source.context(end).mode !== 'code') {
+        return startNewLine(source, lineIndex, options);
+    }
+
+    let inline = '';
+
+    for (let open = source.context(end).bracket; open !== undefined; open = open.previous) {
+        inline += open.close;
+    }
+
+    const head = (source.slice(line.start, end) + inline).trim();
+    const tail = source.slice(end, line.end);
+
+    if (PYTHON_BLOCK.test(head) && !head.endsWith(':')) {
+        const text = `${inline}:${tail}${source.newline(lineIndex)}${whitespaceOf(line.text)}${options.unit}`;
+
+        return { from: end, to: line.end, text, caret: text.length };
+    }
+
+    return inline === '' ? startNewLine(source, lineIndex, options) : { from: end, to: end, text: inline, caret: inline.length };
+}
+
+/* Where Complete Current Statement puts its edits for the carets. Every caret acts on its line, and carets on one line count once. */
+export function planCompleteStatement(source: EditSource, selections: readonly Selection[], options: CompleteStatementOptions): EditPlan {
+    const complete = isBraced(options.language) ? completeBraced : /^(python|py)$/i.test(options.language) ? completePython : null;
+    const pieces = new Map<number, Piece>();
+
+    for (const selection of selections) {
+        const line = source.lineAt(selection.head);
+        pieces.set(line, complete === null ? startNewLine(source, line, options) : complete(source, line, selection.head, options));
+    }
+
+    const ordered = [...pieces.entries()].sort((left, right) => left[1].from - right[1].from);
+    const carets = new Map<number, number>();
+    let delta = 0;
+
+    for (const [line, piece] of ordered) {
+        carets.set(line, piece.from + delta + piece.caret);
+        delta += piece.text.length - (piece.to - piece.from);
+    }
+
+    return {
+        edits: ordered.map(([, piece]) => ({ from: piece.from, to: piece.to, text: piece.text })),
+        selections: selections.map((selection) => {
+            const caret = carets.get(source.lineAt(selection.head))!;
+
+            return { anchor: caret, head: caret };
+        })
+    };
+}

package/src/document.ts

@@ -2,6 +2,10 @@ import { scriptSource } from './script-source.ts';
 import { CloserTracker } from './closer-tracker.ts';
 import { planBlockComment, planLineComments } from './comments.ts';
 import { planEnter } from './enter.ts';
+import { planCodeBlock } from './code-blocks.ts';
+import { planCompleteStatement } from './complete-statement.ts';
+import { planMoveStatement, statementMoveMode } from './statement-move.ts';
+import { planHippie, type HippieCycle, type HippieOptions } from './hippie.ts';
 import { planAutoIndent, planJoinLines, planToggleCase, properIndent, spacingBetween } from './line-commands.ts';
 import { mapOffset, offsetMapper } from './offsets.ts';
 import { planPaste } from './paste.ts';
@@ -163,6 +167,7 @@ const identifier = /[\p{L}\p{N}\p{M}\p{Pc}$]/u;
 /* What can follow `->`: the first letter of a member name, or the `{` of a dynamic one. */
 const arrowContinues = /^[\p{L}_{]/u;
 const wordCommand = /^(select|delete)?(word|camel)(Left|Right)$/i;
+const codeBlockCommand = /^codeBlock(Start|End)(WithSelection)?$/;
 
 let graphemes: Intl.Segmenter | undefined;
 
@@ -471,6 +476,9 @@ export class DocumentModel {
     private occurrenceSession: { wholeWord: boolean; notFound: boolean; signature: string } | undefined;
     /* The last select next occurrence found no more, which a host may say. */
     occurrencesExhausted = false;
+    /* Where the word the last Hippie completion took from this document stands, which a view reads right after the command to show it. */
+    hippieSource: { from: number; to: number } | null = null;
+    private hippieState: { cycle: HippieCycle; revision: number } | null = null;
     private closers = new CloserTracker();
     private bracketCache?: { revision: number; language: string; index: BracketIndex };
     private bracketTracker = new BracketTracker(() => this.rope);
@@ -1046,6 +1054,32 @@ export class DocumentModel {
             );
         }
 
+        if (command === 'moveStatementUp' || command === 'moveStatementDown') {
+            return this.moveStatements(command === 'moveStatementUp' ? -1 : 1, { language, unit, tabSize }, options);
+        }
+
+        if (command === 'hippieCompletion' || command === 'hippieBackwardCompletion') {
+            return this.completeFromWords(command === 'hippieCompletion' ? 1 : -1, { language, wordSources: options.wordSources });
+        }
+
+        if (command === 'completeCurrentStatement') {
+            const plan = planCompleteStatement(this.editSource(language), this.selections, { language, unit, tabSize });
+
+            return this.applyEdits(plan.edits, { source: 'command', selections: plan.selections });
+        }
+
+        const blockMatch = codeBlockCommand.exec(command);
+
+        if (blockMatch) {
+            const plan = planCodeBlock(this.editSource(language), this.selections, blockMatch[1] === 'Start' ? 'start' : 'end', blockMatch[2] !== undefined, {
+                tabSize,
+                guides: options.indentGuides === true,
+                mate: (offset) => this.matchBracket(offset, language)?.mate
+            });
+
+            return this.changeSelections(plan);
+        }
+
         const enter = { language, unit, tabSize, smart: options.smartEnter !== false, reach: true };
 
         if (command === 'insertNewline' || command === 'startNewLine' || command === 'splitLine') {
@@ -1907,6 +1941,61 @@ export class DocumentModel {
         return this.applyEdits(edits, { source: 'command', selections });
     }
 
+    /* Moves the statement at each caret past its neighbor; a language without brackets or indentation to go by moves lines. */
+    private moveStatements(direction: -1 | 1, settings: { language: string; unit: string; tabSize: number }, options: CommandOptions): boolean {
+        if (statementMoveMode(settings.language) === null) {
+            return this.moveLines(this.selectedLines(options.lineSpan), direction, options);
+        }
+
+        const structure = options.structure?.() ?? this.getFoldingRanges({ language: settings.language, tabSize: settings.tabSize });
+        const plan = planMoveStatement(this.editSource(settings.language), this.selections, direction, { ...settings, structure, lineSpan: options.lineSpan });
+
+        if (plan === null) {
+            return false;
+        }
+
+        const changed = this.applyEdits(plan.edits, { source: 'command', selections: plan.selections });
+
+        if (changed) {
+            options.onLinesMoved?.(plan.moves);
+        }
+
+        return changed;
+    }
+
+    /* Hippie completion: the word before every caret becomes the next longer word that starts the same, from this document and then from the others. */
+    private completeFromWords(direction: -1 | 1, options: HippieOptions): boolean {
+        const carets = this.selections.map((selection) => selection.head).sort((a, b) => a - b);
+        const primary = this.selections.at(-1)!.head;
+        const held = this.hippieState;
+        const continues =
+            held !== null &&
+            held.revision === this.revision &&
+            held.cycle.carets.length === carets.length &&
+            held.cycle.carets.every((caret, i) => caret === carets[i]);
+        const plan = planHippie(this.getText(), carets, primary, continues ? held.cycle : null, direction, options);
+
+        this.hippieState = null;
+        this.hippieSource = null;
+
+        if (plan === null) {
+            return false;
+        }
+
+        const primaryIndex = carets.indexOf(primary);
+        const landed = plan.carets.map((caret) => ({ anchor: caret, head: caret }));
+        const [primaryCaret] = landed.splice(primaryIndex, 1);
+
+        this.applyEdits(plan.edits, { source: 'command', selections: [...landed, primaryCaret!] });
+
+        if (plan.cycle !== null) {
+            this.hippieState = { cycle: plan.cycle, revision: this.revision };
+            this.hippieSource = plan.source;
+        }
+
+        return true;
+    }
+
     private moveLines(indices: readonly number[], direction: -1 | 1, options: CommandOptions): boolean {
         const span: LineSpanOf = options.lineSpan ?? ((line) => ({ first: line, last: line }));
         const groups = blocks(indices).filter((block) => (direction === -1 ? block.first > 0 : block.last < this.getLineCount() - 1));