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

package/dist/rope.js

@@ -0,0 +1,246 @@
+const chunkSize = 2048;
+function leaf(text) {
+    if (!text.length) {
+        return null;
+    }
+    const breaks = [];
+    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, right) {
+    return { left, right, length: left.length + right.length, lines: left.lines + right.lines, height: Math.max(left.height, right.height) + 1 };
+}
+function balance(left, right) {
+    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;
+        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;
+        return branch(branch(left, middle.left), branch(middle.right, right.right));
+    }
+    return branch(left, right);
+}
+function join(left, right) {
+    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, offset) {
+    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) {
+    const leaves = [];
+    for (let offset = 0; offset < text.length; offset += chunkSize) {
+        leaves.push(leaf(text.slice(offset, offset + chunkSize)));
+    }
+    const tree = (from, to) => {
+        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, from, to, chunks) {
+    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, from, to) {
+    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, maximum) {
+    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 {
+    root;
+    constructor(root) {
+        this.root = root;
+    }
+    static from(text) {
+        return new TextRope(build(text));
+    }
+    get length() {
+        return this.root?.length ?? 0;
+    }
+    get lineCount() {
+        return (this.root?.lines ?? 0) + 1;
+    }
+    charAt(offset) {
+        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) {
+        const chunks = [];
+        collect(this.root, clampInteger(from, this.length), clampInteger(to, this.length), chunks);
+        return chunks.join('');
+    }
+    replace(from, to, text) {
+        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, from, to) {
+        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) {
+        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) {
+        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) {
+        const bounds = this.lineBounds(index);
+        return { ...bounds, text: this.slice(bounds.start, bounds.end) };
+    }
+    breakAt(index) {
+        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/dist/search.d.ts

@@ -0,0 +1,26 @@
+export interface FindOptions {
+    caseSensitive?: boolean;
+    wholeWord?: boolean;
+    regex?: boolean;
+    from?: number;
+    to?: number;
+    maxResults?: number;
+}
+export interface FindNextOptions extends FindOptions {
+    backwards?: boolean;
+    wrap?: boolean;
+}
+export interface FindMatch {
+    from: number;
+    to: number;
+    text: string;
+    captures: readonly (string | undefined)[];
+    groups?: Readonly<Record<string, string | undefined>>;
+    regex: boolean;
+    revision: number;
+}
+export declare function splitsSurrogate(text: {
+    charAt(offset: number): string;
+}, offset: number): boolean;
+export declare function findMatches(text: string, query: string, revision: number, options?: FindOptions): FindMatch[];
+export declare function replacementText(text: string, match: FindMatch, replacement: string, literal?: boolean, preserveCase?: boolean): string;

package/dist/search.js

@@ -0,0 +1,85 @@
+import { replaceWithCaseRespect } from './preserve-case.js';
+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, offset) {
+    return /[\ud800-\udbff]/.test(text.charAt(offset - 1)) && /[\udc00-\udfff]/.test(text.charAt(offset));
+}
+function characterBefore(text, offset) {
+    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, query, revision, options = {}) {
+    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 = [];
+    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, match, replacement, literal = false, preserveCase = false) {
+    const expanded = literal || !match.regex ? replacement : expandPatterns(text, match, replacement);
+    return preserveCase ? replaceWithCaseRespect(expanded, match.text) : expanded;
+}
+function expandPatterns(text, match, replacement) {
+    return replacement.replace(/\$(\$|&|`|'|\d{1,2}|<[^>]*>)/g, (token, group) => {
+        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/dist/structure.d.ts

@@ -0,0 +1,50 @@
+import type { DocumentLine } from './rope.ts';
+export interface StructureRange {
+    from: number;
+    to: number;
+    innerFrom: number;
+    innerTo: number;
+    kind: 'bracket' | 'string' | 'comment';
+}
+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';
+export interface FoldingRange {
+    startLine: number;
+    endLine: number;
+    from: number;
+    to: number;
+    kind: 'bracket' | 'comment' | 'indentation' | 'imports' | 'line-comments' | 'region' | 'block' | 'section' | 'server';
+    role?: FoldRole;
+}
+export interface FoldingOptions {
+    brackets?: boolean;
+    comments?: boolean;
+    indentation?: boolean;
+    language?: string;
+    imports?: boolean;
+    regions?: boolean;
+    lineComments?: boolean;
+    tabSize?: number;
+    minLines?: number;
+    hints?: FoldHints;
+}
+export interface FoldSymbolHint {
+    from: number;
+    to: number;
+    body: 'function' | 'method' | 'class' | 'value';
+}
+export interface FoldRangeHint {
+    from: number;
+    to: number;
+    kind?: string;
+}
+export interface FoldHints {
+    symbols?: readonly FoldSymbolHint[];
+    ranges?: readonly FoldRangeHint[];
+}
+export declare function tabWidth(options: {
+    tabSize?: number;
+}): number;
+export declare function indentationColumn(text: string, tabSize: number): number;
+export declare function scanStructure(text: string): StructureRange[];
+export declare function deriveFoldingRanges(ranges: readonly StructureRange[], lineAt: (offset: number) => number, lineCount: number, getLine: (line: number) => DocumentLine, options?: FoldingOptions, slice?: (from: number, to: number) => string): FoldingRange[];
+export declare function dedupeFoldingRanges(sorted: readonly FoldingRange[]): FoldingRange[];

package/dist/structure.js

@@ -0,0 +1,124 @@
+import { bracketRole, commentRole } from './fold-roles.js';
+import { openers } from './lexical.js';
+/* Clamped to 1 through 16, with 4 for anything that is not a finite number. */
+export function tabWidth(options) {
+    const requested = options.tabSize ?? 4;
+    return Number.isFinite(requested) ? Math.max(1, Math.min(16, Math.trunc(requested))) : 4;
+}
+export function indentationColumn(text, tabSize) {
+    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) {
+    const result = [];
+    const stack = [];
+    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, getLine, tabSize, minimum) {
+    const folds = [];
+    const headers = [];
+    let previous;
+    const close = (header, endLine) => {
+        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, lineAt, lineCount, getLine, options = {}, slice) {
+    const minimum = options.minLines === undefined ? 1 : Math.max(1, Number.isFinite(options.minLines) ? Math.trunc(options.minLines) : 1);
+    const result = [];
+    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) {
+    const unique = [];
+    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;
+}

package/dist/text-span.d.ts

@@ -0,0 +1,7 @@
+export interface TextSpan {
+    readonly start: number;
+    readonly end: number;
+    readonly text: string;
+}
+export declare function changedSpan(before: string, after: string): TextSpan | null;
+export declare function changedSpans(before: string, after: string): TextSpan[];