@adecore/editor-core 0.39.0 → 0.40.1

package/src/comments.ts

@@ -31,6 +31,7 @@ interface Geometry {
 
 function syntaxOf(regions: EditRegions, options: CommentOptions, line: number, offset?: number): CommentSyntax {
     const syntax = commentSyntax(options.language, regions(line, offset));
+
     return options.lineToken === undefined ? syntax : { ...syntax, line: options.lineToken };
 }
 
@@ -38,17 +39,22 @@ function syntaxOf(regions: EditRegions, options: CommentOptions, line: number, o
 function blocksOf(source: EditSource, selections: readonly Selection[], span?: CommentOptions['lineSpan']): Block[] {
     const blocks: Block[] = [];
     const ordered = selections.map((selection, index) => ({ ...rangeOf(selection), index })).sort((left, right) => left.from - right.from);
+
     for (const { from, to, index } of ordered) {
         let first = source.lineAt(from);
         let last = source.lineAt(to);
+
         if (last > first && source.line(last).start === to) {
             last--;
         }
+
         if (span) {
             first = span(first).first;
             last = Math.max(last, span(last).last);
         }
+
         const previous = blocks.at(-1);
+
         if (previous && first <= previous.last + 1) {
             previous.last = Math.max(previous.last, last);
             previous.carets.push(index);
@@ -56,18 +62,23 @@ function blocksOf(source: EditSource, selections: readonly Selection[], span?: C
             blocks.push({ first, last, carets: [index] });
         }
     }
+
     return blocks;
 }
 
 function isCommented(text: string, syntax: CommentSyntax, multiline: boolean): boolean {
     const trimmed = text.trim();
+
     if (syntax.line !== null) {
         return trimmed.startsWith(syntax.line.trimEnd());
     }
+
     const block = syntax.block!;
+
     if (trimmed === '') {
         return multiline;
     }
+
     return trimmed.length >= block.open.length + block.close.length && trimmed.startsWith(block.open) && trimmed.endsWith(block.close);
 }
 
@@ -75,14 +86,17 @@ function isCommented(text: string, syntax: CommentSyntax, multiline: boolean): b
 function geometryOf(source: EditSource, edits: readonly TextEdit[], index: number): Geometry {
     const bounds = source.line(index);
     const result = { start: bounds.start, length: bounds.end - bounds.start };
+
     for (const edit of edits) {
         const delta = edit.text.length - (edit.to - edit.from);
+
         if (edit.from < bounds.start) {
             result.start += delta;
         } else if (edit.to <= bounds.end) {
             result.length += delta;
         }
     }
+
     return result;
 }
 
@@ -94,21 +108,26 @@ export function planLineComments(source: EditSource, selections: readonly Select
     const regions = editRegions(source, options.language);
     const blocks = blocksOf(source, selections, options.lineSpan);
     const lineBased = new Map<number, CommentSyntax>();
+
     for (const block of blocks) {
         let marker: CommentSyntax | undefined;
         let mixed = false;
         const firstSyntax = hasJsx(options.language) && block.first !== block.last ? syntaxOf(regions, options, block.first) : undefined;
+
         for (let line = block.first; line <= block.last; line++) {
             const syntax = firstSyntax ?? syntaxOf(regions, options, line);
             const effective = syntax.line === null ? syntax : { ...syntax, block: null };
             lineBased.set(line, effective);
+
             if (effective.line !== null || effective.block !== null) {
                 mixed ||=
                     marker !== undefined &&
                     (marker.line !== effective.line || marker.block?.open !== effective.block?.open || marker.block?.close !== effective.block?.close);
+
                 marker ??= effective;
             }
         }
+
         // Commenting a region opener would change the markers needed for the next toggle.
         if (mixed && /^(php|vue)$/i.test(options.language)) {
             for (let line = block.first; line <= block.last; line++) {
@@ -116,24 +135,32 @@ export function planLineComments(source: EditSource, selections: readonly Select
             }
         }
     }
+
     let allCommented = true;
     let anyCommented = false;
+
     for (const block of blocks) {
         const single = block.first === block.last;
+
         for (let line = block.first; line <= block.last; line++) {
             const text = source.line(line).text;
             const syntax = lineBased.get(line)!;
+
             if (syntax.line === null && syntax.block === null) {
                 continue;
             }
+
             const commented = isCommented(text, syntax, !single);
+
             if (commented && !isBlank(text)) {
                 anyCommented = true;
             }
+
             if (!commented && (single || !isBlank(text))) {
                 allCommented = false;
             }
         }
+
         if (allCommented && !single && !anyCommented) {
             allCommented = false;
         }
@@ -141,59 +168,75 @@ export function planLineComments(source: EditSource, selections: readonly Select
 
     const edits: TextEdit[] = [];
     const placed = new Set<number>();
+
     for (const block of blocks) {
         const syntax = lineBased.get(block.first)!;
         const multiline = block.first !== block.last;
+
         const startingNewLine =
             !multiline &&
             block.carets.length === 1 &&
             isBlank(source.line(block.first).text) &&
             selections[block.carets[0]!]!.anchor === selections[block.carets[0]!]!.head;
+
         const minimum = allCommented ? 0 : minimumIndent(source, block, syntax, options);
+
         for (let line = block.first; line <= block.last; line++) {
             const bounds = source.line(line);
             const syntax = lineBased.get(line)!;
+
             if (syntax.line === null && syntax.block === null) {
                 continue;
             }
+
             const edit = allCommented
                 ? uncommentLine(bounds.start, bounds.text, syntax)
                 : commentLine(bounds.start, bounds.text, syntax, minimum, multiline, startingNewLine, options);
+
             if (edit) {
                 edits.push(edit);
+
                 if (startingNewLine && !allCommented) {
                     placed.add(line);
                 }
             }
         }
     }
+
     if (edits.length === 0) {
         return null;
     }
+
     return { edits, selections: finalSelections(source, selections, blocks, edits, allCommented, placed, lineBased, options.lineSpan) };
 }
 
 /* The indentation of the least indented non-blank line, infinite when every line is blank. */
 function smallestIndent(source: EditSource, first: number, last: number, tabSize: number): number {
     let minimum = Number.POSITIVE_INFINITY;
+
     for (let line = first; line <= last; line++) {
         const text = source.line(line).text;
+
         if (!isBlank(text)) {
             minimum = Math.min(minimum, indentationColumn(whitespaceOf(text), tabSize));
         }
     }
+
     return minimum;
 }
 
 function minimumIndent(source: EditSource, block: Block, syntax: CommentSyntax, options: CommentOptions): number {
     let minimum = smallestIndent(source, block.first, block.last, options.tabSize);
+
     if (block.first > 0) {
         const previous = source.line(block.first - 1).text;
         const marker = syntax.line ?? syntax.block?.open;
+
         if (marker && previous.trimStart().startsWith(marker)) {
             minimum = Math.min(minimum, indentationColumn(whitespaceOf(previous), options.tabSize));
         }
     }
+
     return Number.isFinite(minimum) ? minimum : 0;
 }
 
@@ -207,57 +250,75 @@ function commentLine(
     options: CommentOptions
 ): TextEdit | null {
     const blank = isBlank(text);
+
     if (syntax.line === null && blank && multiline) {
         return null;
     }
+
     const leading = whitespaceOf(text);
     let kept = 0;
     let width = 0;
+
     while (kept < leading.length && width < minimum) {
         width += leading[kept] === '\t' ? options.tabSize - (width % options.tabSize) : 1;
         kept++;
     }
+
     // A line whose whitespace ends before the indent does is padded out to it.
     const short = width < minimum;
     const padding = short ? indentText(minimum, options) : '';
     const markerAt = start + (short ? leading.length : kept);
+
     if (syntax.line !== null) {
         const space = !blank || startingNewLine ? ' ' : '';
+
         return { from: short ? start : markerAt, to: markerAt, text: padding + syntax.line + space };
     }
+
     const { open, close } = syntax.block!;
     const end = start + text.trimEnd().length;
     const body = blank ? '' : text.slice(markerAt - start, end - start);
+
     return { from: short ? start : markerAt, to: blank ? start + text.length : end, text: padding + open + (blank ? '  ' : ` ${body} `) + close };
 }
 
 function uncommentLine(start: number, text: string, syntax: CommentSyntax): TextEdit | null {
     const trimmed = text.trim();
+
     if (trimmed === '') {
         return null;
     }
+
     const leading = whitespaceOf(text);
     let rest: string;
+
     if (syntax.line !== null) {
         const marker = syntax.line.trimEnd();
+
         if (!trimmed.startsWith(marker)) {
             return null;
         }
+
         const body = text.slice(leading.length + marker.length);
         rest = body.startsWith(' ') ? body.slice(1) : body;
     } else {
         const { open, close } = syntax.block!;
+
         if (!trimmed.startsWith(open) || !trimmed.endsWith(close)) {
             return null;
         }
+
         const inner = text.trimEnd().slice(leading.length + open.length, -close.length);
         rest = (inner.startsWith(' ') ? inner.slice(1) : inner).replace(/ $/, '');
         rest += text.slice(text.trimEnd().length);
     }
+
     const kept = leading + rest;
+
     if (kept.trim() === '') {
         return { from: start, to: start + text.length, text: '' };
     }
+
     return { from: start + leading.length, to: start + text.length, text: rest };
 }
 
@@ -272,36 +333,48 @@ function finalSelections(
     span: CommentOptions['lineSpan']
 ): Selection[] {
     const sorted = [...edits].sort((left, right) => left.from - right.from);
+
     const result = selections.map((selection) => ({
         anchor: mapOffset(selection.anchor, sorted, true),
         head: mapOffset(selection.head, sorted, true)
     }));
+
     const moveCarets = blocks.every((block) => block.carets.length === 1 || block.first === block.last);
+
     if (!moveCarets) {
         return result;
     }
+
     for (const block of blocks) {
         for (const index of block.carets) {
             const selection = selections[index]!;
             const { from, to } = rangeOf(selection);
             const line = source.lineAt(from);
+
             if (from === to) {
                 const syntax = syntaxes.get(line)!;
+
                 if (syntax.line === null && syntax.block === null) {
                     continue;
                 }
+
                 result[index] = caretAfter(source, sorted, line, span?.(line).last ?? line, selection.head, allCommented, placed, syntax);
+
                 continue;
             }
+
             const lastLine = source.lineAt(to - 1);
             const whole = source.line(line).start === from && source.line(lastLine).next === to;
+
             if (whole) {
                 const start = geometryOf(source, sorted, line).start;
+
                 result[index] =
                     selection.anchor <= selection.head ? { anchor: start, head: result[index]!.head } : { anchor: result[index]!.anchor, head: start };
             }
         }
     }
+
     return result;
 }
 
@@ -316,30 +389,41 @@ function caretAfter(
     syntax: CommentSyntax
 ): Selection {
     const geometry = geometryOf(source, edits, line);
+
     if (placed.has(line) && !allCommented) {
         const caret = syntax.line === null ? geometry.start + geometry.length - syntax.block!.close.length - 1 : geometry.start + geometry.length;
+
         return { anchor: caret, head: caret };
     }
+
     const mapped = mapOffset(offset, edits);
+
     if (lastLine >= source.lineCount - 1) {
         return { anchor: mapped, head: mapped };
     }
+
     const next = geometryOf(source, edits, lastLine + 1);
     const column = Math.min(mapped - geometry.start, next.length);
+
     return { anchor: next.start + column, head: next.start + column };
 }
 
 /* Where the comment that holds `offset` runs, for the markers the lexer knows. Null outside a comment. */
 function commentAround(source: EditSource, offset: number, block: BlockComment): { from: number; to: number } | null {
     const context = source.context(offset);
+
     if ((context.mode !== 'block-comment' && context.mode !== 'html-comment') || context.commentStart === undefined) {
         return null;
     }
+
     const from = block.open === '{/*' && source.charAt(context.commentStart - 1) === '{' ? context.commentStart - 1 : context.commentStart;
+
     if (source.slice(from, from + block.open.length) !== block.open) {
         return null;
     }
+
     const close = source.slice(from + block.open.length, from + block.open.length + 200_000).indexOf(block.close);
+
     return close < 0 ? null : { from, to: from + block.open.length + close + block.close.length };
 }
 
@@ -349,9 +433,11 @@ function commentOf(source: EditSource, from: number, to: number, block: BlockCom
     const start = text.length - text.trimStart().length;
     const end = text.trimEnd().length;
     const body = text.slice(start, end);
+
     if (body.length >= block.open.length + block.close.length && body.startsWith(block.open) && body.endsWith(block.close)) {
         return { from: from + start, to: from + end };
     }
+
     return null;
 }
 
@@ -364,8 +450,10 @@ export function planBlockComment(source: EditSource, selections: readonly Select
     const edits: TextEdit[] = [];
     const result: Selection[] = [];
     let offsetDelta = 0;
+
     for (const selection of selections) {
         const { from, to } = rangeOf(selection);
+
         if (/^php$/i.test(options.language)) {
             const context = source.context(from);
             const { mode } = context;
@@ -373,6 +461,7 @@ export function planBlockComment(source: EditSource, selections: readonly Select
             const endMode = endContext.mode;
             const endsLineComment = mode === 'code' && endMode === 'line-comment' && source.slice(to, source.line(source.lineAt(to)).end).trim() === '';
             const text = source.slice(from, to);
+
             // Wrapping a PHP tag can move a closing marker into a different language.
             if (
                 phpLiteralAt(source, from) ||
@@ -387,14 +476,19 @@ export function planBlockComment(source: EditSource, selections: readonly Select
                 return null;
             }
         }
+
         const block = syntaxOf(regions, options, source.lineAt(from), from).block;
+
         if (!block) {
             return null;
         }
+
         const found = commentOf(source, from, to, block) ?? commentAround(source, from, block);
+
         if (found && from !== to && !(found.from >= from && found.to <= to)) {
             return null;
         }
+
         if (found) {
             const innerStart = found.from + block.open.length + (source.charAt(found.from + block.open.length) === ' ' ? 1 : 0);
             const closeAt = found.to - block.close.length;
@@ -405,25 +499,31 @@ export function planBlockComment(source: EditSource, selections: readonly Select
             const removedBefore = innerStart - found.from;
             result.push({ anchor: anchor - removedBefore + offsetDelta, head: head - removedBefore + offsetDelta });
             offsetDelta -= innerStart - found.from + (found.to - innerEnd);
+
             continue;
         }
+
         if (source.slice(from, to).includes(block.close)) {
             return null;
         }
+
         if (from === to) {
             const text = `${block.open}  ${block.close}`;
             edits.push({ from, to, text });
             const caret = from + offsetDelta + block.open.length + 1;
             result.push({ anchor: caret, head: caret });
             offsetDelta += text.length;
+
             continue;
         }
+
         const wrapped = wrapRange(source, from, to, block, options);
         edits.push(...wrapped);
         const added = wrapped.reduce((sum, edit) => sum + edit.text.length, 0);
         result.push({ anchor: from + offsetDelta, head: to + added + offsetDelta });
         offsetDelta += added;
     }
+
     return { edits, selections: result };
 }
 
@@ -431,16 +531,19 @@ function wrapRange(source: EditSource, from: number, to: number, block: BlockCom
     const first = source.lineAt(from);
     const last = source.lineAt(to - 1);
     const endsLine = source.charAt(to - 1) === '\n' || to === source.line(source.lineCount - 1).end;
+
     if (from !== source.line(first).start || !endsLine) {
         return [
             { from, to: from, text: `${block.open} ` },
             { from: to, to, text: ` ${block.close}` }
         ];
     }
+
     const minimum = smallestIndent(source, first, last, options.tabSize);
     const space = indentText(Number.isFinite(minimum) ? minimum : 0, options);
     const newline = source.newline(first);
     const closing = source.charAt(to - 1) === '\n' ? `${space}${block.close}${newline}` : `${newline}${space}${block.close}`;
+
     return [
         { from, to: from, text: `${space}${block.open}${newline}` },
         { from: to, to, text: closing }

package/src/doc-comments.ts

@@ -23,12 +23,15 @@ function bodyOf(inner: string): string {
     const lines = inner.split(/\r\n|\r|\n/).map((line, index) => (index === 0 ? line.replace(/^[ \t]+/, '') : line.replace(/^[ \t]*\*?[ \t]?/, '')));
     const last = lines.length - 1;
     lines[last] = lines[last]!.replace(/[ \t*]+$/, '');
+
     while (lines.length > 0 && lines[0]!.trim() === '') {
         lines.shift();
     }
+
     while (lines.length > 0 && lines.at(-1)!.trim() === '') {
         lines.pop();
     }
+
     return lines.map((line) => line.replace(/[ \t]+$/, '')).join('\n');
 }
 
@@ -37,12 +40,14 @@ const HEREDOC_OPENER = /<<<[ \t]*(?:'(\w+)'|"(\w+)"|(\w+))\r?\n/g;
 /* The bodies of PHP heredocs and nowdocs, which the structure scan reads as code. Offsets of the first character after the opener and of the closing label. */
 function heredocBodies(text: string): [number, number][] {
     const result: [number, number][] = [];
+
     for (const opener of text.matchAll(HEREDOC_OPENER)) {
         const label = opener[1] ?? opener[2] ?? opener[3]!;
         const from = opener.index + opener[0].length;
         const closer = new RegExp(`^[ \\t]*${label}\\b`, 'm').exec(text.slice(from));
         result.push([from, closer === null ? text.length : from + closer.index]);
     }
+
     return result;
 }
 
@@ -57,48 +62,61 @@ function heredocBodies(text: string): [number, number][] {
 export function findDocComments(text: string, language: string, limit = MAX_DOC_COMMENTS): DocComment[] {
     const vue = language.toLowerCase() === 'vue';
     const syntax = commentSyntax(language, vue ? 'script' : null);
+
     if (syntax.block?.open !== '/*' || syntax.line !== '//' || !text.includes('/**')) {
         return [];
     }
+
     const result: DocComment[] = [];
     const bodies = language.toLowerCase() === 'php' && text.includes('<<<') ? heredocBodies(text) : [];
     const lines = vue ? text.split(/\r\n|\r|\n/) : null;
     let counted = 0;
     let line = 0;
+
     for (const range of scanStructure(text)) {
         if (result.length >= limit) {
             break;
         }
+
         if (range.kind !== 'comment' || commentRole((from, to) => text.slice(from, to), range.from, range.to) === undefined) {
             continue;
         }
-        // Three stars or more is a banner, not a comment about the code under it.
+
         if (text[range.from + 3] === '*' || bodies.some(([from, to]) => range.from >= from && range.from < to)) {
             continue;
         }
+
         const lineStart = Math.max(text.lastIndexOf('\n', range.from - 1), text.lastIndexOf('\r', range.from - 1)) + 1;
         const newline = text.slice(range.to).search(/[\r\n]/);
         const lineEnd = newline === -1 ? text.length : range.to + newline;
         const before = text.slice(lineStart, range.from);
+
         if (!/^[ \t]*$/.test(before) || !/^[ \t]*$/.test(text.slice(range.to, lineEnd))) {
             continue;
         }
+
         for (; counted < range.from; counted++) {
             if (text[counted] === '\n' || (text[counted] === '\r' && text[counted + 1] !== '\n')) {
                 line++;
             }
         }
+
         const startLine = line;
+
         if (lines !== null && vueRegionAt((index) => lines[index] ?? '', startLine) !== 'script') {
             continue;
         }
+
         let endLine = startLine;
+
         for (let at = range.from; at < range.to; at++) {
             if (text[at] === '\n' || (text[at] === '\r' && text[at + 1] !== '\n')) {
                 endLine++;
             }
         }
+
         result.push({ from: range.from, to: range.to, startLine, endLine, indent: before, body: bodyOf(text.slice(range.innerFrom + 1, range.innerTo)) });
     }
+
     return result;
 }