@logtape/logtape 0.11.0 → 0.12.0-dev.182

package/dist/formatter.cjs

@@ -0,0 +1,281 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const __util = require_rolldown_runtime.__toESM(require("#util"));
+
+//#region formatter.ts
+/**
+* The severity level abbreviations.
+*/
+const levelAbbreviations = {
+	"debug": "DBG",
+	"info": "INF",
+	"warning": "WRN",
+	"error": "ERR",
+	"fatal": "FTL"
+};
+/**
+* A platform-specific inspect function.  In Deno, this is {@link Deno.inspect},
+* and in Node.js/Bun it is `util.inspect()`.  If neither is available, it
+* falls back to {@link JSON.stringify}.
+*
+* @param value The value to inspect.
+* @param options The options for inspecting the value.
+*                If `colors` is `true`, the output will be ANSI-colored.
+* @returns The string representation of the value.
+*/
+const inspect = typeof document !== "undefined" || typeof navigator !== "undefined" && navigator.product === "ReactNative" ? (v) => JSON.stringify(v) : "Deno" in globalThis && "inspect" in globalThis.Deno && typeof globalThis.Deno.inspect === "function" ? (v, opts) => globalThis.Deno.inspect(v, {
+	strAbbreviateSize: Infinity,
+	iterableLimit: Infinity,
+	...opts
+}) : __util != null && "inspect" in __util && typeof __util.inspect === "function" ? (v, opts) => __util.inspect(v, {
+	maxArrayLength: Infinity,
+	maxStringLength: Infinity,
+	...opts
+}) : (v) => JSON.stringify(v);
+/**
+* Get a text formatter with the specified options.  Although it's flexible
+* enough to create a custom formatter, if you want more control, you can
+* create a custom formatter that satisfies the {@link TextFormatter} type
+* instead.
+*
+* For more information on the options, see {@link TextFormatterOptions}.
+*
+* By default, the formatter formats log records as follows:
+*
+* ```
+* 2023-11-14 22:13:20.000 +00:00 [INF] category·subcategory: Hello, world!
+* ```
+* @param options The options for the text formatter.
+* @returns The text formatter.
+* @since 0.6.0
+*/
+function getTextFormatter(options = {}) {
+	const timestampRenderer = options.timestamp == null || options.timestamp === "date-time-timezone" ? (ts) => new Date(ts).toISOString().replace("T", " ").replace("Z", " +00:00") : options.timestamp === "date-time-tz" ? (ts) => new Date(ts).toISOString().replace("T", " ").replace("Z", " +00") : options.timestamp === "date-time" ? (ts) => new Date(ts).toISOString().replace("T", " ").replace("Z", "") : options.timestamp === "time-timezone" ? (ts) => new Date(ts).toISOString().replace(/.*T/, "").replace("Z", " +00:00") : options.timestamp === "time-tz" ? (ts) => new Date(ts).toISOString().replace(/.*T/, "").replace("Z", " +00") : options.timestamp === "time" ? (ts) => new Date(ts).toISOString().replace(/.*T/, "").replace("Z", "") : options.timestamp === "date" ? (ts) => new Date(ts).toISOString().replace(/T.*/, "") : options.timestamp === "rfc3339" ? (ts) => new Date(ts).toISOString() : options.timestamp === "none" || options.timestamp === "disabled" ? () => null : options.timestamp;
+	const categorySeparator = options.category ?? "·";
+	const valueRenderer = options.value ?? inspect;
+	const levelRenderer = options.level == null || options.level === "ABBR" ? (level) => levelAbbreviations[level] : options.level === "abbr" ? (level) => levelAbbreviations[level].toLowerCase() : options.level === "FULL" ? (level) => level.toUpperCase() : options.level === "full" ? (level) => level : options.level === "L" ? (level) => level.charAt(0).toUpperCase() : options.level === "l" ? (level) => level.charAt(0) : options.level;
+	const formatter = options.format ?? (({ timestamp, level, category, message }) => `${timestamp ? `${timestamp} ` : ""}[${level}] ${category}: ${message}`);
+	return (record) => {
+		let message = "";
+		for (let i = 0; i < record.message.length; i++) if (i % 2 === 0) message += record.message[i];
+		else message += valueRenderer(record.message[i]);
+		const timestamp = timestampRenderer(record.timestamp);
+		const level = levelRenderer(record.level);
+		const category = typeof categorySeparator === "function" ? categorySeparator(record.category) : record.category.join(categorySeparator);
+		const values = {
+			timestamp,
+			level,
+			category,
+			message,
+			record
+		};
+		return `${formatter(values)}\n`;
+	};
+}
+/**
+* The default text formatter.  This formatter formats log records as follows:
+*
+* ```
+* 2023-11-14 22:13:20.000 +00:00 [INF] category·subcategory: Hello, world!
+* ```
+*
+* @param record The log record to format.
+* @returns The formatted log record.
+*/
+const defaultTextFormatter = getTextFormatter();
+const RESET = "\x1B[0m";
+const ansiColors = {
+	black: "\x1B[30m",
+	red: "\x1B[31m",
+	green: "\x1B[32m",
+	yellow: "\x1B[33m",
+	blue: "\x1B[34m",
+	magenta: "\x1B[35m",
+	cyan: "\x1B[36m",
+	white: "\x1B[37m"
+};
+const ansiStyles = {
+	bold: "\x1B[1m",
+	dim: "\x1B[2m",
+	italic: "\x1B[3m",
+	underline: "\x1B[4m",
+	strikethrough: "\x1B[9m"
+};
+const defaultLevelColors = {
+	debug: "blue",
+	info: "green",
+	warning: "yellow",
+	error: "red",
+	fatal: "magenta"
+};
+/**
+* Get an ANSI color formatter with the specified options.
+*
+* ![A preview of an ANSI color formatter.](https://i.imgur.com/I8LlBUf.png)
+* @param option The options for the ANSI color formatter.
+* @returns The ANSI color formatter.
+* @since 0.6.0
+*/
+function getAnsiColorFormatter(options = {}) {
+	const format = options.format;
+	const timestampStyle = typeof options.timestampStyle === "undefined" ? "dim" : options.timestampStyle;
+	const timestampColor = options.timestampColor ?? null;
+	const timestampPrefix = `${timestampStyle == null ? "" : ansiStyles[timestampStyle]}${timestampColor == null ? "" : ansiColors[timestampColor]}`;
+	const timestampSuffix = timestampStyle == null && timestampColor == null ? "" : RESET;
+	const levelStyle = typeof options.levelStyle === "undefined" ? "bold" : options.levelStyle;
+	const levelColors = options.levelColors ?? defaultLevelColors;
+	const categoryStyle = typeof options.categoryStyle === "undefined" ? "dim" : options.categoryStyle;
+	const categoryColor = options.categoryColor ?? null;
+	const categoryPrefix = `${categoryStyle == null ? "" : ansiStyles[categoryStyle]}${categoryColor == null ? "" : ansiColors[categoryColor]}`;
+	const categorySuffix = categoryStyle == null && categoryColor == null ? "" : RESET;
+	return getTextFormatter({
+		timestamp: "date-time-tz",
+		value(value) {
+			return inspect(value, { colors: true });
+		},
+		...options,
+		format({ timestamp, level, category, message, record }) {
+			const levelColor = levelColors[record.level];
+			timestamp = `${timestampPrefix}${timestamp}${timestampSuffix}`;
+			level = `${levelStyle == null ? "" : ansiStyles[levelStyle]}${levelColor == null ? "" : ansiColors[levelColor]}${level}${levelStyle == null && levelColor == null ? "" : RESET}`;
+			return format == null ? `${timestamp} ${level} ${categoryPrefix}${category}:${categorySuffix} ${message}` : format({
+				timestamp,
+				level,
+				category: `${categoryPrefix}${category}${categorySuffix}`,
+				message,
+				record
+			});
+		}
+	});
+}
+/**
+* A text formatter that uses ANSI colors to format log records.
+*
+* ![A preview of ansiColorFormatter.](https://i.imgur.com/I8LlBUf.png)
+*
+* @param record The log record to format.
+* @returns The formatted log record.
+* @since 0.5.0
+*/
+const ansiColorFormatter = getAnsiColorFormatter();
+/**
+* Get a [JSON Lines] formatter with the specified options.  The log records
+* will be rendered as JSON objects, one per line, which is a common format
+* for log files.  This format is also known as Newline-Delimited JSON (NDJSON).
+* It looks like this:
+*
+* ```json
+* {"@timestamp":"2023-11-14T22:13:20.000Z","level":"INFO","message":"Hello, world!","logger":"my.logger","properties":{"key":"value"}}
+* ```
+*
+* [JSON Lines]: https://jsonlines.org/
+* @param options The options for the JSON Lines formatter.
+* @returns The JSON Lines formatter.
+* @since 0.11.0
+*/
+function getJsonLinesFormatter(options = {}) {
+	let joinCategory;
+	if (typeof options.categorySeparator === "function") joinCategory = options.categorySeparator;
+	else {
+		const separator = options.categorySeparator ?? ".";
+		joinCategory = (category) => category.join(separator);
+	}
+	let getMessage;
+	if (options.message === "template") getMessage = (record) => {
+		if (typeof record.rawMessage === "string") return record.rawMessage;
+		let msg = "";
+		for (let i = 0; i < record.rawMessage.length; i++) msg += i % 2 < 1 ? record.rawMessage[i] : "{}";
+		return msg;
+	};
+	else getMessage = (record) => {
+		let msg = "";
+		for (let i = 0; i < record.message.length; i++) msg += i % 2 < 1 ? record.message[i] : JSON.stringify(record.message[i]);
+		return msg;
+	};
+	const propertiesOption = options.properties ?? "nest:properties";
+	let getProperties;
+	if (propertiesOption === "flatten") getProperties = (properties) => properties;
+	else if (propertiesOption.startsWith("prepend:")) {
+		const prefix = propertiesOption.substring(8);
+		if (prefix === "") throw new TypeError(`Invalid properties option: ${JSON.stringify(propertiesOption)}. It must be of the form "prepend:<prefix>" where <prefix> is a non-empty string.`);
+		getProperties = (properties) => {
+			const result = {};
+			for (const key in properties) result[`${prefix}${key}`] = properties[key];
+			return result;
+		};
+	} else if (propertiesOption.startsWith("nest:")) {
+		const key = propertiesOption.substring(5);
+		getProperties = (properties) => ({ [key]: properties });
+	} else throw new TypeError(`Invalid properties option: ${JSON.stringify(propertiesOption)}. It must be "flatten", "prepend:<prefix>", or "nest:<key>".`);
+	return (record) => {
+		return JSON.stringify({
+			"@timestamp": new Date(record.timestamp).toISOString(),
+			level: record.level === "warning" ? "WARN" : record.level.toUpperCase(),
+			message: getMessage(record),
+			logger: joinCategory(record.category),
+			...getProperties(record.properties)
+		});
+	};
+}
+/**
+* The default [JSON Lines] formatter.  This formatter formats log records
+* as JSON objects, one per line, which is a common format for log files.
+* It looks like this:
+*
+* ```json
+* {"@timestamp":"2023-11-14T22:13:20.000Z","level":"INFO","message":"Hello, world!","logger":"my.logger","properties":{"key":"value"}}
+* ```
+*
+* You can customize the output by passing options to
+* {@link getJsonLinesFormatter}.  For example, you can change the category
+* separator, the message format, and how the properties are formatted.
+*
+* [JSON Lines]: https://jsonlines.org/
+* @since 0.11.0
+*/
+const jsonLinesFormatter = getJsonLinesFormatter();
+/**
+* The styles for the log level in the console.
+*/
+const logLevelStyles = {
+	"debug": "background-color: gray; color: white;",
+	"info": "background-color: white; color: black;",
+	"warning": "background-color: orange; color: black;",
+	"error": "background-color: red; color: white;",
+	"fatal": "background-color: maroon; color: white;"
+};
+/**
+* The default console formatter.
+*
+* @param record The log record to format.
+* @returns The formatted log record, as an array of arguments for
+*          {@link console.log}.
+*/
+function defaultConsoleFormatter(record) {
+	let msg = "";
+	const values = [];
+	for (let i = 0; i < record.message.length; i++) if (i % 2 === 0) msg += record.message[i];
+	else {
+		msg += "%o";
+		values.push(record.message[i]);
+	}
+	const date = new Date(record.timestamp);
+	const time = `${date.getUTCHours().toString().padStart(2, "0")}:${date.getUTCMinutes().toString().padStart(2, "0")}:${date.getUTCSeconds().toString().padStart(2, "0")}.${date.getUTCMilliseconds().toString().padStart(3, "0")}`;
+	return [
+		`%c${time} %c${levelAbbreviations[record.level]}%c %c${record.category.join("·")} %c${msg}`,
+		"color: gray;",
+		logLevelStyles[record.level],
+		"background-color: default;",
+		"color: gray;",
+		"color: default;",
+		...values
+	];
+}
+
+//#endregion
+exports.ansiColorFormatter = ansiColorFormatter;
+exports.defaultConsoleFormatter = defaultConsoleFormatter;
+exports.defaultTextFormatter = defaultTextFormatter;
+exports.getAnsiColorFormatter = getAnsiColorFormatter;
+exports.getJsonLinesFormatter = getJsonLinesFormatter;
+exports.getTextFormatter = getTextFormatter;
+exports.jsonLinesFormatter = jsonLinesFormatter;

package/dist/formatter.d.cts

@@ -0,0 +1,338 @@
+import { LogLevel } from "./level.cjs";
+import { LogRecord } from "./record.cjs";
+
+//#region formatter.d.ts
+
+/**
+ * A text formatter is a function that accepts a log record and returns
+ * a string.
+ *
+ * @param record The log record to format.
+ * @returns The formatted log record.
+ */
+type TextFormatter = (record: LogRecord) => string;
+/**
+ * The formatted values for a log record.
+ * @since 0.6.0
+ */
+interface FormattedValues {
+  /**
+   * The formatted timestamp.
+   */
+  timestamp: string | null;
+  /**
+   * The formatted log level.
+   */
+  level: string;
+  /**
+   * The formatted category.
+   */
+  category: string;
+  /**
+   * The formatted message.
+   */
+  message: string;
+  /**
+   * The unformatted log record.
+   */
+  record: LogRecord;
+}
+/**
+ * The various options for the built-in text formatters.
+ * @since 0.6.0
+ */
+interface TextFormatterOptions {
+  /**
+   * The timestamp format.  This can be one of the following:
+   *
+   * - `"date-time-timezone"`: The date and time with the full timezone offset
+   *   (e.g., `"2023-11-14 22:13:20.000 +00:00"`).
+   * - `"date-time-tz"`: The date and time with the short timezone offset
+   *   (e.g., `"2023-11-14 22:13:20.000 +00"`).
+   * - `"date-time"`: The date and time without the timezone offset
+   *   (e.g., `"2023-11-14 22:13:20.000"`).
+   * - `"time-timezone"`: The time with the full timezone offset but without
+   *   the date (e.g., `"22:13:20.000 +00:00"`).
+   * - `"time-tz"`: The time with the short timezone offset but without the date
+   *   (e.g., `"22:13:20.000 +00"`).
+   * - `"time"`: The time without the date or timezone offset
+   *   (e.g., `"22:13:20.000"`).
+   * - `"date"`: The date without the time or timezone offset
+   *   (e.g., `"2023-11-14"`).
+   * - `"rfc3339"`: The date and time in RFC 3339 format
+   *   (e.g., `"2023-11-14T22:13:20.000Z"`).
+   * - `"none"` or `"disabled"`: No display
+   *
+   * Alternatively, this can be a function that accepts a timestamp and returns
+   * a string.
+   *
+   * The default is `"date-time-timezone"`.
+   */
+  timestamp?: "date-time-timezone" | "date-time-tz" | "date-time" | "time-timezone" | "time-tz" | "time" | "date" | "rfc3339" | "none" | "disabled" | ((ts: number) => string | null);
+  /**
+   * The log level format.  This can be one of the following:
+   *
+   * - `"ABBR"`: The log level abbreviation in uppercase (e.g., `"INF"`).
+   * - `"FULL"`: The full log level name in uppercase (e.g., `"INFO"`).
+   * - `"L"`: The first letter of the log level in uppercase (e.g., `"I"`).
+   * - `"abbr"`: The log level abbreviation in lowercase (e.g., `"inf"`).
+   * - `"full"`: The full log level name in lowercase (e.g., `"info"`).
+   * - `"l"`: The first letter of the log level in lowercase (e.g., `"i"`).
+   *
+   * Alternatively, this can be a function that accepts a log level and returns
+   * a string.
+   *
+   * The default is `"ABBR"`.
+   */
+  level?: "ABBR" | "FULL" | "L" | "abbr" | "full" | "l" | ((level: LogLevel) => string);
+  /**
+   * The separator between category names.  For example, if the separator is
+   * `"·"`, the category `["a", "b", "c"]` will be formatted as `"a·b·c"`.
+   * The default separator is `"·"`.
+   *
+   * If this is a function, it will be called with the category array and
+   * should return a string, which will be used for rendering the category.
+   */
+  category?: string | ((category: readonly string[]) => string);
+  /**
+   * The format of the embedded values.
+   *
+   * A function that renders a value to a string.  This function is used to
+   * render the values in the log record.  The default is [`util.inspect()`] in
+   * Node.js/Bun and [`Deno.inspect()`] in Deno.
+   *
+   * [`util.inspect()`]: https://nodejs.org/api/util.html#utilinspectobject-options
+   * [`Deno.inspect()`]: https://docs.deno.com/api/deno/~/Deno.inspect
+   * @param value The value to render.
+   * @returns The string representation of the value.
+   */
+  value?: (value: unknown) => string;
+  /**
+   * How those formatted parts are concatenated.
+   *
+   * A function that formats the log record.  This function is called with the
+   * formatted values and should return a string.  Note that the formatted
+   * *should not* include a newline character at the end.
+   *
+   * By default, this is a function that formats the log record as follows:
+   *
+   * ```
+   * 2023-11-14 22:13:20.000 +00:00 [INF] category·subcategory: Hello, world!
+   * ```
+   * @param values The formatted values.
+   * @returns The formatted log record.
+   */
+  format?: (values: FormattedValues) => string;
+}
+/**
+ * Get a text formatter with the specified options.  Although it's flexible
+ * enough to create a custom formatter, if you want more control, you can
+ * create a custom formatter that satisfies the {@link TextFormatter} type
+ * instead.
+ *
+ * For more information on the options, see {@link TextFormatterOptions}.
+ *
+ * By default, the formatter formats log records as follows:
+ *
+ * ```
+ * 2023-11-14 22:13:20.000 +00:00 [INF] category·subcategory: Hello, world!
+ * ```
+ * @param options The options for the text formatter.
+ * @returns The text formatter.
+ * @since 0.6.0
+ */
+declare function getTextFormatter(options?: TextFormatterOptions): TextFormatter;
+/**
+ * The default text formatter.  This formatter formats log records as follows:
+ *
+ * ```
+ * 2023-11-14 22:13:20.000 +00:00 [INF] category·subcategory: Hello, world!
+ * ```
+ *
+ * @param record The log record to format.
+ * @returns The formatted log record.
+ */
+declare const defaultTextFormatter: TextFormatter;
+/**
+ * The ANSI colors.  These can be used to colorize text in the console.
+ * @since 0.6.0
+ */
+type AnsiColor = "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white";
+/**
+ * The ANSI text styles.
+ * @since 0.6.0
+ */
+type AnsiStyle = "bold" | "dim" | "italic" | "underline" | "strikethrough";
+/**
+ * The various options for the ANSI color formatter.
+ * @since 0.6.0
+ */
+interface AnsiColorFormatterOptions extends TextFormatterOptions {
+  /**
+   * The timestamp format.  This can be one of the following:
+   *
+   * - `"date-time-timezone"`: The date and time with the full timezone offset
+   *   (e.g., `"2023-11-14 22:13:20.000 +00:00"`).
+   * - `"date-time-tz"`: The date and time with the short timezone offset
+   *   (e.g., `"2023-11-14 22:13:20.000 +00"`).
+   * - `"date-time"`: The date and time without the timezone offset
+   *   (e.g., `"2023-11-14 22:13:20.000"`).
+   * - `"time-timezone"`: The time with the full timezone offset but without
+   *   the date (e.g., `"22:13:20.000 +00:00"`).
+   * - `"time-tz"`: The time with the short timezone offset but without the date
+   *   (e.g., `"22:13:20.000 +00"`).
+   * - `"time"`: The time without the date or timezone offset
+   *   (e.g., `"22:13:20.000"`).
+   * - `"date"`: The date without the time or timezone offset
+   *   (e.g., `"2023-11-14"`).
+   * - `"rfc3339"`: The date and time in RFC 3339 format
+   *   (e.g., `"2023-11-14T22:13:20.000Z"`).
+   *
+   * Alternatively, this can be a function that accepts a timestamp and returns
+   * a string.
+   *
+   * The default is `"date-time-tz"`.
+   */
+  timestamp?: "date-time-timezone" | "date-time-tz" | "date-time" | "time-timezone" | "time-tz" | "time" | "date" | "rfc3339" | ((ts: number) => string);
+  /**
+   * The ANSI style for the timestamp.  `"dim"` is used by default.
+   */
+  timestampStyle?: AnsiStyle | null;
+  /**
+   * The ANSI color for the timestamp.  No color is used by default.
+   */
+  timestampColor?: AnsiColor | null;
+  /**
+   * The ANSI style for the log level.  `"bold"` is used by default.
+   */
+  levelStyle?: AnsiStyle | null;
+  /**
+   * The ANSI colors for the log levels.  The default colors are as follows:
+   *
+   * - `"debug"`: `"blue"`
+   * - `"info"`: `"green"`
+   * - `"warning"`: `"yellow"`
+   * - `"error"`: `"red"`
+   * - `"fatal"`: `"magenta"`
+   */
+  levelColors?: Record<LogLevel, AnsiColor | null>;
+  /**
+   * The ANSI style for the category.  `"dim"` is used by default.
+   */
+  categoryStyle?: AnsiStyle | null;
+  /**
+   * The ANSI color for the category.  No color is used by default.
+   */
+  categoryColor?: AnsiColor | null;
+}
+/**
+ * Get an ANSI color formatter with the specified options.
+ *
+ * ![A preview of an ANSI color formatter.](https://i.imgur.com/I8LlBUf.png)
+ * @param option The options for the ANSI color formatter.
+ * @returns The ANSI color formatter.
+ * @since 0.6.0
+ */
+declare function getAnsiColorFormatter(options?: AnsiColorFormatterOptions): TextFormatter;
+/**
+ * A text formatter that uses ANSI colors to format log records.
+ *
+ * ![A preview of ansiColorFormatter.](https://i.imgur.com/I8LlBUf.png)
+ *
+ * @param record The log record to format.
+ * @returns The formatted log record.
+ * @since 0.5.0
+ */
+declare const ansiColorFormatter: TextFormatter;
+/**
+ * Options for the {@link getJsonLinesFormatter} function.
+ * @since 0.11.0
+ */
+interface JsonLinesFormatterOptions {
+  /**
+   * The separator between category names.  For example, if the separator is
+   * `"."`, the category `["a", "b", "c"]` will be formatted as `"a.b.c"`.
+   * If this is a function, it will be called with the category array and
+   * should return a string or an array of strings, which will be used
+   * for rendering the category.
+   *
+   * @default `"."`
+   */
+  readonly categorySeparator?: string | ((category: readonly string[]) => string | readonly string[]);
+  /**
+   * The message format.  This can be one of the following:
+   *
+   * - `"template"`: The raw message template is used as the message.
+   * - `"rendered"`: The message is rendered with the values.
+   *
+   * @default `"rendered"`
+   */
+  readonly message?: "template" | "rendered";
+  /**
+   * The properties format.  This can be one of the following:
+   *
+   * - `"flatten"`: The properties are flattened into the root object.
+   * - `"prepend:<prefix>"`: The properties are prepended with the given prefix
+   *   (e.g., `"prepend:ctx_"` will prepend `ctx_` to each property key).
+   * - `"nest:<key>"`: The properties are nested under the given key
+   *   (e.g., `"nest:properties"` will nest the properties under the
+   *   `properties` key).
+   *
+   * @default `"nest:properties"`
+   */
+  readonly properties?: "flatten" | `prepend:${string}` | `nest:${string}`;
+}
+/**
+ * Get a [JSON Lines] formatter with the specified options.  The log records
+ * will be rendered as JSON objects, one per line, which is a common format
+ * for log files.  This format is also known as Newline-Delimited JSON (NDJSON).
+ * It looks like this:
+ *
+ * ```json
+ * {"@timestamp":"2023-11-14T22:13:20.000Z","level":"INFO","message":"Hello, world!","logger":"my.logger","properties":{"key":"value"}}
+ * ```
+ *
+ * [JSON Lines]: https://jsonlines.org/
+ * @param options The options for the JSON Lines formatter.
+ * @returns The JSON Lines formatter.
+ * @since 0.11.0
+ */
+declare function getJsonLinesFormatter(options?: JsonLinesFormatterOptions): TextFormatter;
+/**
+ * The default [JSON Lines] formatter.  This formatter formats log records
+ * as JSON objects, one per line, which is a common format for log files.
+ * It looks like this:
+ *
+ * ```json
+ * {"@timestamp":"2023-11-14T22:13:20.000Z","level":"INFO","message":"Hello, world!","logger":"my.logger","properties":{"key":"value"}}
+ * ```
+ *
+ * You can customize the output by passing options to
+ * {@link getJsonLinesFormatter}.  For example, you can change the category
+ * separator, the message format, and how the properties are formatted.
+ *
+ * [JSON Lines]: https://jsonlines.org/
+ * @since 0.11.0
+ */
+declare const jsonLinesFormatter: TextFormatter;
+/**
+ * A console formatter is a function that accepts a log record and returns
+ * an array of arguments to pass to {@link console.log}.
+ *
+ * @param record The log record to format.
+ * @returns The formatted log record, as an array of arguments for
+ *          {@link console.log}.
+ */
+type ConsoleFormatter = (record: LogRecord) => readonly unknown[];
+/**
+ * The default console formatter.
+ *
+ * @param record The log record to format.
+ * @returns The formatted log record, as an array of arguments for
+ *          {@link console.log}.
+ */
+declare function defaultConsoleFormatter(record: LogRecord): readonly unknown[];
+//# sourceMappingURL=formatter.d.ts.map
+//#endregion
+export { AnsiColor, AnsiColorFormatterOptions, AnsiStyle, ConsoleFormatter, FormattedValues, JsonLinesFormatterOptions, TextFormatter, TextFormatterOptions, ansiColorFormatter, defaultConsoleFormatter, defaultTextFormatter, getAnsiColorFormatter, getJsonLinesFormatter, getTextFormatter, jsonLinesFormatter };
+//# sourceMappingURL=formatter.d.cts.map

package/dist/formatter.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatter.d.cts","names":[],"sources":["../formatter.ts"],"sourcesContent":[],"mappings":";;;;;;;AAWA;AA8DA;AA+BA;;;AAuGoB,KApMR,aAAA,GAoMQ,CAAA,MAAA,EApMiB,SAoMjB,EAAA,GAAA,MAAA;AAAe;AAoBnC;;;AAEG,UA5Jc,eAAA,CA4Jd;EAAa;AA6EhB;AAQA;EAyBY,SAAA,EAAA,MAAS,GAAA,IAAA;EA2BJ;;;EAwCW,KAKT,EAAA,MAAA;EAAS;;;EAgBc,QAA1B,EAAA,MAAA;EAAM;;;EA7DiD,OAAA,EAAA,MAAA;EAkFvD;;;EACyB,MACtC,EAjWO,SAiWP;AAAa;AA4DhB;AAMA;AAsDA;;AACW,UAndM,oBAAA,CAmdN;EAA8B;AACzB;AA8FhB;AAUA;AAoBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mEAlhBe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAyCK;;;;;;;;;;;;;;;;;;;iBAoBJ,gBAAA,WACL,uBACR;;;;;;;;;;;cA6EU,sBAAsB;;;;;KAQvB,SAAA;;;;;KAyBA,SAAA;;;;;UA2BK,yBAAA,SAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAwChC;;;;mBAKA;;;;eAKJ;;;;;;;;;;gBAWC,OAAO,UAAU;;;;kBAKf;;;;kBAKA;;;;;;;;;;iBAWF,qBAAA,WACL,4BACR;;;;;;;;;;cA4DU,oBAAoB;;;;;UAMhB,yBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsDD,qBAAA,WACL,4BACR;;;;;;;;;;;;;;;;;cA8FU,oBAAoB;;;;;;;;;KAUrB,gBAAA,YAA4B;;;;;;;;iBAoBxB,uBAAA,SAAgC"}