@adecore/editor-core 0.39.0 → 0.40.1

package/src/structure.ts

@@ -1,5 +1,6 @@
 import { bracketRole, commentRole } from './fold-roles.ts';
 import { openers } from './lexical.ts';
+import { whitespaceOf } from './line-text.ts';
 import type { DocumentLine } from './rope.ts';
 
 /* A bracket pair, string or block comment. `inner*` is the range without its delimiters. */
@@ -99,14 +100,17 @@ interface Header {
 /* Clamped to 1 through 16, with 4 for anything that is not a finite number. */
 export function tabWidth(options: { tabSize?: number }): number {
     const requested = options.tabSize ?? 4;
+
     return Number.isFinite(requested) ? Math.max(1, Math.min(16, Math.trunc(requested))) : 4;
 }
 
 export function indentationColumn(text: string, tabSize: number): number {
     let column = 0;
+
     for (const character of text) {
         column += character === '\t' ? tabSize - (column % tabSize) : 1;
     }
+
     return column;
 }
 
@@ -114,25 +118,31 @@ export function indentationColumn(text: string, tabSize: number): number {
 export function scanStructure(text: string): StructureRange[] {
     const result: StructureRange[] = [];
     const stack: { from: number; closer: string }[] = [];
+
     for (let offset = 0; offset < text.length; offset++) {
         const character = text[offset]!;
+
         if (character === '/' && text[offset + 1] === '/') {
             const end = text.indexOf('\n', offset + 2);
             offset = end === -1 ? text.length : end;
         } else if (character === '/' && text[offset + 1] === '*') {
             const end = text.indexOf('*/', offset + 2);
+
             if (end === -1) {
                 break;
             }
+
             result.push({ from: offset, to: end + 2, innerFrom: offset + 2, innerTo: end, kind: 'comment' });
             offset = end + 1;
         } else if (character === '"' || character === "'" || character === '`') {
             const start = offset;
+
             for (offset++; offset < text.length; offset++) {
                 if (text[offset] === '\\') {
                     offset++;
                 } else if (text[offset] === character) {
                     result.push({ from: start, to: offset + 1, innerFrom: start + 1, innerTo: offset, kind: 'string' });
+
                     break;
                 } else if (character !== '`' && (text[offset] === '\n' || text[offset] === '\r')) {
                     break;
@@ -145,6 +155,7 @@ export function scanStructure(text: string): StructureRange[] {
             result.push({ from: opener.from, to: offset + 1, innerFrom: opener.from + 1, innerTo: offset, kind: 'bracket' });
         }
     }
+
     return result.sort((left, right) => left.from - right.from || right.to - left.to);
 }
 
@@ -161,21 +172,28 @@ function indentationFolds(lineCount: number, getLine: (line: number) => Document
 
     for (let line = 0; line < lineCount; line++) {
         const text = getLine(line).text;
+
         if (!text.trim()) {
             continue;
         }
-        const indent = indentationColumn(text.match(/^[\t ]*/)?.[0] ?? '', tabSize);
+
+        const indent = indentationColumn(whitespaceOf(text), tabSize);
+
         while (headers.length > 0 && indent <= headers.at(-1)!.indent) {
             close(headers.pop()!, previous!.line);
         }
+
         if (previous && indent > previous.indent) {
             headers.push(previous);
         }
+
         previous = { line, indent };
     }
+
     while (headers.length > 0) {
         close(headers.pop()!, previous!.line);
     }
+
     return folds;
 }
 
@@ -190,12 +208,15 @@ export function deriveFoldingRanges(
 ): FoldingRange[] {
     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)) {
             continue;
         }
+
         const startLine = lineAt(range.from);
         const endLine = lineAt(range.to - 1);
+
         if (endLine - startLine >= minimum) {
             const role =
                 slice === undefined
@@ -203,29 +224,36 @@ export function deriveFoldingRanges(
                     : range.kind === 'comment'
                       ? commentRole(slice, range.from, range.to)
                       : bracketRole(slice, range.from, options.language ?? '');
+
             result.push({ from: range.from, to: range.to, startLine, endLine, kind: range.kind, ...(role === undefined ? {} : { role }) });
         }
     }
+
     if (options.indentation) {
         // One push per fold: a long file has more of them than V8 takes as arguments in one call.
         for (const fold of indentationFolds(lineCount, getLine, tabWidth(options), minimum)) {
             result.push(fold);
         }
     }
+
     result.sort((left, right) => left.startLine - right.startLine || right.endLine - left.endLine);
+
     return dedupeFoldingRanges(result);
 }
 
 /* Of ranges that span the same lines, sorted outermost first, the first stays and takes the role of a later one when it has none. */
 export function dedupeFoldingRanges(sorted: readonly FoldingRange[]): FoldingRange[] {
     const unique: FoldingRange[] = [];
+
     for (const range of sorted) {
         const last = unique.at(-1);
+
         if (last === undefined || range.startLine !== last.startLine || range.endLine !== last.endLine) {
             unique.push(range);
         } else if (last.role === undefined && range.role !== undefined) {
             last.role = range.role;
         }
     }
+
     return unique;
 }

package/src/text-span.ts

@@ -23,22 +23,29 @@ export function changedSpan(before: string, after: string): TextSpan | null {
     if (before === after) {
         return null;
     }
+
     const limit = Math.min(before.length, after.length);
     let start = 0;
+
     while (start < limit && before.charCodeAt(start) === after.charCodeAt(start)) {
         start += 1;
     }
+
     // Never between the halves of a surrogate pair, which would leave a lone half on either side.
     if (start > 0 && isHighSurrogate(before.charCodeAt(start - 1))) {
         start -= 1;
     }
+
     let tail = 0;
+
     while (tail < limit - start && before.charCodeAt(before.length - 1 - tail) === after.charCodeAt(after.length - 1 - tail)) {
         tail += 1;
     }
+
     if (tail > 0 && isLowSurrogate(before.charCodeAt(before.length - tail))) {
         tail -= 1;
     }
+
     return { start, end: before.length - tail, text: after.slice(start, after.length - tail) };
 }
 
@@ -59,13 +66,16 @@ interface LineHunk {
 function splitLines(text: string): string[] {
     const lines: string[] = [];
     let from = 0;
+
     for (let at = text.indexOf('\n'); at >= 0; at = text.indexOf('\n', from)) {
         lines.push(text.slice(from, at + 1));
         from = at + 1;
     }
+
     if (from < text.length) {
         lines.push(text.slice(from));
     }
+
     return lines;
 }
 
@@ -82,38 +92,50 @@ function diffLineHunks(before: Int32Array, after: Int32Array): LineHunk[] | null
     const trace: Int32Array[] = [];
     let work = 0;
     let found = -1;
+
     for (let edits = 0; edits <= maxEdits && found < 0; edits++) {
         trace.push(frontier.slice());
+
         for (let diagonal = -edits; diagonal <= edits; diagonal += 2) {
             let x: number;
+
             if (diagonal === -edits || (diagonal !== edits && frontier[base + diagonal - 1]! < frontier[base + diagonal + 1]!)) {
                 x = frontier[base + diagonal + 1]!;
             } else {
                 x = frontier[base + diagonal - 1]! + 1;
             }
+
             let y = x - diagonal;
+
             while (x < rows && y < columns && before[x] === after[y]) {
                 x++;
                 y++;
                 work++;
             }
+
             work++;
             frontier[base + diagonal] = x;
+
             if (x >= rows && y >= columns) {
                 found = edits;
+
                 break;
             }
         }
+
         if (work > DIFF_WORK_LIMIT) {
             return null;
         }
     }
+
     if (found < 0) {
         return null;
     }
+
     const operations: { kind: 'delete' | 'insert'; x: number; y: number }[] = [];
     let x = rows;
     let y = columns;
+
     for (let edits = found; edits > 0; edits--) {
         const previous = trace[edits]!;
         const diagonal = x - y;
@@ -121,10 +143,12 @@ function diffLineHunks(before: Int32Array, after: Int32Array): LineHunk[] | null
         const previousDiagonal = fromAbove ? diagonal + 1 : diagonal - 1;
         const previousX = previous[base + previousDiagonal]!;
         const previousY = previousX - previousDiagonal;
+
         while (x > previousX && y > previousY) {
             x--;
             y--;
         }
+
         if (fromAbove) {
             y--;
             operations.push({ kind: 'insert', x, y });
@@ -133,9 +157,11 @@ function diffLineHunks(before: Int32Array, after: Int32Array): LineHunk[] | null
             operations.push({ kind: 'delete', x, y });
         }
     }
+
     operations.reverse();
     const hunks: LineHunk[] = [];
     let open: { beforeFrom: number; afterFrom: number; beforeTo: number; afterTo: number } | null = null;
+
     for (const operation of operations) {
         if (open !== null && open.beforeTo === operation.x && open.afterTo === operation.y) {
             if (operation.kind === 'delete') {
@@ -143,11 +169,14 @@ function diffLineHunks(before: Int32Array, after: Int32Array): LineHunk[] | null
             } else {
                 open.afterTo++;
             }
+
             continue;
         }
+
         if (open !== null) {
             hunks.push(open);
         }
+
         open = {
             beforeFrom: operation.x,
             afterFrom: operation.y,
@@ -155,9 +184,11 @@ function diffLineHunks(before: Int32Array, after: Int32Array): LineHunk[] | null
             afterTo: operation.y + (operation.kind === 'insert' ? 1 : 0)
         };
     }
+
     if (open !== null) {
         hunks.push(open);
     }
+
     return hunks;
 }
 
@@ -169,62 +200,84 @@ function diffLineHunks(before: Int32Array, after: Int32Array): LineHunk[] | null
  */
 export function changedSpans(before: string, after: string): TextSpan[] {
     const outer = changedSpan(before, after);
+
     if (outer === null) {
         return [];
     }
+
     const afterEnd = after.length - (before.length - outer.end);
+
     if (outer.end - outer.start + (afterEnd - outer.start) > DIFF_TEXT_LIMIT) {
         return [outer];
     }
+
     // Whole lines on both sides of the change, so the diff compares lines and not their halves.
     const lineStart = outer.start === 0 ? 0 : before.lastIndexOf('\n', outer.start - 1) + 1;
+
     const lineEnd = (at: string, from: number): number => {
         const newline = at.indexOf('\n', from);
+
         return newline < 0 ? at.length : newline + 1;
     };
+
     const beforeEnd = lineEnd(before, outer.end > outer.start ? outer.end - 1 : outer.end);
     const afterLineEnd = beforeEnd - outer.end + afterEnd;
     const beforeLines = splitLines(before.slice(lineStart, beforeEnd));
     const afterLines = splitLines(after.slice(lineStart, afterLineEnd));
+
     if (beforeLines.length < 2 && afterLines.length < 2) {
         return [outer];
     }
+
     const ids = new Map<string, number>();
+
     const intern = (lines: string[]): Int32Array => {
         const result = new Int32Array(lines.length);
+
         for (let i = 0; i < lines.length; i++) {
             const line = lines[i]!;
             let id = ids.get(line);
+
             if (id === undefined) {
                 id = ids.size;
                 ids.set(line, id);
             }
+
             result[i] = id;
         }
+
         return result;
     };
+
     const hunks = diffLineHunks(intern(beforeLines), intern(afterLines));
+
     if (hunks === null || hunks.length === 0) {
         return [outer];
     }
+
     const beforeOffsets = lineOffsets(beforeLines, lineStart);
     const afterOffsets = lineOffsets(afterLines, lineStart);
     const spans: TextSpan[] = [];
+
     for (const hunk of hunks) {
         const beforeFrom = beforeOffsets[hunk.beforeFrom]!;
         const afterFrom = afterOffsets[hunk.afterFrom]!;
         const inner = changedSpan(before.slice(beforeFrom, beforeOffsets[hunk.beforeTo]), after.slice(afterFrom, afterOffsets[hunk.afterTo]));
+
         if (inner !== null) {
             spans.push({ start: beforeFrom + inner.start, end: beforeFrom + inner.end, text: inner.text });
         }
     }
+
     return spans;
 }
 
 function lineOffsets(lines: readonly string[], base: number): number[] {
     const offsets = [base];
+
     for (const line of lines) {
         offsets.push(offsets[offsets.length - 1]! + line.length);
     }
+
     return offsets;
 }