@visulima/pail 4.0.0-alpha.8 → 4.0.0

package/dist/reporter/http/http-reporter.js

@@ -1,13 +1 @@
-import { AbstractHttpReporter } from './abstract-http-reporter.js';
-
-class HttpReporter extends AbstractHttpReporter {
-  /**
-   * Creates a new HTTP Reporter instance.
-   * @param options Configuration options for HTTP reporting
-   */
-  constructor(options) {
-    super(options);
-  }
-}
-
-export { HttpReporter as default };
+import{AbstractHttpReporter as r}from"./abstract-http-reporter.js";class o extends r{constructor(t){super(t)}}export{o as default};

package/dist/reporter/json/index.browser.d.ts

@@ -1,3 +1,98 @@
-export type { AbstractJsonReporterOptions } from "./abstract-json-reporter.d.ts";
-export { AbstractJsonReporter } from "./abstract-json-reporter.d.ts";
-export { default as JsonReporter } from "./json-reporter.d.ts";
+import { s as stringify } from "../../packem_shared/index.d-T71KjNAr.js";
+import { R as ReadonlyMeta, E as ExtendedRfc5424LogLevels, L as LiteralUnion, S as StringifyAwareReporter } from "../../packem_shared/types.d-xxE3FOD3.js";
+import '@visulima/colorize';
+import '@visulima/interactive-manager';
+/**
+* Options for configuring JSON reporters.
+*/
+type AbstractJsonReporterOptions = {
+  /** Error serialization options */
+  error: Partial<{
+    /** Properties to exclude from error serialization */
+    exclude?: string[];
+    /** Maximum depth for error object serialization */
+    maxDepth?: number;
+    /** Whether to use toJSON methods during serialization */
+    useToJSON?: boolean;
+  }>;
+};
+/**
+* Abstract JSON Reporter.
+*
+* Base class for JSON-based reporters that provides common functionality
+* for serializing log metadata to JSON format. Handles error serialization,
+* context processing, and provides a template method for actual output.
+* @template L - The log level type
+* @example
+* ```typescript
+* class CustomJsonReporter extends AbstractJsonReporter {
+*   protected _log(message: string): void {
+*     console.log(message);
+*   }
+* }
+* ```
+*/
+declare abstract class AbstractJsonReporter<L extends string = string> implements StringifyAwareReporter<L> {
+  /** Custom stringify function for object serialization */
+  protected stringify: typeof stringify | undefined;
+  /** Error serialization options */
+  protected errorOptions: AbstractJsonReporterOptions["error"];
+  /**
+  * Creates a new AbstractJsonReporter instance.
+  * @param options Configuration options for JSON formatting and error handling
+  */
+  constructor(options?: Partial<AbstractJsonReporterOptions>);
+  /**
+  * Sets a custom stringify function for object serialization.
+  * @param function_ The stringify function to use for serialization
+  */
+  setStringify(function_: typeof stringify): void;
+  log(meta: ReadonlyMeta<L>): void;
+  /**
+  * Template method for outputting the JSON log message.
+  *
+  * Subclasses must implement this method to define how the JSON message
+  * is actually written (to console, file, network, etc.).
+  * @param message The JSON-formatted log message
+  * @param logLevel The log level of the message
+  * @protected
+  * @abstract
+  */
+  protected abstract _log(message: string, logLevel: LiteralUnion<ExtendedRfc5424LogLevels, L>): void;
+}
+/**
+* Browser JSON Reporter.
+*
+* A JSON reporter for browser environments that outputs structured log data
+* to the browser console. Uses appropriate console methods based on log level.
+* @template L - The log level type
+* @example
+* ```typescript
+* import { createPail } from "@visulima/pail";
+*
+* const logger = createPail({
+*   reporters: [new JsonReporter()]
+* });
+*
+* logger.info("Application started", { version: "1.0.0" });
+* // Outputs: {"level":"info","message":"Application started","context":[{"version":"1.0.0"}],...}
+* ```
+*/
+declare class JsonReporter<L extends string = string> extends AbstractJsonReporter<L> {
+  /**
+  * Creates a new Browser JSON Reporter instance.
+  * @param options Configuration options for JSON formatting
+  */
+  constructor(options?: Partial<AbstractJsonReporterOptions>);
+  /**
+  * Outputs the JSON message to the browser console.
+  *
+  * Uses the appropriate console method based on the log level
+  * (console.log, console.error, console.warn, etc.).
+  * @param message The JSON-formatted log message
+  * @param logLevel The log level determining which console method to use
+  * @protected
+  */
+  protected override _log(message: string, logLevel: LiteralUnion<ExtendedRfc5424LogLevels, L>): void;
+}
+export { AbstractJsonReporter, type AbstractJsonReporterOptions, JsonReporter };

package/dist/reporter/json/index.browser.js

@@ -1,2 +1 @@
-export { AbstractJsonReporter } from '../../packem_shared/AbstractJsonReporter-DDjDkciI.js';
-export { default as JsonReporter } from '../../packem_shared/JsonReporter-p_BXg6Sj.js';
+import{AbstractJsonReporter as e}from"../../packem_shared/AbstractJsonReporter-Bp_JCrMQ.js";import{default as p}from"../../packem_shared/JsonReporter-bmem9lcg.js";export{e as AbstractJsonReporter,p as JsonReporter};

package/dist/reporter/json/index.d.ts

@@ -1,3 +1,53 @@
-export type { AbstractJsonReporterOptions } from "./abstract-json-reporter.d.ts";
-export { AbstractJsonReporter } from "./abstract-json-reporter.d.ts";
-export { default as JsonReporter } from "./json-reporter.d.ts";
+import { A as AbstractJsonReporterOptions, a as AbstractJsonReporter } from "../../packem_shared/abstract-json-reporter.d-wfESoEa-.js";
+import { LiteralUnion } from 'type-fest';
+import { E as ExtendedRfc5424LogLevels, a as StreamAwareReporter } from "../../packem_shared/types.d-bWnqHJKL.js";
+import "../../packem_shared/index.d-T71KjNAr.js";
+import '@visulima/colorize';
+import '@visulima/interactive-manager';
+/**
+* Server JSON Reporter.
+*
+* A JSON reporter for Node.js server environments that outputs structured log data
+* to stdout/stderr streams. Routes error-level logs to stderr and others to stdout.
+* @template L - The log level type
+* @example
+* ```typescript
+* import { createPail } from "@visulima/pail";
+*
+* const logger = createPail({
+*   reporters: [new JsonReporter()]
+* });
+*
+* logger.info("Server started", { port: 3000 });
+* logger.error("Database connection failed", error);
+* ```
+*/
+declare class JsonReporter<L extends string = string> extends AbstractJsonReporter<L> implements StreamAwareReporter<L> {
+  #private;
+  /**
+  * Creates a new Server JSON Reporter instance.
+  * @param options Configuration options for JSON formatting
+  */
+  constructor(options?: Partial<AbstractJsonReporterOptions>);
+  /**
+  * Sets the stdout stream for the reporter.
+  * @param stdout_ The writable stream to use for stdout output
+  */
+  setStdout(stdout_: NodeJS.WriteStream): void;
+  /**
+  * Sets the stderr stream for the reporter.
+  * @param stderr_ The writable stream to use for stderr output
+  */
+  setStderr(stderr_: NodeJS.WriteStream): void;
+  /**
+  * Outputs the JSON message to the appropriate stream.
+  *
+  * Routes high-severity RFC 5424 levels (warning/error/critical/alert/emergency/trace)
+  * to stderr, others to stdout.
+  * @param message The JSON-formatted log message
+  * @param logLevel The log level determining which stream to use
+  * @protected
+  */
+  protected override _log(message: string, logLevel: LiteralUnion<ExtendedRfc5424LogLevels, L>): void;
+}
+export { AbstractJsonReporter, type AbstractJsonReporterOptions, JsonReporter };

package/dist/reporter/json/index.js

@@ -1,2 +1 @@
-export { AbstractJsonReporter } from '../../packem_shared/AbstractJsonReporter-CGKHS8_M.js';
-export { default as JsonReporter } from '../../packem_shared/JsonReporter-B3XX8GHN.js';
+import{AbstractJsonReporter as e}from"../../packem_shared/AbstractJsonReporter-w_bGGiD-.js";import{default as p}from"../../packem_shared/JsonReporter-Sd_lJGS-.js";export{e as AbstractJsonReporter,p as JsonReporter};

package/dist/reporter/pretty/index.browser.d.ts

@@ -1,2 +1,105 @@
-export type { PrettyStyleOptions } from "./abstract-pretty-reporter.d.ts";
-export { default as PrettyReporter } from "./pretty-reporter.d.ts";
+import { D as DefaultLogTypes, L as LiteralUnion, a as LoggerTypesConfig, R as ReadonlyMeta, b as LoggerTypesAwareReporter } from "../../packem_shared/types.d-xxE3FOD3.js";
+import '@visulima/colorize';
+import '@visulima/interactive-manager';
+/**
+* Abstract Pretty Reporter.
+*
+* Base class for pretty-printing reporters that format log messages with colors,
+* styles, and structured layout. Provides common functionality for styling options
+* and logger type configuration.
+* @template T - Custom logger type names
+* @template L - Log level types
+* @example
+* ```typescript
+* class CustomPrettyReporter extends AbstractPrettyReporter {
+*   public log(meta: ReadonlyMeta) {
+*     const formatted = this.formatMessage(meta);
+*     console.log(formatted);
+*   }
+* }
+* ```
+*/
+declare abstract class AbstractPrettyReporter<T extends string = string, L extends string = string> implements LoggerTypesAwareReporter<T, L> {
+  /** Styling options for pretty formatting */
+  protected readonly styles: PrettyStyleOptions;
+  /** Logger type configurations for styling */
+  protected loggerTypes: LoggerTypesConfig<LiteralUnion<DefaultLogTypes, T>, L>;
+  /**
+  * Creates a new AbstractPrettyReporter instance.
+  * @param options Styling options for pretty formatting
+  * @protected
+  */
+  protected constructor(options: Partial<PrettyStyleOptions>);
+  /**
+  * Sets the logger types configuration for styling.
+  * @param types Logger type configurations with colors and labels
+  */
+  setLoggerTypes(types: LoggerTypesConfig<LiteralUnion<DefaultLogTypes, T>, L>): void;
+  /**
+  * Logs a message with pretty formatting.
+  * @param meta The log metadata to format and output
+  * @abstract
+  */
+  abstract log(meta: ReadonlyMeta<L>): void;
+}
+/**
+* Options for configuring pretty reporter styling.
+*/
+type PrettyStyleOptions = {
+  /** Bold styling options */
+  bold: {
+    /** Whether to bold the label text */
+    label: boolean;
+  };
+  /** Function to format dates in log output */
+  dateFormatter: (date: Date) => string;
+  /** Maximum length of message before line break (optional) */
+  messageLength: number | undefined;
+  /** Underline styling options */
+  underline: {
+    /** Whether to underline the label */
+    label: boolean;
+    /** Whether to underline prefixes */
+    prefix: boolean;
+    /** Whether to underline suffixes */
+    suffix: boolean;
+  };
+  /** Uppercase styling options */
+  uppercase: {
+    /** Whether to uppercase the label text */
+    label: boolean;
+  };
+};
+/**
+* Browser Pretty Reporter.
+*
+* A pretty-printing reporter for browser environments that formats log messages
+* with colors and structured layout for console output. Uses browser-compatible
+* color formatting and console APIs.
+* @template T - Custom logger type names
+* @template L - Log level types
+* @example
+* ```typescript
+* import { createPail } from "@visulima/pail";
+*
+* const logger = createPail({
+*   reporters: [new PrettyReporter({
+*     bold: { label: true },
+*     uppercase: { label: true }
+*   })]
+* });
+*
+* logger.info("Application started");
+* logger.error("Something went wrong", error);
+* ```
+*/
+declare class PrettyReporter<T extends string = string, L extends string = string> extends AbstractPrettyReporter<T, L> {
+  #private;
+  /**
+  * Creates a new Browser Pretty Reporter instance.
+  * @param options Styling options for pretty formatting
+  */
+  constructor(options?: Partial<PrettyStyleOptions>);
+  log(meta: ReadonlyMeta<L>): void;
+}
+export { PrettyReporter, type PrettyStyleOptions };

package/dist/reporter/pretty/index.browser.js

@@ -1 +1 @@
-export { default as PrettyReporter } from '../../packem_shared/PrettyReporter-BYL3NrdA.js';
+import{default as t}from"../../packem_shared/PrettyReporter-DsHfKOU7.js";export{t as PrettyReporter};

package/dist/reporter/pretty/index.d.ts

@@ -1,2 +1,270 @@
-export type { PrettyReporterOptions } from "./pretty-reporter.d.ts";
-export { PrettyReporter } from "./pretty-reporter.d.ts";
+import { LiteralUnion } from 'type-fest';
+import { InteractiveManager } from '@visulima/interactive-manager';
+import { D as DefaultLogTypes, c as LoggerTypesConfig, R as ReadonlyMeta, e as LoggerTypesAwareReporter, E as ExtendedRfc5424LogLevels, I as InteractiveStreamReporter } from "../../packem_shared/types.d-bWnqHJKL.js";
+import '@visulima/colorize';
+type ColorizeMethod = (value: string) => string;
+type CodeFrameOptions = {
+  color?: {
+    gutter?: ColorizeMethod;
+    marker?: ColorizeMethod;
+    message?: ColorizeMethod;
+  };
+  linesAbove?: number;
+  linesBelow?: number;
+  message?: string;
+  prefix?: string;
+  showGutter?: boolean;
+  showLineNumbers?: boolean;
+  tabWidth?: number | false;
+};
+/**
+* The compiled position of a stack frame handed to a {@link SourceMapResolver}.
+*/
+interface SourceMapLocation {
+  column?: number;
+  file: string;
+  line: number;
+}
+/**
+* The resolved original position returned by a {@link SourceMapResolver}. Any omitted field falls
+* back to the compiled value. `source`, when provided, is used directly as the code-frame content
+* (e.g. from an inlined `sourcesContent`) instead of reading the resolved file from disk.
+*/
+interface ResolvedSourceLocation {
+  column?: number;
+  file?: string;
+  line?: number;
+  source?: string;
+}
+/**
+* Pluggable hook that maps a compiled `*.js:line:col` position back to its original source position
+* (e.g. TS/JSX). Return `undefined` (or throw) to leave the frame untouched. Synchronous so it can
+* be used by the synchronous `renderError`; resolve/inline your maps ahead of time.
+*/
+type SourceMapResolver = (location: SourceMapLocation) => ResolvedSourceLocation | undefined;
+type Options$1 = {
+  /**
+  * Read source files for code frames from anywhere on disk, including absolute paths outside
+  * `cwd`. Defaults to `false`, in which case only files resolving inside `cwd` are read — this
+  * prevents local file disclosure when rendering errors whose stack came from untrusted input
+  * (e.g. a deserialized error). Enable only for trusted, locally-thrown errors.
+  * @default false
+  */
+  allowAllFilePaths: boolean;
+  color: CodeFrameOptions["color"] & {
+    fileLine: ColorizeMethod;
+    hint: ColorizeMethod;
+    method: ColorizeMethod;
+    title: ColorizeMethod;
+  };
+  cwd: string;
+  displayShortPath: boolean;
+  filterStacktrace: ((line: string) => boolean) | undefined;
+  framesMaxLimit: number;
+  hideErrorCauseCodeView: boolean;
+  hideErrorCodeView: boolean;
+  hideErrorErrorsCodeView: boolean;
+  hideErrorTitle: boolean;
+  hideMessage: boolean;
+  indentation: number | "	";
+  prefix: string; /** Optional source-map resolver to map compiled frame positions back to original source. */
+  sourceMap?: SourceMapResolver;
+} & Omit<CodeFrameOptions, "message | prefix">;
+interface Options {
+  /**
+  * When `true`, honour custom inspectors: a value's
+  * `Symbol.for("nodejs.util.inspect.custom")` method (Node only),
+  * `Symbol.for("chai/inspect")` method, an `.inspect()` method, or a handler
+  * registered via `registerConstructor` / `registerStringTag`.
+  * @default true
+  */
+  customInspect: boolean;
+  /**
+  * The maximum nesting depth to traverse before collapsing a nested value to
+  * `[Object]` / `[Array]`. A value `&lt;= 0` disables the limit.
+  * @default 5
+  */
+  depth: number;
+  /**
+  * Pretty-print with indentation. `"\t"` indents with tabs, a positive integer
+  * indents with that many spaces, and `undefined` keeps everything on one line.
+  * @default undefined
+  */
+  indent: number | "	" | undefined;
+  /**
+  * The maximum number of array / typed-array / iterable elements to render
+  * before the remainder is replaced with an `… (N more)` marker. Use
+  * `Number.POSITIVE_INFINITY` to show every element.
+  * @default Number.POSITIVE_INFINITY
+  */
+  maxArrayLength: number;
+  /**
+  * When `true`, render large numbers and bigints with `_` digit-group
+  * separators (e.g. `1_000_000`).
+  * @default true
+  */
+  numericSeparator: boolean;
+  /**
+  * The quote character used when rendering string values and complex object
+  * keys.
+  * @default "single"
+  */
+  quoteStyle: "double" | "single";
+  /**
+  * When `true`, also render non-enumerable own properties of plain objects
+  * (mirrors `util.inspect`'s `showHidden`).
+  * @default false
+  */
+  showHidden: boolean;
+  /**
+  * Colourize / decorate a rendered fragment. Receives the raw fragment and a
+  * style hint and must return the (optionally wrapped) string. Defaults to the
+  * identity function.
+  */
+  stylize: (value: string, styleType: LiteralUnion<"bigint" | "boolean" | "date" | "null" | "number" | "regexp" | "special" | "string" | "symbol" | "undefined", string>) => string;
+  /**
+  * The maximum length (in characters) of a single rendered value before it is
+  * truncated with an ellipsis. Use `Number.POSITIVE_INFINITY` to disable
+  * truncation.
+  * @default Number.POSITIVE_INFINITY
+  */
+  truncate: number;
+}
+/**
+* Abstract Pretty Reporter.
+*
+* Base class for pretty-printing reporters that format log messages with colors,
+* styles, and structured layout. Provides common functionality for styling options
+* and logger type configuration.
+* @template T - Custom logger type names
+* @template L - Log level types
+* @example
+* ```typescript
+* class CustomPrettyReporter extends AbstractPrettyReporter {
+*   public log(meta: ReadonlyMeta) {
+*     const formatted = this.formatMessage(meta);
+*     console.log(formatted);
+*   }
+* }
+* ```
+*/
+declare abstract class AbstractPrettyReporter<T extends string = string, L extends string = string> implements LoggerTypesAwareReporter<T, L> {
+  /** Styling options for pretty formatting */
+  protected readonly styles: PrettyStyleOptions;
+  /** Logger type configurations for styling */
+  protected loggerTypes: LoggerTypesConfig<LiteralUnion<DefaultLogTypes, T>, L>;
+  /**
+  * Creates a new AbstractPrettyReporter instance.
+  * @param options Styling options for pretty formatting
+  * @protected
+  */
+  protected constructor(options: Partial<PrettyStyleOptions>);
+  /**
+  * Sets the logger types configuration for styling.
+  * @param types Logger type configurations with colors and labels
+  */
+  setLoggerTypes(types: LoggerTypesConfig<LiteralUnion<DefaultLogTypes, T>, L>): void;
+  /**
+  * Logs a message with pretty formatting.
+  * @param meta The log metadata to format and output
+  * @abstract
+  */
+  abstract log(meta: ReadonlyMeta<L>): void;
+}
+/**
+* Options for configuring pretty reporter styling.
+*/
+type PrettyStyleOptions = {
+  /** Bold styling options */
+  bold: {
+    /** Whether to bold the label text */
+    label: boolean;
+  };
+  /** Function to format dates in log output */
+  dateFormatter: (date: Date) => string;
+  /** Maximum length of message before line break (optional) */
+  messageLength: number | undefined;
+  /** Underline styling options */
+  underline: {
+    /** Whether to underline the label */
+    label: boolean;
+    /** Whether to underline prefixes */
+    prefix: boolean;
+    /** Whether to underline suffixes */
+    suffix: boolean;
+  };
+  /** Uppercase styling options */
+  uppercase: {
+    /** Whether to uppercase the label text */
+    label: boolean;
+  };
+};
+/**
+* Options for configuring the Server Pretty Reporter.
+*/
+type PrettyReporterOptions = PrettyStyleOptions & {
+  /** Error rendering options */
+  error: Partial<Omit<Options$1, "color" | "prefix" | "indentation">>;
+  /** Object inspection options */
+  inspect: Partial<Options>;
+};
+/**
+* Server Pretty Reporter.
+*
+* A comprehensive pretty-printing reporter for Node.js server environments that
+* formats log messages with colors, structured layout, and advanced features like
+* error rendering, object inspection, and interactive terminal support.
+* @template T - Custom logger type names
+* @template L - Log level types
+* @example
+* ```typescript
+* import { createPail } from "@visulima/pail";
+*
+* const logger = createPail({
+*   reporters: [new PrettyReporter({
+*     bold: { label: true },
+*     error: { color: { title: 'red' } }
+*   })]
+* });
+*
+* logger.info("Server started on port 3000");
+* logger.error("Database error", dbError);
+* ```
+*/
+declare class PrettyReporter<T extends string = string, L extends string = string> extends AbstractPrettyReporter<T, L> implements InteractiveStreamReporter<L> {
+  #private;
+  /**
+  * Creates a new Server Pretty Reporter instance.
+  * @param options Configuration options for styling, error rendering, and object inspection
+  */
+  constructor(options?: Partial<PrettyReporterOptions>);
+  /**
+  * Sets the logger types configuration and refreshes cached badge/label widths.
+  * @param types Logger type configurations with colors and labels
+  */
+  override setLoggerTypes(types: LoggerTypesConfig<LiteralUnion<DefaultLogTypes, T>, L>): void;
+  /**
+  * Sets the stdout stream for the reporter.
+  * @param stdout_ The writable stream to use for standard output
+  */
+  setStdout(stdout_: NodeJS.WriteStream): void;
+  /**
+  * Sets the stderr stream for the reporter.
+  * @param stderr_ The writable stream to use for error output
+  */
+  setStderr(stderr_: NodeJS.WriteStream): void;
+  /**
+  * Sets the interactive manager for handling interactive output.
+  * @param manager The interactive manager instance, or undefined to disable
+  */
+  setInteractiveManager(manager?: InteractiveManager): void;
+  /**
+  * Enables or disables interactive mode.
+  * @param interactive Whether to enable interactive terminal features
+  */
+  setIsInteractive(interactive: boolean): void;
+  log(meta: ReadonlyMeta<L>): void;
+  protected _formatMessage(data: ReadonlyMeta<L>): string;
+  protected _log(message: string, logLevel: LiteralUnion<ExtendedRfc5424LogLevels, L>): void;
+}
+export { PrettyReporter, type PrettyReporterOptions };

package/dist/reporter/pretty/index.js

@@ -1 +1 @@
-export { PrettyReporter } from '../../packem_shared/PrettyReporter-CvBn-hxP.js';
+import{PrettyReporter as t}from"../../packem_shared/PrettyReporter-CcDdPQSt.js";export{t as PrettyReporter};