@adecore/editor-core 0.41.1 → 0.43.0

package/dist/hippie.js

@@ -0,0 +1,183 @@
+import { isBraced, isWordCharacter } from './lexical.js';
+/* 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;
+function isWordPart(character, hyphenated) {
+    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, hyphenated) {
+    const words = [];
+    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, caret, hyphenated) {
+    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, index) {
+    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, prefix, wordIndex, prefixIndex) {
+    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, prefix) {
+    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, carets, primary, prefix, hyphenated) {
+    const before = new Map();
+    const after = new Map();
+    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, prefix, hyphenated) {
+    const seen = new Map();
+    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, direction) {
+    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, other, direction, from) {
+    const otherStart = { 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, other, current, direction) {
+    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, edits) {
+    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, carets, primary, cycle, direction, options) {
+    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 = 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 = [];
+    const landed = [];
+    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/dist/index.d.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 { ChangeSource, CommandOptions, ContentEdit, Disposable, DocumentChange, EditOptions, EditorCommand, EditorSnapshot, Position, Selection, TextEdit } from './types.ts';
 export { changedSpan, changedSpans, type TextSpan } from './text-span.ts';

package/dist/index.js

@@ -3,4 +3,6 @@ export { scanBrackets } from './brackets.js';
 export { findMatches, iterateMatches, findMatchFrom, replacementText } from './search.js';
 export { indentationColumn } from './structure.js';
 export { findDocComments, MAX_DOC_COMMENTS } from './doc-comments.js';
+export { DEFAULT_TODO_WORDS, findTodos } from './todo.js';
+export { detectIndentation } from './line-order.js';
 export { changedSpan, changedSpans } from './text-span.js';

package/dist/lexical.d.ts

@@ -21,3 +21,4 @@ export declare function isWordCharacter(character: string): boolean;
 export declare function startsExpression(word: string): boolean;
 export declare function startsExpressionAt(text: string, from: number, to: number): boolean;
 export declare function startsExpressionAfter(character: string): boolean;
+export declare function statementTerminator(language: string): ';' | null;

package/dist/lexical.js

@@ -78,3 +78,9 @@ export function startsExpressionAt(text, from, to) {
 export function startsExpressionAfter(character) {
     return expressionPunctuation.has(character);
 }
+/* The character that ends a statement in a language, or null where a line break does. */
+export function statementTerminator(language) {
+    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;
+}

package/dist/line-order.d.ts

@@ -0,0 +1,10 @@
+import type { EditPlan, EditSource } from './edit-source.ts';
+import type { Selection, TextEdit } from './types.ts';
+export type LineOrder = 'sort' | 'reverse' | 'unique';
+export declare function planLineOrder(source: EditSource, selections: readonly Selection[], order: LineOrder): EditPlan | null;
+export declare function planConvertIndents(source: EditSource, selections: readonly Selection[], tabSize: number, insertSpaces: boolean): TextEdit[];
+export interface DetectedIndentation {
+    insertSpaces: boolean;
+    tabSize?: number;
+}
+export declare function detectIndentation(text: string): DetectedIndentation | null;

package/dist/line-order.js

@@ -0,0 +1,156 @@
+import { indentText, rangeOf, whitespaceOf } from './line-text.js';
+import { indentationColumn } from './structure.js';
+/* The runs of lines the selections touch, or every line when nothing is selected. A selection that ends at the start of a line does not touch it. */
+function runsOf(source, selections) {
+    const ranges = selections.map(rangeOf).filter(({ from, to }) => from !== to);
+    const wanted = ranges.length > 0 ? ranges : [{ from: 0, to: source.line(source.lineCount - 1).end }];
+    const runs = [];
+    for (const { from, to } of [...wanted].sort((left, right) => left.from - right.from)) {
+        const first = source.lineAt(from);
+        let last = source.lineAt(to);
+        if (last > first && source.line(last).start === to) {
+            last--;
+        }
+        const previous = runs.at(-1);
+        if (previous !== undefined && first <= previous.last) {
+            previous.last = Math.max(previous.last, last);
+        }
+        else {
+            runs.push({ first, last });
+        }
+    }
+    return runs;
+}
+function reorder(lines, order) {
+    if (order === 'reverse') {
+        return [...lines].reverse();
+    }
+    if (order === 'unique') {
+        return [...new Set(lines)];
+    }
+    return [...lines].sort((left, right) => (left < right ? -1 : left > right ? 1 : 0));
+}
+/*
+ * Sorts, reverses or dedupes the lines the selections touch, or the whole text with nothing selected,
+ * each run of lines on its own. Every line break stays where it was, so a last line without one stays
+ * without one. Sorting compares by code unit, so capitals come first, and keeps equal lines in order;
+ * dedupe keeps the first of equal lines. A selection keeps its offsets, as far as the text still reaches.
+ */
+export function planLineOrder(source, selections, order) {
+    const edits = [];
+    const runs = [];
+    for (const { first, last } of runsOf(source, selections)) {
+        if (last <= first) {
+            continue;
+        }
+        const lines = [];
+        const breaks = [];
+        for (let index = first; index <= last; index++) {
+            lines.push(source.line(index).text);
+            if (index < last) {
+                breaks.push(source.newline(index));
+            }
+        }
+        const result = reorder(lines, order);
+        const text = result.map((line, index) => line + (index < result.length - 1 ? breaks[index] : '')).join('');
+        const from = source.line(first).start;
+        const to = source.line(last).end;
+        if (text !== source.slice(from, to)) {
+            edits.push({ from, to, text });
+            runs.push({ from, to, length: text.length });
+        }
+    }
+    if (edits.length === 0) {
+        return null;
+    }
+    const place = (offset) => {
+        let shift = 0;
+        for (const run of runs) {
+            if (offset < run.from) {
+                break;
+            }
+            if (offset < run.to) {
+                return Math.min(offset, run.from + run.length) + shift;
+            }
+            shift += run.length - (run.to - run.from);
+        }
+        return offset + shift;
+    };
+    return { edits, selections: selections.map((selection) => ({ anchor: place(selection.anchor), head: place(selection.head) })) };
+}
+/*
+ * Rewrites the indentation of the lines the selections touch, or of every line with nothing selected:
+ * to spaces with each tab taken to its stop, or to as many tabs as fit and the spaces left over. Only the
+ * whitespace a line starts with changes.
+ */
+export function planConvertIndents(source, selections, tabSize, insertSpaces) {
+    const edits = [];
+    for (const { first, last } of runsOf(source, selections)) {
+        for (let index = first; index <= last; index++) {
+            const line = source.line(index);
+            const current = whitespaceOf(line.text);
+            const target = indentText(indentationColumn(current, tabSize), { tabSize, insertSpaces });
+            if (current !== target) {
+                edits.push({ from: line.start, to: line.start + current.length, text: target });
+            }
+        }
+    }
+    return edits;
+}
+/* Past this many lines the rest says nothing new. */
+const DETECT_LINES = 10_000;
+const MAX_INDENT_SIZE = 8;
+/*
+ * Reads the indentation a text already uses, to edit it the same way. Tabs win when more lines start with
+ * a tab than with spaces; otherwise the width of one level is the step between a line and a deeper one
+ * after it that occurs most often. On a tie the step more indents are a multiple of wins, so a line
+ * aligned under a parenthesis does not pass for a level, and then the smaller. The lines inside a block
+ * comment that start with a star are left out, since their single space is no level. Null when no line says.
+ */
+export function detectIndentation(text) {
+    const steps = new Map();
+    const widths = [];
+    let tabs = 0;
+    let spaces = 0;
+    let previous = 0;
+    let count = 0;
+    for (const line of text.split(/\r\n|\r|\n/)) {
+        if (++count > DETECT_LINES) {
+            break;
+        }
+        const indent = whitespaceOf(line);
+        const content = line.slice(indent.length);
+        if (content === '' || content.startsWith('*')) {
+            continue;
+        }
+        if (indent.startsWith('\t')) {
+            tabs++;
+            previous = -1;
+            continue;
+        }
+        if (indent.includes('\t')) {
+            previous = -1;
+            continue;
+        }
+        if (indent.length > 0) {
+            spaces++;
+            widths.push(indent.length);
+        }
+        const step = indent.length - previous;
+        if (previous >= 0 && step > 0 && step <= MAX_INDENT_SIZE) {
+            steps.set(step, (steps.get(step) ?? 0) + 1);
+        }
+        previous = indent.length;
+    }
+    if (tabs > spaces) {
+        return { insertSpaces: false };
+    }
+    let best = null;
+    for (const [size, uses] of steps) {
+        const fits = widths.filter((width) => width % size === 0).length;
+        if (best === null || uses > best.uses || (uses === best.uses && (fits > best.fits || (fits === best.fits && size < best.size)))) {
+            best = { size, uses, fits };
+        }
+    }
+    return best === null ? null : { insertSpaces: true, tabSize: best.size };
+}

package/dist/statement-move.d.ts

@@ -0,0 +1,21 @@
+import type { EditPlan, EditSource } from './edit-source.ts';
+import type { FoldingRange } from './structure.ts';
+import type { Selection } from './types.ts';
+export interface MoveStatementOptions {
+    language: string;
+    unit: string;
+    tabSize: number;
+    structure: readonly FoldingRange[];
+    lineSpan?: (line: number) => {
+        first: number;
+        last: number;
+    };
+}
+export interface StatementMove extends EditPlan {
+    moves: {
+        from: number;
+        to: number;
+    }[];
+}
+export declare function statementMoveMode(language: string): 'braced' | 'indented' | null;
+export declare function planMoveStatement(source: EditSource, selections: readonly Selection[], direction: -1 | 1, options: MoveStatementOptions): StatementMove | null;