@adecore/editor-core 0.0.1 → 0.17.0-beta.1

package/src/rope.ts

@@ -0,0 +1,278 @@
+/* `end` excludes the line break and `next` is where the following line starts, so the break is `[end, next)`. */
+export interface DocumentLine {
+    start: number;
+    end: number;
+    next: number;
+    text: string;
+}
+
+/*
+ * A persistent AVL tree of text chunks of at most `chunkSize` UTF-16 code units. Every node knows
+ * its length and its LF count, a leaf also where its LFs are, so offsets and line numbers resolve
+ * without scanning.
+ */
+type Leaf = { readonly text: string; readonly breaks: readonly number[]; readonly length: number; readonly lines: number; readonly height: number };
+type Branch = { readonly left: Node; readonly right: Node; readonly length: number; readonly lines: number; readonly height: number };
+type Node = Leaf | Branch;
+const chunkSize = 2048;
+
+function leaf(text: string): Leaf | null {
+    if (!text.length) {
+        return null;
+    }
+    const breaks: number[] = [];
+    for (let index = text.indexOf('\n'); index !== -1; index = text.indexOf('\n', index + 1)) {
+        breaks.push(index);
+    }
+    return { text, breaks, length: text.length, lines: breaks.length, height: 1 };
+}
+
+function branch(left: Node, right: Node): Branch {
+    return { left, right, length: left.length + right.length, lines: left.lines + right.lines, height: Math.max(left.height, right.height) + 1 };
+}
+
+function balance(left: Node, right: Node): Node {
+    if (left.height > right.height + 1 && 'left' in left) {
+        if (left.left.height >= left.right.height) {
+            return branch(left.left, branch(left.right, right));
+        }
+        const middle = left.right as Branch;
+        return branch(branch(left.left, middle.left), branch(middle.right, right));
+    }
+    if (right.height > left.height + 1 && 'left' in right) {
+        if (right.right.height >= right.left.height) {
+            return branch(branch(left, right.left), right.right);
+        }
+        const middle = right.left as Branch;
+        return branch(branch(left, middle.left), branch(middle.right, right.right));
+    }
+    return branch(left, right);
+}
+
+function join(left: Node | null, right: Node | null): Node | null {
+    if (!left) {
+        return right;
+    }
+    if (!right) {
+        return left;
+    }
+    if ('text' in left && 'text' in right && left.length + right.length <= chunkSize) {
+        return leaf(left.text + right.text);
+    }
+    if (left.height > right.height + 1 && 'left' in left) {
+        return balance(left.left, join(left.right, right)!);
+    }
+    if (right.height > left.height + 1 && 'left' in right) {
+        return balance(join(left, right.left)!, right.right);
+    }
+    return branch(left, right);
+}
+
+function split(node: Node | null, offset: number): [Node | null, Node | null] {
+    if (!node || offset <= 0) {
+        return [null, node];
+    }
+    if (offset >= node.length) {
+        return [node, null];
+    }
+    if ('text' in node) {
+        return [leaf(node.text.slice(0, offset)), leaf(node.text.slice(offset))];
+    }
+    if (offset < node.left.length) {
+        const [before, after] = split(node.left, offset);
+        return [before, join(after, node.right)];
+    }
+    const [before, after] = split(node.right, offset - node.left.length);
+    return [join(node.left, before), after];
+}
+
+function build(text: string): Node | null {
+    const leaves: Node[] = [];
+    for (let offset = 0; offset < text.length; offset += chunkSize) {
+        leaves.push(leaf(text.slice(offset, offset + chunkSize))!);
+    }
+    const tree = (from: number, to: number): Node | null => {
+        if (from === to) {
+            return null;
+        }
+        if (to - from === 1) {
+            return leaves[from]!;
+        }
+        const middle = (from + to) >>> 1;
+        return branch(tree(from, middle)!, tree(middle, to)!);
+    };
+    return tree(0, leaves.length);
+}
+
+function collect(node: Node | null, from: number, to: number, chunks: string[]): void {
+    if (!node || from >= to) {
+        return;
+    }
+    if ('text' in node) {
+        chunks.push(node.text.slice(from, to));
+        return;
+    }
+    if (from < node.left.length) {
+        collect(node.left, from, Math.min(to, node.left.length), chunks);
+    }
+    if (to > node.left.length) {
+        collect(node.right, Math.max(0, from - node.left.length), to - node.left.length, chunks);
+    }
+}
+
+function* chunksOf(node: Node | null, from: number, to: number): Generator<string> {
+    if (!node || from >= to) {
+        return;
+    }
+    if ('text' in node) {
+        yield node.text.slice(from, to);
+        return;
+    }
+    if (from < node.left.length) {
+        yield* chunksOf(node.left, from, Math.min(to, node.left.length));
+    }
+    if (to > node.left.length) {
+        yield* chunksOf(node.right, Math.max(0, from - node.left.length), to - node.left.length);
+    }
+}
+
+/* Truncates to an integer in `[0, maximum]`; anything that is not a finite number becomes 0. */
+export function clampInteger(value: number, maximum: number): number {
+    return Math.max(0, Math.min(maximum, Number.isFinite(value) ? Math.trunc(value) : 0));
+}
+
+/* Immutable: an edit returns a new rope and shares every branch it did not touch, which is what makes history cheap. */
+export class TextRope {
+    private readonly root: Node | null;
+
+    private constructor(root: Node | null) {
+        this.root = root;
+    }
+
+    static from(text: string): TextRope {
+        return new TextRope(build(text));
+    }
+    get length(): number {
+        return this.root?.length ?? 0;
+    }
+    get lineCount(): number {
+        return (this.root?.lines ?? 0) + 1;
+    }
+
+    charAt(offset: number): string {
+        if (offset < 0 || offset >= this.length) {
+            return '';
+        }
+        let node = this.root!;
+        while ('left' in node) {
+            if (offset < node.left.length) {
+                node = node.left;
+            } else {
+                offset -= node.left.length;
+                node = node.right;
+            }
+        }
+        return node.text.charAt(offset);
+    }
+
+    slice(from = 0, to = this.length): string {
+        const chunks: string[] = [];
+        collect(this.root, clampInteger(from, this.length), clampInteger(to, this.length), chunks);
+        return chunks.join('');
+    }
+
+    replace(from: number, to: number, text: string): TextRope {
+        const [before, rest] = split(this.root, from);
+        const [, after] = split(rest, to - from);
+        return new TextRope(join(join(before, build(text)), after));
+    }
+
+    /* Whether both ropes hold the same text in `[from, to)`, which has to be the same range of both. */
+    equalsRange(other: TextRope, from: number, to: number): boolean {
+        if (this.root === other.root) {
+            return true;
+        }
+        const left = chunksOf(this.root, from, to);
+        const right = chunksOf(other.root, from, to);
+        let leftChunk = left.next();
+        let rightChunk = right.next();
+        let leftAt = 0;
+        let rightAt = 0;
+        while (!leftChunk.done && !rightChunk.done) {
+            const length = Math.min(leftChunk.value.length - leftAt, rightChunk.value.length - rightAt);
+            if (leftChunk.value.slice(leftAt, leftAt + length) !== rightChunk.value.slice(rightAt, rightAt + length)) {
+                return false;
+            }
+            leftAt += length;
+            rightAt += length;
+            if (leftAt === leftChunk.value.length) {
+                leftChunk = left.next();
+                leftAt = 0;
+            }
+            if (rightAt === rightChunk.value.length) {
+                rightChunk = right.next();
+                rightAt = 0;
+            }
+        }
+        return Boolean(leftChunk.done && rightChunk.done);
+    }
+
+    lineAt(offset: number): number {
+        offset = clampInteger(offset, this.length);
+        let node = this.root;
+        let count = 0;
+        if (!node) {
+            return count;
+        }
+        while ('left' in node) {
+            if (offset < node.left.length) {
+                node = node.left;
+            } else {
+                offset -= node.left.length;
+                count += node.left.lines;
+                node = node.right;
+            }
+        }
+        let low = 0;
+        let high = node.breaks.length;
+        while (low < high) {
+            const middle = (low + high) >>> 1;
+            if (node.breaks[middle]! < offset) {
+                low = middle + 1;
+            } else {
+                high = middle;
+            }
+        }
+        return count + low;
+    }
+
+    lineBounds(index: number): Omit<DocumentLine, 'text'> {
+        index = clampInteger(index, this.lineCount - 1);
+        const start = index === 0 ? 0 : this.breakAt(index - 1) + 1;
+        if (index === this.lineCount - 1) {
+            return { start, end: this.length, next: this.length };
+        }
+        const newline = this.breakAt(index);
+        return { start, end: newline - (this.charAt(newline - 1) === '\r' ? 1 : 0), next: newline + 1 };
+    }
+
+    getLine(index: number): DocumentLine {
+        const bounds = this.lineBounds(index);
+        return { ...bounds, text: this.slice(bounds.start, bounds.end) };
+    }
+
+    private breakAt(index: number): number {
+        let node = this.root!;
+        let offset = 0;
+        while ('left' in node) {
+            if (index < node.left.lines) {
+                node = node.left;
+            } else {
+                index -= node.left.lines;
+                offset += node.left.length;
+                node = node.right;
+            }
+        }
+        return offset + node.breaks[index]!;
+    }
+}

package/src/search.ts

@@ -0,0 +1,119 @@
+import { replaceWithCaseRespect } from './preserve-case.ts';
+
+export interface FindOptions {
+    caseSensitive?: boolean;
+    wholeWord?: boolean;
+    regex?: boolean;
+    /* Bounds filter matches of the whole document, so anchors and lookarounds still see their context. */
+    from?: number;
+    to?: number;
+    maxResults?: number;
+}
+
+export interface FindNextOptions extends FindOptions {
+    backwards?: boolean;
+    /* On unless `false`. */
+    wrap?: boolean;
+}
+
+/* Only valid for the revision it was found in; `replace` refuses a stale one. */
+export interface FindMatch {
+    from: number;
+    to: number;
+    text: string;
+    captures: readonly (string | undefined)[];
+    groups?: Readonly<Record<string, string | undefined>>;
+    regex: boolean;
+    revision: number;
+}
+
+const wordCharacter = /[\p{L}\p{N}\p{M}\p{Pc}$]/u;
+
+/* Whether `offset` sits between the two halves of a surrogate pair. */
+export function splitsSurrogate(text: { charAt(offset: number): string }, offset: number): boolean {
+    return /[\ud800-\udbff]/.test(text.charAt(offset - 1)) && /[\udc00-\udfff]/.test(text.charAt(offset));
+}
+
+function characterBefore(text: string, offset: number): string {
+    return text.slice(offset - (splitsSurrogate(text, offset - 1) ? 2 : 1), offset);
+}
+
+/* Invalid bounds throw `RangeError`, an invalid expression `SyntaxError`. A zero-width match advances by one code point. */
+export function findMatches(text: string, query: string, revision: number, options: FindOptions = {}): FindMatch[] {
+    if (!query && !options.regex) {
+        return [];
+    }
+    const from = options.from ?? 0;
+    const to = options.to ?? text.length;
+    const maximum = options.maxResults ?? Infinity;
+    if (!Number.isInteger(from) || !Number.isInteger(to) || from < 0 || to < from || to > text.length) {
+        throw new RangeError('Search bounds must be ordered offsets inside the document.');
+    }
+    if (maximum !== Infinity && (!Number.isInteger(maximum) || maximum < 0)) {
+        throw new RangeError('maxResults must be a nonnegative integer.');
+    }
+    const source = options.regex ? query : query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const expression = new RegExp(source, `gmu${options.caseSensitive ? '' : 'i'}`);
+    expression.lastIndex = from;
+    const matches: FindMatch[] = [];
+    while (matches.length < maximum) {
+        const match = expression.exec(text);
+        if (!match || match.index > to) {
+            break;
+        }
+        const end = match.index + match[0].length;
+        const wholeWord =
+            !options.wholeWord ||
+            (!wordCharacter.test(characterBefore(text, match.index)) && !wordCharacter.test(String.fromCodePoint(text.codePointAt(end) ?? 0)));
+        if (match.index >= from && end <= to && !splitsSurrogate(text, match.index) && !splitsSurrogate(text, end) && wholeWord) {
+            matches.push({
+                from: match.index,
+                to: end,
+                text: match[0],
+                captures: match.slice(1),
+                groups: match.groups ? { ...match.groups } : undefined,
+                regex: options.regex === true,
+                revision
+            });
+        }
+        if (!match[0].length) {
+            expression.lastIndex = match.index + ((text.codePointAt(match.index) ?? 0) > 0xffff ? 2 : 1);
+        }
+    }
+    return matches;
+}
+
+/* Expands the JavaScript `$` patterns of a regex replacement, and gives it the case of the match when asked. Literal replacements are returned as they are. */
+export function replacementText(text: string, match: FindMatch, replacement: string, literal = false, preserveCase = false): string {
+    const expanded = literal || !match.regex ? replacement : expandPatterns(text, match, replacement);
+    return preserveCase ? replaceWithCaseRespect(expanded, match.text) : expanded;
+}
+
+function expandPatterns(text: string, match: FindMatch, replacement: string): string {
+    return replacement.replace(/\$(\$|&|`|'|\d{1,2}|<[^>]*>)/g, (token: string, group: string) => {
+        if (group === '$') {
+            return '$';
+        }
+        if (group === '&') {
+            return match.text;
+        }
+        if (group === '`') {
+            return text.slice(0, match.from);
+        }
+        if (group === "'") {
+            return text.slice(match.to);
+        }
+        if (group.startsWith('<')) {
+            return match.groups ? (match.groups[group.slice(1, -1)] ?? '') : token;
+        }
+        const index = Number(group);
+        if (index > 0 && index <= match.captures.length) {
+            return match.captures[index - 1] ?? '';
+        }
+        const first = Number(group[0]);
+        if (group.length === 2 && first > 0 && first <= match.captures.length) {
+            return (match.captures[first - 1] ?? '') + group[1];
+        }
+        return token;
+    });
+}

package/src/structure.ts

@@ -0,0 +1,223 @@
+import { bracketRole, commentRole } from './fold-roles.ts';
+import { openers } from './lexical.ts';
+import type { DocumentLine } from './rope.ts';
+
+/* A bracket pair, string or block comment. `inner*` is the range without its delimiters. */
+export interface StructureRange {
+    from: number;
+    to: number;
+    innerFrom: number;
+    innerTo: number;
+    kind: 'bracket' | 'string' | 'comment';
+}
+
+/* What a fold is, which the settings choose by to fold it when a file opens. */
+export type FoldRole =
+    | 'file-header'
+    | 'imports'
+    | 'doc-comment'
+    | 'region'
+    | 'function-body'
+    | 'method-body'
+    | 'class-body'
+    | 'object-literal'
+    | 'array-literal'
+    | 'tag'
+    | 'attribute'
+    | 'php-tag'
+    | 'heredoc'
+    | 'front-matter'
+    | 'code-fence'
+    | 'table';
+
+/*
+ * Lines are zero-based and the offsets half-open. Fold from the end of `startLine` through `endLine`.
+ * `kind` is the shape: `imports` is a run of import lines, `line-comments` a run of lines of `//` comments,
+ * `region` what sits between `// region` and `// endregion`, `block` a run of whole lines such as a code
+ * fence, `section` what a Markdown heading holds and `server` a range a language server named.
+ */
+export interface FoldingRange {
+    startLine: number;
+    endLine: number;
+    from: number;
+    to: number;
+    kind: 'bracket' | 'comment' | 'indentation' | 'imports' | 'line-comments' | 'region' | 'block' | 'section' | 'server';
+    /* What the range is, where the text or a language server says; most ranges have none. */
+    role?: FoldRole;
+}
+
+export interface FoldingOptions {
+    /* On unless `false`. */
+    brackets?: boolean;
+    /* On unless `false`. */
+    comments?: boolean;
+    indentation?: boolean;
+    /* The language id, which decides what an import line and a line comment look like. Without one only brackets, block comments and indentation fold. */
+    language?: string;
+    /* Each on unless `false`, and only with a language. */
+    imports?: boolean;
+    regions?: boolean;
+    lineComments?: boolean;
+    tabSize?: number;
+    /* How many lines a range spans past its first one before it can fold. */
+    minLines?: number;
+    /* What a language server said about the document, in offsets of its text. */
+    hints?: FoldHints;
+}
+
+/* A symbol's range and the kind of body it has. */
+export interface FoldSymbolHint {
+    from: number;
+    to: number;
+    /* `value` is a variable or property, which has a function body when its initializer is a function. */
+    body: 'function' | 'method' | 'class' | 'value';
+}
+
+/* A range a server folds, from any offset on its first line to any offset on its last. */
+export interface FoldRangeHint {
+    from: number;
+    to: number;
+    /* The LSP kind: `comment`, `imports` or `region`. */
+    kind?: string;
+}
+
+export interface FoldHints {
+    symbols?: readonly FoldSymbolHint[];
+    ranges?: readonly FoldRangeHint[];
+}
+
+interface Header {
+    line: number;
+    indent: number;
+}
+
+/* Clamped to 1 through 16, with 4 for anything that is not a finite number. */
+export function tabWidth(options: { tabSize?: number }): number {
+    const requested = options.tabSize ?? 4;
+    return Number.isFinite(requested) ? Math.max(1, Math.min(16, Math.trunc(requested))) : 4;
+}
+
+export function indentationColumn(text: string, tabSize: number): number {
+    let column = 0;
+    for (const character of text) {
+        column += character === '\t' ? tabSize - (column % tabSize) : 1;
+    }
+    return column;
+}
+
+/* Outermost first. It knows only line and block comments and the three quote characters, so a regex literal can confuse it. */
+export function scanStructure(text: string): StructureRange[] {
+    const result: StructureRange[] = [];
+    const stack: { from: number; closer: string }[] = [];
+    for (let offset = 0; offset < text.length; offset++) {
+        const character = text[offset]!;
+        if (character === '/' && text[offset + 1] === '/') {
+            const end = text.indexOf('\n', offset + 2);
+            offset = end === -1 ? text.length : end;
+        } else if (character === '/' && text[offset + 1] === '*') {
+            const end = text.indexOf('*/', offset + 2);
+            if (end === -1) {
+                break;
+            }
+            result.push({ from: offset, to: end + 2, innerFrom: offset + 2, innerTo: end, kind: 'comment' });
+            offset = end + 1;
+        } else if (character === '"' || character === "'" || character === '`') {
+            const start = offset;
+            for (offset++; offset < text.length; offset++) {
+                if (text[offset] === '\\') {
+                    offset++;
+                } else if (text[offset] === character) {
+                    result.push({ from: start, to: offset + 1, innerFrom: start + 1, innerTo: offset, kind: 'string' });
+                    break;
+                } else if (character !== '`' && (text[offset] === '\n' || text[offset] === '\r')) {
+                    break;
+                }
+            }
+        } else if (openers[character]) {
+            stack.push({ from: offset, closer: openers[character] });
+        } else if (stack.at(-1)?.closer === character) {
+            const opener = stack.pop()!;
+            result.push({ from: opener.from, to: offset + 1, innerFrom: opener.from + 1, innerTo: offset, kind: 'bracket' });
+        }
+    }
+    return result.sort((left, right) => left.from - right.from || right.to - left.to);
+}
+
+function indentationFolds(lineCount: number, getLine: (line: number) => DocumentLine, tabSize: number, minimum: number): FoldingRange[] {
+    const folds: FoldingRange[] = [];
+    const headers: Header[] = [];
+    let previous: Header | undefined;
+
+    const close = (header: Header, endLine: number): void => {
+        if (endLine - header.line >= minimum) {
+            folds.push({ from: getLine(header.line).start, to: getLine(endLine).end, startLine: header.line, endLine, kind: 'indentation' });
+        }
+    };
+
+    for (let line = 0; line < lineCount; line++) {
+        const text = getLine(line).text;
+        if (!text.trim()) {
+            continue;
+        }
+        const indent = indentationColumn(text.match(/^[\t ]*/)?.[0] ?? '', tabSize);
+        while (headers.length > 0 && indent <= headers.at(-1)!.indent) {
+            close(headers.pop()!, previous!.line);
+        }
+        if (previous && indent > previous.indent) {
+            headers.push(previous);
+        }
+        previous = { line, indent };
+    }
+    while (headers.length > 0) {
+        close(headers.pop()!, previous!.line);
+    }
+    return folds;
+}
+
+/* Ranges that span the same lines collapse into the first, which is the outermost. */
+export function deriveFoldingRanges(
+    ranges: readonly StructureRange[],
+    lineAt: (offset: number) => number,
+    lineCount: number,
+    getLine: (line: number) => DocumentLine,
+    options: FoldingOptions = {},
+    slice?: (from: number, to: number) => string
+): FoldingRange[] {
+    const minimum = options.minLines === undefined ? 1 : Math.max(1, Number.isFinite(options.minLines) ? Math.trunc(options.minLines) : 1);
+    const result: FoldingRange[] = [];
+    for (const range of ranges) {
+        if (range.kind === 'string' || (range.kind === 'bracket' ? options.brackets === false : options.comments === false)) {
+            continue;
+        }
+        const startLine = lineAt(range.from);
+        const endLine = lineAt(range.to - 1);
+        if (endLine - startLine >= minimum) {
+            const role =
+                slice === undefined
+                    ? undefined
+                    : range.kind === 'comment'
+                      ? commentRole(slice, range.from, range.to)
+                      : bracketRole(slice, range.from, options.language ?? '');
+            result.push({ from: range.from, to: range.to, startLine, endLine, kind: range.kind, ...(role === undefined ? {} : { role }) });
+        }
+    }
+    if (options.indentation) {
+        result.push(...indentationFolds(lineCount, getLine, tabWidth(options), minimum));
+    }
+    result.sort((left, right) => left.startLine - right.startLine || right.endLine - left.endLine);
+    return dedupeFoldingRanges(result);
+}
+
+/* Of ranges that span the same lines, sorted outermost first, the first stays and takes the role of a later one when it has none. */
+export function dedupeFoldingRanges(sorted: readonly FoldingRange[]): FoldingRange[] {
+    const unique: FoldingRange[] = [];
+    for (const range of sorted) {
+        const last = unique.at(-1);
+        if (last === undefined || range.startLine !== last.startLine || range.endLine !== last.endLine) {
+            unique.push(range);
+        } else if (last.role === undefined && range.role !== undefined) {
+            last.role = range.role;
+        }
+    }
+    return unique;
+}