@adecore/editor-core 0.41.1 → 0.43.0

package/src/statements.ts

@@ -0,0 +1,307 @@
+import type { EditSource } from './edit-source.ts';
+import { lineContinues } from './enter.ts';
+import type { FoldingRange } from './structure.ts';
+import { isBlank, whitespaceOf } from './line-text.ts';
+
+/* The indentation of a line text in columns, tabs taken to their stops. */
+export function indentWidth(text: string, tabSize: number): number {
+    return visualWidth(whitespaceOf(text), tabSize);
+}
+
+/* The width in columns of a text that starts a line, tabs taken to their stops. */
+export function visualWidth(text: string, tabSize: number): number {
+    let width = 0;
+
+    for (const character of text) {
+        width += character === '\t' ? tabSize - (width % tabSize) : 1;
+    }
+
+    return width;
+}
+
+/* The `{` brackets the offset is inside, innermost first. None in a string, a comment or markup, and an `${` of a template is no block. */
+export function enclosingBraces(source: EditSource, offset: number): number[] {
+    const context = source.context(offset);
+
+    if (context.mode !== 'code') {
+        return [];
+    }
+
+    const braces: number[] = [];
+
+    for (let bracket = context.bracket; bracket !== undefined; bracket = bracket.previous) {
+        if (bracket.close === '}' && bracket.template !== true) {
+            braces.push(bracket.at);
+        }
+    }
+
+    return braces;
+}
+
+/* The innermost `{` around the offset, or null. */
+export function enclosingBrace(source: EditSource, offset: number): number | null {
+    return enclosingBraces(source, offset)[0] ?? null;
+}
+
+export interface IndentGuide {
+    /* The line the guide starts on: the header, at the guide's own indent. */
+    startLine: number;
+    /* The first later line at or above the guide's indent, or the line count when the text ends first. */
+    endLine: number;
+}
+
+function nextNonBlank(source: EditSource, line: number): number {
+    let next = line + 1;
+
+    while (next < source.lineCount && isBlank(source.line(next).text)) {
+        next++;
+    }
+
+    return next;
+}
+
+/*
+ * The guide an editor draws at `column` (in columns, tabs expanded) that holds `line`: a line at that indent
+ * whose next non-blank line is deeper starts it, and the first later non-blank line at or above that indent ends it.
+ */
+export function indentGuideAt(source: EditSource, line: number, column: number, tabSize: number): IndentGuide | null {
+    if (column <= 0 || line < 0 || line >= source.lineCount) {
+        return null;
+    }
+
+    for (let start = line; start >= 0; start--) {
+        const text = source.line(start).text;
+
+        if (isBlank(text)) {
+            continue;
+        }
+
+        const indent = indentWidth(text, tabSize);
+
+        if (indent > column) {
+            continue;
+        }
+
+        const following = nextNonBlank(source, start);
+
+        if (indent < column || following >= source.lineCount || indentWidth(source.line(following).text, tabSize) <= column) {
+            return null;
+        }
+
+        let end = following;
+
+        while (end < source.lineCount && (isBlank(source.line(end).text) || indentWidth(source.line(end).text, tabSize) > column)) {
+            end++;
+        }
+
+        return end > line ? { startLine: start, endLine: end } : null;
+    }
+
+    return null;
+}
+
+const CONTINUATION_START = /^(?:\{|\.|\?\.|&&|\|\||\?\?|\+(?!\+)|-(?!-)|\?|:|else\b|catch\b|finally\b)/;
+
+/*
+ * The first line of the statement a line belongs to: a line that opens with a closer belongs to the statement of its
+ * opener, and a line the one above leaves open, or that goes on with a member access, an operator or `else`, to the one above.
+ */
+export function statementStart(source: EditSource, line: number, language: string): number {
+    let first = line;
+
+    // Each step goes up at least one line, so the walk ends.
+    while (first > 0) {
+        const info = source.line(first);
+        const lead = info.text.length - info.text.trimStart().length;
+        const opener = /^[)\]}]/.test(info.text.slice(lead)) ? source.context(info.start + lead).bracket : undefined;
+        const openerLine = opener === undefined ? first : source.lineAt(opener.at);
+
+        if (openerLine < first) {
+            first = openerLine;
+
+            continue;
+        }
+
+        const above = first - 1;
+
+        if (isBlank(source.line(above).text) || !(CONTINUATION_START.test(info.text.trimStart()) || lineContinues(source, language, above))) {
+            break;
+        }
+
+        first = above;
+    }
+
+    return first;
+}
+
+const MODIFIERS =
+    '(?:export\\s+|default\\s+|declare\\s+|abstract\\s+|async\\s+|pub(?:\\([^)]*\\))?\\s+|public\\s+|private\\s+|protected\\s+|static\\s+|final\\s+|readonly\\s+|override\\s+|unsafe\\s+|extern\\s+)*';
+
+// The outline of the editor reads headers the same way; a statement is not a declaration when it ends in a value, so `type` and `namespace` are left out.
+export const DECLARATION = new RegExp(`^${MODIFIERS}(function\\*?|class|interface|enum|trait|impl|struct|fn|func|object|record)\\b`);
+export const METHOD = /^(?:(?:public|private|protected|static|async|get|set|override|readonly|abstract)\s+)*\*?\s*([A-Za-z_$#][\w$]*)\s*[(<]/;
+export const NOT_METHODS = new Set([
+    'if',
+    'for',
+    'while',
+    'switch',
+    'catch',
+    'function',
+    'return',
+    'else',
+    'with',
+    'do',
+    'try',
+    'new',
+    'await',
+    'typeof',
+    'super',
+    'finally'
+]);
+export const BODIES = new Set(['class', 'interface', 'enum', 'trait', 'impl', 'struct', 'object', 'record']);
+/* What kind of body the offset is in: that of an interface, of another type or namespace, or none of them. */
+export function declarationBody(source: EditSource, offset: number): 'interface' | 'other' | null {
+    const brace = enclosingBrace(source, offset);
+
+    if (brace === null) {
+        return null;
+    }
+
+    const braceLine = source.lineAt(brace);
+    const own = source.line(braceLine).text.slice(0, brace - source.line(braceLine).start);
+    // A brace on a line of its own belongs to the header above it.
+    const header = own.trim() === '' && braceLine > 0 ? source.line(braceLine - 1).text : own;
+
+    if (/\binterface\b/.test(header)) {
+        return 'interface';
+    }
+
+    return /\b(?:class|enum|trait|impl|struct|object|record|namespace)\b/.test(header) ? 'other' : null;
+}
+
+export interface StatementRange {
+    /* The first line, counting the doc comment and the attributes above the code. */
+    first: number;
+    /* The first line of the code itself. */
+    code: number;
+    last: number;
+}
+
+/* The doc comment a line is part of, as the lines it spans. */
+function docCommentAt(source: EditSource, line: number): { first: number; last: number } | null {
+    let first = line;
+
+    while (first >= 0 && !source.line(first).text.trim().startsWith('/**') && source.line(first).text.trim().startsWith('*')) {
+        first--;
+    }
+
+    if (first < 0 || !source.line(first).text.trim().startsWith('/**')) {
+        return null;
+    }
+
+    let last = first;
+
+    while (last < source.lineCount - 1 && !source.line(last).text.includes('*/')) {
+        last++;
+    }
+
+    return last >= line ? { first, last } : null;
+}
+
+function isAttribute(text: string): boolean {
+    return /^\s*(?:@|#\[)/.test(text);
+}
+
+const NO_STRUCTURE: readonly FoldingRange[] = [];
+
+/* The offset of the bracket that is still open at the start of a line and is no block of statements. */
+function enclosingOpener(source: EditSource, line: number): number | null {
+    const open = source.context(source.line(line).start).bracket;
+
+    return open !== undefined && open.template !== true && !(open.close === '}' && open.block === true) ? open.at : null;
+}
+
+function chainLength(source: EditSource, offset: number): number {
+    let length = 0;
+
+    for (let bracket = source.context(offset).bracket; bracket !== undefined; bracket = bracket.previous) {
+        length++;
+    }
+
+    return length;
+}
+
+/* The last line of the statement that starts on `from`: where the brackets it opened are closed again and nothing goes on. */
+function statementLast(source: EditSource, from: number, language: string): number {
+    const depth = chainLength(source, source.line(from).start);
+    const isDo = /^\s*do\b/.test(source.line(from).text);
+
+    for (let line = from; line < source.lineCount; line++) {
+        const info = source.line(line);
+
+        if (chainLength(source, info.end) > depth || lineContinues(source, language, line)) {
+            continue;
+        }
+
+        const next = line + 1 < source.lineCount ? source.line(line + 1).text.trimStart() : '';
+
+        if (next !== '' && (CONTINUATION_START.test(next) || (isDo && /^while\b/.test(next))) && !isBlank(info.text)) {
+            continue;
+        }
+
+        return line;
+    }
+
+    return source.lineCount - 1;
+}
+
+/*
+ * The lines of the statement a line belongs to. A doc comment and the attributes right above it are part of it, a line
+ * in them stands for the statement below, and a range a server or a bracket pair folds from its first line sets its end.
+ */
+export function statementAt(source: EditSource, line: number, language: string, structure: readonly FoldingRange[] = NO_STRUCTURE): StatementRange {
+    let code = line;
+    const doc = docCommentAt(source, code);
+
+    if (doc !== null) {
+        code = doc.last + 1;
+    }
+
+    while (code < source.lineCount - 1 && isAttribute(source.line(code).text)) {
+        code++;
+    }
+
+    if (code >= source.lineCount || isBlank(source.line(code).text)) {
+        return { first: line, code: line, last: line };
+    }
+
+    // A line inside brackets a line above opened belongs to the statement of that line.
+    for (let open = enclosingOpener(source, code); open !== null; open = enclosingOpener(source, code)) {
+        code = statementStart(source, source.lineAt(open), language);
+    }
+
+    code = statementStart(source, code, language);
+    let first = code;
+
+    for (let above = first - 1; above >= 0; above = first - 1) {
+        const comment = source.line(above).text.trim().endsWith('*/') ? docCommentAt(source, above) : null;
+
+        if (comment !== null) {
+            first = comment.first;
+        } else if (isAttribute(source.line(above).text)) {
+            first = above;
+        } else {
+            break;
+        }
+    }
+
+    let last = statementLast(source, code, language);
+
+    for (const range of structure) {
+        if (range.startLine === code && range.endLine > last) {
+            last = range.endLine;
+        }
+    }
+
+    return { first, code, last };
+}

package/src/todo.ts

@@ -0,0 +1,118 @@
+import type { DocumentLine } from './rope.ts';
+import { type TypingContext, TypingContexts } from './typing-context.ts';
+
+/* The words a TODO comment starts with when a host names none. */
+export const DEFAULT_TODO_WORDS: readonly string[] = ['TODO', 'FIXME'];
+
+/* A TODO in a comment: from its word to the end of the comment on that line. */
+export interface TodoMatch {
+    from: number;
+    to: number;
+    /* Zero-based. */
+    line: number;
+    /* The word of the list it matched, as the list writes it. */
+    word: string;
+}
+
+export interface TodoOptions {
+    /* Matched as whole words in any case. `DEFAULT_TODO_WORDS` without them; an empty list finds nothing. */
+    words?: readonly string[];
+}
+
+/* What finding the TODOs of a document reads of it. */
+export interface TodoSource {
+    lineCount: number;
+    line(index: number): DocumentLine;
+    context(line: number, column: number): TypingContext;
+}
+
+const CLOSERS: Partial<Record<TypingContext['mode'], string>> = { 'block-comment': '*/', 'html-comment': '-->' };
+
+function escape(word: string): string {
+    return word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/* Null when there is nothing to look for. */
+export function todoPattern(words: readonly string[] = DEFAULT_TODO_WORDS): RegExp | null {
+    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: TodoSource, index: number, pattern: RegExp, words: readonly string[]): TodoMatch[] {
+    const line = source.line(index);
+    const result: TodoMatch[] = [];
+    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: TodoSource, options: TodoOptions = {}, first = 0, last = source.lineCount - 1): TodoMatch[] {
+    const words = options.words ?? DEFAULT_TODO_WORDS;
+    const pattern = todoPattern(words);
+
+    if (pattern === null) {
+        return [];
+    }
+
+    const result: TodoMatch[] = [];
+
+    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: string, language: string, options: TodoOptions = {}): TodoMatch[] {
+    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: string): DocumentLine[] {
+    const lines: DocumentLine[] = [];
+    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/src/types.ts

@@ -1,3 +1,5 @@
+import type { FoldingRange } from './structure.ts';
+
 /* Offsets are UTF-16 code units from the start of the document. */
 export interface Selection {
     anchor: number;
@@ -110,7 +112,21 @@ export type EditorCommand =
     | 'selectNextOccurrence'
     | 'unselectOccurrence'
     | 'selectAllOccurrences'
-    | 'addCaretPerSelectedLine';
+    | 'addCaretPerSelectedLine'
+    | 'sortLines'
+    | 'reverseLines'
+    | 'uniqueLines'
+    | 'convertIndentsToSpaces'
+    | 'convertIndentsToTabs'
+    | 'codeBlockStart'
+    | 'codeBlockEnd'
+    | 'codeBlockStartWithSelection'
+    | 'codeBlockEndWithSelection'
+    | 'completeCurrentStatement'
+    | 'moveStatementUp'
+    | 'moveStatementDown'
+    | 'hippieCompletion'
+    | 'hippieBackwardCompletion';
 
 export interface CommandOptions {
     /* Clamped to 1 through 16. */
@@ -146,4 +162,10 @@ export interface CommandOptions {
     lineSpan?: (line: number) => { first: number; last: number };
     /* Told which lines a move went to (`from` before, `to` after), so a host can take what it keeps by line along. */
     onLinesMoved?: (moves: readonly { from: number; to: number }[]) => void;
+    /* The folding ranges of the document, a language server's included, which Move Statement reads the extent of a statement from. Without it the model scans its own. */
+    structure?: () => readonly FoldingRange[];
+    /* Whether the indent guides count as blocks for the code block commands. Off unless true. */
+    indentGuides?: boolean;
+    /* The texts of the other open documents, which Hippie completion takes words from after those of this one. */
+    wordSources?: () => readonly string[];
 }

package/src/whitespace-cleanup.ts

@@ -0,0 +1,162 @@
+import { isBlank } from './line-text.ts';
+import type { DocumentLine } from './rope.ts';
+import type { DocumentChange, TextEdit } from './types.ts';
+
+/* Which lines lose the spaces and tabs at their end. */
+export type TrailingWhitespace = 'off' | 'modified' | 'all';
+
+export interface WhitespaceCleanupOptions {
+    /* Off unless set. `modified` reads the lines changed since the document was last marked as saved. */
+    trailingWhitespace?: TrailingWhitespace;
+    /* The lines a caret is on keep their trailing whitespace, so a person typing there does not lose it. On unless false. */
+    keepCaretLines?: boolean;
+    /* The blank lines at the end go, up to the last line with text and its line break. Off unless true. */
+    removeTrailingBlankLines?: boolean;
+    /* A text that does not end in a line break gets one, in the style of its first. Off unless true. */
+    ensureFinalNewline?: boolean;
+}
+
+/* What the cleanup reads of a document. */
+export interface CleanupSource {
+    lineCount: number;
+    line(index: number): DocumentLine;
+    newline(index: number): string;
+    /* Whether trailing whitespace starting at this column belongs to the text itself, such as inside a multiline string. */
+    keeps?(line: number, column: number): boolean;
+}
+
+export interface CleanupLines {
+    modified(line: number): boolean;
+    carets: ReadonlySet<number>;
+}
+
+/* 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: CleanupSource, options: WhitespaceCleanupOptions, lines: CleanupLines): TextEdit[] {
+    const edits: TextEdit[] = [];
+    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 {
+    private stretches: { from: number; to: number }[] = [];
+
+    clear(): void {
+        this.stretches = [];
+    }
+
+    /* One transaction, its changes in the coordinates of the text before it. */
+    record(changes: readonly DocumentChange[]): void {
+        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: number, end: boolean): number => {
+            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: (offset: number) => number, lineStart: (line: number) => number): number[] {
+        const result: number[] = [];
+
+        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;
+    }
+}