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

package/dist/typing-handlers.js

@@ -0,0 +1,125 @@
+const quotes = /["'`]/;
+export function isQuote(character) {
+    return quotes.test(character);
+}
+/* Every quote of a body with whether a backslash escapes it. */
+function quotesIn(body, selected, typed) {
+    const found = [];
+    let escaped = false;
+    for (let index = 0; index < body.length; index++) {
+        const character = body[index];
+        if (escaped) {
+            if (character === selected || character === typed) {
+                found.push({ index, escaped: true });
+            }
+            escaped = false;
+        }
+        else if (character === '\\') {
+            escaped = true;
+        }
+        else if (character === selected || character === typed) {
+            found.push({ index, escaped: false });
+        }
+    }
+    return found;
+}
+/* The string that has the quote at `offset` for its opening or its closing quote, on that line. */
+function stringAround(source, offset, quote) {
+    const line = source.line(source.lineAt(offset));
+    const before = source.context(offset);
+    const after = source.context(offset + 1);
+    const inString = (mode) => mode === 'quote' || mode === 'template';
+    if (before.mode === 'code' && inString(after.mode) && after.quote === quote) {
+        const text = source.slice(offset + 1, line.end);
+        for (let at = 0; at < text.length; at++) {
+            if (text[at] === '\\') {
+                at++;
+            }
+            else if (text[at] === quote) {
+                return { start: offset, end: offset + 1 + at };
+            }
+        }
+        return null;
+    }
+    if (inString(before.mode) && before.quote === quote && !before.escaped && after.mode === 'code') {
+        const text = source.slice(line.start, offset);
+        for (let at = text.length - 1; at >= 0; at--) {
+            let slashes = 0;
+            while (at - slashes - 1 >= 0 && text[at - slashes - 1] === '\\') {
+                slashes++;
+            }
+            if (text[at] === quote && slashes % 2 === 0) {
+                return { start: line.start + at, end: offset };
+            }
+        }
+    }
+    return null;
+}
+/*
+ * A quote typed over a selected quote of a string turns that string's own quotes into the typed
+ * one, escaping the typed quote inside it and unescaping the old one.
+ */
+export function swapQuotes(source, offset, typed) {
+    const selected = source.charAt(offset);
+    if (selected === typed || !isQuote(selected) || !isQuote(typed)) {
+        return null;
+    }
+    const span = stringAround(source, offset, selected);
+    if (!span) {
+        return null;
+    }
+    const body = source.slice(span.start + 1, span.end);
+    const inside = quotesIn(body, selected, typed);
+    const interpolated = selected === '`' && body.includes('${');
+    if (interpolated && inside.length > 0) {
+        return null;
+    }
+    let rewritten = body;
+    if (!interpolated) {
+        let shift = 0;
+        for (const { index, escaped } of inside) {
+            const character = body[index];
+            if (character === typed && !escaped) {
+                rewritten = rewritten.slice(0, index + shift) + '\\' + rewritten.slice(index + shift);
+                shift++;
+            }
+            else if (character === selected && escaped) {
+                rewritten = rewritten.slice(0, index + shift - 1) + rewritten.slice(index + shift);
+                shift--;
+            }
+        }
+    }
+    const text = typed + rewritten + typed;
+    return { from: span.start, to: span.end + 1, text, caret: offset === span.start ? 1 : text.length };
+}
+const comparison = /^[<>=!]+$/;
+/* Whether typing `<` or `>` over this selection replaces an operator, as `<` over `==` does. */
+export function replacesComparison(typed, selected, inCommentOrString) {
+    return (typed === '<' || typed === '>') && selected.length <= 3 && comparison.test(selected) && !inCommentOrString;
+}
+const closerOf = { '(': ')', '[': ']', '{': '}', '<': '>', '"': '"', "'": "'", '`': '`' };
+export function matchingDelimiter(character) {
+    return closerOf[character] ?? character;
+}
+function similarDelimiters(left, right) {
+    const bracket = (character) => /[([{<]/.test(character);
+    return (bracket(left) && bracket(right)) || (isQuote(left) && isQuote(right));
+}
+/*
+ * What a delimiter typed over a selection makes of it: the selection between the new delimiters. A
+ * selection that already has delimiters of the same kind swaps them for the typed ones.
+ */
+export function surround(selected, typed) {
+    let inner = selected;
+    if (selected.length > 1) {
+        const first = selected[0];
+        const last = selected.at(-1);
+        if (similarDelimiters(first, typed) &&
+            last === matchingDelimiter(first) &&
+            (isQuote(first) || first !== typed) &&
+            selected.indexOf(last, 1) === selected.length - 1) {
+            inner = selected.slice(1, -1);
+        }
+    }
+    return { text: typed + inner + matchingDelimiter(typed), inner };
+}

package/dist/words.d.ts

@@ -0,0 +1,7 @@
+export type WordText = string | {
+    readonly length: number;
+    charAt(offset: number): string;
+};
+export declare function isHumpBoundary(text: WordText, offset: number, isStart: boolean): boolean;
+export declare function isWordBoundary(text: WordText, offset: number, camel: boolean, isStart: boolean): boolean;
+export declare function wordBoundary(text: WordText, offset: number, direction: -1 | 1, camel?: boolean): number;

package/dist/words.js

@@ -0,0 +1,72 @@
+// Copyright 2000-2023 JetBrains s.r.o. and contributors.
+// Adapted to TypeScript under Apache-2.0; see NOTICE, README.md and LICENSE.apache-2.0.txt.
+//
+// isWordBoundary, isHumpBoundary and isPunctuation adapt `isWordBoundary`, `isHumpBound`,
+// `isLowerCaseOrDigit` and `isPunctuation` from JetBrains/intellij-community at
+// 7184b03af6c5370e79a01ded0df68cf56d7669da, platform/platform-impl/src/com/intellij/openapi/editor/actions/EditorActionUtil.java,
+// lines 934-982.
+// Java's Character.isJavaIdentifierPart, which counts the ignorable control characters as part of a word.
+// oxlint-disable-next-line no-control-regex
+const identifierPart = /[\p{L}\p{Nl}\p{Sc}\p{Pc}\p{Nd}\p{Mc}\p{Mn}\p{Cf}\u0000-\u0008\u000e-\u001b\u007f-\u009f]/u;
+// Java's Character.isWhitespace: no no-break spaces.
+// oxlint-disable-next-line no-control-regex
+const whitespace = /[\t\n\v\f\r\u001c-\u0020\u1680\u2000-\u2006\u2008-\u200a\u2028\u2029\u205f\u3000]/u;
+const lower = /\p{Lowercase}/u;
+const upper = /\p{Uppercase}/u;
+const digit = /\p{Nd}/u;
+const letterOrDigit = /[\p{L}\p{Nd}]/u;
+function characterAt(text, offset) {
+    return offset >= 0 && offset < text.length ? text.charAt(offset) : '\0';
+}
+function isPunctuation(character) {
+    return !(identifierPart.test(character) || whitespace.test(character));
+}
+/* Whether `offset` splits a camel hump, a digit run or an underscore from the word around it. */
+export function isHumpBoundary(text, offset, isStart) {
+    if (offset <= 0 || offset >= text.length) {
+        return false;
+    }
+    const previous = characterAt(text, offset - 1);
+    const current = characterAt(text, offset);
+    const next = characterAt(text, offset + 1);
+    const hump = isStart ? current : previous;
+    const neighbor = isStart ? previous : current;
+    return (((lower.test(previous) || digit.test(previous)) && upper.test(current)) ||
+        (neighbor === '_' && hump !== '_') ||
+        (neighbor === '$' && letterOrDigit.test(hump)) ||
+        (upper.test(previous) && upper.test(current) && lower.test(next)));
+}
+/* Whether a word starts (`isStart`) or ends at `offset`. Punctuation runs count as words. */
+export function isWordBoundary(text, offset, camel, isStart) {
+    if (offset < 0 || offset > text.length) {
+        return false;
+    }
+    const previous = characterAt(text, offset - 1);
+    const current = characterAt(text, offset);
+    const word = isStart ? current : previous;
+    const neighbor = isStart ? previous : current;
+    if (identifierPart.test(word)) {
+        if (!identifierPart.test(neighbor)) {
+            return true;
+        }
+        if (camel && isHumpBoundary(text, offset, isStart)) {
+            return true;
+        }
+    }
+    return isPunctuation(word) && !isPunctuation(neighbor);
+}
+/* The next stop in `direction`, never inside a surrogate pair or between CR and LF. Written here, not ported. */
+export function wordBoundary(text, offset, direction, camel = true) {
+    let position = offset + direction;
+    while (position > 0 && position < text.length) {
+        const before = text.charAt(position - 1);
+        const after = text.charAt(position);
+        const splitsPair = /[\ud800-\udbff]/.test(before) && /[\udc00-\udfff]/.test(after);
+        const splitsLineBreak = before === '\r' && after === '\n';
+        if (!splitsPair && !splitsLineBreak && isWordBoundary(text, position, camel, direction === -1)) {
+            return position;
+        }
+        position += direction;
+    }
+    return Math.max(0, Math.min(text.length, position));
+}

package/package.json

@@ -1,11 +1,42 @@
 {
   "name": "@adecore/editor-core",
-  "version": "0.0.1",
-  "description": "Placeholder for the first release.",
+  "version": "0.17.0-beta.1",
+  "type": "module",
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "benchmark": "bun --expose-gc scripts/benchmark.ts",
+    "build": "bun scripts/build.ts",
+    "test": "bun test --conditions=source"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.4.2",
+    "typescript": "^7.0.2"
+  },
   "license": "FSL-1.1-MIT",
+  "author": "Bas Milius",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/basmilius/adecore.git",
     "directory": "packages/editor-core"
-  }
+  },
+  "bugs": {
+    "url": "https://github.com/basmilius/adecore/issues"
+  },
+  "homepage": "https://adecore.dev/editor-core/",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "src",
+    "!src/**/*.test.ts",
+    "LICENSE",
+    "NOTICE",
+    "LICENSE.apache-2.0.txt"
+  ]
 }

package/src/block-folds.ts

@@ -0,0 +1,117 @@
+import { rangeOf } from './lexical-folds.ts';
+import type { DocumentLine } from './rope.ts';
+import type { FoldingRange } from './structure.ts';
+
+const MARKDOWN = /^(markdown|md|mdx)$/i;
+const HEADING = /^(#{1,6})\s+\S/;
+const FENCE = /^\s*(`{3,}|~{3,})/;
+const TABLE_ROW = /^\s*\|/;
+const HEREDOC = /<<<[ \t]*(["']?)([A-Za-z_]\w*)\1\s*$/;
+
+/*
+ * Front matter, code fences, tables and the sections under headings. A fence closes on a line of the same
+ * character and at least as long, and what a fence holds is never read as a heading or a table.
+ */
+function markdownFolds(lineCount: number, getLine: (line: number) => DocumentLine): FoldingRange[] {
+    const result: FoldingRange[] = [];
+    const headings: { line: number; level: number }[] = [];
+    let first = 0;
+    if (lineCount > 0 && getLine(0).text.trim() === '---') {
+        for (let line = 1; line < lineCount; line++) {
+            const text = getLine(line).text.trim();
+            if (text === '---' || text === '...') {
+                result.push(rangeOf(0, line, getLine, 'block', 'front-matter'));
+                first = line + 1;
+                break;
+            }
+        }
+    }
+    let tableStart = -1;
+    const flushTable = (end: number): void => {
+        if (tableStart !== -1 && end > tableStart) {
+            result.push(rangeOf(tableStart, end, getLine, 'block', 'table'));
+        }
+        tableStart = -1;
+    };
+    for (let line = first; line < lineCount; line++) {
+        const text = getLine(line).text;
+        const fence = FENCE.exec(text);
+        if (fence !== null) {
+            flushTable(line - 1);
+            const marker = fence[1]!;
+            let end = -1;
+            for (let next = line + 1; next < lineCount && end === -1; next++) {
+                const closer = FENCE.exec(getLine(next).text);
+                if (closer !== null && closer[1]![0] === marker[0] && closer[1]!.length >= marker.length && getLine(next).text.trim() === closer[1]) {
+                    end = next;
+                }
+            }
+            if (end !== -1) {
+                result.push(rangeOf(line, end, getLine, 'block', 'code-fence'));
+                line = end;
+            }
+            continue;
+        }
+        if (TABLE_ROW.test(text)) {
+            tableStart = tableStart === -1 ? line : tableStart;
+            continue;
+        }
+        flushTable(line - 1);
+        const heading = HEADING.exec(text);
+        if (heading !== null) {
+            headings.push({ line, level: heading[1]!.length });
+        }
+    }
+    flushTable(lineCount - 1);
+    for (const [index, heading] of headings.entries()) {
+        const next = headings.slice(index + 1).find((candidate) => candidate.level <= heading.level);
+        let end = (next?.line ?? lineCount) - 1;
+        while (end > heading.line && getLine(end).text.trim() === '') {
+            end--;
+        }
+        if (end > heading.line) {
+            result.push(rangeOf(heading.line, end, getLine, 'section'));
+        }
+    }
+    return result;
+}
+
+/* `<?php ... ?>` blocks that sit between markup, and heredocs and nowdocs. A block that opens the file is the file, not a fold. */
+function phpFolds(lineCount: number, getLine: (line: number) => DocumentLine): FoldingRange[] {
+    const result: FoldingRange[] = [];
+    let open = -1;
+    for (let line = 0; line < lineCount; line++) {
+        const text = getLine(line).text;
+        const heredoc = HEREDOC.exec(text);
+        if (heredoc !== null) {
+            const closer = new RegExp(`^\\s*${heredoc[2]}\\b`);
+            for (let next = line + 1; next < lineCount; next++) {
+                if (closer.test(getLine(next).text)) {
+                    result.push(rangeOf(line, next, getLine, 'block', 'heredoc'));
+                    line = next;
+                    break;
+                }
+            }
+            continue;
+        }
+        const opened = open === -1 ? text.search(/<\?(?:php\b|=)/) : -1;
+        const closed = text.indexOf('?>', Math.max(0, opened));
+        if (opened !== -1 && closed === -1) {
+            open = line === 0 ? -1 : line;
+        } else if (open !== -1 && closed !== -1) {
+            if (line > open) {
+                result.push(rangeOf(open, line, getLine, 'block', 'php-tag'));
+            }
+            open = -1;
+        }
+    }
+    return result;
+}
+
+/* The folds of whole lines that a language has beyond brackets and indentation. */
+export function blockFolds(lineCount: number, getLine: (line: number) => DocumentLine, language: string): FoldingRange[] {
+    if (MARKDOWN.test(language)) {
+        return markdownFolds(lineCount, getLine);
+    }
+    return language.toLowerCase() === 'php' ? phpFolds(lineCount, getLine) : [];
+}

package/src/brackets.ts

@@ -0,0 +1,159 @@
+import {
+    hasBlockComments,
+    hasDashComments,
+    hasHashComments,
+    hashNeedsWordStart,
+    hasMarkupComments,
+    hasSlashComments,
+    isPhp,
+    isScript,
+    isWordCharacter,
+    openers,
+    startsExpression,
+    startsExpressionAfter,
+    startsWord
+} from './lexical.ts';
+
+export interface BracketIndex {
+    /* Both directions: an opener maps to its closer and the closer back to the opener. */
+    pairs: ReadonlyMap<number, number>;
+    unmatched: ReadonlySet<number>;
+}
+
+interface OpenBracket {
+    at: number;
+    close: string;
+    /* An `${` whose closer resumes the template text. */
+    template?: boolean;
+}
+
+function skipLine(text: string, at: number): number {
+    const end = text.indexOf('\n', at + 1);
+    return end < 0 ? text.length : end;
+}
+
+function skipComment(text: string, from: number, terminator: string): number {
+    const end = text.indexOf(terminator, from);
+    return end < 0 ? text.length : end + terminator.length - 1;
+}
+
+function skipString(text: string, at: number, quote: string, endsAtLineBreak: boolean): number {
+    let cursor = at + 1;
+    for (; cursor < text.length; cursor++) {
+        if (text[cursor] === '\\') {
+            cursor++;
+        } else if (text[cursor] === quote || (endsAtLineBreak && /[\r\n]/.test(text[cursor]))) {
+            break;
+        }
+    }
+    return cursor;
+}
+
+function skipRegex(text: string, at: number): number {
+    let inClass = false;
+    let cursor = at + 1;
+    for (; cursor < text.length; cursor++) {
+        const character = text[cursor];
+        if (character === '\\') {
+            cursor++;
+        } else if (character === '[') {
+            inClass = true;
+        } else if (character === ']') {
+            inClass = false;
+        } else if ((character === '/' && !inClass) || /[\r\n]/.test(character)) {
+            break;
+        }
+    }
+    return cursor;
+}
+
+/* Lexical pairing for incomplete code; malformed nesting never produces crossing pairs. */
+export function scanBrackets(text: string, language = 'typescript'): BracketIndex {
+    const pairs = new Map<number, number>();
+    const unmatched = new Set<number>();
+    const stack: OpenBracket[] = [];
+    const script = isScript(language);
+    const hashComments = hasHashComments(language);
+    const hashAtWordStart = hashNeedsWordStart(language);
+    const dashComments = hasDashComments(language);
+    const phpAttributes = isPhp(language);
+    const slashComments = hasSlashComments(language);
+    const blockComments = hasBlockComments(language);
+    const markupComments = hasMarkupComments(language);
+    let inTemplate = false;
+    let expectsExpression = true;
+
+    for (let at = 0; at < text.length; at++) {
+        const char = text[at];
+        const next = text[at + 1];
+
+        if (inTemplate) {
+            if (char === '\\') {
+                at++;
+            } else if (char === '`') {
+                inTemplate = false;
+                expectsExpression = false;
+            } else if (char === '$' && next === '{') {
+                stack.push({ at: ++at, close: '}', template: true });
+                inTemplate = false;
+                expectsExpression = true;
+            }
+            continue;
+        }
+
+        if (/\s/.test(char)) {
+            continue;
+        }
+
+        if (markupComments && text.startsWith('<!--', at)) {
+            at = skipComment(text, at + 4, '-->');
+        } else if (
+            (slashComments && char === '/' && next === '/') ||
+            (dashComments && char === '-' && next === '-') ||
+            (hashComments && char === '#' && !(phpAttributes && next === '[') && (!hashAtWordStart || startsWord(text, at)))
+        ) {
+            at = skipLine(text, at);
+        } else if (blockComments && char === '/' && next === '*') {
+            at = skipComment(text, at + 2, '*/');
+        } else if (char === '"' || char === "'") {
+            at = skipString(text, at, char, script);
+            expectsExpression = false;
+        } else if (script && char === '`') {
+            inTemplate = true;
+        } else if (script && char === '/' && expectsExpression) {
+            at = skipRegex(text, at);
+            expectsExpression = false;
+        } else if (openers[char]) {
+            stack.push({ at, close: openers[char] });
+            expectsExpression = true;
+        } else if (/[)\]}]/.test(char)) {
+            const open = stack.at(-1);
+            if (open?.close === char) {
+                stack.pop();
+                pairs.set(open.at, at);
+                pairs.set(at, open.at);
+                inTemplate = open.template === true;
+            } else {
+                unmatched.add(at);
+                // A mismatched closer keeps a distant opener from claiming it later.
+                for (const abandoned of stack.splice(0)) {
+                    unmatched.add(abandoned.at);
+                }
+            }
+            expectsExpression = false;
+        } else if (isWordCharacter(char)) {
+            const start = at;
+            while (at + 1 < text.length && isWordCharacter(text[at + 1])) {
+                at++;
+            }
+            expectsExpression = startsExpression(text.slice(start, at + 1));
+        } else {
+            expectsExpression = startsExpressionAfter(char);
+        }
+    }
+
+    for (const open of stack) {
+        unmatched.add(open.at);
+    }
+    return { pairs, unmatched };
+}

package/src/closer-tracker.ts

@@ -0,0 +1,60 @@
+import type { Selection, TextEdit } from './types.ts';
+
+interface Mark {
+    open: number;
+    close: number;
+}
+
+const limit = 64;
+
+/*
+ * The closers the editor inserted by itself and the caret has not left yet, which Tab steps over. A
+ * mark follows its opener and closer through edits and goes as soon as an edit replaces either one
+ * or no caret sits inside the pair any more.
+ */
+export class CloserTracker {
+    private marks: Mark[] = [];
+
+    add(open: number, close: number): void {
+        this.marks.push({ open, close });
+        if (this.marks.length > limit) {
+            this.marks.shift();
+        }
+    }
+
+    /* The closer that sits at `offset`, which a Tab there steps over. */
+    isCloserAt(offset: number): boolean {
+        return this.marks.some((mark) => mark.close === offset);
+    }
+
+    map(edits: readonly TextEdit[]): void {
+        this.marks = this.marks.flatMap((mark) => {
+            const open = mapThrough(mark.open, edits);
+            const close = mapThrough(mark.close, edits);
+            return open === null || close === null ? [] : [{ open, close }];
+        });
+    }
+
+    prune(selections: readonly Selection[]): void {
+        this.marks = this.marks.filter((mark) => selections.some((selection) => selection.head > mark.open && selection.head <= mark.close));
+    }
+
+    clear(): void {
+        this.marks = [];
+    }
+}
+
+/* Null when an edit replaced the character at `offset`. */
+function mapThrough(offset: number, edits: readonly TextEdit[]): number | null {
+    let delta = 0;
+    for (const edit of edits) {
+        if (offset < edit.from) {
+            break;
+        }
+        if (offset < edit.to) {
+            return null;
+        }
+        delta += edit.text.length - (edit.to - edit.from);
+    }
+    return offset + delta;
+}