@fend/firo 0.0.1

package/dist/index.js

@@ -0,0 +1,312 @@
+// src/utils.ts
+var LOG_LEVELS = {
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50
+};
+var FIRO_COLORS = {
+  // Basic ANSI (safe for any terminal)
+  cyan: "36",
+  green: "32",
+  yellow: "33",
+  magenta: "35",
+  blue: "34",
+  brightCyan: "96",
+  brightGreen: "92",
+  brightYellow: "93",
+  brightMagenta: "95",
+  brightBlue: "94",
+  // Extended 256-color palette
+  orange: "38;5;214",
+  pink: "38;5;213",
+  lilac: "38;5;141",
+  skyBlue: "38;5;117",
+  mint: "38;5;156",
+  salmon: "38;5;210",
+  lemon: "38;5;228",
+  lavender: "38;5;183",
+  sage: "38;5;114",
+  coral: "38;5;209",
+  teal: "38;5;116",
+  rose: "38;5;219",
+  pistachio: "38;5;150",
+  mauve: "38;5;175",
+  aqua: "38;5;81",
+  gold: "38;5;222",
+  thistle: "38;5;182",
+  seafoam: "38;5;115",
+  tangerine: "38;5;208",
+  periwinkle: "38;5;147"
+};
+var COLORS_LIST = Object.values(FIRO_COLORS);
+var SAFE_COLORS_COUNT = 10;
+var getColorIndex = (str, useAllColors = false) => {
+  let hash = 0;
+  str.split("").forEach((char) => {
+    hash = char.charCodeAt(0) + ((hash << 5) - hash);
+  });
+  const range = useAllColors ? COLORS_LIST.length : SAFE_COLORS_COUNT;
+  return Math.abs(hash % range);
+};
+var colorize = (text, colorIndex, color) => {
+  const code = color ?? (COLORS_LIST[colorIndex] || COLORS_LIST[colorIndex % SAFE_COLORS_COUNT]);
+  return `\x1B[${code}m${text}\x1B[0m`;
+};
+var colorizeLevel = (level, text) => {
+  if (level === "info") return text;
+  switch (level) {
+    case "error":
+      return `\x1B[31m${text}\x1B[0m`;
+    // Red
+    case "warn":
+      return `\x1B[33m${text}\x1B[0m`;
+    // Yellow
+    case "debug":
+      return `\x1B[2m${text}\x1B[0m`;
+    // Dim
+    default:
+      return text;
+  }
+};
+
+// src/transports.ts
+import { inspect } from "util";
+import process from "process";
+import fs from "fs";
+var createDevTransport = (config = {}) => {
+  const locale = config.locale ?? void 0;
+  const timeOpts = {
+    hour12: false,
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    fractionalSecondDigits: 3,
+    ...config.timeOptions || {}
+  };
+  const transport = (level, context, msg, data, opts) => {
+    const now = /* @__PURE__ */ new Date();
+    const timestamp = now.toLocaleTimeString(locale, timeOpts);
+    const contextStr = context.map((ctx) => {
+      const key = ctx.options?.omitKey ? "" : `${ctx.key}:`;
+      const content = `${key}${ctx.value}`;
+      return colorize(`[${content}]`, ctx.options.colorIndex, ctx.options.color);
+    }).join(" ");
+    if (level === "error" && data === void 0) {
+      const realError = wrapToError(msg);
+      data = realError;
+      msg = realError.message;
+    }
+    let dataStr = "";
+    if (data !== void 0) {
+      const inspectOptions = opts?.pretty ? { compact: false, colors: true, depth: null } : { compact: true, breakLength: Infinity, colors: true, depth: null };
+      dataStr = inspect(data, inspectOptions);
+    }
+    const msgStr = typeof msg === "object" && msg !== null ? inspect(msg, { colors: true, compact: true, breakLength: Infinity }) : String(msg);
+    const parts = [
+      `[${timestamp}]`,
+      // Normal (not dimmed)
+      contextStr,
+      level === "error" ? colorizeLevel("error", `[ERROR] ${msgStr}`) : level === "warn" ? colorizeLevel("warn", `[WARN] ${msgStr}`) : level === "debug" ? colorizeLevel("debug", msgStr) : msgStr,
+      level === "debug" && dataStr ? `\x1B[2m${dataStr.replace(/\x1b\[0m/g, "\x1B[0m\x1B[2m")}\x1B[0m` : dataStr
+    ];
+    let finalLine = parts.filter(Boolean).join(" ") + "\n";
+    if (level === "error") process.stderr.write(finalLine);
+    else process.stdout.write(finalLine);
+  };
+  return transport;
+};
+var safeStringify = (obj) => {
+  try {
+    return JSON.stringify(obj);
+  } catch {
+    return inspect(obj);
+  }
+};
+var wrapToError = (obj) => {
+  if (obj instanceof Error) return obj;
+  return new Error(
+    typeof obj === "object" && obj !== null ? safeStringify(obj) : String(obj)
+  );
+};
+var serializeError = (_err) => {
+  const err = wrapToError(_err);
+  return {
+    message: err.message,
+    stack: err.stack,
+    name: err.name,
+    ...err
+  };
+};
+var buildRecord = (level, context, msg, data) => {
+  const contextObj = context.reduce((acc, item) => {
+    acc[item.key] = item.value;
+    return acc;
+  }, {});
+  const logRecord = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    level,
+    ...contextObj
+  };
+  if (level === "error") {
+    const message = typeof msg === "string" ? msg : msg instanceof Error ? msg.message : typeof msg === "object" && msg !== null ? safeStringify(msg) : String(msg);
+    logRecord.message = message;
+    if (data instanceof Error) {
+      logRecord.error = serializeError(data);
+    } else if (msg instanceof Error) {
+      logRecord.error = serializeError(msg);
+      if (data !== void 0) logRecord.data = data;
+    } else {
+      logRecord.error = serializeError(msg);
+      if (data !== void 0) logRecord.data = data;
+    }
+  } else {
+    logRecord.message = typeof msg === "object" && msg !== null ? safeStringify(msg) : String(msg);
+    if (data !== void 0) {
+      logRecord.data = data instanceof Error ? serializeError(data) : data;
+    }
+  }
+  return logRecord;
+};
+var createJsonTransport = (config = {}) => {
+  const queue = [];
+  const maxQueueSize = config.maxQueueSize ?? 1e3;
+  let isDraining = false;
+  const flush = () => {
+    if (queue.length === 0 || isDraining) return;
+    while (queue.length > 0) {
+      const line = queue.shift();
+      const ok = process.stdout.write(line);
+      if (!ok) {
+        isDraining = true;
+        process.stdout.once("drain", () => {
+          isDraining = false;
+          flush();
+        });
+        return;
+      }
+    }
+  };
+  const flushSync = () => {
+    while (queue.length > 0) {
+      const line = queue.shift();
+      if (line) {
+        try {
+          fs.writeSync(1, line);
+        } catch {
+        }
+      }
+    }
+  };
+  if (config.async) {
+    process.on("beforeExit", flushSync);
+    process.on("exit", flushSync);
+  }
+  return (level, context, msg, data) => {
+    const record = buildRecord(level, context, msg, data);
+    let line;
+    try {
+      line = JSON.stringify(record) + "\n";
+    } catch {
+      if (record.data) record.data = inspect(record.data);
+      try {
+        line = JSON.stringify(record) + "\n";
+      } catch {
+        line = JSON.stringify({
+          timestamp: record.timestamp,
+          level,
+          message: record.message,
+          error: "Failed to serialize log record"
+        }) + "\n";
+      }
+    }
+    if (!config.async) {
+      process.stdout.write(line);
+      return;
+    }
+    queue.push(line);
+    if (queue.length > maxQueueSize) {
+      queue.shift();
+    }
+    flush();
+  };
+};
+
+// src/index.ts
+var fillContextItem = (item, useAllColors = false) => {
+  return {
+    ...item,
+    options: {
+      colorIndex: item.options && typeof item.options.colorIndex === "number" ? item.options.colorIndex : getColorIndex(item.key, useAllColors),
+      color: item.options?.color,
+      omitKey: item.options?.omitKey ?? false
+    }
+  };
+};
+var createLoggerInternal = (config, parentContext) => {
+  const useAllColors = config.useAllColors ?? false;
+  const fill = (item) => fillContextItem(item, useAllColors);
+  const appendContextWithInvokeContext = (context2, invokeContext) => {
+    if (!invokeContext || invokeContext.length === 0) return context2;
+    return [...context2, ...invokeContext.map(fill)];
+  };
+  const context = [...parentContext.map(fill)];
+  const transport = config.transport ?? (config.mode === "prod" ? createJsonTransport({ async: config.async }) : createDevTransport(config.devTransportConfig));
+  const minLevelName = config.mode === "prod" ? config.minLevelInProd ?? config.minLevel : config.minLevelInDev ?? config.minLevel;
+  const minLevel = LOG_LEVELS[minLevelName ?? "debug"];
+  const getContext = () => context;
+  const addContext = (key, value, options) => {
+    let item = typeof key === "string" ? { key, value, options } : key;
+    context.push(fill(item));
+  };
+  const removeKeyFromContext = (key) => {
+    const index = context.findIndex((ctx) => ctx.key === key);
+    if (index !== -1) context.splice(index, 1);
+  };
+  const child = (ctx) => {
+    const newItems = Object.entries(ctx).map(([key, value]) => ({
+      key,
+      value,
+      options: { colorIndex: getColorIndex(key, useAllColors) }
+    }));
+    return createLoggerInternal({ transport, minLevel: minLevelName, useAllColors }, [...context, ...newItems]);
+  };
+  const debug = (msg, data, opts) => {
+    if (minLevel > LOG_LEVELS.debug) return;
+    transport("debug", appendContextWithInvokeContext(context, opts?.ctx), msg, data, opts);
+  };
+  const info = (msg, data, opts) => {
+    if (minLevel > LOG_LEVELS.info) return;
+    transport("info", appendContextWithInvokeContext(context, opts?.ctx), msg, data, opts);
+  };
+  const warn = (msg, data, opts) => {
+    if (minLevel > LOG_LEVELS.warn) return;
+    transport("warn", appendContextWithInvokeContext(context, opts?.ctx), msg, data, opts);
+  };
+  const error = (msgOrError, err, opts) => {
+    if (minLevel > LOG_LEVELS.error) return;
+    transport("error", appendContextWithInvokeContext(context, opts?.ctx), msgOrError, err, opts);
+  };
+  const logInstance = ((msg, data, opts) => {
+    info(msg, data, opts);
+  });
+  return Object.assign(logInstance, {
+    debug,
+    info,
+    warn,
+    error,
+    child,
+    addContext,
+    getContext,
+    removeFromContext: removeKeyFromContext
+  });
+};
+var createLogger = (config = {}) => {
+  return createLoggerInternal(config, []);
+};
+export {
+  FIRO_COLORS,
+  createDevTransport,
+  createJsonTransport,
+  createLogger
+};

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@fend/firo",
+  "version": "0.0.1",
+  "description": "Elegant logger for Node.js, Bun and Deno with brilliant DX.",
+  "keywords": [
+    "logger",
+    "pino",
+    "firo",
+    "fend",
+    "dx",
+    "structured-logging",
+    "ndjson",
+    "color",
+    "zero-dependencies"
+  ],
+  "author": "Alex Saft <fend25@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fend25/firo.git"
+  },
+  "bugs": {
+    "url": "https://github.com/fend25/firo/issues"
+  },
+  "homepage": "https://github.com/fend25/firo#readme",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "publish:jsr": "pnpm dlx jsr publish",
+    "test": "node --import tsx --test test/*.test.ts",
+    "typecheck": "tsc --noEmit",
+    "demo": "tsx demo.ts"
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "tsup": "^8.5.1",
+    "tsx": "^4.0.0",
+    "typescript": "^5.9.3"
+  }
+}