@heinrichb/console-toolkit 1.0.7 → 1.0.9

package/dist/components/spinner.test.js

@@ -1,53 +0,0 @@
-import { expect, test, describe, spyOn, afterEach, beforeEach } from "bun:test";
-import { Spinner, SPINNERS } from "./spinner";
-describe("Spinner Class", () => {
-    let now = 1000;
-    // Mock Date.now() to control time
-    const dateSpy = spyOn(Date, "now").mockImplementation(() => now);
-    beforeEach(() => {
-        now = 1000;
-        dateSpy.mockClear();
-        dateSpy.mockImplementation(() => now);
-    });
-    afterEach(() => {
-        dateSpy.mockClear();
-    });
-    test("initializes with correct defaults", () => {
-        const spinner = new Spinner({ frames: ["a", "b"] });
-        expect(spinner.getFrame()).toBe("a");
-    });
-    test("advances frames over time", () => {
-        const spinner = new Spinner({ frames: ["a", "b", "c"], interval: 100 });
-        // t=0 (1000)
-        expect(spinner.getFrame()).toBe("a");
-        // t=50 (1050) -> still frame 0
-        now = 1050;
-        expect(spinner.getFrame()).toBe("a");
-        // t=100 (1100) -> frame 1
-        now = 1100;
-        expect(spinner.getFrame()).toBe("b");
-        // t=200 (1200) -> frame 2
-        now = 1200;
-        expect(spinner.getFrame()).toBe("c");
-        // t=300 (1300) -> frame 0 (loop)
-        now = 1300;
-        expect(spinner.getFrame()).toBe("a");
-    });
-    test("uses custom interval", () => {
-        const spinner = new Spinner({ frames: ["a", "b"], interval: 50 });
-        // t=0
-        expect(spinner.getFrame()).toBe("a");
-        // t=50 -> frame 1
-        now = 1050;
-        expect(spinner.getFrame()).toBe("b");
-    });
-});
-describe("Spinner Presets", () => {
-    test("dots preset exists and has frames", () => {
-        expect(SPINNERS.dots).toBeDefined();
-        expect(SPINNERS.dots.length).toBeGreaterThan(0);
-    });
-    test("lines preset exists", () => {
-        expect(SPINNERS.lines).toBeDefined();
-    });
-});

package/dist/core/layout.js

@@ -1,55 +0,0 @@
-import { computeMaxWidth, padLine } from "./utils";
-import { Printer } from "./printer";
-// -----------------
-// Core Layout & Printing
-// -----------------
-/**
- * Merges multiple columns of PrintLines into a single layout.
- * Ensures proper alignment by padding shorter lines.
- *
- * @param columns - Array of columns, where each column is an array of PrintLines.
- * @param separator - String used to separate columns.
- * @param defaultStyle - Style to apply to the separator and padding.
- * @param widths - Optional fixed widths for each column.
- * @returns A single array of PrintLines representing the merged output.
- */
-export function mergeMultipleColumns(columns, separator = "     ", defaultStyle, widths) {
-    if (columns.length === 0)
-        return [];
-    const maxLines = Math.max(...columns.map((c) => c.length));
-    const colWidths = columns.map((col, i) => {
-        if (widths?.[i] !== undefined)
-            return widths[i];
-        return computeMaxWidth(col);
-    });
-    const output = [];
-    for (let i = 0; i < maxLines; i++) {
-        let segments = [];
-        for (let j = 0; j < columns.length; j++) {
-            const line = columns[j][i] || { segments: [] };
-            // If not the last column, pad it
-            if (j < columns.length - 1) {
-                const padded = padLine(line, colWidths[j], defaultStyle);
-                segments = [...segments, ...padded.segments, { text: separator, style: defaultStyle }];
-            }
-            else {
-                // Last column, just add segments
-                segments = [...segments, ...line.segments];
-            }
-        }
-        output.push({ segments });
-    }
-    return output;
-}
-/**
- * Prints multiple columns of styled content to the console.
- * A convenience wrapper around `mergeMultipleColumns` and `Printer.print`.
- *
- * @param columns - Array of columns to print.
- * @param options - Layout options (widths, separator, custom printer).
- */
-export function printColumns(columns, options = {}) {
-    const { widths, separator = "     ", printer = new Printer() } = options;
-    const mergedLines = mergeMultipleColumns(columns, separator, undefined, widths);
-    printer.print({ lines: mergedLines });
-}

package/dist/core/layout.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/core/layout.test.js

@@ -1,52 +0,0 @@
-import { expect, test, describe, spyOn, afterEach } from "bun:test";
-import { mergeMultipleColumns, printColumns } from "./layout";
-import { getLineLength } from "./utils";
-const lineA = { segments: [{ text: "Hello" }] };
-const lineB = { segments: [{ text: "World!!" }] };
-describe("Layout Utilities", () => {
-    const stdoutSpy = spyOn(process.stdout, "write").mockImplementation(() => true);
-    afterEach(() => {
-        stdoutSpy.mockClear();
-    });
-    test("mergeMultipleColumns handles asymmetric column lengths", () => {
-        // Column 1: [lineA]
-        // Column 2: [lineB, lineB]
-        // Separator: " | "
-        // Default Style: undefined
-        // Widths: [10] (first col width 10)
-        const merged = mergeMultipleColumns([[lineA], [lineB, lineB]], " | ", undefined, [10]);
-        expect(merged.length).toBe(2);
-        // Second merged line:
-        // Col 1 is empty (pad to 10) + " | " + Col 2 (lineB, length 7)
-        // 10 + 3 + 7 = 20
-        expect(getLineLength(merged[1])).toBe(20);
-    });
-    test("printColumns executes correctly", () => {
-        printColumns([[lineA], [lineB]]);
-        expect(stdoutSpy).toHaveBeenCalled();
-        const output = stdoutSpy.mock.calls[0][0];
-        expect(output).toContain("Hello");
-        expect(output).toContain("World!!");
-    });
-    test("printColumns handles undefined style in segments", () => {
-        const lineNoStyle = { segments: [{ text: "NoStyle" }] };
-        printColumns([[lineNoStyle]]);
-        expect(stdoutSpy).toHaveBeenCalled();
-        const output = stdoutSpy.mock.calls[0][0];
-        expect(output).toContain("NoStyle");
-    });
-    test("printColumns handles empty columns", () => {
-        printColumns([]);
-        // Should just print nothing or minimal output (if logic handles empty array gracefully)
-        // mergeMultipleColumns returns []
-        // printer.print({ lines: [] }) -> might output clear sequence or empty string
-        expect(stdoutSpy).toHaveBeenCalled();
-    });
-    test("printColumns handles 3 columns", () => {
-        printColumns([[lineA], [lineA], [lineB]]);
-        expect(stdoutSpy).toHaveBeenCalled();
-        const output = stdoutSpy.mock.calls[0][0];
-        expect(output).toContain("Hello");
-        expect(output).toContain("World!!");
-    });
-});

package/dist/core/printer.js

@@ -1,129 +0,0 @@
-import { getGradientColor, mergeStyles, resolveStyle, RESET, interpolateColor, resolveModifiersToAnsi } from "./style";
-const ESC = "\x1b";
-/**
- * Handles rendering PrintBlocks to the terminal with support for interactive/live overwriting.
- */
-export class Printer {
-    linesRendered = 0;
-    isLive;
-    data;
-    constructor(options = {}) {
-        this.isLive = options.live ?? false;
-        this.data = options.data;
-    }
-    /**
-     * Generates the clear sequence to move cursor and clear previously rendered lines.
-     */
-    getClearSequence() {
-        if (!this.isLive || this.linesRendered === 0)
-            return "";
-        return `${ESC}[1A${ESC}[2K\r`.repeat(this.linesRendered);
-    }
-    /**
-     * Clears the console using the stored line count.
-     */
-    clear() {
-        if (this.linesRendered > 0) {
-            process.stdout.write(this.getClearSequence());
-            this.linesRendered = 0;
-        }
-    }
-    /**
-     * Renders the PrintBlock to the standard output.
-     * If data is provided, updates the internal state.
-     *
-     * @param data - Optional data to update the printer with.
-     */
-    print(data) {
-        if (data) {
-            this.data = data;
-        }
-        if (!this.data) {
-            return; // Nothing to print
-        }
-        let output = this.getClearSequence();
-        const lines = this.data.lines;
-        const blockStyle = this.data.style ?? {};
-        lines.forEach((line, lineIndex) => {
-            output += this.renderLine(line, lineIndex, lines.length, blockStyle);
-            output += "\n";
-        });
-        process.stdout.write(output);
-        this.linesRendered = lines.length;
-    }
-    /**
-     * Resolves the block's vertical gradient (if any) to a solid color for the specific line.
-     */
-    resolveBlockColorForLine(blockStyle, lineIndex, totalLines) {
-        if (!blockStyle.color)
-            return undefined;
-        if (Array.isArray(blockStyle.color)) {
-            // Vertical Gradient
-            if (totalLines <= 1)
-                return blockStyle.color[0]; // Single line, use first color
-            const colors = blockStyle.color;
-            const factor = lineIndex / (totalLines - 1);
-            // Interpolate manually to obtain Hex Color
-            const f = Math.max(0, Math.min(1, factor));
-            const segmentLength = 1 / (colors.length - 1);
-            const segmentIndex = Math.min(Math.floor(f / segmentLength), colors.length - 2);
-            const segmentFactor = (f - segmentIndex * segmentLength) / segmentLength;
-            const c1 = colors[segmentIndex];
-            const c2 = colors[segmentIndex + 1];
-            return interpolateColor(c1, c2, segmentFactor);
-        }
-        return blockStyle.color;
-    }
-    /**
-     * Renders a single line.
-     */
-    renderLine(line, lineIndex, totalLines, parentBlockStyle) {
-        // 1. Resolve Block Gradient to Solid Color for this line
-        const blockColorForLine = this.resolveBlockColorForLine(parentBlockStyle, lineIndex, totalLines);
-        // 2. Create Base Line Style (Block Modifiers + Resolved Block Color)
-        const baseLineStyle = {
-            modifiers: parentBlockStyle.modifiers,
-            color: blockColorForLine
-        };
-        // 3. Merge with Line's own style
-        // If line.style has color, it overrides baseLineStyle.color
-        const effectiveLineStyle = mergeStyles(baseLineStyle, line.style);
-        // 4. Pre-calculate total chars for horizontal gradients
-        const totalChars = line.segments.reduce((acc, seg) => acc + seg.text.length, 0);
-        let currentCharIndex = 0;
-        let lineOutput = "";
-        line.segments.forEach((seg) => {
-            const effectiveSegmentStyle = mergeStyles(effectiveLineStyle, seg.style);
-            if (Array.isArray(effectiveSegmentStyle.color)) {
-                // Gradient Handling (Horizontal)
-                const colors = effectiveSegmentStyle.color;
-                const text = seg.text;
-                // Determine if we are using the Line's gradient (Global) or Segment's gradient (Local)
-                // If effectiveSegmentStyle.color === effectiveLineStyle.color, it's inherited (Global)
-                // Otherwise it's the segment's own gradient (Local)
-                const isGlobalGradient = effectiveSegmentStyle.color === effectiveLineStyle.color;
-                // Iterate characters to apply gradient
-                const modifiersAnsi = resolveModifiersToAnsi(effectiveSegmentStyle.modifiers);
-                for (let i = 0; i < text.length; i++) {
-                    let factor = 0;
-                    if (isGlobalGradient && totalChars > 1) {
-                        factor = (currentCharIndex + i) / (totalChars - 1);
-                    }
-                    else if (!isGlobalGradient && text.length > 1) {
-                        factor = i / (text.length - 1);
-                    }
-                    const colorAnsi = getGradientColor(colors, factor); // Returns ANSI Color Code
-                    lineOutput += `${modifiersAnsi}${colorAnsi}${text[i]}`;
-                }
-                lineOutput += RESET;
-            }
-            else {
-                // Solid Color Handling
-                const ansi = resolveStyle(effectiveSegmentStyle);
-                lineOutput += `${ansi}${seg.text}${RESET}`;
-            }
-            currentCharIndex += seg.text.length;
-        });
-        return lineOutput;
-    }
-}

package/dist/core/printer.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/core/printer.test.js

@@ -1,124 +0,0 @@
-import { expect, test, describe, spyOn, afterEach } from "bun:test";
-import { Printer } from "./printer";
-import { resolveColorToAnsi } from "./style";
-const ESC = "\x1b";
-describe("Printer", () => {
-    // Mock process.stdout.write to prevent actual output during tests
-    const stdoutSpy = spyOn(process.stdout, "write").mockImplementation(() => true);
-    afterEach(() => {
-        stdoutSpy.mockClear();
-    });
-    test("Printer.print outputs basic text with solid styles", () => {
-        const printer = new Printer();
-        const block = {
-            lines: [{ segments: [{ text: "Hello", style: { color: "red" } }] }]
-        };
-        printer.print(block);
-        expect(stdoutSpy).toHaveBeenCalledTimes(1);
-        const output = stdoutSpy.mock.calls[0][0];
-        // Check for Red ANSI + Text + Reset
-        expect(output).toContain(`${ESC}[38;2;239;68;68mHello${ESC}[0m`);
-    });
-    test("Printer.print applies Block style to lines (inheritance)", () => {
-        const printer = new Printer();
-        const block = {
-            style: { color: "blue", modifiers: ["bold"] },
-            lines: [{ segments: [{ text: "Line 1" }] }, { segments: [{ text: "Line 2" }] }]
-        };
-        printer.print(block);
-        const output = stdoutSpy.mock.calls[0][0];
-        const blueAnsi = resolveColorToAnsi("blue");
-        const boldAnsi = `${ESC}[1m`;
-        // Both lines should be Blue + Bold
-        // Matches: Bold + Blue + Text + Reset
-        expect(output).toContain(`${boldAnsi}${blueAnsi}Line 1${ESC}[0m`);
-        expect(output).toContain(`${boldAnsi}${blueAnsi}Line 2${ESC}[0m`);
-    });
-    test("Printer handles Block Vertical Gradient (Lines inherit solid colors)", () => {
-        const printer = new Printer();
-        const block = {
-            style: { color: ["#000000", "#FFFFFF"] }, // Black to White
-            lines: [
-                { segments: [{ text: "Start" }] }, // Should be Black
-                { segments: [{ text: "Middle" }] }, // Should be Gray
-                { segments: [{ text: "End" }] } // Should be White
-            ]
-        };
-        printer.print(block);
-        const output = stdoutSpy.mock.calls[0][0];
-        const blackAnsi = resolveColorToAnsi("#000000");
-        const whiteAnsi = resolveColorToAnsi("#FFFFFF");
-        const grayAnsi = resolveColorToAnsi("#808080");
-        expect(output).toContain(`${blackAnsi}Start${ESC}[0m`);
-        expect(output).toContain(`${grayAnsi}Middle${ESC}[0m`);
-        expect(output).toContain(`${whiteAnsi}End${ESC}[0m`);
-    });
-    test("Printer handles Line Override (Horizontal Gradient)", () => {
-        const printer = new Printer();
-        const block = {
-            lines: [
-                {
-                    style: { color: ["#FF0000", "#0000FF"] }, // Red to Blue
-                    segments: [{ text: "GB" }] // Gradient applies to these 2 chars
-                }
-            ]
-        };
-        printer.print(block);
-        const output = stdoutSpy.mock.calls[0][0];
-        // First char 'G' should be Red (start)
-        // Second char 'B' should be Blue (end) - wait, factor logic?
-        // Length 2. index 0 -> factor 0. index 1 -> factor 1.
-        const redAnsi = resolveColorToAnsi("#FF0000");
-        const blueAnsi = resolveColorToAnsi("#0000FF");
-        expect(output).toContain(`${redAnsi}G`);
-        expect(output).toContain(`${blueAnsi}B`);
-    });
-    test("Printer handles Segment Override (Solid overrides Line Gradient)", () => {
-        const printer = new Printer();
-        const block = {
-            lines: [
-                {
-                    style: { color: ["#FF0000", "#0000FF"] }, // Line Gradient
-                    segments: [
-                        { text: "A" }, // Inherits Gradient (Red)
-                        { text: "B", style: { color: "green" } } // Override Solid (Green)
-                    ]
-                }
-            ]
-        };
-        printer.print(block);
-        const output = stdoutSpy.mock.calls[0][0];
-        const redAnsi = resolveColorToAnsi("#FF0000");
-        const greenAnsi = resolveColorToAnsi("green");
-        expect(output).toContain(`${redAnsi}A`);
-        expect(output).toContain(`${greenAnsi}B`);
-    });
-    test("Printer handles live clearing", () => {
-        const printer = new Printer({ live: true });
-        // Print 2 lines
-        printer.print({
-            lines: [{ segments: [{ text: "1" }] }, { segments: [{ text: "2" }] }]
-        });
-        // Print again (should clear 2 lines)
-        printer.print({
-            lines: [{ segments: [{ text: "New" }] }]
-        });
-        const clearSeq = `${ESC}[1A${ESC}[2K\r`;
-        const expectedClear = clearSeq.repeat(2);
-        const secondCallOutput = stdoutSpy.mock.calls[1][0];
-        expect(secondCallOutput.startsWith(expectedClear)).toBe(true);
-    });
-    test("Printer.clear() manually clears the output", () => {
-        const printer = new Printer({ live: true });
-        printer.print({
-            lines: [{ segments: [{ text: "Line 1" }] }]
-        });
-        expect(stdoutSpy).toHaveBeenCalledTimes(1);
-        printer.clear();
-        expect(stdoutSpy).toHaveBeenCalledTimes(2);
-        const clearSeq = `${ESC}[1A${ESC}[2K\r`;
-        const expectedClear = clearSeq.repeat(1);
-        const clearOutput = stdoutSpy.mock.calls[1][0];
-        expect(clearOutput).toBe(expectedClear);
-    });
-});

package/dist/core/style.js

@@ -1,171 +0,0 @@
-// -----------------
-// Color Utilities
-// -----------------
-const ESC = "\x1b";
-/**
- * ANSI escape sequence to reset all styles.
- */
-export const RESET = `${ESC}[0m`;
-const STANDARD_COLORS = {
-    black: "#000000",
-    red: "#EF4444", // Tailwind Red-500
-    green: "#10B981", // Tailwind Emerald-500
-    yellow: "#F59E0B", // Tailwind Amber-500
-    blue: "#3B82F6", // Tailwind Blue-500
-    magenta: "#EC4899", // Tailwind Pink-500
-    cyan: "#06B6D4", // Tailwind Cyan-500
-    white: "#FFFFFF",
-    gray: "#6B7280", // Tailwind Gray-500
-    grey: "#6B7280"
-};
-const MODIFIER_CODES = {
-    default: "0",
-    bold: "1",
-    dim: "2",
-    italic: "3",
-    underline: "4",
-    inverse: "7",
-    hidden: "8",
-    strikethrough: "9"
-};
-/**
- * Converts any Color (hex or standard name) to a Hex string.
- */
-export function colorToHex(color) {
-    if (color.startsWith("#"))
-        return color;
-    const hex = STANDARD_COLORS[color.toLowerCase()];
-    if (!hex)
-        return "#FFFFFF"; // Fallback
-    return hex;
-}
-/**
- * Converts a hex color string to an RGB object.
- */
-export function hexToRgb(hex) {
-    const h = hex.replace(/^#/, "");
-    if (h.length !== 6)
-        return { r: 255, g: 255, b: 255 }; // Fallback for invalid hex
-    return {
-        r: parseInt(h.substring(0, 2), 16),
-        g: parseInt(h.substring(2, 4), 16),
-        b: parseInt(h.substring(4, 6), 16)
-    };
-}
-/**
- * Converts RGB to a 24-bit ANSI foreground color escape sequence.
- */
-export function rgbToAnsi(r, g, b) {
-    return `${ESC}[38;2;${r};${g};${b}m`;
-}
-/**
- * Converts any Color to an ANSI escape sequence.
- */
-export function resolveColorToAnsi(color) {
-    const hex = colorToHex(color);
-    const { r, g, b } = hexToRgb(hex);
-    return rgbToAnsi(r, g, b);
-}
-/**
- * Converts a list of modifiers to an ANSI escape sequence.
- */
-export function resolveModifiersToAnsi(modifiers) {
-    if (!modifiers || modifiers.length === 0)
-        return "";
-    return modifiers
-        .map((m) => {
-        const code = MODIFIER_CODES[m];
-        return code ? `${ESC}[${code}m` : "";
-    })
-        .join("");
-}
-/**
- * Helper to convert number to 2-digit hex.
- */
-function toHex(c) {
-    const hex = Math.max(0, Math.min(255, Math.round(c))).toString(16);
-    return hex.length === 1 ? "0" + hex : hex;
-}
-/**
- * Interpolates between two hex colors.
- */
-export function interpolateHex(color1, color2, factor) {
-    const f = Math.max(0, Math.min(1, factor));
-    const c1 = hexToRgb(color1);
-    const c2 = hexToRgb(color2);
-    const r = c1.r + f * (c2.r - c1.r);
-    const g = c1.g + f * (c2.g - c1.g);
-    const b = c1.b + f * (c2.b - c1.b);
-    return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
-}
-/**
- * Public interpolation function that accepts any Color type.
- */
-export function interpolateColor(color1, color2, factor) {
-    return interpolateHex(colorToHex(color1), colorToHex(color2), factor);
-}
-/**
- * logic to get a specific color from a multi-stop gradient array at a specific factor (0-1).
- */
-export function getGradientColor(colors, factor) {
-    if (colors.length === 0)
-        return "";
-    if (colors.length === 1)
-        return resolveColorToAnsi(colors[0]);
-    const f = Math.max(0, Math.min(1, factor));
-    // Map factor to segments between colors
-    // e.g. 3 colors: [0, 0.5, 1]. factor 0.25 is in first segment (0.5 of way through)
-    const segmentLength = 1 / (colors.length - 1);
-    const segmentIndex = Math.min(Math.floor(f / segmentLength), colors.length - 2);
-    const segmentFactor = (f - segmentIndex * segmentLength) / segmentLength;
-    const c1 = colors[segmentIndex];
-    const c2 = colors[segmentIndex + 1];
-    const hex = interpolateColor(c1, c2, segmentFactor);
-    return resolveColorToAnsi(hex);
-}
-// -----------------
-// Style Merging
-// -----------------
-/**
- * Merges a child style into a parent style.
- * - Modifiers are combined (union).
- * - Child color overrides parent color.
- */
-export function mergeStyles(parent, child) {
-    if (!parent && !child)
-        return {};
-    if (!parent)
-        return child ?? {};
-    if (!child)
-        return parent;
-    const mergedModifiers = Array.from(new Set([...(parent.modifiers ?? []), ...(child.modifiers ?? [])]));
-    return {
-        modifiers: mergedModifiers,
-        color: child.color ?? parent.color
-    };
-}
-/**
- * Resolves a style object into an ANSI string.
- * If the color is a gradient (array), it uses the provided factor (0-1) to pick the color.
- * Defaults to factor 0 if not provided.
- */
-export function resolveStyle(style, gradientFactor = 0) {
-    if (!style)
-        return "";
-    let ansi = "";
-    if (style.modifiers) {
-        ansi += resolveModifiersToAnsi(style.modifiers);
-    }
-    if (style.color) {
-        if (Array.isArray(style.color)) {
-            // Gradient
-            const hex = getGradientColor(style.color, gradientFactor);
-            ansi += hex;
-        }
-        else {
-            // Solid
-            ansi += resolveColorToAnsi(style.color);
-        }
-    }
-    return ansi;
-}

package/dist/core/style.test.d.ts

@@ -1 +0,0 @@
-export {};