@adecore/editor-core 0.43.0 → 0.44.1

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

@@ -147,6 +147,8 @@ export interface CommandOptions {
     smartSemicolon?: boolean;
     /* In PHP a `-` typed after a variable, a member or a `)` or `]` becomes `->`. On unless false. */
     smartArrow?: boolean;
+    /* In JavaScript and TypeScript a `${` typed in a quoted string makes it a template literal, in a second undo step. On unless false. */
+    templateLiterals?: boolean;
     /* Tab steps over a closer the editor inserted. On unless false. */
     tabOutOfClosers?: boolean;
     /* Enter computes the indentation of the new line, continues comments and closes braces. On unless false. */

package/src/typing-handlers.ts

@@ -1,4 +1,5 @@
 import type { EditSource } from './edit-source.ts';
+import type { TextEdit } from './types.ts';
 
 /* A change of text in one place and where the caret stands in what replaces it. */
 export interface HandlerEdit {
@@ -169,3 +170,85 @@ export function surround(selected: string, typed: string): { text: string; inner
 
     return { text: typed + inner + matchingDelimiter(typed), inner };
 }
+
+const scriptLanguages = /^(javascript|typescript|jsx|tsx|javascriptreact|typescriptreact|js|ts|mjs|cjs|mts|cts)$/i;
+const moduleSpecifier = /(?:\bfrom|\bimport|\brequire)\s*\(?\s*$/;
+
+/*
+ * The quotes of the string a `${` is typed in when that makes it a template literal: a single- or
+ * double-quoted string of a script, closed on its line and not the specifier of a module.
+ */
+export function templateString(source: EditSource, offset: number, language: string): { open: number; close: number } | null {
+    const line = source.lineAt(offset);
+    const script = scriptLanguages.test(language) || (/^vue$/i.test(language) && source.region(line) === 'script');
+
+    const { start, end } = source.line(line);
+    const before = source.slice(start, offset);
+
+    if (!script || !before.endsWith('$') || escapedIn(before, before.length - 1)) {
+        return null;
+    }
+
+    const context = source.context(offset);
+
+    if (context.mode !== 'quote' || context.escaped || (context.quote !== "'" && context.quote !== '"')) {
+        return null;
+    }
+
+    let open = before.length - 1;
+
+    while (open >= 0 && (before[open] !== context.quote || escapedIn(before, open))) {
+        open--;
+    }
+
+    if (open < 0 || moduleSpecifier.test(before.slice(0, open))) {
+        return null;
+    }
+
+    const after = source.slice(offset, end);
+
+    for (let at = 0; at < after.length; at++) {
+        if (after[at] === '\\') {
+            at++;
+        } else if (after[at] === context.quote) {
+            return { open: start + open, close: offset + at };
+        }
+    }
+
+    return null;
+}
+
+function escapedIn(text: string, index: number): boolean {
+    let slashes = 0;
+
+    while (index - slashes - 1 >= 0 && text[index - slashes - 1] === '\\') {
+        slashes++;
+    }
+
+    return slashes % 2 === 1;
+}
+
+/* The edits that make the string between the quotes at `open` and `close` a template literal: its backticks are escaped and its escaped old quotes are not. */
+export function templateLiteralEdits(source: EditSource, open: number, close: number): TextEdit[] {
+    const quote = source.charAt(open);
+    const body = source.slice(open + 1, close);
+    const edits: TextEdit[] = [{ from: open, to: open + 1, text: '`' }];
+
+    for (let index = 0; index < body.length; index++) {
+        const at = open + 1 + index;
+
+        if (body[index] === '\\') {
+            if (body[index + 1] === quote) {
+                edits.push({ from: at, to: at + 1, text: '' });
+            }
+
+            index++;
+        } else if (body[index] === '`') {
+            edits.push({ from: at, to: at + 1, text: '\\`' });
+        }
+    }
+
+    edits.push({ from: close, to: close + 1, text: '`' });
+
+    return edits;
+}