@loomcli/core 0.2.0 → 0.4.0

package/dist/style-layout.d.ts

@@ -0,0 +1,29 @@
+import type { TextUnit, Unit } from './style-ansi.js';
+/** Width at each tab-stop offset composes without rescanning nested text. */
+interface Metrics {
+    advance: readonly number[];
+    tabs: boolean;
+    text: boolean;
+}
+type Rope = ({
+    kind: 'leaf';
+    unit: TextUnit;
+    tab: boolean;
+} | {
+    kind: 'join';
+    children: readonly Rope[];
+}) & Metrics;
+interface Line {
+    content: Rope;
+    ending: readonly TextUnit[];
+}
+interface Block {
+    lines: readonly Line[];
+    minimum: number;
+    tabs: boolean;
+}
+/** Nested padding resolves inside outward; unchanged content retains its rope and analysis. */
+declare function layout(units: readonly Unit[]): Block;
+declare function renderedUnits(block: Block): Generator<TextUnit>;
+declare function blockWidth(block: Block): number;
+export { blockWidth, layout, renderedUnits };

package/dist/style-layout.js

@@ -0,0 +1,228 @@
+import { graphemeWidths } from '@rockorager/uucode/width';
+const offsets = [0, 1, 2, 3, 4, 5, 6, 7];
+const empty = {
+    advance: offsets.map(() => 0),
+    children: [],
+    kind: 'join',
+    tabs: false,
+    text: false,
+};
+function leaf(unit, width, tab = false) {
+    return {
+        advance: offsets.map((offset) => (tab ? 8 - offset : width)),
+        kind: 'leaf',
+        tab,
+        tabs: tab,
+        text: unit.kind === 'text' && unit.text.length > 0,
+        unit,
+    };
+}
+function join(children) {
+    children = children.filter((child) => child !== empty);
+    if (children.length === 0) {
+        return empty;
+    }
+    if (children.length === 1 && children[0]) {
+        return children[0];
+    }
+    const advance = offsets.map((offset) => children.reduce((column, child) => column + (child.advance[column % 8] ?? 0), offset) -
+        offset);
+    return {
+        advance,
+        children,
+        kind: 'join',
+        tabs: children.some((child) => child.tabs),
+        text: children.some((child) => child.text),
+    };
+}
+function* leaves(root) {
+    const stack = [{ index: 0, node: root }];
+    while (stack.length > 0) {
+        const frame = stack.at(-1);
+        if (!frame) {
+            break;
+        }
+        if (frame.node.kind === 'leaf') {
+            yield frame.node;
+            stack.pop();
+            continue;
+        }
+        const child = frame.node.children[frame.index];
+        if (child === undefined) {
+            stack.pop();
+            continue;
+        }
+        frame.index += 1;
+        stack.push({ index: 0, node: child });
+    }
+}
+/** Grapheme segmentation ignores attribute boundaries and terminal-control envelopes. */
+function textBlock(units) {
+    const visible = units
+        .filter((unit) => unit.kind === 'text')
+        .map((unit) => unit.text)
+        .join('');
+    const widths = new Map();
+    for (const segment of graphemeWidths(visible)) {
+        widths.set(segment.start, segment.width);
+    }
+    const lines = [];
+    let parts = [];
+    let offset = 0;
+    for (const unit of units) {
+        if (unit.kind !== 'text') {
+            parts.push(leaf(unit, 0));
+            continue;
+        }
+        if (unit.text === '\n' || unit.text === '\r\n') {
+            lines.push({ content: join(parts), ending: [unit] });
+            parts = [];
+        }
+        else {
+            let width = 0;
+            for (let at = offset; at < offset + unit.text.length; at += 1) {
+                width += widths.get(at) ?? 0;
+            }
+            parts.push(leaf(unit, width, unit.text === '\t'));
+        }
+        offset += unit.text.length;
+    }
+    lines.push({ content: join(parts), ending: [] });
+    return measured(lines);
+}
+function measured(lines) {
+    let minimum = Infinity;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (line && !(index > 0 && index === lines.length - 1 && !line.content.text)) {
+            minimum = Math.min(minimum, line.content.advance[0] ?? 0);
+        }
+    }
+    return { lines, minimum, tabs: lines.some((line) => line.content.tabs) };
+}
+function expandTabs(root) {
+    if (!root.tabs) {
+        return root;
+    }
+    const parts = [];
+    let column = 0;
+    for (const part of leaves(root)) {
+        const width = part.advance[column % 8] ?? 0;
+        parts.push(part.tab ? leaf({ ...part.unit, text: ' '.repeat(width) }, width) : part);
+        column += width;
+    }
+    return join(parts);
+}
+function padBlock(block, padding, attributes) {
+    if (!block.tabs && block.minimum >= padding.width) {
+        return block;
+    }
+    const lines = block.lines.map((line, index) => {
+        // A terminal newline has no extra line to align; interior blank lines do.
+        if (index > 0 && index === block.lines.length - 1 && !line.content.text) {
+            return line;
+        }
+        const content = expandTabs(line.content);
+        const missing = Math.max(0, padding.width - (content.advance[0] ?? 0));
+        if (missing === 0) {
+            return content === line.content ? line : { ...line, content };
+        }
+        let before = 0;
+        if (padding.align === 'right') {
+            before = missing;
+        }
+        else if (padding.align === 'center') {
+            before = Math.floor(missing / 2);
+        }
+        const space = (count) => leaf({ attributes, kind: 'text', text: ' '.repeat(count) }, count);
+        // Re-segment inserted spaces too: a trailing Unicode Prepend character can absorb one.
+        const spaced = join([space(before), content, space(missing - before)]);
+        const row = measured([{ content: spaced, ending: [] }]);
+        let padded = textBlock([...renderedUnits(row)]);
+        const shortfall = padding.width - padded.minimum;
+        if (shortfall > 0) {
+            padded = textBlock([
+                ...renderedUnits(padded),
+                { attributes, kind: 'text', text: ' '.repeat(shortfall) },
+            ]);
+        }
+        return { ...line, content: padded.lines[0]?.content ?? empty };
+    });
+    return measured(lines);
+}
+function textRope(parts) {
+    if (parts.length === 1 && parts[0] && 'parts' in parts[0]) {
+        return parts[0];
+    }
+    return {
+        parts,
+        tabs: parts.some((part) => 'parts' in part ? part.tabs : part.kind === 'text' && part.text.includes('\t')),
+    };
+}
+function* textUnits(root) {
+    const stack = [{ index: 0, rope: root }];
+    while (stack.length > 0) {
+        const frame = stack.at(-1);
+        if (!frame) {
+            break;
+        }
+        // Analysis is owned by the composed root; old subtree snapshots need not stay live.
+        if (frame.rope !== root) {
+            delete frame.rope.analysis;
+        }
+        const part = frame.rope.parts[frame.index++];
+        if (!part) {
+            stack.pop();
+        }
+        else if ('parts' in part) {
+            stack.push({ index: 0, rope: part });
+        }
+        else {
+            yield part;
+        }
+    }
+}
+function analyze(rope) {
+    rope.analysis ??= textBlock([...textUnits(rope)]);
+    return rope.analysis;
+}
+/** Nested padding resolves inside outward; unchanged content retains its rope and analysis. */
+function layout(units) {
+    let current = { padding: undefined, parts: [] };
+    const stack = [];
+    for (const unit of units) {
+        if (unit.kind === 'open') {
+            stack.push(current);
+            current = { padding: { attributes: unit.attributes, value: unit.padding }, parts: [] };
+        }
+        else if (unit.kind === 'close') {
+            let rope = textRope(current.parts);
+            const padding = current.padding;
+            if (padding && (padding.value.width > 0 || rope.tabs)) {
+                const original = analyze(rope);
+                const padded = padBlock(original, padding.value, padding.attributes);
+                if (padded !== original) {
+                    rope = { analysis: padded, parts: [...renderedUnits(padded)], tabs: false };
+                }
+            }
+            current = stack.pop() ?? { padding: undefined, parts: [] };
+            current.parts.push(rope);
+        }
+        else {
+            current.parts.push(unit);
+        }
+    }
+    return analyze(textRope(current.parts));
+}
+function* renderedUnits(block) {
+    for (const line of block.lines) {
+        for (const part of leaves(line.content)) {
+            yield part.unit;
+        }
+        yield* line.ending;
+    }
+}
+function blockWidth(block) {
+    return block.lines.reduce((widest, line) => Math.max(widest, line.content.advance[0] ?? 0), 0);
+}
+export { blockWidth, layout, renderedUnits };

package/dist/style-resolve.d.ts

@@ -0,0 +1,6 @@
+import type { Capabilities } from './rendering.js';
+import type { Palette } from './style-state.js';
+/** A complete string is one state boundary; no terminal attributes survive the call. */
+declare function resolveText(text: string, palette: Palette, caps: Capabilities): string;
+declare function width(text: string, palette: Palette, caps: Capabilities): number;
+export { resolveText, width };

package/dist/style-resolve.js

@@ -0,0 +1,26 @@
+import { scanAnsi } from './style-ansi.js';
+import { blockWidth, layout, renderedUnits } from './style-layout.js';
+import { emptyAttributes, transition } from './style-state.js';
+import { parseText } from './style-wire.js';
+/** A complete string is one state boundary; no terminal attributes survive the call. */
+function resolveText(text, palette, caps) {
+    const parsed = parseText(text, palette, caps.mainGlyphs);
+    const result = [];
+    let previous = emptyAttributes;
+    let preservedSgr = false;
+    for (const unit of renderedUnits(layout(scanAnsi(parsed, caps)))) {
+        preservedSgr ||= unit.kind === 'sgr';
+        result.push(transition(previous, unit.attributes, caps), unit.text);
+        previous = unit.attributes;
+    }
+    result.push(transition(previous, emptyAttributes, caps));
+    if (preservedSgr) {
+        result.push('\u001b[0m');
+    }
+    return result.join('');
+}
+function width(text, palette, caps) {
+    const parsed = parseText(text, palette, caps.mainGlyphs);
+    return blockWidth(layout(scanAnsi(parsed, caps)));
+}
+export { resolveText, width };

package/dist/style-state.d.ts

@@ -0,0 +1,14 @@
+import type { Capabilities } from './rendering.js';
+import type { Color, Modifier, Operation } from './style.js';
+interface Attributes {
+    foreground: Color | undefined;
+    background: Color | undefined;
+    modifiers: ReadonlySet<Modifier>;
+}
+type Palette = ReadonlyMap<string, readonly Operation[]>;
+declare const emptyAttributes: Attributes;
+declare function applyOperations(base: Attributes, operations: readonly Operation[], palette: Palette): Attributes;
+/** Diffs effective attributes, including the shared reset for bold and faint. */
+declare function transition(previous: Attributes, next: Attributes, caps: Capabilities): string;
+export type { Attributes, Palette };
+export { applyOperations, emptyAttributes, transition };

package/dist/style-state.js

@@ -0,0 +1,179 @@
+import { colors } from './style.js';
+const emptyAttributes = {
+    background: undefined,
+    foreground: undefined,
+    modifiers: new Set(),
+};
+function applyOperations(base, operations, palette) {
+    let foreground = base.foreground;
+    let background = base.background;
+    let active = new Set(base.modifiers);
+    const expanded = operations.flatMap((operation) => operation[0] === 'token' ? (palette.get(operation[1]) ?? []) : [operation]);
+    for (const operation of expanded) {
+        switch (operation[0]) {
+            case 'foreground': {
+                foreground = operation[1];
+                break;
+            }
+            case 'background': {
+                background = operation[1];
+                break;
+            }
+            case 'modifier': {
+                active.add(operation[1]);
+                break;
+            }
+            case 'reset': {
+                foreground = undefined;
+                background = undefined;
+                active = new Set();
+                break;
+            }
+            case 'resetForeground': {
+                foreground = undefined;
+                break;
+            }
+            case 'resetBackground': {
+                background = undefined;
+                break;
+            }
+            case 'token': {
+                break;
+            }
+        }
+    }
+    return { background, foreground, modifiers: active };
+}
+const ansiModifiers = {
+    bold: 1,
+    faint: 2,
+    hidden: 8,
+    inverse: 7,
+    italic: 3,
+    overline: 53,
+    strikethrough: 9,
+    underline: 4,
+};
+const resetModifiers = {
+    bold: 22,
+    faint: 22,
+    hidden: 28,
+    inverse: 27,
+    italic: 23,
+    overline: 55,
+    strikethrough: 29,
+    underline: 24,
+};
+const basicPalette = [
+    [0, 0, 0],
+    [128, 0, 0],
+    [0, 128, 0],
+    [128, 128, 0],
+    [0, 0, 128],
+    [128, 0, 128],
+    [0, 128, 128],
+    [192, 192, 192],
+    [128, 128, 128],
+    [255, 0, 0],
+    [0, 255, 0],
+    [255, 255, 0],
+    [0, 0, 255],
+    [255, 0, 255],
+    [0, 255, 255],
+    [255, 255, 255],
+];
+function channel(value) {
+    return value === 0 ? 0 : 55 + value * 40;
+}
+function paletteRgb(index) {
+    const basic = basicPalette[index];
+    if (basic) {
+        return basic;
+    }
+    if (index >= 232) {
+        const value = 8 + (index - 232) * 10;
+        return [value, value, value];
+    }
+    const cube = index - 16;
+    return [channel(Math.floor(cube / 36)), channel(Math.floor(cube / 6) % 6), channel(cube % 6)];
+}
+function nearest(rgb, limit) {
+    let closest = 0;
+    let distance = Infinity;
+    for (let index = 0; index < limit; index += 1) {
+        const candidate = paletteRgb(index);
+        const next = (rgb[0] - candidate[0]) ** 2 + (rgb[1] - candidate[1]) ** 2 + (rgb[2] - candidate[2]) ** 2;
+        if (next < distance) {
+            distance = next;
+            closest = index;
+        }
+    }
+    return closest;
+}
+function colorCode(color, background, depth) {
+    const offset = background ? 10 : 0;
+    if (color === undefined) {
+        return String(39 + offset);
+    }
+    let index = 0;
+    if (typeof color === 'string') {
+        index = colors[color];
+    }
+    else if (color[0] === 'rgb') {
+        if (depth === 'truecolor') {
+            return `${38 + offset};2;${color[1]};${color[2]};${color[3]}`;
+        }
+        const fallback = color[4];
+        if (depth === 16 && fallback?.ansi16 !== undefined) {
+            index = colors[fallback.ansi16];
+        }
+        else if (depth === 256 && fallback?.ansi256 !== undefined) {
+            index = fallback.ansi256;
+        }
+        else {
+            index = nearest([color[1], color[2], color[3]], depth);
+        }
+    }
+    else if (depth !== 16) {
+        index = color[1];
+    }
+    else {
+        const fallback = color[2]?.ansi16;
+        index = fallback === undefined ? nearest(paletteRgb(color[1]), 16) : colors[fallback];
+    }
+    return index < 16
+        ? String((index < 8 ? 30 + index : 90 + index - 8) + offset)
+        : `${38 + offset};5;${index}`;
+}
+function sgr(codes) {
+    return codes.length ? `\u001b[${codes.join(';')}m` : '';
+}
+/** Diffs effective attributes, including the shared reset for bold and faint. */
+function transition(previous, next, caps) {
+    const codes = [];
+    if (caps.color) {
+        for (const field of ['foreground', 'background']) {
+            const before = colorCode(previous[field], field === 'background', caps.depth);
+            const after = colorCode(next[field], field === 'background', caps.depth);
+            if (before !== after) {
+                codes.push(after);
+            }
+        }
+    }
+    if (caps.modifiers) {
+        const removed = new Set();
+        for (const modifier of previous.modifiers) {
+            if (!next.modifiers.has(modifier)) {
+                removed.add(resetModifiers[modifier]);
+            }
+        }
+        codes.push(...removed);
+        for (const modifier of next.modifiers) {
+            if (!previous.modifiers.has(modifier) || removed.has(resetModifiers[modifier])) {
+                codes.push(ansiModifiers[modifier]);
+            }
+        }
+    }
+    return sgr(codes);
+}
+export { applyOperations, emptyAttributes, transition };

package/dist/style-wire.d.ts

@@ -0,0 +1,31 @@
+import type { Attributes, Palette } from './style-state.js';
+import type { Operation } from './style.js';
+type Alignment = 'left' | 'right' | 'center';
+interface Padding {
+    width: number;
+    align: Alignment;
+}
+type Boundary = {
+    kind: 'open';
+    padding: Padding;
+    attributes: Attributes;
+    scope: StyleScope;
+} | {
+    kind: 'close';
+};
+interface ParsedText {
+    text: string;
+    scopes: StyleScope[];
+    root: StyleScope;
+    palette: Palette;
+    boundaries: Map<number, Boundary[]>;
+}
+interface StyleScope {
+    attributes: Attributes;
+    parent: StyleScope | undefined;
+    operations: readonly Operation[];
+}
+/** Decodes framing once. Rejected headers are opaque, and nesting uses an explicit stack. */
+declare function parseText(input: string, palette: Palette, mainGlyphs: boolean): ParsedText;
+export type { Alignment, Boundary, Padding, ParsedText, StyleScope };
+export { parseText };