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

package/dist/markup-regions.js

@@ -0,0 +1,331 @@
+const JSX_LANGUAGES = /^(typescriptreact|javascriptreact|tsx|jsx|javascript|js|mjs|cjs)$/i;
+const NAME = /[\w$.:-]/;
+const START_OF_NAME = /[A-Za-z_$>]/;
+const EXPRESSION_KEYWORDS = /^(return|case|yield|await|default|typeof|void|delete|in|of|else|do)$/;
+/* The characters after which an expression, and so a JSX element, may start. */
+const EXPRESSION_STARTS = '(,=:[!&|?{>~^%*+-';
+const CLOSERS = { '{': '}', '(': ')', '[': ']' };
+/*
+ * The stretches of a script that are JSX elements, as offsets, outermost first. A scanner and not a
+ * parser: an element that does not close as one is left out, and a file that costs more than a few
+ * passes over its text gives up with what it found.
+ */
+class JsxScanner {
+    ranges = [];
+    /* The quoted values of attributes, quotes included. */
+    values = [];
+    text;
+    depth = 0;
+    budget;
+    constructor(text) {
+        this.text = text;
+        this.budget = text.length * 12 + 1_000;
+    }
+    scan() {
+        this.code(0, null);
+    }
+    /* Reads code up to the closer that ends it and returns the offset after it; -1 when it never closes as it should. */
+    code(from, closer) {
+        const { text } = this;
+        let at = from;
+        let previous = '';
+        let word = '';
+        while (at < text.length) {
+            if (--this.budget < 0) {
+                return -1;
+            }
+            const char = text[at];
+            const next = text[at + 1];
+            if (/\s/.test(char)) {
+                at++;
+                continue;
+            }
+            if (char === '/' && next === '/') {
+                const end = text.indexOf('\n', at);
+                at = end < 0 ? text.length : end;
+                continue;
+            }
+            if (char === '/' && next === '*') {
+                const end = text.indexOf('*/', at + 2);
+                at = end < 0 ? text.length : end + 2;
+                continue;
+            }
+            if (char === '"' || char === "'") {
+                at = this.quoted(at);
+                previous = char;
+                word = '';
+                continue;
+            }
+            if (char === '`') {
+                at = this.template(at);
+                if (at < 0) {
+                    return -1;
+                }
+                previous = char;
+                word = '';
+                continue;
+            }
+            const expressionStart = previous === '' || EXPRESSION_STARTS.includes(previous) || EXPRESSION_KEYWORDS.test(word);
+            if (char === '/' && expressionStart) {
+                at = this.regex(at);
+                previous = '/';
+                word = '';
+                continue;
+            }
+            if (char === '<' && expressionStart && next !== undefined && START_OF_NAME.test(next)) {
+                const end = this.element(at, true);
+                if (end >= 0) {
+                    at = end;
+                    previous = ')';
+                    word = '';
+                    continue;
+                }
+            }
+            const closes = CLOSERS[char];
+            if (closes !== undefined) {
+                const end = this.code(at + 1, closes);
+                if (end < 0) {
+                    return -1;
+                }
+                at = end;
+                previous = closes;
+                word = '';
+                continue;
+            }
+            if (char === '}' || char === ')' || char === ']') {
+                if (closer === char) {
+                    return at + 1;
+                }
+                if (closer !== null) {
+                    return -1;
+                }
+                at++;
+                previous = char;
+                word = '';
+                continue;
+            }
+            if (/[\w$]/.test(char)) {
+                const start = at;
+                while (at < text.length && /[\w$]/.test(text[at])) {
+                    at++;
+                }
+                word = text.slice(start, at);
+                previous = word.slice(-1);
+                continue;
+            }
+            previous = char;
+            word = '';
+            at++;
+        }
+        return closer === null ? text.length : -1;
+    }
+    quoted(from) {
+        const { text } = this;
+        const quote = text[from];
+        let at = from + 1;
+        while (at < text.length && text[at] !== quote && text[at] !== '\n') {
+            at += text[at] === '\\' ? 2 : 1;
+        }
+        return Math.min(text.length, at + 1);
+    }
+    template(from) {
+        const { text } = this;
+        let at = from + 1;
+        while (at < text.length) {
+            if (text[at] === '\\') {
+                at += 2;
+            }
+            else if (text[at] === '`') {
+                return at + 1;
+            }
+            else if (text[at] === '$' && text[at + 1] === '{') {
+                at = this.code(at + 2, '}');
+                if (at < 0) {
+                    return -1;
+                }
+            }
+            else {
+                at++;
+            }
+        }
+        return text.length;
+    }
+    regex(from) {
+        const { text } = this;
+        let at = from + 1;
+        let inClass = false;
+        while (at < text.length && text[at] !== '\n') {
+            const char = text[at];
+            if (char === '\\') {
+                at++;
+            }
+            else if (char === '[') {
+                inClass = true;
+            }
+            else if (char === ']') {
+                inClass = false;
+            }
+            else if (char === '/' && !inClass) {
+                return at + 1;
+            }
+            at++;
+        }
+        return from + 1;
+    }
+    /* An element from its `<`, recorded when no element holds it, and the offset after its closing tag; -1 when it is not one. */
+    element(from, outermost) {
+        this.depth++;
+        const end = this.parse(from);
+        this.depth--;
+        if (end >= 0 && outermost && this.depth === 0) {
+            this.ranges.push({ from, to: end });
+        }
+        return end;
+    }
+    skipSpace(from) {
+        let at = from;
+        while (at < this.text.length && /\s/.test(this.text[at])) {
+            at++;
+        }
+        return at;
+    }
+    parse(from) {
+        const { text } = this;
+        let at = from + 1;
+        while (at < text.length && NAME.test(text[at])) {
+            at++;
+        }
+        const name = text.slice(from + 1, at);
+        for (;;) {
+            at = this.skipSpace(at);
+            const char = text[at];
+            if (char === undefined || --this.budget < 0) {
+                return -1;
+            }
+            if (char === '/' && text[at + 1] === '>') {
+                return at + 2;
+            }
+            if (char === '>') {
+                at++;
+                break;
+            }
+            if (char === '{') {
+                at = this.code(at + 1, '}');
+                if (at < 0) {
+                    return -1;
+                }
+                continue;
+            }
+            if (!/[A-Za-z_$]/.test(char)) {
+                return -1;
+            }
+            while (at < text.length && NAME.test(text[at])) {
+                at++;
+            }
+            at = this.skipSpace(at);
+            if (text[at] !== '=') {
+                continue;
+            }
+            at = this.skipSpace(at + 1);
+            const value = text[at];
+            if (value === '"' || value === "'") {
+                const close = text.indexOf(value, at + 1);
+                if (close < 0) {
+                    return -1;
+                }
+                this.values.push({ from: at, to: close + 1 });
+                at = close + 1;
+            }
+            else if (value === '{') {
+                at = this.code(at + 1, '}');
+            }
+            else if (value === '<' && START_OF_NAME.test(text[at + 1] ?? '')) {
+                at = this.parse(at);
+            }
+            else {
+                return -1;
+            }
+            if (at < 0) {
+                return -1;
+            }
+        }
+        for (;;) {
+            while (at < text.length && text[at] !== '<' && text[at] !== '{') {
+                at++;
+            }
+            if (at >= text.length || --this.budget < 0) {
+                return -1;
+            }
+            if (text[at] === '{') {
+                at = this.code(at + 1, '}');
+            }
+            else if (text[at + 1] === '/') {
+                const closing = /^<\/\s*([\w$.:-]*)\s*>/.exec(text.slice(at, at + 200));
+                return closing !== null && closing[1] === name ? at + closing[0].length : -1;
+            }
+            else if (START_OF_NAME.test(text[at + 1] ?? '')) {
+                at = this.parse(at);
+            }
+            else {
+                return -1;
+            }
+            if (at < 0) {
+                return -1;
+            }
+        }
+    }
+}
+/* The offsets of the JSX elements of a script, outermost first and in order. */
+export function jsxRanges(text) {
+    const scanner = new JsxScanner(text);
+    scanner.scan();
+    return scanner.ranges;
+}
+/* Whether a language is one whose scripts can hold JSX. */
+export function hasJsx(language) {
+    return JSX_LANGUAGES.test(language);
+}
+/* Whether the string that opens at `offset` is the value of a JSX attribute, which is markup and not a string expression. */
+export function isJsxAttributeValue(text, offset) {
+    const scanner = new JsxScanner(text);
+    scanner.scan();
+    return scanner.values.some((value) => value.from === offset);
+}
+/*
+ * Whether a line is markup that a command which works from the code around a line must leave as it
+ * is: a Vue template and everything outside its script and style blocks, and the elements of JSX
+ * with what stands inside them. The HTML of a PHP file and heredocs are modes of the lexer.
+ */
+export function markupGuard(source, language) {
+    const id = language.toLowerCase();
+    if (id === 'vue') {
+        return (line) => {
+            const region = source.region(line);
+            return (region !== 'script' && region !== 'style') || /^\s*<\/?(?:script|style|template)\b/.test(source.line(line).text);
+        };
+    }
+    if (hasJsx(id)) {
+        const ranges = jsxRanges(source.slice(0, source.line(source.lineCount - 1).end));
+        return (line) => {
+            const bounds = source.line(line);
+            const start = bounds.start + (/^[\t ]*/.exec(bounds.text)?.[0].length ?? 0);
+            let low = 0;
+            let high = ranges.length - 1;
+            while (low <= high) {
+                const middle = (low + high) >> 1;
+                const range = ranges[middle];
+                if (start < range.from) {
+                    high = middle - 1;
+                }
+                else if (start >= range.to) {
+                    low = middle + 1;
+                }
+                else {
+                    return true;
+                }
+            }
+            return false;
+        };
+    }
+    return () => false;
+}

package/dist/offsets.d.ts

@@ -0,0 +1,2 @@
+import type { TextEdit } from './types.ts';
+export declare function mapOffset(offset: number, edits: readonly TextEdit[], stayBefore?: boolean): number;

package/dist/offsets.js

@@ -0,0 +1,14 @@
+/* An offset after simultaneous edits. An edit that inserts at it leaves it in front of the new text when `stayBefore`. */
+export function mapOffset(offset, edits, stayBefore = false) {
+    let delta = 0;
+    for (const edit of edits) {
+        if (offset < edit.from || (stayBefore && offset === edit.from && edit.to === edit.from)) {
+            break;
+        }
+        if (offset < edit.to) {
+            return edit.from + delta + edit.text.length;
+        }
+        delta += edit.text.length - (edit.to - edit.from);
+    }
+    return offset + delta;
+}

package/dist/paste.d.ts

@@ -0,0 +1,9 @@
+import type { EditPlan, EditSource } from './edit-source.ts';
+import type { Selection } from './types.ts';
+export interface PasteOptions {
+    tabSize: number;
+    insertSpaces: boolean;
+    wholeLines: boolean;
+    reindent: boolean;
+}
+export declare function planPaste(source: EditSource, selections: readonly Selection[], text: string, options: PasteOptions): EditPlan;

package/dist/paste.js

@@ -0,0 +1,108 @@
+import { mapOffset } from './offsets.js';
+import { indentationColumn } from './structure.js';
+function whitespaceOf(text) {
+    return /^[\t ]*/.exec(text)[0];
+}
+function isBlank(text) {
+    return text.trim() === '';
+}
+/* A line break at the end is the end of the last line, not a line of its own. */
+function linesOf(text) {
+    return text.replace(/\r?\n$/, '').split(/\r?\n/);
+}
+/* One line of the text for each caret, when there are as many lines as carets. */
+function perCaretLines(text, carets) {
+    if (carets < 2) {
+        return null;
+    }
+    const lines = linesOf(text);
+    return lines.length === carets ? lines : null;
+}
+function indentText(width, options) {
+    if (options.insertSpaces) {
+        return ' '.repeat(width);
+    }
+    return '\t'.repeat(Math.floor(width / options.tabSize)) + ' '.repeat(width % options.tabSize);
+}
+/*
+ * Where a block of several lines lands, it lands at the indentation of the line it is pasted into:
+ * the pasted lines move together by the difference between that indentation and the least indented
+ * of them. A first line that starts at the caret stays where it is, and the lines below it are
+ * measured against each other, since its own indentation was left behind in the copy.
+ */
+function reindent(source, from, text, options) {
+    const newline = text.includes('\r\n') ? '\r\n' : '\n';
+    const lines = text.split(/\r?\n/);
+    if (lines.length < 2) {
+        return text;
+    }
+    const line = source.line(source.lineAt(from));
+    const before = source.slice(line.start, from);
+    const caretColumn = indentationColumn(before, options.tabSize);
+    const lineIndent = indentationColumn(whitespaceOf(line.text), options.tabSize);
+    const startsLine = isBlank(before);
+    const firstIndent = whitespaceOf(lines[0]);
+    const anchored = startsLine ? caretColumn > 0 && firstIndent === '' : true;
+    const target = startsLine ? (anchored ? caretColumn : Math.max(caretColumn, lineIndent)) : lineIndent;
+    const widths = lines.map((entry) => (isBlank(entry) ? null : indentationColumn(whitespaceOf(entry), options.tabSize)));
+    const measured = widths.filter((width, index) => width !== null && !(anchored && index === 0));
+    const trailingBreak = isBlank(lines.at(-1));
+    if (measured.length > 0) {
+        const delta = target - Math.min(...measured);
+        for (const [index, entry] of lines.entries()) {
+            const width = widths[index];
+            if (width === null || width === undefined || (anchored && index === 0)) {
+                continue;
+            }
+            // The first line follows the indentation already in front of the caret.
+            const indent = Math.max(0, width + delta - (index === 0 ? caretColumn : 0));
+            if (indent !== width) {
+                lines[index] = indentText(indent, options) + entry.slice(whitespaceOf(entry).length);
+            }
+        }
+    }
+    if (trailingBreak) {
+        // What follows the paste stays under the indentation of the line it was on.
+        lines[lines.length - 1] = whitespaceOf(before);
+    }
+    return lines.join(newline);
+}
+/*
+ * What pasting `text` does at every selection: one line for each caret when the counts match, text
+ * copied from a bare caret as lines above the caret's own, and a block moved to the indentation of
+ * the line it lands on, when it lands in code and not in a string, a comment or a heredoc.
+ */
+export function planPaste(source, selections, text, options) {
+    const ordered = selections.map((selection, index) => ({
+        from: Math.min(selection.anchor, selection.head),
+        to: Math.max(selection.anchor, selection.head),
+        index
+    }));
+    ordered.sort((left, right) => left.from - right.from);
+    const segments = perCaretLines(text, selections.length);
+    const newline = text.includes('\r\n') ? '\r\n' : '\n';
+    const edits = [];
+    if (options.wholeLines && selections.every((selection) => selection.anchor === selection.head)) {
+        const lineEdits = new Map();
+        for (const [position, { from }] of ordered.entries()) {
+            const start = source.line(source.lineAt(from)).start;
+            const piece = segments?.[position] ?? text;
+            lineEdits.set(start, (lineEdits.get(start) ?? '') + (/\r?\n$/.test(piece) ? piece : piece + newline));
+        }
+        for (const [start, insert] of lineEdits) {
+            edits.push({ from: start, to: start, text: insert });
+        }
+        return { edits, selections: selections.map((selection) => ({ anchor: mapOffset(selection.anchor, edits), head: mapOffset(selection.head, edits) })) };
+    }
+    const carets = new Array(selections.length);
+    let shift = 0;
+    for (const [position, { from, to, index }] of ordered.entries()) {
+        const piece = segments?.[position] ?? text;
+        const inserted = options.reindent && segments === null && source.context(from).mode === 'code' ? reindent(source, from, piece, options) : piece;
+        edits.push({ from, to, text: inserted });
+        const head = from + shift + inserted.length;
+        carets[index] = { anchor: head, head };
+        shift += inserted.length - (to - from);
+    }
+    return { edits, selections: carets };
+}

package/dist/preserve-case.d.ts

@@ -0,0 +1 @@
+export declare function replaceWithCaseRespect(replacement: string, found: string): string;

package/dist/preserve-case.js

@@ -0,0 +1,61 @@
+const letter = /\p{L}/u;
+const upper = /\p{Lu}/u;
+const lower = /\p{Ll}/u;
+/*
+ * Gives a replacement the case of the text it replaces: the first letter follows the first letter of
+ * the match, and the rest follows the tail of the match when that is all upper or all lower case and
+ * the replacement's own tail is not already the other way. The platform's "Preserve case" for a replace.
+ */
+export function replaceWithCaseRespect(replacement, found) {
+    if (found === '' || replacement === '') {
+        return replacement;
+    }
+    const [firstFound] = found;
+    const [firstReplacement] = replacement;
+    const head = upper.test(firstFound) ? firstReplacement.toUpperCase() : firstReplacement.toLowerCase();
+    const replacementTail = replacement.slice(firstReplacement.length);
+    if (replacementTail === '') {
+        return head;
+    }
+    const foundTail = found.slice(firstFound.length);
+    if (foundTail === '') {
+        return head + replacementTail;
+    }
+    let replacementLower = true;
+    let replacementUpper = true;
+    for (const character of replacementTail) {
+        if (!letter.test(character)) {
+            continue;
+        }
+        replacementLower &&= lower.test(character);
+        replacementUpper &&= upper.test(character);
+        if (!replacementLower && !replacementUpper) {
+            break;
+        }
+    }
+    let tailUpper = true;
+    let tailLower = true;
+    let tailChecked = false;
+    for (const character of foundTail) {
+        if (!letter.test(character)) {
+            continue;
+        }
+        tailUpper &&= upper.test(character);
+        tailLower &&= lower.test(character);
+        tailChecked = true;
+        if (!tailUpper && !tailLower) {
+            break;
+        }
+    }
+    if (!tailChecked) {
+        tailUpper = letter.test(firstFound) && upper.test(firstFound);
+        tailLower = letter.test(firstFound) && lower.test(firstFound);
+    }
+    if (tailUpper && (replacementLower || !replacementUpper)) {
+        return head + replacementTail.toUpperCase();
+    }
+    if (tailLower && (replacementLower || replacementUpper)) {
+        return head + replacementTail.toLowerCase();
+    }
+    return head + replacementTail;
+}

package/dist/rope.d.ts

@@ -0,0 +1,22 @@
+export interface DocumentLine {
+    start: number;
+    end: number;
+    next: number;
+    text: string;
+}
+export declare function clampInteger(value: number, maximum: number): number;
+export declare class TextRope {
+    private readonly root;
+    private constructor();
+    static from(text: string): TextRope;
+    get length(): number;
+    get lineCount(): number;
+    charAt(offset: number): string;
+    slice(from?: number, to?: number): string;
+    replace(from: number, to: number, text: string): TextRope;
+    equalsRange(other: TextRope, from: number, to: number): boolean;
+    lineAt(offset: number): number;
+    lineBounds(index: number): Omit<DocumentLine, 'text'>;
+    getLine(index: number): DocumentLine;
+    private breakAt;
+}