@heinrichb/console-toolkit 1.0.5 → 1.0.7

package/dist/core/style.d.ts

@@ -1,14 +1,14 @@
-import { HexColor, Style } from "./types";
+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.
- * Validates the hex string format.
- *
- * @param hex - Hex color in the form "#RRGGBB".
- * @returns Object with r, g, b components (0-255).
  */
 export declare function hexToRgb(hex: string): {
     r: number;
@@ -17,35 +17,37 @@ export declare function hexToRgb(hex: string): {
 };
 /**
  * Converts RGB to a 24-bit ANSI foreground color escape sequence.
- *
- * @param r - Red component (0-255).
- * @param g - Green component (0-255).
- * @param b - Blue component (0-255).
- * @returns ANSI escape sequence string.
  */
 export declare function rgbToAnsi(r: number, g: number, b: number): string;
 /**
- * Converts a hex color string directly to an ANSI escape sequence.
- *
- * @param hex - Hex color string.
- * @returns ANSI escape sequence 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 hexToAnsi(hex: string): string;
+export declare function getGradientColor(colors: Color[], factor: number): string;
 /**
- * Interpolates between two hex colors based on a factor (0 to 1) and returns a Hex color string.
- * Used for gradients.
- *
- * @param color1 - Start color (hex).
- * @param color2 - End color (hex).
- * @param factor - Interpolation factor (0.0 to 1.0).
- * @returns Interpolated Hex color.
+ * Merges a child style into a parent style.
+ * - Modifiers are combined (union).
+ * - Child color overrides parent color.
  */
-export declare function interpolateColor(color1: string, color2: string, factor: number): HexColor;
+export declare function mergeStyles(parent?: PrintStyle, child?: PrintStyle): PrintStyle;
 /**
- * Resolves a single Style or array of Styles into an ANSI escape sequence.
- * Handles hex colors, standard colors, and modifiers.
- *
- * @param style - The style or array of styles to resolve.
- * @returns The resulting ANSI escape sequence string.
+ * 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?: Style | Style[]): string;
+export declare function resolveStyle(style?: PrintStyle, gradientFactor?: number): string;

package/dist/core/style.js

@@ -6,17 +6,46 @@ 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.
- * Validates the hex string format.
- *
- * @param hex - Hex color in the form "#RRGGBB".
- * @returns Object with r, g, b components (0-255).
  */
 export function hexToRgb(hex) {
     const h = hex.replace(/^#/, "");
     if (h.length !== 6)
-        throw new Error("Invalid hex color.");
+        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),
@@ -25,43 +54,42 @@ export function hexToRgb(hex) {
 }
 /**
  * Converts RGB to a 24-bit ANSI foreground color escape sequence.
- *
- * @param r - Red component (0-255).
- * @param g - Green component (0-255).
- * @param b - Blue component (0-255).
- * @returns ANSI escape sequence string.
  */
 export function rgbToAnsi(r, g, b) {
     return `${ESC}[38;2;${r};${g};${b}m`;
 }
 /**
- * Converts a hex color string directly to an ANSI escape sequence.
- *
- * @param hex - Hex color string.
- * @returns ANSI escape sequence string.
+ * Converts any Color to an ANSI escape sequence.
  */
-export function hexToAnsi(hex) {
+export function resolveColorToAnsi(color) {
+    const hex = colorToHex(color);
     const { r, g, b } = hexToRgb(hex);
     return rgbToAnsi(r, g, b);
 }
 /**
- * Converts a single RGB component to a 2-digit hex string.
- * Helper for interpolation.
+ * 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 based on a factor (0 to 1) and returns a Hex color string.
- * Used for gradients.
- *
- * @param color1 - Start color (hex).
- * @param color2 - End color (hex).
- * @param factor - Interpolation factor (0.0 to 1.0).
- * @returns Interpolated Hex color.
+ * Interpolates between two hex colors.
  */
-export function interpolateColor(color1, color2, factor) {
+export function interpolateHex(color1, color2, factor) {
     const f = Math.max(0, Math.min(1, factor));
     const c1 = hexToRgb(color1);
     const c2 = hexToRgb(color2);
@@ -70,58 +98,74 @@ export function interpolateColor(color1, color2, factor) {
     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 Resolution
+// Style Merging
 // -----------------
-const STYLE_CODES = {
-    default: "0",
-    bold: "1",
-    dim: "2",
-    italic: "3",
-    underline: "4",
-    inverse: "7",
-    hidden: "8",
-    strikethrough: "9",
-    black: "30",
-    red: "31",
-    green: "32",
-    yellow: "33",
-    blue: "34",
-    magenta: "35",
-    cyan: "36",
-    white: "37",
-    gray: "90",
-    grey: "90"
-};
 /**
- * Resolves a single Style or array of Styles into an ANSI escape sequence.
- * Handles hex colors, standard colors, and modifiers.
- *
- * @param style - The style or array of styles to resolve.
- * @returns The resulting ANSI escape sequence string.
+ * Merges a child style into a parent style.
+ * - Modifiers are combined (union).
+ * - Child color overrides parent color.
  */
-export function resolveStyle(style) {
-    if (Array.isArray(style)) {
-        return style.map(resolveStyle).join("");
-    }
-    if (typeof style !== "string") {
+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);
     }
-    // Check for hex color
-    if (style.startsWith("#")) {
-        try {
-            return hexToAnsi(style);
+    if (style.color) {
+        if (Array.isArray(style.color)) {
+            // Gradient
+            const hex = getGradientColor(style.color, gradientFactor);
+            ansi += hex;
         }
-        catch {
-            return ""; // Invalid hex, ignore
+        else {
+            // Solid
+            ansi += resolveColorToAnsi(style.color);
         }
     }
-    // Check for standard styles/colors
-    const code = STYLE_CODES[style.toLowerCase()];
-    if (code) {
-        return `${ESC}[${code}m`;
-    }
-    // Fallback: return as raw string if it looks like ANSI or just text
-    // Ideally we would validate ANSI here, but for flexibility we return it.
-    return style;
+    return ansi;
 }

package/dist/core/style.test.js

@@ -1,53 +1,108 @@
 import { expect, test, describe } from "bun:test";
-import { hexToRgb, rgbToAnsi, hexToAnsi, interpolateColor, resolveStyle } from "./style";
+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 throws on invalid hex", () => {
-        expect(() => hexToRgb("invalid")).toThrow("Invalid hex color.");
-        expect(() => hexToRgb("#FFF")).toThrow("Invalid hex color.");
+    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("\x1b[38;2;255;255;255m");
-        expect(rgbToAnsi(0, 0, 0)).toBe("\x1b[38;2;0;0;0m");
+        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("hexToAnsi converts hex string directly to ANSI", () => {
-        expect(hexToAnsi("#FFFFFF")).toBe("\x1b[38;2;255;255;255m");
-        expect(hexToAnsi("#000000")).toBe("\x1b[38;2;0;0;0m");
-        expect(hexToAnsi("#FF0000")).toBe("\x1b[38;2;255;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", () => {
+    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("resolveStyle handles standard colors", () => {
-        expect(resolveStyle("red")).toBe("\x1b[31m");
-        expect(resolveStyle("blue")).toBe("\x1b[34m");
+    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 modifiers", () => {
-        expect(resolveStyle("bold")).toBe("\x1b[1m");
+    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
     });
-    test("resolveStyle handles hex colors", () => {
-        expect(resolveStyle("#FF0000")).toBe("\x1b[38;2;255;0;0m");
+});
+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("resolveStyle handles arrays of styles", () => {
-        expect(resolveStyle(["bold", "red"])).toBe("\x1b[1m\x1b[31m");
+    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("resolveStyle handles undefined style", () => {
-        expect(resolveStyle(undefined)).toBe("");
+    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("resolveStyle passes through raw strings", () => {
-        const raw = "\x1b[31m";
-        expect(resolveStyle(raw)).toBe(raw);
-        expect(resolveStyle("unknown")).toBe("unknown");
+    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

@@ -11,32 +11,62 @@ export type StyleModifier = "bold" | "dim" | "italic" | "underline" | "default"
  */
 export type HexColor = `#${string}`;
 /**
- * A style can be a standard color name, a hex color string, or a style modifier.
- * It can also be a raw ANSI string (though discouraged) for backward compatibility or special cases.
+ * A color can be a standard color name or a hex color string.
  */
-export type Style = StandardColor | StyleModifier | HexColor | 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 StyledSegment {
+export interface PrintSegment {
     /** The text content of the segment. */
     text: string;
-    /** Style or array of styles to apply to the text. */
-    style?: Style | Style[];
+    /** The style specific to this segment. Merges with parent styles. */
+    style?: PrintStyle;
 }
 /**
  * Represents a line of text composed of multiple styled segments.
  */
-export interface StyledLine {
+export interface PrintLine {
     /** Array of segments that make up the line. */
-    segments: StyledSegment[];
+    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 lines instead of appending new ones. */
-    interactive?: boolean;
-    /** The default style to apply to padding or separators. */
-    defaultStyle?: Style | Style[];
+    /**
+     * 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/utils.d.ts

@@ -1,25 +1,25 @@
-import { Style, StyledLine } from "./types";
+import { PrintLine, PrintStyle } from "./types";
 /**
- * Gets the plain text length of a StyledLine (ignoring ANSI codes).
+ * Gets the plain text length of a PrintLine (ignoring ANSI codes).
  *
- * @param line - The StyledLine to measure.
+ * @param line - The PrintLine to measure.
  * @returns The length of the text content.
  */
-export declare function getLineLength(line: StyledLine): number;
+export declare function getLineLength(line: PrintLine): number;
 /**
- * Computes the maximum width among an array of StyledLines.
+ * Computes the maximum width among an array of PrintLines.
  * Useful for aligning columns.
  *
- * @param lines - Array of StyledLines.
+ * @param lines - Array of PrintLines.
  * @returns The maximum line length found.
  */
-export declare function computeMaxWidth(lines: StyledLine[]): number;
+export declare function computeMaxWidth(lines: PrintLine[]): number;
 /**
- * Pads a StyledLine to a target width by adding an empty segment at the end.
+ * 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 StyledLine with padding added if necessary.
+ * @returns A new PrintLine with padding added if necessary.
  */
-export declare function padLine(line: StyledLine, targetWidth: number, padStyle: Style | Style[]): StyledLine;
+export declare function padLine(line: PrintLine, targetWidth: number, padStyle?: PrintStyle): PrintLine;

package/dist/core/utils.js

@@ -1,32 +1,29 @@
-// -----------------
-// Line Manipulation Helpers
-// -----------------
 /**
- * Gets the plain text length of a StyledLine (ignoring ANSI codes).
+ * Gets the plain text length of a PrintLine (ignoring ANSI codes).
  *
- * @param line - The StyledLine to measure.
+ * @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 StyledLines.
+ * Computes the maximum width among an array of PrintLines.
  * Useful for aligning columns.
  *
- * @param lines - Array of StyledLines.
+ * @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 StyledLine to a target width by adding an empty segment at the end.
+ * 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 StyledLine with padding added if necessary.
+ * @returns A new PrintLine with padding added if necessary.
  */
 export function padLine(line, targetWidth, padStyle) {
     const currentLength = getLineLength(line);

package/dist/core/utils.test.js

@@ -1,7 +1,7 @@
 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: [] }] };
+const lineA = { segments: [{ text: "Hello", style: {} }] };
+const lineB = { segments: [{ text: "World!!", style: {} }] };
 describe("Line Utilities", () => {
     test("getLineLength calculates correctly", () => {
         expect(getLineLength(lineA)).toBe(5);
@@ -12,13 +12,13 @@ describe("Line Utilities", () => {
         expect(computeMaxWidth([])).toBe(0);
     });
     test("padLine adds padding when needed", () => {
-        const padded = padLine(lineA, 10, "red");
+        const padded = padLine(lineA, 10, { color: "red" });
         expect(getLineLength(padded)).toBe(10);
-        expect(padded.segments[1].style).toBe("red");
+        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, "red");
+        const ignored = padLine(lineB, 5, { color: "red" });
         expect(getLineLength(ignored)).toBe(7);
         expect(ignored.segments.length).toBe(1);
     });