@heinrichb/console-toolkit 1.0.7 → 1.0.8

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.d.ts

@@ -1,53 +0,0 @@
-import { Color, HexColor, PrintStyle, StyleModifier } from "./types";
-/**
- * ANSI escape sequence to reset all styles.
- */
-export declare const RESET = "\u001B[0m";
-/**
- * Converts any Color (hex or standard name) to a Hex string.
- */
-export declare function colorToHex(color: Color): string;
-/**
- * Converts a hex color string to an RGB object.
- */
-export declare function hexToRgb(hex: string): {
-    r: number;
-    g: number;
-    b: number;
-};
-/**
- * Converts RGB to a 24-bit ANSI foreground color escape sequence.
- */
-export declare function rgbToAnsi(r: number, g: number, b: number): string;
-/**
- * Converts any Color to an ANSI escape sequence.
- */
-export declare function resolveColorToAnsi(color: Color): string;
-/**
- * Converts a list of modifiers to an ANSI escape sequence.
- */
-export declare function resolveModifiersToAnsi(modifiers?: StyleModifier[]): string;
-/**
- * Interpolates between two hex colors.
- */
-export declare function interpolateHex(color1: string, color2: string, factor: number): string;
-/**
- * Public interpolation function that accepts any Color type.
- */
-export declare function interpolateColor(color1: Color, color2: Color, factor: number): HexColor;
-/**
- * logic to get a specific color from a multi-stop gradient array at a specific factor (0-1).
- */
-export declare function getGradientColor(colors: Color[], factor: number): string;
-/**
- * Merges a child style into a parent style.
- * - Modifiers are combined (union).
- * - Child color overrides parent color.
- */
-export declare function mergeStyles(parent?: PrintStyle, child?: PrintStyle): PrintStyle;
-/**
- * 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 declare function resolveStyle(style?: PrintStyle, gradientFactor?: number): string;

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 {};

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.d.ts

@@ -1,72 +0,0 @@
-/**
- * Standard colors supported by most terminals.
- */
-export type StandardColor = "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white" | "gray" | "grey";
-/**
- * Text style modifiers.
- */
-export type StyleModifier = "bold" | "dim" | "italic" | "underline" | "default" | "hidden" | "inverse" | "strikethrough";
-/**
- * A valid Hex color string (e.g., "#FF0000").
- */
-export type HexColor = `#${string}`;
-/**
- * A color can be a standard color name or a hex color string.
- */
-export type Color = StandardColor | HexColor;
-/**
- * Represents the style configuration for a text segment, line, or block.
- */
-export interface PrintStyle {
-    /**
-     * The color to apply.
-     * - A single color (string) applies a solid color.
-     * - An array of colors applies a gradient.
-     */
-    color?: Color | Color[];
-    /**
-     * A list of style modifiers (e.g., bold, italic) to apply.
-     */
-    modifiers?: StyleModifier[];
-}
-/**
- * Represents a segment of text with applied styles.
- */
-export interface PrintSegment {
-    /** The text content of the segment. */
-    text: string;
-    /** The style specific to this segment. Merges with parent styles. */
-    style?: PrintStyle;
-}
-/**
- * Represents a line of text composed of multiple styled segments.
- */
-export interface PrintLine {
-    /** Array of segments that make up the line. */
-    segments: PrintSegment[];
-    /** The style specific to this line. Merges with parent block style and applies to all children. */
-    style?: PrintStyle;
-}
-/**
- * Represents a block of lines managed by the printer.
- */
-export interface PrintBlock {
-    /** Array of lines that make up the block. */
-    lines: PrintLine[];
-    /** The style specific to this block. Applies to all children. */
-    style?: PrintStyle;
-}
-/**
- * Configuration for the Printer engine.
- */
-export interface PrinterOptions {
-    /**
-     * If true, the printer will overwrite previous output on subsequent print calls.
-     * Useful for live-updating displays (spinners, progress bars).
-     */
-    live?: boolean;
-    /**
-     * Initial data to load into the printer.
-     */
-    data?: PrintBlock;
-}

package/dist/core/types.js

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