@warlock.js/logger 4.0.174 → 4.1.1

package/esm/redact/redact.mjs

@@ -0,0 +1,109 @@
+//#region ../../@warlock.js/logger/src/redact/redact.ts
+/**
+* Deep-clone a value with structural fidelity for log entries — handles plain
+* objects, arrays, `Date`, `Error`, and primitives. Anything else is copied
+* by reference (we only redact paths through plain objects/arrays anyway,
+* and rebuilding e.g. a `Buffer` would change semantics).
+*
+* Purpose-built rather than reaching for `structuredClone`: `Error` instances
+* lose their `message`/`stack` under `structuredClone` in some Node versions,
+* and the logger pipeline carries them often.
+*/
+function cloneEntry(value, seen = /* @__PURE__ */ new WeakMap()) {
+	if (value === null || typeof value !== "object") return value;
+	if (seen.has(value)) return seen.get(value);
+	if (value instanceof Date) return new Date(value.getTime());
+	if (value instanceof Error) {
+		const copy = new value.constructor(value.message);
+		copy.stack = value.stack;
+		copy.name = value.name;
+		return copy;
+	}
+	if (Array.isArray(value)) {
+		const arr = [];
+		seen.set(value, arr);
+		for (const item of value) arr.push(cloneEntry(item, seen));
+		return arr;
+	}
+	const out = {};
+	seen.set(value, out);
+	for (const key of Object.keys(value)) out[key] = cloneEntry(value[key], seen);
+	return out;
+}
+/**
+* Apply a single censor decision to a value. String censors are returned
+* verbatim; function censors receive the original value plus the dotted
+* path so callers can implement value-aware redaction (mask all but the
+* last 4 chars, hash, etc.).
+*/
+function applyCensor(value, censor, path) {
+	if (typeof censor === "function") return censor(value, path.join("."));
+	return censor;
+}
+/**
+* Walk `target` following the remaining `segments` of a path pattern,
+* replacing matched leaves via `censor`. Operates in place — the caller
+* is responsible for cloning before calling.
+*
+* Wildcards:
+* - `*` matches exactly one segment (any key on a plain object, any index
+*   on an array — stringified for the path that's passed to a function
+*   censor).
+* - `**` matches zero or more segments greedily; the rest of the pattern
+*   is then attempted at the current level and at every descendant.
+*/
+function redactAtPath(target, segments, censor, pathTrail) {
+	if (target === null || typeof target !== "object") return;
+	if (segments.length === 0) return;
+	const [head, ...rest] = segments;
+	if (head === "**") {
+		if (rest.length > 0) redactAtPath(target, rest, censor, pathTrail);
+		const keys = Array.isArray(target) ? target.map((_, index) => String(index)) : Object.keys(target);
+		for (const key of keys) redactAtPath(target[key], segments, censor, [...pathTrail, key]);
+		return;
+	}
+	const keysToVisit = head === "*" ? Array.isArray(target) ? target.map((_, index) => String(index)) : Object.keys(target) : Array.isArray(target) ? /^\d+$/.test(head) && Number(head) < target.length ? [head] : [] : Object.prototype.hasOwnProperty.call(target, head) ? [head] : [];
+	for (const key of keysToVisit) if (rest.length === 0) target[key] = applyCensor(target[key], censor, [...pathTrail, key]);
+	else redactAtPath(target[key], rest, censor, [...pathTrail, key]);
+}
+/**
+* Produce a new `LoggingData` with every path in `config.paths` replaced
+* by `config.censor`. The original entry is never mutated — channels and
+* other call sites can hold references to the input safely.
+*
+* No-op (returns the input by reference) when `config` is `undefined` or
+* its `paths` array is empty, so the fast path stays fast.
+*/
+function applyRedact(data, config) {
+	if (!config || config.paths.length === 0) return data;
+	const censor = config.censor ?? "[REDACTED]";
+	const cloned = cloneEntry(data);
+	for (const pattern of config.paths) {
+		const segments = pattern.split(".").filter((segment) => segment.length > 0);
+		if (segments.length === 0) continue;
+		redactAtPath(cloned, segments, censor, []);
+	}
+	return cloned;
+}
+/**
+* Combine two redact configs into one effective config. Used to merge a
+* channel's additive paths on top of the logger-wide floor.
+*
+* - `paths` are concatenated; duplicates are kept (the matcher tolerates
+*   them, and de-duping cross-config would mask a developer typo).
+* - `censor` from the channel wins; falls back to the logger's; falls back
+*   to the default `"[REDACTED]"`.
+*/
+function mergeRedact(base, extra) {
+	if (!base && !extra) return void 0;
+	if (!base) return extra;
+	if (!extra) return base;
+	return {
+		paths: [...base.paths, ...extra.paths],
+		censor: extra.censor ?? base.censor
+	};
+}
+
+//#endregion
+export { applyRedact, mergeRedact };
+//# sourceMappingURL=redact.mjs.map

package/esm/redact/redact.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"redact.mjs","names":[],"sources":["../../../../../../@warlock.js/logger/src/redact/redact.ts"],"sourcesContent":["import type { LoggingData, RedactCensor, RedactConfig } from \"../types\";\n\n/**\n * Deep-clone a value with structural fidelity for log entries — handles plain\n * objects, arrays, `Date`, `Error`, and primitives. Anything else is copied\n * by reference (we only redact paths through plain objects/arrays anyway,\n * and rebuilding e.g. a `Buffer` would change semantics).\n *\n * Purpose-built rather than reaching for `structuredClone`: `Error` instances\n * lose their `message`/`stack` under `structuredClone` in some Node versions,\n * and the logger pipeline carries them often.\n */\nfunction cloneEntry<T>(value: T, seen = new WeakMap<object, any>()): T {\n  if (value === null || typeof value !== \"object\") {\n    return value;\n  }\n\n  if (seen.has(value as unknown as object)) {\n    return seen.get(value as unknown as object);\n  }\n\n  if (value instanceof Date) {\n    return new Date(value.getTime()) as unknown as T;\n  }\n\n  if (value instanceof Error) {\n    const copy = new (value.constructor as ErrorConstructor)(value.message);\n    copy.stack = value.stack;\n    copy.name = value.name;\n    return copy as unknown as T;\n  }\n\n  if (Array.isArray(value)) {\n    const arr: any[] = [];\n    seen.set(value as unknown as object, arr);\n    for (const item of value) {\n      arr.push(cloneEntry(item, seen));\n    }\n    return arr as unknown as T;\n  }\n\n  const out: Record<string, any> = {};\n  seen.set(value as unknown as object, out);\n  for (const key of Object.keys(value as Record<string, any>)) {\n    out[key] = cloneEntry((value as Record<string, any>)[key], seen);\n  }\n  return out as unknown as T;\n}\n\n/**\n * Apply a single censor decision to a value. String censors are returned\n * verbatim; function censors receive the original value plus the dotted\n * path so callers can implement value-aware redaction (mask all but the\n * last 4 chars, hash, etc.).\n */\nfunction applyCensor(value: any, censor: RedactCensor, path: string[]): any {\n  if (typeof censor === \"function\") {\n    return censor(value, path.join(\".\"));\n  }\n  return censor;\n}\n\n/**\n * Walk `target` following the remaining `segments` of a path pattern,\n * replacing matched leaves via `censor`. Operates in place — the caller\n * is responsible for cloning before calling.\n *\n * Wildcards:\n * - `*` matches exactly one segment (any key on a plain object, any index\n *   on an array — stringified for the path that's passed to a function\n *   censor).\n * - `**` matches zero or more segments greedily; the rest of the pattern\n *   is then attempted at the current level and at every descendant.\n */\nfunction redactAtPath(\n  target: any,\n  segments: string[],\n  censor: RedactCensor,\n  pathTrail: string[],\n): void {\n  if (target === null || typeof target !== \"object\") {\n    return;\n  }\n\n  if (segments.length === 0) {\n    return;\n  }\n\n  const [head, ...rest] = segments;\n\n  if (head === \"**\") {\n    // Try matching `rest` at the current level (the zero-segment match\n    // case), then recurse into every child carrying the `**` forward so\n    // it keeps matching at deeper levels too.\n    if (rest.length > 0) {\n      redactAtPath(target, rest, censor, pathTrail);\n    }\n    const keys = Array.isArray(target)\n      ? target.map((_, index) => String(index))\n      : Object.keys(target);\n    for (const key of keys) {\n      redactAtPath(target[key], segments, censor, [...pathTrail, key]);\n    }\n    return;\n  }\n\n  const keysToVisit =\n    head === \"*\"\n      ? Array.isArray(target)\n        ? target.map((_, index) => String(index))\n        : Object.keys(target)\n      : Array.isArray(target)\n        ? // Numeric segment can index into an array.\n          /^\\d+$/.test(head) && Number(head) < target.length\n          ? [head]\n          : []\n        : Object.prototype.hasOwnProperty.call(target, head)\n          ? [head]\n          : [];\n\n  for (const key of keysToVisit) {\n    if (rest.length === 0) {\n      target[key] = applyCensor(target[key], censor, [...pathTrail, key]);\n    } else {\n      redactAtPath(target[key], rest, censor, [...pathTrail, key]);\n    }\n  }\n}\n\n/**\n * Produce a new `LoggingData` with every path in `config.paths` replaced\n * by `config.censor`. The original entry is never mutated — channels and\n * other call sites can hold references to the input safely.\n *\n * No-op (returns the input by reference) when `config` is `undefined` or\n * its `paths` array is empty, so the fast path stays fast.\n */\nexport function applyRedact(\n  data: LoggingData,\n  config: RedactConfig | undefined,\n): LoggingData {\n  if (!config || config.paths.length === 0) {\n    return data;\n  }\n\n  const censor = config.censor ?? \"[REDACTED]\";\n  const cloned = cloneEntry(data);\n\n  for (const pattern of config.paths) {\n    const segments = pattern.split(\".\").filter((segment) => segment.length > 0);\n    if (segments.length === 0) continue;\n    redactAtPath(cloned, segments, censor, []);\n  }\n\n  return cloned;\n}\n\n/**\n * Combine two redact configs into one effective config. Used to merge a\n * channel's additive paths on top of the logger-wide floor.\n *\n * - `paths` are concatenated; duplicates are kept (the matcher tolerates\n *   them, and de-duping cross-config would mask a developer typo).\n * - `censor` from the channel wins; falls back to the logger's; falls back\n *   to the default `\"[REDACTED]\"`.\n */\nexport function mergeRedact(\n  base: RedactConfig | undefined,\n  extra: RedactConfig | undefined,\n): RedactConfig | undefined {\n  if (!base && !extra) return undefined;\n  if (!base) return extra;\n  if (!extra) return base;\n\n  return {\n    paths: [...base.paths, ...extra.paths],\n    censor: extra.censor ?? base.censor,\n  };\n}\n"],"mappings":"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"}

package/esm/types.d.mts

@@ -0,0 +1,129 @@
+//#region ../../@warlock.js/logger/src/types.d.ts
+type LogLevel = "debug" | "info" | "warn" | "error" | "success";
+/**
+ * Process-level events that `Logger.enableAutoFlush()` can hook to drain
+ * buffered channels before the process terminates.
+ *
+ * - Signals (`SIGINT`, `SIGTERM`, `SIGHUP`, `SIGBREAK`, `SIGUSR2`) are flushed
+ *   then re-raised so Node's default exit behavior runs.
+ * - `beforeExit` is flushed in place — Node exits on its own afterwards.
+ */
+type AutoFlushEvent = "SIGINT" | "SIGTERM" | "SIGHUP" | "SIGBREAK" | "SIGUSR2" | "beforeExit";
+type DebugMode = "daily" | "monthly" | "yearly" | "hourly";
+/**
+ * Replacement value used by `RedactConfig`. Either a literal string
+ * (e.g. `"[REDACTED]"`) or a function that receives the original value plus
+ * the dotted path it sits at and returns whatever should replace it.
+ */
+type RedactCensor = string | ((value: any, path: string) => any);
+/**
+ * Strip sensitive fields from log entries before they reach a channel.
+ *
+ * Paths are dotted glob patterns evaluated against the `LoggingData` itself —
+ * use `context.password`, `message.token`, etc. Wildcards:
+ *
+ * - `*`  — matches a single segment (any one key)
+ * - `**` — matches zero or more segments (any depth, any key)
+ *
+ * Configurable in two places:
+ *
+ * 1. **Logger-wide** via `Logger.configure({ redact })` — applied once before
+ *    fan-out. This is the security floor; no channel can undo it.
+ * 2. **Per channel** via the channel's options. Channel paths are *additive*:
+ *    they extend (never replace) the logger-wide list, so a channel can only
+ *    redact more, never less.
+ *
+ * @example
+ * logger.configure({
+ *   redact: {
+ *     paths: ["context.password", "context.*.token", "context.headers.authorization"],
+ *     censor: "[REDACTED]",
+ *   },
+ * });
+ */
+type RedactConfig = {
+  /**
+   * Glob path patterns to redact. Paths are evaluated against the full
+   * `LoggingData` object — so prefix with `context.` or `message.` to scope
+   * to either field.
+   */
+  paths: string[];
+  /**
+   * Replacement applied at each matched path.
+   *
+   * @default "[REDACTED]"
+   */
+  censor?: RedactCensor;
+};
+type BasicLogConfigurations = {
+  /**
+   * Set what level of logs should be logged
+   *
+   * @default all
+   */
+  levels?: LogLevel[];
+  /**
+   * Date and time format
+   */
+  dateFormat?: {
+    date?: string;
+    time?: string;
+  };
+  /**
+   * Advanced filter to determine if the message should be logged or not
+   */
+  filter?: (data: LoggingData) => boolean;
+  /**
+   * Add additional context to the log
+   */
+  context?: (data: LoggingData) => Promise<Record<string, any>>;
+  /**
+   * Channel-specific redaction. Additive on top of the logger-wide config —
+   * the channel's paths extend (never replace) the logger floor. The
+   * `censor` here, when omitted, falls back to the logger-wide censor.
+   */
+  redact?: RedactConfig;
+};
+type LogMessage = {
+  content: string;
+  level: LogLevel;
+  date: string;
+  module: string;
+  action: string;
+  stack?: string;
+  context?: Record<string, any>;
+  timestamp?: string;
+};
+interface LogContract {
+  /**
+   * Channel name
+   */
+  name: string;
+  /**
+   * Channel description
+   */
+  description?: string;
+  /**
+   * Determine if channel is logging in terminal
+   */
+  terminal?: boolean;
+  /**
+   * Log the given message
+   */
+  log(data: LoggingData): void | Promise<void>;
+  /**
+   * Synchronously flush logs
+   */
+  flushSync?(): void;
+}
+type LoggingData = {
+  type: "info" | "debug" | "warn" | "error" | "success";
+  module: string;
+  action: string;
+  message: any;
+  context?: Record<string, any>;
+};
+type OmittedLoggingData = Omit<LoggingData, "type">;
+//#endregion
+export { AutoFlushEvent, BasicLogConfigurations, DebugMode, LogContract, LogLevel, LogMessage, LoggingData, OmittedLoggingData, RedactCensor, RedactConfig };
+//# sourceMappingURL=types.d.mts.map

package/esm/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../../@warlock.js/logger/src/types.ts"],"mappings":";KAAY,QAAA;AAAZ;;;;AAAoB;AAUpB;;;AAVA,KAUY,cAAA;AAAA,KAQA,SAAA;AAAZ;;;;AAAqB;AAArB,KAOY,YAAA,cAEN,KAAA,OAAY,IAAY;;;;AAAA;AA2B9B;;;;;;;;AAYuB;AAGvB;;;;;;;;;;;;KAfY,YAAA;EAyBV;;;;;EAnBA,KAAA;EA8BA;;;;;EAxBA,MAAA,GAAS,YAAY;AAAA;AAAA,KAGX,sBAAA;EA2BW;AAGvB;;;;EAxBE,MAAA,GAAS,QAAA;EA0BT;;;EAtBA,UAAA;IACE,IAAA;IACA,IAAA;EAAA;EAyBQ;;;EApBV,MAAA,IAAU,IAAA,EAAM,WAAA;EAwBD;;;EApBf,OAAA,IAAW,IAAA,EAAM,WAAA,KAAgB,OAAA,CAAQ,MAAA;EAwBzC;;;;;EAlBA,MAAA,GAAS,YAAA;AAAA;AAAA,KAGC,UAAA;EACV,OAAA;EACA,KAAA,EAAO,QAAA;EACP,IAAA;EACA,MAAA;EACA,MAAA;EACA,KAAA;EACA,OAAA,GAAU,MAAM;EAChB,SAAA;AAAA;AAAA,UAGe,WAAA;EAgCf;;;EA5BA,IAAA;EA+BU;;;EA1BV,WAAA;EA0B+C;;;EArB/C,QAAA;;;;EAKA,GAAA,CAAI,IAAA,EAAM,WAAA,UAAqB,OAAO;;;;EAKtC,SAAA;AAAA;AAAA,KAGU,WAAA;EACV,IAAA;EACA,MAAA;EACA,MAAA;EACA,OAAA;EACA,OAAA,GAAU,MAAM;AAAA;AAAA,KAGN,kBAAA,GAAqB,IAAI,CAAC,WAAA"}

package/esm/utils/capture-unhandled-errors.d.mts

@@ -0,0 +1,16 @@
+//#region ../../@warlock.js/logger/src/utils/capture-unhandled-errors.d.ts
+/**
+ * Route Node's process-level failure events through the logger so they land in
+ * every configured channel with full stack context. Registers one listener for
+ * `unhandledRejection` and one for `uncaughtException`; call once at startup
+ * after channels are configured. Pair with `autoFlushOn: ["beforeExit"]` so the
+ * final entry survives the process exit that follows an uncaught exception.
+ *
+ * @example
+ * log.configure({ channels: [new ConsoleLog(), new FileLog()] });
+ * captureAnyUnhandledRejection();
+ */
+declare function captureAnyUnhandledRejection(): void;
+//#endregion
+export { captureAnyUnhandledRejection };
+//# sourceMappingURL=capture-unhandled-errors.d.mts.map

package/esm/utils/capture-unhandled-errors.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capture-unhandled-errors.d.mts","names":[],"sources":["../../../../../../@warlock.js/logger/src/utils/capture-unhandled-errors.ts"],"mappings":";;AAaA;;;;AAA4C;;;;;;iBAA5B,4BAAA,CAAA"}

package/esm/utils/capture-unhandled-errors.mjs

@@ -0,0 +1,26 @@
+import { log } from "../logger.mjs";
+
+//#region ../../@warlock.js/logger/src/utils/capture-unhandled-errors.ts
+/**
+* Route Node's process-level failure events through the logger so they land in
+* every configured channel with full stack context. Registers one listener for
+* `unhandledRejection` and one for `uncaughtException`; call once at startup
+* after channels are configured. Pair with `autoFlushOn: ["beforeExit"]` so the
+* final entry survives the process exit that follows an uncaught exception.
+*
+* @example
+* log.configure({ channels: [new ConsoleLog(), new FileLog()] });
+* captureAnyUnhandledRejection();
+*/
+function captureAnyUnhandledRejection() {
+	process.on("unhandledRejection", (reason) => {
+		log.error("app", "unhandledRejection", reason);
+	});
+	process.on("uncaughtException", (error) => {
+		log.error("app", "uncaughtException", error);
+	});
+}
+
+//#endregion
+export { captureAnyUnhandledRejection };
+//# sourceMappingURL=capture-unhandled-errors.mjs.map

package/esm/utils/capture-unhandled-errors.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"capture-unhandled-errors.mjs","names":[],"sources":["../../../../../../@warlock.js/logger/src/utils/capture-unhandled-errors.ts"],"sourcesContent":["import { log } from \"../logger\";\r\n\r\n/**\r\n * Route Node's process-level failure events through the logger so they land in\r\n * every configured channel with full stack context. Registers one listener for\r\n * `unhandledRejection` and one for `uncaughtException`; call once at startup\r\n * after channels are configured. Pair with `autoFlushOn: [\"beforeExit\"]` so the\r\n * final entry survives the process exit that follows an uncaught exception.\r\n *\r\n * @example\r\n * log.configure({ channels: [new ConsoleLog(), new FileLog()] });\r\n * captureAnyUnhandledRejection();\r\n */\r\nexport function captureAnyUnhandledRejection() {\r\n  process.on(\"unhandledRejection\", (reason: any) => {\r\n    log.error(\"app\", \"unhandledRejection\", reason);\r\n  });\r\n\r\n  process.on(\"uncaughtException\", (error) => {\r\n    log.error(\"app\", \"uncaughtException\", error);\r\n  });\r\n}\r\n"],"mappings":";;;;;;;;;;;;;;AAaA,SAAgB,+BAA+B;CAC7C,QAAQ,GAAG,uBAAuB,WAAgB;EAChD,IAAI,MAAM,OAAO,sBAAsB,MAAM;CAC/C,CAAC;CAED,QAAQ,GAAG,sBAAsB,UAAU;EACzC,IAAI,MAAM,OAAO,qBAAqB,KAAK;CAC7C,CAAC;AACH"}

package/esm/utils/clear-message.d.mts

@@ -0,0 +1,8 @@
+//#region ../../@warlock.js/logger/src/utils/clear-message.d.ts
+/**
+ * Clear message from any terminal codes
+ */
+declare function clearMessage(message: any): any;
+//#endregion
+export { clearMessage };
+//# sourceMappingURL=clear-message.d.mts.map

package/esm/utils/clear-message.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clear-message.d.mts","names":[],"sources":["../../../../../../@warlock.js/logger/src/utils/clear-message.ts"],"mappings":";;AAGA;;iBAAgB,YAAA,CAAa,OAAY"}

package/esm/utils/clear-message.mjs

@@ -0,0 +1,12 @@
+//#region ../../@warlock.js/logger/src/utils/clear-message.ts
+/**
+* Clear message from any terminal codes
+*/
+function clearMessage(message) {
+	if (typeof message !== "string") return message;
+	return message.replace(/\u001b[^m]*?m/g, "");
+}
+
+//#endregion
+export { clearMessage };
+//# sourceMappingURL=clear-message.mjs.map

package/esm/utils/clear-message.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"clear-message.mjs","names":[],"sources":["../../../../../../@warlock.js/logger/src/utils/clear-message.ts"],"sourcesContent":["/**\r\n * Clear message from any terminal codes\r\n */\r\nexport function clearMessage(message: any) {\r\n  if (typeof message !== \"string\") return message;\r\n\r\n  // eslint-disable-next-line no-control-regex\r\n  return message.replace(/\\u001b[^m]*?m/g, \"\");\r\n}\r\n"],"mappings":";;;;AAGA,SAAgB,aAAa,SAAc;CACzC,IAAI,OAAO,YAAY,UAAU,OAAO;CAGxC,OAAO,QAAQ,QAAQ,kBAAkB,EAAE;AAC7C"}

package/esm/utils/index.mjs

@@ -0,0 +1,5 @@
+import { safeJsonStringify } from "./safe-json-stringify.mjs";
+import { clearMessage } from "./clear-message.mjs";
+import { captureAnyUnhandledRejection } from "./capture-unhandled-errors.mjs";
+
+export {  };

package/esm/utils/safe-json-stringify.d.mts

@@ -0,0 +1,14 @@
+//#region ../../@warlock.js/logger/src/utils/safe-json-stringify.d.ts
+/**
+ * JSON-serialize log payloads safely. Circular refs, BigInt, and repeated
+ * non-tree references are handled by `safe-stable-stringify`; functions and
+ * symbols are dropped (standard JSON behavior); Errors are expanded via
+ * `errorReplacer`. Class instances serialize as their enumerable props.
+ *
+ * @example
+ * await fs.promises.writeFile(filePath, safeJsonStringify(payload, 2));
+ */
+declare function safeJsonStringify(value: unknown, space?: number): string;
+//#endregion
+export { safeJsonStringify };
+//# sourceMappingURL=safe-json-stringify.d.mts.map

package/esm/utils/safe-json-stringify.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safe-json-stringify.d.mts","names":[],"sources":["../../../../../../@warlock.js/logger/src/utils/safe-json-stringify.ts"],"mappings":";;AAyCA;;;;AAAgE;;;;iBAAhD,iBAAA,CAAkB,KAAA,WAAgB,KAAc"}

package/esm/utils/safe-json-stringify.mjs

@@ -0,0 +1,35 @@
+import { stringify } from "safe-stable-stringify";
+
+//#region ../../@warlock.js/logger/src/utils/safe-json-stringify.ts
+/**
+* Replacer that surfaces Error data — `name`, `message`, and `stack` are
+* non-enumerable on `Error`, so neither default JSON serialization nor an
+* object spread captures them (both produce `{}`). They are copied explicitly;
+* the trailing spread then captures any additional enumerable props the caller
+* (or a subclass) attached, such as a `code` field.
+*/
+function errorReplacer(_key, value) {
+	if (value instanceof Error) return {
+		...value,
+		name: value.name,
+		message: value.message,
+		stack: value.stack
+	};
+	return value;
+}
+/**
+* JSON-serialize log payloads safely. Circular refs, BigInt, and repeated
+* non-tree references are handled by `safe-stable-stringify`; functions and
+* symbols are dropped (standard JSON behavior); Errors are expanded via
+* `errorReplacer`. Class instances serialize as their enumerable props.
+*
+* @example
+* await fs.promises.writeFile(filePath, safeJsonStringify(payload, 2));
+*/
+function safeJsonStringify(value, space) {
+	return stringify(value, errorReplacer, space) ?? "";
+}
+
+//#endregion
+export { safeJsonStringify };
+//# sourceMappingURL=safe-json-stringify.mjs.map

package/esm/utils/safe-json-stringify.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"safe-json-stringify.mjs","names":["safeStableStringify"],"sources":["../../../../../../@warlock.js/logger/src/utils/safe-json-stringify.ts"],"sourcesContent":["import { stringify as safeStableStringify } from \"safe-stable-stringify\";\n\n/**\n * Replacer that surfaces Error data — `name`, `message`, and `stack` are\n * non-enumerable on `Error`, so neither default JSON serialization nor an\n * object spread captures them (both produce `{}`). They are copied explicitly;\n * the trailing spread then captures any additional enumerable props the caller\n * (or a subclass) attached, such as a `code` field.\n */\nfunction errorReplacer<Value = unknown>(\n  _key: string,\n  value: Value,\n): Record<string, unknown> | Value {\n  if (value instanceof Error) {\n    // Spread first, then the explicit Error fields. `name`/`message`/`stack`\n    // are non-enumerable on `Error`, so the spread never carries them — the\n    // explicit assignments are what surface them. Placing the spread first\n    // means those explicit keys legitimately take precedence over any\n    // identically-named *enumerable* prop a subclass attached (resolving the\n    // duplicate-key warning). Because `safe-stable-stringify` sorts keys, the\n    // insertion order here does not affect the serialized bytes.\n    return {\n      ...value,\n      name: value.name,\n      message: value.message,\n      stack: value.stack,\n    };\n  }\n\n  return value;\n}\n\n/**\n * JSON-serialize log payloads safely. Circular refs, BigInt, and repeated\n * non-tree references are handled by `safe-stable-stringify`; functions and\n * symbols are dropped (standard JSON behavior); Errors are expanded via\n * `errorReplacer`. Class instances serialize as their enumerable props.\n *\n * @example\n * await fs.promises.writeFile(filePath, safeJsonStringify(payload, 2));\n */\nexport function safeJsonStringify(value: unknown, space?: number): string {\n  return safeStableStringify(value, errorReplacer, space) ?? \"\";\n}\n"],"mappings":";;;;;;;;;;AASA,SAAS,cACP,MACA,OACiC;CACjC,IAAI,iBAAiB,OAQnB,OAAO;EACL,GAAG;EACH,MAAM,MAAM;EACZ,SAAS,MAAM;EACf,OAAO,MAAM;CACf;CAGF,OAAO;AACT;;;;;;;;;;AAWA,SAAgB,kBAAkB,OAAgB,OAAwB;CACxE,OAAOA,UAAoB,OAAO,eAAe,KAAK,KAAK;AAC7D"}