239 lines
7.6 KiB
TypeScript
239 lines
7.6 KiB
TypeScript
|
|
// === Char type ===
|
|
export type StringIndex = number; // UTF-16 index into string
|
|
export type CodePointIndex = number; // index into array of code-points
|
|
export type CodePoint = number; // could also name it `UnicodeCodePoint`. Basically for `s: string` we have `s.codePointAt(i: index): char`.
|
|
|
|
export function char(c: string): CodePoint {
|
|
return c.codePointAt(0) as CodePoint;
|
|
}
|
|
|
|
export type CodePointRef = {
|
|
char: CodePoint,
|
|
offset: StringIndex,
|
|
};
|
|
|
|
// === Source Text ===
|
|
export class SourceText {
|
|
readonly source: string;
|
|
// TODO: Later you can try to change this to two `Uint32Array`s - one for codepoints (each 20 bit but whatever), the other for pointers to original string.
|
|
readonly chars: CodePointRef[];
|
|
|
|
// Stores the CodePointIndex where each line begins
|
|
readonly lineStarts: CodePointIndex[];
|
|
|
|
constructor(rawSource: string) {
|
|
const source = rawSource.normalize('NFC');
|
|
|
|
this.source = source;
|
|
this.chars = [];
|
|
this.lineStarts = [0]; // Line 1 always starts at index 0
|
|
|
|
let i = 0;
|
|
while (i < source.length) {
|
|
const char = source.codePointAt(i) as CodePoint;
|
|
const cpIndex = this.chars.length;
|
|
this.chars.push({ char: char, offset: i });
|
|
|
|
const size =(char > 0xFFFF ? 2 : 1);
|
|
i += size;
|
|
|
|
// === Newline Logic ===
|
|
if (char === NEW_LINE) {
|
|
// Found a newline, the NEXT char starts a new line
|
|
this.lineStarts.push(cpIndex + 1);
|
|
}
|
|
// Handle CR (Classic Mac) or CRLF start
|
|
else if (char === CARRIAGE_RETURN) {
|
|
// Check if the next char is '\n' (CRLF)
|
|
// We peek ahead in the raw string to see if we need to skip the \n for line counting purposes
|
|
// or just treat this as a newline.
|
|
const nextIsNL = i < source.length && source.codePointAt(i) === NEW_LINE;
|
|
if (!nextIsNL) {
|
|
// Only push if it's NOT CRLF. If it is CRLF, the loop handles the \n next.
|
|
this.lineStarts.push(cpIndex + 1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
get length(): number {
|
|
return this.chars.length;
|
|
}
|
|
|
|
sliceByCp(start: number, end: number): string {
|
|
const startRef = this.chars[start];
|
|
// Handle out of bounds gracefully
|
|
if (!startRef) return "";
|
|
|
|
const startOff = startRef.offset;
|
|
const endOff = end < this.chars.length
|
|
? this.chars[end].offset
|
|
: this.source.length;
|
|
|
|
return this.source.slice(startOff, endOff);
|
|
}
|
|
|
|
// Converts a linear Code Point Index into SourceLocation
|
|
// getLocation(index: CodePointIndex): SourceLocation {
|
|
// // TODO: can be implemented either by a linear or binary search.
|
|
// return (0 as any);
|
|
// }
|
|
|
|
// Returns the full text of a specific line (1-based index)
|
|
getLineText(line: number): string {
|
|
const lineIndex = line - 1;
|
|
if (lineIndex < 0 || lineIndex >= this.lineStarts.length) return "";
|
|
|
|
const startCp = this.lineStarts[lineIndex];
|
|
const endCp = (lineIndex + 1 < this.lineStarts.length)
|
|
? this.lineStarts[lineIndex + 1] - 1 // -1 to exclude the newline char itself
|
|
: this.chars.length;
|
|
|
|
// TODO: Consider removing \r or \n from the end if they exist.
|
|
return this.sliceByCp(startCp, endCp);
|
|
}
|
|
|
|
getLineRange(line: number): { start: CodePointIndex, end: CodePointIndex } {
|
|
const lineIndex = line - 1;
|
|
if (lineIndex < 0 || lineIndex >= this.lineStarts.length) {
|
|
// TODO: This is a bit suspicious. Maybe return undefined?
|
|
return { start: 0, end: 0 };
|
|
}
|
|
|
|
const start = this.lineStarts[lineIndex];
|
|
const end = (lineIndex + 1 < this.lineStarts.length)
|
|
? this.lineStarts[lineIndex + 1]
|
|
: this.chars.length;
|
|
|
|
return { start, end };
|
|
}
|
|
}
|
|
|
|
export function sourceText(s: string): SourceText {
|
|
return new SourceText(s);
|
|
}
|
|
|
|
export type Span = {
|
|
start: SourceLocation;
|
|
end: SourceLocation;
|
|
}
|
|
|
|
export type SourceLocation = {
|
|
index: CodePointIndex;
|
|
line: number; // 1-based
|
|
column: number; // 1-based
|
|
}
|
|
|
|
// Whitespace
|
|
export const NEW_LINE: CodePoint = char('\n');
|
|
export const CARRIAGE_RETURN: CodePoint = char('\r');
|
|
export const SPACE: CodePoint = char(' ');
|
|
export const TAB: CodePoint = char('\t');
|
|
|
|
// Digit Boundaries
|
|
export const DIGIT_0: CodePoint = char('0');
|
|
export const DIGIT_9: CodePoint = char('9');
|
|
|
|
export const DOT: CodePoint = char('.');
|
|
|
|
// Hex Boundaries
|
|
export const LOWERCASE_a: CodePoint = char('a');
|
|
export const UPPERCASE_A: CodePoint = char('A');
|
|
export const LOWERCASE_f: CodePoint = char('f');
|
|
export const UPPERCASE_F: CodePoint = char('F');
|
|
|
|
// === Rendering Utilities ===
|
|
|
|
export type LineView = {
|
|
lineNo: number;
|
|
sourceLine: string; // The full raw text of the line
|
|
|
|
// These split the line into 3 parts for coloring:
|
|
// prefix | highlight | suffix
|
|
prefix: string;
|
|
highlight: string;
|
|
suffix: string;
|
|
|
|
// Helpers for underlines (e.g., " ^^^^^")
|
|
gutterPad: string; // Padding to align line numbers
|
|
underline: string; // The literal "^^^" string for CLI usage
|
|
};
|
|
|
|
export function renderSpan(text: SourceText, span: Span, contextLines = 1): LineView[] {
|
|
const views: LineView[] = [];
|
|
|
|
// Determine range of lines to show (including context)
|
|
const startLine = Math.max(1, span.start.line - contextLines);
|
|
const endLine = Math.min(text.lineStarts.length, span.end.line + contextLines);
|
|
|
|
// Calculate the max width of line numbers for nice padding (e.g. " 9 |" vs " 10 |")
|
|
const maxLineNoWidth = endLine.toString().length;
|
|
|
|
for (let lineNo = startLine; lineNo <= endLine; lineNo++) {
|
|
const lineRange = text.getLineRange(lineNo);
|
|
|
|
// We strip the trailing newline for display purposes
|
|
let lineRaw = text.sliceByCp(lineRange.start, lineRange.end);
|
|
if (lineRaw.endsWith('\n') || lineRaw.endsWith('\r')) {
|
|
lineRaw = lineRaw.trimEnd();
|
|
}
|
|
|
|
// Determine the intersection of the Span with this specific Line
|
|
|
|
// 1. Where does the highlight start on this line?
|
|
// If this is the start line, use span.column. Otherwise start at 0 (beginning of line)
|
|
// We subtract 1 because columns are 1-based, string indices are 0-based.
|
|
const highlightStartCol = (lineNo === span.start.line)
|
|
? span.start.column - 1
|
|
: 0;
|
|
|
|
// 2. Where does the highlight end on this line?
|
|
// If this is the end line, use span.column. Otherwise end at the string length.
|
|
const highlightEndCol = (lineNo === span.end.line)
|
|
? span.end.column - 1
|
|
: lineRaw.length;
|
|
|
|
// Logic to distinguish context lines from error lines
|
|
const isErrorLine = lineNo >= span.start.line && lineNo <= span.end.line;
|
|
|
|
let prefix = "", highlight = "", suffix = "";
|
|
|
|
if (isErrorLine) {
|
|
// Clamp indices to bounds (safety)
|
|
const safeStart = Math.max(0, Math.min(highlightStartCol, lineRaw.length));
|
|
const safeEnd = Math.max(0, Math.min(highlightEndCol, lineRaw.length));
|
|
|
|
prefix = lineRaw.substring(0, safeStart);
|
|
highlight = lineRaw.substring(safeStart, safeEnd);
|
|
suffix = lineRaw.substring(safeEnd);
|
|
} else {
|
|
// Pure context line
|
|
prefix = lineRaw;
|
|
}
|
|
|
|
// Build the "underline" string (e.g., " ^^^^")
|
|
// Note: This naive approach assumes monospaced fonts and no fancy unicode widths,
|
|
// which usually holds for code.
|
|
let underline = "";
|
|
if (isErrorLine) {
|
|
// Spaces for prefix
|
|
underline += " ".repeat(prefix.length);
|
|
// Carets for highlight (ensure at least 1 if it's a zero-width cursor position)
|
|
const hlLen = Math.max(1, highlight.length);
|
|
underline += "^".repeat(hlLen);
|
|
}
|
|
|
|
views.push({
|
|
lineNo,
|
|
sourceLine: lineRaw,
|
|
prefix,
|
|
highlight,
|
|
suffix,
|
|
gutterPad: " ".repeat(maxLineNoWidth - lineNo.toString().length),
|
|
underline
|
|
});
|
|
}
|
|
|
|
return views;
|
|
}
|