@andrew_l/pino-pretty 0.2.17

package/dist/index.cjs

@@ -0,0 +1,596 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const node_stream = require('node:stream');
+const abstractTransport = require('pino-abstract-transport');
+const pump = require('pump');
+const toolkit = require('@andrew_l/toolkit');
+const path = require('node:path');
+const node_util = require('node:util');
+const _SonicBoom = require('sonic-boom');
+const node_worker_threads = require('node:worker_threads');
+const tty = require('node:tty');
+const stringWidth = require('@cto.af/string-width');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+function _interopNamespaceCompat(e) {
+  if (e && typeof e === 'object' && 'default' in e) return e;
+  const n = Object.create(null);
+  if (e) {
+    for (const k in e) {
+      n[k] = e[k];
+    }
+  }
+  n.default = e;
+  return n;
+}
+
+const abstractTransport__default = /*#__PURE__*/_interopDefaultCompat(abstractTransport);
+const pump__default = /*#__PURE__*/_interopDefaultCompat(pump);
+const path__default = /*#__PURE__*/_interopDefaultCompat(path);
+const _SonicBoom__default = /*#__PURE__*/_interopDefaultCompat(_SonicBoom);
+const tty__namespace = /*#__PURE__*/_interopNamespaceCompat(tty);
+
+function buildSafeSonicBoom(opts) {
+  const stream = new _SonicBoom__default(opts);
+  stream.on("error", filterBrokenPipe);
+  if (!process.env.NODE_V8_COVERAGE && !opts.sync && node_worker_threads.isMainThread) {
+    setupOnExit(stream);
+  }
+  return stream;
+  function filterBrokenPipe(err) {
+    if (err.code === "EPIPE") {
+      stream.write = toolkit.noop;
+      stream.end = toolkit.noop;
+      stream.flushSync = toolkit.noop;
+      stream.destroy = toolkit.noop;
+      return;
+    }
+    stream.removeListener("error", filterBrokenPipe);
+  }
+}
+function setupOnExit(stream) {
+  if (global.WeakRef && global.WeakMap && global.FinalizationRegistry) {
+    import('on-exit-leak-free').then((onExit) => {
+      onExit.register(stream, autoEnd);
+      stream.on("close", function() {
+        onExit.unregister(stream);
+      });
+    });
+  }
+}
+function autoEnd(stream, eventName) {
+  if (stream.destroyed) {
+    return;
+  }
+  if (eventName === "beforeExit") {
+    stream.flush();
+    stream.on("drain", function() {
+      stream.end();
+    });
+  } else {
+    stream.flushSync();
+  }
+}
+
+const {
+  env = {},
+  argv = [],
+  platform = ""
+} = typeof process === "undefined" ? {} : process;
+const isDisabled = "NO_COLOR" in env || argv.includes("--no-color");
+const isForced = "FORCE_COLOR" in env || argv.includes("--color");
+const isWindows = platform === "win32";
+const isDumbTerminal = env.TERM === "dumb";
+const isCompatibleTerminal = tty__namespace && tty__namespace.isatty && tty__namespace.isatty(1) && env.TERM && !isDumbTerminal;
+const isCI = "CI" in env && ("GITHUB_ACTIONS" in env || "GITLAB_CI" in env || "CIRCLECI" in env);
+const isColorSupported = !isDisabled && (isForced || isWindows && !isDumbTerminal || isCompatibleTerminal || isCI);
+function replaceClose(index, string, close, replace, head = string.slice(0, Math.max(0, index)) + replace, tail = string.slice(Math.max(0, index + close.length)), next = tail.indexOf(close)) {
+  return head + (next < 0 ? tail : replaceClose(next, tail, close, replace));
+}
+function clearBleed(index, string, open, close, replace) {
+  return index < 0 ? open + string + close : open + replaceClose(index, string, close, replace) + close;
+}
+function filterEmpty(open, close, replace = open, at = open.length + 1) {
+  return (string) => string || !(string === "" || string === void 0) ? clearBleed(
+    ("" + string).indexOf(close, at),
+    string,
+    open,
+    close,
+    replace
+  ) : "";
+}
+function init(open, close, replace) {
+  return filterEmpty(`\x1B[${open}m`, `\x1B[${close}m`, replace);
+}
+function init256Color(code, isBg = false) {
+  const prefix = isBg ? "48;5;" : "38;5;";
+  const closeCode = isBg ? 49 : 39;
+  return filterEmpty(`\x1B[${prefix}${code}m`, `\x1B[${closeCode}m`);
+}
+const colorDefs = {
+  reset: init(0, 0),
+  bold: init(1, 22, "\x1B[22m\x1B[1m"),
+  dim: init(2, 22, "\x1B[22m\x1B[2m"),
+  italic: init(3, 23),
+  underline: init(4, 24),
+  inverse: init(7, 27),
+  hidden: init(8, 28),
+  strikethrough: init(9, 29),
+  black: init(30, 39),
+  red: init(31, 39),
+  green: init(32, 39),
+  yellow: init(33, 39),
+  blue: init(34, 39),
+  magenta: init(35, 39),
+  cyan: init(36, 39),
+  white: init(37, 39),
+  gray: init(90, 39),
+  bgBlack: init(40, 49),
+  bgRed: init(41, 49),
+  bgGreen: init(42, 49),
+  bgYellow: init(43, 49),
+  bgBlue: init(44, 49),
+  bgMagenta: init(45, 49),
+  bgCyan: init(46, 49),
+  bgWhite: init(47, 49),
+  blackBright: init(90, 39),
+  redBright: init(91, 39),
+  greenBright: init(92, 39),
+  yellowBright: init(93, 39),
+  blueBright: init(94, 39),
+  magentaBright: init(95, 39),
+  cyanBright: init(96, 39),
+  whiteBright: init(97, 39),
+  bgBlackBright: init(100, 49),
+  bgRedBright: init(101, 49),
+  bgGreenBright: init(102, 49),
+  bgYellowBright: init(103, 49),
+  bgBlueBright: init(104, 49),
+  bgMagentaBright: init(105, 49),
+  bgCyanBright: init(106, 49),
+  bgWhiteBright: init(107, 49),
+  // Extended 256-color palette - Popular colors
+  orange: init256Color(208),
+  purple: init256Color(129),
+  pink: init256Color(207),
+  lime: init256Color(154),
+  teal: init256Color(37),
+  indigo: init256Color(54),
+  brown: init256Color(130),
+  olive: init256Color(142),
+  navy: init256Color(17),
+  maroon: init256Color(52),
+  silver: init256Color(248),
+  gold: init256Color(220),
+  bgOrange: init256Color(208, true),
+  bgPurple: init256Color(129, true),
+  bgPink: init256Color(207, true),
+  bgLime: init256Color(154, true),
+  bgTeal: init256Color(37, true),
+  bgIndigo: init256Color(54, true),
+  bgBrown: init256Color(130, true),
+  bgOlive: init256Color(142, true),
+  bgNavy: init256Color(17, true),
+  bgMaroon: init256Color(52, true),
+  bgSilver: init256Color(248, true),
+  bgGold: init256Color(220, true)
+};
+const RAND_COLOR_LIST = Object.keys(colorDefs).filter((v) => {
+  if (v.startsWith("bg")) return false;
+  if ([
+    "reset",
+    "bold",
+    "dim",
+    "italic",
+    "underline",
+    "inverse",
+    "hidden",
+    "strikethrough",
+    "black",
+    "white",
+    "gray"
+  ].includes(v))
+    return false;
+  return true;
+});
+function createColors(useColor = isColorSupported) {
+  return useColor ? colorDefs : Object.fromEntries(Object.keys(colorDefs).map((key) => [key, String]));
+}
+const colors = createColors();
+function getColor(color, fallback = "reset") {
+  return colors[color] || colors[fallback];
+}
+
+var QUOTES = { double: '"', single: "'" };
+var QUOTE_REGEX = { double: /(["\\])/g, single: /(['\\])/g };
+var ESCAPE_CHARS = { 8: "b", 9: "t", 10: "n", 12: "f", 13: "r" };
+var SEP_REGEX = /\d(?=(?:\d{3})+(?!\d))/g;
+function addNumericSeparator(num, str) {
+  if (num === Infinity || num === -Infinity || Number.isNaN(num) || typeof num === "number" && Math.abs(num) < 1e3 || str.includes("e")) {
+    return str;
+  }
+  if (typeof num === "number" && !Number.isInteger(num)) {
+    var intPart = Math.trunc(num);
+    var intStr = String(intPart);
+    var decPart = str.slice(intStr.length + 1);
+    return intStr.replace(SEP_REGEX, "$&_") + "." + decPart.replace(/(\d{3})/g, "$&_").replace(/_$/, "");
+  }
+  return str.replace(SEP_REGEX, "$&_");
+}
+function inspectString(str, opts) {
+  var processedStr = str;
+  if (str.length > opts.maxStringLength) {
+    var remaining = str.length - opts.maxStringLength;
+    var trailer = `... ${remaining} more character${remaining > 1 ? "s" : ""}`;
+    processedStr = str.slice(0, opts.maxStringLength);
+    return inspectString(processedStr, opts) + trailer;
+  }
+  var quoteRegex = QUOTE_REGEX[opts.quoteStyle];
+  var escaped = processedStr.replace(quoteRegex, "\\$1").replace(/[\x00-\x1f]/g, (char) => {
+    var code = char.charCodeAt(0);
+    var escapeChar = ESCAPE_CHARS[code];
+    return escapeChar ? `\\${escapeChar}` : `\\x${code.toString(16).padStart(2, "0").toUpperCase()}`;
+  });
+  var quote = QUOTES[opts.quoteStyle];
+  var result = `${quote}${escaped}${quote}`;
+  return opts.customStringify.string?.(result) ?? result;
+}
+function getIndentStrings(opts, depth) {
+  if (depth === 0) return { base: " ".repeat(opts.indent), prev: "" };
+  return {
+    base: " ".repeat(opts.indent),
+    prev: " ".repeat(opts.indent * depth)
+  };
+}
+function isSingleLine(values) {
+  return values.every((value) => !value.includes("\n"));
+}
+function formatMultiline(values, indent) {
+  if (values.length === 0) return "";
+  var lineJoiner = `
+${indent.prev}${indent.base}`;
+  return `${lineJoiner}${values.join(`,${lineJoiner}`)}
+${indent.prev}`;
+}
+function getObjectEntries(obj, inspectFn) {
+  var isArray = Array.isArray(obj);
+  var entries = [];
+  if (isArray) {
+    for (var i = 0; i < obj.length; i++) {
+      entries[i] = Object.hasOwn(obj, i) ? inspectFn(obj[i], obj) : "";
+    }
+  }
+  for (var key in obj) {
+    if (!Object.hasOwn(obj, key)) continue;
+    if (isArray && /^\d+$/.test(key) && Number(key) < obj.length) continue;
+    var needsQuotes = /[^\w$]/.test(key);
+    var keyStr = needsQuotes ? inspectFn(key, obj) : key;
+    entries.push(`${keyStr}: ${inspectFn(obj[key], obj)}`);
+  }
+  return entries;
+}
+function inspectValue(obj, opts, depth, seen) {
+  if (obj === void 0)
+    return opts.customStringify.undefined?.(obj) ?? "undefined";
+  if (obj === null) return opts.customStringify.null?.(obj) ?? "null";
+  if (typeof obj === "boolean")
+    return opts.customStringify.boolean?.(obj) ?? String(obj);
+  if (typeof obj === "string") return inspectString(obj, opts);
+  if (typeof obj === "number") {
+    if (obj === 0) return Object.is(obj, -0) ? "-0" : "0";
+    var str = String(obj);
+    var result = opts.numericSeparator ? addNumericSeparator(obj, str) : str;
+    return opts.customStringify.number?.(result) ?? result;
+  }
+  if (typeof obj === "bigint") {
+    var str = `${obj}n`;
+    var result = opts.numericSeparator ? addNumericSeparator(obj, str) : str;
+    return opts.customStringify.number?.(result) ?? result;
+  }
+  if (depth >= opts.depth && opts.depth > 0 && typeof obj === "object") {
+    return Array.isArray(obj) ? "[Array]" : "[Object]";
+  }
+  if (seen.has(obj)) return "[Circular]";
+  seen.add(obj);
+  var indent = getIndentStrings(opts, depth);
+  var inspectChild = (value) => inspectValue(value, opts, depth + 1, seen);
+  if (Array.isArray(obj)) {
+    if (obj.length === 0) return "[]";
+    var entries = getObjectEntries(obj, inspectChild);
+    if (indent.base && !isSingleLine(entries)) {
+      return `[${formatMultiline(entries, indent)}]`;
+    }
+    return `[ ${entries.join(", ")} ]`;
+  }
+  if (toolkit.isObject(obj)) {
+    if (toolkit.isFunction(obj[node_util.inspect.custom])) {
+      var lineJoiner = `
+${indent.prev}`;
+      return node_util.inspect(obj, { depth: opts.depth - depth }).split("\n").join(lineJoiner);
+    }
+    var entries = getObjectEntries(obj, inspectChild);
+    if (entries.length === 0) return "{}";
+    if (indent.base) {
+      return `{${formatMultiline(entries, indent)}}`;
+    }
+    return `{ ${entries.join(", ")} }`;
+  }
+  seen.delete(obj);
+  return String(obj);
+}
+function inspect(obj, options) {
+  return inspectValue(obj, options, 0, /* @__PURE__ */ new WeakSet());
+}
+
+function parseOptions(value) {
+  const defOptions = {
+    columns: 80,
+    indent: 2,
+    depth: 5,
+    messageKey: "msg",
+    quoteStyle: "single",
+    badgeMinLevel: 40,
+    maxStringLength: 400,
+    numericSeparator: false,
+    ignore: "hostname,pid",
+    colorize: true,
+    types: {
+      number: { color: "green" },
+      boolean: { color: "redBright" },
+      string: { color: "yellow" },
+      object: { color: "gray" },
+      error: { color: "gray" },
+      errorStack: { color: "cyan" },
+      time: { color: "gray" },
+      name: { color: "rand" }
+    },
+    levels: {
+      10: { badge: "TRACE", color: "gray", icon: "\u2192" },
+      20: { badge: "DEBUG", color: "blue", icon: "\u2699" },
+      30: { badge: "INFO", color: "cyan", icon: "\u2139" },
+      40: { badge: "WARN", color: "yellow", icon: "\u26A0" },
+      50: { badge: "ERROR", color: "red", icon: "\u2716" },
+      60: { badge: "FATAL", color: "red", icon: "\u2716" }
+    }
+  };
+  const opts = toolkit.deepDefaults({}, value, defOptions);
+  const sw = new stringWidth.StringWidth({
+    extraWidths: new Map(
+      Object.values(opts.levels).map((v) => [v.icon.charCodeAt(0), 1])
+    )
+  });
+  const result = {
+    ...opts,
+    sw,
+    colorFallback: createColorizeFn(opts.colorize, "gray"),
+    inspect: {
+      depth: opts.depth,
+      quoteStyle: opts.quoteStyle,
+      indent: opts.indent,
+      maxStringLength: opts.maxStringLength,
+      numericSeparator: opts.numericSeparator,
+      customStringify: {}
+    },
+    levels: Object.fromEntries(
+      Object.entries(opts.levels).map(([key, value2]) => [
+        key,
+        {
+          ...value2,
+          color: createColorizeFn(opts.colorize, value2.color),
+          colorBadge: createColorizeBadgeFn(opts.colorize, value2.color)
+        }
+      ])
+    ),
+    types: Object.fromEntries(
+      Object.entries(opts.types).map(([key, value2]) => [
+        key,
+        {
+          ...value2,
+          color: createColorizeFn(opts.colorize, value2.color)
+        }
+      ])
+    ),
+    ignoreAdditional: /* @__PURE__ */ new Set([
+      "level",
+      "time",
+      "pid",
+      "hostname",
+      opts.messageKey,
+      opts.nestedKey ?? "",
+      "name"
+    ]),
+    ignore: new Set(
+      opts.ignore.split(",").map((v) => v.trim()).filter(Boolean)
+    )
+  };
+  result.inspect.customStringify = {
+    number: result.types.number.color,
+    boolean: result.types.boolean.color,
+    string: result.types.string.color
+  };
+  return result;
+}
+const randColor = toolkit.withCache((str) => {
+  var hash = toolkit.crc32(str) >>> 0;
+  var index = hash % RAND_COLOR_LIST.length;
+  return RAND_COLOR_LIST[index];
+});
+function createColorizeFn(colorize, value) {
+  if (!colorize) {
+    return String;
+  }
+  if (value === "rand") {
+    return (v) => getColor(randColor(v))(v);
+  }
+  var colors = toolkit.arrayable(value);
+  if (!colors.length) return String;
+  return (v) => {
+    var result = v;
+    for (var color of colors) {
+      result = getColor(color)(result);
+    }
+    return result;
+  };
+}
+function createColorizeBadgeFn(colorize, value) {
+  if (!colorize) {
+    return String;
+  }
+  if (value === "rand") {
+    return (v) => getColor(randColor(v))(v);
+  }
+  var colors = toolkit.arrayable(value).map((v) => {
+    if (v.startsWith("bg")) {
+      v = v.slice(2);
+    }
+    return `bg${toolkit.capitalize(v)}`;
+  });
+  if (!colors.length) return String;
+  colors.push("black");
+  return (v) => {
+    var result = v;
+    for (var color of colors) {
+      result = getColor(color)(result);
+    }
+    return result;
+  };
+}
+
+function isSerializedError(value) {
+  return toolkit.has(value, ["type", "message", "stack"]);
+}
+function parseStack(stack, message) {
+  const cwd = process.cwd() + path__default.sep;
+  const lines = stack.split("\n").splice(message.split("\n").length).map((l) => l.trim().replace("file://", "").replace(cwd, ""));
+  return lines;
+}
+function characterFormat(str) {
+  return str.replace(/`([^`]+)`/gm, (_, m) => getColor("cyan")(m)).replace(/\s+_([^_]+)_\s+/gm, (_, m) => ` ${getColor("underline")(m)} `);
+}
+function formatStack(stack, message, errorLevel, opts) {
+  const indent = " ".repeat(opts.indent * errorLevel);
+  const colorizeStack = opts.types.errorStack?.color || opts.colorFallback;
+  return `
+${indent}` + parseStack(stack, message).map(
+    (line) => "  " + line.replace(/\((.+)\)/, (_, m) => `(${colorizeStack(m)})`)
+  ).join(`
+${indent}`);
+}
+function formatDate(date, opts) {
+  return opts.ignore.has("time") ? "" : date.toLocaleTimeString();
+}
+function formatType(logObj, badge, opts) {
+  const levelBadge = opts.levels[logObj.level].badge || `LEVEL:${logObj.level}`;
+  if (badge) {
+    const colorize = opts.levels[logObj.level]?.colorBadge || opts.colorFallback;
+    return colorize(` ${levelBadge} `);
+  }
+  const type = opts.levels[logObj.level].icon || levelBadge;
+  const typeColor = opts.levels[logObj.level].color || opts.colorFallback;
+  return type ? typeColor(type) : "";
+}
+function filterAndJoin(arr) {
+  return arr.filter(Boolean).join(" ");
+}
+function formatError(err, errorLevel, opts) {
+  const message = (err.type ? `${err.type}: ` : "") + (err.message ?? node_util.formatWithOptions({ depth: opts.depth, colors: opts.colorize }, err));
+  const colorizeError = opts.types.error?.color || opts.colorFallback;
+  const stack = err.stack ? formatStack(err.stack, message, errorLevel, opts) : "";
+  const causedPrefix = errorLevel > 0 ? `${" ".repeat(opts.indent * errorLevel)}[cause]: ` : "";
+  const causedError = err.cause ? "\n\n" + formatError(err.cause, errorLevel + 1, opts) : "";
+  return colorizeError(causedPrefix + message + stack + causedError);
+}
+function formatAdditional(obj, opts) {
+  const additional = {};
+  let empty = true;
+  if (isSerializedError(obj)) {
+    return formatError(obj, 0, opts);
+  } else {
+    for (const key in obj) {
+      empty = false;
+      if (isSerializedError(obj[key])) {
+        additional[key] = {
+          ...obj[key],
+          [node_util.inspect.custom]: () => formatError(obj[key], 0, opts)
+        };
+      } else {
+        additional[key] = obj[key];
+      }
+    }
+  }
+  if (empty) {
+    return "";
+  }
+  const colorizeObject = opts.types.object?.color || opts.colorFallback;
+  return colorizeObject(inspect(additional, opts.inspect).slice(2, -2));
+}
+function pretty(logObj) {
+  const opts = this;
+  const message = toolkit.isString(logObj[opts.messageKey]) ? logObj[opts.messageKey] : "";
+  const additional = opts.nestedKey ? formatAdditional(logObj[opts.nestedKey], opts) : formatAdditional(toolkit.omit(logObj, opts.ignoreAdditional), opts);
+  const date = formatDate(new Date(logObj.time), opts);
+  const coloredDate = date ? opts.types.time.color(date) : "";
+  const isBadge = logObj.level >= opts.badgeMinLevel;
+  const type = formatType(logObj, isBadge, opts);
+  const name = logObj.name ? opts.types.name.color(logObj.name) : "";
+  let line;
+  const left = filterAndJoin([type, characterFormat(message)]);
+  const right = filterAndJoin([name, coloredDate]);
+  const space = opts.columns - opts.sw.width(left) - opts.sw.width(right) - 2;
+  line = space > 0 && opts.columns >= 80 ? left + " ".repeat(space) + right : (right ? `[${right}] ` : "") + left;
+  if (additional) {
+    line += "\n" + additional;
+  }
+  return isBadge ? "\n" + line + "\n" : line;
+}
+
+function prettyFactory(options) {
+  const opts = parseOptions(options);
+  return pretty.bind(opts);
+}
+function build(opts = {}) {
+  var destination;
+  return abstractTransport__default(
+    function(source) {
+      var pretty2 = prettyFactory({
+        messageKey: source.messageKey || "msg",
+        ...opts
+      });
+      const stream = new node_stream.Transform({
+        objectMode: true,
+        autoDestroy: true,
+        transform(chunk, enc, cb) {
+          const line = pretty2(chunk);
+          cb(null, line + "\n");
+        }
+      });
+      destination = buildSafeSonicBoom({
+        dest: 1,
+        append: true,
+        mkdir: true,
+        sync: false
+      });
+      source.on("unknown", function(line) {
+        destination.write(line + "\n");
+      });
+      pump__default(source, stream, destination);
+      return stream;
+    },
+    {
+      expectPinoConfig: true,
+      enablePipelining: false,
+      close(err, cb) {
+        destination.on("close", () => {
+          cb(err);
+        });
+      }
+    }
+  );
+}
+
+exports.build = build;
+exports.default = build;
+//# sourceMappingURL=index.cjs.map