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

package/dist/reporter/file/utils/rotating-file-stream.d.ts

@@ -1,48 +0,0 @@
-import type { Options as RfsOptions } from "rotating-file-stream";
-/**
- * Rotating File Stream.
- *
- * A wrapper for the `rotating-file-stream` module that provides optional immediate
- * writing to disk by creating and closing a new stream on each write operation.
- * This is useful for ensuring log messages are written immediately rather than buffered.
- * @example
- * ```typescript
- * // Buffered writing (default)
- * const bufferedStream = new RotatingFileStream("/var/log/app.log", false, {
- *   interval: "1d",
- *   size: "10M"
- * });
- *
- * // Immediate writing
- * const immediateStream = new RotatingFileStream("/var/log/app.log", true, {
- *   interval: "1d"
- * });
- * ```
- */
-declare class RotatingFileStream {
-    #private;
-    /**
-     * Creates a new RotatingFileStream instance.
-     * @param filePath Path to the log file
-     * @param writeImmediately Whether to write immediately or buffer writes
-     * @param options Options for the rotating file stream
-     * @throws {Error} If the 'rotating-file-stream' package is not installed
-     */
-    constructor(filePath: string, writeImmediately?: boolean, options?: RfsOptions);
-    /**
-     * Writes a message to the rotating file stream.
-     *
-     * If writeImmediately was set to true in the constructor, a new stream
-     * is created for each write operation. Otherwise, uses the buffered stream.
-     * @param message The message to write to the file
-     */
-    write(message: string): void;
-    /**
-     * Ends the rotating file stream.
-     *
-     * Closes the underlying stream. When `writeImmediately` is not `true`,
-     * calling `write` after calling this method will throw an error.
-     */
-    end(): void;
-}
-export default RotatingFileStream;

package/dist/reporter/http/utils/compression.d.ts

@@ -1,7 +0,0 @@
-/**
- * Compresses data using gzip compression.
- * @param data The data to compress as a string
- * @returns A Promise that resolves to the compressed data as Uint8Array
- */
-declare const compressData: (data: string) => Promise<Uint8Array>;
-export default compressData;

package/dist/reporter/http/utils/log-size-error.d.ts

@@ -1,30 +0,0 @@
-/**
- * Error thrown when a log entry exceeds the maximum allowed size.
- */
-declare class LogSizeError extends Error {
-    /**
-     * The log entry data that caused the error
-     */
-    readonly logData: Record<string, unknown>;
-    /**
-     * The actual size of the log entry in bytes
-     */
-    readonly actualSize: number;
-    /**
-     * The maximum allowed size in bytes
-     */
-    readonly maxSize: number;
-    /**
-     * Creates a new LogSizeError instance.
-     * @param message Descriptive error message explaining the size violation
-     * @param logData The log entry data that caused the error
-     * @param actualSize Size of the log entry in bytes
-     * @param maxSize Maximum allowed size in bytes
-     * @example
-     * ```typescript
-     * throw new LogSizeError("Log too large", logData, 2000000, 1000000);
-     * ```
-     */
-    constructor(message: string, logData: Record<string, unknown>, actualSize: number, maxSize: number);
-}
-export default LogSizeError;

package/dist/reporter/http/utils/retry.d.ts

@@ -1,27 +0,0 @@
-/**
- * Sends an HTTP request with retry logic and rate limiting support.
- * @param url The URL to send the request to
- * @param method The HTTP method to use
- * @param headers Request headers
- * @param body The request body (string or Uint8Array)
- * @param maxRetries Maximum number of retry attempts
- * @param retryDelay Base delay between retries in milliseconds
- * @param respectRateLimit Whether to respect rate limiting (429 responses)
- * @param onDebugRequestResponse Optional callback for debugging requests/responses
- * @param onError Optional callback for error handling
- */
-declare const sendWithRetry: (url: string, method: string, headers: Record<string, string>, body: string | Uint8Array, maxRetries: number, retryDelay: number, respectRateLimit: boolean, onDebugRequestResponse?: (requestResponse: {
-    req: {
-        body: string | Uint8Array;
-        headers: Record<string, string>;
-        method: string;
-        url: string;
-    };
-    res: {
-        body: string;
-        headers: Record<string, string>;
-        status: number;
-        statusText: string;
-    };
-}) => void, onError?: (error: Error) => void) => Promise<void>;
-export default sendWithRetry;

package/dist/reporter/json/abstract-json-reporter.d.ts

@@ -1,61 +0,0 @@
-import type { stringify } from "safe-stable-stringify";
-import type { LiteralUnion } from "type-fest";
-import type { ExtendedRfc5424LogLevels, ReadonlyMeta, StringifyAwareReporter } from "../../types.d.ts";
-/**
- * Options for configuring JSON reporters.
- */
-export 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);
- *   }
- * }
- * ```
- */
-export 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;
-}

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

@@ -1,40 +0,0 @@
-import type { LiteralUnion } from "type-fest";
-import type { ExtendedRfc5424LogLevels } from "../../types.d.ts";
-import type { AbstractJsonReporterOptions } from "./abstract-json-reporter.d.ts";
-import { AbstractJsonReporter } from "./abstract-json-reporter.d.ts";
-/**
- * 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 _log(message: string, logLevel: LiteralUnion<ExtendedRfc5424LogLevels, L>): void;
-}
-export default JsonReporter;

package/dist/reporter/json/json-reporter.server.d.ts

@@ -1,50 +0,0 @@
-import type { LiteralUnion } from "type-fest";
-import type { ExtendedRfc5424LogLevels, StreamAwareReporter } from "../../types.d.ts";
-import type { AbstractJsonReporterOptions } from "./abstract-json-reporter.d.ts";
-import { AbstractJsonReporter } from "./abstract-json-reporter.d.ts";
-/**
- * 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 error and warning level messages to stderr, others to stdout.
-     * @param message The JSON-formatted log message
-     * @param logLevel The log level determining which stream to use
-     * @protected
-     */
-    protected _log(message: string, logLevel: LiteralUnion<ExtendedRfc5424LogLevels, L>): void;
-}
-export default JsonReporter;

package/dist/reporter/pretty/abstract-pretty-reporter.d.ts

@@ -1,83 +0,0 @@
-import type { LiteralUnion } from "type-fest";
-import type { DefaultLogTypes, LoggerTypesAwareReporter, LoggerTypesConfig, ReadonlyMeta } from "../../types.d.ts";
-/**
- * Default date formatter for pretty reporters.
- *
- * Formats a Date object as HH:MM:SS (24-hour format).
- * @param date The date to format
- * @returns Formatted time string
- * @example
- * ```typescript
- * dateFormatter(new Date()); // "14:30:25"
- * ```
- */
-export declare const dateFormatter: (date: Date) => string;
-/**
- * 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);
- *   }
- * }
- * ```
- */
-export 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.
- */
-export 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;
-    };
-};

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

@@ -1,36 +0,0 @@
-import type { ReadonlyMeta } from "../../types.d.ts";
-import type { PrettyStyleOptions } from "./abstract-pretty-reporter.d.ts";
-import { AbstractPrettyReporter } from "./abstract-pretty-reporter.d.ts";
-/**
- * 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 default PrettyReporter;

package/dist/reporter/pretty/pretty-reporter.server.d.ts

@@ -1,70 +0,0 @@
-import type { RenderErrorOptions } from "@visulima/error/error";
-import type { Options as InspectorOptions } from "@visulima/inspector";
-import type { InteractiveManager } from "@visulima/interactive-manager";
-import type { LiteralUnion } from "type-fest";
-import type { ExtendedRfc5424LogLevels, InteractiveStreamReporter, ReadonlyMeta } from "../../types.d.ts";
-import type { PrettyStyleOptions } from "./abstract-pretty-reporter.d.ts";
-import { AbstractPrettyReporter } from "./abstract-pretty-reporter.d.ts";
-/**
- * Options for configuring the Server Pretty Reporter.
- */
-export type PrettyReporterOptions = PrettyStyleOptions & {
-    /** Error rendering options */
-    error: Partial<Omit<RenderErrorOptions, "color" | "prefix" | "indentation">>;
-    /** Object inspection options */
-    inspect: Partial<InspectorOptions>;
-};
-/**
- * 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);
- * ```
- */
-export 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 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;
-}

package/dist/reporter/raw/raw-reporter.browser.d.ts

@@ -1,5 +0,0 @@
-import type { ReadonlyMeta, Reporter } from "../../types.d.ts";
-declare class RawReporter<L extends string = string> implements Reporter<L> {
-    log(meta: ReadonlyMeta<L>): void;
-}
-export default RawReporter;

package/dist/reporter/raw/raw-reporter.server.d.ts

@@ -1,13 +0,0 @@
-import type { Options as InspectorOptions } from "@visulima/inspector";
-import type { InteractiveManager } from "@visulima/interactive-manager";
-import type { ReadonlyMeta, StreamAwareReporter } from "../../types.d.ts";
-declare class RawReporter<L extends string = string> implements StreamAwareReporter<L> {
-    #private;
-    constructor(inspectOptions?: Partial<InspectorOptions>);
-    setStdout(stdout_: NodeJS.WriteStream): void;
-    setStderr(stderr_: NodeJS.WriteStream): void;
-    setInteractiveManager(manager?: InteractiveManager): void;
-    setIsInteractive(interactive: boolean): void;
-    log(meta: ReadonlyMeta<L>): void;
-}
-export default RawReporter;

package/dist/reporter/utils/default-inspector-config.d.ts

@@ -1,3 +0,0 @@
-import type { Options } from "@visulima/inspector";
-declare const defaultInspectorConfig: Partial<Options>;
-export default defaultInspectorConfig;

package/dist/reporter/utils/format-label.d.ts

@@ -1,3 +0,0 @@
-import type { PrettyStyleOptions } from "../pretty/abstract-pretty-reporter.d.ts";
-declare const formatLabel: (label: string, styles: PrettyStyleOptions) => string;
-export default formatLabel;