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

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;

package/dist/types.d.ts

@@ -1,241 +0,0 @@
-import type { AnsiColors } from "@visulima/colorize";
-import type { InteractiveManager } from "@visulima/interactive-manager";
-import type { stringify } from "safe-stable-stringify";
-import type { LiteralUnion, Primitive } from "type-fest";
-/**
- * Global namespace for extending Pail's metadata interface.
- *
- * This global declaration allows other packages and applications to extend
- * the Meta interface with custom properties by declaring additional properties
- * in the VisulimaPail.CustomMeta interface.
- * @example
- * ```typescript
- * declare global {
- *   namespace VisulimaPail {
- *     interface CustomMeta<L> {
- *       userId?: string;
- *       requestId?: string;
- *     }
- *   }
- * }
- * ```
- */
-declare global {
-    namespace VisulimaPail {
-        interface CustomMeta<L> {
-        }
-    }
-}
-/**
- * Metadata object containing all information about a log entry.
- *
- * This interface defines the structure of metadata that is passed to reporters
- * and processors. It contains all the contextual information about a log message
- * including the message itself, timing information, error details, and more.
- * @template L - The log level type
- */
-export interface Meta<L> extends VisulimaPail.CustomMeta<L> {
-    badge: string | undefined;
-    context: any[] | undefined;
-    date: Date | string;
-    error: Error | undefined;
-    groups: string[];
-    label: string | undefined;
-    message: Primitive | ReadonlyArray<unknown> | Record<PropertyKey, unknown>;
-    prefix: string | undefined;
-    repeated?: number;
-    scope: string[] | undefined;
-    suffix: string | undefined;
-    traceError: Error | undefined;
-    type: {
-        level: ExtendedRfc5424LogLevels | L;
-        name: string;
-    };
-}
-/**
- * Extended RFC 5424 Log Levels.
- *
- * Standard syslog severity levels as defined in RFC 5424, plus additional
- * levels commonly used in modern applications. Each level has a numeric
- * priority where lower numbers indicate higher severity.
- * @see https://datatracker.ietf.org/doc/html/rfc5424#section-6.2.1
- */
-export type ExtendedRfc5424LogLevels = "alert" | "critical" | "debug" | "emergency" | "error" | "informational" | "notice" | "trace" | "warning";
-/**
- * Default Log Types.
- *
- * Predefined semantic log types that provide meaningful categorization
- * for different kinds of log messages. Each type has associated styling
- * and log level configuration.
- */
-export type DefaultLogTypes = "alert" | "await" | "complete" | "critical" | "debug" | "emergency" | "error" | "info" | "log" | "notice" | "pending" | "start" | "stop" | "success" | "trace" | "wait" | "warn" | "warning" | "watch";
-/**
- * Logger Function Type.
- *
- * Represents a logging function that can accept either a structured Message object
- * or multiple arguments in the traditional console.log style.
- */
-export interface LoggerFunction {
-    (message: Message): void;
-    (...message: any[]): void;
-}
-/**
- * Logger Configuration.
- *
- * Configuration object that defines how a specific logger type should behave,
- * including its visual appearance and log level.
- * @template L - The log level type
- */
-export interface LoggerConfiguration<L extends string> {
-    badge?: string;
-    color?: AnsiColors;
-    label: string;
-    logLevel: LiteralUnion<ExtendedRfc5424LogLevels, L>;
-}
-/**
- * Logger Types Configuration.
- *
- * A record mapping logger type names to their configurations.
- * @template T - Custom logger type names
- * @template L - Log level types
- */
-export type LoggerTypesConfig<T extends string, L extends string> = Record<T, Partial<LoggerConfiguration<L>>>;
-/**
- * Default Logger Types Configuration.
- *
- * A complete mapping of all default log types to their full configurations.
- * @template L - Log level types
- */
-export type DefaultLoggerTypes<L extends string = string> = Record<DefaultLogTypes, LoggerConfiguration<L>>;
-/**
- * Read-only Metadata.
- *
- * Immutable version of the Meta interface for use in reporters.
- * @template L - The log level type
- */
-export type ReadonlyMeta<L extends string> = Readonly<Meta<L>>;
-/**
- * Reporter Interface.
- *
- * Base interface for all reporters. Reporters are responsible for
- * outputting log messages to various destinations (console, files, etc.).
- * @template L - The log level type
- */
-export interface Reporter<L extends string> {
-    log: (meta: ReadonlyMeta<L>) => void;
-}
-/**
- * Stream-Aware Reporter Interface.
- *
- * Extends Reporter with the ability to work with Node.js streams.
- * Used for server-side reporters that need to write to stdout/stderr.
- * @template L - The log level type
- */
-export interface StreamAwareReporter<L extends string> extends Reporter<L> {
-    /** Set the stderr stream for error output */
-    setStderr: (stderr: NodeJS.WriteStream) => void;
-    /** Set the stdout stream for standard output */
-    setStdout: (stdout: NodeJS.WriteStream) => void;
-}
-/**
- * Logger Types Aware Reporter Interface.
- *
- * Extends Reporter with the ability to receive logger type configurations.
- * Allows reporters to customize their output based on logger types.
- * @template T - Custom logger type names
- * @template L - The log level type
- */
-export interface LoggerTypesAwareReporter<T extends string, L extends string> extends Reporter<L> {
-    /** Set the logger types configuration */
-    setLoggerTypes: (types: LoggerTypesConfig<T, L> & Partial<LoggerTypesConfig<DefaultLogTypes, L>>) => void;
-}
-/**
- * Stringify-Aware Reporter Interface.
- *
- * Extends Reporter with the ability to receive a custom stringify function.
- * Useful for reporters that need to serialize complex objects.
- * @template L - The log level type
- */
-export interface StringifyAwareReporter<L extends string> extends Reporter<L> {
-    /** Set the stringify function for object serialization */
-    setStringify: (stringify: any) => void;
-}
-/**
- * Interactive Stream Reporter Interface.
- *
- * Extends StreamAwareReporter with interactive capabilities for terminal UIs.
- * Supports features like progress bars and dynamic updates.
- * @template L - The log level type
- */
-export interface InteractiveStreamReporter<L extends string> extends StreamAwareReporter<L> {
-    /** Set the interactive manager for handling interactive output */
-    setInteractiveManager: (manager?: InteractiveManager) => void;
-    /** Enable or disable interactive mode */
-    setIsInteractive: (interactive: boolean) => void;
-}
-/**
- * Processor Interface.
- *
- * Base interface for all processors. Processors can modify or enhance
- * log metadata before it reaches reporters.
- * @template L - The log level type
- */
-export interface Processor<L extends string> {
-    /** Process the log metadata */
-    process: (meta: Meta<L>) => Meta<L>;
-}
-/**
- * Stringify-Aware Processor Interface.
- *
- * Extends Processor with the ability to receive a custom stringify function.
- * Useful for processors that need to serialize complex objects.
- * @template L - The log level type
- */
-export interface StringifyAwareProcessor<L extends string> extends Processor<L> {
-    /** Set the stringify function for object serialization */
-    setStringify: (stringify: typeof JSON.stringify) => void;
-}
-export interface ConstructorOptions<T extends string, L extends string> {
-    disabled?: boolean;
-    logLevel?: LiteralUnion<ExtendedRfc5424LogLevels, L>;
-    logLevels?: Partial<Record<ExtendedRfc5424LogLevels, number>> & Record<L, number>;
-    messages?: {
-        timerEnd?: string;
-        timerStart?: string;
-    };
-    processors?: Processor<L>[];
-    rawReporter?: Reporter<L>;
-    reporters?: Reporter<L>[];
-    scope?: string[] | string;
-    throttle?: number;
-    throttleMin?: number;
-    types?: LoggerTypesConfig<T, L> & Partial<LoggerTypesConfig<DefaultLogTypes, L>>;
-}
-export interface ServerConstructorOptions<T extends string, L extends string> extends ConstructorOptions<T, L> {
-    interactive?: boolean;
-    stderr: NodeJS.WriteStream;
-    stdout: NodeJS.WriteStream;
-}
-export type Message = {
-    context?: any[];
-    message: any;
-    prefix?: string;
-    suffix?: string;
-};
-/**
- * Internal interface for parent logger optimization properties.
- *
- * These properties are used internally to optimize child logger creation
- * by reusing parent logger's computed values when they haven't changed.
- * @internal
- */
-export interface ParentLoggerOptimization<T extends string = string, L extends string = string> {
-    parentLogLevels?: Record<string, number>;
-    parentLongestLabel?: string;
-    parentMessages?: {
-        timerEnd: string;
-        timerStart: string;
-    };
-    parentStringify?: typeof stringify;
-    parentTypes?: LoggerTypesConfig<LiteralUnion<DefaultLogTypes, T>, L>;
-}

package/dist/utils/arrayify.d.ts

@@ -1,2 +0,0 @@
-declare const arrayify: <T>(x: T | T[]) => T[];
-export default arrayify;

package/dist/utils/get-longest-badge.d.ts

@@ -1,4 +0,0 @@
-import type { LiteralUnion } from "type-fest";
-import type { DefaultLogTypes, LoggerTypesConfig } from "../types.d.ts";
-declare const getLongestBadge: <L extends string, T extends string>(types: LoggerTypesConfig<LiteralUnion<DefaultLogTypes, T>, L>) => string;
-export default getLongestBadge;

package/dist/utils/get-longest-label.d.ts

@@ -1,4 +0,0 @@
-import type { LiteralUnion } from "type-fest";
-import type { DefaultLogTypes, LoggerTypesConfig } from "../types.d.ts";
-declare const getLongestLabel: <L extends string, T extends string>(types: LoggerTypesConfig<LiteralUnion<DefaultLogTypes, T>, L>) => string;
-export default getLongestLabel;

package/dist/utils/merge-types.d.ts

@@ -1,4 +0,0 @@
-import type { LiteralUnion } from "type-fest";
-import type { DefaultLoggerTypes, DefaultLogTypes, LoggerTypesConfig } from "../types.d.ts";
-declare const mergeTypes: <L extends string, T extends string>(standard: DefaultLoggerTypes<L>, custom: LoggerTypesConfig<T, L>) => LoggerTypesConfig<LiteralUnion<DefaultLogTypes, T>, L>;
-export default mergeTypes;