@logtape/logtape 1.4.0-dev.461 → 1.4.0-dev.464

package/dist/logger.cjs

@@ -95,6 +95,11 @@ var LoggerImpl = class LoggerImpl {
 		if (this.parent != null && this.parentSinks === "inherit") for (const sink of this.parent.getSinks(level)) yield sink;
 		for (const sink of this.sinks) yield sink;
 	}
+	isEnabledFor(level) {
+		if (this.lowestLevel === null || require_level.compareLogLevel(level, this.lowestLevel) < 0) return false;
+		for (const _ of this.getSinks(level)) return true;
+		return false;
+	}
 	emit(record, bypassSinks) {
 		const categoryPrefix = require_context.getCategoryPrefix();
 		const baseCategory = "category" in record ? record.category : this.category;
@@ -201,52 +206,185 @@ var LoggerImpl = class LoggerImpl {
 		});
 	}
 	trace(message, ...values) {
-		if (typeof message === "string") this.log("trace", message, values[0] ?? {});
-		else if (typeof message === "function") this.logLazily("trace", message);
+		if (typeof message === "string") {
+			const props = values[0];
+			if (typeof props === "function") {
+				if (props.constructor.name === "AsyncFunction") {
+					if (!this.isEnabledFor("trace")) return Promise.resolve();
+					return props().then((resolvedProps) => {
+						this.log("trace", message, resolvedProps);
+					});
+				}
+				const result = props();
+				if (result instanceof Promise) {
+					if (!this.isEnabledFor("trace")) return Promise.resolve();
+					return result.then((resolvedProps) => {
+						this.log("trace", message, resolvedProps);
+					});
+				}
+				this.log("trace", message, result);
+				return;
+			}
+			this.log("trace", message, props ?? {});
+		} else if (typeof message === "function") this.logLazily("trace", message);
 		else if (!Array.isArray(message)) this.log("trace", "{*}", message);
 		else this.logTemplate("trace", message, values);
 	}
 	debug(message, ...values) {
-		if (typeof message === "string") this.log("debug", message, values[0] ?? {});
-		else if (typeof message === "function") this.logLazily("debug", message);
+		if (typeof message === "string") {
+			const props = values[0];
+			if (typeof props === "function") {
+				if (props.constructor.name === "AsyncFunction") {
+					if (!this.isEnabledFor("debug")) return Promise.resolve();
+					return props().then((resolvedProps) => {
+						this.log("debug", message, resolvedProps);
+					});
+				}
+				const result = props();
+				if (result instanceof Promise) {
+					if (!this.isEnabledFor("debug")) return Promise.resolve();
+					return result.then((resolvedProps) => {
+						this.log("debug", message, resolvedProps);
+					});
+				}
+				this.log("debug", message, result);
+				return;
+			}
+			this.log("debug", message, props ?? {});
+		} else if (typeof message === "function") this.logLazily("debug", message);
 		else if (!Array.isArray(message)) this.log("debug", "{*}", message);
 		else this.logTemplate("debug", message, values);
 	}
 	info(message, ...values) {
-		if (typeof message === "string") this.log("info", message, values[0] ?? {});
-		else if (typeof message === "function") this.logLazily("info", message);
+		if (typeof message === "string") {
+			const props = values[0];
+			if (typeof props === "function") {
+				if (props.constructor.name === "AsyncFunction") {
+					if (!this.isEnabledFor("info")) return Promise.resolve();
+					return props().then((resolvedProps) => {
+						this.log("info", message, resolvedProps);
+					});
+				}
+				const result = props();
+				if (result instanceof Promise) {
+					if (!this.isEnabledFor("info")) return Promise.resolve();
+					return result.then((resolvedProps) => {
+						this.log("info", message, resolvedProps);
+					});
+				}
+				this.log("info", message, result);
+				return;
+			}
+			this.log("info", message, props ?? {});
+		} else if (typeof message === "function") this.logLazily("info", message);
 		else if (!Array.isArray(message)) this.log("info", "{*}", message);
 		else this.logTemplate("info", message, values);
 	}
 	warn(message, ...values) {
 		if (message instanceof Error) this.log("warning", "{error.message}", { error: message });
 		else if (typeof message === "string" && values[0] instanceof Error) this.log("warning", message, { error: values[0] });
-		else if (typeof message === "string") this.log("warning", message, values[0] ?? {});
-		else if (typeof message === "function") this.logLazily("warning", message);
+		else if (typeof message === "string") {
+			const props = values[0];
+			if (typeof props === "function") {
+				if (props.constructor.name === "AsyncFunction") {
+					if (!this.isEnabledFor("warning")) return Promise.resolve();
+					return props().then((resolvedProps) => {
+						this.log("warning", message, resolvedProps);
+					});
+				}
+				const result = props();
+				if (result instanceof Promise) {
+					if (!this.isEnabledFor("warning")) return Promise.resolve();
+					return result.then((resolvedProps) => {
+						this.log("warning", message, resolvedProps);
+					});
+				}
+				this.log("warning", message, result);
+				return;
+			}
+			this.log("warning", message, props ?? {});
+		} else if (typeof message === "function") this.logLazily("warning", message);
 		else if (!Array.isArray(message)) this.log("warning", "{*}", message);
 		else this.logTemplate("warning", message, values);
 	}
 	warning(message, ...values) {
 		if (message instanceof Error) this.log("warning", "{error.message}", { error: message });
 		else if (typeof message === "string" && values[0] instanceof Error) this.log("warning", message, { error: values[0] });
-		else if (typeof message === "string") this.log("warning", message, values[0] ?? {});
-		else if (typeof message === "function") this.logLazily("warning", message);
+		else if (typeof message === "string") {
+			const props = values[0];
+			if (typeof props === "function") {
+				if (props.constructor.name === "AsyncFunction") {
+					if (!this.isEnabledFor("warning")) return Promise.resolve();
+					return props().then((resolvedProps) => {
+						this.log("warning", message, resolvedProps);
+					});
+				}
+				const result = props();
+				if (result instanceof Promise) {
+					if (!this.isEnabledFor("warning")) return Promise.resolve();
+					return result.then((resolvedProps) => {
+						this.log("warning", message, resolvedProps);
+					});
+				}
+				this.log("warning", message, result);
+				return;
+			}
+			this.log("warning", message, props ?? {});
+		} else if (typeof message === "function") this.logLazily("warning", message);
 		else if (!Array.isArray(message)) this.log("warning", "{*}", message);
 		else this.logTemplate("warning", message, values);
 	}
 	error(message, ...values) {
 		if (message instanceof Error) this.log("error", "{error.message}", { error: message });
 		else if (typeof message === "string" && values[0] instanceof Error) this.log("error", message, { error: values[0] });
-		else if (typeof message === "string") this.log("error", message, values[0] ?? {});
-		else if (typeof message === "function") this.logLazily("error", message);
+		else if (typeof message === "string") {
+			const props = values[0];
+			if (typeof props === "function") {
+				if (props.constructor.name === "AsyncFunction") {
+					if (!this.isEnabledFor("error")) return Promise.resolve();
+					return props().then((resolvedProps) => {
+						this.log("error", message, resolvedProps);
+					});
+				}
+				const result = props();
+				if (result instanceof Promise) {
+					if (!this.isEnabledFor("error")) return Promise.resolve();
+					return result.then((resolvedProps) => {
+						this.log("error", message, resolvedProps);
+					});
+				}
+				this.log("error", message, result);
+				return;
+			}
+			this.log("error", message, props ?? {});
+		} else if (typeof message === "function") this.logLazily("error", message);
 		else if (!Array.isArray(message)) this.log("error", "{*}", message);
 		else this.logTemplate("error", message, values);
 	}
 	fatal(message, ...values) {
 		if (message instanceof Error) this.log("fatal", "{error.message}", { error: message });
 		else if (typeof message === "string" && values[0] instanceof Error) this.log("fatal", message, { error: values[0] });
-		else if (typeof message === "string") this.log("fatal", message, values[0] ?? {});
-		else if (typeof message === "function") this.logLazily("fatal", message);
+		else if (typeof message === "string") {
+			const props = values[0];
+			if (typeof props === "function") {
+				if (props.constructor.name === "AsyncFunction") {
+					if (!this.isEnabledFor("fatal")) return Promise.resolve();
+					return props().then((resolvedProps) => {
+						this.log("fatal", message, resolvedProps);
+					});
+				}
+				const result = props();
+				if (result instanceof Promise) {
+					if (!this.isEnabledFor("fatal")) return Promise.resolve();
+					return result.then((resolvedProps) => {
+						this.log("fatal", message, resolvedProps);
+					});
+				}
+				this.log("fatal", message, result);
+				return;
+			}
+			this.log("fatal", message, props ?? {});
+		} else if (typeof message === "function") this.logLazily("fatal", message);
 		else if (!Array.isArray(message)) this.log("fatal", "{*}", message);
 		else this.logTemplate("fatal", message, values);
 	}
@@ -303,53 +441,189 @@ var LoggerCtx = class LoggerCtx {
 		};
 		this.logger.emit(recordWithContext);
 	}
+	isEnabledFor(level) {
+		return this.logger.isEnabledFor(level);
+	}
 	trace(message, ...values) {
-		if (typeof message === "string") this.log("trace", message, values[0] ?? {});
-		else if (typeof message === "function") this.logLazily("trace", message);
+		if (typeof message === "string") {
+			const props = values[0];
+			if (typeof props === "function") {
+				if (props.constructor.name === "AsyncFunction") {
+					if (!this.isEnabledFor("trace")) return Promise.resolve();
+					return props().then((resolvedProps) => {
+						this.log("trace", message, resolvedProps);
+					});
+				}
+				const result = props();
+				if (result instanceof Promise) {
+					if (!this.isEnabledFor("trace")) return Promise.resolve();
+					return result.then((resolvedProps) => {
+						this.log("trace", message, resolvedProps);
+					});
+				}
+				this.log("trace", message, result);
+				return;
+			}
+			this.log("trace", message, props ?? {});
+		} else if (typeof message === "function") this.logLazily("trace", message);
 		else if (!Array.isArray(message)) this.log("trace", "{*}", message);
 		else this.logTemplate("trace", message, values);
 	}
 	debug(message, ...values) {
-		if (typeof message === "string") this.log("debug", message, values[0] ?? {});
-		else if (typeof message === "function") this.logLazily("debug", message);
+		if (typeof message === "string") {
+			const props = values[0];
+			if (typeof props === "function") {
+				if (props.constructor.name === "AsyncFunction") {
+					if (!this.isEnabledFor("debug")) return Promise.resolve();
+					return props().then((resolvedProps) => {
+						this.log("debug", message, resolvedProps);
+					});
+				}
+				const result = props();
+				if (result instanceof Promise) {
+					if (!this.isEnabledFor("debug")) return Promise.resolve();
+					return result.then((resolvedProps) => {
+						this.log("debug", message, resolvedProps);
+					});
+				}
+				this.log("debug", message, result);
+				return;
+			}
+			this.log("debug", message, props ?? {});
+		} else if (typeof message === "function") this.logLazily("debug", message);
 		else if (!Array.isArray(message)) this.log("debug", "{*}", message);
 		else this.logTemplate("debug", message, values);
 	}
 	info(message, ...values) {
-		if (typeof message === "string") this.log("info", message, values[0] ?? {});
-		else if (typeof message === "function") this.logLazily("info", message);
+		if (typeof message === "string") {
+			const props = values[0];
+			if (typeof props === "function") {
+				if (props.constructor.name === "AsyncFunction") {
+					if (!this.isEnabledFor("info")) return Promise.resolve();
+					return props().then((resolvedProps) => {
+						this.log("info", message, resolvedProps);
+					});
+				}
+				const result = props();
+				if (result instanceof Promise) {
+					if (!this.isEnabledFor("info")) return Promise.resolve();
+					return result.then((resolvedProps) => {
+						this.log("info", message, resolvedProps);
+					});
+				}
+				this.log("info", message, result);
+				return;
+			}
+			this.log("info", message, props ?? {});
+		} else if (typeof message === "function") this.logLazily("info", message);
 		else if (!Array.isArray(message)) this.log("info", "{*}", message);
 		else this.logTemplate("info", message, values);
 	}
 	warn(message, ...values) {
 		if (message instanceof Error) this.log("warning", "{error.message}", { error: message });
 		else if (typeof message === "string" && values[0] instanceof Error) this.log("warning", message, { error: values[0] });
-		else if (typeof message === "string") this.log("warning", message, values[0] ?? {});
-		else if (typeof message === "function") this.logLazily("warning", message);
+		else if (typeof message === "string") {
+			const props = values[0];
+			if (typeof props === "function") {
+				if (props.constructor.name === "AsyncFunction") {
+					if (!this.isEnabledFor("warning")) return Promise.resolve();
+					return props().then((resolvedProps) => {
+						this.log("warning", message, resolvedProps);
+					});
+				}
+				const result = props();
+				if (result instanceof Promise) {
+					if (!this.isEnabledFor("warning")) return Promise.resolve();
+					return result.then((resolvedProps) => {
+						this.log("warning", message, resolvedProps);
+					});
+				}
+				this.log("warning", message, result);
+				return;
+			}
+			this.log("warning", message, props ?? {});
+		} else if (typeof message === "function") this.logLazily("warning", message);
 		else if (!Array.isArray(message)) this.log("warning", "{*}", message);
 		else this.logTemplate("warning", message, values);
 	}
 	warning(message, ...values) {
 		if (message instanceof Error) this.log("warning", "{error.message}", { error: message });
 		else if (typeof message === "string" && values[0] instanceof Error) this.log("warning", message, { error: values[0] });
-		else if (typeof message === "string") this.log("warning", message, values[0] ?? {});
-		else if (typeof message === "function") this.logLazily("warning", message);
+		else if (typeof message === "string") {
+			const props = values[0];
+			if (typeof props === "function") {
+				if (props.constructor.name === "AsyncFunction") {
+					if (!this.isEnabledFor("warning")) return Promise.resolve();
+					return props().then((resolvedProps) => {
+						this.log("warning", message, resolvedProps);
+					});
+				}
+				const result = props();
+				if (result instanceof Promise) {
+					if (!this.isEnabledFor("warning")) return Promise.resolve();
+					return result.then((resolvedProps) => {
+						this.log("warning", message, resolvedProps);
+					});
+				}
+				this.log("warning", message, result);
+				return;
+			}
+			this.log("warning", message, props ?? {});
+		} else if (typeof message === "function") this.logLazily("warning", message);
 		else if (!Array.isArray(message)) this.log("warning", "{*}", message);
 		else this.logTemplate("warning", message, values);
 	}
 	error(message, ...values) {
 		if (message instanceof Error) this.log("error", "{error.message}", { error: message });
 		else if (typeof message === "string" && values[0] instanceof Error) this.log("error", message, { error: values[0] });
-		else if (typeof message === "string") this.log("error", message, values[0] ?? {});
-		else if (typeof message === "function") this.logLazily("error", message);
+		else if (typeof message === "string") {
+			const props = values[0];
+			if (typeof props === "function") {
+				if (props.constructor.name === "AsyncFunction") {
+					if (!this.isEnabledFor("error")) return Promise.resolve();
+					return props().then((resolvedProps) => {
+						this.log("error", message, resolvedProps);
+					});
+				}
+				const result = props();
+				if (result instanceof Promise) {
+					if (!this.isEnabledFor("error")) return Promise.resolve();
+					return result.then((resolvedProps) => {
+						this.log("error", message, resolvedProps);
+					});
+				}
+				this.log("error", message, result);
+				return;
+			}
+			this.log("error", message, props ?? {});
+		} else if (typeof message === "function") this.logLazily("error", message);
 		else if (!Array.isArray(message)) this.log("error", "{*}", message);
 		else this.logTemplate("error", message, values);
 	}
 	fatal(message, ...values) {
 		if (message instanceof Error) this.log("fatal", "{error.message}", { error: message });
 		else if (typeof message === "string" && values[0] instanceof Error) this.log("fatal", message, { error: values[0] });
-		else if (typeof message === "string") this.log("fatal", message, values[0] ?? {});
-		else if (typeof message === "function") this.logLazily("fatal", message);
+		else if (typeof message === "string") {
+			const props = values[0];
+			if (typeof props === "function") {
+				if (props.constructor.name === "AsyncFunction") {
+					if (!this.isEnabledFor("fatal")) return Promise.resolve();
+					return props().then((resolvedProps) => {
+						this.log("fatal", message, resolvedProps);
+					});
+				}
+				const result = props();
+				if (result instanceof Promise) {
+					if (!this.isEnabledFor("fatal")) return Promise.resolve();
+					return result.then((resolvedProps) => {
+						this.log("fatal", message, resolvedProps);
+					});
+				}
+				this.log("fatal", message, result);
+				return;
+			}
+			this.log("fatal", message, props ?? {});
+		} else if (typeof message === "function") this.logLazily("fatal", message);
 		else if (!Array.isArray(message)) this.log("fatal", "{*}", message);
 		else this.logTemplate("fatal", message, values);
 	}

package/dist/logger.d.cts

@@ -1,3 +1,4 @@
+import { LogLevel } from "./level.cjs";
 import { LogRecord } from "./record.cjs";
 
 //#region src/logger.d.ts
@@ -110,6 +111,26 @@ interface Logger {
    * @since 0.12.0
    */
   trace(message: string, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+  /**
+   * Log a trace message with properties computed asynchronously.
+   *
+   * Use this when the properties require async operations to compute:
+   *
+   * ```typescript
+   * await logger.trace(
+   *   'A trace message with {value}.',
+   *   async () => ({ value: await fetchValue() })
+   * );
+   * ```
+   *
+   * @param message The message template.  Placeholders to be replaced with
+   *                `values` are indicated by keys in curly braces (e.g.,
+   *                `{value}`).
+   * @param properties An async callback that returns the properties.
+   * @returns A promise that resolves when the log is written.
+   * @since 1.4.0
+   */
+  trace(message: string, properties: () => Promise<Record<string, unknown>>): Promise<void>;
   /**
    * Log a trace values with no message.  This is useful when you
    * want to log properties without a message, e.g., when you want to log
@@ -189,6 +210,26 @@ interface Logger {
    *                   properties.
    */
   debug(message: string, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+  /**
+   * Log a debug message with properties computed asynchronously.
+   *
+   * Use this when the properties require async operations to compute:
+   *
+   * ```typescript
+   * await logger.debug(
+   *   'A debug message with {value}.',
+   *   async () => ({ value: await fetchValue() })
+   * );
+   * ```
+   *
+   * @param message The message template.  Placeholders to be replaced with
+   *                `values` are indicated by keys in curly braces (e.g.,
+   *                `{value}`).
+   * @param properties An async callback that returns the properties.
+   * @returns A promise that resolves when the log is written.
+   * @since 1.4.0
+   */
+  debug(message: string, properties: () => Promise<Record<string, unknown>>): Promise<void>;
   /**
    * Log a debug values with no message.  This is useful when you
    * want to log properties without a message, e.g., when you want to log
@@ -267,6 +308,26 @@ interface Logger {
    *                   properties.
    */
   info(message: string, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+  /**
+   * Log an informational message with properties computed asynchronously.
+   *
+   * Use this when the properties require async operations to compute:
+   *
+   * ```typescript
+   * await logger.info(
+   *   'An info message with {value}.',
+   *   async () => ({ value: await fetchValue() })
+   * );
+   * ```
+   *
+   * @param message The message template.  Placeholders to be replaced with
+   *                `values` are indicated by keys in curly braces (e.g.,
+   *                `{value}`).
+   * @param properties An async callback that returns the properties.
+   * @returns A promise that resolves when the log is written.
+   * @since 1.4.0
+   */
+  info(message: string, properties: () => Promise<Record<string, unknown>>): Promise<void>;
   /**
    * Log an informational values with no message.  This is useful when you
    * want to log properties without a message, e.g., when you want to log
@@ -376,6 +437,26 @@ interface Logger {
    *                   properties.
    */
   warn(message: string, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+  /**
+   * Log a warning message with properties computed asynchronously.
+   *
+   * Use this when the properties require async operations to compute:
+   *
+   * ```typescript
+   * await logger.warn(
+   *   'A warning message with {value}.',
+   *   async () => ({ value: await fetchValue() })
+   * );
+   * ```
+   *
+   * @param message The message template.  Placeholders to be replaced with
+   *                `values` are indicated by keys in curly braces (e.g.,
+   *                `{value}`).
+   * @param properties An async callback that returns the properties.
+   * @returns A promise that resolves when the log is written.
+   * @since 1.4.0
+   */
+  warn(message: string, properties: () => Promise<Record<string, unknown>>): Promise<void>;
   /**
    * Log a warning values with no message.  This is useful when you
    * want to log properties without a message, e.g., when you want to log
@@ -487,6 +568,26 @@ interface Logger {
    * @since 0.12.0
    */
   warning(message: string, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+  /**
+   * Log a warning message with properties computed asynchronously.
+   *
+   * Use this when the properties require async operations to compute:
+   *
+   * ```typescript
+   * await logger.warning(
+   *   'A warning message with {value}.',
+   *   async () => ({ value: await fetchValue() })
+   * );
+   * ```
+   *
+   * @param message The message template.  Placeholders to be replaced with
+   *                `values` are indicated by keys in curly braces (e.g.,
+   *                `{value}`).
+   * @param properties An async callback that returns the properties.
+   * @returns A promise that resolves when the log is written.
+   * @since 1.4.0
+   */
+  warning(message: string, properties: () => Promise<Record<string, unknown>>): Promise<void>;
   /**
    * Log a warning values with no message.  This is useful when you
    * want to log properties without a message, e.g., when you want to log
@@ -597,6 +698,26 @@ interface Logger {
    *                   properties.
    */
   error(message: string, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+  /**
+   * Log an error message with properties computed asynchronously.
+   *
+   * Use this when the properties require async operations to compute:
+   *
+   * ```typescript
+   * await logger.error(
+   *   'An error message with {value}.',
+   *   async () => ({ value: await fetchValue() })
+   * );
+   * ```
+   *
+   * @param message The message template.  Placeholders to be replaced with
+   *                `values` are indicated by keys in curly braces (e.g.,
+   *                `{value}`).
+   * @param properties An async callback that returns the properties.
+   * @returns A promise that resolves when the log is written.
+   * @since 1.4.0
+   */
+  error(message: string, properties: () => Promise<Record<string, unknown>>): Promise<void>;
   /**
    * Log an error values with no message.  This is useful when you
    * want to log properties without a message, e.g., when you want to log
@@ -706,6 +827,26 @@ interface Logger {
    *                   properties.
    */
   fatal(message: string, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+  /**
+   * Log a fatal error message with properties computed asynchronously.
+   *
+   * Use this when the properties require async operations to compute:
+   *
+   * ```typescript
+   * await logger.fatal(
+   *   'A fatal error message with {value}.',
+   *   async () => ({ value: await fetchValue() })
+   * );
+   * ```
+   *
+   * @param message The message template.  Placeholders to be replaced with
+   *                `values` are indicated by keys in curly braces (e.g.,
+   *                `{value}`).
+   * @param properties An async callback that returns the properties.
+   * @returns A promise that resolves when the log is written.
+   * @since 1.4.0
+   */
+  fatal(message: string, properties: () => Promise<Record<string, unknown>>): Promise<void>;
   /**
    * Log a fatal error values with no message.  This is useful when you
    * want to log properties without a message, e.g., when you want to log
@@ -779,6 +920,27 @@ interface Logger {
    * @since 1.1.0
    */
   emit(record: Omit<LogRecord, "category">): void;
+  /**
+   * Check if a message of the given severity level would be processed by
+   * this logger.
+   *
+   * This is useful for conditionally executing expensive computations
+   * before logging, particularly for async operations where lazy
+   * evaluation callbacks cannot be used:
+   *
+   * ```typescript
+   * if (logger.isEnabledFor("debug")) {
+   *   const result = await expensiveAsync();
+   *   logger.debug("Result: {result}", { result });
+   * }
+   * ```
+   *
+   * @param level The log level to check.
+   * @returns `true` if a message of the given level would be logged,
+   *          `false` otherwise.
+   * @since 1.4.0
+   */
+  isEnabledFor(level: LogLevel): boolean;
 }
 /**
  * A logging callback function.  It is used to defer the computation of a
@@ -816,6 +978,16 @@ interface LogMethod {
    *                   properties.
    */
   (message: string, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+  /**
+   * Log a message with the given level with properties computed asynchronously.
+   * @param message The message template.  Placeholders to be replaced with
+   *                `values` are indicated by keys in curly braces (e.g.,
+   *                `{value}`).
+   * @param properties An async callback that returns the properties.
+   * @returns A promise that resolves when the log is written.
+   * @since 1.4.0
+   */
+  (message: string, properties: () => Promise<Record<string, unknown>>): Promise<void>;
   /**
    * Log a message with the given level with no message.
    * @param properties The values to log.  Note that this does not take

package/dist/logger.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.cts","names":[],"sources":["../src/logger.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;AA6QgB,UArPC,MAAA,CAqPD;EAAoB;;;EA4DX,SAcR,QAAA,EAAA,SAAA,MAAA,EAAA;EAAW;;;;EAwEL,SAA2B,MAAA,EA7X/B,MA6X+B,GAAA,IAAA;EAAM;;;;;;;;;;;;;;;;;;EA6TnB,QAYpB,CAAA,WAAA,EAAA,MAAA,GAAA,SAAA,CAAA,MAAA,CAAA,GAAA,SAAA,CAAA,MAAA,EAAA,GAAA,MAAA,EAAA,CAAA,CAAA,EAhrBZ,MAgrBY;EAAoB;;;;;;AAyGlB;AASnB;AASA;AASA;;;;;;;AAqCwB;AAexB;;;;;;;;;mBA50BmB,0BAA0B;;;;;;;;;;;;iBAa5B;;;;;;;;;;;;;;;;;;;;;;;;;;sCA6BA,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAgC9B;;;;;;;;;;;;;kBAcF;;;;;;;;;;;iBAYD;;;;;;;;;;;;;;;;;;;;;;;;;sCA4BA,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAgC9B;;;;;;;;;;;;kBAaF;;;;;;;;;;;gBAYF;;;;;;;;;;;;;;;;;;;;;;;;;qCA4BC,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAgC/B;;;;;;;;;;;;;iBAcF;;;;;;;;;;;;;;;;;;cAmBH;;;;;;;;;;;;+BAaiB;;;;;;;;;;;gBAYf;;;;;;;;;;;;;;;;;;;;;;;;;qCA4BC,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAgC/B;;;;;;;;;;;;;iBAcF;;;;;;;;;;;;;;;;;;iBAmBA;;;;;;;;;;;;kCAaiB;;;;;;;;;;;;mBAaf;;;;;;;;;;;;;;;;;;;;;;;;;;wCA6BF,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAgC5B;;;;;;;;;;;;;;oBAeF;;;;;;;;;;;;;;;;;;eAmBL;;;;;;;;;;;;gCAaiB;;;;;;;;;;;iBAYf;;;;;;;;;;;;;;;;;;;;;;;;;sCA4BA,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAgC9B;;;;;;;;;;;;;kBAcF;;;;;;;;;;;;;;;;;;eAmBH;;;;;;;;;;;;gCAaiB;;;;;;;;;;;iBAYf;;;;;;;;;;;;;;;;;;;;;;;;;sCA4BA,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAgC9B;;;;;;;;;;;;;kBAcF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eA+BH,KAAK;;;;;;;;KASR,WAAA,YAAuB;;;;;;;;KASvB,iBAAA,aACD;;;;;UAQM,SAAA;;;;;;YAOJ;;;;;;;;;;iCAeI,iCAAiC;;;;;;eAQnC;;;;;;aAOF;;;;;;;;;;;;;;iBAeG,SAAA,yCAAsD"}
+{"version":3,"file":"logger.d.cts","names":[],"sources":["../src/logger.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;AA4OiB,UApNA,MAAA,CAoNA;EAAM;;;EAwBM,SACxB,QAAA,EAAA,SAAA,MAAA,EAAA;EAAO;;;;EAoFW,SAA2B,MAAA,EAvT/B,MAuT+B,GAAA,IAAA;EAAM;;;;;;;;;;;;;;;;;;EAiQjB,QA6BtB,CAAA,WAAA,EAAA,MAAA,GAAA,SAAA,CAAA,MAAA,CAAA,GAAA,SAAA,CAAA,MAAA,EAAA,GAAA,MAAA,EAAA,CAAA,CAAA,EA/jBZ,MA+jBY;EAAM;;;;;;;;;;;;;;;;;;;;;;;;;;EAmWM,IA+BT,CAAA,UAAA,EAr6BD,MAq6BC,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA,EAr6ByB,MAq6BzB;EAAS;;AAsBC;AAS9B;AASA;AASA;;;;;;EAoCoC,KAAd,CAAA,OAAA,EA7+BL,oBA6+BK,EAAA,GAAA,MAAA,EAAA,SAAA,OAAA,EAAA,CAAA,EAAA,IAAA;EAAO;;;AAeL;AAexB;;;;;;;;;;;;;;;;;;;;;sCA9+BiB,iCAAiC;;;;;;;;;;;;;;;;;;;;2CAwB5B,QAAQ,2BACzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBA+Be;;;;;;;;;;;;;kBAcF;;;;;;;;;;;iBAYD;;;;;;;;;;;;;;;;;;;;;;;;;sCA4BA,iCAAiC;;;;;;;;;;;;;;;;;;;;2CAwB5B,QAAQ,2BACzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBA+Be;;;;;;;;;;;;kBAaF;;;;;;;;;;;gBAYF;;;;;;;;;;;;;;;;;;;;;;;;;qCA4BC,iCAAiC;;;;;;;;;;;;;;;;;;;;0CAwB5B,QAAQ,2BACzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA+Bc;;;;;;;;;;;;;iBAcF;;;;;;;;;;;;;;;;;;cAmBH;;;;;;;;;;;;+BAaiB;;;;;;;;;;;gBAYf;;;;;;;;;;;;;;;;;;;;;;;;;qCA4BC,iCAAiC;;;;;;;;;;;;;;;;;;;;0CAwB5B,QAAQ,2BACzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA+Bc;;;;;;;;;;;;;iBAcF;;;;;;;;;;;;;;;;;;iBAmBA;;;;;;;;;;;;kCAaiB;;;;;;;;;;;;mBAaf;;;;;;;;;;;;;;;;;;;;;;;;;;wCA6BF,iCAAiC;;;;;;;;;;;;;;;;;;;;6CAwB5B,QAAQ,2BACzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBA+BiB;;;;;;;;;;;;;;oBAeF;;;;;;;;;;;;;;;;;;eAmBL;;;;;;;;;;;;gCAaiB;;;;;;;;;;;iBAYf;;;;;;;;;;;;;;;;;;;;;;;;;sCA4BA,iCAAiC;;;;;;;;;;;;;;;;;;;;2CAwB5B,QAAQ,2BACzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBA+Be;;;;;;;;;;;;;kBAcF;;;;;;;;;;;;;;;;;;eAmBH;;;;;;;;;;;;gCAaiB;;;;;;;;;;;iBAYf;;;;;;;;;;;;;;;;;;;;;;;;;sCA4BA,iCAAiC;;;;;;;;;;;;;;;;;;;;2CAwB5B,QAAQ,2BACzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBA+Be;;;;;;;;;;;;;kBAcF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eA+BH,KAAK;;;;;;;;;;;;;;;;;;;;;sBAsBE;;;;;;;;KASV,WAAA,YAAuB;;;;;;;;KASvB,iBAAA,aACD;;;;;UAQM,SAAA;;;;;;YAOJ;;;;;;;;;;iCAeI,iCAAiC;;;;;;;;;;sCAc5B,QAAQ,2BACzB;;;;;;eAOU;;;;;;aAOF;;;;;;;;;;;;;;iBAeG,SAAA,yCAAsD"}