velocious 1.0.431 → 1.0.433

package/build/src/logger.js

@@ -1,60 +1,50 @@
 // @ts-check
-
-import LoggerConsoleOutput from "./logger/outputs/console-output.js"
-import LoggerFileOutput from "./logger/outputs/file-output.js"
-import {currentConfiguration} from "./current-configuration.js"
-import {formatValue} from "./utils/format-value.js"
-import restArgsError from "./utils/rest-args-error.js"
-
+import LoggerConsoleOutput from "./logger/outputs/console-output.js";
+import LoggerFileOutput from "./logger/outputs/file-output.js";
+import { currentConfiguration } from "./current-configuration.js";
+import { formatValue } from "./utils/format-value.js";
+import restArgsError from "./utils/rest-args-error.js";
 /**
  * LogLevel type.
   @typedef {"debug-low-level" | "debug" | "info" | "warn" | "error"} LogLevel */
-
 const DEFAULT_LOGGING_CONFIGURATION = {
-  console: true,
-  file: false,
-  /**
-   * Types the following value.
-    @type {LogLevel[]} */
-  levels: ["info", "warn", "error"]
-}
-
+    console: true,
+    file: false,
+    /**
+     * Types the following value.
+      @type {LogLevel[]} */
+    levels: ["info", "warn", "error"]
+};
 /**
  * Level order.
   @type {LogLevel[]} */
-const LEVEL_ORDER = ["debug-low-level", "debug", "info", "warn", "error"]
-
+const LEVEL_ORDER = ["debug-low-level", "debug", "info", "warn", "error"];
 /**
  * Runs function or messages.
  * @param {...?|function() : Array<?>} messages - Messages.
  * @returns {Array<?>} - Either the function result or the messages
  */
 function functionOrMessages(...messages) {
-  if (messages.length === 1 && typeof messages[0] == "function") {
-    const result = messages[0]()
-    messages = Array.isArray(result) ? result : [result]
-  }
-
-  return messages
+    if (messages.length === 1 && typeof messages[0] == "function") {
+        const result = messages[0]();
+        messages = Array.isArray(result) ? result : [result];
+    }
+    return messages;
 }
-
 /**
  * Format a single value for inclusion in a log message.
  * @param {?} value - Value to format.
  * @returns {string} - String representation.
  */
 function formatPart(value) {
-  if (value instanceof Error) {
-    return `${value.message}\n${value.stack}`
-  }
-
-  if (typeof value === "object") {
-    return formatValue(value)
-  }
-
-  return String(value)
+    if (value instanceof Error) {
+        return `${value.message}\n${value.stack}`;
+    }
+    if (typeof value === "object") {
+        return formatValue(value);
+    }
+    return String(value);
 }
-
 /**
  * Formats the user-supplied messages into a single string.
  *
@@ -67,53 +57,46 @@ function formatPart(value) {
  * @returns {string} - The formatted user message.
  */
 function formatUserMessages(messages) {
-  if (messages.length === 0) return ""
-
-  const first = messages[0]
-
-  if (typeof first === "string" && /%[sdjoO%]/.test(first)) {
-    let argIndex = 1
-    const formatted = first.replace(/%[sdjoO%]/g, (match) => {
-      if (match === "%%") return "%"
-      if (argIndex >= messages.length) return match
-
-      const value = messages[argIndex]
-
-      argIndex += 1
-
-      if (match === "%d") {
-        // Match util.format: never throw for non-coercible values — yield "NaN" instead.
-        // Number(Symbol()) throws, so catch and fall back.
-        try {
-          return String(Number(value))
-        } catch {
-          return "NaN"
+    if (messages.length === 0)
+        return "";
+    const first = messages[0];
+    if (typeof first === "string" && /%[sdjoO%]/.test(first)) {
+        let argIndex = 1;
+        const formatted = first.replace(/%[sdjoO%]/g, (match) => {
+            if (match === "%%")
+                return "%";
+            if (argIndex >= messages.length)
+                return match;
+            const value = messages[argIndex];
+            argIndex += 1;
+            if (match === "%d") {
+                // Match util.format: never throw for non-coercible values — yield "NaN" instead.
+                // Number(Symbol()) throws, so catch and fall back.
+                try {
+                    return String(Number(value));
+                }
+                catch {
+                    return "NaN";
+                }
+            }
+            if (match === "%j" || match === "%o" || match === "%O")
+                return formatValue(value);
+            return formatPart(value);
+        });
+        let message = formatted;
+        for (let index = argIndex; index < messages.length; index += 1) {
+            message += ` ${formatPart(messages[index])}`;
         }
-      }
-      if (match === "%j" || match === "%o" || match === "%O") return formatValue(value)
-
-      return formatPart(value)
-    })
-
-    let message = formatted
-
-    for (let index = argIndex; index < messages.length; index += 1) {
-      message += ` ${formatPart(messages[index])}`
+        return message;
     }
-
-    return message
-  }
-
-  let message = ""
-
-  for (let index = 0; index < messages.length; index += 1) {
-    if (index > 0) message += " "
-    message += formatPart(messages[index])
-  }
-
-  return message
+    let message = "";
+    for (let index = 0; index < messages.length; index += 1) {
+        if (index > 0)
+            message += " ";
+        message += formatPart(messages[index]);
+    }
+    return message;
 }
-
 /**
  * Converts a logger subject and message parts into a single log line.
  * @param {string} subject - Logger subject / category prefix.
@@ -121,46 +104,40 @@ function formatUserMessages(messages) {
  * @returns {string} - The formatted log line.
  */
 function messagesToMessage(subject, ...messages) {
-  const userMessage = formatUserMessages(messages)
-
-  if (!subject) return userMessage
-  if (!userMessage) return String(subject)
-
-  return `${subject} ${userMessage}`
+    const userMessage = formatUserMessages(messages);
+    if (!subject)
+        return userMessage;
+    if (!userMessage)
+        return String(subject);
+    return `${subject} ${userMessage}`;
 }
-
 /**
  * Runs resolve logging configuration.
  * @param {import("./configuration.js").default | undefined} configuration - Configuration instance.
  * @returns {Required<Pick<import("./configuration-types.js").LoggingConfiguration, "console" | "file" | "levels">> & Partial<Pick<import("./configuration-types.js").LoggingConfiguration, "filePath" | "outputs">>} - The logging configuration.
  */
 function resolveLoggingConfiguration(configuration) {
-  const debugEnabled = configuration?.debug === true
-  if (configuration && typeof configuration.getLoggingConfiguration === "function") {
-    const resolved = configuration.getLoggingConfiguration()
-
-    if (debugEnabled) {
-      return {
-        ...resolved,
-        console: true,
-        levels: LEVEL_ORDER
-      }
+    const debugEnabled = configuration?.debug === true;
+    if (configuration && typeof configuration.getLoggingConfiguration === "function") {
+        const resolved = configuration.getLoggingConfiguration();
+        if (debugEnabled) {
+            return {
+                ...resolved,
+                console: true,
+                levels: LEVEL_ORDER
+            };
+        }
+        return resolved;
     }
-
-    return resolved
-  }
-
-  if (debugEnabled) {
-    return {
-      ...DEFAULT_LOGGING_CONFIGURATION,
-      console: true,
-      levels: LEVEL_ORDER
+    if (debugEnabled) {
+        return {
+            ...DEFAULT_LOGGING_CONFIGURATION,
+            console: true,
+            levels: LEVEL_ORDER
+        };
     }
-  }
-
-  return DEFAULT_LOGGING_CONFIGURATION
+    return DEFAULT_LOGGING_CONFIGURATION;
 }
-
 /**
  * Runs is level allowed.
  * @param {object} args - Options object.
@@ -169,14 +146,13 @@ function resolveLoggingConfiguration(configuration) {
  * @param {boolean} [args.debugFlag] - Whether debug flag.
  * @returns {boolean} - Whether level allowed.
  */
-function isLevelAllowed({level, allowedLevels, debugFlag}) {
-  if (allowedLevels.includes(level)) return true
-
-  if (debugFlag && LEVEL_ORDER.indexOf(level) >= LEVEL_ORDER.indexOf("debug")) return true
-
-  return false
+function isLevelAllowed({ level, allowedLevels, debugFlag }) {
+    if (allowedLevels.includes(level))
+        return true;
+    if (debugFlag && LEVEL_ORDER.indexOf(level) >= LEVEL_ORDER.indexOf("debug"))
+        return true;
+    return false;
 }
-
 /**
  * Runs resolve logging outputs.
  * @param {object} args - Options object.
@@ -184,75 +160,65 @@ function isLevelAllowed({level, allowedLevels, debugFlag}) {
  * @param {import("./configuration.js").default | undefined} args.configuration - Configuration instance.
  * @returns {import("./configuration-types.js").LoggingOutputConfig[]} - Logging outputs.
  */
-function resolveLoggingOutputs({loggingConfiguration, configuration}) {
-  if (Array.isArray(loggingConfiguration.outputs)) return loggingConfiguration.outputs
-
-  if (Array.isArray(loggingConfiguration.loggers)) {
+function resolveLoggingOutputs({ loggingConfiguration, configuration }) {
+    if (Array.isArray(loggingConfiguration.outputs))
+        return loggingConfiguration.outputs;
+    if (Array.isArray(loggingConfiguration.loggers)) {
+        /**
+         * Logger outputs.
+          @type {import("./configuration-types.js").LoggingOutputConfig[]} */
+        const loggerOutputs = [];
+        for (const logger of loggingConfiguration.loggers) {
+            if (!logger)
+                continue;
+            const loggerConfig = /**
+                                  * Types the following value.
+                                   @type {?} */ (logger);
+            if (typeof loggerConfig.toOutputConfig === "function") {
+                loggerOutputs.push(loggerConfig.toOutputConfig({ configuration }));
+                continue;
+            }
+            if (loggerConfig.output && typeof loggerConfig.output.write === "function") {
+                loggerOutputs.push({
+                    output: loggerConfig.output,
+                    levels: loggerConfig.levels
+                });
+                continue;
+            }
+            if (typeof loggerConfig.write === "function") {
+                loggerOutputs.push({
+                    output: loggerConfig,
+                    levels: loggerConfig.levels
+                });
+                continue;
+            }
+            const loggerName = loggerConfig?.constructor?.name || "UnknownLogger";
+            throw new Error(`Logger must implement toOutputConfig or write: ${loggerName}`);
+        }
+        return loggerOutputs;
+    }
     /**
-     * Logger outputs.
+     * Outputs.
       @type {import("./configuration-types.js").LoggingOutputConfig[]} */
-    const loggerOutputs = []
-
-    for (const logger of loggingConfiguration.loggers) {
-      if (!logger) continue
-
-      const loggerConfig = /**
-                            * Types the following value.
-                             @type {?} */ (logger)
-
-      if (typeof loggerConfig.toOutputConfig === "function") {
-        loggerOutputs.push(loggerConfig.toOutputConfig({configuration}))
-        continue
-      }
-
-      if (loggerConfig.output && typeof loggerConfig.output.write === "function") {
-        loggerOutputs.push({
-          output: loggerConfig.output,
-          levels: loggerConfig.levels
-        })
-        continue
-      }
-
-      if (typeof loggerConfig.write === "function") {
-        loggerOutputs.push({
-          output: loggerConfig,
-          levels: loggerConfig.levels
-        })
-        continue
-      }
-
-      const loggerName = loggerConfig?.constructor?.name || "UnknownLogger"
-      throw new Error(`Logger must implement toOutputConfig or write: ${loggerName}`)
+    const outputs = [];
+    if (loggingConfiguration.console !== false) {
+        outputs.push({
+            output: new LoggerConsoleOutput(),
+            levels: loggingConfiguration.levels
+        });
     }
-
-    return loggerOutputs
-  }
-
-  /**
-   * Outputs.
-    @type {import("./configuration-types.js").LoggingOutputConfig[]} */
-  const outputs = []
-  if (loggingConfiguration.console !== false) {
-    outputs.push({
-      output: new LoggerConsoleOutput(),
-      levels: loggingConfiguration.levels
-    })
-  }
-
-  if (loggingConfiguration.file !== false && loggingConfiguration.filePath) {
-    outputs.push({
-      output: new LoggerFileOutput({
-        configuration,
-        getConfiguration: () => configuration,
-        filePath: loggingConfiguration.filePath
-      }),
-      levels: loggingConfiguration.levels
-    })
-  }
-
-  return outputs
+    if (loggingConfiguration.file !== false && loggingConfiguration.filePath) {
+        outputs.push({
+            output: new LoggerFileOutput({
+                configuration,
+                getConfiguration: () => configuration,
+                filePath: loggingConfiguration.filePath
+            }),
+            levels: loggingConfiguration.levels
+        });
+    }
+    return outputs;
 }
-
 /**
  * Runs is output level allowed.
  * @param {object} args - Options object.
@@ -262,20 +228,16 @@ function resolveLoggingOutputs({loggingConfiguration, configuration}) {
  * @param {boolean} [args.debugFlag] - Whether debug flag.
  * @returns {boolean} - Whether output should log.
  */
-function isOutputLevelAllowed({level, outputConfig, loggingConfiguration, debugFlag}) {
-  if (Array.isArray(outputConfig.levels)) {
-    return isLevelAllowed({level, allowedLevels: outputConfig.levels, debugFlag: false})
-  }
-
-  if (Array.isArray(outputConfig.output?.levels)) {
-    return isLevelAllowed({level, allowedLevels: outputConfig.output.levels, debugFlag: false})
-  }
-
-  const allowedLevels = loggingConfiguration.levels || DEFAULT_LOGGING_CONFIGURATION.levels
-
-  return isLevelAllowed({level, allowedLevels, debugFlag})
+function isOutputLevelAllowed({ level, outputConfig, loggingConfiguration, debugFlag }) {
+    if (Array.isArray(outputConfig.levels)) {
+        return isLevelAllowed({ level, allowedLevels: outputConfig.levels, debugFlag: false });
+    }
+    if (Array.isArray(outputConfig.output?.levels)) {
+        return isLevelAllowed({ level, allowedLevels: outputConfig.output.levels, debugFlag: false });
+    }
+    const allowedLevels = loggingConfiguration.levels || DEFAULT_LOGGING_CONFIGURATION.levels;
+    return isLevelAllowed({ level, allowedLevels, debugFlag });
 }
-
 /**
  * Runs enabled output configs.
  * @param {object} args - Options object.
@@ -285,14 +247,13 @@ function isOutputLevelAllowed({level, outputConfig, loggingConfiguration, debugF
  * @param {boolean} [args.debugFlag] - Whether debug flag.
  * @returns {import("./configuration-types.js").LoggingOutputConfig[]} - Outputs enabled for the level.
  */
-function enabledOutputConfigs({level, outputs, loggingConfiguration, debugFlag}) {
-  return outputs.filter((outputConfig) => {
-    if (!outputConfig || !outputConfig.output || typeof outputConfig.output.write !== "function") return false
-
-    return isOutputLevelAllowed({level, outputConfig, loggingConfiguration, debugFlag})
-  })
+function enabledOutputConfigs({ level, outputs, loggingConfiguration, debugFlag }) {
+    return outputs.filter((outputConfig) => {
+        if (!outputConfig || !outputConfig.output || typeof outputConfig.output.write !== "function")
+            return false;
+        return isOutputLevelAllowed({ level, outputConfig, loggingConfiguration, debugFlag });
+    });
 }
-
 /**
  * Runs write log.
  * @param {object} args - Options object.
@@ -304,204 +265,187 @@ function enabledOutputConfigs({level, outputs, loggingConfiguration, debugFlag})
  * @param {boolean} [args.debugFlag] - Whether debug flag.
  * @returns {Promise<void>} - Resolves when complete.
  */
-async function writeLog({subject, level, messages, configuration, loggingConfiguration, debugFlag}) {
-  const resolvedLoggingConfiguration = loggingConfiguration || resolveLoggingConfiguration(configuration)
-  const outputs = resolveLoggingOutputs({loggingConfiguration: resolvedLoggingConfiguration, configuration})
-  const enabledOutputs = enabledOutputConfigs({
-    level,
-    outputs,
-    loggingConfiguration: resolvedLoggingConfiguration,
-    debugFlag
-  })
-
-  if (enabledOutputs.length === 0) return
-
-  const writes = []
-  /**
-   * Types the following value.
-    @type {Array<?> | undefined} */
-  let resolvedMessages
-  /**
-   * Types the following value.
-    @type {string | undefined} */
-  let message
-  /**
-   * Payload.
-    @type {import("./configuration-types.js").LoggingOutputPayload | null} */
-  let payload = null
-
-  for (const outputConfig of enabledOutputs) {
-    if (!payload) {
-      resolvedMessages = functionOrMessages(...messages)
-      message = messagesToMessage(subject, ...resolvedMessages)
-      // subject is the first positional arg, then the user messages
-      payload = {
+async function writeLog({ subject, level, messages, configuration, loggingConfiguration, debugFlag }) {
+    const resolvedLoggingConfiguration = loggingConfiguration || resolveLoggingConfiguration(configuration);
+    const outputs = resolveLoggingOutputs({ loggingConfiguration: resolvedLoggingConfiguration, configuration });
+    const enabledOutputs = enabledOutputConfigs({
         level,
-        message,
-        subject,
-        timestamp: new Date()
-      }
+        outputs,
+        loggingConfiguration: resolvedLoggingConfiguration,
+        debugFlag
+    });
+    if (enabledOutputs.length === 0)
+        return;
+    const writes = [];
+    /**
+     * Types the following value.
+      @type {Array<?> | undefined} */
+    let resolvedMessages;
+    /**
+     * Types the following value.
+      @type {string | undefined} */
+    let message;
+    /**
+     * Payload.
+      @type {import("./configuration-types.js").LoggingOutputPayload | null} */
+    let payload = null;
+    for (const outputConfig of enabledOutputs) {
+        if (!payload) {
+            resolvedMessages = functionOrMessages(...messages);
+            message = messagesToMessage(subject, ...resolvedMessages);
+            // subject is the first positional arg, then the user messages
+            payload = {
+                level,
+                message,
+                subject,
+                timestamp: new Date()
+            };
+        }
+        writes.push(outputConfig.output.write(payload));
+    }
+    if (writes.length === 1) {
+        await writes[0];
+    }
+    else if (writes.length > 1) {
+        await Promise.all(writes);
     }
-
-    writes.push(outputConfig.output.write(payload))
-  }
-
-  if (writes.length === 1) {
-    await writes[0]
-  } else if (writes.length > 1) {
-    await Promise.all(writes)
-  }
 }
-
 export default class Logger {
-  /**
-   * Runs constructor.
-   * @param {string | object} object - Object.
-   * @param {object} args - Options object.
-   * @param {import("./configuration.js").default} [args.configuration] - Configuration instance.
-   * @param {boolean} [args.debug] - Whether debug.
-   * @param {import("./configuration-types.js").LoggingConfiguration} [args.loggingConfiguration] - Logging configuration.
-   */
-  constructor(object, {configuration, debug = false, loggingConfiguration, ...restArgs} = {}) {
-    restArgsError(restArgs)
-
-    this._debug = debug
-    this._configuration = configuration
-    this._loggingConfiguration = loggingConfiguration
-
-    if (typeof object == "string") {
-      this._subject = object || "EmptyString"
-    } else {
-      this._object = object
-      this._subject = object.constructor.name || "UnknownClass"
+    /**
+     * Runs constructor.
+     * @param {string | object} object - Object.
+     * @param {object} args - Options object.
+     * @param {import("./configuration.js").default} [args.configuration] - Configuration instance.
+     * @param {boolean} [args.debug] - Whether debug.
+     * @param {import("./configuration-types.js").LoggingConfiguration} [args.loggingConfiguration] - Logging configuration.
+     */
+    constructor(object, { configuration, debug = false, loggingConfiguration, ...restArgs } = {}) {
+        restArgsError(restArgs);
+        this._debug = debug;
+        this._configuration = configuration;
+        this._loggingConfiguration = loggingConfiguration;
+        if (typeof object == "string") {
+            this._subject = object || "EmptyString";
+        }
+        else {
+            this._object = object;
+            this._subject = object.constructor.name || "UnknownClass";
+        }
     }
-  }
-
-  /**
-   * Runs get configuration.
-   * @returns {import("./configuration.js").default} - The configuration.
-   */
-  getConfiguration() {
-    if (!this._configuration) {
-      const objectWithConfig = /**
-                                * Types the following value.
-                                 @type {{configuration?: import("./configuration.js").default}} */ (this._object)
-      this._configuration = objectWithConfig?.configuration || currentConfiguration()
+    /**
+     * Runs get configuration.
+     * @returns {import("./configuration.js").default} - The configuration.
+     */
+    getConfiguration() {
+        if (!this._configuration) {
+            const objectWithConfig = /**
+                                      * Types the following value.
+                                       @type {{configuration?: import("./configuration.js").default}} */ (this._object);
+            this._configuration = objectWithConfig?.configuration || currentConfiguration();
+        }
+        return this._configuration;
+    }
+    /**
+     * Runs safe configuration.
+     * @returns {import("./configuration.js").default | undefined} - The safe configuration.
+     */
+    _safeConfiguration() {
+        try {
+            return this.getConfiguration();
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Runs is level enabled.
+     * @param {LogLevel} level - Level.
+     * @returns {boolean} - Whether any configured output emits this level.
+     */
+    isLevelEnabled(level) {
+        const configuration = this._safeConfiguration();
+        const loggingConfiguration = this._loggingConfiguration || resolveLoggingConfiguration(configuration);
+        const outputs = resolveLoggingOutputs({ loggingConfiguration, configuration });
+        return enabledOutputConfigs({
+            level,
+            outputs,
+            loggingConfiguration,
+            debugFlag: this._debug
+        }).length > 0;
+    }
+    /**
+     * Runs debug.
+     * @param {Array<?>} messages - Messages.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async debug(...messages) {
+        await this._write({ level: "debug", messages });
+    }
+    /**
+     * Runs info.
+     * @param {Array<?>} messages - Messages.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async info(...messages) {
+        await this._write({ level: "info", messages });
+    }
+    /**
+     * Runs debug low level.
+     * @param {Array<?>} messages - Messages.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async debugLowLevel(...messages) {
+        await this._write({ level: "debug-low-level", messages });
+    }
+    /**
+     * Runs log.
+     * @param {Array<?>} messages - Messages.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async log(...messages) {
+        await this._write({ level: "info", messages });
+    }
+    /**
+     * Runs error.
+     * @param {Array<?>} messages - Messages.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async error(...messages) {
+        await this._write({ level: "error", messages });
+    }
+    /**
+     * Runs set debug.
+     * @param {boolean} newValue - New value.
+     * @returns {void} - No return value.
+     */
+    setDebug(newValue) {
+        this._debug = newValue;
     }
-
-    return this._configuration
-  }
-
-  /**
-   * Runs safe configuration.
-   * @returns {import("./configuration.js").default | undefined} - The safe configuration.
-   */
-  _safeConfiguration() {
-    try {
-      return this.getConfiguration()
-    } catch {
-      return undefined
+    /**
+     * Runs warn.
+     * @type {(...args: Parameters<typeof functionOrMessages>) => Promise<void>}
+     */
+    async warn(...messages) {
+        await this._write({ level: "warn", messages });
+    }
+    /**
+     * Runs write.
+     * @param {object} args - Options object.
+     * @param {LogLevel} args.level - Level.
+     * @param {Parameters<typeof functionOrMessages>} args.messages - Messages.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async _write({ level, messages }) {
+        const configuration = this._safeConfiguration();
+        const loggingConfiguration = this._loggingConfiguration || resolveLoggingConfiguration(configuration);
+        await writeLog({
+            subject: this._subject,
+            level,
+            messages,
+            configuration,
+            loggingConfiguration,
+            debugFlag: this._debug
+        });
     }
-  }
-
-  /**
-   * Runs is level enabled.
-   * @param {LogLevel} level - Level.
-   * @returns {boolean} - Whether any configured output emits this level.
-   */
-  isLevelEnabled(level) {
-    const configuration = this._safeConfiguration()
-    const loggingConfiguration = this._loggingConfiguration || resolveLoggingConfiguration(configuration)
-    const outputs = resolveLoggingOutputs({loggingConfiguration, configuration})
-
-    return enabledOutputConfigs({
-      level,
-      outputs,
-      loggingConfiguration,
-      debugFlag: this._debug
-    }).length > 0
-  }
-
-  /**
-   * Runs debug.
-   * @param {Array<?>} messages - Messages.
-   * @returns {Promise<void>} - Resolves when complete.
-   */
-  async debug(...messages) {
-    await this._write({level: "debug", messages})
-  }
-
-  /**
-   * Runs info.
-   * @param {Array<?>} messages - Messages.
-   * @returns {Promise<void>} - Resolves when complete.
-   */
-  async info(...messages) {
-    await this._write({level: "info", messages})
-  }
-
-  /**
-   * Runs debug low level.
-   * @param {Array<?>} messages - Messages.
-   * @returns {Promise<void>} - Resolves when complete.
-   */
-  async debugLowLevel(...messages) {
-    await this._write({level: "debug-low-level", messages})
-  }
-
-  /**
-   * Runs log.
-   * @param {Array<?>} messages - Messages.
-   * @returns {Promise<void>} - Resolves when complete.
-   */
-  async log(...messages) {
-    await this._write({level: "info", messages})
-  }
-
-  /**
-   * Runs error.
-   * @param {Array<?>} messages - Messages.
-   * @returns {Promise<void>} - Resolves when complete.
-   */
-  async error(...messages) {
-    await this._write({level: "error", messages})
-  }
-
-  /**
-   * Runs set debug.
-   * @param {boolean} newValue - New value.
-   * @returns {void} - No return value.
-   */
-  setDebug(newValue) {
-    this._debug = newValue
-  }
-
-  /**
-   * Runs warn.
-   * @type {(...args: Parameters<typeof functionOrMessages>) => Promise<void>}
-   */
-  async warn(...messages) {
-    await this._write({level: "warn", messages})
-  }
-
-  /**
-   * Runs write.
-   * @param {object} args - Options object.
-   * @param {LogLevel} args.level - Level.
-   * @param {Parameters<typeof functionOrMessages>} args.messages - Messages.
-   * @returns {Promise<void>} - Resolves when complete.
-   */
-  async _write({level, messages}) {
-    const configuration = this._safeConfiguration()
-    const loggingConfiguration = this._loggingConfiguration || resolveLoggingConfiguration(configuration)
-
-    await writeLog({
-      subject: this._subject,
-      level,
-      messages,
-      configuration,
-      loggingConfiguration,
-      debugFlag: this._debug
-    })
-  }
 }
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"logger.js","sourceRoot":"","sources":["../../src/logger.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport LoggerConsoleOutput from \"./logger/outputs/console-output.js\"\nimport LoggerFileOutput from \"./logger/outputs/file-output.js\"\nimport {currentConfiguration} from \"./current-configuration.js\"\nimport {formatValue} from \"./utils/format-value.js\"\nimport restArgsError from \"./utils/rest-args-error.js\"\n\n/**\n * LogLevel type.\n  @typedef {\"debug-low-level\" | \"debug\" | \"info\" | \"warn\" | \"error\"} LogLevel */\n\nconst DEFAULT_LOGGING_CONFIGURATION = {\n  console: true,\n  file: false,\n  /**\n   * Types the following value.\n    @type {LogLevel[]} */\n  levels: [\"info\", \"warn\", \"error\"]\n}\n\n/**\n * Level order.\n  @type {LogLevel[]} */\nconst LEVEL_ORDER = [\"debug-low-level\", \"debug\", \"info\", \"warn\", \"error\"]\n\n/**\n * Runs function or messages.\n * @param {...?|function() : Array<?>} messages - Messages.\n * @returns {Array<?>} - Either the function result or the messages\n */\nfunction functionOrMessages(...messages) {\n  if (messages.length === 1 && typeof messages[0] == \"function\") {\n    const result = messages[0]()\n    messages = Array.isArray(result) ? result : [result]\n  }\n\n  return messages\n}\n\n/**\n * Format a single value for inclusion in a log message.\n * @param {?} value - Value to format.\n * @returns {string} - String representation.\n */\nfunction formatPart(value) {\n  if (value instanceof Error) {\n    return `${value.message}\\n${value.stack}`\n  }\n\n  if (typeof value === \"object\") {\n    return formatValue(value)\n  }\n\n  return String(value)\n}\n\n/**\n * Formats the user-supplied messages into a single string.\n *\n * If the first message is a string containing printf-style format\n * specifiers (`%s`, `%d`, `%j`, `%o`, `%O`, or `%%`), the remaining\n * messages are interpolated into it in order (like `console.log` /\n * `util.format`). Any leftover messages are appended with a space\n * separator. Otherwise, all parts are joined with spaces.\n * @param {Array<?>} messages - User-supplied message parts.\n * @returns {string} - The formatted user message.\n */\nfunction formatUserMessages(messages) {\n  if (messages.length === 0) return \"\"\n\n  const first = messages[0]\n\n  if (typeof first === \"string\" && /%[sdjoO%]/.test(first)) {\n    let argIndex = 1\n    const formatted = first.replace(/%[sdjoO%]/g, (match) => {\n      if (match === \"%%\") return \"%\"\n      if (argIndex >= messages.length) return match\n\n      const value = messages[argIndex]\n\n      argIndex += 1\n\n      if (match === \"%d\") {\n        // Match util.format: never throw for non-coercible values — yield \"NaN\" instead.\n        // Number(Symbol()) throws, so catch and fall back.\n        try {\n          return String(Number(value))\n        } catch {\n          return \"NaN\"\n        }\n      }\n      if (match === \"%j\" || match === \"%o\" || match === \"%O\") return formatValue(value)\n\n      return formatPart(value)\n    })\n\n    let message = formatted\n\n    for (let index = argIndex; index < messages.length; index += 1) {\n      message += ` ${formatPart(messages[index])}`\n    }\n\n    return message\n  }\n\n  let message = \"\"\n\n  for (let index = 0; index < messages.length; index += 1) {\n    if (index > 0) message += \" \"\n    message += formatPart(messages[index])\n  }\n\n  return message\n}\n\n/**\n * Converts a logger subject and message parts into a single log line.\n * @param {string} subject - Logger subject / category prefix.\n * @param {...?} messages - User-supplied message parts (supports printf-style format specifiers on the first part).\n * @returns {string} - The formatted log line.\n */\nfunction messagesToMessage(subject, ...messages) {\n  const userMessage = formatUserMessages(messages)\n\n  if (!subject) return userMessage\n  if (!userMessage) return String(subject)\n\n  return `${subject} ${userMessage}`\n}\n\n/**\n * Runs resolve logging configuration.\n * @param {import(\"./configuration.js\").default | undefined} configuration - Configuration instance.\n * @returns {Required<Pick<import(\"./configuration-types.js\").LoggingConfiguration, \"console\" | \"file\" | \"levels\">> & Partial<Pick<import(\"./configuration-types.js\").LoggingConfiguration, \"filePath\" | \"outputs\">>} - The logging configuration.\n */\nfunction resolveLoggingConfiguration(configuration) {\n  const debugEnabled = configuration?.debug === true\n  if (configuration && typeof configuration.getLoggingConfiguration === \"function\") {\n    const resolved = configuration.getLoggingConfiguration()\n\n    if (debugEnabled) {\n      return {\n        ...resolved,\n        console: true,\n        levels: LEVEL_ORDER\n      }\n    }\n\n    return resolved\n  }\n\n  if (debugEnabled) {\n    return {\n      ...DEFAULT_LOGGING_CONFIGURATION,\n      console: true,\n      levels: LEVEL_ORDER\n    }\n  }\n\n  return DEFAULT_LOGGING_CONFIGURATION\n}\n\n/**\n * Runs is level allowed.\n * @param {object} args - Options object.\n * @param {LogLevel} args.level - Level.\n * @param {LogLevel[]} args.allowedLevels - Allowed levels.\n * @param {boolean} [args.debugFlag] - Whether debug flag.\n * @returns {boolean} - Whether level allowed.\n */\nfunction isLevelAllowed({level, allowedLevels, debugFlag}) {\n  if (allowedLevels.includes(level)) return true\n\n  if (debugFlag && LEVEL_ORDER.indexOf(level) >= LEVEL_ORDER.indexOf(\"debug\")) return true\n\n  return false\n}\n\n/**\n * Runs resolve logging outputs.\n * @param {object} args - Options object.\n * @param {import(\"./configuration-types.js\").LoggingConfiguration} args.loggingConfiguration - Logging configuration.\n * @param {import(\"./configuration.js\").default | undefined} args.configuration - Configuration instance.\n * @returns {import(\"./configuration-types.js\").LoggingOutputConfig[]} - Logging outputs.\n */\nfunction resolveLoggingOutputs({loggingConfiguration, configuration}) {\n  if (Array.isArray(loggingConfiguration.outputs)) return loggingConfiguration.outputs\n\n  if (Array.isArray(loggingConfiguration.loggers)) {\n    /**\n     * Logger outputs.\n      @type {import(\"./configuration-types.js\").LoggingOutputConfig[]} */\n    const loggerOutputs = []\n\n    for (const logger of loggingConfiguration.loggers) {\n      if (!logger) continue\n\n      const loggerConfig = /**\n                            * Types the following value.\n                             @type {?} */ (logger)\n\n      if (typeof loggerConfig.toOutputConfig === \"function\") {\n        loggerOutputs.push(loggerConfig.toOutputConfig({configuration}))\n        continue\n      }\n\n      if (loggerConfig.output && typeof loggerConfig.output.write === \"function\") {\n        loggerOutputs.push({\n          output: loggerConfig.output,\n          levels: loggerConfig.levels\n        })\n        continue\n      }\n\n      if (typeof loggerConfig.write === \"function\") {\n        loggerOutputs.push({\n          output: loggerConfig,\n          levels: loggerConfig.levels\n        })\n        continue\n      }\n\n      const loggerName = loggerConfig?.constructor?.name || \"UnknownLogger\"\n      throw new Error(`Logger must implement toOutputConfig or write: ${loggerName}`)\n    }\n\n    return loggerOutputs\n  }\n\n  /**\n   * Outputs.\n    @type {import(\"./configuration-types.js\").LoggingOutputConfig[]} */\n  const outputs = []\n  if (loggingConfiguration.console !== false) {\n    outputs.push({\n      output: new LoggerConsoleOutput(),\n      levels: loggingConfiguration.levels\n    })\n  }\n\n  if (loggingConfiguration.file !== false && loggingConfiguration.filePath) {\n    outputs.push({\n      output: new LoggerFileOutput({\n        configuration,\n        getConfiguration: () => configuration,\n        filePath: loggingConfiguration.filePath\n      }),\n      levels: loggingConfiguration.levels\n    })\n  }\n\n  return outputs\n}\n\n/**\n * Runs is output level allowed.\n * @param {object} args - Options object.\n * @param {LogLevel} args.level - Level.\n * @param {import(\"./configuration-types.js\").LoggingOutputConfig} args.outputConfig - Output configuration.\n * @param {import(\"./configuration-types.js\").LoggingConfiguration} args.loggingConfiguration - Logging configuration.\n * @param {boolean} [args.debugFlag] - Whether debug flag.\n * @returns {boolean} - Whether output should log.\n */\nfunction isOutputLevelAllowed({level, outputConfig, loggingConfiguration, debugFlag}) {\n  if (Array.isArray(outputConfig.levels)) {\n    return isLevelAllowed({level, allowedLevels: outputConfig.levels, debugFlag: false})\n  }\n\n  if (Array.isArray(outputConfig.output?.levels)) {\n    return isLevelAllowed({level, allowedLevels: outputConfig.output.levels, debugFlag: false})\n  }\n\n  const allowedLevels = loggingConfiguration.levels || DEFAULT_LOGGING_CONFIGURATION.levels\n\n  return isLevelAllowed({level, allowedLevels, debugFlag})\n}\n\n/**\n * Runs enabled output configs.\n * @param {object} args - Options object.\n * @param {LogLevel} args.level - Level.\n * @param {import(\"./configuration-types.js\").LoggingOutputConfig[]} args.outputs - Output configurations.\n * @param {import(\"./configuration-types.js\").LoggingConfiguration} args.loggingConfiguration - Logging configuration.\n * @param {boolean} [args.debugFlag] - Whether debug flag.\n * @returns {import(\"./configuration-types.js\").LoggingOutputConfig[]} - Outputs enabled for the level.\n */\nfunction enabledOutputConfigs({level, outputs, loggingConfiguration, debugFlag}) {\n  return outputs.filter((outputConfig) => {\n    if (!outputConfig || !outputConfig.output || typeof outputConfig.output.write !== \"function\") return false\n\n    return isOutputLevelAllowed({level, outputConfig, loggingConfiguration, debugFlag})\n  })\n}\n\n/**\n * Runs write log.\n * @param {object} args - Options object.\n * @param {string} args.subject - Log subject.\n * @param {LogLevel} args.level - Level.\n * @param {Parameters<typeof functionOrMessages>} args.messages - Messages.\n * @param {import(\"./configuration.js\").default | undefined} args.configuration - Configuration instance.\n * @param {import(\"./configuration-types.js\").LoggingConfiguration | undefined} args.loggingConfiguration - Logging configuration.\n * @param {boolean} [args.debugFlag] - Whether debug flag.\n * @returns {Promise<void>} - Resolves when complete.\n */\nasync function writeLog({subject, level, messages, configuration, loggingConfiguration, debugFlag}) {\n  const resolvedLoggingConfiguration = loggingConfiguration || resolveLoggingConfiguration(configuration)\n  const outputs = resolveLoggingOutputs({loggingConfiguration: resolvedLoggingConfiguration, configuration})\n  const enabledOutputs = enabledOutputConfigs({\n    level,\n    outputs,\n    loggingConfiguration: resolvedLoggingConfiguration,\n    debugFlag\n  })\n\n  if (enabledOutputs.length === 0) return\n\n  const writes = []\n  /**\n   * Types the following value.\n    @type {Array<?> | undefined} */\n  let resolvedMessages\n  /**\n   * Types the following value.\n    @type {string | undefined} */\n  let message\n  /**\n   * Payload.\n    @type {import(\"./configuration-types.js\").LoggingOutputPayload | null} */\n  let payload = null\n\n  for (const outputConfig of enabledOutputs) {\n    if (!payload) {\n      resolvedMessages = functionOrMessages(...messages)\n      message = messagesToMessage(subject, ...resolvedMessages)\n      // subject is the first positional arg, then the user messages\n      payload = {\n        level,\n        message,\n        subject,\n        timestamp: new Date()\n      }\n    }\n\n    writes.push(outputConfig.output.write(payload))\n  }\n\n  if (writes.length === 1) {\n    await writes[0]\n  } else if (writes.length > 1) {\n    await Promise.all(writes)\n  }\n}\n\nexport default class Logger {\n  /**\n   * Runs constructor.\n   * @param {string | object} object - Object.\n   * @param {object} args - Options object.\n   * @param {import(\"./configuration.js\").default} [args.configuration] - Configuration instance.\n   * @param {boolean} [args.debug] - Whether debug.\n   * @param {import(\"./configuration-types.js\").LoggingConfiguration} [args.loggingConfiguration] - Logging configuration.\n   */\n  constructor(object, {configuration, debug = false, loggingConfiguration, ...restArgs} = {}) {\n    restArgsError(restArgs)\n\n    this._debug = debug\n    this._configuration = configuration\n    this._loggingConfiguration = loggingConfiguration\n\n    if (typeof object == \"string\") {\n      this._subject = object || \"EmptyString\"\n    } else {\n      this._object = object\n      this._subject = object.constructor.name || \"UnknownClass\"\n    }\n  }\n\n  /**\n   * Runs get configuration.\n   * @returns {import(\"./configuration.js\").default} - The configuration.\n   */\n  getConfiguration() {\n    if (!this._configuration) {\n      const objectWithConfig = /**\n                                * Types the following value.\n                                 @type {{configuration?: import(\"./configuration.js\").default}} */ (this._object)\n      this._configuration = objectWithConfig?.configuration || currentConfiguration()\n    }\n\n    return this._configuration\n  }\n\n  /**\n   * Runs safe configuration.\n   * @returns {import(\"./configuration.js\").default | undefined} - The safe configuration.\n   */\n  _safeConfiguration() {\n    try {\n      return this.getConfiguration()\n    } catch {\n      return undefined\n    }\n  }\n\n  /**\n   * Runs is level enabled.\n   * @param {LogLevel} level - Level.\n   * @returns {boolean} - Whether any configured output emits this level.\n   */\n  isLevelEnabled(level) {\n    const configuration = this._safeConfiguration()\n    const loggingConfiguration = this._loggingConfiguration || resolveLoggingConfiguration(configuration)\n    const outputs = resolveLoggingOutputs({loggingConfiguration, configuration})\n\n    return enabledOutputConfigs({\n      level,\n      outputs,\n      loggingConfiguration,\n      debugFlag: this._debug\n    }).length > 0\n  }\n\n  /**\n   * Runs debug.\n   * @param {Array<?>} messages - Messages.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async debug(...messages) {\n    await this._write({level: \"debug\", messages})\n  }\n\n  /**\n   * Runs info.\n   * @param {Array<?>} messages - Messages.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async info(...messages) {\n    await this._write({level: \"info\", messages})\n  }\n\n  /**\n   * Runs debug low level.\n   * @param {Array<?>} messages - Messages.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async debugLowLevel(...messages) {\n    await this._write({level: \"debug-low-level\", messages})\n  }\n\n  /**\n   * Runs log.\n   * @param {Array<?>} messages - Messages.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async log(...messages) {\n    await this._write({level: \"info\", messages})\n  }\n\n  /**\n   * Runs error.\n   * @param {Array<?>} messages - Messages.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async error(...messages) {\n    await this._write({level: \"error\", messages})\n  }\n\n  /**\n   * Runs set debug.\n   * @param {boolean} newValue - New value.\n   * @returns {void} - No return value.\n   */\n  setDebug(newValue) {\n    this._debug = newValue\n  }\n\n  /**\n   * Runs warn.\n   * @type {(...args: Parameters<typeof functionOrMessages>) => Promise<void>}\n   */\n  async warn(...messages) {\n    await this._write({level: \"warn\", messages})\n  }\n\n  /**\n   * Runs write.\n   * @param {object} args - Options object.\n   * @param {LogLevel} args.level - Level.\n   * @param {Parameters<typeof functionOrMessages>} args.messages - Messages.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _write({level, messages}) {\n    const configuration = this._safeConfiguration()\n    const loggingConfiguration = this._loggingConfiguration || resolveLoggingConfiguration(configuration)\n\n    await writeLog({\n      subject: this._subject,\n      level,\n      messages,\n      configuration,\n      loggingConfiguration,\n      debugFlag: this._debug\n    })\n  }\n}\n"]}