@visulima/pail 2.1.16 → 2.1.18

package/dist/packem_shared/JsonFileReporter-CdHau53i.mjs

@@ -0,0 +1,133 @@
+import { A as AbstractJsonReporter } from './abstract-json-reporter-CG0EXqip.mjs';
+
+import __cjs_mod__ from "node:module"; // -- packem CommonJS require shim --
+const require = __cjs_mod__.createRequire(import.meta.url);
+var __defProp$2 = Object.defineProperty;
+var __name$2 = (target, value) => __defProp$2(target, "name", { value, configurable: true });
+class SafeStreamHandler {
+  static {
+    __name$2(this, "SafeStreamHandler");
+  }
+  #ready = true;
+  #stream;
+  #name;
+  constructor(stream, name) {
+    this.#stream = stream;
+    this.#name = name;
+  }
+  /**
+   * Writes `message` to the instance's internal stream
+   * @param message Message to write
+   */
+  write(message) {
+    this.writeStream(message);
+  }
+  /**
+   * Calls `end` on this instance's internal stream
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  end(...arguments_) {
+    this.#stream.end(...arguments_);
+  }
+  get isReady() {
+    return this.#ready;
+  }
+  writeStream(message) {
+    if (!this.#ready) {
+      console.warn("Stream busy: " + this.#name + '. Write will be dropped: "' + message + '"');
+      return;
+    }
+    this.#ready = false;
+    this.#stream.on("error", (error) => {
+      throw error;
+    });
+    this.#stream.on("drain", () => {
+      this.#ready = true;
+    });
+    this.#stream.on("finish", () => {
+      this.#ready = true;
+    });
+    this.#ready = this.#stream.write(message, () => {
+    });
+  }
+}
+
+var __defProp$1 = Object.defineProperty;
+var __name$1 = (target, value) => __defProp$1(target, "name", { value, configurable: true });
+class RotatingFileStream {
+  static {
+    __name$1(this, "RotatingFileStream");
+  }
+  #filePath;
+  #immediate;
+  #stream;
+  #options;
+  // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+  #createRfsStream;
+  constructor(filePath, writeImmediately = false, options = {}) {
+    this.#filePath = filePath;
+    this.#immediate = writeImmediately;
+    this.#options = options;
+    if (!this.#immediate) {
+      try {
+        this.#createRfsStream = require("rotating-file-stream").createStream;
+      } catch {
+        throw new Error("The 'rotating-file-stream' package is missing. Make sure to install the 'rotating-file-stream' package.");
+      }
+      this.#stream = this.#createRfsStream(this.#filePath, options);
+    }
+  }
+  /**
+   * Writes `message` to the instance's internal #stream
+   * @param message Message to write
+   */
+  write(message) {
+    let fileStream = this.#stream;
+    if (this.#immediate) {
+      fileStream = this.#createRfsStream(this.#filePath, this.#options);
+    }
+    const stream = new SafeStreamHandler(fileStream, this.#filePath);
+    stream.write(message);
+    if (this.#immediate) {
+      stream.end();
+    }
+  }
+  /**
+   * Ends the instance's internal #stream
+   *
+   * When `immediate` is not `true`, a call to `write` after calling this method
+   * will throw an error.
+   */
+  end() {
+    if (this.#stream !== undefined) {
+      this.#stream.end();
+    }
+  }
+}
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class JsonFileReporter extends AbstractJsonReporter {
+  static {
+    __name(this, "JsonFileReporter");
+  }
+  stream;
+  constructor(options) {
+    super();
+    const { filePath, writeImmediately = false, ...rfsOptions } = options;
+    this.stream = new RotatingFileStream(filePath, writeImmediately, {
+      compress: "gzip",
+      // compress rotated files
+      interval: "1d",
+      // rotate daily
+      size: "10M",
+      // rotate every 10 MegaBytes written,
+      ...rfsOptions
+    });
+  }
+  _log(message) {
+    this.stream.write(message + "\n");
+  }
+}
+
+export { JsonFileReporter };

package/dist/packem_shared/JsonReporter-C05lFJhj.mjs

@@ -0,0 +1,20 @@
+import { w as writeConsoleLogBasedOnLevel } from './write-console-log-Tptfzg9D.mjs';
+import { A as AbstractJsonReporter } from './abstract-json-reporter-CG0EXqip.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class JsonReporter extends AbstractJsonReporter {
+  static {
+    __name(this, "JsonReporter");
+  }
+  constructor(options = {}) {
+    super(options);
+  }
+  // eslint-disable-next-line class-methods-use-this
+  _log(message, logLevel) {
+    const consoleLogFunction = writeConsoleLogBasedOnLevel(logLevel);
+    consoleLogFunction(message);
+  }
+}
+
+export { JsonReporter as default };

package/dist/packem_shared/JsonReporter-DCd8dbfQ.mjs

@@ -0,0 +1,32 @@
+import { stdout, stderr } from 'node:process';
+import { w as writeStream } from './write-stream-BBAF33Zm.mjs';
+import { A as AbstractJsonReporter } from './abstract-json-reporter-CG0EXqip.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class JsonReporter extends AbstractJsonReporter {
+  static {
+    __name(this, "JsonReporter");
+  }
+  #stdout;
+  #stderr;
+  constructor(options = {}) {
+    super(options);
+    this.#stdout = stdout;
+    this.#stderr = stderr;
+  }
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  setStdout(stdout_) {
+    this.#stdout = stdout_;
+  }
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  setStderr(stderr_) {
+    this.#stderr = stderr_;
+  }
+  _log(message, logLevel) {
+    const stream = ["error", "warn"].includes(logLevel) ? this.#stderr : this.#stdout;
+    writeStream(message + "\n", stream);
+  }
+}
+
+export { JsonReporter as default };

package/dist/packem_shared/JsonReporter-DDubAhfJ.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+const writeConsoleLog = require('./write-console-log-Cu0-IDN-.cjs');
+const abstractJsonReporter = require('./abstract-json-reporter-D4MiU6B-.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class JsonReporter extends abstractJsonReporter.AbstractJsonReporter {
+  static {
+    __name(this, "JsonReporter");
+  }
+  constructor(options = {}) {
+    super(options);
+  }
+  // eslint-disable-next-line class-methods-use-this
+  _log(message, logLevel) {
+    const consoleLogFunction = writeConsoleLog.writeConsoleLogBasedOnLevel(logLevel);
+    consoleLogFunction(message);
+  }
+}
+
+module.exports = JsonReporter;

package/dist/packem_shared/JsonReporter-HXYHZuWz.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+const process = require('node:process');
+const writeStream = require('./write-stream-CkNf2Ju8.cjs');
+const abstractJsonReporter = require('./abstract-json-reporter-D4MiU6B-.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class JsonReporter extends abstractJsonReporter.AbstractJsonReporter {
+  static {
+    __name(this, "JsonReporter");
+  }
+  #stdout;
+  #stderr;
+  constructor(options = {}) {
+    super(options);
+    this.#stdout = process.stdout;
+    this.#stderr = process.stderr;
+  }
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  setStdout(stdout_) {
+    this.#stdout = stdout_;
+  }
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  setStderr(stderr_) {
+    this.#stderr = stderr_;
+  }
+  _log(message, logLevel) {
+    const stream = ["error", "warn"].includes(logLevel) ? this.#stderr : this.#stdout;
+    writeStream.writeStream(message + "\n", stream);
+  }
+}
+
+module.exports = JsonReporter;

package/dist/packem_shared/MessageFormatterProcessor-CFyi7GWt.mjs

@@ -0,0 +1,53 @@
+import { build } from '@visulima/fmt';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class MessageFormatterProcessor {
+  static {
+    __name(this, "MessageFormatterProcessor");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+  #stringify;
+  #formatters;
+  constructor(options = {}) {
+    this.#formatters = options.formatters;
+  }
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+  setStringify(function_) {
+    this.#stringify = function_;
+  }
+  process(meta) {
+    const formatter = build({
+      formatters: this.#formatters,
+      stringify: /* @__PURE__ */ __name((value) => {
+        const stringified = this.#stringify(value);
+        if (stringified === undefined) {
+          console.warn("Unable to stringify value of type " + typeof value, value);
+          return "undefined";
+        }
+        return stringified;
+      }, "stringify")
+    });
+    if (meta.message !== undefined) {
+      meta.message = this._format(formatter, meta.message, meta.context ?? []);
+    }
+    return meta;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  _format(formatter, data, arguments_ = []) {
+    if (typeof data === "string") {
+      return formatter(data, arguments_);
+    }
+    if (typeof data === "object" && data !== null) {
+      for (const index in data) {
+        const value = data[index];
+        if (typeof value === "string" || Array.isArray(value) || typeof value === "object") {
+          data[index] = this._format(formatter, value, arguments_);
+        }
+      }
+    }
+    return data;
+  }
+}
+
+export { MessageFormatterProcessor as default };

package/dist/packem_shared/MessageFormatterProcessor-D_txQ9nO.cjs

@@ -0,0 +1,55 @@
+'use strict';
+
+const fmt = require('@visulima/fmt');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class MessageFormatterProcessor {
+  static {
+    __name(this, "MessageFormatterProcessor");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+  #stringify;
+  #formatters;
+  constructor(options = {}) {
+    this.#formatters = options.formatters;
+  }
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+  setStringify(function_) {
+    this.#stringify = function_;
+  }
+  process(meta) {
+    const formatter = fmt.build({
+      formatters: this.#formatters,
+      stringify: /* @__PURE__ */ __name((value) => {
+        const stringified = this.#stringify(value);
+        if (stringified === undefined) {
+          console.warn("Unable to stringify value of type " + typeof value, value);
+          return "undefined";
+        }
+        return stringified;
+      }, "stringify")
+    });
+    if (meta.message !== undefined) {
+      meta.message = this._format(formatter, meta.message, meta.context ?? []);
+    }
+    return meta;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  _format(formatter, data, arguments_ = []) {
+    if (typeof data === "string") {
+      return formatter(data, arguments_);
+    }
+    if (typeof data === "object" && data !== null) {
+      for (const index in data) {
+        const value = data[index];
+        if (typeof value === "string" || Array.isArray(value) || typeof value === "object") {
+          data[index] = this._format(formatter, value, arguments_);
+        }
+      }
+    }
+    return data;
+  }
+}
+
+module.exports = MessageFormatterProcessor;

package/dist/packem_shared/PrettyReporter-Bx3QLZrW.mjs

@@ -0,0 +1,162 @@
+import colorize, { grey, white, underline, bold } from '@visulima/colorize/browser';
+import { format } from '@visulima/fmt';
+import { E as EMPTY_SYMBOL } from './constants-BYYZ5WNW.mjs';
+import { A as AbstractPrettyReporter, g as getLongestBadge } from './abstract-pretty-reporter-izJgxoMv.mjs';
+import { g as getLongestLabel } from './get-longest-label-CM8kLFWH.mjs';
+import { w as writeConsoleLogBasedOnLevel } from './write-console-log-Tptfzg9D.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class PrettyReporter extends AbstractPrettyReporter {
+  static {
+    __name(this, "PrettyReporter");
+  }
+  constructor(options = {}) {
+    super({
+      uppercase: {
+        label: true,
+        ...options.uppercase
+      },
+      ...options
+    });
+  }
+  // eslint-disable-next-line sonarjs/cognitive-complexity
+  log(meta) {
+    const isNotBrowser = typeof window !== "undefined" && typeof window.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("\n" + cSuffix[0], cSuffix.slice(1)));
+      } else {
+        items.push(["\n" + 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_);
+    }
+  }
+  _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 };