@adecore/editor-core 0.41.1 → 0.43.0

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';
@@ -37,10 +41,17 @@ import type {
 } from './types.ts';
 import { TypingContexts } from './typing-context.ts';
 import type { TypingContext } from './typing-context.ts';
+import { todosInLines, type TodoMatch, type TodoOptions } from './todo.ts';
+import { type LineOrder, planConvertIndents, planLineOrder } from './line-order.ts';
+import { ModifiedStretches, planWhitespaceCleanup, type WhitespaceCleanupOptions } from './whitespace-cleanup.ts';
 import { isHumpBoundary, isWordBoundary } from './words.ts';
 
 export type { DocumentLine, FindMatch, FindNextOptions, FindOptions, FoldingOptions, FoldingRange };
 
+const LINE_ORDERS: Partial<Record<EditorCommand, LineOrder>> = { sortLines: 'sort', reverseLines: 'reverse', uniqueLines: 'unique' };
+/* Where trailing whitespace is part of a string's value, which a cleanup must not change. */
+const STRING_MODES = new Set<TypingContext['mode']>(['quote', 'template', 'heredoc']);
+
 export interface OffsetRange {
     readonly from: number;
     readonly to: number;
@@ -156,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;
 
@@ -456,6 +468,7 @@ export class DocumentModel {
     private structureCache?: StructureRange[];
     private selectionHistory: Selection[][] = [];
     private typingContexts = new TypingContexts((line) => this.getLine(line));
+    private readonly modified = new ModifiedStretches();
     private statementClosers = new Map<number, { text: string; language: string }>();
     /* The carets that stand right after a `->` the editor completed, where the next keystroke decides whether it stays. */
     private arrows = new Set<number>();
@@ -463,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);
@@ -814,6 +830,52 @@ export class DocumentModel {
         return options.hints === undefined ? unique : applyFoldHints(unique, options.hints, lineAt, getLine, slice, minimum);
     }
 
+    /* The TODO comments of the lines from `first` through `last`. It reads the lexer state the editing commands keep, so after an edit only the lines from the edit on are lexed again. */
+    findTodos(language: string, options: TodoOptions = {}, first = 0, last = this.getLineCount() - 1): TodoMatch[] {
+        const source = {
+            lineCount: this.getLineCount(),
+            line: (index: number) => this.getLine(index),
+            context: (line: number, column: number) => this.typingContexts.at(line, column, language)
+        };
+
+        return todosInLines(source, options, first, last);
+    }
+
+    /* Forgets which lines changed, as when the text was just written to disk. */
+    markSaved(): void {
+        this.modified.clear();
+    }
+
+    /* The zero-based lines changed since `markSaved`, or since the document was made, undo and redo included. */
+    getModifiedLines(): number[] {
+        return this.modified.lines(
+            (offset) => this.rope.lineAt(offset),
+            (line) => this.rope.lineBounds(line).start
+        );
+    }
+
+    /*
+     * Cleans up the whitespace before a save, as one undo step: the trailing whitespace of the modified or
+     * of all lines, except on the lines with a caret and inside a multiline string of the language, the
+     * blank lines at the end, and a final line break. Returns whether the text changed.
+     */
+    cleanUpWhitespace(options: WhitespaceCleanupOptions & { language?: string } = {}): boolean {
+        const language = options.language ?? 'plaintext';
+        const modified = new Set(options.trailingWhitespace === 'modified' ? this.getModifiedLines() : []);
+
+        const source = {
+            lineCount: this.getLineCount(),
+            line: (index: number) => this.getLine(index),
+            newline: (index: number) => this.newlineAt(index),
+            keeps: (line: number, column: number) => STRING_MODES.has(this.typingContexts.at(line, column, language).mode)
+        };
+
+        const carets = new Set(this.selections.map((selection) => this.rope.lineAt(selection.head)));
+        const edits = planWhitespaceCleanup(source, options, { modified: (line) => modified.has(line), carets });
+
+        return edits.length > 0 && this.applyEdits(edits, { source: 'command' });
+    }
+
     /*
      * Types `text` at every caret as one keystroke would: it wraps a selection in a bracket or quote,
      * closes an opener, types over a closer that is already there and, in TypeScript, JavaScript and
@@ -992,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') {
@@ -1006,6 +1094,20 @@ export class DocumentModel {
             return this.editLines(command, { language, unit });
         }
 
+        const order = LINE_ORDERS[command];
+
+        if (order !== undefined) {
+            const plan = planLineOrder(this.editSource(language), this.selections, order);
+
+            return plan !== null && this.applyEdits(plan.edits, { source: 'command', selections: plan.selections });
+        }
+
+        if (command === 'convertIndentsToSpaces' || command === 'convertIndentsToTabs') {
+            const edits = planConvertIndents(this.editSource(language), this.selections, tabSize, command === 'convertIndentsToSpaces');
+
+            return edits.length > 0 && this.applyEdits(edits, { source: 'command' });
+        }
+
         if (command === 'insertTab') {
             return this.insertTab(tabSize, options);
         }
@@ -1839,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));
@@ -2738,6 +2895,10 @@ export class DocumentModel {
         const snapshot = this.getSnapshot();
 
         if (changes) {
+            for (const transaction of changes) {
+                this.modified.record(transaction);
+            }
+
             snapshot.changes = changes.map((transaction) => transaction.map((change) => ({ ...change })));
             snapshot.source = source;
 

package/src/hippie.ts

@@ -0,0 +1,290 @@
+import { isBraced, isWordCharacter } from './lexical.ts';
+import type { TextEdit } from './types.ts';
+
+/* Texts of other documents longer than this are not read for words. */
+const MAX_SOURCE_LENGTH = 2_000_000;
+
+const LETTER_OR_DIGIT = /[\p{L}\p{N}]/u;
+const LETTER = /\p{L}/u;
+
+export interface HippieOptions {
+    language: string;
+    /* The texts of the other open documents, in the order their words are offered. */
+    wordSources?: () => readonly string[];
+}
+
+interface Word {
+    text: string;
+    start: number;
+    end: number;
+}
+
+/* A word the cycle can offer. `side` tells which side of the caret a word of this document stands on. */
+interface Variant extends Word {
+    source: 'here' | 'other';
+    side: 'before' | 'after';
+}
+
+/* What the last press left, so the next one goes on from it. */
+export interface HippieCycle {
+    /* What stood at the caret before the first press, which every press of the cycle completes. */
+    prefix: string;
+    /* The length of the text each caret holds from the last press, which the next press replaces. */
+    length: number;
+    /* The carets the last press left. */
+    carets: readonly number[];
+    proposal: Pick<Variant, 'text' | 'source' | 'side'>;
+}
+
+export interface HippiePlan {
+    edits: TextEdit[];
+    carets: number[];
+    /* Null when the cycle is over and the next press starts again. */
+    cycle: HippieCycle | null;
+    /* Where the proposed word stands in this document after the edit, when it came from here. */
+    source: { from: number; to: number } | null;
+}
+
+interface Position {
+    source: 'here' | 'other';
+    index: number;
+}
+
+function isWordPart(character: string, hyphenated: boolean): boolean {
+    return isWordCharacter(character) || (hyphenated && (character === '-' || character === '*'));
+}
+
+/* The words of a text in order. A word has a letter or a digit in it. */
+export function hippieWords(text: string, hyphenated: boolean): Word[] {
+    const words: Word[] = [];
+    let start = -1;
+
+    for (let i = 0; i <= text.length; i++) {
+        const inside = i < text.length && isWordPart(text[i]!, hyphenated);
+
+        if (inside && start < 0) {
+            start = i;
+        } else if (!inside && start >= 0) {
+            const word = text.slice(start, i);
+
+            if (LETTER_OR_DIGIT.test(word)) {
+                words.push({ text: word, start, end: i });
+            }
+
+            start = -1;
+        }
+    }
+
+    return words;
+}
+
+/* Where the word before the caret starts, which is the caret itself when it is not in a word. */
+export function hippiePrefixStart(text: string, caret: number, hyphenated: boolean): number {
+    let start = caret;
+
+    while (start > 0 && isWordPart(text[start - 1]!, hyphenated)) {
+        start--;
+    }
+
+    return LETTER_OR_DIGIT.test(text.slice(start, caret)) ? start : caret;
+}
+
+/* A letter that starts a camel hump (an uppercase after a lowercase) or follows a `_`, a `-` or a digit. */
+function isHump(word: string, index: number): boolean {
+    const character = word[index]!;
+    const before = word[index - 1]!;
+
+    if (!LETTER.test(character)) {
+        return false;
+    }
+
+    const startsHump = character !== character.toLowerCase() && before !== before.toUpperCase();
+
+    return startsHump || /[\d_-]/.test(before);
+}
+
+function continues(word: string, prefix: string, wordIndex: number, prefixIndex: number): boolean {
+    if (prefixIndex === prefix.length) {
+        return true;
+    }
+
+    for (let i = wordIndex; i < word.length; i++) {
+        // The character right after the last match continues it; any other has to start a hump.
+        if (i > wordIndex && !isHump(word, i)) {
+            continue;
+        }
+
+        if (word[i]!.toLowerCase() === prefix[prefixIndex]!.toLowerCase() && continues(word, prefix, i + 1, prefixIndex + 1)) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+/* Whether a word is longer than the prefix and starts with it: the first character as typed, the rest by letters of any case or camel humps. */
+export function hippieMatches(word: string, prefix: string): boolean {
+    if (word.length <= prefix.length) {
+        return false;
+    }
+
+    return prefix === '' || (word[0] === prefix[0] && continues(word, prefix, 1, 1));
+}
+
+/* The words of this document that complete the prefix: those before the primary caret ascending, then those after it. */
+function variantsHere(text: string, carets: readonly number[], primary: number, prefix: string, hyphenated: boolean): Variant[] {
+    const before = new Map<string, Variant>();
+    const after = new Map<string, Variant>();
+
+    const words = hippieWords(text, hyphenated).filter(
+        (word) => !carets.some((caret) => word.start <= caret && caret <= word.end) && hippieMatches(word.text, prefix)
+    );
+
+    // The nearest occurrence of a repeated word stands: walk back from the caret before it, forward from it after.
+    for (const word of words.filter((entry) => entry.end <= primary).reverse()) {
+        if (!before.has(word.text)) {
+            before.set(word.text, { ...word, source: 'here', side: 'before' });
+        }
+    }
+
+    for (const word of words) {
+        if (word.end > primary && !after.has(word.text)) {
+            after.set(word.text, { ...word, source: 'here', side: 'after' });
+        }
+    }
+
+    return [...before.values()].reverse().concat([...after.values()]);
+}
+
+function variantsOther(sources: readonly string[], prefix: string, hyphenated: boolean): Variant[] {
+    const seen = new Map<string, Variant>();
+
+    for (const source of sources) {
+        if (source.length > MAX_SOURCE_LENGTH) {
+            continue;
+        }
+
+        for (const word of hippieWords(source, hyphenated)) {
+            if (!seen.has(word.text) && hippieMatches(word.text, prefix)) {
+                seen.set(word.text, { ...word, source: 'other', side: 'after' });
+            }
+        }
+    }
+
+    return [...seen.values()];
+}
+
+/* The first proposal going up is the nearest word above the caret, going down the nearest below it. */
+function homeOf(here: readonly Variant[], direction: 1 | -1): number {
+    const firstAfter = here.findIndex((variant) => variant.side === 'after');
+
+    if (direction === 1) {
+        return Math.max((firstAfter < 0 ? here.length : firstAfter) - 1, 0);
+    }
+
+    return firstAfter < 0 ? 0 : firstAfter;
+}
+
+/* Where a source runs out the cycle goes to the other documents, and from there back home. */
+function enter(here: readonly Variant[], other: readonly Variant[], direction: 1 | -1, from: 'here' | 'other'): Position | null {
+    const otherStart: Position = { source: 'other', index: direction === 1 ? other.length - 1 : 0 };
+
+    if (from === 'here' && other.length > 0) {
+        return otherStart;
+    }
+
+    if (here.length > 0) {
+        return { source: 'here', index: homeOf(here, direction) };
+    }
+
+    return other.length > 0 ? otherStart : null;
+}
+
+function step(here: readonly Variant[], other: readonly Variant[], current: Position | null, direction: 1 | -1): Position | null {
+    if (current === null) {
+        return enter(here, other, direction, 'other');
+    }
+
+    const list = current.source === 'here' ? here : other;
+    const index = current.index + (direction === 1 ? -1 : 1);
+
+    return index >= 0 && index < list.length ? { source: current.source, index } : enter(here, other, direction, current.source);
+}
+
+/* Where a word stands once the edits are made, or null when an edit reaches into it. */
+function sourceAfter(word: Word, edits: readonly TextEdit[]): { from: number; to: number } | null {
+    let delta = 0;
+
+    for (const edit of edits) {
+        if (edit.to <= word.start) {
+            delta += edit.text.length - (edit.to - edit.from);
+        } else if (edit.from < word.end) {
+            return null;
+        }
+    }
+
+    return { from: word.start + delta, to: word.end + delta };
+}
+
+/*
+ * The next proposal of Hippie completion: the word before each caret is replaced by a longer word that starts the
+ * same, the nearest in this document first, and the following presses go through the others and then through the
+ * other open documents. `cycle` is what the last press left; pass it only while nothing has moved since.
+ * `carets` is ascending and `primary` is one of them.
+ */
+export function planHippie(
+    text: string,
+    carets: readonly number[],
+    primary: number,
+    cycle: HippieCycle | null,
+    direction: 1 | -1,
+    options: HippieOptions
+): HippiePlan | null {
+    const hyphenated = !isBraced(options.language);
+    const prefix = cycle?.prefix ?? text.slice(hippiePrefixStart(text, primary, hyphenated), primary);
+    const here = variantsHere(text, carets, primary, prefix, hyphenated);
+    const other = variantsOther(options.wordSources?.() ?? [], prefix, hyphenated);
+    let current: Position | null = null;
+
+    if (cycle !== null) {
+        const index = (cycle.proposal.source === 'here' ? here : other).findIndex(
+            (variant) => variant.text === cycle.proposal.text && variant.side === cycle.proposal.side
+        );
+
+        current = index < 0 ? null : { source: cycle.proposal.source, index };
+    }
+
+    const next = step(here, other, current, direction);
+    const variant = next === null ? null : (next.source === 'here' ? here : other)[next.index]!;
+
+    if (variant === null && cycle === null) {
+        return null;
+    }
+
+    // With nothing left to offer, a cycle that is under way gives the prefix back.
+    const proposal = variant?.text ?? prefix;
+    const length = cycle?.length ?? prefix.length;
+    const edits: TextEdit[] = [];
+    const landed: number[] = [];
+    let end = 0;
+    let delta = 0;
+
+    for (const caret of carets) {
+        const from = Math.max(caret - length, end);
+
+        edits.push({ from, to: caret, text: proposal });
+        landed.push(from + delta + proposal.length);
+        delta += proposal.length - (caret - from);
+        end = caret;
+    }
+
+    return {
+        edits,
+        carets: landed,
+        cycle:
+            variant === null
+                ? null
+                : { prefix, length: proposal.length, carets: landed, proposal: { text: variant.text, source: variant.source, side: variant.side } },
+        source: variant?.source === 'here' ? sourceAfter(variant, edits) : null
+    };
+}

package/src/index.ts

@@ -4,6 +4,9 @@ export { scanBrackets, type BracketIndex, type BracketMatch } from './brackets.t
 export { findMatches, iterateMatches, findMatchFrom, replacementText, type FindMatch, type FindNextOptions, type FindOptions } from './search.ts';
 export { indentationColumn } from './structure.ts';
 export { findDocComments, MAX_DOC_COMMENTS, type DocComment } from './doc-comments.ts';
+export { DEFAULT_TODO_WORDS, findTodos, type TodoMatch, type TodoOptions } from './todo.ts';
+export { detectIndentation, type DetectedIndentation } from './line-order.ts';
+export type { TrailingWhitespace, WhitespaceCleanupOptions } from './whitespace-cleanup.ts';
 export type { FoldHints, FoldRangeHint, FoldRole, FoldSymbolHint, FoldingOptions, FoldingRange } from './structure.ts';
 
 export type {

package/src/lexical.ts

@@ -130,3 +130,12 @@ export function startsExpressionAt(text: string, from: number, to: number): bool
 export function startsExpressionAfter(character: string): boolean {
     return expressionPunctuation.has(character);
 }
+
+/* The character that ends a statement in a language, or null where a line break does. */
+export function statementTerminator(language: string): ';' | null {
+    return /^(typescript|javascript|typescriptreact|javascriptreact|tsx|jsx|ts|js|mjs|cjs|mts|cts|php|java|c|cpp|c\+\+|csharp|cs|rust|rs|dart|zig|glsl|hlsl|scala)$/i.test(
+        language
+    )
+        ? ';'
+        : null;
+}