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

package/dist/text-span.js

@@ -0,0 +1,211 @@
+function isHighSurrogate(code) {
+    return code >= 0xd800 && code <= 0xdbff;
+}
+function isLowSurrogate(code) {
+    return code >= 0xdc00 && code <= 0xdfff;
+}
+/*
+ * The one stretch that differs between two texts, found from both ends. Replacing only that keeps a
+ * cursor, a selection and the scroll where they were anywhere outside it, which setting the whole
+ * text would not. Null when the two are the same.
+ */
+export function changedSpan(before, after) {
+    if (before === after) {
+        return null;
+    }
+    const limit = Math.min(before.length, after.length);
+    let start = 0;
+    while (start < limit && before.charCodeAt(start) === after.charCodeAt(start)) {
+        start += 1;
+    }
+    // Never between the halves of a surrogate pair, which would leave a lone half on either side.
+    if (start > 0 && isHighSurrogate(before.charCodeAt(start - 1))) {
+        start -= 1;
+    }
+    let tail = 0;
+    while (tail < limit - start && before.charCodeAt(before.length - 1 - tail) === after.charCodeAt(after.length - 1 - tail)) {
+        tail += 1;
+    }
+    if (tail > 0 && isLowSurrogate(before.charCodeAt(before.length - tail))) {
+        tail -= 1;
+    }
+    return { start, end: before.length - tail, text: after.slice(start, after.length - tail) };
+}
+/* A line diff stops at this much work (snake steps and diagonals visited) and falls back to the one span. */
+const DIFF_WORK_LIMIT = 4_000_000;
+/* More edit lines than this is a rewrite, where one span is as good as any. */
+const DIFF_EDIT_LIMIT = 1_000;
+/* Past this much text between the first and last change the intern table costs more than the diff is worth. */
+const DIFF_TEXT_LIMIT = 16 * 1024 * 1024;
+function splitLines(text) {
+    const lines = [];
+    let from = 0;
+    for (let at = text.indexOf('\n'); at >= 0; at = text.indexOf('\n', from)) {
+        lines.push(text.slice(from, at + 1));
+        from = at + 1;
+    }
+    if (from < text.length) {
+        lines.push(text.slice(from));
+    }
+    return lines;
+}
+/*
+ * The shortest edit script between two line sequences (Myers), as the runs of lines that differ.
+ * Null once the work or the number of edited lines passes its limit.
+ */
+function diffLineHunks(before, after) {
+    const rows = before.length;
+    const columns = after.length;
+    const maxEdits = Math.min(rows + columns, DIFF_EDIT_LIMIT);
+    const base = maxEdits + 1;
+    const frontier = new Int32Array(2 * base + 2);
+    const trace = [];
+    let work = 0;
+    let found = -1;
+    for (let edits = 0; edits <= maxEdits && found < 0; edits++) {
+        trace.push(frontier.slice());
+        for (let diagonal = -edits; diagonal <= edits; diagonal += 2) {
+            let x;
+            if (diagonal === -edits || (diagonal !== edits && frontier[base + diagonal - 1] < frontier[base + diagonal + 1])) {
+                x = frontier[base + diagonal + 1];
+            }
+            else {
+                x = frontier[base + diagonal - 1] + 1;
+            }
+            let y = x - diagonal;
+            while (x < rows && y < columns && before[x] === after[y]) {
+                x++;
+                y++;
+                work++;
+            }
+            work++;
+            frontier[base + diagonal] = x;
+            if (x >= rows && y >= columns) {
+                found = edits;
+                break;
+            }
+        }
+        if (work > DIFF_WORK_LIMIT) {
+            return null;
+        }
+    }
+    if (found < 0) {
+        return null;
+    }
+    const operations = [];
+    let x = rows;
+    let y = columns;
+    for (let edits = found; edits > 0; edits--) {
+        const previous = trace[edits];
+        const diagonal = x - y;
+        const fromAbove = diagonal === -edits || (diagonal !== edits && previous[base + diagonal - 1] < previous[base + diagonal + 1]);
+        const previousDiagonal = fromAbove ? diagonal + 1 : diagonal - 1;
+        const previousX = previous[base + previousDiagonal];
+        const previousY = previousX - previousDiagonal;
+        while (x > previousX && y > previousY) {
+            x--;
+            y--;
+        }
+        if (fromAbove) {
+            y--;
+            operations.push({ kind: 'insert', x, y });
+        }
+        else {
+            x--;
+            operations.push({ kind: 'delete', x, y });
+        }
+    }
+    operations.reverse();
+    const hunks = [];
+    let open = null;
+    for (const operation of operations) {
+        if (open !== null && open.beforeTo === operation.x && open.afterTo === operation.y) {
+            if (operation.kind === 'delete') {
+                open.beforeTo++;
+            }
+            else {
+                open.afterTo++;
+            }
+            continue;
+        }
+        if (open !== null) {
+            hunks.push(open);
+        }
+        open = {
+            beforeFrom: operation.x,
+            afterFrom: operation.y,
+            beforeTo: operation.x + (operation.kind === 'delete' ? 1 : 0),
+            afterTo: operation.y + (operation.kind === 'insert' ? 1 : 0)
+        };
+    }
+    if (open !== null) {
+        hunks.push(open);
+    }
+    return hunks;
+}
+/*
+ * The stretches that differ between two texts, found by a line diff with a bounded cost, in the
+ * coordinates of `before`. Applied as one batch they keep every cursor, fold, marker and the scroll
+ * wherever the text around them stayed, also between two far apart changes, where the one span of
+ * `changedSpan` would cover everything in between. A rewrite that passes the bounds is that one span.
+ */
+export function changedSpans(before, after) {
+    const outer = changedSpan(before, after);
+    if (outer === null) {
+        return [];
+    }
+    const afterEnd = after.length - (before.length - outer.end);
+    if (outer.end - outer.start + (afterEnd - outer.start) > DIFF_TEXT_LIMIT) {
+        return [outer];
+    }
+    // Whole lines on both sides of the change, so the diff compares lines and not their halves.
+    const lineStart = outer.start === 0 ? 0 : before.lastIndexOf('\n', outer.start - 1) + 1;
+    const lineEnd = (at, from) => {
+        const newline = at.indexOf('\n', from);
+        return newline < 0 ? at.length : newline + 1;
+    };
+    const beforeEnd = lineEnd(before, outer.end > outer.start ? outer.end - 1 : outer.end);
+    const afterLineEnd = beforeEnd - outer.end + afterEnd;
+    const beforeLines = splitLines(before.slice(lineStart, beforeEnd));
+    const afterLines = splitLines(after.slice(lineStart, afterLineEnd));
+    if (beforeLines.length < 2 && afterLines.length < 2) {
+        return [outer];
+    }
+    const ids = new Map();
+    const intern = (lines) => {
+        const result = new Int32Array(lines.length);
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            let id = ids.get(line);
+            if (id === undefined) {
+                id = ids.size;
+                ids.set(line, id);
+            }
+            result[i] = id;
+        }
+        return result;
+    };
+    const hunks = diffLineHunks(intern(beforeLines), intern(afterLines));
+    if (hunks === null || hunks.length === 0) {
+        return [outer];
+    }
+    const beforeOffsets = lineOffsets(beforeLines, lineStart);
+    const afterOffsets = lineOffsets(afterLines, lineStart);
+    const spans = [];
+    for (const hunk of hunks) {
+        const beforeFrom = beforeOffsets[hunk.beforeFrom];
+        const afterFrom = afterOffsets[hunk.afterFrom];
+        const inner = changedSpan(before.slice(beforeFrom, beforeOffsets[hunk.beforeTo]), after.slice(afterFrom, afterOffsets[hunk.afterTo]));
+        if (inner !== null) {
+            spans.push({ start: beforeFrom + inner.start, end: beforeFrom + inner.end, text: inner.text });
+        }
+    }
+    return spans;
+}
+function lineOffsets(lines, base) {
+    const offsets = [base];
+    for (const line of lines) {
+        offsets.push(offsets[offsets.length - 1] + line.length);
+    }
+    return offsets;
+}

package/dist/types.d.ts

@@ -0,0 +1,70 @@
+export interface Selection {
+    anchor: number;
+    head: number;
+}
+export interface TextEdit {
+    from: number;
+    to: number;
+    text: string;
+}
+export interface DocumentChange {
+    from: number;
+    to: number;
+    insertedLength: number;
+}
+export interface Position {
+    line: number;
+    column: number;
+}
+export interface ContentEdit {
+    start: Position;
+    end: Position;
+    text: string;
+}
+export interface Disposable {
+    dispose(): void;
+}
+export type ChangeSource = 'input' | 'command' | 'external';
+export interface EditorSnapshot {
+    text: string;
+    selections: readonly Selection[];
+    revision: number;
+    canUndo: boolean;
+    canRedo: boolean;
+    changes?: readonly (readonly DocumentChange[])[];
+    contentEdits?: readonly ContentEdit[];
+    source?: ChangeSource;
+}
+export interface EditOptions {
+    selections?: readonly Selection[];
+    source?: ChangeSource;
+    historyGroup?: string;
+}
+export type EditorCommand = 'undo' | 'redo' | 'selectAll' | 'smartHome' | 'smartEnd' | 'selectSmartHome' | 'selectSmartEnd' | 'wordLeft' | 'wordRight' | 'selectWordLeft' | 'selectWordRight' | 'deleteWordLeft' | 'deleteWordRight' | 'camelLeft' | 'camelRight' | 'selectCamelLeft' | 'selectCamelRight' | 'deleteCamelLeft' | 'deleteCamelRight' | 'expandSelection' | 'shrinkSelection' | 'smartBackspace' | 'deleteForward' | 'duplicateLine' | 'deleteLine' | 'moveLineUp' | 'moveLineDown' | 'toggleLineComment' | 'toggleBlockComment' | 'insertTab' | 'indent' | 'outdent' | 'insertNewline' | 'startNewLine' | 'startNewLineBefore' | 'splitLine' | 'joinLines' | 'toggleCase' | 'autoIndentLines' | 'addCaretAbove' | 'addCaretBelow' | 'selectNextOccurrence' | 'unselectOccurrence' | 'selectAllOccurrences' | 'addCaretPerSelectedLine';
+export interface CommandOptions {
+    tabSize?: number;
+    insertSpaces?: boolean;
+    commentToken?: string;
+    camelCase?: boolean;
+    autoClosingPairs?: boolean;
+    autoClosingBrackets?: boolean;
+    autoClosingQuotes?: boolean;
+    surroundSelection?: boolean;
+    language?: string;
+    smartSemicolon?: boolean;
+    tabOutOfClosers?: boolean;
+    smartEnter?: boolean;
+    indentOnPaste?: boolean;
+    visualLine?: (offset: number) => {
+        start: number;
+        end: number;
+    };
+    lineSpan?: (line: number) => {
+        first: number;
+        last: number;
+    };
+    onLinesMoved?: (moves: readonly {
+        from: number;
+        to: number;
+    }[]) => void;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/typing-context.d.ts

@@ -0,0 +1,30 @@
+import type { DocumentLine } from './rope.ts';
+export interface TypingBracket {
+    at: number;
+    close: string;
+    previous?: TypingBracket;
+    template?: boolean;
+    control?: boolean;
+    block?: boolean;
+}
+type Mode = 'code' | 'line-comment' | 'block-comment' | 'html-comment' | 'quote' | 'template' | 'regex' | 'html' | 'heredoc';
+export interface TypingContext {
+    mode: Mode;
+    quote?: string;
+    escaped: boolean;
+    inClass: boolean;
+    bracket?: TypingBracket;
+    expression: boolean;
+    word: string;
+    commentStart?: number;
+}
+export declare class TypingContexts {
+    private readonly line;
+    private states;
+    private language;
+    constructor(line: (index: number) => DocumentLine);
+    invalidate(line?: number): void;
+    private initialState;
+    at(line: number, column: number, language: string): TypingContext;
+}
+export {};

package/dist/typing-context.js

@@ -0,0 +1,270 @@
+import { hasBlockComments, hasDashComments, hasHashComments, hashNeedsWordStart, hasMarkupComments, hasSlashComments, isPhp, isScript, isWordCharacter, openers, startsExpression, startsExpressionAfter, startsWord } from './lexical.js';
+const PHP_HEREDOC = /^<<<[ \t]*(["']?)([A-Za-z_]\w*)\1[ \t]*$/;
+const PHP_OPEN = /<\?(?:php\b|=)/;
+const controlWords = /^(for|for-await|if|while|switch|catch|with)$/;
+const blockWords = /^(else|try|finally|do)$/;
+function initial() {
+    return { mode: 'code', escaped: false, inClass: false, expression: true, word: '' };
+}
+function rulesOf(language) {
+    return {
+        script: isScript(language),
+        php: isPhp(language),
+        hash: hasHashComments(language),
+        hashAtWordStart: hashNeedsWordStart(language),
+        dash: hasDashComments(language),
+        slash: hasSlashComments(language),
+        block: hasBlockComments(language),
+        markup: hasMarkupComments(language)
+    };
+}
+function scanComment(state, text, at, end) {
+    const close = state.mode === 'block-comment' ? '*/' : '-->';
+    if (at + close.length <= end && text.startsWith(close, at)) {
+        state.mode = 'code';
+        state.commentStart = undefined;
+        return at + close.length - 1;
+    }
+    return at;
+}
+function scanLiteral(state, text, at, end, offset) {
+    const char = text[at];
+    if (state.escaped) {
+        state.escaped = false;
+    }
+    else if (char === '\\') {
+        state.escaped = true;
+    }
+    else if (state.mode === 'regex') {
+        if (char === '[') {
+            state.inClass = true;
+        }
+        else if (char === ']') {
+            state.inClass = false;
+        }
+        else if (char === '/' && !state.inClass) {
+            state.mode = 'code';
+            state.expression = false;
+        }
+    }
+    else if (state.mode === 'template' && char === '$' && text[at + 1] === '{' && at + 1 < end) {
+        state.bracket = { at: offset + at + 1, close: '}', previous: state.bracket, template: true };
+        state.mode = 'code';
+        state.expression = true;
+        state.word = '';
+        return at + 1;
+    }
+    else if (char === state.quote) {
+        state.mode = 'code';
+        state.expression = false;
+        state.quote = undefined;
+    }
+    return at;
+}
+function scanCode(state, rules, text, at, end, offset) {
+    const char = text[at];
+    const next = text[at + 1];
+    if (/\s/u.test(char)) {
+        return at;
+    }
+    if (rules.markup && text.startsWith('<!--', at)) {
+        state.mode = 'html-comment';
+        state.commentStart = offset + at;
+        return at + 3;
+    }
+    if (rules.hash && char === '#' && !(rules.php && next === '[') && (!rules.hashAtWordStart || startsWord(text, at))) {
+        state.mode = 'line-comment';
+        state.commentStart = offset + at;
+        return at;
+    }
+    if (rules.dash && char === '-' && next === '-') {
+        state.mode = 'line-comment';
+        state.commentStart = offset + at;
+        return at + 1;
+    }
+    if (rules.slash && char === '/' && next === '/') {
+        state.mode = 'line-comment';
+        state.commentStart = offset + at;
+        return at + 1;
+    }
+    if (rules.block && char === '/' && next === '*') {
+        state.mode = 'block-comment';
+        state.commentStart = offset + at;
+        return at + 1;
+    }
+    if (rules.php && char === '<' && text.startsWith('<<<', at)) {
+        const opener = PHP_HEREDOC.exec(text.slice(at));
+        if (opener !== null) {
+            state.mode = 'heredoc';
+            state.quote = opener[2];
+            return text.length;
+        }
+    }
+    if (rules.php && char === '?' && next === '>') {
+        state.mode = 'html';
+        return at + 1;
+    }
+    if (char === '"' || char === "'" || char === '`') {
+        state.mode = rules.script && char === '`' ? 'template' : 'quote';
+        state.quote = char;
+        state.escaped = false;
+        state.word = '';
+        return at;
+    }
+    if (rules.script && char === '/' && state.expression) {
+        state.mode = 'regex';
+        state.inClass = false;
+        state.escaped = false;
+        return at;
+    }
+    if ((char === '+' || char === '-') && next === char) {
+        state.word = '';
+        return at + 1;
+    }
+    if (openers[char]) {
+        state.bracket = {
+            at: offset + at,
+            close: openers[char],
+            previous: state.bracket,
+            control: char === '(' && controlWords.test(state.word),
+            block: char === '{' && (!state.expression || state.word === 'control-close' || blockWords.test(state.word))
+        };
+        state.expression = true;
+        state.word = '';
+    }
+    else if (/[)\]}]/.test(char)) {
+        closeBracket(state, char);
+    }
+    else if (isWordCharacter(char)) {
+        const from = at;
+        while (at + 1 < end && isWordCharacter(text[at + 1])) {
+            at++;
+        }
+        const word = text.slice(from, at + 1);
+        state.word = word === 'await' && state.word === 'for' ? 'for-await' : word;
+        state.expression = startsExpression(word);
+    }
+    else {
+        state.expression = startsExpressionAfter(char);
+        state.word = '';
+    }
+    return at;
+}
+function closeBracket(state, char) {
+    const bracket = state.bracket;
+    if (bracket?.close !== char) {
+        state.bracket = undefined;
+        state.expression = false;
+        return;
+    }
+    state.bracket = bracket.previous;
+    if (bracket.template) {
+        state.mode = 'template';
+        state.quote = '`';
+    }
+    state.expression = Boolean(bracket.control || bracket.block);
+    state.word = bracket.control ? 'control-close' : '';
+}
+/* Lexes `text` up to `end`, from the state the line started in. `offset` is where the line starts in the document. */
+function scan(text, end, start, rules, offset) {
+    const state = { ...start };
+    for (let at = 0; at < end; at++) {
+        if (state.mode === 'line-comment') {
+            // A PHP line comment ends at its line break and at a closing tag.
+            const tag = rules.php ? text.indexOf('?>', at) : -1;
+            if (tag < 0 || tag >= end) {
+                break;
+            }
+            state.mode = 'html';
+            state.commentStart = undefined;
+            at = tag + 1;
+        }
+        else if (state.mode === 'html') {
+            const open = PHP_OPEN.exec(text.slice(at));
+            if (open === null || at + open.index >= end) {
+                break;
+            }
+            state.mode = 'code';
+            state.expression = true;
+            state.word = '';
+            at += open.index + open[0].length - 1;
+        }
+        else if (state.mode === 'heredoc') {
+            const closing = new RegExp(`^[\\t ]*${state.quote}(?![\\w])`).exec(text);
+            if (closing === null) {
+                break;
+            }
+            state.mode = 'code';
+            state.quote = undefined;
+            state.expression = false;
+            at = closing[0].length - 1;
+        }
+        else if (state.mode === 'block-comment' || state.mode === 'html-comment') {
+            at = scanComment(state, text, at, end);
+        }
+        else if (state.mode === 'code') {
+            at = scanCode(state, rules, text, at, end, offset);
+        }
+        else {
+            at = scanLiteral(state, text, at, end, offset);
+        }
+    }
+    return state;
+}
+function sameState(left, right) {
+    return (left.mode === right.mode &&
+        left.quote === right.quote &&
+        left.escaped === right.escaped &&
+        left.inClass === right.inClass &&
+        left.bracket === right.bracket &&
+        left.expression === right.expression &&
+        left.word === right.word &&
+        left.commentStart === right.commentStart);
+}
+/* The state of the lexer at the start of each line, computed on demand. An edit drops the lines from its own on. */
+export class TypingContexts {
+    line;
+    states = [initial()];
+    language = '';
+    constructor(line) {
+        this.line = line;
+    }
+    invalidate(line = 0) {
+        this.states.length = Math.min(this.states.length, Math.max(1, line + 1));
+        if (line === 0) {
+            this.language = '';
+        }
+    }
+    /* A PHP file that opens with markup, and not with a tag, starts outside the PHP. */
+    initialState(language) {
+        const state = initial();
+        if (language === 'php' && /^\s*<(?![?<])/.test(this.line(0).text)) {
+            state.mode = 'html';
+        }
+        return state;
+    }
+    at(line, column, language) {
+        const id = language.toLowerCase();
+        if (this.language !== id) {
+            this.language = id;
+            this.states = [this.initialState(id)];
+        }
+        const rules = rulesOf(id);
+        while (this.states.length <= line) {
+            const previous = this.states.at(-1);
+            const source = this.line(this.states.length - 1);
+            const next = scan(source.text, source.text.length, previous, rules, source.start);
+            // Only PHP and Rust strings run past a line break without a trailing backslash.
+            if (next.mode === 'line-comment' || next.mode === 'regex' || (next.mode === 'quote' && !/^(php|rust|rs)$/i.test(id) && !next.escaped)) {
+                next.mode = 'code';
+                next.quote = undefined;
+                next.commentStart = undefined;
+                next.expression = true;
+            }
+            next.escaped = false;
+            this.states.push(sameState(next, previous) ? previous : next);
+        }
+        const source = this.line(line);
+        return scan(source.text, column, this.states[line], rules, source.start);
+    }
+}

package/dist/typing-handlers.d.ts

@@ -0,0 +1,15 @@
+import type { EditSource } from './edit-source.ts';
+export interface HandlerEdit {
+    from: number;
+    to: number;
+    text: string;
+    caret: number;
+}
+export declare function isQuote(character: string): boolean;
+export declare function swapQuotes(source: EditSource, offset: number, typed: string): HandlerEdit | null;
+export declare function replacesComparison(typed: string, selected: string, inCommentOrString: boolean): boolean;
+export declare function matchingDelimiter(character: string): string;
+export declare function surround(selected: string, typed: string): {
+    text: string;
+    inner: string;
+};