@visulima/pail 4.0.0-alpha.4 → 4.0.0-alpha.5

package/dist/interactive/index.js

@@ -1,2 +1,2 @@
 export { default as InteractiveManager } from '../packem_shared/InteractiveManager-CbE7d1kY.js';
-export { I as InteractiveStreamHook } from '../packem_shared/interactive-stream-hook-DG4BtN12.js';
+export { default as InteractiveStreamHook } from '../packem_shared/InteractiveStreamHook-ePIURL_U.js';

package/dist/packem_shared/AbstractJsonReporter-DWRpTtGw.js

@@ -0,0 +1,204 @@
+import { E as EMPTY_SYMBOL } from './constants-B1RjD_ps.js';
+
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
+}
+
+const ErrorProto = Object.create(
+  {},
+  {
+    cause: {
+      enumerable: true,
+      value: void 0,
+      writable: true
+    },
+    code: {
+      enumerable: true,
+      value: void 0,
+      writable: true
+    },
+    errors: {
+      enumerable: true,
+      value: void 0,
+      writable: true
+    },
+    message: {
+      enumerable: true,
+      value: void 0,
+      writable: true
+    },
+    name: {
+      enumerable: true,
+      value: void 0,
+      writable: true
+    },
+    stack: {
+      enumerable: true,
+      value: void 0,
+      writable: true
+    }
+  }
+);
+const toJsonWasCalled = /* @__PURE__ */ new WeakSet();
+const toJSON = (from) => {
+  toJsonWasCalled.add(from);
+  const json = from.toJSON();
+  toJsonWasCalled.delete(from);
+  return json;
+};
+const serializeValue = (value, seen, depth, options) => {
+  if (value && value instanceof Uint8Array && value.constructor.name === "Buffer") {
+    return "[object Buffer]";
+  }
+  if (value !== null && typeof value === "object" && typeof value.pipe === "function") {
+    return "[object Stream]";
+  }
+  if (value instanceof Error) {
+    if (seen.includes(value)) {
+      return "[Circular]";
+    }
+    depth += 1;
+    return _serialize(value, options, seen, depth);
+  }
+  if (options.useToJSON && typeof value.toJSON === "function") {
+    return value.toJSON();
+  }
+  if (typeof value === "object" && value instanceof Date) {
+    return value.toISOString();
+  }
+  if (typeof value === "function") {
+    return `[Function: ${value.name || "anonymous"}]`;
+  }
+  if (isPlainObject(value)) {
+    depth += 1;
+    if (options.maxDepth && depth >= options.maxDepth) {
+      return {};
+    }
+    const plainObject = {};
+    for (const key in value) {
+      plainObject[key] = serializeValue(value[key], seen, depth, options);
+    }
+    return plainObject;
+  }
+  try {
+    return value;
+  } catch {
+    return "[Not Available]";
+  }
+};
+const _serialize = (error, options, seen, depth) => {
+  seen.push(error);
+  if (options.maxDepth === 0) {
+    return {};
+  }
+  if (options.useToJSON && typeof error.toJSON === "function" && !toJsonWasCalled.has(error)) {
+    return toJSON(error);
+  }
+  const protoError = Object.create(ErrorProto);
+  protoError.name = Object.prototype.toString.call(error.constructor) === "[object Function]" ? error.constructor.name : error.name;
+  protoError.message = error.message;
+  protoError.stack = error.stack;
+  if (Array.isArray(error.errors)) {
+    const aggregateErrors = [];
+    for (const aggregateError of error.errors) {
+      if (!(aggregateError instanceof Error)) {
+        throw new TypeError("All errors in the 'errors' property must be instances of Error");
+      }
+      if (seen.includes(aggregateError)) {
+        protoError.errors = [];
+        return protoError;
+      }
+      aggregateErrors.push(_serialize(aggregateError, options, seen, depth));
+    }
+    protoError.errors = aggregateErrors;
+  }
+  if (error.cause instanceof Error && !seen.includes(error.cause)) {
+    protoError.cause = _serialize(error.cause, options, seen, depth);
+  }
+  for (const key in error) {
+    if (protoError[key] === void 0) {
+      const value = error[key];
+      protoError[key] = serializeValue(value, seen, depth, options);
+    }
+  }
+  if (Array.isArray(options.exclude) && options.exclude.length > 0) {
+    for (const key of options.exclude) {
+      try {
+        delete protoError[key];
+      } catch {
+      }
+    }
+  }
+  return protoError;
+};
+const serialize = (error, options = {}) => _serialize(
+  error,
+  {
+    exclude: options.exclude ?? [],
+    maxDepth: options.maxDepth ?? Number.POSITIVE_INFINITY,
+    useToJSON: options.useToJSON ?? false
+  },
+  [],
+  0
+);
+
+class AbstractJsonReporter {
+  /** Custom stringify function for object serialization */
+  stringify;
+  /** Error serialization options */
+  errorOptions;
+  /**
+   * Creates a new AbstractJsonReporter instance.
+   * @param options Configuration options for JSON formatting and error handling
+   */
+  constructor(options = {}) {
+    this.errorOptions = options.error ?? {};
+  }
+  /**
+   * Sets a custom stringify function for object serialization.
+   * @param function_ The stringify function to use for serialization
+   */
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+  setStringify(function_) {
+    this.stringify = function_;
+  }
+  // eslint-disable-next-line sonarjs/cognitive-complexity
+  log(meta) {
+    const { context, error, file, message, type, ...rest } = meta;
+    if (rest.label) {
+      rest.label = rest.label.trim();
+    }
+    if (file) {
+      rest.file = `${file.name}:${file.line}${file.column ? `:${file.column}` : ""}`;
+    }
+    if (message === EMPTY_SYMBOL) {
+      rest.message = void 0;
+    } else {
+      rest.message = message;
+    }
+    if (error) {
+      rest.error = serialize(error, this.errorOptions);
+    }
+    if (context) {
+      const newContext = [];
+      for (const item of context) {
+        if (item === EMPTY_SYMBOL) {
+          continue;
+        }
+        if (item instanceof Error) {
+          newContext.push(serialize(item, this.errorOptions));
+        } else {
+          newContext.push(item);
+        }
+      }
+      rest.context = newContext;
+    }
+    this._log(this.stringify(rest), type.level);
+  }
+}
+
+export { AbstractJsonReporter };

package/dist/packem_shared/{interactive-stream-hook-DG4BtN12.js → InteractiveStreamHook-ePIURL_U.js}

@@ -22,17 +22,9 @@ const {
 } = __cjs_getBuiltinModule("node:string_decoder");
 
 const ESC = "\x1B[";
-const eraseScreen = `${ESC}2J`;
 const eraseLine = `${ESC}2K`;
 const cursorLeft = `${ESC}G`;
 const cursorUp = (count = 1) => `${ESC + count}A`;
-const clearTerminal = process.platform === "win32" ? `${eraseScreen}${ESC}0f` : (
-  // 1. Erases the screen (Only done in case `2` is not supported)
-  // 2. Erases the whole screen including scrollback buffer
-  // 3. Moves cursor to the top-left position
-  // More info: https://www.real-world-systems.com/docs/ANSIcode.html
-  `${eraseScreen}${ESC}3J${ESC}H`
-);
 const cursorHide = `${ESC}?25l`;
 const cursorShow = `${ESC}?25h`;
 const eraseLines = (count) => {
@@ -138,4 +130,4 @@ class InteractiveStreamHook {
   }
 }
 
-export { InteractiveStreamHook as I, clearTerminal as c };
+export { InteractiveStreamHook as default };

package/dist/packem_shared/{JsonReporter-VzgyLEYz.js → JsonReporter-BV5lMnJX.js}

@@ -9,7 +9,7 @@ const {
   stderr
 } = __cjs_getProcess;
 import { w as writeStream } from './write-stream-BG8fhcs3.js';
-import { AbstractJsonReporter } from './AbstractJsonReporter-BaZ33PlE.js';
+import { AbstractJsonReporter } from './AbstractJsonReporter-DWRpTtGw.js';
 
 class JsonReporter extends AbstractJsonReporter {
   /** Standard output stream */

package/dist/packem_shared/{PrettyReporter-DySIXBjQ.js → PrettyReporter-BYL3NrdA.js}

@@ -1,10 +1,55 @@
 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-omsTHUWB.js';
-import { A as AbstractPrettyReporter, g as getLongestBadge } from './abstract-pretty-reporter-Di_sdm2r.js';
-import { g as getLongestLabel } from './get-longest-label-C9PWeyKq.js';
+import { f as format, g as getLongestLabel } from './index-DnkF86LQ.js';
+import { L as LOG_TYPES, E as EMPTY_SYMBOL } from './constants-omsTHUWB.js';
 import { w as writeConsoleLogBasedOnLevel } from './write-console-log-based-on-level-DBmRYXpj.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;
+  }
+}
+
 class PrettyReporter extends AbstractPrettyReporter {
   /**
    * Creates a new Browser Pretty Reporter instance.

package/dist/packem_shared/{format-label-De49vNPd.js → PrettyReporter-DLQtmATi.js}

@@ -17,10 +17,17 @@ const __cjs_getBuiltinModule = (module) => {
     return __cjs_require(module);
 };
 
+const {
+  stdout,
+  stderr
+} = __cjs_getProcess;
+import colorize, { grey, green, cyan, red, yellow, bold, magenta, underline, greenBright, white, bgGrey } from '@visulima/colorize';
+import { t as terminalSize, g as getStringWidth, w as wordWrap, W as WrapMode } from './index-EZ_WSQZS.js';
+import { L as LOG_TYPES, E as EMPTY_SYMBOL } from './constants-B1RjD_ps.js';
+import { w as writeStream } from './write-stream-BG8fhcs3.js';
 const {
   createRequire
 } = __cjs_getBuiltinModule("node:module");
-import { grey, green, cyan, red, yellow, bold, magenta, underline } from '@visulima/colorize';
 
 const normalizeLF = (code) => code.replaceAll(/\r\n|\r(?!\n)|\n/gu, "\n");
 const _process = globalThis.process || /* @__PURE__ */ Object.create(null);
@@ -1158,6 +1165,22 @@ const inspect = (value, options_ = {}) => {
   return internalInspect(value, options, 0, []);
 };
 
+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 getLongestLabel = (types) => {
+  const labels = Object.keys(types).map((x) => types[x].label ?? "");
+  if (labels.length === 0) {
+    return "";
+  }
+  return labels.reduce((x, y) => x.length > y.length ? x : y);
+};
+
 const defaultInspectorConfig = {
   indent: 2,
   quoteStyle: "single",
@@ -1190,4 +1213,246 @@ const formatLabel = (label, styles) => {
   return formattedLabel;
 };
 
-export { defaultInspectorConfig as d, formatLabel as f, inspect as i, renderError as r };
+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;
+  }
+}
+
+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 };