@adecore/editor-core 0.42.0 → 0.44.0

package/src/statements.ts

@@ -0,0 +1,307 @@
+import type { EditSource } from './edit-source.ts';
+import { lineContinues } from './enter.ts';
+import type { FoldingRange } from './structure.ts';
+import { isBlank, whitespaceOf } from './line-text.ts';
+
+/* The indentation of a line text in columns, tabs taken to their stops. */
+export function indentWidth(text: string, tabSize: number): number {
+    return visualWidth(whitespaceOf(text), tabSize);
+}
+
+/* The width in columns of a text that starts a line, tabs taken to their stops. */
+export function visualWidth(text: string, tabSize: number): number {
+    let width = 0;
+
+    for (const character of text) {
+        width += character === '\t' ? tabSize - (width % tabSize) : 1;
+    }
+
+    return width;
+}
+
+/* The `{` brackets the offset is inside, innermost first. None in a string, a comment or markup, and an `${` of a template is no block. */
+export function enclosingBraces(source: EditSource, offset: number): number[] {
+    const context = source.context(offset);
+
+    if (context.mode !== 'code') {
+        return [];
+    }
+
+    const braces: number[] = [];
+
+    for (let bracket = context.bracket; bracket !== undefined; bracket = bracket.previous) {
+        if (bracket.close === '}' && bracket.template !== true) {
+            braces.push(bracket.at);
+        }
+    }
+
+    return braces;
+}
+
+/* The innermost `{` around the offset, or null. */
+export function enclosingBrace(source: EditSource, offset: number): number | null {
+    return enclosingBraces(source, offset)[0] ?? null;
+}
+
+export interface IndentGuide {
+    /* The line the guide starts on: the header, at the guide's own indent. */
+    startLine: number;
+    /* The first later line at or above the guide's indent, or the line count when the text ends first. */
+    endLine: number;
+}
+
+function nextNonBlank(source: EditSource, line: number): number {
+    let next = line + 1;
+
+    while (next < source.lineCount && isBlank(source.line(next).text)) {
+        next++;
+    }
+
+    return next;
+}
+
+/*
+ * The guide an editor draws at `column` (in columns, tabs expanded) that holds `line`: a line at that indent
+ * whose next non-blank line is deeper starts it, and the first later non-blank line at or above that indent ends it.
+ */
+export function indentGuideAt(source: EditSource, line: number, column: number, tabSize: number): IndentGuide | null {
+    if (column <= 0 || line < 0 || line >= source.lineCount) {
+        return null;
+    }
+
+    for (let start = line; start >= 0; start--) {
+        const text = source.line(start).text;
+
+        if (isBlank(text)) {
+            continue;
+        }
+
+        const indent = indentWidth(text, tabSize);
+
+        if (indent > column) {
+            continue;
+        }
+
+        const following = nextNonBlank(source, start);
+
+        if (indent < column || following >= source.lineCount || indentWidth(source.line(following).text, tabSize) <= column) {
+            return null;
+        }
+
+        let end = following;
+
+        while (end < source.lineCount && (isBlank(source.line(end).text) || indentWidth(source.line(end).text, tabSize) > column)) {
+            end++;
+        }
+
+        return end > line ? { startLine: start, endLine: end } : null;
+    }
+
+    return null;
+}
+
+const CONTINUATION_START = /^(?:\{|\.|\?\.|&&|\|\||\?\?|\+(?!\+)|-(?!-)|\?|:|else\b|catch\b|finally\b)/;
+
+/*
+ * The first line of the statement a line belongs to: a line that opens with a closer belongs to the statement of its
+ * opener, and a line the one above leaves open, or that goes on with a member access, an operator or `else`, to the one above.
+ */
+export function statementStart(source: EditSource, line: number, language: string): number {
+    let first = line;
+
+    // Each step goes up at least one line, so the walk ends.
+    while (first > 0) {
+        const info = source.line(first);
+        const lead = info.text.length - info.text.trimStart().length;
+        const opener = /^[)\]}]/.test(info.text.slice(lead)) ? source.context(info.start + lead).bracket : undefined;
+        const openerLine = opener === undefined ? first : source.lineAt(opener.at);
+
+        if (openerLine < first) {
+            first = openerLine;
+
+            continue;
+        }
+
+        const above = first - 1;
+
+        if (isBlank(source.line(above).text) || !(CONTINUATION_START.test(info.text.trimStart()) || lineContinues(source, language, above))) {
+            break;
+        }
+
+        first = above;
+    }
+
+    return first;
+}
+
+const MODIFIERS =
+    '(?:export\\s+|default\\s+|declare\\s+|abstract\\s+|async\\s+|pub(?:\\([^)]*\\))?\\s+|public\\s+|private\\s+|protected\\s+|static\\s+|final\\s+|readonly\\s+|override\\s+|unsafe\\s+|extern\\s+)*';
+
+// The outline of the editor reads headers the same way; a statement is not a declaration when it ends in a value, so `type` and `namespace` are left out.
+export const DECLARATION = new RegExp(`^${MODIFIERS}(function\\*?|class|interface|enum|trait|impl|struct|fn|func|object|record)\\b`);
+export const METHOD = /^(?:(?:public|private|protected|static|async|get|set|override|readonly|abstract)\s+)*\*?\s*([A-Za-z_$#][\w$]*)\s*[(<]/;
+export const NOT_METHODS = new Set([
+    'if',
+    'for',
+    'while',
+    'switch',
+    'catch',
+    'function',
+    'return',
+    'else',
+    'with',
+    'do',
+    'try',
+    'new',
+    'await',
+    'typeof',
+    'super',
+    'finally'
+]);
+export const BODIES = new Set(['class', 'interface', 'enum', 'trait', 'impl', 'struct', 'object', 'record']);
+/* What kind of body the offset is in: that of an interface, of another type or namespace, or none of them. */
+export function declarationBody(source: EditSource, offset: number): 'interface' | 'other' | null {
+    const brace = enclosingBrace(source, offset);
+
+    if (brace === null) {
+        return null;
+    }
+
+    const braceLine = source.lineAt(brace);
+    const own = source.line(braceLine).text.slice(0, brace - source.line(braceLine).start);
+    // A brace on a line of its own belongs to the header above it.
+    const header = own.trim() === '' && braceLine > 0 ? source.line(braceLine - 1).text : own;
+
+    if (/\binterface\b/.test(header)) {
+        return 'interface';
+    }
+
+    return /\b(?:class|enum|trait|impl|struct|object|record|namespace)\b/.test(header) ? 'other' : null;
+}
+
+export interface StatementRange {
+    /* The first line, counting the doc comment and the attributes above the code. */
+    first: number;
+    /* The first line of the code itself. */
+    code: number;
+    last: number;
+}
+
+/* The doc comment a line is part of, as the lines it spans. */
+function docCommentAt(source: EditSource, line: number): { first: number; last: number } | null {
+    let first = line;
+
+    while (first >= 0 && !source.line(first).text.trim().startsWith('/**') && source.line(first).text.trim().startsWith('*')) {
+        first--;
+    }
+
+    if (first < 0 || !source.line(first).text.trim().startsWith('/**')) {
+        return null;
+    }
+
+    let last = first;
+
+    while (last < source.lineCount - 1 && !source.line(last).text.includes('*/')) {
+        last++;
+    }
+
+    return last >= line ? { first, last } : null;
+}
+
+function isAttribute(text: string): boolean {
+    return /^\s*(?:@|#\[)/.test(text);
+}
+
+const NO_STRUCTURE: readonly FoldingRange[] = [];
+
+/* The offset of the bracket that is still open at the start of a line and is no block of statements. */
+function enclosingOpener(source: EditSource, line: number): number | null {
+    const open = source.context(source.line(line).start).bracket;
+
+    return open !== undefined && open.template !== true && !(open.close === '}' && open.block === true) ? open.at : null;
+}
+
+function chainLength(source: EditSource, offset: number): number {
+    let length = 0;
+
+    for (let bracket = source.context(offset).bracket; bracket !== undefined; bracket = bracket.previous) {
+        length++;
+    }
+
+    return length;
+}
+
+/* The last line of the statement that starts on `from`: where the brackets it opened are closed again and nothing goes on. */
+function statementLast(source: EditSource, from: number, language: string): number {
+    const depth = chainLength(source, source.line(from).start);
+    const isDo = /^\s*do\b/.test(source.line(from).text);
+
+    for (let line = from; line < source.lineCount; line++) {
+        const info = source.line(line);
+
+        if (chainLength(source, info.end) > depth || lineContinues(source, language, line)) {
+            continue;
+        }
+
+        const next = line + 1 < source.lineCount ? source.line(line + 1).text.trimStart() : '';
+
+        if (next !== '' && (CONTINUATION_START.test(next) || (isDo && /^while\b/.test(next))) && !isBlank(info.text)) {
+            continue;
+        }
+
+        return line;
+    }
+
+    return source.lineCount - 1;
+}
+
+/*
+ * The lines of the statement a line belongs to. A doc comment and the attributes right above it are part of it, a line
+ * in them stands for the statement below, and a range a server or a bracket pair folds from its first line sets its end.
+ */
+export function statementAt(source: EditSource, line: number, language: string, structure: readonly FoldingRange[] = NO_STRUCTURE): StatementRange {
+    let code = line;
+    const doc = docCommentAt(source, code);
+
+    if (doc !== null) {
+        code = doc.last + 1;
+    }
+
+    while (code < source.lineCount - 1 && isAttribute(source.line(code).text)) {
+        code++;
+    }
+
+    if (code >= source.lineCount || isBlank(source.line(code).text)) {
+        return { first: line, code: line, last: line };
+    }
+
+    // A line inside brackets a line above opened belongs to the statement of that line.
+    for (let open = enclosingOpener(source, code); open !== null; open = enclosingOpener(source, code)) {
+        code = statementStart(source, source.lineAt(open), language);
+    }
+
+    code = statementStart(source, code, language);
+    let first = code;
+
+    for (let above = first - 1; above >= 0; above = first - 1) {
+        const comment = source.line(above).text.trim().endsWith('*/') ? docCommentAt(source, above) : null;
+
+        if (comment !== null) {
+            first = comment.first;
+        } else if (isAttribute(source.line(above).text)) {
+            first = above;
+        } else {
+            break;
+        }
+    }
+
+    let last = statementLast(source, code, language);
+
+    for (const range of structure) {
+        if (range.startLine === code && range.endLine > last) {
+            last = range.endLine;
+        }
+    }
+
+    return { first, code, last };
+}

package/src/surround-shape.ts

@@ -0,0 +1,172 @@
+import type { EditSource } from './edit-source.ts';
+import { lineContinues } from './enter.ts';
+import { skipTriviaBack } from './trivia.ts';
+
+export interface SurroundShape {
+    /* The range after trimming whitespace. */
+    readonly from: number;
+    readonly to: number;
+    /* Whole statements: statement surrounders apply. */
+    readonly statements: boolean;
+    /* One expression: `(expr)` and `!(expr)` apply. */
+    readonly expression: boolean;
+}
+
+const KEYWORDS = new Set([
+    'if',
+    'else',
+    'for',
+    'foreach',
+    'while',
+    'do',
+    'try',
+    'catch',
+    'finally',
+    'switch',
+    'case',
+    'default',
+    'return',
+    'throw',
+    'break',
+    'continue',
+    'const',
+    'let',
+    'var',
+    'function',
+    'class',
+    'interface',
+    'enum',
+    'import',
+    'export',
+    'echo',
+    'use',
+    'namespace',
+    'abstract',
+    'final'
+]);
+
+/* Whether a statement can start at the offset: after `;`, a block, a control statement's head, `else` or `do`, or on a line the one above leaves closed. */
+export function atStatementStart(source: EditSource, offset: number, language: string): boolean {
+    const context = source.context(offset);
+    const bracket = context.bracket;
+
+    // Inside parentheses, brackets or an object literal a new line starts an element, not a statement.
+    if (context.mode !== 'code' || (bracket !== undefined && !(bracket.close === '}' && bracket.block === true && bracket.template !== true))) {
+        return false;
+    }
+
+    if (context.word === 'control-close' || context.word === 'else' || context.word === 'do') {
+        return true;
+    }
+
+    const before = skipTriviaBack(source, offset);
+
+    if (before === 0) {
+        return true;
+    }
+
+    const last = source.charAt(before - 1);
+
+    if (last === ';' || (last === '{' && bracket?.at === before - 1)) {
+        return true;
+    }
+
+    if (last === '}') {
+        const opener = source.context(before - 1).bracket;
+
+        if (opener?.block === true && opener.template !== true) {
+            return true;
+        }
+    }
+
+    const line = source.line(source.lineAt(offset));
+
+    return source.slice(line.start, offset).trim() === '' && (line.start === 0 || !lineContinues(source, language, source.lineAt(offset) - 1));
+}
+
+/* Whether a statement ends at the offset: after `;` or `}`, or at the end of a line the statement does not go on after. */
+function atStatementEnd(source: EditSource, offset: number, language: string): boolean {
+    const last = source.charAt(offset - 1);
+
+    if (last === ';' || last === '}') {
+        return true;
+    }
+
+    const index = source.lineAt(offset);
+
+    return source.slice(offset, source.line(index).end).trim() === '' && !lineContinues(source, language, index);
+}
+
+/* Whether the range holds a `;` or a block at its own depth, which no expression does. */
+function holdsStatements(source: EditSource, from: number, to: number): boolean {
+    const bracket = source.context(from).bracket;
+
+    for (const match of source.slice(from, to).matchAll(/[;{]/g)) {
+        const at = from + match.index;
+
+        if (source.context(at).bracket?.at !== bracket?.at || source.context(at).mode !== 'code') {
+            continue;
+        }
+
+        if (match[0] === ';' || source.context(at + 1).bracket?.block === true) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+/* The line break of the range's last line, past a trailing line comment, or `to` when something else follows. */
+function widenedEnd(source: EditSource, to: number): number {
+    const line = source.line(source.lineAt(to));
+    const rest = source.slice(to, line.end);
+
+    if (rest.trim() === '') {
+        return to;
+    }
+
+    const context = source.context(line.end);
+
+    if (context.mode !== 'line-comment' || context.commentStart === undefined || context.commentStart < to) {
+        return to;
+    }
+
+    return source.slice(to, context.commentStart).trim() === '' ? to + rest.trimEnd().length : to;
+}
+
+/*
+ * What a range can be surrounded with: whole statements, one expression, both or neither. Both ends have to be code
+ * in the same bracket, and statements also start and end where a statement does.
+ */
+export function surroundShape(source: EditSource, from: number, to: number, language: string): SurroundShape | null {
+    let start = from;
+    let end = to;
+
+    while (start < end && /\s/u.test(source.charAt(start))) {
+        start++;
+    }
+
+    while (end > start && /\s/u.test(source.charAt(end - 1))) {
+        end--;
+    }
+
+    if (start >= end) {
+        return null;
+    }
+
+    const first = source.context(start);
+    const last = source.context(end);
+
+    // Brackets are compared by position, since a scan makes new ones for the line it starts on.
+    if (first.mode !== 'code' || last.mode !== 'code' || first.bracket?.at !== last.bracket?.at) {
+        return { from: start, to: end, statements: false, expression: false };
+    }
+
+    const statements = atStatementStart(source, start, language) && atStatementEnd(source, end, language);
+    const wide = statements ? widenedEnd(source, end) : end;
+    const text = source.slice(start, end);
+    const word = /^[\p{L}_$][\p{L}\p{N}_$]*/u.exec(text)?.[0] ?? '';
+    const expression = wide === end && !/[\n\r]/.test(text) && !KEYWORDS.has(word) && !holdsStatements(source, start, end);
+
+    return { from: start, to: wide, statements, expression };
+}

package/src/text-places.ts

@@ -0,0 +1,126 @@
+import type { EditSource } from './edit-source.ts';
+import { editRegions } from './edit-regions.ts';
+import { vueRegionAt } from './languages.ts';
+import type { TypingContext } from './typing-context.ts';
+
+export type TextPlaceKind = 'code' | 'comment' | 'string';
+
+export interface TextPlace {
+    /* The language the offset is written in, with embedded regions resolved: `typescript` in `<script lang="ts">` of a Vue file, `css` in `<style>`, `html` in PHP markup. */
+    readonly language: string;
+    readonly kind: TextPlaceKind;
+}
+
+const SCAN_LIMIT = 2_000_000;
+const JSX_LANGUAGES = /^(?:typescriptreact|javascriptreact|tsx|jsx)$/;
+const VUE_TAG = /^<\/?(?:template|script|style)\b/;
+
+function kindOf(context: TypingContext): TextPlaceKind {
+    switch (context.mode) {
+        case 'line-comment':
+        case 'block-comment':
+        case 'html-comment':
+            return 'comment';
+
+        case 'quote':
+        case 'template':
+        case 'heredoc':
+        case 'regex':
+            return 'string';
+
+        case 'html':
+            if (context.markup === 'comment') {
+                return 'comment';
+            }
+
+            return context.markup === 'value' ? 'string' : 'code';
+
+        default:
+            return 'code';
+    }
+}
+
+/* The language of a `<script>` or `<style>` of a Vue file, read from the `lang` attribute of the tag that opened the region. */
+function vueRegionLanguage(source: EditSource, line: number, region: 'script' | 'style'): string {
+    for (let index = line; index >= 0; index--) {
+        const text = source.line(index).text;
+
+        if (!text.startsWith(`<${region}`)) {
+            continue;
+        }
+
+        const lang = /\blang\s*=\s*["']?([\w-]+)/.exec(text)?.[1]?.toLowerCase();
+
+        if (region === 'style') {
+            return lang === 'scss' || lang === 'less' ? lang : 'css';
+        }
+
+        return lang === 'ts' || lang === 'tsx' ? 'typescript' : 'javascript';
+    }
+
+    return region === 'style' ? 'css' : 'javascript';
+}
+
+function vueLanguage(source: EditSource, offset: number): string {
+    const line = source.lineAt(offset);
+    const region = VUE_TAG.test(source.line(line).text) ? null : vueRegionAt((index) => source.line(index).text, line);
+
+    return region === 'script' || region === 'style' ? vueRegionLanguage(source, line, region) : 'html';
+}
+
+/* Whether a `<script>` or `<style>` element is open at the offset in a plain markup document. */
+function markupLanguage(source: EditSource, offset: number): string {
+    let open: string | null = null;
+
+    for (const match of source.slice(0, offset).matchAll(/<(\/)?(script|style)\b[^>]*?(\/)?>/gi)) {
+        open = match[1] === undefined && match[3] === undefined ? match[2]!.toLowerCase() : null;
+    }
+
+    if (open === null) {
+        return 'html';
+    }
+
+    return open === 'script' ? 'javascript' : 'css';
+}
+
+function phpLanguage(context: TypingContext): string {
+    if (context.embedded === 'javascript') {
+        return 'javascript';
+    }
+
+    if (context.mode !== 'html') {
+        return 'php';
+    }
+
+    return context.markup === 'raw' && context.element === 'style' ? 'css' : 'html';
+}
+
+/* What the text at an offset is written in and whether it is code, a comment or a string. */
+export function placeAt(source: EditSource, offset: number, language: string): TextPlace {
+    const id = language.toLowerCase();
+
+    if (source.line(source.lineCount - 1).end > SCAN_LIMIT) {
+        return { language, kind: 'code' };
+    }
+
+    const context = source.context(offset);
+    const kind = kindOf(context);
+
+    if (id === 'php') {
+        return { language: phpLanguage(context), kind };
+    }
+
+    if (id === 'vue') {
+        return { language: vueLanguage(source, offset), kind };
+    }
+
+    if (id === 'html' || id === 'xhtml') {
+        return { language: markupLanguage(source, offset), kind };
+    }
+
+    if (JSX_LANGUAGES.test(id) && editRegions(source, id)(source.lineAt(offset), offset) === 'jsx') {
+        return { language: 'html', kind };
+    }
+
+    return { language, kind };
+}

package/src/trivia.ts

@@ -0,0 +1,29 @@
+import type { EditSource } from './edit-source.ts';
+
+/* The end of the last token before `end`, past the whitespace and the comments between them. */
+export function skipTriviaBack(source: EditSource, end: number): number {
+    let at = end;
+
+    while (at > 0) {
+        const char = source.charAt(at - 1);
+
+        if (/\s/u.test(char)) {
+            at--;
+
+            continue;
+        }
+
+        // The lexer leaves a block comment at its `*`, so the state before the closing `/` is already code.
+        const inside = source.context(char === '/' && at > 1 && source.charAt(at - 2) === '*' ? at - 2 : at - 1);
+
+        if ((inside.mode === 'line-comment' || inside.mode === 'block-comment') && inside.commentStart !== undefined && inside.commentStart < at) {
+            at = inside.commentStart;
+
+            continue;
+        }
+
+        break;
+    }
+
+    return at;
+}

package/src/types.ts

@@ -1,3 +1,5 @@
+import type { FoldingRange } from './structure.ts';
+
 /* Offsets are UTF-16 code units from the start of the document. */
 export interface Selection {
     anchor: number;
@@ -115,7 +117,16 @@ export type EditorCommand =
     | 'reverseLines'
     | 'uniqueLines'
     | 'convertIndentsToSpaces'
-    | 'convertIndentsToTabs';
+    | 'convertIndentsToTabs'
+    | 'codeBlockStart'
+    | 'codeBlockEnd'
+    | 'codeBlockStartWithSelection'
+    | 'codeBlockEndWithSelection'
+    | 'completeCurrentStatement'
+    | 'moveStatementUp'
+    | 'moveStatementDown'
+    | 'hippieCompletion'
+    | 'hippieBackwardCompletion';
 
 export interface CommandOptions {
     /* Clamped to 1 through 16. */
@@ -151,4 +162,10 @@ export interface CommandOptions {
     lineSpan?: (line: number) => { first: number; last: number };
     /* Told which lines a move went to (`from` before, `to` after), so a host can take what it keeps by line along. */
     onLinesMoved?: (moves: readonly { from: number; to: number }[]) => void;
+    /* The folding ranges of the document, a language server's included, which Move Statement reads the extent of a statement from. Without it the model scans its own. */
+    structure?: () => readonly FoldingRange[];
+    /* Whether the indent guides count as blocks for the code block commands. Off unless true. */
+    indentGuides?: boolean;
+    /* The texts of the other open documents, which Hippie completion takes words from after those of this one. */
+    wordSources?: () => readonly string[];
 }