@visulima/pail 3.0.3 → 3.2.0

package/dist/packem_shared/PrettyReporter-BFWaYP_J.js

@@ -0,0 +1,222 @@
+import { createRequire as __cjs_createRequire } from "node:module";
+
+const __cjs_require = __cjs_createRequire(import.meta.url);
+
+const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+
+const {
+  stdout,
+  stderr
+} = __cjs_getProcess;
+import colorize, { red, greenBright, cyan, green, grey, white, bgGrey, underline } from '@visulima/colorize';
+import { d as defaultInspectorConfig, f as formatLabel, i as inspect, r as renderError } from './format-label-Btft2KGP.js';
+import { t as terminalSize, g as getStringWidth, w as wordWrap, W as WrapMode } from './index-DqKWykfa.js';
+import { E as EMPTY_SYMBOL } from './constants-DfDr4MHC.js';
+import { A as AbstractPrettyReporter, g as getLongestBadge } from './abstract-pretty-reporter-DMPDCslJ.js';
+import { g as getLongestLabel } from './get-longest-label-C9PWeyKq.js';
+import { w as writeStream } from './write-stream-BG8fhcs3.js';
+
+const pailFileFilter = (line) => !/[\\/]pail[\\/]dist/.test(line);
+class PrettyReporter extends AbstractPrettyReporter {
+  #stdout;
+  #stderr;
+  #interactiveManager;
+  #interactive = false;
+  #inspectOptions;
+  #errorOptions;
+  /**
+   * Creates a new Server Pretty Reporter instance.
+   * @param options Configuration options for styling, error rendering, and object inspection
+   */
+  constructor(options = {}) {
+    const { error: errorOptions, inspect: inspectOptions, ...rest } = options;
+    super({
+      uppercase: {
+        label: true,
+        ...rest.uppercase
+      },
+      ...rest
+    });
+    this.#inspectOptions = { ...defaultInspectorConfig, ...inspectOptions };
+    this.#errorOptions = {
+      ...errorOptions,
+      color: {
+        fileLine: green,
+        hint: cyan,
+        marker: red,
+        message: red,
+        method: greenBright,
+        title: red
+      }
+    };
+    this.#stdout = stdout;
+    this.#stderr = stderr;
+  }
+  /**
+   * Sets the stdout stream for the reporter.
+   * @param stdout_ The writable stream to use for standard output
+   */
+  setStdout(stdout_) {
+    this.#stdout = stdout_;
+  }
+  /**
+   * Sets the stderr stream for the reporter.
+   * @param stderr_ The writable stream to use for error output
+   */
+  setStderr(stderr_) {
+    this.#stderr = stderr_;
+  }
+  /**
+   * Sets the interactive manager for handling interactive output.
+   * @param manager The interactive manager instance, or undefined to disable
+   */
+  setInteractiveManager(manager) {
+    this.#interactiveManager = manager;
+  }
+  /**
+   * Enables or disables interactive mode.
+   * @param interactive Whether to enable interactive terminal features
+   */
+  setIsInteractive(interactive) {
+    this.#interactive = interactive;
+  }
+  log(meta) {
+    this._log(this._formatMessage(meta), meta.type.level);
+  }
+  // eslint-disable-next-line sonarjs/cognitive-complexity, no-underscore-dangle
+  _formatMessage(data) {
+    const { columns } = terminalSize();
+    let size = columns;
+    if (typeof this.styles.messageLength === "number") {
+      size = this.styles.messageLength;
+    }
+    const { badge, context, date, error, file, groups, label, message, prefix, repeated, scope, suffix, traceError, type } = data;
+    const { color } = this.loggerTypes[type.name];
+    const colorized = color ? colorize[color] : white;
+    const groupSpaces = groups.map(() => "    ").join("");
+    const items = [];
+    if (groups.length > 0) {
+      items.push(`${groupSpaces + grey(`[${groups.at(-1)}]`)} `);
+    }
+    if (date) {
+      items.push(`${grey(this.styles.dateFormatter(typeof date === "string" ? new Date(date) : date))} `);
+    }
+    if (badge) {
+      items.push(colorized(badge));
+    } else {
+      const longestBadge = getLongestBadge(this.loggerTypes);
+      if (longestBadge.length > 0) {
+        items.push(`${grey(".".repeat(longestBadge.length))} `);
+      }
+    }
+    const longestLabel = getLongestLabel(this.loggerTypes);
+    if (label) {
+      const longestLabelWidth = getStringWidth(longestLabel);
+      const labelWidth = getStringWidth(label);
+      items.push(`${colorized(formatLabel(label, this.styles))} `, grey(".".repeat(Math.max(0, longestLabelWidth - labelWidth))));
+    } else {
+      items.push(grey(".".repeat(longestLabel.length + 2)));
+    }
+    if (repeated) {
+      items.push(`${bgGrey.white(`[${repeated}x]`)} `);
+    }
+    if (Array.isArray(scope) && scope.length > 0) {
+      items.push(` ${grey(`[${scope.join(" > ")}]`)} `);
+    }
+    if (prefix) {
+      items.push(
+        `${grey(`${Array.isArray(scope) && scope.length > 0 ? ". " : " "}[${this.styles.underline.prefix ? underline(prefix) : prefix}]`)} `
+      );
+    }
+    const titleSize = getStringWidth(items.join(" "));
+    if (file) {
+      const fileMessage = file.name + (file.line ? `:${file.line}` : "");
+      const fileMessageSize = getStringWidth(fileMessage);
+      if (fileMessageSize + titleSize + 2 > size) {
+        items.push(grey(` ${fileMessage}`));
+      } else {
+        const dots = Math.max(0, size - titleSize - fileMessageSize - 2);
+        items.push(grey(`${".".repeat(dots)} ${fileMessage}`));
+      }
+    } else {
+      items.push(grey(".".repeat(Math.max(0, size - titleSize - 1))));
+    }
+    if (items.length > 0) {
+      items.push("\n\n");
+    }
+    if (message !== EMPTY_SYMBOL) {
+      const formattedMessage = typeof message === "string" ? message : inspect(message, this.#inspectOptions);
+      items.push(
+        groupSpaces + wordWrap(formattedMessage, {
+          trim: false,
+          width: size - 3,
+          wrapMode: WrapMode.STRICT_WIDTH
+        })
+      );
+    }
+    if (context) {
+      let hasError = false;
+      items.push(
+        ...context.map((value) => {
+          if (value instanceof Error) {
+            hasError = true;
+            return `
+
+${renderError(value, {
+              ...this.#errorOptions,
+              filterStacktrace: pailFileFilter,
+              prefix: groupSpaces
+            })}`;
+          }
+          if (typeof value === "object") {
+            return ` ${inspect(value, this.#inspectOptions)}`;
+          }
+          const newValue = (hasError ? "\n\n" : " ") + value;
+          hasError = false;
+          return newValue;
+        })
+      );
+    }
+    if (error) {
+      items.push(
+        renderError(error, {
+          ...this.#errorOptions,
+          filterStacktrace: pailFileFilter,
+          prefix: groupSpaces
+        })
+      );
+    }
+    if (traceError) {
+      items.push(
+        `
+
+${renderError(traceError, {
+          ...this.#errorOptions,
+          filterStacktrace: pailFileFilter,
+          hideErrorCauseCodeView: true,
+          hideErrorCodeView: true,
+          hideErrorErrorsCodeView: true,
+          hideMessage: true,
+          prefix: groupSpaces
+        })}`
+      );
+    }
+    if (suffix) {
+      items.push("\n", groupSpaces + grey(this.styles.underline.suffix ? underline(suffix) : suffix));
+    }
+    return items.join("");
+  }
+  // eslint-disable-next-line no-underscore-dangle
+  _log(message, logLevel) {
+    const streamType = ["error", "trace", "warn"].includes(logLevel) ? "stderr" : "stdout";
+    const stream = streamType === "stderr" ? this.#stderr : this.#stdout;
+    if (this.#interactive && this.#interactiveManager !== void 0 && stream.isTTY) {
+      this.#interactiveManager.update(streamType, message.split("\n"), 0);
+    } else {
+      writeStream(`${message}
+`, stream);
+    }
+  }
+}
+
+export { PrettyReporter };

package/dist/packem_shared/PrettyReporter-CuLLKr6-.js

@@ -0,0 +1,169 @@
+import colorize, { grey, white, underline, bold } from '@visulima/colorize/browser';
+import { f as format } from './index-BomQ3E6J.js';
+import { E as EMPTY_SYMBOL } from './constants-DfDr4MHC.js';
+import { A as AbstractPrettyReporter, g as getLongestBadge } from './abstract-pretty-reporter-DMPDCslJ.js';
+import { g as getLongestLabel } from './get-longest-label-C9PWeyKq.js';
+import { w as writeConsoleLogBasedOnLevel } from './write-console-log-based-on-level-DBmRYXpj.js';
+
+class PrettyReporter extends AbstractPrettyReporter {
+  /**
+   * Creates a new Browser Pretty Reporter instance.
+   * @param options Styling options for pretty formatting
+   */
+  constructor(options = {}) {
+    super({
+      uppercase: {
+        label: true,
+        ...options.uppercase
+      },
+      ...options
+    });
+  }
+  // eslint-disable-next-line sonarjs/cognitive-complexity
+  log(meta) {
+    const isNotBrowser = typeof globalThis.window !== "undefined" && typeof globalThis.document !== "undefined";
+    const consoleLogFunction = writeConsoleLogBasedOnLevel(meta.type.level);
+    const { badge, context, date, error, groups, label, message, prefix, repeated, scope, suffix, type } = meta;
+    const { color } = this.loggerTypes[type.name];
+    const colorized = color ? colorize[color] : white;
+    const items = [];
+    if (isNotBrowser && groups.length > 0) {
+      const groupSpaces = groups.map(() => "   ").join("");
+      const cGroup = grey(`[${groups.at(-1)}]`);
+      items.push(format(groupSpaces + cGroup[0], cGroup.slice(1)));
+    }
+    if (date) {
+      const cDate = grey(this.styles.dateFormatter(typeof date === "string" ? new Date(date) : date));
+      if (isNotBrowser) {
+        items.push(format(cDate[0], cDate.slice(1)));
+      } else {
+        items.push([`${cDate[0]} `, ...cDate.slice(1)]);
+      }
+    }
+    if (badge) {
+      const cBadge = colorized(badge);
+      if (isNotBrowser) {
+        items.push(format(cBadge[0], cBadge.slice(1)));
+      } else {
+        items.push([`${cBadge[0]} `, ...cBadge.slice(1)]);
+      }
+    } else {
+      const longestBadge = getLongestBadge(this.loggerTypes);
+      if (longestBadge.length > 0) {
+        const cBadgePlaceholder = grey(".".repeat(longestBadge.length));
+        if (isNotBrowser) {
+          items.push(format(`${cBadgePlaceholder[0]} `, cBadgePlaceholder.slice(1)));
+        } else {
+          items.push([`${cBadgePlaceholder[0]} `, ...cBadgePlaceholder.slice(1)]);
+        }
+      }
+    }
+    const longestLabel = getLongestLabel(this.loggerTypes);
+    let repeatedMessage;
+    if (repeated) {
+      const cRepeated = white(`[${repeated}x]`);
+      repeatedMessage = isNotBrowser ? format(cRepeated[0], cRepeated.slice(1)) : [cRepeated[0], ...cRepeated.slice(1)];
+    }
+    if (label) {
+      const cLabel = colorized(this.#formatLabel(label));
+      if (isNotBrowser) {
+        items.push(format(cLabel[0], cLabel.slice(1)));
+      } else {
+        items.push([cLabel[0], ...cLabel.slice(1)]);
+      }
+      if (repeatedMessage) {
+        items.push(repeatedMessage);
+      }
+      let lengthDiff = longestLabel.length - label.length;
+      if (repeated) {
+        lengthDiff -= String(repeated).length + 3;
+      } else {
+        lengthDiff += 1;
+      }
+      if (lengthDiff > 0) {
+        const cLabelSpacer = grey(".".repeat(lengthDiff));
+        if (isNotBrowser) {
+          items.push(format(cLabelSpacer[0], cLabelSpacer.slice(1)));
+        } else {
+          items.push([` ${cLabelSpacer[0]}`, ...cLabelSpacer.slice(1)]);
+        }
+      }
+    } else {
+      const cSpacer = grey(".".repeat(longestLabel.length + 1));
+      if (isNotBrowser) {
+        items.push(format(cSpacer[0], cSpacer.slice(1)));
+      } else {
+        items.push([cSpacer[0], ...cSpacer.slice(1)]);
+      }
+    }
+    if (Array.isArray(scope) && scope.length > 0) {
+      const cScope = grey(`[${scope.join(" > ")}]`);
+      if (isNotBrowser) {
+        items.push(format(cScope[0], cScope.slice(1)));
+      } else {
+        items.push([cScope[0], ...cScope.slice(1)]);
+      }
+    }
+    if (prefix) {
+      const cPrefix = grey(
+        `${Array.isArray(scope) && scope.length > 0 ? ". " : " "}[${this.styles.underline.prefix ? underline(prefix) : prefix}] `
+      );
+      if (isNotBrowser) {
+        items.push(format(cPrefix[0], cPrefix.slice(1)));
+      } else {
+        items.push([cPrefix[0], ...cPrefix.slice(1)]);
+      }
+    }
+    if (message !== EMPTY_SYMBOL) {
+      items.push(message);
+    }
+    if (context) {
+      items.push(...context);
+    }
+    if (error) {
+      items.push(error, "\n\n");
+    }
+    if (suffix) {
+      const cSuffix = grey(this.styles.underline.suffix ? underline(suffix) : suffix);
+      if (isNotBrowser) {
+        items.push(format(`
+${cSuffix[0]}`, cSuffix.slice(1)));
+      } else {
+        items.push([`
+${cSuffix[0]}`, ...cSuffix.slice(1)]);
+      }
+    }
+    if (isNotBrowser) {
+      consoleLogFunction(...items);
+    } else {
+      let logMessage = "";
+      const css = [];
+      const arguments_ = [];
+      for (const value of items) {
+        if (Array.isArray(value) && value.length > 1 && value[0].includes("%c")) {
+          logMessage += value[0];
+          css.push(...value.slice(1));
+        } else {
+          arguments_.push(value);
+        }
+      }
+      consoleLogFunction(`${logMessage}%c`, ...css, "", ...arguments_);
+    }
+  }
+  /**
+   * Formats a label according to styling options.
+   * @param label The label to format
+   * @returns The formatted label string
+   * @private
+   */
+  #formatLabel(label) {
+    let formattedLabel = this.styles.uppercase.label ? label.toUpperCase() : label;
+    formattedLabel = this.styles.underline.label ? underline(formattedLabel) : formattedLabel;
+    if (this.styles.bold.label) {
+      formattedLabel = bold(formattedLabel);
+    }
+    return formattedLabel;
+  }
+}
+
+export { PrettyReporter as default };

package/dist/packem_shared/{abstract-json-reporter-wUti0B3k.d.ts → abstract-json-reporter-DiyVyU0j.d.ts}

@@ -1,6 +1,6 @@
 import { s as stringify } from './index.d-oxZvg_y7.js';
 import { LiteralUnion } from 'type-fest';
-import { g as StringifyAwareReporter, h as ReadonlyMeta, E as ExtendedRfc5424LogLevels } from './types-RidvA4RN.js';
+import { f as StringifyAwareReporter, e as ReadonlyMeta, E as ExtendedRfc5424LogLevels } from './types-D3ycu8-x.js';
 
 type AbstractJsonReporterOptions = {
     error: Partial<{
@@ -18,5 +18,5 @@ declare abstract class AbstractJsonReporter<L extends string = string> implement
     protected abstract _log(message: string, logLevel: LiteralUnion<ExtendedRfc5424LogLevels, L>): void;
 }
 
-export { AbstractJsonReporter as a };
-export type { AbstractJsonReporterOptions as A };
+export { AbstractJsonReporter as A };
+export type { AbstractJsonReporterOptions as a };

package/dist/packem_shared/{abstract-pretty-reporter-MOYolfGR.d.ts → abstract-pretty-reporter-BbOWXMCs.d.ts}

@@ -1,5 +1,5 @@
 import { LiteralUnion } from 'type-fest';
-import { c as LoggerTypesAwareReporter, d as LoggerTypesConfig, a as DefaultLogTypes, h as ReadonlyMeta } from './types-RidvA4RN.js';
+import { c as LoggerTypesAwareReporter, d as LoggerTypesConfig, a as DefaultLogTypes, e as ReadonlyMeta } from './types-D3ycu8-x.js';
 
 declare abstract class AbstractPrettyReporter<T extends string = string, L extends string = string> implements LoggerTypesAwareReporter<T, L> {
     protected readonly styles: PrettyStyleOptions;

package/dist/packem_shared/abstract-pretty-reporter-DMPDCslJ.js

@@ -0,0 +1,50 @@
+import { L as LOG_TYPES } from './constants-DfDr4MHC.js';
+
+const getLongestBadge = (types) => {
+  const badges = Object.keys(types).map((x) => types[x].badge ?? "");
+  if (badges.length === 0) {
+    return "";
+  }
+  return badges.reduce((x, y) => x.length > y.length ? x : y);
+};
+
+const dateFormatter = (date) => [date.getHours(), date.getMinutes(), date.getSeconds()].map((n) => String(n).padStart(2, "0")).join(":");
+class AbstractPrettyReporter {
+  /** Styling options for pretty formatting */
+  styles;
+  /** Logger type configurations for styling */
+  loggerTypes;
+  /**
+   * Creates a new AbstractPrettyReporter instance.
+   * @param options Styling options for pretty formatting
+   * @protected
+   */
+  constructor(options) {
+    this.styles = {
+      bold: {
+        label: false
+      },
+      dateFormatter,
+      underline: {
+        label: false,
+        message: false,
+        prefix: false,
+        suffix: false
+      },
+      uppercase: {
+        label: false
+      },
+      ...options
+    };
+    this.loggerTypes = LOG_TYPES;
+  }
+  /**
+   * Sets the logger types configuration for styling.
+   * @param types Logger type configurations with colors and labels
+   */
+  setLoggerTypes(types) {
+    this.loggerTypes = types;
+  }
+}
+
+export { AbstractPrettyReporter as A, getLongestBadge as g };

package/dist/packem_shared/constants-DfDr4MHC.js

@@ -0,0 +1,119 @@
+const EXTENDED_RFC_5424_LOG_LEVELS = {
+  alert: 7,
+  // Action must be taken immediately. Example: Entire website down, database unavailable, etc. This should trigger the SMS alerts and wake you up.
+  critical: 6,
+  // Critical conditions. Example: Application component unavailable, unexpected exception.
+  debug: 1,
+  // Detailed debug information.
+  emergency: 8,
+  // Emergency: system is unusable.
+  error: 5,
+  // Runtime errors that do not require immediate action but should typically be logged and monitored.
+  informational: 2,
+  // Interesting events. Examples: User logs in, SQL logs.
+  notice: 3,
+  // Normal but significant events.
+  trace: 2,
+  // Trace information.
+  warning: 4
+  // Exceptional occurrences that are not errors. Examples: Use of deprecated APIs, poor use of an API, undesirable things that are not necessarily wrong.
+};
+const LOG_TYPES = {
+  alert: {
+    color: "red",
+    label: "alert",
+    logLevel: "alert"
+  },
+  await: {
+    color: "blue",
+    label: "awaiting",
+    logLevel: "informational"
+  },
+  complete: {
+    color: "cyan",
+    label: "complete",
+    logLevel: "informational"
+  },
+  critical: {
+    color: "redBright",
+    label: "critical",
+    logLevel: "critical"
+  },
+  debug: {
+    color: "gray",
+    label: "debug",
+    logLevel: "debug"
+  },
+  emergency: {
+    color: "redBright",
+    label: "emergency",
+    logLevel: "emergency"
+  },
+  error: {
+    color: "red",
+    label: "error",
+    logLevel: "error"
+  },
+  info: {
+    color: "blueBright",
+    label: "info",
+    logLevel: "informational"
+  },
+  log: {
+    label: "",
+    logLevel: "informational"
+  },
+  notice: {
+    color: "magentaBright",
+    label: "notice",
+    logLevel: "notice"
+  },
+  pending: {
+    color: "magenta",
+    label: "pending",
+    logLevel: "informational"
+  },
+  start: {
+    color: "greenBright",
+    label: "start",
+    logLevel: "informational"
+  },
+  stop: {
+    color: "red",
+    label: "stop",
+    logLevel: "informational"
+  },
+  success: {
+    color: "green",
+    label: "success",
+    logLevel: "informational"
+  },
+  trace: {
+    color: "cyanBright",
+    label: "trace",
+    logLevel: "trace"
+  },
+  wait: {
+    color: "blue",
+    label: "waiting",
+    logLevel: "informational"
+  },
+  warn: {
+    color: "yellow",
+    label: "warning",
+    logLevel: "warning"
+  },
+  warning: {
+    color: "yellow",
+    label: "warning",
+    logLevel: "warning"
+  },
+  watch: {
+    color: "yellowBright",
+    label: "watching",
+    logLevel: "informational"
+  }
+};
+const EMPTY_SYMBOL = Symbol("EMPTY");
+
+export { EMPTY_SYMBOL as E, LOG_TYPES as L, EXTENDED_RFC_5424_LOG_LEVELS as a };