@heinrichb/console-toolkit 1.0.7 → 1.0.9

package/dist/core/style.test.js

@@ -1,108 +0,0 @@
-import { expect, test, describe } from "bun:test";
-import { hexToRgb, rgbToAnsi, interpolateColor, resolveStyle, resolveColorToAnsi, resolveModifiersToAnsi, getGradientColor, mergeStyles } from "./style";
-const ESC = "\x1b";
-describe("Color Utilities", () => {
-    test("hexToRgb converts correctly", () => {
-        expect(hexToRgb("#FFFFFF")).toEqual({ r: 255, g: 255, b: 255 });
-        expect(hexToRgb("#000000")).toEqual({ r: 0, g: 0, b: 0 });
-    });
-    test("hexToRgb handles invalid hex gracefully", () => {
-        expect(hexToRgb("invalid")).toEqual({ r: 255, g: 255, b: 255 }); // Fallback
-        expect(hexToRgb("#FFF")).toEqual({ r: 255, g: 255, b: 255 }); // Fallback
-    });
-    test("rgbToAnsi converts correctly", () => {
-        expect(rgbToAnsi(255, 255, 255)).toBe(`${ESC}[38;2;255;255;255m`);
-        expect(rgbToAnsi(0, 0, 0)).toBe(`${ESC}[38;2;0;0;0m`);
-    });
-    test("resolveColorToAnsi converts hex and standard colors", () => {
-        expect(resolveColorToAnsi("#FFFFFF")).toBe(`${ESC}[38;2;255;255;255m`);
-        expect(resolveColorToAnsi("red")).toBe(`${ESC}[38;2;239;68;68m`); // Updated to Tailwind value
-    });
-    test("interpolateColor returns hex string for hex inputs", () => {
-        const start = "#000000";
-        const end = "#ffffff";
-        expect(interpolateColor(start, end, 0.5)).toBe("#808080");
-    });
-    test("interpolateColor handles standard color names", () => {
-        expect(interpolateColor("black", "white", 0.5)).toBe("#808080");
-    });
-    test("interpolateColor clamps factors", () => {
-        expect(interpolateColor("#000000", "#ffffff", -1)).toBe("#000000");
-        expect(interpolateColor("#000000", "#ffffff", 2)).toBe("#ffffff");
-    });
-});
-describe("Style Resolution", () => {
-    test("resolveModifiersToAnsi handles modifiers", () => {
-        expect(resolveModifiersToAnsi(["bold"])).toBe(`${ESC}[1m`);
-        expect(resolveModifiersToAnsi(["bold", "italic"])).toBe(`${ESC}[1m${ESC}[3m`);
-        expect(resolveModifiersToAnsi([])).toBe("");
-    });
-    test("resolveStyle handles modifiers only", () => {
-        expect(resolveStyle({ modifiers: ["bold"] })).toBe(`${ESC}[1m`);
-    });
-    test("resolveStyle handles solid color", () => {
-        const style = { color: "#FF0000" };
-        expect(resolveStyle(style)).toBe(`${ESC}[38;2;255;0;0m`);
-    });
-    test("resolveStyle handles modifiers and solid color", () => {
-        const style = { modifiers: ["bold"], color: "#FF0000" };
-        expect(resolveStyle(style)).toBe(`${ESC}[1m${ESC}[38;2;255;0;0m`);
-    });
-    test("resolveStyle handles gradient (uses factor 0 by default)", () => {
-        const colors = ["#000000", "#FFFFFF"];
-        const style = { color: colors };
-        expect(resolveStyle(style)).toBe(`${ESC}[38;2;0;0;0m`); // Factor 0 is black
-    });
-    test("resolveStyle handles gradient with explicit factor", () => {
-        const colors = ["#000000", "#FFFFFF"];
-        const style = { color: colors };
-        expect(resolveStyle(style, 1)).toBe(`${ESC}[38;2;255;255;255m`); // Factor 1 is white
-    });
-});
-describe("Gradient Utilities", () => {
-    test("getGradientColor handles 2 colors", () => {
-        const colors = ["#000000", "#FFFFFF"];
-        expect(getGradientColor(colors, 0)).toBe(`${ESC}[38;2;0;0;0m`);
-        expect(getGradientColor(colors, 0.5)).toBe(`${ESC}[38;2;128;128;128m`);
-        expect(getGradientColor(colors, 1)).toBe(`${ESC}[38;2;255;255;255m`);
-    });
-    test("getGradientColor handles 3 colors", () => {
-        const colors = ["#000000", "#808080", "#FFFFFF"];
-        // 0 -> black
-        expect(getGradientColor(colors, 0)).toBe(`${ESC}[38;2;0;0;0m`);
-        // 0.5 -> middle color (gray)
-        expect(getGradientColor(colors, 0.5)).toBe(`${ESC}[38;2;128;128;128m`);
-        // 1 -> white
-        expect(getGradientColor(colors, 1)).toBe(`${ESC}[38;2;255;255;255m`);
-        // 0.25 -> between black and gray
-        expect(getGradientColor(colors, 0.25)).toBe(`${ESC}[38;2;64;64;64m`);
-    });
-});
-describe("Style Merging", () => {
-    test("mergeStyles combines modifiers", () => {
-        const p = { modifiers: ["bold"] };
-        const c = { modifiers: ["italic"] };
-        const merged = mergeStyles(p, c);
-        expect(merged.modifiers).toContain("bold");
-        expect(merged.modifiers).toContain("italic");
-    });
-    test("mergeStyles overrides color (Child wins)", () => {
-        const p = { color: "red" };
-        const c = { color: "blue" };
-        const merged = mergeStyles(p, c);
-        expect(merged.color).toBe("blue");
-    });
-    test("mergeStyles inherits parent color if child has none", () => {
-        const p = { color: "red" };
-        const c = { modifiers: ["bold"] };
-        const merged = mergeStyles(p, c);
-        expect(merged.color).toBe("red");
-        expect(merged.modifiers).toContain("bold");
-    });
-    test("mergeStyles handles null/undefined inputs", () => {
-        const p = { color: "red" };
-        expect(mergeStyles(p, undefined)).toEqual(p);
-        expect(mergeStyles(undefined, p)).toEqual(p);
-        expect(mergeStyles(undefined, undefined)).toEqual({});
-    });
-});

package/dist/core/types.js

@@ -1,4 +0,0 @@
-// -----------------
-// Style Types
-// -----------------
-export {};

package/dist/core/utils.js

@@ -1,36 +0,0 @@
-/**
- * Gets the plain text length of a PrintLine (ignoring ANSI codes).
- *
- * @param line - The PrintLine to measure.
- * @returns The length of the text content.
- */
-export function getLineLength(line) {
-    return line.segments.reduce((acc, seg) => acc + seg.text.length, 0);
-}
-/**
- * Computes the maximum width among an array of PrintLines.
- * Useful for aligning columns.
- *
- * @param lines - Array of PrintLines.
- * @returns The maximum line length found.
- */
-export function computeMaxWidth(lines) {
-    return lines.length > 0 ? Math.max(...lines.map(getLineLength)) : 0;
-}
-/**
- * Pads a PrintLine to a target width by adding an empty segment at the end.
- *
- * @param line - The line to pad.
- * @param targetWidth - The desired minimum width.
- * @param padStyle - The style to apply to the padding spaces.
- * @returns A new PrintLine with padding added if necessary.
- */
-export function padLine(line, targetWidth, padStyle) {
-    const currentLength = getLineLength(line);
-    if (currentLength < targetWidth) {
-        return {
-            segments: [...line.segments, { text: " ".repeat(targetWidth - currentLength), style: padStyle }]
-        };
-    }
-    return line;
-}

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

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

package/dist/core/utils.test.js

@@ -1,25 +0,0 @@
-import { expect, test, describe } from "bun:test";
-import { getLineLength, computeMaxWidth, padLine } from "./utils";
-const lineA = { segments: [{ text: "Hello", style: {} }] };
-const lineB = { segments: [{ text: "World!!", style: {} }] };
-describe("Line Utilities", () => {
-    test("getLineLength calculates correctly", () => {
-        expect(getLineLength(lineA)).toBe(5);
-        expect(getLineLength(lineB)).toBe(7);
-    });
-    test("computeMaxWidth finds the longest line", () => {
-        expect(computeMaxWidth([lineA, lineB])).toBe(7);
-        expect(computeMaxWidth([])).toBe(0);
-    });
-    test("padLine adds padding when needed", () => {
-        const padded = padLine(lineA, 10, { color: "red" });
-        expect(getLineLength(padded)).toBe(10);
-        expect(padded.segments[1].style).toEqual({ color: "red" });
-        expect(padded.segments[1].text).toBe("     ");
-    });
-    test("padLine does nothing if line is already wide enough", () => {
-        const ignored = padLine(lineB, 5, { color: "red" });
-        expect(getLineLength(ignored)).toBe(7);
-        expect(ignored.segments.length).toBe(1);
-    });
-});

package/dist/demo.d.ts

@@ -1 +0,0 @@
-export declare function runDemo(): Promise<void>;

package/dist/demo.js

@@ -1,145 +0,0 @@
-import { printColumns, getDragon, Printer, interpolateColor, createProgressBar, Spinner, SPINNERS } from "./index";
-import pkg from "../package.json";
-/**
- * Run this demo to visually verify terminal output:
- * bun run src/demo.ts
- */
-function getProgressBarColor(factor) {
-    // Multi-stop gradient: Blue -> Cyan -> Green
-    if (factor < 0.5) {
-        return interpolateColor("#3B82F6", "#06B6D4", factor * 2);
-    }
-    else {
-        return interpolateColor("#06B6D4", "#10B981", (factor - 0.5) * 2);
-    }
-}
-export async function runDemo() {
-    console.clear();
-    const staticPrinter = new Printer();
-    // 1. Static Dual Column Print
-    console.log("--- Static Dual Column Demo ---");
-    const purple = { color: "#A78BFA" };
-    const blue = { color: "#60A5FA" };
-    const green = { color: "#34D399" };
-    const yellow = { color: "#FBBF24" };
-    const leftContent = [
-        { segments: [{ text: "Package:", style: purple }] },
-        { segments: [{ text: "Version:", style: purple }] },
-        { segments: [{ text: "Status:", style: purple }] }
-    ];
-    const rightContent = [
-        { segments: [{ text: pkg.name, style: blue }] },
-        { segments: [{ text: pkg.version, style: green }] },
-        { segments: [{ text: "Testing live output...", style: yellow }] }
-    ];
-    printColumns([leftContent, rightContent], { separator: "  =>  " });
-    console.log("\n");
-    // 2. Block Vertical Gradient Demo
-    console.log("--- Block Vertical Gradient Demo ---");
-    const gradientBlockLines = Array.from({ length: 10 }, (_, i) => ({
-        segments: [{ text: `Line ${i + 1} - Inherits Gradient` }]
-    }));
-    staticPrinter.print({
-        style: { color: ["#EF4444", "#3B82F6"] },
-        lines: gradientBlockLines
-    });
-    console.log("\n");
-    // 3. Dragon Gradient Preset
-    console.log("--- Dragon Gradient Preset ---");
-    const dragon = getDragon("#EF4444", "#FDE047");
-    staticPrinter.print({ lines: dragon });
-    console.log("\n");
-    // 4. Interactive Progress Bar Demo
-    console.log("--- Live Progress Bar Demo ---");
-    const livePrinter = new Printer({ live: true });
-    const gray = { color: "#4B5563" };
-    for (let i = 0; i <= 100; i += 2) {
-        const factor = i / 100;
-        const progressColorHex = interpolateColor("#3B82F6", "#10B981", factor);
-        const progressColor = { color: progressColorHex };
-        // Standard Bar
-        const progressLine = createProgressBar({
-            progress: factor,
-            width: 30,
-            startChar: "[",
-            endChar: "]",
-            startStyle: progressColor,
-            endStyle: progressColor,
-            fillStyle: progressColor,
-            emptyStyle: gray,
-            percentageStyle: progressColor
-        });
-        // Gradient Bar
-        const gradientHex = getProgressBarColor(factor);
-        const gradientStyle = { color: gradientHex };
-        const complexGradientBar = createProgressBar({
-            progress: factor,
-            width: 40,
-            startChar: "▕",
-            endChar: "▏",
-            fillChar: "█",
-            emptyChar: "░",
-            startStyle: gradientStyle,
-            endStyle: gradientStyle,
-            fillStyle: { color: ["#3B82F6", "#EC4899"] },
-            emptyStyle: { color: "gray" },
-            percentageStyle: { modifiers: ["bold"], color: gradientHex }
-        });
-        livePrinter.print({
-            lines: [
-                progressLine,
-                { segments: [] },
-                { segments: [{ text: "Horizontal Gradient on Bar Segment:", style: { modifiers: ["bold"] } }] },
-                complexGradientBar
-            ]
-        });
-        await new Promise((resolve) => setTimeout(resolve, 30));
-    }
-    console.log("\n");
-    // 5. Spinners Demo
-    console.log("--- Spinners Demo ---");
-    const spinnerTypes = Object.keys(SPINNERS);
-    const spinners = spinnerTypes.map((type) => ({
-        type,
-        instance: new Spinner({ frames: SPINNERS[type], interval: 80 })
-    }));
-    const spinnerPrinter = new Printer({ live: true });
-    const spinnerStart = Date.now();
-    while (Date.now() - spinnerStart < 3000) {
-        const lines = spinners.map((s) => ({
-            segments: [
-                { text: `${s.type.charAt(0).toUpperCase() + s.type.slice(1)}:`.padEnd(10), style: { modifiers: ["dim"] } },
-                { text: s.instance.getFrame(), style: { color: "cyan" } }
-            ]
-        }));
-        spinnerPrinter.print({ lines });
-        await new Promise((resolve) => setTimeout(resolve, 50));
-    }
-    console.log("\n");
-    // 6. Style Codes Demo
-    console.log("--- Style Codes Demo ---");
-    const styles = [
-        { name: "Default" },
-        { name: "Bold + Red", style: { modifiers: ["bold"], color: "red" } },
-        { name: "Bold", style: { modifiers: ["bold"] } },
-        { name: "Dim", style: { modifiers: ["dim"] } },
-        { name: "Italic", style: { modifiers: ["italic"] } },
-        { name: "Underline", style: { modifiers: ["underline"] } },
-        { name: "Strikethrough", style: { modifiers: ["strikethrough"] } },
-        { name: "Inverse", style: { modifiers: ["inverse"] } },
-        { name: "Hidden", style: { modifiers: ["hidden"] } },
-        { name: "Red", style: { color: "red" } },
-        { name: "Green", style: { color: "green" } },
-        { name: "Yellow", style: { color: "yellow" } },
-        { name: "Blue", style: { color: "blue" } },
-        { name: "Magenta", style: { color: "magenta" } },
-        { name: "Cyan", style: { color: "cyan" } },
-        { name: "White", style: { color: "white" } },
-        { name: "Gray", style: { color: "gray" } }
-    ];
-    const styleLines = styles.map((s) => ({
-        segments: [{ text: s.name.padEnd(20) }, { text: "Sample Text", style: s.style }]
-    }));
-    staticPrinter.print({ lines: styleLines });
-    console.log("\n✨ Demo Complete!");
-}

package/dist/demo.test.d.ts

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

package/dist/demo.test.js

@@ -1,28 +0,0 @@
-import { expect, test, describe, spyOn, afterEach, beforeEach } from "bun:test";
-import { runDemo } from "./demo";
-describe("Demo Script", () => {
-    const logSpy = spyOn(console, "log").mockImplementation(() => undefined);
-    const clearSpy = spyOn(console, "clear").mockImplementation(() => undefined);
-    const stdoutSpy = spyOn(process.stdout, "write").mockImplementation(() => true);
-    const originalTimeout = global.setTimeout;
-    beforeEach(() => {
-        // Mocking setTimeout requires unknown casting due to return type mismatch in Bun (void vs Timer)
-        global.setTimeout = ((fn) => {
-            fn();
-        });
-    });
-    afterEach(() => {
-        logSpy.mockClear();
-        clearSpy.mockClear();
-        stdoutSpy.mockClear();
-        global.setTimeout = originalTimeout;
-    });
-    test("runDemo executes correctly", async () => {
-        // Just await the function call; we expect it not to throw.
-        await runDemo();
-        expect(clearSpy).toHaveBeenCalled();
-        expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("Static Dual Column Demo"));
-        expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("Demo Complete!"));
-        expect(stdoutSpy).toHaveBeenCalled();
-    });
-});

package/dist/presets/ascii.js

@@ -1,35 +0,0 @@
-import { interpolateColor } from "../core/style";
-// -----------------
-// Presets
-// -----------------
-/**
- * Returns the classic Dragon ASCII art as PrintLines with a vertical color gradient.
- */
-export function getDragon(startColor = "#EF4444", endColor = "#F59E0B") {
-    const rawDragon = [
-        "                ^    ^",
-        "               / \\  //\\",
-        " |\\___/|      /   \\//  .\\",
-        " /O  O  \\__  /    //  | \\ \\",
-        "/     /  \\_/_/    //   |  \\  \\",
-        "@___@'    \\_//   //    |   \\   \\ ",
-        "   |       \\_// //     |    \\    \\ ",
-        "   |        \\///      |     \\     \\ ",
-        "  _|_ /   )  //       |      \\     _\\",
-        " '/,_ _ _/  ( ; -.    |    _ _\\.-~        .-~~~^-.",
-        " ,-{        _      `-.|.-~-.           .~         `.",
-        "  '/\\      /                 ~-. _ .-~      .-~^-.  \\",
-        "     `.   {            }                   /      \\  \\",
-        "   .----~-\\.        \\-'                 .~         \\  `. \\^-.",
-        "  ///.----..>    c   \\             _ -~             `.  ^-`   ^-_",
-        "    ///-._ _ _ _ _ _ _}^ - - - - ~                     ~--,   .-~",
-        "                                                          /.-'"
-    ];
-    // Note: We could use PrintBlock's vertical gradient feature instead of manual interpolation here.
-    // But to keep logic similar and return lines directly, we manual interp.
-    return rawDragon.map((text, i) => {
-        const factor = rawDragon.length <= 1 ? 0 : i / (rawDragon.length - 1);
-        const colorStyle = interpolateColor(startColor, endColor, factor);
-        return { segments: [{ text, style: { color: colorStyle } }] };
-    });
-}

package/dist/presets/ascii.test.d.ts

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

package/dist/presets/ascii.test.js

@@ -1,21 +0,0 @@
-import { expect, test, describe } from "bun:test";
-import { getDragon } from "./ascii";
-describe("Presets", () => {
-    test("getDragon returns valid array", () => {
-        const lines = getDragon();
-        expect(lines.length).toBeGreaterThan(0);
-        const firstSegmentStyle = lines[0].segments[0].style;
-        expect(firstSegmentStyle).toBeDefined();
-        if (firstSegmentStyle) {
-            // Check that color is defined and is hex
-            expect(firstSegmentStyle.color).toBeDefined();
-            if (typeof firstSegmentStyle.color === "string") {
-                expect(firstSegmentStyle.color.startsWith("#")).toBe(true);
-            }
-            else {
-                // Fail if it's not a string (e.g. array)
-                expect(typeof firstSegmentStyle.color).toBe("string");
-            }
-        }
-    });
-});