@visulima/pail 4.0.0-alpha.1 → 4.0.0-alpha.10

package/dist/packem_shared/{AbstractJsonReporter-BaZ33PlE.js → AbstractJsonReporter-DlugSJpY.js}

@@ -12,7 +12,7 @@ const ErrorProto = Object.create(
   {},
   {
     cause: {
-      enumerable: true,
+      enumerable: false,
       value: void 0,
       writable: true
     },
@@ -22,62 +22,89 @@ const ErrorProto = Object.create(
       writable: true
     },
     errors: {
-      enumerable: true,
+      enumerable: false,
       value: void 0,
       writable: true
     },
     message: {
-      enumerable: true,
+      enumerable: false,
       value: void 0,
       writable: true
     },
     name: {
-      enumerable: true,
+      enumerable: false,
       value: void 0,
       writable: true
     },
     stack: {
-      enumerable: true,
+      enumerable: false,
       value: void 0,
       writable: true
     }
   }
 );
 const toJsonWasCalled = /* @__PURE__ */ new WeakSet();
+const makePropertiesEnumerable = (object) => {
+  const props = Object.getOwnPropertyNames(object);
+  for (const prop of props) {
+    const descriptor = Object.getOwnPropertyDescriptor(object, prop);
+    if (descriptor) {
+      if (!descriptor.enumerable) {
+        Object.defineProperty(object, prop, {
+          ...descriptor,
+          enumerable: true
+        });
+      }
+      if (descriptor.value && typeof descriptor.value === "object" && !Array.isArray(descriptor.value) && (Object.getPrototypeOf(descriptor.value) === Object.prototype || Object.getPrototypeOf(descriptor.value) === null)) {
+        makePropertiesEnumerable(descriptor.value);
+      }
+    }
+  }
+};
 const toJSON = (from) => {
   toJsonWasCalled.add(from);
   const json = from.toJSON();
   toJsonWasCalled.delete(from);
+  if (
+    // Only make properties enumerable if the object is extensible
+    // Non-extensible objects (like when toJSON returns 'this') should preserve original enumerability
+    Object.isExtensible(json)
+  ) {
+    makePropertiesEnumerable(json);
+  }
   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") {
+  if (value !== null && typeof value === "object" && "pipe" in value && typeof value.pipe === "function") {
     return "[object Stream]";
   }
   if (value instanceof Error) {
-    if (seen.includes(value)) {
+    if (seen.has(value)) {
       return "[Circular]";
     }
     depth += 1;
     return _serialize(value, options, seen, depth);
   }
-  if (options.useToJSON && typeof value.toJSON === "function") {
+  if (options.useToJSON && value !== null && typeof value === "object" && "toJSON" in value && typeof value.toJSON === "function") {
     return value.toJSON();
   }
-  if (typeof value === "object" && value instanceof Date) {
+  if (value instanceof Date) {
     return value.toISOString();
   }
   if (typeof value === "function") {
     return `[Function: ${value.name || "anonymous"}]`;
   }
+  if (typeof value === "bigint") {
+    return `${String(value)}n`;
+  }
   if (isPlainObject(value)) {
-    depth += 1;
-    if (options.maxDepth && depth >= options.maxDepth) {
+    if (options.maxDepth !== void 0 && options.maxDepth !== Number.POSITIVE_INFINITY && depth + 1 >= options.maxDepth) {
       return {};
     }
+    depth += 1;
     const plainObject = {};
     for (const key in value) {
       plainObject[key] = serializeValue(value[key], seen, depth, options);
@@ -91,7 +118,7 @@ const serializeValue = (value, seen, depth, options) => {
   }
 };
 const _serialize = (error, options, seen, depth) => {
-  seen.push(error);
+  seen.add(error);
   if (options.maxDepth === 0) {
     return {};
   }
@@ -99,31 +126,88 @@ const _serialize = (error, options, seen, depth) => {
     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;
+  Object.defineProperty(protoError, "name", {
+    configurable: true,
+    enumerable: true,
+    value: Object.prototype.toString.call(error.constructor) === "[object Function]" ? error.constructor.name : error.name,
+    writable: true
+  });
+  Object.defineProperty(protoError, "message", {
+    configurable: true,
+    enumerable: true,
+    value: error.message,
+    writable: true
+  });
+  Object.defineProperty(protoError, "stack", {
+    configurable: true,
+    enumerable: true,
+    value: error.stack,
+    writable: true
+  });
   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 = [];
+      if (seen.has(aggregateError)) {
+        Object.defineProperty(protoError, "errors", {
+          configurable: true,
+          enumerable: true,
+          value: [],
+          writable: true
+        });
         return protoError;
       }
       aggregateErrors.push(_serialize(aggregateError, options, seen, depth));
     }
-    protoError.errors = aggregateErrors;
+    Object.defineProperty(protoError, "errors", {
+      configurable: true,
+      enumerable: true,
+      value: aggregateErrors,
+      writable: true
+    });
   }
-  if (error.cause instanceof Error && !seen.includes(error.cause)) {
-    protoError.cause = _serialize(error.cause, options, seen, depth);
+  const causeValue = error.cause;
+  if (causeValue !== void 0 && causeValue !== null) {
+    if (causeValue instanceof Error) {
+      if (seen.has(causeValue)) {
+        Object.defineProperty(protoError, "cause", {
+          configurable: true,
+          enumerable: true,
+          value: "[Circular]",
+          writable: true
+        });
+      } else {
+        Object.defineProperty(protoError, "cause", {
+          configurable: true,
+          enumerable: true,
+          value: _serialize(causeValue, options, seen, depth),
+          writable: true
+        });
+      }
+    } else {
+      const serializedCause = serializeValue(causeValue, seen, depth, options);
+      Object.defineProperty(protoError, "cause", {
+        configurable: true,
+        enumerable: true,
+        value: serializedCause,
+        writable: true
+      });
+    }
   }
   for (const key in error) {
-    if (protoError[key] === void 0) {
-      const value = error[key];
-      protoError[key] = serializeValue(value, seen, depth, options);
+    if (key === "name" || key === "message" || key === "stack" || key === "cause" || key === "errors") {
+      continue;
     }
+    const value = error[key];
+    const serializedValue = serializeValue(value, seen, depth, options);
+    Object.defineProperty(protoError, key, {
+      configurable: true,
+      enumerable: true,
+      value: serializedValue,
+      writable: true
+    });
   }
   if (Array.isArray(options.exclude) && options.exclude.length > 0) {
     for (const key of options.exclude) {
@@ -142,7 +226,7 @@ const serialize = (error, options = {}) => _serialize(
     maxDepth: options.maxDepth ?? Number.POSITIVE_INFINITY,
     useToJSON: options.useToJSON ?? false
   },
-  [],
+  /* @__PURE__ */ new Set(),
   0
 );
 
@@ -162,7 +246,6 @@ class AbstractJsonReporter {
    * 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_;
   }
@@ -173,7 +256,7 @@ class AbstractJsonReporter {
       rest.label = rest.label.trim();
     }
     if (file) {
-      rest.file = `${file.name}:${file.line}${file.column ? `:${file.column}` : ""}`;
+      rest.file = `${file.name ?? ""}:${String(file.line)}${file.column ? `:${String(file.column)}` : ""}`;
     }
     if (message === EMPTY_SYMBOL) {
       rest.message = void 0;
@@ -185,7 +268,8 @@ class AbstractJsonReporter {
     }
     if (context) {
       const newContext = [];
-      for (const item of context) {
+      for (let i = 0; i < context.length; i += 1) {
+        const item = context[i];
         if (item === EMPTY_SYMBOL) {
           continue;
         }

package/dist/packem_shared/{InteractiveManager-CZ85hGNW.js → InteractiveManager-CowYA3Hx.js}

@@ -1,4 +1,4 @@
-import { t as terminalSize, w as wordWrap, W as WrapMode } from './index-DqKWykfa.js';
+import { t as terminalSize, w as wordWrap, W as WrapMode } from './index-BEfVUy9P.js';
 
 class InteractiveManager {
   #stream;
@@ -64,9 +64,6 @@ class InteractiveManager {
    * @throws {TypeError} If the specified stream is not available
    */
   erase(stream, count = this.#lastLength) {
-    if (this.#stream[stream] === void 0) {
-      throw new TypeError(`Stream "${stream}" is not available`);
-    }
     this.#stream[stream].erase(count);
   }
   /**
@@ -75,7 +72,10 @@ class InteractiveManager {
    */
   hook() {
     if (!this.#isActive) {
-      Object.values(this.#stream).forEach((hook) => hook.active());
+      const hooks = Object.values(this.#stream);
+      for (let i = 0; i < hooks.length; i += 1) {
+        hooks[i].active();
+      }
       this.#clear(true);
     }
     return this.#isActive;
@@ -92,7 +92,10 @@ class InteractiveManager {
         this.erase(stream, eraseRowCount);
       }
       this.#lastLength = 0;
-      Object.values(this.#stream).forEach((hook) => hook.active());
+      const hooks = Object.values(this.#stream);
+      for (let i = 0; i < hooks.length; i += 1) {
+        hooks[i].active();
+      }
     }
   }
   /**
@@ -106,7 +109,10 @@ class InteractiveManager {
       if (erase) {
         this.erase(stream);
       }
-      Object.values(this.#stream).forEach((hook) => hook.renew());
+      const hooks = Object.values(this.#stream);
+      for (let i = 0; i < hooks.length; i += 1) {
+        hooks[i].renew();
+      }
     }
   }
   /**
@@ -116,7 +122,10 @@ class InteractiveManager {
    */
   unhook(separateHistory = true) {
     if (this.#isActive) {
-      Object.values(this.#stream).forEach((hook) => hook.inactive(separateHistory));
+      const hooks = Object.values(this.#stream);
+      for (let i = 0; i < hooks.length; i += 1) {
+        hooks[i].inactive(separateHistory);
+      }
       this.#clear();
     }
     return !this.#isActive;
@@ -129,9 +138,6 @@ class InteractiveManager {
    */
   update(stream, rows, from = 0) {
     if (rows.length > 0) {
-      if (this.#stream[stream] === void 0) {
-        throw new TypeError(`Stream "${stream}" is not available`);
-      }
       const hook = this.#stream[stream];
       const { columns: width, rows: height } = terminalSize();
       const position = from > height ? height - 1 : Math.max(0, Math.min(height - 1, from));

package/dist/packem_shared/{interactive-stream-hook-DG4BtN12.js → InteractiveStreamHook-BypRlYTX.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 cursorUp = (count = 1) => `${ESC}${String(count)}A`;
 const cursorHide = `${ESC}?25l`;
 const cursorShow = `${ESC}?25h`;
 const eraseLines = (count) => {
@@ -58,7 +50,7 @@ class InteractiveStreamHook {
    * @param stream The Node.js WriteStream to hook into (usually stdout or stderr)
    */
   constructor(stream) {
-    this.#method = stream.write;
+    this.#method = stream.write.bind(stream);
     this.#stream = stream;
   }
   /**
@@ -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-BgPvIyC2.js}

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

package/dist/packem_shared/{JsonReporter-BRw4skd5.js → JsonReporter-Dbw82ewj.js}

@@ -1,5 +1,5 @@
-import { AbstractJsonReporter } from './AbstractJsonReporter-BaZ33PlE.js';
-import { w as writeConsoleLogBasedOnLevel } from './write-console-log-based-on-level-DBmRYXpj.js';
+import { AbstractJsonReporter } from './AbstractJsonReporter-DlugSJpY.js';
+import { w as writeConsoleLogBasedOnLevel } from './write-console-log-based-on-level-ree2lDPw.js';
 
 class JsonReporter extends AbstractJsonReporter {
   /**

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

@@ -1,9 +1,54 @@
 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 { w as writeConsoleLogBasedOnLevel } from './write-console-log-based-on-level-DBmRYXpj.js';
+import { f as format, g as getLongestLabel } from './index-Bx3-C0j9.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-ree2lDPw.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 {
   /**
@@ -19,7 +64,7 @@ class PrettyReporter extends AbstractPrettyReporter {
       ...options
     });
   }
-  // eslint-disable-next-line sonarjs/cognitive-complexity
+  // eslint-disable-next-line sonarjs/cognitive-complexity -- browser colorize returns arrays where spread is intentional
   log(meta) {
     const isNotBrowser = typeof globalThis.window !== "undefined" && typeof globalThis.document !== "undefined";
     const consoleLogFunction = writeConsoleLogBasedOnLevel(meta.type.level);
@@ -139,9 +184,10 @@ ${cSuffix[0]}`, ...cSuffix.slice(1)]);
       let logMessage = "";
       const css = [];
       const arguments_ = [];
-      for (const value of items) {
+      for (let i = 0; i < items.length; i += 1) {
+        const value = items[i];
         if (Array.isArray(value) && value.length > 1 && value[0].includes("%c")) {
-          logMessage += value[0];
+          logMessage += String(value[0]);
           css.push(...value.slice(1));
         } else {
           arguments_.push(value);