hexlogger 1.0.0

package/index.js

@@ -0,0 +1,23 @@
+const { Colors, rgb, bgrgb, hexclr, bghex } = require("./src/colors");
+const { Theme, THEMES, LEVEL_ICONS } = require("./src/themes");
+const { LogLevel, LoggerConfig, getConfig, settheme, setstyle, setlog, setlevel } = require("./src/config");
+const { debug, info, success, warn, warning, error, critical, fatal, trace } = require("./src/core");
+const { divider, section, blank, rule, banner, pair } = require("./src/formatting");
+const { gtext, gprint, mgtext, mgprint, rbtext, rbprint } = require("./src/gradient");
+const { panel, table, box } = require("./src/widgets");
+const { Progress, Spinner, Timer } = require("./src/progress");
+const { stripAnsi, clr, bold, italic, uline } = require("./src/utils");
+
+module.exports = {
+    __version__: "1.0.0",
+    __author__: "Montage",
+    Colors, rgb, bgrgb, hexclr, bghex,
+    Theme, THEMES, LEVEL_ICONS, LogLevel, LoggerConfig, getConfig,
+    settheme, setstyle, setlog, setlevel,
+    debug, info, success, warn, warning, error, critical, fatal, trace,
+    divider, section, blank, rule, banner, pair,
+    gtext, gprint, mgtext, mgprint, rbtext, rbprint,
+    panel, table, box,
+    Progress, Spinner, Timer,
+    stripAnsi, clr, bold, italic, uline,
+};

package/package.json

@@ -0,0 +1,38 @@
+{
+    "name": "hexlogger",
+    "version": "1.0.0",
+    "description": "Premium console logging library with themes, gradients, panels, tables, progress bars, and spinners.",
+    "main": "index.js",
+    "exports": {
+        ".": "./index.js"
+    },
+    "keywords": [
+        "logger",
+        "logging",
+        "console",
+        "colors",
+        "terminal",
+        "ansi",
+        "themes",
+        "gradient",
+        "spinner",
+        "progress",
+        "table",
+        "panel",
+        "box",
+        "cli"
+    ],
+    "author": "Montage",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": ""
+    },
+    "engines": {
+        "node": ">=14.0.0"
+    },
+    "files": [
+        "index.js",
+        "src/"
+    ]
+}

package/src/colors.js

@@ -0,0 +1,79 @@
+const R = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const ITALIC = "\x1b[3m";
+const UNDERLINE = "\x1b[4m";
+const BLINK = "\x1b[5m";
+const REVERSE = "\x1b[7m";
+const STRIKE = "\x1b[9m";
+const BLACK = "\x1b[30m";
+const RED = "\x1b[31m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const BLUE = "\x1b[34m";
+const MAGENTA = "\x1b[35m";
+const CYAN = "\x1b[36m";
+const WHITE = "\x1b[37m";
+const GRAY = "\x1b[90m";
+const BRIGHT_RED = "\x1b[91m";
+const BRIGHT_GREEN = "\x1b[92m";
+const BRIGHT_YELLOW = "\x1b[93m";
+const BRIGHT_BLUE = "\x1b[94m";
+const BRIGHT_MAGENTA = "\x1b[95m";
+const BRIGHT_CYAN = "\x1b[96m";
+const BRIGHT_WHITE = "\x1b[97m";
+const BG_BLACK = "\x1b[40m";
+const BG_RED = "\x1b[41m";
+const BG_GREEN = "\x1b[42m";
+const BG_YELLOW = "\x1b[43m";
+const BG_BLUE = "\x1b[44m";
+const BG_MAGENTA = "\x1b[45m";
+const BG_CYAN = "\x1b[46m";
+const BG_WHITE = "\x1b[47m";
+
+const Colors = {
+    RESET: R, BOLD, DIM, ITALIC, UNDERLINE, BLINK, REVERSE, STRIKE,
+    BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE, GRAY,
+    BRIGHT_RED, BRIGHT_GREEN, BRIGHT_YELLOW, BRIGHT_BLUE,
+    BRIGHT_MAGENTA, BRIGHT_CYAN, BRIGHT_WHITE,
+    BG_BLACK, BG_RED, BG_GREEN, BG_YELLOW, BG_BLUE,
+    BG_MAGENTA, BG_CYAN, BG_WHITE,
+};
+
+function _clamp(v) {
+    return Math.max(0, Math.min(255, Math.floor(Number(v) || 0)));
+}
+
+function rgb(r, g, b) {
+    return `\x1b[38;2;${_clamp(r)};${_clamp(g)};${_clamp(b)}m`;
+}
+
+function bgrgb(r, g, b) {
+    return `\x1b[48;2;${_clamp(r)};${_clamp(g)};${_clamp(b)}m`;
+}
+
+function hexclr(hex) {
+    try {
+        hex = String(hex).replace(/^#/, "");
+        if (hex.length < 6) hex = hex.padEnd(6, "0");
+        const r = parseInt(hex.slice(0, 2), 16);
+        const g = parseInt(hex.slice(2, 4), 16);
+        const b = parseInt(hex.slice(4, 6), 16);
+        if (isNaN(r) || isNaN(g) || isNaN(b)) return R;
+        return rgb(r, g, b);
+    } catch { return R; }
+}
+
+function bghex(hex) {
+    try {
+        hex = String(hex).replace(/^#/, "");
+        if (hex.length < 6) hex = hex.padEnd(6, "0");
+        const r = parseInt(hex.slice(0, 2), 16);
+        const g = parseInt(hex.slice(2, 4), 16);
+        const b = parseInt(hex.slice(4, 6), 16);
+        if (isNaN(r) || isNaN(g) || isNaN(b)) return R;
+        return bgrgb(r, g, b);
+    } catch { return R; }
+}
+
+module.exports = { Colors, rgb, bgrgb, hexclr, bghex, _clamp };

package/src/config.js

@@ -0,0 +1,62 @@
+const fs = require("fs");
+const { Theme, THEMES } = require("./themes");
+const { STYLES } = require("./styles");
+
+const LogLevel = { TRACE: 0, DEBUG: 1, INFO: 2, SUCCESS: 3, WARNING: 4, ERROR: 5, CRITICAL: 6, FATAL: 7 };
+
+class LoggerConfig {
+    constructor() {
+        this.theme = THEMES.default || new Theme("default", {});
+        this.style = "default";
+        this.timeFormat = "HH:mm:ss";
+        this.showTime = true;
+        this.logFile = null;
+        this.minLevel = LogLevel.TRACE;
+        this._stream = null;
+    }
+    setTheme(name) {
+        if (THEMES[name]) this.theme = THEMES[name];
+        else throw new Error(`Unknown theme: ${name}. Available: ${Object.keys(THEMES).join(", ")}`);
+    }
+    setStyle(name) {
+        if (STYLES[name]) this.style = name;
+        else throw new Error(`Unknown style: ${name}. Available: ${Object.keys(STYLES).join(", ")}`);
+    }
+    addTheme(name, colors) {
+        try {
+            const t = new Theme(String(name), typeof colors === "object" ? colors : {});
+            THEMES[String(name)] = t;
+            return t;
+        } catch { throw new Error(`Failed to add theme: ${name}`); }
+    }
+    setLogFile(path) {
+        try {
+            this.logFile = String(path);
+            if (this._stream) { try { this._stream.end(); } catch { } }
+            this._stream = fs.createWriteStream(this.logFile, { flags: "a", encoding: "utf-8" });
+        } catch { this._stream = null; throw new Error(`Failed to open log file: ${path}`); }
+    }
+    close() {
+        if (this._stream) { try { this._stream.end(); } catch { } this._stream = null; }
+    }
+}
+
+const _config = new LoggerConfig();
+
+function getConfig() { return _config; }
+
+function settheme(name) { _config.setTheme(String(name)); }
+function setstyle(name) { _config.setStyle(String(name)); }
+function setlog(path) { _config.setLogFile(String(path)); }
+function setlevel(level) {
+    const mapping = {
+        trace: LogLevel.TRACE, debug: LogLevel.DEBUG, info: LogLevel.INFO,
+        success: LogLevel.SUCCESS, warning: LogLevel.WARNING, error: LogLevel.ERROR,
+        critical: LogLevel.CRITICAL, fatal: LogLevel.FATAL,
+    };
+    const key = String(level).toLowerCase().trim();
+    if (mapping[key] !== undefined) _config.minLevel = mapping[key];
+    else throw new Error(`Unknown level: ${level}. Available: ${Object.keys(mapping).join(", ")}`);
+}
+
+module.exports = { LogLevel, LoggerConfig, getConfig, settheme, setstyle, setlog, setlevel };

package/src/core.js

@@ -0,0 +1,49 @@
+const { getConfig, LogLevel } = require("./config");
+const { STYLES } = require("./styles");
+const { stripAnsi } = require("./utils");
+
+function _getTime() {
+    try {
+        const d = new Date();
+        const pad = (n) => String(n).padStart(2, "0");
+        return `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+    } catch { return ""; }
+}
+
+function _writeToFile(message) {
+    const cfg = getConfig();
+    if (cfg._stream) {
+        try { cfg._stream.write(stripAnsi(message) + "\n"); }
+        catch { }
+    }
+}
+
+function _log(level, message, levelValue) {
+    try {
+        const cfg = getConfig();
+        if (levelValue < cfg.minLevel) return;
+        const t = cfg.theme;
+        const now = _getTime();
+        const lc = t.get(level);
+        const ll = t.get(`label_${level}`);
+        const styleFn = STYLES[cfg.style] || STYLES.default;
+        const line = styleFn(now, level, lc, ll, String(message), t, cfg.showTime);
+        process.stdout.write(line + "\n");
+        _writeToFile(line);
+    } catch {
+        try { process.stdout.write(`[${level.toUpperCase()}] ${message}\n`); }
+        catch { }
+    }
+}
+
+function debug(msg) { _log("debug", msg, LogLevel.DEBUG); }
+function info(msg) { _log("info", msg, LogLevel.INFO); }
+function success(msg) { _log("success", msg, LogLevel.SUCCESS); }
+function warn(msg) { _log("warning", msg, LogLevel.WARNING); }
+function warning(msg) { _log("warning", msg, LogLevel.WARNING); }
+function error(msg) { _log("error", msg, LogLevel.ERROR); }
+function critical(msg) { _log("critical", msg, LogLevel.CRITICAL); }
+function fatal(msg) { _log("fatal", msg, LogLevel.FATAL); }
+function trace(msg) { _log("trace", msg, LogLevel.TRACE); }
+
+module.exports = { debug, info, success, warn, warning, error, critical, fatal, trace };

package/src/formatting.js

@@ -0,0 +1,84 @@
+const { Colors } = require("./colors");
+const { getConfig } = require("./config");
+const { stripAnsi } = require("./utils");
+
+function _write(message) {
+    const cfg = getConfig();
+    if (cfg._stream) {
+        try { cfg._stream.write(stripAnsi(message) + "\n"); }
+        catch { }
+    }
+}
+
+function divider(char = "─", length = 60, color = null) {
+    try {
+        const cfg = getConfig();
+        const c = color || cfg.theme.get("divider");
+        length = Math.max(1, Math.floor(length));
+        const ch = String(char)[0] || "─";
+        const line = `${c}${ch.repeat(length)}${Colors.RESET}`;
+        process.stdout.write(line + "\n");
+        _write(line);
+    } catch { process.stdout.write((String(char)[0] || "─").repeat(Math.max(1, length)) + "\n"); }
+}
+
+function section(title = "", char = "═", length = 60) {
+    try {
+        const cfg = getConfig();
+        const t = cfg.theme;
+        title = String(title);
+        length = Math.max(title.length + 4, Math.floor(length));
+        const pad = length - title.length - 2;
+        const left = Math.floor(pad / 2);
+        const right = pad - left;
+        const ch = String(char)[0] || "═";
+        const line = `${t.get("divider")}${ch.repeat(left)}${Colors.RESET} ${Colors.BOLD}${t.get("info")}${title}${Colors.RESET} ${t.get("divider")}${ch.repeat(right)}${Colors.RESET}`;
+        process.stdout.write(line + "\n");
+        _write(line);
+    } catch { process.stdout.write(`== ${title} ==\n`); }
+}
+
+function blank(count = 1) {
+    for (let i = 0; i < Math.max(1, Math.floor(count)); i++) process.stdout.write("\n");
+}
+
+function rule(text = "", char = "─", length = 60) {
+    if (text) section(text, char, length);
+    else divider(char, length);
+}
+
+function banner(text = "", char = "═", padding = 2) {
+    try {
+        const cfg = getConfig();
+        text = String(text);
+        padding = Math.max(0, Math.floor(padding));
+        const lines = text.split("\n");
+        const maxLen = Math.max(...lines.map(l => l.length), 0);
+        const width = maxLen + (padding * 2) + 2;
+        const t = cfg.theme;
+        const bc = t.get("info"), tc = t.get("success"), R = Colors.RESET;
+        const ch = String(char)[0] || "═";
+        process.stdout.write(`${bc}╔${ch.repeat(width - 2)}╗${R}\n`);
+        for (const l of lines) {
+            const pad2 = maxLen - l.length;
+            const lp = Math.floor(pad2 / 2);
+            const rp = pad2 - lp;
+            process.stdout.write(`${bc}║${R}${" ".repeat(padding)}${tc}${" ".repeat(lp)}${l}${" ".repeat(rp)}${R}${" ".repeat(padding)}${bc}║${R}\n`);
+        }
+        process.stdout.write(`${bc}╚${ch.repeat(width - 2)}╝${R}\n`);
+    } catch { process.stdout.write(text + "\n"); }
+}
+
+function pair(k, v, kClr = null, vClr = null) {
+    try {
+        const cfg = getConfig();
+        const kc = kClr || cfg.theme.get("info");
+        const vc = vClr || Colors.RESET;
+        k = String(k); v = String(v);
+        const line = `  ${kc}${Colors.BOLD}${k}${Colors.RESET}: ${vc}${v}${Colors.RESET}`;
+        process.stdout.write(line + "\n");
+        _write(`  ${k}: ${v}`);
+    } catch { process.stdout.write(`  ${k}: ${v}\n`); }
+}
+
+module.exports = { divider, section, blank, rule, banner, pair };

package/src/gradient.js

@@ -0,0 +1,56 @@
+const { Colors, rgb } = require("./colors");
+
+const _RAINBOW = [[255, 0, 0], [255, 127, 0], [255, 255, 0], [0, 255, 0], [0, 127, 255], [75, 0, 130], [148, 0, 211]];
+
+function _interp(c1, c2, t) {
+    t = Math.max(0, Math.min(1, t));
+    return [
+        Math.floor(c1[0] + (c2[0] - c1[0]) * t),
+        Math.floor(c1[1] + (c2[1] - c1[1]) * t),
+        Math.floor(c1[2] + (c2[2] - c1[2]) * t),
+    ];
+}
+
+function gtext(text, start = [255, 0, 100], end = [100, 0, 255]) {
+    try {
+        text = String(text);
+        if (!text) return "";
+        const len = Math.max(text.length - 1, 1);
+        let res = "";
+        for (let i = 0; i < text.length; i++) {
+            const [r, g, b] = _interp(start, end, i / len);
+            res += `${rgb(r, g, b)}${text[i]}`;
+        }
+        return res + Colors.RESET;
+    } catch { return String(text); }
+}
+
+function gprint(text, start = [255, 0, 100], end = [100, 0, 255]) {
+    process.stdout.write(gtext(text, start, end) + "\n");
+}
+
+function mgtext(text, colors = null) {
+    try {
+        text = String(text);
+        if (!colors || colors.length < 2 || !text) return text;
+        const segments = colors.length - 1;
+        const cps = Math.max(text.length / segments, 1);
+        let res = "";
+        for (let i = 0; i < text.length; i++) {
+            const seg = Math.min(Math.floor(i / cps), segments - 1);
+            const t = (i - seg * cps) / cps;
+            const [r, g, b] = _interp(colors[seg], colors[seg + 1], t);
+            res += `${rgb(r, g, b)}${text[i]}`;
+        }
+        return res + Colors.RESET;
+    } catch { return String(text); }
+}
+
+function mgprint(text, colors = null) {
+    process.stdout.write(mgtext(text, colors) + "\n");
+}
+
+function rbtext(text) { return mgtext(text, _RAINBOW); }
+function rbprint(text) { process.stdout.write(rbtext(text) + "\n"); }
+
+module.exports = { gtext, gprint, mgtext, mgprint, rbtext, rbprint };

package/src/progress.js

@@ -0,0 +1,97 @@
+const { Colors } = require("./colors");
+const { getConfig } = require("./config");
+
+class Progress {
+    constructor(total, width = 30, label = "Progress", fill = "█", empty = "░", color = null) {
+        this.total = Math.max(1, Math.floor(total) || 1);
+        this.width = Math.max(5, Math.floor(width));
+        this.label = String(label);
+        this.fill = String(fill)[0] || "█";
+        this.empty = String(empty)[0] || "░";
+        try { this.color = color || getConfig().theme.get("success"); }
+        catch { this.color = ""; }
+        this.current = 0;
+        this._start = Date.now();
+    }
+    update(n = 1) {
+        this.current = Math.min(this.current + Math.max(0, Math.floor(n)), this.total);
+        this._render();
+    }
+    _render() {
+        try {
+            const pct = this.current / this.total;
+            const filled = Math.floor(this.width * pct);
+            const bar = this.fill.repeat(filled) + this.empty.repeat(this.width - filled);
+            const elapsed = (Date.now() - this._start) / 1000;
+            const eta = pct > 0 ? (elapsed / pct - elapsed) : 0;
+            process.stdout.write(
+                `\r${this.color}${this.label}${Colors.RESET} ` +
+                `│${this.color}${bar}${Colors.RESET}│ ` +
+                `${Colors.BOLD}${(pct * 100).toFixed(1).padStart(5)}%${Colors.RESET} ` +
+                `(${this.current}/${this.total}) ` +
+                `[${elapsed.toFixed(1)}s / ETA ${eta.toFixed(1)}s]`
+            );
+            if (this.current >= this.total) process.stdout.write("\n");
+        } catch { }
+    }
+}
+
+class Spinner {
+    constructor(msg = "Loading", style = "dots", color = null) {
+        this.msg = String(msg);
+        this.frames = ({
+            dots: ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"],
+            line: ["-", "\\", "|", "/"],
+            arrow: ["←", "↖", "↑", "↗", "→", "↘", "↓", "↙"],
+            bounce: ["⠁", "⠂", "⠄", "⠂"],
+            box: ["▖", "▘", "▝", "▗"],
+            circle: ["◐", "◓", "◑", "◒"],
+        })[style] || ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+        try { this.color = color || getConfig().theme.get("info"); }
+        catch { this.color = ""; }
+        this._run = false;
+        this._timer = null;
+        this._i = 0;
+    }
+    start() {
+        this._run = true;
+        this._i = 0;
+        this._timer = setInterval(() => {
+            try {
+                const frame = this.frames[this._i % this.frames.length];
+                process.stdout.write(`\r${this.color}${frame}${Colors.RESET} ${this.msg}`);
+                this._i++;
+            } catch { }
+        }, 80);
+        return this;
+    }
+    stop(final = "") {
+        this._run = false;
+        if (this._timer) { clearInterval(this._timer); this._timer = null; }
+        try { process.stdout.write("\r" + " ".repeat(this.msg.length + 10) + "\r"); }
+        catch { }
+        if (final) {
+            try { const { success } = require("./core"); success(final); }
+            catch { process.stdout.write(final + "\n"); }
+        }
+    }
+}
+
+class Timer {
+    constructor(label = "Elapsed") {
+        this.label = String(label);
+        this._start = null;
+    }
+    start() { this._start = Date.now(); return this; }
+    stop() {
+        try {
+            if (this._start === null) return 0;
+            const elapsed = (Date.now() - this._start) / 1000;
+            const { info } = require("./core");
+            info(`${this.label}: ${elapsed.toFixed(3)}s`);
+            return elapsed;
+        } catch { return 0; }
+    }
+}
+
+module.exports = { Progress, Spinner, Timer };

package/src/styles.js

@@ -0,0 +1,74 @@
+const { Colors, bgrgb } = require("./colors");
+const { LEVEL_ICONS } = require("./themes");
+
+const _TAG_BG = {
+    debug: bgrgb(50, 80, 120), info: bgrgb(40, 70, 130),
+    success: bgrgb(30, 100, 50), warning: bgrgb(130, 100, 0),
+    error: bgrgb(130, 30, 30), critical: bgrgb(150, 20, 20),
+    fatal: bgrgb(120, 0, 0), trace: bgrgb(60, 60, 60),
+};
+
+function _ljust(s, w) { s = String(s); return s.length >= w ? s : s + " ".repeat(w - s.length); }
+
+const R = Colors.RESET, B = Colors.BOLD;
+
+function _default(now, level, lc, ll, msg, t, st) {
+    const br = t.get("bracket"), ts = t.get("timestamp"), dt = t.get("dot"), sep = t.get("separator");
+    if (st) return `${br}[-(${ts}${now}${R}${br})-]${R} ${br}[${R} ${dt}●${R} ${br}]${R} ${B}${lc}${ll}${R} ${sep}»${R}  ${lc}${msg}${R}`;
+    return `${br}[${R} ${dt}●${R} ${br}]${R} ${B}${lc}${ll}${R} ${sep}»${R}  ${lc}${msg}${R}`;
+}
+
+function _box(now, level, lc, ll, msg, t, st) {
+    const br = t.get("bracket"), ts = t.get("timestamp"), icon = LEVEL_ICONS[level] || "●", lbl = _ljust(ll, 8);
+    if (st) return `${br}┃${R} ${ts}${now}${R} ${br}│${R} ${lc}${icon}${R} ${B}${lc}${lbl}${R} ${br}│${R} ${lc}${msg}${R}`;
+    return `${br}┃${R} ${lc}${icon}${R} ${B}${lc}${lbl}${R} ${br}│${R} ${lc}${msg}${R}`;
+}
+
+function _modern(now, level, lc, ll, msg, t, st) {
+    const ts = t.get("timestamp"), icon = LEVEL_ICONS[level] || "●";
+    if (st) return `${ts}${now}${R}  ${lc}${icon} ${B}${ll}${R}  ${lc}${msg}${R}`;
+    return `${lc}${icon} ${B}${ll}${R}  ${lc}${msg}${R}`;
+}
+
+function _bracket(now, level, lc, ll, msg, t, st) {
+    const br = t.get("bracket"), ts = t.get("timestamp");
+    if (st) return `${br}[${ts}${now}${R}${br}]${R} ${br}[${B}${lc}${ll}${R}${br}]${R} ${lc}${msg}${R}`;
+    return `${br}[${B}${lc}${ll}${R}${br}]${R} ${lc}${msg}${R}`;
+}
+
+function _arrow(now, level, lc, ll, msg, t, st) {
+    const ts = t.get("timestamp"), sep = t.get("separator");
+    if (st) return `${ts}${now}${R} ${sep}▸${R} ${B}${lc}${ll}${R} ${sep}▸${R} ${lc}${msg}${R}`;
+    return `${sep}▸${R} ${B}${lc}${ll}${R} ${sep}▸${R} ${lc}${msg}${R}`;
+}
+
+function _pipe(now, level, lc, ll, msg, t, st) {
+    const ts = t.get("timestamp"), br = t.get("bracket"), lbl = _ljust(ll, 8);
+    if (st) return `${lc}▌${R} ${ts}${now}${R} ${br}|${R} ${B}${lc}${lbl}${R} ${br}|${R} ${lc}${msg}${R}`;
+    return `${lc}▌${R} ${B}${lc}${lbl}${R} ${br}|${R} ${lc}${msg}${R}`;
+}
+
+function _tag(now, level, lc, ll, msg, t, st) {
+    const ts = t.get("timestamp"), bg = _TAG_BG[level] || "";
+    if (st) return `${ts}${now}${R} ${bg}${B} ${ll} ${R} ${lc}${msg}${R}`;
+    return `${bg}${B} ${ll} ${R} ${lc}${msg}${R}`;
+}
+
+function _dots(now, level, lc, ll, msg, t, st) {
+    const ts = t.get("timestamp"), sep = t.get("separator"), icon = LEVEL_ICONS[level] || "●";
+    if (st) return `${lc}${icon}${R} ${ts}${now}${R} ${sep}·${R} ${B}${lc}${ll}${R} ${sep}·${R} ${lc}${msg}${R}`;
+    return `${lc}${icon} ${B}${lc}${ll}${R} ${sep}·${R} ${lc}${msg}${R}`;
+}
+
+function _clean(now, level, lc, ll, msg, t, st) {
+    const ts = t.get("timestamp"), lbl = _ljust(ll, 8);
+    if (st) return `  ${ts}${now}${R}  ${B}${lc}${lbl}${R}  ${lc}${msg}${R}`;
+    return `  ${B}${lc}${lbl}${R}  ${lc}${msg}${R}`;
+}
+
+const STYLES = {
+    default: _default, box: _box, modern: _modern, bracket: _bracket,
+    arrow: _arrow, pipe: _pipe, tag: _tag, dots: _dots, clean: _clean,
+};
+
+module.exports = { STYLES };

package/src/themes.js

@@ -0,0 +1,82 @@
+const { Colors, rgb } = require("./colors");
+
+class Theme {
+    constructor(name, colors) {
+        this.name = String(name);
+        this.colors = (colors && typeof colors === "object") ? colors : {};
+    }
+    get(key) {
+        try { return this.colors[key] !== undefined ? this.colors[key] : Colors.RESET; }
+        catch { return Colors.RESET; }
+    }
+}
+
+const THEMES = {
+    default: new Theme("default", {
+        timestamp: rgb(100, 100, 100), bracket: rgb(70, 70, 70), dot: rgb(255, 255, 255),
+        separator: rgb(100, 100, 100), debug: rgb(138, 180, 248), info: rgb(130, 170, 255),
+        success: rgb(80, 230, 120), warning: rgb(255, 200, 60), error: rgb(255, 85, 85),
+        critical: rgb(255, 50, 50), fatal: rgb(200, 0, 0), trace: rgb(160, 160, 160),
+        divider: rgb(60, 60, 60),
+        label_debug: "DEBUG", label_info: "INFO", label_success: "SUCCESS",
+        label_warning: "WARNING", label_error: "ERROR", label_critical: "CRITICAL",
+        label_fatal: "FATAL", label_trace: "TRACE",
+    }),
+    neon: new Theme("neon", {
+        timestamp: rgb(0, 255, 200), bracket: rgb(0, 200, 150), dot: rgb(0, 255, 255),
+        separator: rgb(0, 180, 180), debug: rgb(0, 200, 255), info: rgb(0, 255, 200),
+        success: rgb(0, 255, 100), warning: rgb(255, 255, 0), error: rgb(255, 50, 80),
+        critical: rgb(255, 0, 100), fatal: rgb(200, 0, 50), trace: rgb(100, 200, 200),
+        divider: rgb(0, 100, 100),
+        label_debug: "DEBUG", label_info: "INFO", label_success: "SUCCESS",
+        label_warning: "WARNING", label_error: "ERROR", label_critical: "CRITICAL",
+        label_fatal: "FATAL", label_trace: "TRACE",
+    }),
+    minimal: new Theme("minimal", {
+        timestamp: rgb(120, 120, 120), bracket: rgb(80, 80, 80), dot: rgb(180, 180, 180),
+        separator: rgb(100, 100, 100), debug: rgb(150, 150, 150), info: rgb(200, 200, 200),
+        success: rgb(100, 200, 100), warning: rgb(200, 180, 80), error: rgb(200, 80, 80),
+        critical: rgb(220, 50, 50), fatal: rgb(180, 0, 0), trace: rgb(120, 120, 120),
+        divider: rgb(60, 60, 60),
+        label_debug: "DBG", label_info: "INF", label_success: "OK",
+        label_warning: "WRN", label_error: "ERR", label_critical: "CRT",
+        label_fatal: "FTL", label_trace: "TRC",
+    }),
+    hacker: new Theme("hacker", {
+        timestamp: rgb(0, 180, 0), bracket: rgb(0, 120, 0), dot: rgb(0, 255, 0),
+        separator: rgb(0, 150, 0), debug: rgb(0, 200, 0), info: rgb(0, 255, 0),
+        success: rgb(50, 255, 50), warning: rgb(200, 255, 0), error: rgb(255, 100, 0),
+        critical: rgb(255, 50, 0), fatal: rgb(255, 0, 0), trace: rgb(0, 150, 0),
+        divider: rgb(0, 80, 0),
+        label_debug: "DEBUG", label_info: "INFO", label_success: "SUCCESS",
+        label_warning: "WARNING", label_error: "ERROR", label_critical: "CRITICAL",
+        label_fatal: "FATAL", label_trace: "TRACE",
+    }),
+    sunset: new Theme("sunset", {
+        timestamp: rgb(255, 150, 50), bracket: rgb(200, 100, 50), dot: rgb(255, 200, 100),
+        separator: rgb(200, 120, 60), debug: rgb(255, 180, 100), info: rgb(255, 160, 80),
+        success: rgb(255, 220, 50), warning: rgb(255, 120, 30), error: rgb(255, 60, 60),
+        critical: rgb(200, 30, 30), fatal: rgb(150, 0, 0), trace: rgb(200, 150, 100),
+        divider: rgb(150, 80, 40),
+        label_debug: "DEBUG", label_info: "INFO", label_success: "SUCCESS",
+        label_warning: "WARNING", label_error: "ERROR", label_critical: "CRITICAL",
+        label_fatal: "FATAL", label_trace: "TRACE",
+    }),
+    ocean: new Theme("ocean", {
+        timestamp: rgb(0, 150, 200), bracket: rgb(0, 100, 160), dot: rgb(0, 200, 255),
+        separator: rgb(0, 130, 180), debug: rgb(100, 180, 255), info: rgb(0, 200, 255),
+        success: rgb(0, 255, 200), warning: rgb(255, 220, 80), error: rgb(255, 80, 100),
+        critical: rgb(255, 40, 80), fatal: rgb(200, 0, 50), trace: rgb(80, 150, 200),
+        divider: rgb(0, 80, 120),
+        label_debug: "DEBUG", label_info: "INFO", label_success: "SUCCESS",
+        label_warning: "WARNING", label_error: "ERROR", label_critical: "CRITICAL",
+        label_fatal: "FATAL", label_trace: "TRACE",
+    }),
+};
+
+const LEVEL_ICONS = {
+    debug: "●", info: "ℹ", success: "✓", warning: "⚠",
+    error: "✗", critical: "☠", fatal: "💀", trace: "→",
+};
+
+module.exports = { Theme, THEMES, LEVEL_ICONS };

package/src/utils.js

@@ -0,0 +1,15 @@
+const { Colors } = require("./colors");
+
+const _ANSI_RE = /\x1b\[[0-9;]*m/g;
+
+function stripAnsi(text) {
+    try { return String(text).replace(_ANSI_RE, ""); }
+    catch { return String(text); }
+}
+
+function clr(text, color) { return `${color}${text}${Colors.RESET}`; }
+function bold(text) { return `${Colors.BOLD}${text}${Colors.RESET}`; }
+function italic(text) { return `${Colors.ITALIC}${text}${Colors.RESET}`; }
+function uline(text) { return `${Colors.UNDERLINE}${text}${Colors.RESET}`; }
+
+module.exports = { stripAnsi, clr, bold, italic, uline };

package/src/widgets.js

@@ -0,0 +1,116 @@
+const { Colors } = require("./colors");
+const { getConfig } = require("./config");
+const { stripAnsi } = require("./utils");
+
+const _PANEL = {
+    rounded: ["╭", "╮", "╰", "╯", "─", "│"], sharp: ["┌", "┐", "└", "┘", "─", "│"],
+    double: ["╔", "╗", "╚", "╝", "═", "║"], heavy: ["┏", "┓", "┗", "┛", "━", "┃"],
+    ascii: ["+", "+", "+", "+", "-", "|"],
+};
+const _TABLE = {
+    rounded: ["╭", "╮", "╰", "╯", "─", "│", "┬", "┴", "├", "┤", "┼"],
+    sharp: ["┌", "┐", "└", "┘", "─", "│", "┬", "┴", "├", "┤", "┼"],
+    double: ["╔", "╗", "╚", "╝", "═", "║", "╦", "╩", "╠", "╣", "╬"],
+    heavy: ["┏", "┓", "┗", "┛", "━", "┃", "┳", "┻", "┣", "┫", "╋"],
+    ascii: ["+", "+", "+", "+", "-", "|", "+", "+", "+", "+", "+"],
+};
+const _BOX = {
+    ..._PANEL,
+    stars: ["*", "*", "*", "*", "*", "*"], dashes: ["+", "+", "+", "+", "~", ":"],
+};
+
+function _ljust(s, w) { s = String(s); return s.length >= w ? s : s + " ".repeat(w - s.length); }
+
+function panel(content = "", title = "", width = 50, color = null, style = "rounded") {
+    try {
+        const cfg = getConfig();
+        const bc = color || cfg.theme.get("info"), R = Colors.RESET;
+        const [tl, tr, bl, br, h, v] = _PANEL[style] || _PANEL.rounded;
+        content = String(content);
+        const lines = content.split("\n");
+        width = Math.max(width, 8);
+        const innerW = width - 4;
+        if (title) {
+            title = String(title);
+            const hp = Math.max(width - stripAnsi(title).length - 5, 1);
+            process.stdout.write(`${bc}${tl}${h} ${Colors.BOLD}${title}${R}${bc} ${h.repeat(hp)}${tr}${R}\n`);
+        } else {
+            process.stdout.write(`${bc}${tl}${h.repeat(width - 2)}${tr}${R}\n`);
+        }
+        for (const l of lines) {
+            const pad = Math.max(innerW - stripAnsi(l).length, 0);
+            process.stdout.write(`${bc}${v}${R} ${l}${" ".repeat(pad)} ${bc}${v}${R}\n`);
+        }
+        process.stdout.write(`${bc}${bl}${h.repeat(width - 2)}${br}${R}\n`);
+    } catch { process.stdout.write(content + "\n"); }
+}
+
+function table(headers = null, rows = null, color = null, style = "rounded") {
+    try {
+        if (!headers || !headers.length) return;
+        headers = headers.map(h => String(h));
+        rows = (rows || []).map(r => r.map(c => String(c)));
+        const cfg = getConfig();
+        const bc = color || cfg.theme.get("info");
+        const hc = cfg.theme.get("success");
+        const R = Colors.RESET, B = Colors.BOLD;
+        const [tl, tr, bl, br, h, v, tm, bm, ml, mr, mm] = _TABLE[style] || _TABLE.rounded;
+        const colW = headers.map(hdr => hdr.length);
+        for (const r of rows) {
+            for (let i = 0; i < r.length; i++) {
+                if (i < colW.length) colW[i] = Math.max(colW[i], r[i].length);
+                else colW.push(r[i].length);
+            }
+        }
+        const sep = (l, m, r2, f) => `${bc}${l}${colW.map(w => f.repeat(w + 2)).join(`${m}`)}${r2}${R}`;
+        const row = (cells, c = "") => `${bc}${v}${R}` + cells.map((cell, i) => {
+            const w = i < colW.length ? colW[i] : cell.length;
+            return ` ${c}${_ljust(cell, w)}${R} `;
+        }).join(`${bc}${v}${R}`) + `${bc}${v}${R}`;
+        process.stdout.write(sep(tl, tm, tr, h) + "\n");
+        process.stdout.write(row(headers, B + hc) + "\n");
+        process.stdout.write(sep(ml, mm, mr, h) + "\n");
+        for (const r of rows) process.stdout.write(row(r) + "\n");
+        process.stdout.write(sep(bl, bm, br, h) + "\n");
+    } catch {
+        if (headers) {
+            process.stdout.write(headers.join(" | ") + "\n");
+            for (const r of (rows || [])) process.stdout.write(r.join(" | ") + "\n");
+        }
+    }
+}
+
+function box(text = "", width = null, style = "rounded", color = null, textClr = null, align = "left", padding = 1) {
+    try {
+        const cfg = getConfig();
+        const bc = color || cfg.theme.get("info");
+        const tc = textClr || Colors.RESET;
+        const R = Colors.RESET;
+        const [tl, tr, bl, br, h, v] = _BOX[style] || _BOX.rounded;
+        text = String(text);
+        padding = Math.max(0, Math.floor(padding));
+        const lines = text.split("\n");
+        const maxLine = Math.max(...lines.map(l => stripAnsi(l).length), 0);
+        let innerW = width ? (width - 4) : maxLine + (padding * 2);
+        innerW = Math.max(innerW, 1);
+        const totalW = innerW + 4;
+        process.stdout.write(`${bc}${tl}${h.repeat(totalW - 2)}${tr}${R}\n`);
+        for (const l of lines) {
+            const sLen = stripAnsi(l).length;
+            const space = Math.max(innerW - sLen, 0);
+            let padded;
+            if (align === "center") {
+                const lp = Math.floor(space / 2), rp = space - lp;
+                padded = `${" ".repeat(lp)}${tc}${l}${R}${" ".repeat(rp)}`;
+            } else if (align === "right") {
+                padded = `${" ".repeat(space)}${tc}${l}${R}`;
+            } else {
+                padded = `${tc}${l}${R}${" ".repeat(space)}`;
+            }
+            process.stdout.write(`${bc}${v}${R} ${padded} ${bc}${v}${R}\n`);
+        }
+        process.stdout.write(`${bc}${bl}${h.repeat(totalW - 2)}${br}${R}\n`);
+    } catch { process.stdout.write(text + "\n"); }
+}
+
+module.exports = { panel, table, box };