@visulima/pail 3.1.0 → 3.2.0

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-CPsNkpz8.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 { e as StringifyAwareReporter, f as ReadonlyMeta, E as ExtendedRfc5424LogLevels } from './types-DVzG8TWL.js';
+import { f as StringifyAwareReporter, e as ReadonlyMeta, E as ExtendedRfc5424LogLevels } from './types-D3ycu8-x.js';
 
 type AbstractJsonReporterOptions = {
     error: Partial<{

package/dist/packem_shared/{abstract-pretty-reporter-DB2G-qlI.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, f as ReadonlyMeta } from './types-DVzG8TWL.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 };