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

package/dist/packem_shared/AbstractJsonReporter-nOj0Ft1F.js

@@ -0,0 +1,284 @@
+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: false,
+      value: void 0,
+      writable: true
+    },
+    code: {
+      enumerable: true,
+      value: void 0,
+      writable: true
+    },
+    errors: {
+      enumerable: false,
+      value: void 0,
+      writable: true
+    },
+    message: {
+      enumerable: false,
+      value: void 0,
+      writable: true
+    },
+    name: {
+      enumerable: false,
+      value: void 0,
+      writable: true
+    },
+    stack: {
+      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" && "pipe" in value && typeof value.pipe === "function") {
+    return "[object Stream]";
+  }
+  if (value instanceof Error) {
+    if (seen.has(value)) {
+      return "[Circular]";
+    }
+    depth += 1;
+    return _serialize(value, options, seen, depth);
+  }
+  if (options.useToJSON && value !== null && typeof value === "object" && "toJSON" in value && typeof value.toJSON === "function") {
+    return value.toJSON();
+  }
+  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)) {
+    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);
+    }
+    return plainObject;
+  }
+  try {
+    return value;
+  } catch {
+    return "[Not Available]";
+  }
+};
+const _serialize = (error, options, seen, depth) => {
+  seen.add(error);
+  if (options.maxDepth === 0) {
+    return {};
+  }
+  if (options.useToJSON && typeof error.toJSON === "function" && !toJsonWasCalled.has(error)) {
+    return toJSON(error);
+  }
+  const protoError = Object.create(ErrorProto);
+  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.has(aggregateError)) {
+        Object.defineProperty(protoError, "errors", {
+          configurable: true,
+          enumerable: true,
+          value: [],
+          writable: true
+        });
+        return protoError;
+      }
+      aggregateErrors.push(_serialize(aggregateError, options, seen, depth));
+    }
+    Object.defineProperty(protoError, "errors", {
+      configurable: true,
+      enumerable: true,
+      value: aggregateErrors,
+      writable: true
+    });
+  }
+  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 (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) {
+      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
+  },
+  /* @__PURE__ */ new Set(),
+  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
+   */
+  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 ?? ""}:${String(file.line)}${file.column ? `:${String(file.column)}` : ""}`;
+    }
+    rest.message = message === EMPTY_SYMBOL ? void 0 : message;
+    if (error) {
+      rest.error = serialize(error, this.errorOptions);
+    }
+    if (context) {
+      const newContext = [];
+      for (let i = 0; i < context.length; i += 1) {
+        const item = context[i];
+        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/{JsonReporter-BRw4skd5.js → JsonReporter-CCmj7oYL.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-BO8Calb4.js';
+import { w as writeConsoleLogBasedOnLevel } from './write-console-log-based-on-level-ree2lDPw.js';
 
 class JsonReporter extends AbstractJsonReporter {
   /**

package/dist/packem_shared/{JsonReporter-VzgyLEYz.js → JsonReporter-Ck2PIAEw.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-MDqyXmc_.js';
+import { AbstractJsonReporter } from './AbstractJsonReporter-nOj0Ft1F.js';
 
 class JsonReporter extends AbstractJsonReporter {
   /** Standard output stream */