@adecore/editor-core 0.43.0 → 0.44.0

package/dist/text-places.js

@@ -0,0 +1,87 @@
+import { editRegions } from './edit-regions.js';
+import { vueRegionAt } from './languages.js';
+const SCAN_LIMIT = 2_000_000;
+const JSX_LANGUAGES = /^(?:typescriptreact|javascriptreact|tsx|jsx)$/;
+const VUE_TAG = /^<\/?(?:template|script|style)\b/;
+function kindOf(context) {
+    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, line, region) {
+    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, offset) {
+    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, offset) {
+    let open = 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) {
+    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, offset, language) {
+    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/dist/trivia.d.ts

@@ -0,0 +1,2 @@
+import type { EditSource } from './edit-source.ts';
+export declare function skipTriviaBack(source: EditSource, end: number): number;

package/dist/trivia.js

@@ -0,0 +1,19 @@
+/* The end of the last token before `end`, past the whitespace and the comments between them. */
+export function skipTriviaBack(source, end) {
+    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/dist/unwrap.d.ts

@@ -0,0 +1,10 @@
+import type { OffsetRange } from './document.ts';
+import type { EditSource } from './edit-source.ts';
+import type { TextEdit } from './types.ts';
+export type UnwrapKind = 'if' | 'else' | 'removeElse' | 'for' | 'while' | 'do' | 'try' | 'removeCatch' | 'removeFinally' | 'braces';
+export interface UnwrapTarget {
+    readonly kind: UnwrapKind;
+    readonly range: OffsetRange;
+    readonly edits: readonly TextEdit[];
+}
+export declare function unwrapTargets(source: EditSource, offset: number, language: string, indentUnit: string): UnwrapTarget[];

package/dist/unwrap.js

@@ -0,0 +1,320 @@
+import { isPhp, isScript, isWordCharacter } from './lexical.js';
+import { whitespaceOf } from './line-text.js';
+import { enclosingBraces } from './statements.js';
+import { placeAt } from './text-places.js';
+import { skipTriviaBack } from './trivia.js';
+const SCAN_LIMIT = 2_000_000;
+const LOOPS = new Set(['for', 'foreach']);
+function wordBefore(source, end) {
+    const to = skipTriviaBack(source, end);
+    let from = to;
+    while (from > 0 && isWordCharacter(source.charAt(from - 1))) {
+        from--;
+    }
+    return from === to ? null : { text: source.slice(from, to), from };
+}
+function skipSpaces(source, at) {
+    let next = at;
+    while (/\s/u.test(source.charAt(next))) {
+        next++;
+    }
+    return next;
+}
+function wordAt(source, at) {
+    let end = at;
+    while (end < at + 12 && isWordCharacter(source.charAt(end))) {
+        end++;
+    }
+    return source.slice(at, end);
+}
+/* The closer of the bracket at `open`. */
+function closerOf(source, open) {
+    const closer = source.charAt(open) === '(' ? ')' : '}';
+    const text = source.slice(open + 1, Math.min(source.line(source.lineCount - 1).end, open + 1 + SCAN_LIMIT));
+    for (let index = text.indexOf(closer); index >= 0; index = text.indexOf(closer, index + 1)) {
+        const context = source.context(open + 1 + index);
+        if (context.mode === 'code' && context.bracket?.at === open) {
+            return open + 1 + index;
+        }
+    }
+    return null;
+}
+/* The header of the block that opens at `open`, or null for a function, a class, an object and the like. */
+function headerOf(source, open) {
+    const before = skipTriviaBack(source, open);
+    const last = source.charAt(before - 1);
+    if (last === ')') {
+        const paren = source.context(before - 1).bracket;
+        // The lexer flags the parenthesis of `foreach` and `elseif` as plain, so the word decides.
+        const keyword = paren === undefined ? null : wordBefore(source, paren.at);
+        if (keyword === null) {
+            return null;
+        }
+        if (LOOPS.has(keyword.text) || keyword.text === 'await') {
+            const loop = keyword.text === 'await' ? wordBefore(source, keyword.from) : keyword;
+            return loop !== null && LOOPS.has(loop.text) ? { word: 'for', start: loop.from } : null;
+        }
+        if (keyword.text === 'elseif') {
+            return { word: 'if', start: keyword.from, elseStart: keyword.from };
+        }
+        if (keyword.text === 'if') {
+            const before = wordBefore(source, keyword.from);
+            return { word: 'if', start: keyword.from, elseStart: before?.text === 'else' ? before.from : undefined };
+        }
+        if (keyword.text === 'while') {
+            return { word: 'while', start: keyword.from };
+        }
+        return keyword.text === 'catch' ? { word: 'catch', start: keyword.from } : null;
+    }
+    const word = wordBefore(source, open);
+    if (word !== null) {
+        return word.text === 'else' || word.text === 'try' || word.text === 'finally' || word.text === 'do' || word.text === 'catch'
+            ? { word: word.text, start: word.from }
+            : null;
+    }
+    // The lexer takes a brace after `;` or `{` for an object, so only the text before it says that it is a block.
+    const inBlock = last === ';' || last === '{' || before === 0 || (last === '}' && source.context(before - 1).bracket?.block === true);
+    return inBlock ? { word: 'braces', start: open } : null;
+}
+/* The block that ends right before `end`, past whitespace and comments. */
+function blockEndingAt(source, end) {
+    const close = skipTriviaBack(source, end) - 1;
+    const open = close >= 0 && source.charAt(close) === '}' ? source.context(close).bracket : undefined;
+    if (open === undefined || open.template === true) {
+        return null;
+    }
+    const header = headerOf(source, open.at);
+    return header === null ? null : { header, open: open.at, close };
+}
+/* The closer of the block after an optional parenthesis, starting at `at`. */
+function blockAfter(source, at, parenthesis) {
+    let next = skipSpaces(source, at);
+    if (parenthesis) {
+        const close = source.charAt(next) === '(' ? closerOf(source, next) : null;
+        if (close === null) {
+            return null;
+        }
+        next = skipSpaces(source, close + 1);
+    }
+    return source.charAt(next) === '{' ? closerOf(source, next) : null;
+}
+/* The end of an `if` statement whose first block closes at `close`, past its `else if` and `else` clauses. */
+function ifEnd(source, close) {
+    let end = close + 1;
+    for (;;) {
+        const at = skipSpaces(source, end);
+        const word = wordAt(source, at);
+        let next = null;
+        if (word === 'elseif') {
+            next = blockAfter(source, at + word.length, true);
+        }
+        else if (word === 'else') {
+            const after = skipSpaces(source, at + word.length);
+            next = wordAt(source, after) === 'if' ? blockAfter(source, after + 2, true) : blockAfter(source, at + word.length, false);
+        }
+        if (next === null) {
+            return end;
+        }
+        end = next + 1;
+    }
+}
+/* The `try` block that closes at `close` and the `catch` and `finally` blocks behind it. */
+function tryClauses(source, close) {
+    const clauses = [{ word: 'try', close }];
+    for (;;) {
+        const at = skipSpaces(source, clauses.at(-1).close + 1);
+        const word = wordAt(source, at);
+        if (word !== 'catch' && word !== 'finally') {
+            return clauses;
+        }
+        const closer = blockAfter(source, at + word.length, source.charAt(skipSpaces(source, at + word.length)) === '(');
+        if (closer === null) {
+            return clauses;
+        }
+        clauses.push({ word, close: closer });
+    }
+}
+/* The end of a `do` statement whose block closes at `close`, with its `while` condition. */
+function doEnd(source, close) {
+    const at = skipSpaces(source, close + 1);
+    if (wordAt(source, at) !== 'while') {
+        return close + 1;
+    }
+    const paren = skipSpaces(source, at + 5);
+    const closer = source.charAt(paren) === '(' ? closerOf(source, paren) : null;
+    if (closer === null) {
+        return close + 1;
+    }
+    return closer + 1 + (/^[ \t]*;/.exec(source.slice(closer + 1, closer + 16))?.[0].length ?? 0);
+}
+function lineBreakLength(source, at) {
+    const char = source.charAt(at);
+    if (char === '\r') {
+        return source.charAt(at + 1) === '\n' ? 2 : 1;
+    }
+    return char === '\n' ? 1 : 0;
+}
+/* The construct and the line it leaves blank, as one deletion. */
+function deleteConstruct(source, start, end) {
+    const first = source.line(source.lineAt(start));
+    const last = source.line(source.lineAt(end));
+    return {
+        from: source.slice(first.start, start).trim() === '' ? first.start : start,
+        to: source.slice(end, last.end).trim() === '' ? last.next : end,
+        text: ''
+    };
+}
+/* The edits that keep the body of the block at `open` and drop the rest of the construct that runs from `start` to `end`. */
+function unwrapEdits(source, indentUnit, start, open, close, end) {
+    if (source.slice(open + 1, close).trim() === '') {
+        return [deleteConstruct(source, start, end)];
+    }
+    let afterOpen = open + 1;
+    while (source.charAt(afterOpen) === ' ' || source.charAt(afterOpen) === '\t') {
+        afterOpen++;
+    }
+    const headerLine = source.line(source.lineAt(start));
+    const headerIndent = whitespaceOf(headerLine.text).length;
+    // The body takes the place of the header, so the header's own indentation goes too.
+    const edits = [
+        { from: source.slice(headerLine.start, start).trim() === '' ? headerLine.start : start, to: afterOpen + lineBreakLength(source, afterOpen), text: '' }
+    ];
+    let delta = 0;
+    for (let index = source.lineAt(open) + 1; index < source.lineAt(close); index++) {
+        const line = source.line(index);
+        if (line.text.trim() === '') {
+            continue;
+        }
+        const indent = whitespaceOf(line.text).length;
+        if (delta === 0) {
+            delta = indent > headerIndent ? indent - headerIndent : indentUnit.length;
+        }
+        const removed = Math.min(delta, indent);
+        if (removed > 0) {
+            edits.push({ from: line.start, to: line.start + removed, text: '' });
+        }
+    }
+    const closing = source.line(source.lineAt(close));
+    const alone = source.slice(closing.start, close).trim() === '';
+    let from = close;
+    if (alone && closing.start > 0) {
+        from = source.line(source.lineAt(close) - 1).end;
+    }
+    else {
+        while (from > closing.start && /[ \t]/.test(source.charAt(from - 1))) {
+            from--;
+        }
+    }
+    edits.push({ from, to: end, text: '' });
+    return edits;
+}
+/* The `if` statement an `else` block belongs to, and the block right before the `else`. */
+function ifOf(source, header) {
+    let current = header;
+    let first = null;
+    for (;;) {
+        const previous = blockEndingAt(source, current.elseStart ?? current.start);
+        if (previous === null || previous.header.word !== 'if') {
+            return null;
+        }
+        first ??= previous;
+        if (previous.header.elseStart === undefined) {
+            return { start: previous.header.start, previous: first };
+        }
+        current = previous.header;
+    }
+}
+/* The `try` block and its clauses around a `catch` or `finally` block. */
+function tryOf(source, header) {
+    let current = header;
+    for (;;) {
+        const previous = blockEndingAt(source, current.start);
+        if (previous === null || (previous.header.word !== 'try' && previous.header.word !== 'catch')) {
+            return null;
+        }
+        if (previous.header.word === 'try') {
+            return { start: previous.header.start, clauses: tryClauses(source, previous.close) };
+        }
+        current = previous.header;
+    }
+}
+function targetsOf(source, header, open, indentUnit) {
+    const close = closerOf(source, open);
+    if (close === null) {
+        return [];
+    }
+    switch (header.word) {
+        case 'if': {
+            const end = ifEnd(source, close);
+            return [{ kind: 'if', range: { from: header.start, to: end }, edits: unwrapEdits(source, indentUnit, header.start, open, close, end) }];
+        }
+        case 'else': {
+            const chain = ifOf(source, header);
+            if (chain === null) {
+                return [];
+            }
+            const range = { from: chain.start, to: close + 1 };
+            return [
+                { kind: 'else', range, edits: unwrapEdits(source, indentUnit, chain.start, open, close, close + 1) },
+                { kind: 'removeElse', range, edits: [{ from: chain.previous.close + 1, to: close + 1, text: '' }] }
+            ];
+        }
+        case 'for':
+        case 'while':
+            return [
+                {
+                    kind: header.word,
+                    range: { from: header.start, to: close + 1 },
+                    edits: unwrapEdits(source, indentUnit, header.start, open, close, close + 1)
+                }
+            ];
+        case 'do': {
+            const end = doEnd(source, close);
+            return [{ kind: 'do', range: { from: header.start, to: end }, edits: unwrapEdits(source, indentUnit, header.start, open, close, end) }];
+        }
+        case 'try': {
+            const end = tryClauses(source, close).at(-1).close + 1;
+            return [{ kind: 'try', range: { from: header.start, to: end }, edits: unwrapEdits(source, indentUnit, header.start, open, close, end) }];
+        }
+        case 'catch':
+        case 'finally': {
+            const statement = tryOf(source, header);
+            const index = statement?.clauses.findIndex((clause) => clause.close === close) ?? -1;
+            if (statement === null || index < 1) {
+                return [];
+            }
+            const others = statement.clauses.filter((clause, position) => position !== index && clause.word !== 'try');
+            // A try needs a catch or a finally, so the last of them stays, and a finally needs a catch beside it.
+            if (header.word === 'catch' ? others.length === 0 : !others.some((clause) => clause.word === 'catch')) {
+                return [];
+            }
+            return [
+                {
+                    kind: header.word === 'catch' ? 'removeCatch' : 'removeFinally',
+                    range: { from: statement.start, to: statement.clauses.at(-1).close + 1 },
+                    edits: [{ from: statement.clauses[index - 1].close + 1, to: close + 1, text: '' }]
+                }
+            ];
+        }
+        default:
+            return [{ kind: 'braces', range: { from: open, to: close + 1 }, edits: unwrapEdits(source, indentUnit, open, open, close, close + 1) }];
+    }
+}
+/*
+ * What can be unwrapped or removed around an offset, innermost first: a statement whose body stays and whose header goes,
+ * or a clause that goes with its body. Only the blocks of control statements and bare blocks count, not functions, classes or objects.
+ */
+export function unwrapTargets(source, offset, language, indentUnit) {
+    const place = placeAt(source, offset, language);
+    if (place.kind !== 'code' || !(isScript(place.language) || isPhp(place.language))) {
+        return [];
+    }
+    const targets = [];
+    for (const open of enclosingBraces(source, offset)) {
+        const header = headerOf(source, open);
+        if (header !== null) {
+            targets.push(...targetsOf(source, header, open, indentUnit));
+        }
+    }
+    return targets;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/editor-core",
-  "version": "0.43.0",
+  "version": "0.44.0",
   "type": "module",
   "exports": {
     ".": {

package/src/document.ts

@@ -40,6 +40,10 @@ import type {
     TextEdit
 } from './types.ts';
 import { TypingContexts } from './typing-context.ts';
+import { placeAt, type TextPlace } from './text-places.ts';
+import { postfixOperands, type PostfixOperand } from './postfix-operands.ts';
+import { surroundShape, type SurroundShape } from './surround-shape.ts';
+import { unwrapTargets, type UnwrapTarget } from './unwrap.ts';
 import type { TypingContext } from './typing-context.ts';
 import { todosInLines, type TodoMatch, type TodoOptions } from './todo.ts';
 import { type LineOrder, planConvertIndents, planLineOrder } from './line-order.ts';
@@ -2150,6 +2154,26 @@ export class DocumentModel {
         return this.applyEdits(plan.edits, { source: 'command', selections });
     }
 
+    /* What the text at an offset is written in, with embedded regions resolved, and whether it is code, a comment or a string. */
+    placeAt(offset: number, language: string): TextPlace {
+        return placeAt(this.editSource(language), offset, language);
+    }
+
+    /* Every expression that ends right before the `.` at `dot`, innermost first; empty where none does. */
+    postfixOperands(dot: number, language: string): PostfixOperand[] {
+        return postfixOperands(this.editSource(language), dot, language);
+    }
+
+    /* What a range can be surrounded with: whole statements, one expression, both or neither. Null where the range is blank. */
+    surroundShape(from: number, to: number, language: string): SurroundShape | null {
+        return surroundShape(this.editSource(language), from, to, language);
+    }
+
+    /* What can be unwrapped or removed around an offset, innermost first, each with the edits that do it. */
+    unwrapTargets(offset: number, language: string, indentUnit: string): UnwrapTarget[] {
+        return unwrapTargets(this.editSource(language), offset, language, indentUnit);
+    }
+
     private editSource(language: string): EditSource {
         return {
             lineCount: this.getLineCount(),

package/src/index.ts

@@ -3,6 +3,7 @@ export type { DocumentEditOptions, DocumentLine, OffsetRange, ReplaceAllOptions,
 export { scanBrackets, type BracketIndex, type BracketMatch } from './brackets.ts';
 export { findMatches, iterateMatches, findMatchFrom, replacementText, type FindMatch, type FindNextOptions, type FindOptions } from './search.ts';
 export { indentationColumn } from './structure.ts';
+export { commentSyntax, type CommentSyntax } from './languages.ts';
 export { findDocComments, MAX_DOC_COMMENTS, type DocComment } from './doc-comments.ts';
 export { DEFAULT_TODO_WORDS, findTodos, type TodoMatch, type TodoOptions } from './todo.ts';
 export { detectIndentation, type DetectedIndentation } from './line-order.ts';
@@ -24,3 +25,7 @@ export type {
 } from './types.ts';
 
 export { changedSpan, changedSpans, type TextSpan } from './text-span.ts';
+export type { TextPlace, TextPlaceKind } from './text-places.ts';
+export type { PostfixOperand } from './postfix-operands.ts';
+export type { SurroundShape } from './surround-shape.ts';
+export type { UnwrapKind, UnwrapTarget } from './unwrap.ts';