@meadown/logger 1.6.0 → 1.8.0

package/dist/tap/createTap.d.ts

@@ -0,0 +1,18 @@
+/** Logs a value and returns it unchanged. Promises route to the timed path. */
+export interface Tap {
+    <T>(value: T, label?: string): T;
+}
+/**
+ * Builds `tap` — logs a value and returns it **unchanged**, so it drops into any
+ * expression (`const u = logger.tap(getUser(), "user")`). The consumer always
+ * gets back exactly what they passed; the only effect is a clean log.
+ *
+ * - A plain value is logged synchronously and returned.
+ * - A **promise** is returned as-is (same object, never awaited or wrapped), and
+ *   its elapsed time — plus the HTTP status if it resolves to a `Response` — is
+ *   logged in the background (fire-and-forget, non-blocking).
+ *
+ * The returned closure is what the caller invokes directly, so {@link getCaller}
+ * resolves the caller's own frame. Silent in production; the value still flows.
+ */
+export default function createTap(): Tap;

package/dist/tap/createTap.js

@@ -0,0 +1,45 @@
+/*
+ * createTap.ts
+ * Created by Dewan Mobashirul
+ * Copyright (c) 2026 dewan-meadown
+ * All rights reserved
+ */
+import getCaller from "../caller/getCaller.js";
+import { writeLog } from "../core/writeLog.js";
+import { isLogAllowed } from "../config.js";
+import { isThenable, tapAsync } from "./tapAsync.js";
+/**
+ * Builds `tap` — logs a value and returns it **unchanged**, so it drops into any
+ * expression (`const u = logger.tap(getUser(), "user")`). The consumer always
+ * gets back exactly what they passed; the only effect is a clean log.
+ *
+ * - A plain value is logged synchronously and returned.
+ * - A **promise** is returned as-is (same object, never awaited or wrapped), and
+ *   its elapsed time — plus the HTTP status if it resolves to a `Response` — is
+ *   logged in the background (fire-and-forget, non-blocking).
+ *
+ * The returned closure is what the caller invokes directly, so {@link getCaller}
+ * resolves the caller's own frame. Silent in production; the value still flows.
+ */
+export default function createTap() {
+    const tap = (value, label) => {
+        if (!isLogAllowed())
+            return value;
+        const caller = getCaller();
+        if (isThenable(value)) {
+            // value is a promise → hand off to the async tap (caller passed in so the
+            // location stays on the user's file, not on this helper).
+            tapAsync(value, label, caller);
+        }
+        else {
+            writeLog({
+                channel: "log",
+                tag: "[TAP]",
+                args: label === undefined ? [value] : [label, value],
+                caller,
+            });
+        }
+        return value;
+    };
+    return tap;
+}

package/dist/tap/tapAsync.d.ts

@@ -0,0 +1,11 @@
+import { type Caller } from "../caller/getCaller.js";
+/** Whether `value` is thenable (a promise we can await + time). */
+export declare function isThenable(value: unknown): value is PromiseLike<unknown>;
+/**
+ * The async tap. Fire-and-forget: returns `promise` immediately (unchanged),
+ * and logs a rich block once it resolves. For a `Response`, reads the body from
+ * a clone so the caller's original stays consumable. A rejection logs an error
+ * to stderr. `caller` MUST be resolved by `tap` (the user-facing function) so
+ * the logged location points at the user's file.
+ */
+export declare function tapAsync(promise: PromiseLike<unknown>, label: string | undefined, caller: Caller): void;

package/dist/tap/tapAsync.js

@@ -0,0 +1,203 @@
+/*
+ * tapAsync.ts
+ * Created by Dewan Mobashirul
+ * Copyright (c) 2026 dewan-meadown
+ * All rights reserved
+ *
+ * The async side of `tap`: times a promise and logs a rich response block when
+ * it resolves to a `Response` — status color, slow-request highlighting, size,
+ * and the actual body — all fire-and-forget so the caller never waits.
+ */
+import { performance } from "node:perf_hooks";
+import { formatWithOptions } from "node:util";
+import { writeLog } from "../core/writeLog.js";
+import { colorize } from "../colors/color.js";
+import { isTTY } from "../terminal/isTTY.js";
+/** Whether `value` is thenable (a promise we can await + time). */
+export function isThenable(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        typeof value.then === "function");
+}
+/** Whether the resolved value is a fetch `Response` we can read. */
+function isResponse(value) {
+    const v = value;
+    return (typeof v?.status === "number" &&
+        typeof v.clone === "function" &&
+        typeof v.text === "function");
+}
+/** `65ms` (green) · `1.2s` (yellow) · `5.8s` (red). */
+function formatDuration(ms, useColor) {
+    const text = ms >= 1000 ? `${(ms / 1000).toFixed(2)}s` : `${ms}ms`;
+    if (!useColor)
+        return text;
+    if (ms >= 3000)
+        return colorize(text, "red");
+    if (ms >= 1000)
+        return colorize(text, "yellow");
+    return colorize(text, "green");
+}
+/** `848 B` / `1.84 KB` / `2.10 MB`. */
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(2)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}
+/**
+ * Status badge color:
+ * 2xx → green · 3xx → cyan · 4xx → yellow · 5xx → red
+ */
+function statusColor(status) {
+    if (status >= 500)
+        return "red";
+    if (status >= 400)
+        return "yellow";
+    if (status >= 300)
+        return "cyan";
+    return "green";
+}
+function formatStatus(res, useColor) {
+    const text = typeof res.statusText === "string" && res.statusText
+        ? `${res.status} ${res.statusText}`
+        : `${res.status}`;
+    return useColor ? colorize(text, statusColor(res.status)) : text;
+}
+/**
+ * Reads a (cloned) response body and returns both the parsed value and the
+ * actual byte size. Size is calculated from the body text — not `Content-Length`,
+ * which is absent on compressed responses — so size is always shown.
+ */
+async function readBody(res) {
+    try {
+        const text = await res.text();
+        const bytes = new TextEncoder().encode(text).length;
+        const size = formatBytes(bytes);
+        if (text === "")
+            return { data: undefined, size };
+        try {
+            return { data: JSON.parse(text), size };
+        }
+        catch {
+            return { data: text, size };
+        }
+    }
+    catch {
+        return { data: undefined, size: "unknown" };
+    }
+}
+/**
+ * Renders the nested tree block the user asked for:
+ *
+ *   GET /users/1
+ *   │
+ *   │  response:
+ *   │  ├── time:   65ms
+ *   │  ├── status: 200 OK
+ *   │  └── size:   848 B
+ *   │
+ *   │  body:
+ *   │  ├── id:    1
+ *   │  └── name:  Leanne Graham
+ */
+function buildBlock(label, ms, res, body, useColor) {
+    const pipe = useColor ? colorize("│", "gray") : "│";
+    const branch = useColor ? colorize("├──", "gray") : "├──";
+    const last = useColor ? colorize("└──", "gray") : "└──";
+    const indent = `${pipe}  `;
+    const statusLine = `${indent}${branch} status: ${formatStatus(res, useColor)}`;
+    const timeLine = `${indent}${branch} time:   ${formatDuration(ms, useColor)}`;
+    const sizeLine = `${indent}${last} size:   ${body.size}`;
+    const responseBlock = [
+        `${pipe}`,
+        `${indent}response:`,
+        timeLine,
+        statusLine,
+        sizeLine,
+    ].join("\n");
+    if (body.data === undefined) {
+        const head = label === undefined ? "" : `${label}\n`;
+        return [`${head}${responseBlock}`];
+    }
+    // Render the body using util.formatWithOptions so objects/arrays look like
+    // console.log output — colors, proper nesting, no JSON.stringify quirkiness.
+    const bodyText = formatWithOptions({ colors: useColor }, body.data);
+    const bodyLines = bodyText.split("\n");
+    const lastIdx = bodyLines.length - 1;
+    const bodyBlock = bodyLines
+        .map((line, i) => `${indent}${i === lastIdx ? last : branch} ${line}`)
+        .join("\n");
+    const full = [
+        `${pipe}`,
+        `${indent}response:`,
+        timeLine,
+        statusLine,
+        sizeLine,
+        `${pipe}`,
+        `${indent}body:`,
+        bodyBlock,
+    ].join("\n");
+    const head = label === undefined ? "" : `${label}\n`;
+    return [`${head}${full}`];
+}
+/**
+ * The async tap. Fire-and-forget: returns `promise` immediately (unchanged),
+ * and logs a rich block once it resolves. For a `Response`, reads the body from
+ * a clone so the caller's original stays consumable. A rejection logs an error
+ * to stderr. `caller` MUST be resolved by `tap` (the user-facing function) so
+ * the logged location points at the user's file.
+ */
+export function tapAsync(promise, label, caller) {
+    const useColor = isTTY("stdout");
+    const start = performance.now();
+    void promise.then((resolved) => {
+        const ms = Math.round(performance.now() - start);
+        if (isResponse(resolved)) {
+            let clone = null;
+            try {
+                clone = resolved.clone();
+            }
+            catch {
+                clone = null;
+            }
+            if (clone === null) {
+                writeLog({
+                    channel: "log", tag: "[TAP]",
+                    args: buildBlock(label, ms, resolved, { data: undefined, size: "unknown" }, useColor),
+                    caller,
+                });
+                return;
+            }
+            const cl = resolved.headers?.get?.("content-length");
+            const tooLarge = cl != null && cl !== "" && Number(cl) > 512 * 1024;
+            if (tooLarge) {
+                writeLog({
+                    channel: "log", tag: "[TAP]",
+                    args: buildBlock(label, ms, resolved, { data: "(body too large to display)", size: formatBytes(Number(cl)) }, useColor),
+                    caller,
+                });
+                return;
+            }
+            void readBody(clone).then((body) => {
+                writeLog({ channel: "log", tag: "[TAP]", args: buildBlock(label, ms, resolved, body, useColor), caller });
+            });
+            return;
+        }
+        // Non-Response promise — plain value with elapsed time.
+        const elapsed = formatDuration(ms, useColor);
+        writeLog({
+            channel: "log", tag: "[TAP]",
+            args: label === undefined ? [elapsed, resolved] : [`${label} ${elapsed}`, resolved],
+            caller,
+        });
+    }, (err) => {
+        const ms = Math.round(performance.now() - start);
+        const elapsed = formatDuration(ms, useColor);
+        writeLog({
+            channel: "error", tag: "[TAP]",
+            args: [label === undefined ? `rejected after ${elapsed}` : `${label} rejected after ${elapsed}`, err],
+            caller,
+        });
+    });
+}

package/dist/terminal/isTTY.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Whether the given stream is an interactive terminal — the single source of
+ * truth for "should we emit terminal escapes (colors, clickable links)?". No env
+ * vars, no config. When output is piped or redirected this is `false`, so escape
+ * codes never end up in files or logs.
+ */
+export declare function isTTY(streamName: "stdout" | "stderr"): boolean;

package/dist/terminal/isTTY.js

@@ -0,0 +1,18 @@
+/*
+ * isTTY.ts
+ * Created by Dewan Mobashirul
+ * Copyright (c) 2026 dewan-meadown
+ * All rights reserved
+ */
+/**
+ * Whether the given stream is an interactive terminal — the single source of
+ * truth for "should we emit terminal escapes (colors, clickable links)?". No env
+ * vars, no config. When output is piped or redirected this is `false`, so escape
+ * codes never end up in files or logs.
+ */
+export function isTTY(streamName) {
+    if (typeof process === "undefined")
+        return false;
+    const stream = streamName === "stdout" ? process.stdout : process.stderr;
+    return Boolean(stream?.isTTY);
+}

package/dist/{utils → time}/getTimeStamp.d.ts

@@ -4,4 +4,3 @@
  * compact; date and time are both local so they stay consistent.
  */
 export default function getTimeStamp(date?: Date): string;
-//# sourceMappingURL=getTimeStamp.d.ts.map

package/dist/{utils → time}/getTimeStamp.js

@@ -23,4 +23,3 @@ export default function getTimeStamp(date = new Date()) {
     const datePart = `${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
     return `${datePart} ${TIME_FORMATTER.format(date)}`;
 }
-//# sourceMappingURL=getTimeStamp.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@meadown/logger",
-  "version": "1.6.0",
-  "description": "A tiny, zero-dependency logger for Node.js and TypeScript that tags each line, timestamps it, shows the source file and line, and goes quiet in production.",
+  "version": "1.8.0",
+  "description": "A development-focused logger for Node.js and TypeScript — zero dependencies, clickable source links, and API response logging built in.",
   "keywords": [
     "logger",
     "logging",
@@ -54,6 +54,8 @@
     "lint": "eslint src",
     "lint:fix": "eslint src --fix",
     "demo": "pnpm build && node examples/demo.mjs",
+    "demo:calls": "pnpm build && node examples/call-sites.mjs",
+    "demo:api": "pnpm build && node examples/api.mjs",
     "prepublishOnly": "pnpm run lint && pnpm test && pnpm run build",
     "prepare": "husky",
     "release": "semantic-release"

package/dist/cjs/utils/color.d.ts

@@ -1,25 +0,0 @@
-/** ANSI SGR codes for the colors/styles the logger uses. */
-declare const CODES: {
-    readonly red: 31;
-    readonly yellow: 33;
-    readonly cyan: 36;
-    readonly gray: 90;
-    readonly teal: "38;5;30";
-    readonly dimTeal: "38;5;23";
-};
-/** The named colors/styles {@link colorize} understands. */
-export type Color = keyof typeof CODES;
-/**
- * Wraps `text` in the ANSI escape codes for `color`, resetting afterwards.
- * Pure string work — deciding *whether* to colorize is {@link supportsColor}'s
- * job, kept separate so callers control it per stream.
- */
-export declare function colorize(text: string, color: Color): string;
-/**
- * Whether to emit ANSI colors for the given stream. Driven solely by the stream
- * being an interactive terminal (`isTTY`) — no env vars, no config. When output
- * is piped or redirected, colors are skipped so escape codes never end up in
- * files or logs.
- */
-export declare function supportsColor(streamName: "stdout" | "stderr"): boolean;
-export {};

package/dist/cjs/utils/color.js

@@ -1,40 +0,0 @@
-"use strict";
-/*
- * color.ts
- * Created by Dewan Mobashirul
- * Copyright (c) 2026 dewan-meadown
- * All rights reserved
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.colorize = colorize;
-exports.supportsColor = supportsColor;
-/** ANSI SGR codes for the colors/styles the logger uses. */
-const CODES = {
-    red: 31,
-    yellow: 33,
-    cyan: 36,
-    gray: 90, // bright black — renders as light gray
-    teal: "38;5;30", // 256-color teal (#008787)
-    dimTeal: "38;5;23", // 256-color darker teal (#005f5f)
-};
-const RESET = "\x1b[0m";
-/**
- * Wraps `text` in the ANSI escape codes for `color`, resetting afterwards.
- * Pure string work — deciding *whether* to colorize is {@link supportsColor}'s
- * job, kept separate so callers control it per stream.
- */
-function colorize(text, color) {
-    return `\x1b[${CODES[color]}m${text}${RESET}`;
-}
-/**
- * Whether to emit ANSI colors for the given stream. Driven solely by the stream
- * being an interactive terminal (`isTTY`) — no env vars, no config. When output
- * is piped or redirected, colors are skipped so escape codes never end up in
- * files or logs.
- */
-function supportsColor(streamName) {
-    if (typeof process === "undefined")
-        return false;
-    const stream = streamName === "stdout" ? process.stdout : process.stderr;
-    return Boolean(stream?.isTTY);
-}

package/dist/cjs/utils/createLog.d.ts

@@ -1,14 +0,0 @@
-/** The console channels the logger writes to. */
-export type LogChannel = "log" | "error" | "warn";
-/** How many lines a long message shows before collapsing (0 = all). */
-export declare function getVisibleLines(): number;
-/** Set how many lines a long message shows before collapsing (0 = all). */
-export declare function setVisibleLines(value: number): void;
-/**
- * Builds a log function bound to a console channel and tag. The returned closure
- * is what the caller invokes directly, so {@link getCaller} still resolves the
- * caller's own frame (no extra stack frame is inserted). `console[channel]` is
- * looked up at call time, so reassigning `console.log` (e.g. in tests) is
- * respected. Logs only outside production — see {@link isLogAllowed}.
- */
-export default function createLog(channel: LogChannel, tag: string): (...args: unknown[]) => void;

package/dist/cjs/utils/createLog.js

@@ -1,116 +0,0 @@
-"use strict";
-/*
- * createLog.ts
- * Created by Dewan Mobashirul
- * Copyright (c) 2026 dewan-meadown
- * All rights reserved
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getVisibleLines = getVisibleLines;
-exports.setVisibleLines = setVisibleLines;
-exports.default = createLog;
-const node_util_1 = require("node:util");
-const getCaller_js_1 = __importDefault(require("./getCaller.js"));
-const getTimeStamp_js_1 = __importDefault(require("./getTimeStamp.js"));
-const link_js_1 = require("./link.js");
-const color_js_1 = require("./color.js");
-const config_js_1 = require("../config.js");
-/** The tag color for each channel: info → cyan, warn → yellow, error → red. */
-const TAG_COLOR = {
-    log: "cyan",
-    warn: "yellow",
-    error: "red",
-};
-/** Visible width of the `└── ` branch; message lines left-align under it. */
-const MESSAGE_INDENT = "   ";
-/** Max message lines to show before collapsing the rest; 0 (default) shows all. */
-let visibleLines = 0;
-/** How many lines a long message shows before collapsing (0 = all). */
-function getVisibleLines() {
-    return visibleLines;
-}
-/** Set how many lines a long message shows before collapsing (0 = all). */
-function setVisibleLines(value) {
-    visibleLines = Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
-}
-/**
- * Collapses a long multi-line message to {@link visibleLines} lines, replacing
- * the rest with a dimmed `… N more lines` summary. When `visibleLines` is 0
- * (the default) nothing is collapsed — the full message is shown.
- */
-function collapse(text, useColor) {
-    if (visibleLines < 1)
-        return text;
-    const lines = text.split("\n");
-    if (lines.length <= visibleLines)
-        return text;
-    const hidden = lines.length - visibleLines;
-    const summary = `${MESSAGE_INDENT}... ${hidden} more line${hidden === 1 ? "" : "s"}`;
-    const visible = lines.slice(0, visibleLines);
-    visible.push(useColor ? (0, color_js_1.colorize)(summary, "gray") : summary);
-    return visible.join("\n");
-}
-/**
- * Renders the args into a single message string exactly as console would —
- * objects/errors via util.inspect, `%s`/`%d` format specifiers, and colors when
- * on a terminal — then hang-indents every continuation line so multi-line
- * output (multi-line strings, pretty-printed objects, error stacks) all stays
- * left-aligned under the `└── ` branch, and collapses very long output.
- */
-function renderMessage(args, useColor) {
-    const text = (0, node_util_1.formatWithOptions)({ colors: useColor }, ...args);
-    return collapse(text.replace(/\n/g, `\n${MESSAGE_INDENT}`), useColor);
-}
-/**
- * Renders a caller as a `(file:line)` location. When the terminal supports
- * OSC-8 hyperlinks, the location is a clickable link to the source file while
- * the line stays visible in the label; otherwise it's plain text. Pure (no
- * stack access), so it can be called from a helper without disturbing
- * {@link getCaller}'s frame depth.
- */
-function formatLocation(caller, streamName) {
-    if (caller.file !== null &&
-        caller.line !== null &&
-        (0, link_js_1.supportsHyperlinks)(streamName))
-        return (0, link_js_1.hyperlink)(caller.label, (0, link_js_1.fileUrl)(caller.file));
-    return caller.label;
-}
-/**
- * Builds a log function bound to a console channel and tag. The returned closure
- * is what the caller invokes directly, so {@link getCaller} still resolves the
- * caller's own frame (no extra stack frame is inserted). `console[channel]` is
- * looked up at call time, so reassigning `console.log` (e.g. in tests) is
- * respected. Logs only outside production — see {@link isLogAllowed}.
- */
-function createLog(channel, tag) {
-    const streamName = channel === "log" ? "stdout" : "stderr";
-    return (...args) => {
-        if (!(0, config_js_1.isLogAllowed)())
-            return;
-        const caller = (0, getCaller_js_1.default)();
-        const location = formatLocation(caller, streamName);
-        // Colors (terminal only): tag by level, timestamp teal, location dim teal,
-        // branch and separator gray.
-        const useColor = (0, color_js_1.supportsColor)(streamName);
-        const tagOut = useColor ? (0, color_js_1.colorize)(tag, TAG_COLOR[channel]) : tag;
-        const timeStamp = useColor
-            ? (0, color_js_1.colorize)((0, getTimeStamp_js_1.default)(), "teal")
-            : (0, getTimeStamp_js_1.default)();
-        const locOut = useColor
-            ? (0, color_js_1.colorize)(`(${location})`, "dimTeal")
-            : `(${location})`;
-        const connector = useColor ? (0, color_js_1.colorize)("├──", "gray") : "└──";
-        const connectorBottom = useColor ? (0, color_js_1.colorize)("└──", "gray") : "└──";
-        const separator = useColor ? (0, color_js_1.colorize)("-", "gray") : "-";
-        // Layout: the tag, the message hanging off a `├──` branch, then the
-        // timestamp and location on a `└──` branch below.
-        const message = renderMessage(args, useColor);
-        const meta = `\n${connectorBottom} ${timeStamp} ${separator} ${locOut}`;
-        // Leading `\n` puts a blank line above each entry — in the same call and on
-        // the right stream (a separate `console.log` would always hit stdout).
-        console[channel](`\n${tagOut}`, `\n${connector}`, message, meta);
-    };
-}

package/dist/cjs/utils/index.d.ts

@@ -1,5 +0,0 @@
-export { default as createLog, getVisibleLines, setVisibleLines, type LogChannel, } from "./createLog.js";
-export { default as getCaller, type Caller } from "./getCaller.js";
-export { default as getTimeStamp } from "./getTimeStamp.js";
-export { fileUrl, hyperlink, supportsHyperlinks } from "./link.js";
-export { colorize, supportsColor, type Color } from "./color.js";

package/dist/cjs/utils/index.js

@@ -1,27 +0,0 @@
-"use strict";
-/*
- * index.ts
- * Created by Dewan Mobashirul
- * Copyright (c) 2026 dewan-meadown
- * All rights reserved
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.supportsColor = exports.colorize = exports.supportsHyperlinks = exports.hyperlink = exports.fileUrl = exports.getTimeStamp = exports.getCaller = exports.setVisibleLines = exports.getVisibleLines = exports.createLog = void 0;
-var createLog_js_1 = require("./createLog.js");
-Object.defineProperty(exports, "createLog", { enumerable: true, get: function () { return __importDefault(createLog_js_1).default; } });
-Object.defineProperty(exports, "getVisibleLines", { enumerable: true, get: function () { return createLog_js_1.getVisibleLines; } });
-Object.defineProperty(exports, "setVisibleLines", { enumerable: true, get: function () { return createLog_js_1.setVisibleLines; } });
-var getCaller_js_1 = require("./getCaller.js");
-Object.defineProperty(exports, "getCaller", { enumerable: true, get: function () { return __importDefault(getCaller_js_1).default; } });
-var getTimeStamp_js_1 = require("./getTimeStamp.js");
-Object.defineProperty(exports, "getTimeStamp", { enumerable: true, get: function () { return __importDefault(getTimeStamp_js_1).default; } });
-var link_js_1 = require("./link.js");
-Object.defineProperty(exports, "fileUrl", { enumerable: true, get: function () { return link_js_1.fileUrl; } });
-Object.defineProperty(exports, "hyperlink", { enumerable: true, get: function () { return link_js_1.hyperlink; } });
-Object.defineProperty(exports, "supportsHyperlinks", { enumerable: true, get: function () { return link_js_1.supportsHyperlinks; } });
-var color_js_1 = require("./color.js");
-Object.defineProperty(exports, "colorize", { enumerable: true, get: function () { return color_js_1.colorize; } });
-Object.defineProperty(exports, "supportsColor", { enumerable: true, get: function () { return color_js_1.supportsColor; } });

package/dist/config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAOA;;;;GAIG;AACH,wBAAgB,YAAY,IAAI,OAAO,CAItC"}

package/dist/config.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;GAIG;AACH,MAAM,UAAU,YAAY;IAC1B,6EAA6E;IAC7E,wEAAwE;IACxE,OAAO,OAAO,OAAO,KAAK,WAAW,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,YAAY,CAAA;AAChF,CAAC"}

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AASA,gFAAgF;AAChF,MAAM,WAAW,KAAK;IACpB,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAA;IAC1B,KAAK,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAA;IAC/B,IAAI,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAA;IAC9B;;;OAGG;IACH,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED;;;;;;;;;GASG;AACH,QAAA,MAAM,MAAM,EAGN,KAAK,CAAA;AAWX;;;GAGG;AACH,QAAA,MAAM,SAAS,OAAS,CAAA;AAExB,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,CAAA;AAC5B,eAAe,MAAM,CAAA"}

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAc9E;;;;;;;;;GASG;AACH,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,QAAQ,CAAC,EAAE;IACvD,KAAK,EAAE,SAAS,CAAC,OAAO,EAAE,SAAS,CAAC;IACpC,IAAI,EAAE,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC;CAClC,CAAU,CAAA;AAEX,+EAA+E;AAC/E,uDAAuD;AACvD,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,UAAU,EAAE;IACxC,GAAG,EAAE,eAAe;IACpB,GAAG,EAAE,eAAe;IACpB,UAAU,EAAE,IAAI;IAChB,YAAY,EAAE,IAAI;CACnB,CAAC,CAAA;AAEF;;;GAGG;AACH,MAAM,SAAS,GAAG,MAAM,CAAA;AAExB,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,CAAA;AAC5B,eAAe,MAAM,CAAA"}

package/dist/utils/color.d.ts

@@ -1,26 +0,0 @@
-/** ANSI SGR codes for the colors/styles the logger uses. */
-declare const CODES: {
-    readonly red: 31;
-    readonly yellow: 33;
-    readonly cyan: 36;
-    readonly gray: 90;
-    readonly teal: "38;5;30";
-    readonly dimTeal: "38;5;23";
-};
-/** The named colors/styles {@link colorize} understands. */
-export type Color = keyof typeof CODES;
-/**
- * Wraps `text` in the ANSI escape codes for `color`, resetting afterwards.
- * Pure string work — deciding *whether* to colorize is {@link supportsColor}'s
- * job, kept separate so callers control it per stream.
- */
-export declare function colorize(text: string, color: Color): string;
-/**
- * Whether to emit ANSI colors for the given stream. Driven solely by the stream
- * being an interactive terminal (`isTTY`) — no env vars, no config. When output
- * is piped or redirected, colors are skipped so escape codes never end up in
- * files or logs.
- */
-export declare function supportsColor(streamName: "stdout" | "stderr"): boolean;
-export {};
-//# sourceMappingURL=color.d.ts.map

package/dist/utils/color.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"color.d.ts","sourceRoot":"","sources":["../../src/utils/color.ts"],"names":[],"mappings":"AAOA,4DAA4D;AAC5D,QAAA,MAAM,KAAK;;;;;;;CAOD,CAAA;AAEV,4DAA4D;AAC5D,MAAM,MAAM,KAAK,GAAG,MAAM,OAAO,KAAK,CAAA;AAItC;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,MAAM,CAE3D;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,QAAQ,GAAG,QAAQ,GAAG,OAAO,CAItE"}

package/dist/utils/color.js

@@ -1,37 +0,0 @@
-/*
- * color.ts
- * Created by Dewan Mobashirul
- * Copyright (c) 2026 dewan-meadown
- * All rights reserved
- */
-/** ANSI SGR codes for the colors/styles the logger uses. */
-const CODES = {
-    red: 31,
-    yellow: 33,
-    cyan: 36,
-    gray: 90, // bright black — renders as light gray
-    teal: "38;5;30", // 256-color teal (#008787)
-    dimTeal: "38;5;23", // 256-color darker teal (#005f5f)
-};
-const RESET = "\x1b[0m";
-/**
- * Wraps `text` in the ANSI escape codes for `color`, resetting afterwards.
- * Pure string work — deciding *whether* to colorize is {@link supportsColor}'s
- * job, kept separate so callers control it per stream.
- */
-export function colorize(text, color) {
-    return `\x1b[${CODES[color]}m${text}${RESET}`;
-}
-/**
- * Whether to emit ANSI colors for the given stream. Driven solely by the stream
- * being an interactive terminal (`isTTY`) — no env vars, no config. When output
- * is piped or redirected, colors are skipped so escape codes never end up in
- * files or logs.
- */
-export function supportsColor(streamName) {
-    if (typeof process === "undefined")
-        return false;
-    const stream = streamName === "stdout" ? process.stdout : process.stderr;
-    return Boolean(stream?.isTTY);
-}
-//# sourceMappingURL=color.js.map