lognal 0.1.0

package/dist/core/text/ansi.js

@@ -0,0 +1,187 @@
+const ESCAPE = '\x1b';
+const BELL = '\x07';
+/**
+ * Turns text with ANSI escape codes into styled parts.
+ *
+ * Select Graphic Rendition codes (colors, bold, italic, underline and so on) become styles.
+ * Every other escape sequence, such as cursor movement or an OSC hyperlink wrapper, is removed
+ * so it cannot show up as stray characters. The style carries over between calls, the way a
+ * terminal keeps it from one line to the next.
+ */
+export class AnsiParser {
+    style = {};
+    /** Parses one piece of text, usually a line. */
+    parse(text) {
+        if (!text.includes(ESCAPE)) {
+            return [this.createPart(text)];
+        }
+        const parts = [];
+        let buffer = '';
+        let index = 0;
+        const flush = () => {
+            if (buffer) {
+                parts.push(this.createPart(buffer));
+                buffer = '';
+            }
+        };
+        while (index < text.length) {
+            const character = text[index];
+            if (character !== ESCAPE) {
+                buffer += character;
+                index++;
+                continue;
+            }
+            const next = text[index + 1];
+            if (next === '[') {
+                const end = findCsiEnd(text, index + 2);
+                if (end < 0) {
+                    break;
+                }
+                if (text[end] === 'm') {
+                    flush();
+                    this.applySgr(text.slice(index + 2, end));
+                }
+                index = end + 1;
+            }
+            else if (next === ']') {
+                index = findOscEnd(text, index + 2);
+            }
+            else {
+                // A two-character escape such as `ESC c`, or a lone escape at the end.
+                index += next === undefined ? 1 : 2;
+            }
+        }
+        flush();
+        return parts.length ? parts : [this.createPart('')];
+    }
+    /** Forgets the current style. */
+    reset() {
+        this.style = {};
+    }
+    createPart(text) {
+        const part = { type: 'text', text };
+        if (Object.keys(this.style).length > 0) {
+            part.style = { ...this.style };
+        }
+        return part;
+    }
+    applySgr(sequence) {
+        const codes = sequence === '' ? [0] : sequence.split(/[;:]/).map((code) => Number(code) || 0);
+        const style = { ...this.style };
+        for (let index = 0; index < codes.length; index++) {
+            const code = codes[index];
+            if (code === 0) {
+                for (const key of Object.keys(style)) {
+                    delete style[key];
+                }
+            }
+            else if (code === 1) {
+                style.bold = true;
+            }
+            else if (code === 2) {
+                style.dim = true;
+            }
+            else if (code === 3) {
+                style.italic = true;
+            }
+            else if (code === 4) {
+                style.underline = true;
+            }
+            else if (code === 9) {
+                style.strikethrough = true;
+            }
+            else if (code === 22) {
+                delete style.bold;
+                delete style.dim;
+            }
+            else if (code === 23) {
+                delete style.italic;
+            }
+            else if (code === 24) {
+                delete style.underline;
+            }
+            else if (code === 29) {
+                delete style.strikethrough;
+            }
+            else if (code >= 30 && code <= 37) {
+                style.color = code - 30;
+            }
+            else if (code >= 90 && code <= 97) {
+                style.color = code - 90 + 8;
+            }
+            else if (code >= 40 && code <= 47) {
+                style.background = code - 40;
+            }
+            else if (code >= 100 && code <= 107) {
+                style.background = code - 100 + 8;
+            }
+            else if (code === 39) {
+                delete style.color;
+            }
+            else if (code === 49) {
+                delete style.background;
+            }
+            else if (code === 38 || code === 48) {
+                const [color, used] = readExtendedColor(codes, index + 1);
+                if (color !== undefined) {
+                    if (code === 38) {
+                        style.color = color;
+                    }
+                    else {
+                        style.background = color;
+                    }
+                }
+                index += used;
+            }
+        }
+        this.style = style;
+    }
+}
+/** Reads a `5;n` or `2;r;g;b` color after code 38 or 48. Returns the color and codes consumed. */
+const readExtendedColor = (codes, start) => {
+    const mode = codes[start];
+    if (mode === 5) {
+        const index = codes[start + 1];
+        return [index >= 0 && index <= 255 ? index : undefined, 2];
+    }
+    if (mode === 2) {
+        const [red, green, blue] = codes.slice(start + 1, start + 4).map((value) => clampByte(value));
+        return [`#${toHex(red)}${toHex(green)}${toHex(blue)}`, 4];
+    }
+    return [undefined, 0];
+};
+const clampByte = (value) => {
+    return Math.min(255, Math.max(0, value ?? 0));
+};
+const toHex = (value) => {
+    return value.toString(16).padStart(2, '0');
+};
+/** Returns the index of the final byte of a CSI sequence, or -1 if the text ends first. */
+const findCsiEnd = (text, start) => {
+    for (let index = start; index < text.length; index++) {
+        const code = text.charCodeAt(index);
+        if (code >= 0x40 && code <= 0x7e) {
+            return index;
+        }
+    }
+    return -1;
+};
+/** Returns the index just after an OSC sequence, which ends with BEL or `ESC \`. */
+const findOscEnd = (text, start) => {
+    for (let index = start; index < text.length; index++) {
+        if (text[index] === BELL) {
+            return index + 1;
+        }
+        if (text[index] === ESCAPE && text[index + 1] === '\\') {
+            return index + 2;
+        }
+    }
+    return text.length;
+};
+/** Removes every ANSI escape sequence from text. */
+export const stripAnsi = (text) => {
+    return new AnsiParser()
+        .parse(text)
+        .map((part) => part.text)
+        .join('');
+};

package/dist/core/text/graphemes.d.ts

@@ -0,0 +1,17 @@
+/** Splits text into user-perceived characters (grapheme clusters). */
+export type GraphemeSplitter = (text: string) => string[];
+/**
+ * A grapheme splitter that needs no platform support.
+ *
+ * It joins combining marks, variation selectors, emoji modifiers, zero width joiner sequences
+ * and regional indicator pairs to the character before them. That covers the cases a log line
+ * meets in practice; `Intl.Segmenter` is used instead wherever it exists.
+ */
+export declare const splitGraphemesFallback: GraphemeSplitter;
+/**
+ * Replaces the grapheme splitter used by the text layout. Pass `null` to go back to the
+ * default, which uses `Intl.Segmenter` when the platform has it.
+ */
+export declare const setGraphemeSplitter: (splitter: GraphemeSplitter | null) => void;
+/** Splits text into grapheme clusters with the active splitter. */
+export declare const splitGraphemes: (text: string) => string[];

package/dist/core/text/graphemes.js

@@ -0,0 +1,70 @@
+import { codePointWidth } from './width.js';
+const ZERO_WIDTH_JOINER = 0x200d;
+const REGIONAL_INDICATOR_FIRST = 0x1f1e6;
+const REGIONAL_INDICATOR_LAST = 0x1f1ff;
+const isRegionalIndicator = (codePoint) => {
+    return codePoint >= REGIONAL_INDICATOR_FIRST && codePoint <= REGIONAL_INDICATOR_LAST;
+};
+const isEmojiModifier = (codePoint) => {
+    return codePoint >= 0x1f3fb && codePoint <= 0x1f3ff;
+};
+/**
+ * A grapheme splitter that needs no platform support.
+ *
+ * It joins combining marks, variation selectors, emoji modifiers, zero width joiner sequences
+ * and regional indicator pairs to the character before them. That covers the cases a log line
+ * meets in practice; `Intl.Segmenter` is used instead wherever it exists.
+ */
+export const splitGraphemesFallback = (text) => {
+    const clusters = [];
+    let joinNext = false;
+    let regionalCount = 0;
+    for (const character of text) {
+        const codePoint = character.codePointAt(0) ?? 0;
+        const last = clusters.length - 1;
+        const attaches = last >= 0 &&
+            (joinNext ||
+                codePointWidth(codePoint) === 0 ||
+                isEmojiModifier(codePoint) ||
+                (isRegionalIndicator(codePoint) && regionalCount % 2 === 1));
+        if (attaches) {
+            clusters[last] += character;
+        }
+        else {
+            clusters.push(character);
+        }
+        regionalCount = isRegionalIndicator(codePoint) ? regionalCount + 1 : 0;
+        joinNext = codePoint === ZERO_WIDTH_JOINER;
+    }
+    return clusters;
+};
+let activeSplitter = null;
+const createDefaultSplitter = () => {
+    const intl = globalThis
+        .Intl;
+    if (intl?.Segmenter) {
+        const segmenter = new intl.Segmenter(undefined, { granularity: 'grapheme' });
+        return (text) => {
+            const clusters = [];
+            for (const { segment } of segmenter.segment(text)) {
+                clusters.push(segment);
+            }
+            return clusters;
+        };
+    }
+    return splitGraphemesFallback;
+};
+/**
+ * Replaces the grapheme splitter used by the text layout. Pass `null` to go back to the
+ * default, which uses `Intl.Segmenter` when the platform has it.
+ */
+export const setGraphemeSplitter = (splitter) => {
+    activeSplitter = splitter;
+};
+/** Splits text into grapheme clusters with the active splitter. */
+export const splitGraphemes = (text) => {
+    if (!activeSplitter) {
+        activeSplitter = createDefaultSplitter();
+    }
+    return activeSplitter(text);
+};

package/dist/core/text/line-splitter.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Splits a stream of text chunks into lines.
+ *
+ * A line ends at `\n`, `\r\n` or a lone `\r`. A `\r\n` pair split across two chunks still
+ * counts as one line break.
+ */
+export declare class LineSplitter {
+    private pending;
+    private skipLineFeed;
+    /** Adds a chunk and returns the lines it completed. */
+    push(chunk: string): string[];
+    /** Returns the unfinished last line, if any, and resets the splitter. */
+    flush(): string[];
+    /** Whether text is waiting for a line break. */
+    get hasPending(): boolean;
+}
+/** Splits a whole string into lines. A trailing line break does not add an empty line. */
+export declare const splitLines: (text: string) => string[];

package/dist/core/text/line-splitter.js

@@ -0,0 +1,56 @@
+/**
+ * Splits a stream of text chunks into lines.
+ *
+ * A line ends at `\n`, `\r\n` or a lone `\r`. A `\r\n` pair split across two chunks still
+ * counts as one line break.
+ */
+export class LineSplitter {
+    pending = '';
+    skipLineFeed = false;
+    /** Adds a chunk and returns the lines it completed. */
+    push(chunk) {
+        const lines = [];
+        let start = 0;
+        let index = 0;
+        if (this.skipLineFeed && chunk.charCodeAt(0) === 0x0a) {
+            start = 1;
+            index = 1;
+        }
+        this.skipLineFeed = false;
+        for (; index < chunk.length; index++) {
+            const code = chunk.charCodeAt(index);
+            if (code !== 0x0a && code !== 0x0d) {
+                continue;
+            }
+            lines.push(this.pending + chunk.slice(start, index));
+            this.pending = '';
+            if (code === 0x0d) {
+                if (index + 1 === chunk.length) {
+                    this.skipLineFeed = true;
+                }
+                else if (chunk.charCodeAt(index + 1) === 0x0a) {
+                    index++;
+                }
+            }
+            start = index + 1;
+        }
+        this.pending += chunk.slice(start);
+        return lines;
+    }
+    /** Returns the unfinished last line, if any, and resets the splitter. */
+    flush() {
+        const rest = this.pending;
+        this.pending = '';
+        this.skipLineFeed = false;
+        return rest ? [rest] : [];
+    }
+    /** Whether text is waiting for a line break. */
+    get hasPending() {
+        return this.pending.length > 0;
+    }
+}
+/** Splits a whole string into lines. A trailing line break does not add an empty line. */
+export const splitLines = (text) => {
+    const splitter = new LineSplitter();
+    return [...splitter.push(text), ...splitter.flush()];
+};

package/dist/core/text/measure.d.ts

@@ -0,0 +1,10 @@
+import { type AmbiguousWidth } from './width.js';
+/** Returns how many cells a string takes on one row. */
+export declare const measureCells: (text: string, ambiguousWidth?: AmbiguousWidth) => number;
+/**
+ * Cuts a string to at most `maxCells` cells, ending it with `…` when anything was cut.
+ * A wide character that would cross the limit is left out rather than split.
+ */
+export declare const truncateCells: (text: string, maxCells: number, ambiguousWidth?: AmbiguousWidth) => string;
+/** Pads a string with spaces on the right to `cells` cells. */
+export declare const padCells: (text: string, cells: number, ambiguousWidth?: AmbiguousWidth) => string;

package/dist/core/text/measure.js

@@ -0,0 +1,38 @@
+import { splitGraphemes } from './graphemes.js';
+import { clusterWidth } from './width.js';
+const PRINTABLE_ASCII = /^[\x20-\x7e]*$/;
+/** Returns how many cells a string takes on one row. */
+export const measureCells = (text, ambiguousWidth = 1) => {
+    if (PRINTABLE_ASCII.test(text)) {
+        return text.length;
+    }
+    let cells = 0;
+    for (const cluster of splitGraphemes(text)) {
+        cells += clusterWidth(cluster, ambiguousWidth);
+    }
+    return cells;
+};
+/**
+ * Cuts a string to at most `maxCells` cells, ending it with `…` when anything was cut.
+ * A wide character that would cross the limit is left out rather than split.
+ */
+export const truncateCells = (text, maxCells, ambiguousWidth = 1) => {
+    if (measureCells(text, ambiguousWidth) <= maxCells) {
+        return text;
+    }
+    let result = '';
+    let cells = 0;
+    for (const cluster of splitGraphemes(text)) {
+        const width = clusterWidth(cluster, ambiguousWidth);
+        if (cells + width > maxCells - 1) {
+            break;
+        }
+        result += cluster;
+        cells += width;
+    }
+    return `${result}…`;
+};
+/** Pads a string with spaces on the right to `cells` cells. */
+export const padCells = (text, cells, ambiguousWidth = 1) => {
+    return text + ' '.repeat(Math.max(0, cells - measureCells(text, ambiguousWidth)));
+};

package/dist/core/text/shape.d.ts

@@ -0,0 +1,24 @@
+import { type LineSpan, type ShapedLine } from '../layout/types.js';
+import { type AmbiguousWidth } from './width.js';
+export interface ShapeOptions {
+    /** Cells between tab stops. */
+    tabSize: number;
+    /** Cells an East Asian Ambiguous character takes. */
+    ambiguousWidth: AmbiguousWidth;
+    /** The most clusters a line keeps. The rest is replaced with `…`. */
+    maxClusters: number;
+}
+export declare const DEFAULT_SHAPE_OPTIONS: ShapeOptions;
+/**
+ * Splits the spans of a logical line into clusters and measures them.
+ *
+ * Tabs become spaces up to the next tab stop, and control and bidirectional formatting
+ * characters are replaced with a visible notation in the muted style.
+ */
+export declare const shapeLine: (spans: readonly LineSpan[], indent: number, options?: ShapeOptions) => ShapedLine;
+/** Returns the width of a cluster of a shaped line. */
+export declare const widthAt: (line: ShapedLine, index: number) => number;
+/** Returns the break class of a cluster of a shaped line. */
+export declare const breakAt: (line: ShapedLine, index: number) => number;
+/** Returns the text of the clusters from `start` to `end`. */
+export declare const textBetween: (line: ShapedLine, start: number, end: number) => string;

package/dist/core/text/shape.js

@@ -0,0 +1,220 @@
+import { BREAK_KEEP, BREAK_NORMAL, BREAK_SPACE, BREAK_WIDE } from '../layout/types.js';
+import { splitGraphemes } from './graphemes.js';
+import { clusterWidth, isHangul } from './width.js';
+export const DEFAULT_SHAPE_OPTIONS = {
+    tabSize: 8,
+    ambiguousWidth: 1,
+    maxClusters: 10000
+};
+const PRINTABLE_ASCII = /^[\x20-\x7e]*$/;
+const SPECIAL_CHARACTER = /[\x00-\x1f\x7f-\x9f\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069]/;
+const ELLIPSIS = '…';
+/**
+ * Returns the visible notation for a character that must not be drawn as is: a control
+ * character, which would be invisible or move the cursor, or a bidirectional formatting
+ * character, which can make a line read differently from what it contains.
+ */
+const notationOf = (code) => {
+    if (code < 0x20) {
+        return `^${String.fromCharCode(code + 0x40)}`;
+    }
+    if (code === 0x7f) {
+        return '^?';
+    }
+    return `<U+${code.toString(16).toUpperCase().padStart(4, '0')}>`;
+};
+class LineBuilder {
+    options;
+    spans = [];
+    spanStarts = [];
+    clusters = [];
+    widths = [];
+    breaks = [];
+    cells = 0;
+    simple = true;
+    full = false;
+    constructor(options) {
+        this.options = options;
+    }
+    openSpan(span) {
+        this.spans.push(span);
+        this.spanStarts.push(this.clusters.length);
+    }
+    addCluster(cluster, width, breakClass) {
+        if (this.clusters.length >= this.options.maxClusters) {
+            this.full = true;
+            return;
+        }
+        this.clusters.push(cluster);
+        this.widths.push(width);
+        this.breaks.push(breakClass);
+        this.cells += width;
+    }
+    /** Drops clusters past `count`, and spans that no longer have a cluster. */
+    truncate(count) {
+        this.clusters.length = count;
+        this.widths.length = count;
+        this.breaks.length = count;
+        this.cells = this.widths.reduce((sum, width) => sum + width, 0);
+        this.full = false;
+        while (this.spanStarts.length > 0 && this.spanStarts[this.spanStarts.length - 1] >= count) {
+            this.spanStarts.pop();
+            this.spans.pop();
+        }
+    }
+    addText(source, text) {
+        if (!text || this.full) {
+            return;
+        }
+        this.openSpan({ ...source, text });
+        if (PRINTABLE_ASCII.test(text)) {
+            for (let index = 0; index < text.length && !this.full; index++) {
+                const character = text[index];
+                this.addCluster(character, 1, character === ' ' ? BREAK_SPACE : BREAK_NORMAL);
+            }
+            return;
+        }
+        this.simple = false;
+        for (const cluster of splitGraphemes(text)) {
+            if (this.full) {
+                return;
+            }
+            const width = clusterWidth(cluster, this.options.ambiguousWidth);
+            let breakClass = BREAK_NORMAL;
+            if (cluster === ' ') {
+                breakClass = BREAK_SPACE;
+            }
+            else if (width === 2) {
+                breakClass = isHangul(cluster.codePointAt(0) ?? 0) ? BREAK_KEEP : BREAK_WIDE;
+            }
+            this.addCluster(cluster, width, breakClass);
+        }
+    }
+    addSpan(span) {
+        if ('icon' in span) {
+            this.openSpan({ text: '', icon: span.icon, expanded: span.expanded, action: span.action });
+            this.simple = false;
+            this.addCluster('', 2, BREAK_NORMAL);
+            return;
+        }
+        const source = {
+            text: '',
+            token: span.token,
+            style: span.style,
+            action: span.action
+        };
+        const { text } = span;
+        if (!SPECIAL_CHARACTER.test(text)) {
+            this.addText(source, text);
+            return;
+        }
+        let start = 0;
+        for (let index = 0; index < text.length; index++) {
+            if (!SPECIAL_CHARACTER.test(text[index])) {
+                continue;
+            }
+            const code = text.charCodeAt(index);
+            this.addText(source, text.slice(start, index));
+            start = index + 1;
+            if (code === 0x09) {
+                const size = this.options.tabSize;
+                this.addText(source, ' '.repeat(size - (this.cells % size)));
+            }
+            else {
+                this.addText({ ...source, token: 'muted', style: undefined }, notationOf(code));
+            }
+        }
+        this.addText(source, text.slice(start));
+    }
+}
+/** Builds a simple line without splitting it, for the common case of one ASCII span. */
+const shapeSimple = (span, indent) => {
+    return {
+        indent,
+        spans: [span],
+        spanStarts: Uint32Array.of(0),
+        simple: true,
+        text: span.text,
+        clusters: null,
+        widths: null,
+        breaks: null,
+        length: span.text.length,
+        cells: span.text.length,
+        wrap: true
+    };
+};
+/**
+ * Splits the spans of a logical line into clusters and measures them.
+ *
+ * Tabs become spaces up to the next tab stop, and control and bidirectional formatting
+ * characters are replaced with a visible notation in the muted style.
+ */
+export const shapeLine = (spans, indent, options = DEFAULT_SHAPE_OPTIONS) => {
+    if (spans.length === 1) {
+        const [span] = spans;
+        if (!('icon' in span) &&
+            span.text.length <= options.maxClusters &&
+            PRINTABLE_ASCII.test(span.text)) {
+            return shapeSimple({ text: span.text, token: span.token, style: span.style, action: span.action }, indent);
+        }
+    }
+    const builder = new LineBuilder(options);
+    for (const span of spans) {
+        if (builder.full) {
+            break;
+        }
+        builder.addSpan(span);
+    }
+    if (builder.full) {
+        builder.truncate(Math.max(0, builder.clusters.length - 2));
+        builder.openSpan({ text: ` ${ELLIPSIS}`, token: 'muted' });
+        builder.addCluster(' ', 1, BREAK_SPACE);
+        builder.addCluster(ELLIPSIS, 1, BREAK_NORMAL);
+        builder.simple = false;
+    }
+    const text = builder.clusters.join('');
+    const spanStarts = Uint32Array.from(builder.spanStarts);
+    if (builder.simple) {
+        return {
+            indent,
+            spans: builder.spans,
+            spanStarts,
+            simple: true,
+            text,
+            clusters: null,
+            widths: null,
+            breaks: null,
+            length: builder.clusters.length,
+            cells: builder.cells,
+            wrap: true
+        };
+    }
+    return {
+        indent,
+        spans: builder.spans,
+        spanStarts,
+        simple: false,
+        text,
+        clusters: builder.clusters,
+        widths: Uint8Array.from(builder.widths),
+        breaks: Uint8Array.from(builder.breaks),
+        length: builder.clusters.length,
+        cells: builder.cells,
+        wrap: true
+    };
+};
+/** Returns the width of a cluster of a shaped line. */
+export const widthAt = (line, index) => {
+    return line.widths ? line.widths[index] : 1;
+};
+/** Returns the break class of a cluster of a shaped line. */
+export const breakAt = (line, index) => {
+    if (line.breaks) {
+        return line.breaks[index];
+    }
+    return line.text.charCodeAt(index) === 0x20 ? BREAK_SPACE : BREAK_NORMAL;
+};
+/** Returns the text of the clusters from `start` to `end`. */
+export const textBetween = (line, start, end) => {
+    return line.clusters ? line.clusters.slice(start, end).join('') : line.text.slice(start, end);
+};