@adecore/editor-core 0.41.1 → 0.43.0

package/dist/todo.js

@@ -0,0 +1,72 @@
+import { TypingContexts } from './typing-context.js';
+/* The words a TODO comment starts with when a host names none. */
+export const DEFAULT_TODO_WORDS = ['TODO', 'FIXME'];
+const CLOSERS = { 'block-comment': '*/', 'html-comment': '-->' };
+function escape(word) {
+    return word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/* Null when there is nothing to look for. */
+export function todoPattern(words = DEFAULT_TODO_WORDS) {
+    const usable = words.map((word) => word.trim()).filter((word) => word !== '');
+    if (usable.length === 0) {
+        return null;
+    }
+    // Longest first, so `TODO` does not stop a list that also has `TODO_LATER` short.
+    const alternatives = [...usable].sort((left, right) => right.length - left.length).map(escape);
+    return new RegExp(`(?<![\\p{L}\\p{N}_])(?:${alternatives.join('|')})(?![\\p{L}\\p{N}_])`, 'giu');
+}
+/*
+ * The TODOs on one line. A word counts only where the lexer says a comment is, so one in a string or in
+ * code is no TODO, and a second word in the same comment is part of the first one's TODO.
+ */
+export function todosOnLine(source, index, pattern, words) {
+    const line = source.line(index);
+    const result = [];
+    pattern.lastIndex = 0;
+    for (let found = pattern.exec(line.text); found !== null; found = pattern.exec(line.text)) {
+        const context = source.context(index, found.index);
+        const closer = CLOSERS[context.mode];
+        if (context.mode !== 'line-comment' && closer === undefined) {
+            continue;
+        }
+        const close = closer === undefined ? -1 : line.text.indexOf(closer, found.index + found[0].length);
+        const end = close === -1 ? line.text.length : close;
+        const word = words.find((candidate) => candidate.trim().toLowerCase() === found[0].toLowerCase()) ?? found[0];
+        result.push({ from: line.start + found.index, to: line.start + end, line: index, word: word.trim() });
+        pattern.lastIndex = Math.max(pattern.lastIndex, end);
+    }
+    return result;
+}
+/* Every TODO of the lines from `first` through `last`, in order. */
+export function todosInLines(source, options = {}, first = 0, last = source.lineCount - 1) {
+    const words = options.words ?? DEFAULT_TODO_WORDS;
+    const pattern = todoPattern(words);
+    if (pattern === null) {
+        return [];
+    }
+    const result = [];
+    for (let index = Math.max(0, first); index <= Math.min(last, source.lineCount - 1); index++) {
+        result.push(...todosOnLine(source, index, pattern, words));
+    }
+    return result;
+}
+/*
+ * The TODO comments of a text, for a host that lists them. The language decides what a comment is, as
+ * it does for the editor's own commands, and a language without comments has none.
+ */
+export function findTodos(text, language, options = {}) {
+    const lines = splitLines(text);
+    const contexts = new TypingContexts((index) => lines[index]);
+    return todosInLines({ lineCount: lines.length, line: (index) => lines[index], context: (line, column) => contexts.at(line, column, language) }, options);
+}
+function splitLines(text) {
+    const lines = [];
+    const breaks = /\r\n|\r|\n/g;
+    let start = 0;
+    for (let found = breaks.exec(text); found !== null; found = breaks.exec(text)) {
+        lines.push({ start, end: found.index, next: found.index + found[0].length, text: text.slice(start, found.index) });
+        start = found.index + found[0].length;
+    }
+    lines.push({ start, end: text.length, next: text.length, text: text.slice(start) });
+    return lines;
+}

package/dist/types.d.ts

@@ -1,3 +1,4 @@
+import type { FoldingRange } from './structure.ts';
 export interface Selection {
     anchor: number;
     head: number;
@@ -43,7 +44,7 @@ export interface EditOptions {
     joinPrevious?: boolean;
     typed?: boolean;
 }
-export type EditorCommand = 'undo' | 'redo' | 'selectAll' | 'smartHome' | 'smartEnd' | 'selectSmartHome' | 'selectSmartEnd' | 'wordLeft' | 'wordRight' | 'selectWordLeft' | 'selectWordRight' | 'deleteWordLeft' | 'deleteWordRight' | 'camelLeft' | 'camelRight' | 'selectCamelLeft' | 'selectCamelRight' | 'deleteCamelLeft' | 'deleteCamelRight' | 'expandSelection' | 'shrinkSelection' | 'smartBackspace' | 'deleteForward' | 'duplicateLine' | 'deleteLine' | 'moveLineUp' | 'moveLineDown' | 'toggleLineComment' | 'toggleBlockComment' | 'insertTab' | 'indent' | 'outdent' | 'insertNewline' | 'startNewLine' | 'startNewLineBefore' | 'splitLine' | 'joinLines' | 'toggleCase' | 'autoIndentLines' | 'addCaretAbove' | 'addCaretBelow' | 'selectNextOccurrence' | 'unselectOccurrence' | 'selectAllOccurrences' | 'addCaretPerSelectedLine';
+export type EditorCommand = 'undo' | 'redo' | 'selectAll' | 'smartHome' | 'smartEnd' | 'selectSmartHome' | 'selectSmartEnd' | 'wordLeft' | 'wordRight' | 'selectWordLeft' | 'selectWordRight' | 'deleteWordLeft' | 'deleteWordRight' | 'camelLeft' | 'camelRight' | 'selectCamelLeft' | 'selectCamelRight' | 'deleteCamelLeft' | 'deleteCamelRight' | 'expandSelection' | 'shrinkSelection' | 'smartBackspace' | 'deleteForward' | 'duplicateLine' | 'deleteLine' | 'moveLineUp' | 'moveLineDown' | 'toggleLineComment' | 'toggleBlockComment' | 'insertTab' | 'indent' | 'outdent' | 'insertNewline' | 'startNewLine' | 'startNewLineBefore' | 'splitLine' | 'joinLines' | 'toggleCase' | 'autoIndentLines' | 'addCaretAbove' | 'addCaretBelow' | 'selectNextOccurrence' | 'unselectOccurrence' | 'selectAllOccurrences' | 'addCaretPerSelectedLine' | 'sortLines' | 'reverseLines' | 'uniqueLines' | 'convertIndentsToSpaces' | 'convertIndentsToTabs' | 'codeBlockStart' | 'codeBlockEnd' | 'codeBlockStartWithSelection' | 'codeBlockEndWithSelection' | 'completeCurrentStatement' | 'moveStatementUp' | 'moveStatementDown' | 'hippieCompletion' | 'hippieBackwardCompletion';
 export interface CommandOptions {
     tabSize?: number;
     insertSpaces?: boolean;
@@ -71,4 +72,7 @@ export interface CommandOptions {
         from: number;
         to: number;
     }[]) => void;
+    structure?: () => readonly FoldingRange[];
+    indentGuides?: boolean;
+    wordSources?: () => readonly string[];
 }

package/dist/whitespace-cleanup.d.ts

@@ -0,0 +1,26 @@
+import type { DocumentLine } from './rope.ts';
+import type { DocumentChange, TextEdit } from './types.ts';
+export type TrailingWhitespace = 'off' | 'modified' | 'all';
+export interface WhitespaceCleanupOptions {
+    trailingWhitespace?: TrailingWhitespace;
+    keepCaretLines?: boolean;
+    removeTrailingBlankLines?: boolean;
+    ensureFinalNewline?: boolean;
+}
+export interface CleanupSource {
+    lineCount: number;
+    line(index: number): DocumentLine;
+    newline(index: number): string;
+    keeps?(line: number, column: number): boolean;
+}
+export interface CleanupLines {
+    modified(line: number): boolean;
+    carets: ReadonlySet<number>;
+}
+export declare function planWhitespaceCleanup(source: CleanupSource, options: WhitespaceCleanupOptions, lines: CleanupLines): TextEdit[];
+export declare class ModifiedStretches {
+    private stretches;
+    clear(): void;
+    record(changes: readonly DocumentChange[]): void;
+    lines(lineAt: (offset: number) => number, lineStart: (line: number) => number): number[];
+}

package/dist/whitespace-cleanup.js

@@ -0,0 +1,100 @@
+import { isBlank } from './line-text.js';
+/* The edits that clean up the whitespace of a text before it is saved, all in the coordinates of the text as it is. */
+export function planWhitespaceCleanup(source, options, lines) {
+    const edits = [];
+    let lastText = source.lineCount - 1;
+    if (options.removeTrailingBlankLines === true) {
+        while (lastText >= 0 && isBlank(source.line(lastText).text)) {
+            lastText--;
+        }
+    }
+    const mode = options.trailingWhitespace ?? 'off';
+    for (let index = 0; mode !== 'off' && index <= lastText; index++) {
+        const line = source.line(index);
+        const trailing = /[\t ]+$/.exec(line.text);
+        if (trailing === null) {
+            continue;
+        }
+        const kept = trailing.index;
+        if ((mode === 'modified' && !lines.modified(index)) ||
+            (options.keepCaretLines !== false && lines.carets.has(index)) ||
+            source.keeps?.(index, kept) === true) {
+            continue;
+        }
+        edits.push({ from: line.start + kept, to: line.end, text: '' });
+    }
+    const last = source.line(source.lineCount - 1);
+    if (lastText < source.lineCount - 1) {
+        edits.push({ from: lastText < 0 ? 0 : source.line(lastText + 1).start, to: last.end, text: '' });
+    }
+    // A last line that is empty, or that the cleanup emptied, already stands after a line break.
+    const end = source.line(source.lineCount - 1);
+    const emptied = edits.some((edit) => edit.from === end.start && edit.to === end.end);
+    if (options.ensureFinalNewline === true && lastText === source.lineCount - 1 && end.text !== '' && !emptied) {
+        edits.push({ from: end.end, to: end.end, text: source.lineCount > 1 ? source.newline(0) : '\n' });
+    }
+    return edits;
+}
+/*
+ * The stretches of a text that changed since it was last marked as saved, followed through every
+ * change after it, undo included. A deletion leaves an empty stretch, which still marks its line.
+ */
+export class ModifiedStretches {
+    stretches = [];
+    clear() {
+        this.stretches = [];
+    }
+    /* One transaction, its changes in the coordinates of the text before it. */
+    record(changes) {
+        const ordered = [...changes].sort((left, right) => left.from - right.from);
+        let index = 0;
+        let shift = 0;
+        // The stretches are in order and apart, so one walk over the changes maps all their offsets.
+        const map = (offset, end) => {
+            for (; index < ordered.length; index++) {
+                const change = ordered[index];
+                if (offset < change.from || (offset === change.from && !end)) {
+                    break;
+                }
+                if (offset < change.to) {
+                    return change.from + shift + (end ? change.insertedLength : 0);
+                }
+                shift += change.insertedLength - (change.to - change.from);
+            }
+            return offset + shift;
+        };
+        const next = this.stretches.map((stretch) => ({ from: map(stretch.from, false), to: map(stretch.to, true) }));
+        shift = 0;
+        for (const change of ordered) {
+            const from = change.from + shift;
+            next.push({ from, to: from + change.insertedLength });
+            shift += change.insertedLength - (change.to - change.from);
+        }
+        next.sort((left, right) => left.from - right.from);
+        this.stretches = [];
+        for (const stretch of next) {
+            const previous = this.stretches.at(-1);
+            if (previous !== undefined && stretch.from <= previous.to) {
+                previous.to = Math.max(previous.to, stretch.to);
+            }
+            else {
+                this.stretches.push({ ...stretch });
+            }
+        }
+    }
+    /* The zero-based lines the stretches touch, in order. A stretch that ends at the start of a line, such as an inserted line, does not touch it. */
+    lines(lineAt, lineStart) {
+        const result = [];
+        for (const { from, to } of this.stretches) {
+            const first = lineAt(from);
+            let last = lineAt(to);
+            if (last > first && lineStart(last) === to) {
+                last--;
+            }
+            for (let line = Math.max(first, (result.at(-1) ?? -1) + 1); line <= last; line++) {
+                result.push(line);
+            }
+        }
+        return result;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/editor-core",
-  "version": "0.41.1",
+  "version": "0.43.0",
   "type": "module",
   "exports": {
     ".": {

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 };
+        })
+    };
+}