@adecore/editor 0.39.0 → 0.40.1

package/src/attribution.ts

@@ -50,21 +50,27 @@ export class AttributionRuns {
     /* Marks name lines one-based and inclusive; `lineBounds` answers for the document as it is now. */
     set(marks: readonly (EditorLineHighlight & { id: string })[], lineCount: number, lineBounds: (line: number) => { start: number; end: number }): void {
         const clamp = (line: number): number => Math.min(lineCount, Math.max(1, Math.trunc(line) || 1)) - 1;
+
         this.runs = marks.map((mark) => {
             const start = clamp(mark.startLine);
             const end = Math.max(start, clamp(mark.endLine));
+
             const emphasis = (mark.emphasis ?? []).slice(0, end - start + 1).flatMap((ranges, index) => {
                 const bounds = lineBounds(start + index);
                 const length = bounds.end - bounds.start;
+
                 return ranges.flatMap(([from, to]) => {
                     if (!Number.isFinite(from) || !Number.isFinite(to)) {
                         return [];
                     }
+
                     const first = Math.min(length, Math.max(0, Math.trunc(from)));
                     const last = Math.min(length, Math.max(0, Math.trunc(to)));
+
                     return last > first ? [{ from: bounds.start + first, to: bounds.start + last }] : [];
                 });
             });
+
             return {
                 id: mark.id,
                 color: mark.color,
@@ -93,29 +99,37 @@ export class AttributionRuns {
     /* The run on each line from `first` to `last`, zero-based, where `from` and `to` are the offsets they span; where runs overlap the one set last wins. */
     linesIn(first: number, last: number, from: number, to: number, lineOf: (offset: number) => number): Map<number, AttributedLines> {
         const lines = new Map<number, AttributedLines>();
+
         for (const run of this.runs) {
             if (run.to < from || run.from > to) {
                 continue;
             }
+
             const value = { id: run.id, color: run.color, sign: run.sign, fill: run.fill, bar: run.bar };
             const emphasis = new Map<number, { from: number; to: number }[]>();
+
             for (const range of run.emphasis) {
                 if (range.to <= from || range.from > to) {
                     continue;
                 }
+
                 const endLine = Math.min(lineOf(range.to - 1), last);
+
                 for (let line = Math.max(lineOf(range.from), first); line <= endLine; line++) {
                     const ranges = emphasis.get(line) ?? [];
                     ranges.push(range);
                     emphasis.set(line, ranges);
                 }
             }
+
             const end = Math.min(Math.max(lineOf(run.from), lineOf(run.to)), last);
+
             for (let line = Math.max(lineOf(run.from), first); line <= end; line++) {
                 const ranges = emphasis.get(line);
                 lines.set(line, ranges === undefined ? value : { ...value, emphasis: ranges });
             }
         }
+
         return lines;
     }
 }

package/src/code-block.ts

@@ -19,86 +19,111 @@ export function renderCodeBlock(
     block.className = 'se-code-block';
     block.style.tabSize = String(tabSize);
     const lines = text.split(/\r?\n/);
+
     lines.forEach((line, index) => {
         const row = document.createElement('div');
         row.className = 'se-code-row';
+
         if (options.color !== undefined) {
             row.style.background = tintValue(options.color);
         }
+
         const gutter = codeGutter(document, options, index);
         const code = document.createElement('div');
         code.className = 'se-code-text';
+
         if (options.faded) {
             code.dataset.faded = 'true';
         }
+
         const emphasis = options.emphasis?.[index] ?? [];
+
         if (emphasis.length > 0 && options.color !== undefined) {
             row.style.setProperty('--se-emphasis', colorValue(options.color));
         }
+
         fill(code, line, tokens?.[index] ?? null, emphasis);
         row.append(gutter, code);
         block.append(row);
     });
+
     container.append(block);
 }
 
 function codeGutter(document: Document, options: EditorCodeBlockOptions, index: number): HTMLElement {
     const gutter = document.createElement('div');
     gutter.className = 'se-code-gutter';
+
     if (options.firstLine !== undefined) {
         const number = document.createElement('span');
         number.textContent = String(options.firstLine + index);
         gutter.append(number);
     }
+
     if (options.sign) {
         const sign = document.createElement('span');
         sign.className = 'se-line-sign';
         sign.textContent = options.sign;
+
         if (options.color !== undefined) {
             sign.style.color = colorValue(options.color);
         }
+
         gutter.append(sign);
     }
+
     if (options.color !== undefined) {
         const bar = document.createElement('span');
         bar.className = 'se-attribution';
         bar.style.background = colorValue(options.color);
         gutter.append(bar);
     }
+
     return gutter;
 }
 
 function fill(element: HTMLElement, line: string, tokens: readonly LineToken[] | null, emphasis: ReadonlyArray<readonly [number, number]>): void {
     if (tokens === null && emphasis.length === 0) {
         element.textContent = line;
+
         return;
     }
+
     const spans: Array<{ start: number; end: number; token: LineToken | null }> = [];
     let start = 0;
+
     for (const token of tokens ?? []) {
         const end = Math.min(line.length, start + token.length);
+
         if (end > start) {
             spans.push({ start, end, token });
         }
+
         start = end;
     }
+
     if (start < line.length) {
         spans.push({ start, end: line.length, token: null });
     }
+
     for (const { start: from, end: to, token } of spans) {
         // A token is cut at the edges of every emphasis that crosses it, so each piece is one color and either on or off.
         const cuts = [...new Set([from, to, ...emphasis.flatMap((range) => range).filter((cut) => cut > from && cut < to)])].sort(
             (left, right) => left - right
         );
+
         for (let i = 0; i < cuts.length - 1; i++) {
             const piece = element.ownerDocument.createElement('span');
             piece.textContent = line.slice(cuts[i]!, cuts[i + 1]!);
+
             if (token !== null) {
                 styleSpan(piece, token);
             }
+
             if (emphasis.some(([emphasisStart, emphasisEnd]) => emphasisStart <= cuts[i]! && cuts[i + 1]! <= emphasisEnd)) {
                 piece.className = 'se-code-emphasis';
             }
+
             element.append(piece);
         }
     }

package/src/column-selection.ts

@@ -28,35 +28,45 @@ export function columnSelections(layout: EditorLayout, from: ContentPoint, to: C
     const right = Math.max(fromCell, toCell);
     const reversed = toCell < fromCell;
     const result: Selection[] = [];
+
     for (let line = Math.min(fromLine, toLine); line <= Math.max(fromLine, toLine); line++) {
         const row = layout.rowForLine(line);
+
         if (row.kind !== 'text' || layout.isHidden(line)) {
             continue;
         }
+
         const geometry = layout.geometry(row);
         const endX = geometry.rowStarts.length > 1 ? geometry.rowEnds[0]! : xOfStop(geometry, stopCount(geometry) - 1);
+
         const offsetAt = (cell: number): number => layout.offsetAtX(geometry, 0, TEXT_PADDING + cell * charWidth).offset;
+
         if (cellAt(layout, endX + TEXT_PADDING) < left) {
             if (left === right) {
                 const end = document.getLine(line).end;
                 result.push({ anchor: end, head: end });
             }
+
             continue;
         }
+
         const start = offsetAt(left);
         const end = offsetAt(right);
         result.push(reversed ? { anchor: end, head: start } : { anchor: start, head: end });
     }
+
     if (result.length === 0) {
         const end = document.getLine(toLine).end;
         result.push({ anchor: end, head: end });
     }
+
     return result;
 }
 
 /* Whether two points are in the same cell of the same line, which makes a press with alt a click and not yet a box. */
 export function sameCell(layout: EditorLayout, from: ContentPoint, to: ContentPoint): boolean {
     const document = layout.document;
+
     return (
         cellAt(layout, from.x) === cellAt(layout, to.x) &&
         document.positionAt(layout.hitTest(from.x, from.y)).line === document.positionAt(layout.hitTest(to.x, to.y)).line