@adecore/editor-core 0.21.1 → 0.22.0

package/src/enter.ts

@@ -1,6 +1,7 @@
 import type { EditSource } from './edit-source.ts';
 import { commentSyntax } from './languages.ts';
-import { hasHashComments, isBraced, isPhp } from './lexical.ts';
+import { hasHashComments, isBraced, isPhp, openers } from './lexical.ts';
+import { whitespaceOf } from './line-text.ts';
 import { hasJsx, isJsxAttributeValue } from './markup-regions.ts';
 import type { DocumentLine } from './rope.ts';
 import { indentationColumn } from './structure.ts';
@@ -25,7 +26,6 @@ export interface EnterPlan {
     caret: number;
 }
 
-const closers: Readonly<Record<string, string>> = { '(': ')', '[': ']', '{': '}' };
 const concatenation = new Map<string, string>();
 for (const id of 'typescript javascript typescriptreact javascriptreact tsx jsx ts js java csharp cs kotlin scala dart swift go groovy'.split(' ')) {
     concatenation.set(id, '+');
@@ -41,11 +41,7 @@ const jsxScanLimit = 2_000_000;
 /* How far past the caret a comment is searched for its end. */
 const commentReach = 20_000;
 
-function whitespaceOf(text: string): string {
-    return /^[\t ]*/.exec(text)![0];
-}
-
-function isBlank(text: string): boolean {
+function isIndentOnly(text: string): boolean {
     return /^[\t ]*$/.test(text);
 }
 
@@ -90,16 +86,21 @@ class Enter {
             return { from, to, text: newline + leading, caret: newline.length + leading.length };
         }
         const context = source.context(from);
-        const selection = from !== to;
-        const planned =
-            context.mode === 'block-comment'
-                ? this.inBlockComment(from, to, context, index)
-                : context.mode === 'line-comment' && !selection
-                  ? this.inLineComment(from, context, index)
-                  : context.mode === 'quote' && !selection
-                    ? this.inString(from, context, index)
-                    : null;
-        return planned ?? this.inCode(from, to, context, index);
+        return this.inLiteral(from, to, context, index) ?? this.inCode(from, to, context, index);
+    }
+
+    /* The plan inside a comment or a string, or null where Enter acts as in code. */
+    private inLiteral(from: number, to: number, context: TypingContext, index: number): EnterPlan | null {
+        if (context.mode === 'block-comment') {
+            return this.inBlockComment(from, to, context, index);
+        }
+        if (from !== to) {
+            return null;
+        }
+        if (context.mode === 'line-comment') {
+            return this.inLineComment(from, context, index);
+        }
+        return context.mode === 'quote' ? this.inString(from, context, index) : null;
     }
 
     /* The indentation a new statement after this line gets, which is not the line's own when the line is a continuation. */
@@ -115,7 +116,7 @@ class Enter {
 
     private previousCodeLine(index: number): number | null {
         for (let candidate = index - 1; candidate >= 0 && candidate >= index - lookBack; candidate--) {
-            if (!isBlank(this.source.line(candidate).text)) {
+            if (!isIndentOnly(this.source.line(candidate).text)) {
                 return candidate;
             }
         }
@@ -137,7 +138,7 @@ class Enter {
         const { unit, language } = options;
         // A comment that trails the code is not part of what decides the indentation.
         const commentAt = lineContext.mode === 'line-comment' ? lineContext.commentStart : undefined;
-        const trailing = commentAt !== undefined && commentAt >= line.start && !isBlank(source.slice(line.start, commentAt));
+        const trailing = commentAt !== undefined && commentAt >= line.start && !isIndentOnly(source.slice(line.start, commentAt));
         const trimmed = trailing ? source.slice(line.start, commentAt).trimEnd() : before.trimEnd();
         const context = trailing ? source.context(line.start + trimmed.length) : lineContext;
         const last = trimmed.at(-1) ?? '';
@@ -152,10 +153,10 @@ class Enter {
             return plain(leading);
         }
 
-        const opener = closers[last] !== undefined && context.bracket?.close === closers[last] && context.bracket.at === line.start + trimmed.length - 1;
+        const opener = openers[last] !== undefined && context.bracket?.close === openers[last] && context.bracket.at === line.start + trimmed.length - 1;
         if (opener) {
             const inner = start + unit;
-            if (next === closers[last]) {
+            if (next === openers[last]) {
                 return { from, to: afterWhitespace, text: newline + inner + newline + start, caret: newline.length + inner.length };
             }
             const closing =
@@ -177,7 +178,8 @@ class Enter {
         }
 
         if (continues(trimmed, context, language)) {
-            const continued = this.previousCodeLine(index) !== null && this.lineContinues(this.previousCodeLine(index)!);
+            const previous = this.previousCodeLine(index);
+            const continued = previous !== null && this.lineContinues(previous);
             return plain(continued ? leading : start + unit);
         }
         return plain(start);
@@ -272,7 +274,7 @@ class Enter {
             return { from, to: textStart, text: newline + leading, caret: newline.length + leading.length };
         }
         const code = source.slice(line.start, commentStart);
-        const onlyComment = isBlank(code);
+        const onlyComment = isIndentOnly(code);
         let spacing = ' ';
         if (onlyComment) {
             const gap = whitespaceOf(source.slice(commentStart + marker.length, line.end));
@@ -405,7 +407,13 @@ class Enter {
             }
             return { from, to: textStart, text: newline + star, caret: newline.length + star.length };
         }
-        if (isDoc && onOpener && source.lineAt(closeAt) === index && isBlank(source.slice(to, closeAt)) && isBlank(source.slice(closeAt + 2, line.end))) {
+        if (
+            isDoc &&
+            onOpener &&
+            source.lineAt(closeAt) === index &&
+            isIndentOnly(source.slice(to, closeAt)) &&
+            isIndentOnly(source.slice(closeAt + 2, line.end))
+        ) {
             // Nothing left to say after the caret: the closer gets a line of its own, under the opener's star.
             const star = this.starPrefix(line, lead, false, isDoc);
             return { from, to: line.end, text: `${newline}${star}${newline}${lead} */`, caret: newline.length + star.length };

package/src/fold-roles.ts

@@ -1,4 +1,5 @@
-import { isImportLine } from './lexical-folds.ts';
+import { isImportLine, rangeOf, textStart } from './lexical-folds.ts';
+import { isBlank } from './line-text.ts';
 import type { DocumentLine } from './rope.ts';
 import type { FoldHints, FoldRangeHint, FoldRole, FoldingRange } from './structure.ts';
 
@@ -46,10 +47,6 @@ export function bracketRole(slice: (from: number, to: number) => string, from: n
     return /^\s*(?:case\b|default\s*:|(?:export\s+)?(?:declare\s+)?(?:type|interface)\b)/.test(head) ? undefined : 'object-literal';
 }
 
-function isBlank(text: string): boolean {
-    return text.trim() === '';
-}
-
 /*
  * The comment at the very top of a file is its header, unless it is the documentation of what follows
  * right under it. Only the first comment can be one, and only behind a shebang, an open tag or blank lines.
@@ -65,8 +62,7 @@ export function markFileHeader(ranges: FoldingRange[], getLine: (line: number) =
             return;
         }
     }
-    const start = getLine(candidate.startLine);
-    if (candidate.from > start.start + (start.text.length - start.text.trimStart().length)) {
+    if (candidate.from > textStart(getLine(candidate.startLine))) {
         return;
     }
     const next = candidate.endLine + 1 < lineCount ? getLine(candidate.endLine + 1).text : '';
@@ -125,19 +121,9 @@ export function applyFoldHints(
         if (endLine - startLine < minimum || starts.has(startLine)) {
             continue;
         }
-        const first = getLine(startLine);
-        const indent = first.text.length - first.text.trimStart().length;
-        const role = serverRole(hint.kind, first.text.trimStart());
         starts.add(startLine);
-        result.push({
-            startLine,
-            endLine,
-            from: first.start + indent,
-            to: getLine(endLine).end,
-            kind: 'server',
-            ...(role === undefined ? {} : { role }),
-            ...edgesOf(hint)
-        });
+        const role = serverRole(hint.kind, getLine(startLine).text.trimStart());
+        result.push({ ...rangeOf(startLine, endLine, getLine, 'server', role), ...edgesOf(hint) });
     }
     return result.sort((left, right) => left.startLine - right.startLine || right.endLine - left.endLine);
 }

package/src/lexical-folds.ts

@@ -48,6 +48,11 @@ function bracketDelta(text: string): number {
     return depth;
 }
 
+/* The offset of the first character of a line that is not indentation. */
+export function textStart(line: DocumentLine): number {
+    return line.start + (line.text.length - line.text.trimStart().length);
+}
+
 /* A fold of whole lines, from the end of the first to the end of the last. */
 export function rangeOf(
     startLine: number,
@@ -56,11 +61,10 @@ export function rangeOf(
     kind: FoldingRange['kind'],
     role?: FoldRole
 ): FoldingRange {
-    const start = getLine(startLine);
     return {
         startLine,
         endLine,
-        from: start.start + (start.text.length - start.text.trimStart().length),
+        from: textStart(getLine(startLine)),
         to: getLine(endLine).end,
         kind,
         ...(role === undefined ? {} : { role })

package/src/line-commands.ts

@@ -2,6 +2,7 @@ import type { EditPlan, EditSource } from './edit-source.ts';
 import { commentSyntax } from './languages.ts';
 import { continues } from './enter.ts';
 import { indentsByBrackets } from './lexical.ts';
+import { isBlank, rangeOf, whitespaceOf } from './line-text.ts';
 import { markupGuard } from './markup-regions.ts';
 import { mapOffset } from './offsets.ts';
 import type { Selection, TextEdit } from './types.ts';
@@ -15,18 +16,6 @@ export interface LineCommandOptions {
 
 const identifier = /[\p{L}\p{N}\p{M}\p{Pc}$]/u;
 
-function rangeOf(selection: Selection): { from: number; to: number } {
-    return { from: Math.min(selection.anchor, selection.head), to: Math.max(selection.anchor, selection.head) };
-}
-
-function whitespaceOf(text: string): string {
-    return /^[\t ]*/.exec(text)![0];
-}
-
-function isBlank(text: string): boolean {
-    return text.trim() === '';
-}
-
 /* How far the edits in front of an offset moved it. An edit that starts at the offset is not in front of it. */
 function shiftBefore(offset: number, edits: readonly TextEdit[]): number {
     return edits.filter((edit) => edit.from < offset).reduce((sum, edit) => sum + edit.text.length - (Math.min(edit.to, offset) - edit.from), 0);
@@ -137,7 +126,7 @@ export function planJoinLines(source: EditSource, selections: readonly Selection
                 !isBlank(source.slice(source.line(line).start, comment.start)) &&
                 !source.slice(nextStart, nextLine.end).startsWith(comment.marker.trimEnd()) &&
                 commentSyntax(options.language, source.region(line)).block?.open === '/*';
-            if (converts && comment) {
+            if (converts) {
                 const body = source.slice(comment.start + comment.marker.length, join.from);
                 if (!body.includes('*/')) {
                     edits.push({ from: comment.start, to: comment.start + comment.marker.length, text: '/*' });

package/src/line-text.ts

@@ -0,0 +1,22 @@
+import type { Selection } from './types.ts';
+
+/* The spaces and tabs a line starts with. */
+export function whitespaceOf(text: string): string {
+    return /^[\t ]*/.exec(text)![0];
+}
+
+export function isBlank(text: string): boolean {
+    return text.trim() === '';
+}
+
+/* Indentation `width` columns wide, in tabs as far as they reach when spaces are off. */
+export function indentText(width: number, options: { tabSize: number; insertSpaces: boolean }): string {
+    if (options.insertSpaces) {
+        return ' '.repeat(width);
+    }
+    return '\t'.repeat(Math.floor(width / options.tabSize)) + ' '.repeat(width % options.tabSize);
+}
+
+export function rangeOf(selection: Selection): { from: number; to: number } {
+    return { from: Math.min(selection.anchor, selection.head), to: Math.max(selection.anchor, selection.head) };
+}

package/src/markup-regions.ts

@@ -179,7 +179,7 @@ class JsxScanner {
     /* An element from its `<`, recorded when no element holds it, and the offset after its closing tag; -1 when it is not one. */
     private element(from: number, outermost: boolean): number {
         this.depth++;
-        const end = this.parse(from);
+        const end = this.parseElement(from);
         this.depth--;
         if (end >= 0 && outermost && this.depth === 0) {
             this.ranges.push({ from, to: end });
@@ -195,7 +195,7 @@ class JsxScanner {
         return at;
     }
 
-    private parse(from: number): number {
+    private parseElement(from: number): number {
         const { text } = this;
         let at = from + 1;
         while (at < text.length && NAME.test(text[at]!)) {
@@ -244,7 +244,7 @@ class JsxScanner {
             } else if (value === '{') {
                 at = this.code(at + 1, '}');
             } else if (value === '<' && START_OF_NAME.test(text[at + 1] ?? '')) {
-                at = this.parse(at);
+                at = this.parseElement(at);
             } else {
                 return -1;
             }
@@ -265,7 +265,7 @@ class JsxScanner {
                 const closing = /^<\/\s*([\w$.:-]*)\s*>/.exec(text.slice(at, at + 200));
                 return closing !== null && closing[1] === name ? at + closing[0].length : -1;
             } else if (START_OF_NAME.test(text[at + 1] ?? '')) {
-                at = this.parse(at);
+                at = this.parseElement(at);
             } else {
                 return -1;
             }
@@ -283,6 +283,24 @@ export function jsxRanges(text: string): { from: number; to: number }[] {
     return scanner.ranges;
 }
 
+/* Whether `offset` falls inside one of `ranges`, which are sorted and do not overlap. */
+function insideAny(ranges: readonly { from: number; to: number }[], offset: number): boolean {
+    let low = 0;
+    let high = ranges.length - 1;
+    while (low <= high) {
+        const middle = (low + high) >> 1;
+        const range = ranges[middle]!;
+        if (offset < range.from) {
+            high = middle - 1;
+        } else if (offset >= range.to) {
+            low = middle + 1;
+        } else {
+            return true;
+        }
+    }
+    return false;
+}
+
 /* Whether a language is one whose scripts can hold JSX. */
 export function hasJsx(language: string): boolean {
     return JSX_LANGUAGES.test(language);
@@ -313,20 +331,7 @@ export function markupGuard(source: EditSource, language: string): (line: number
         return (line) => {
             const bounds = source.line(line);
             const start = bounds.start + (/^[\t ]*/.exec(bounds.text)?.[0].length ?? 0);
-            let low = 0;
-            let high = ranges.length - 1;
-            while (low <= high) {
-                const middle = (low + high) >> 1;
-                const range = ranges[middle]!;
-                if (start < range.from) {
-                    high = middle - 1;
-                } else if (start >= range.to) {
-                    low = middle + 1;
-                } else {
-                    return true;
-                }
-            }
-            return false;
+            return insideAny(ranges, start);
         };
     }
     return () => false;

package/src/paste.ts

@@ -1,4 +1,5 @@
 import type { EditPlan, EditSource } from './edit-source.ts';
+import { indentText, isBlank, whitespaceOf } from './line-text.ts';
 import { mapOffset } from './offsets.ts';
 import { indentationColumn } from './structure.ts';
 import type { Selection, TextEdit } from './types.ts';
@@ -12,14 +13,6 @@ export interface PasteOptions {
     reindent: boolean;
 }
 
-function whitespaceOf(text: string): string {
-    return /^[\t ]*/.exec(text)![0];
-}
-
-function isBlank(text: string): boolean {
-    return text.trim() === '';
-}
-
 /* A line break at the end is the end of the last line, not a line of its own. */
 function linesOf(text: string): string[] {
     return text.replace(/\r?\n$/, '').split(/\r?\n/);
@@ -34,13 +27,6 @@ function perCaretLines(text: string, carets: number): string[] | null {
     return lines.length === carets ? lines : null;
 }
 
-function indentText(width: number, options: PasteOptions): string {
-    if (options.insertSpaces) {
-        return ' '.repeat(width);
-    }
-    return '\t'.repeat(Math.floor(width / options.tabSize)) + ' '.repeat(width % options.tabSize);
-}
-
 /*
  * Where a block of several lines lands, it lands at the indentation of the line it is pasted into:
  * the pasted lines move together by the difference between that indentation and the least indented

package/src/preserve-case.ts

@@ -22,41 +22,35 @@ export function replaceWithCaseRespect(replacement: string, found: string): stri
     if (foundTail === '') {
         return head + replacementTail;
     }
-    let replacementLower = true;
-    let replacementUpper = true;
-    for (const character of replacementTail) {
-        if (!letter.test(character)) {
-            continue;
-        }
-        replacementLower &&= lower.test(character);
-        replacementUpper &&= upper.test(character);
-        if (!replacementLower && !replacementUpper) {
-            break;
-        }
+    const replacementCase = letterCase(replacementTail);
+    const foundCase = letterCase(foundTail);
+    // A tail without letters, like `x2`, follows the first letter of the match.
+    const tailUpper = foundCase.hasLetters ? foundCase.upper : upper.test(firstFound!);
+    const tailLower = foundCase.hasLetters ? foundCase.lower : lower.test(firstFound!);
+    if (tailUpper && (replacementCase.lower || !replacementCase.upper)) {
+        return head + replacementTail.toUpperCase();
+    }
+    if (tailLower && (replacementCase.lower || replacementCase.upper)) {
+        return head + replacementTail.toLowerCase();
     }
-    let tailUpper = true;
-    let tailLower = true;
-    let tailChecked = false;
-    for (const character of foundTail) {
+    return head + replacementTail;
+}
+
+/* Whether every letter of `text` is upper case and whether every one is lower case; both hold without letters. */
+function letterCase(text: string): { upper: boolean; lower: boolean; hasLetters: boolean } {
+    let allUpper = true;
+    let allLower = true;
+    let hasLetters = false;
+    for (const character of text) {
         if (!letter.test(character)) {
             continue;
         }
-        tailUpper &&= upper.test(character);
-        tailLower &&= lower.test(character);
-        tailChecked = true;
-        if (!tailUpper && !tailLower) {
+        hasLetters = true;
+        allUpper &&= upper.test(character);
+        allLower &&= lower.test(character);
+        if (!allUpper && !allLower) {
             break;
         }
     }
-    if (!tailChecked) {
-        tailUpper = letter.test(firstFound!) && upper.test(firstFound!);
-        tailLower = letter.test(firstFound!) && lower.test(firstFound!);
-    }
-    if (tailUpper && (replacementLower || !replacementUpper)) {
-        return head + replacementTail.toUpperCase();
-    }
-    if (tailLower && (replacementLower || replacementUpper)) {
-        return head + replacementTail.toLowerCase();
-    }
-    return head + replacementTail;
+    return { upper: allUpper, lower: allLower, hasLetters };
 }

package/src/structure.ts

@@ -50,9 +50,8 @@ export interface FoldingRange {
 }
 
 export interface FoldingOptions {
-    /* On unless `false`. */
+    /* Both on unless `false`. */
     brackets?: boolean;
-    /* On unless `false`. */
     comments?: boolean;
     indentation?: boolean;
     /* The language id, which decides what an import line and a line comment look like. Without one only brackets, block comments and indentation fold. */
@@ -189,7 +188,7 @@ export function deriveFoldingRanges(
     options: FoldingOptions = {},
     slice?: (from: number, to: number) => string
 ): FoldingRange[] {
-    const minimum = options.minLines === undefined ? 1 : Math.max(1, Number.isFinite(options.minLines) ? Math.trunc(options.minLines) : 1);
+    const minimum = Number.isFinite(options.minLines) ? Math.max(1, Math.trunc(options.minLines!)) : 1;
     const result: FoldingRange[] = [];
     for (const range of ranges) {
         if (range.kind === 'string' || (range.kind === 'bracket' ? options.brackets === false : options.comments === false)) {

package/src/typing-context.ts

@@ -117,6 +117,12 @@ function scanLiteral(state: TypingContext, text: string, at: number, end: number
     return at;
 }
 
+function openComment(state: TypingContext, mode: 'line-comment' | 'block-comment' | 'html-comment', start: number, resume: number): number {
+    state.mode = mode;
+    state.commentStart = start;
+    return resume;
+}
+
 function scanCode(state: TypingContext, rules: Rules, text: string, at: number, end: number, offset: number): number {
     const char = text[at];
     const next = text[at + 1];
@@ -125,29 +131,16 @@ function scanCode(state: TypingContext, rules: Rules, text: string, at: number,
         return at;
     }
     if (rules.markup && text.startsWith('<!--', at)) {
-        state.mode = 'html-comment';
-        state.commentStart = offset + at;
-        return at + 3;
+        return openComment(state, 'html-comment', offset + at, at + 3);
     }
     if (rules.hash && char === '#' && !(rules.php && next === '[') && (!rules.hashAtWordStart || startsWord(text, at))) {
-        state.mode = 'line-comment';
-        state.commentStart = offset + at;
-        return at;
+        return openComment(state, 'line-comment', offset + at, 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.dash && char === '-' && next === '-') || (rules.slash && char === '/' && next === '/')) {
+        return openComment(state, 'line-comment', offset + at, at + 1);
     }
     if (rules.block && char === '/' && next === '*') {
-        state.mode = 'block-comment';
-        state.commentStart = offset + at;
-        return at + 1;
+        return openComment(state, 'block-comment', offset + at, at + 1);
     }
     if (rules.php && char === '<' && text.startsWith('<<<', at)) {
         const opener = PHP_HEREDOC.exec(text.slice(at));

package/src/words.ts

@@ -6,6 +6,8 @@
 // 7184b03af6c5370e79a01ded0df68cf56d7669da, platform/platform-impl/src/com/intellij/openapi/editor/actions/EditorActionUtil.java,
 // lines 934-982.
 
+import { splitsSurrogate } from './search.ts';
+
 // 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;
@@ -70,11 +72,8 @@ export function isWordBoundary(text: WordText, offset: number, camel: boolean, i
 export function wordBoundary(text: WordText, offset: number, direction: -1 | 1, camel = true): number {
     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)) {
+        const splitsLineBreak = text.charAt(position - 1) === '\r' && text.charAt(position) === '\n';
+        if (!splitsSurrogate(text, position) && !splitsLineBreak && isWordBoundary(text, position, camel, direction === -1)) {
             return position;
         }
         position += direction;