@heinrichb/console-toolkit 1.0.3 → 1.0.6

package/dist/presets/ascii.js

@@ -0,0 +1,35 @@
+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

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

package/dist/presets/ascii.test.js

@@ -0,0 +1,21 @@
+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");
+            }
+        }
+    });
+});

package/package.json

@@ -1,44 +1,46 @@
-{
-	"name": "@heinrichb/console-toolkit",
-	"version": "1.0.3",
-	"description": "A versatile TypeScript utility library for enhanced console logging, formatting, and layout management.",
-	"type": "module",
-	"main": "./dist/index.js",
-	"module": "./dist/index.js",
-	"types": "./dist/index.d.ts",
-	"publishConfig": {
-		"access": "public"
-	},
-	"files": [
-		"dist"
-	],
-	"scripts": {
-		"demo": "bun run scripts/run-demo.ts",
-		"test": "bun run build && bun test src",
-		"test:coverage": "bun run build && bun test src --coverage --coverage-threshold=100",
-		"build": "bun x tsc",
-		"publish": "npm publish",
-		"format:check": "prettier --check \"src/**/*.{ts,json,md}\"",
-		"format:write": "prettier --write \"src/**/*.{ts,json,md}\"",
-		"lint": "eslint \"src/**/*.ts\"",
-		"tree": "tree -a -I '.git|node_modules|dist'"
-	},
-	"prettier": {
-		"printWidth": 128,
-		"tabWidth": 2,
-		"trailingComma": "none",
-		"bracketSameLine": true,
-		"semi": true,
-		"singleQuote": false,
-		"useTabs": true
-	},
-	"devDependencies": {
-		"@eslint/js": "^9.0.0",
-		"@types/bun": "latest",
-		"eslint": "^9.0.0",
-		"eslint-config-prettier": "^10.1.8",
-		"prettier": "^3.5.3",
-		"typescript": "^5",
-		"typescript-eslint": "^8.56.1"
-	}
-}
+{
+	"name": "@heinrichb/console-toolkit",
+	"version": "1.0.6",
+	"description": "A versatile TypeScript utility library for enhanced console logging, formatting, and layout management.",
+	"type": "module",
+	"main": "./dist/index.js",
+	"module": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"publishConfig": {
+		"access": "public"
+	},
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"demo": "bun run scripts/run-demo.ts",
+		"test": "bun run build && bun test src",
+		"test:coverage": "bun run build && bun test src --coverage --coverage-threshold=100",
+		"build": "bun x tsc",
+		"publish": "npm publish",
+		"format:check": "prettier --check \"src/**/*.{ts,json,md}\"",
+		"format:write": "prettier --write \"src/**/*.{ts,json,md}\"",
+		"lint": "eslint \"src/**/*.ts\"",
+		"tree": "tree -a -I '.git|node_modules|dist'"
+	},
+	"prettier": {
+		"printWidth": 128,
+		"tabWidth": 2,
+		"trailingComma": "none",
+		"bracketSameLine": true,
+		"semi": true,
+		"singleQuote": false,
+		"useTabs": true
+	},
+	"devDependencies": {
+		"@eslint/js": "^10.0.1",
+		"@types/bun": "^1.3.9",
+		"eslint": "^10.0.2",
+		"eslint-config-prettier": "^10.1.8",
+		"globals": "^17.3.0",
+		"jiti": "^2.6.1",
+		"prettier": "^3.8.1",
+		"typescript": "^5.9.3",
+		"typescript-eslint": "^8.56.1"
+	}
+}

package/dist/index.test.js

@@ -1,126 +0,0 @@
-import { expect, test, describe, spyOn, afterEach } from "bun:test";
-import { hexToRgb, rgbToAnsi, hexToAnsi, interpolateColor, getLineLength, computeMaxWidth, padLine, Printer, printDualColumn, getDragonLines, mergeColumns, resolveStyle } from "./index";
-const lineA = { segments: [{ text: "Hello", style: [] }] };
-const lineB = { segments: [{ text: "World!!", style: [] }] };
-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("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");
-    });
-    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("interpolateColor returns hex string", () => {
-        const start = "#000000";
-        const end = "#ffffff";
-        expect(interpolateColor(start, end, 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("resolveStyle handles modifiers", () => {
-        expect(resolveStyle("bold")).toBe("\x1b[1m");
-        expect(resolveStyle("reset")).toBe("\x1b[0m");
-    });
-    test("resolveStyle handles hex colors", () => {
-        expect(resolveStyle("#FF0000")).toBe("\x1b[38;2;255;0;0m");
-    });
-    test("resolveStyle handles arrays of styles", () => {
-        expect(resolveStyle(["bold", "red"])).toBe("\x1b[1m\x1b[31m");
-    });
-    test("resolveStyle passes through raw strings", () => {
-        const raw = "\x1b[31m";
-        expect(resolveStyle(raw)).toBe(raw);
-        expect(resolveStyle("unknown")).toBe("unknown");
-    });
-});
-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, "red");
-        expect(getLineLength(padded)).toBe(10);
-        expect(padded.segments[1].style).toBe("red");
-        expect(padded.segments[1].text).toBe("     ");
-    });
-    test("padLine does nothing if line is already wide enough", () => {
-        const ignored = padLine(lineB, 5, "red");
-        expect(getLineLength(ignored)).toBe(7);
-        expect(ignored.segments.length).toBe(1);
-    });
-    test("mergeColumns handles asymmetric column lengths", () => {
-        const merged = mergeColumns([lineA], [lineB, lineB], 10, " | ", "");
-        expect(merged.length).toBe(2);
-        expect(getLineLength(merged[1])).toBe(10 + 3 + 7);
-    });
-});
-describe("Printer & Layout", () => {
-    const stdoutSpy = spyOn(process.stdout, "write").mockImplementation(() => true);
-    afterEach(() => {
-        stdoutSpy.mockClear();
-    });
-    test("Printer.print outputs to console with resolved styles", () => {
-        const printer = new Printer();
-        printer.print([{ segments: [{ text: "Test", style: "red" }] }]);
-        expect(stdoutSpy).toHaveBeenCalled();
-        const output = stdoutSpy.mock.calls[0][0];
-        expect(output).toContain("\x1b[31mTest");
-    });
-    test("Printer handles interactive clearing", () => {
-        const printer = new Printer({ interactive: true });
-        printer.print([{ segments: [{ text: "L1", style: "" }] }]);
-        printer.print([{ segments: [{ text: "L2", style: "" }] }]);
-        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining("\x1b[1A\x1b[2K\r"));
-    });
-    test("Printer optimizes clearing of multiple lines", () => {
-        const printer = new Printer({ interactive: true });
-        printer.print([
-            { segments: [{ text: "L1", style: "" }] },
-            { segments: [{ text: "L2", style: "" }] },
-            { segments: [{ text: "L3", style: "" }] }
-        ]);
-        stdoutSpy.mockClear();
-        printer.print([{ segments: [{ text: "New", style: "" }] }]);
-        const clearSeq = "\x1b[1A\x1b[2K\r";
-        const expectedClear = clearSeq.repeat(3);
-        expect(stdoutSpy).toHaveBeenCalledTimes(1);
-        const callArg = stdoutSpy.mock.calls[0][0];
-        expect(callArg.startsWith(expectedClear)).toBe(true);
-    });
-    test("printDualColumn executes correctly", () => {
-        printDualColumn([lineA], [lineB]);
-        expect(stdoutSpy).toHaveBeenCalled();
-        const output = stdoutSpy.mock.calls[0][0];
-        expect(output).toContain("Hello");
-        expect(output).toContain("World!!");
-    });
-    test("getDragonLines returns valid array", () => {
-        const lines = getDragonLines();
-        expect(lines.length).toBeGreaterThan(0);
-        const firstSegmentStyle = lines[0].segments[0].style;
-        expect(firstSegmentStyle.startsWith("#")).toBe(true);
-    });
-});