@visulima/pail 4.0.0-alpha.9 → 4.0.1

package/dist/packem_shared/pailMiddleware-Ci88geIF.js

@@ -1,24 +0,0 @@
-const GLOB_STRIP_RE = /\*+/g;
-const pailMiddleware = (NextResponseClass, options) => {
-  const { exclude, include } = options ?? {};
-  return (request) => {
-    const path = request.nextUrl.pathname;
-    if (exclude?.some((p) => path.startsWith(p.replaceAll(GLOB_STRIP_RE, "")))) {
-      return NextResponseClass.next();
-    }
-    if (include?.length && !include.some((p) => path.startsWith(p.replaceAll(GLOB_STRIP_RE, "")))) {
-      return NextResponseClass.next();
-    }
-    const requestId = request.headers.get("x-request-id") ?? crypto.randomUUID();
-    const requestHeaders = new Headers(request.headers);
-    requestHeaders.set("x-request-id", requestId);
-    requestHeaders.set("x-pail-start", String(Date.now()));
-    const response = NextResponseClass.next({
-      request: { headers: requestHeaders }
-    });
-    response.headers.set("x-request-id", requestId);
-    return response;
-  };
-};
-
-export { pailMiddleware };

package/dist/packem_shared/storage-D0vqz8OX.js

@@ -1,36 +0,0 @@
-import { createRequire as __cjs_createRequire } from "node:module";
-
-const __cjs_require = __cjs_createRequire(import.meta.url);
-
-const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
-
-const __cjs_getBuiltinModule = (module) => {
-    // Check if we're in Node.js and version supports getBuiltinModule
-    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
-        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
-        // Node.js 20.16.0+ and 22.3.0+
-        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
-            return __cjs_getProcess.getBuiltinModule(module);
-        }
-    }
-    // Fallback to createRequire
-    return __cjs_require(module);
-};
-
-const {
-  AsyncLocalStorage
-} = __cjs_getBuiltinModule("node:async_hooks");
-
-const createLoggerStorage = (contextHint) => {
-  const storage = new AsyncLocalStorage();
-  const useLogger = () => {
-    const logger = storage.getStore();
-    if (!logger) {
-      throw new Error(`[pail] useLogger() called outside of ${contextHint}`);
-    }
-    return logger;
-  };
-  return { storage, useLogger };
-};
-
-export { createLoggerStorage as c };

package/dist/packem_shared/useLogger-D0rU3lcX.js

@@ -1,33 +0,0 @@
-import { createRequire as __cjs_createRequire } from "node:module";
-
-const __cjs_require = __cjs_createRequire(import.meta.url);
-
-const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
-
-const __cjs_getBuiltinModule = (module) => {
-    // Check if we're in Node.js and version supports getBuiltinModule
-    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
-        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
-        // Node.js 20.16.0+ and 22.3.0+
-        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
-            return __cjs_getProcess.getBuiltinModule(module);
-        }
-    }
-    // Fallback to createRequire
-    return __cjs_require(module);
-};
-
-const {
-  AsyncLocalStorage
-} = __cjs_getBuiltinModule("node:async_hooks");
-
-const pailStorage = new AsyncLocalStorage();
-const useLogger = () => {
-  const logger = pailStorage.getStore();
-  if (!logger) {
-    throw new Error("[pail] useLogger() called outside of withPail() context. Wrap your route handler or server action with withPail().");
-  }
-  return logger;
-};
-
-export { pailStorage, useLogger };

package/dist/packem_shared/write-console-log-based-on-level-DBmRYXpj.js

@@ -1,14 +0,0 @@
-const writeConsoleLogBasedOnLevel = (level) => {
-  if (level === "error") {
-    return console.__error ?? console.error;
-  }
-  if (level === "warn") {
-    return console.__warn ?? console.warn;
-  }
-  if (level === "trace") {
-    return console.__trace ?? console.trace;
-  }
-  return console.__log ?? console.log;
-};
-
-export { writeConsoleLogBasedOnLevel as w };

package/dist/packem_shared/write-stream-BG8fhcs3.js

@@ -1,6 +0,0 @@
-const writeStream = (data, stream) => {
-  const write = stream.__write ?? stream.write;
-  return write.call(stream, data);
-};
-
-export { writeStream as w };

package/dist/pail.browser.d.ts

@@ -1,412 +0,0 @@
-import type { stringify } from "safe-stable-stringify";
-import type { LiteralUnion } from "type-fest";
-import type { ConstructorOptions, DefaultLogTypes, ExtendedRfc5424LogLevels, LoggerFunction, LoggerTypesConfig, Meta, Processor, Reporter } from "./types.d.ts";
-/**
- * Pail Browser Implementation.
- *
- * A comprehensive logging library for browser environments with support for
- * multiple log levels, custom types, processors, reporters, and advanced features
- * like throttling, scoping, timers, and counters.
- * @template T - Custom logger types (string union)
- * @template L - Log level types (string union)
- * @example
- * ```typescript
- * const logger = new PailBrowserImpl({
- *   logLevel: "debug",
- *   types: {
- *     http: { color: "blue", label: "HTTP", logLevel: "info" }
- *   },
- *   reporters: [new JsonReporter()]
- * });
- *
- * logger.info("Application started");
- * logger.http("GET /api/users 200");
- * logger.error("Something went wrong", error);
- * ```
- */
-export declare class PailBrowserImpl<T extends string = string, L extends string = string> {
-    #private;
-    protected timersMap: Map<string, number>;
-    protected countMap: Map<string, number>;
-    protected seqTimers: Set<string>;
-    protected readonly lastLog: {
-        count?: number;
-        object?: Meta<L>;
-        time?: Date;
-        timeout?: ReturnType<typeof setTimeout>;
-    };
-    protected readonly logLevels: Record<string, number>;
-    protected disabled: boolean;
-    protected paused: boolean;
-    protected messageQueue: {
-        messageObject: any[];
-        raw: boolean;
-        type: LiteralUnion<DefaultLogTypes, T>;
-    }[];
-    protected scopeName: string[];
-    protected readonly types: LoggerTypesConfig<LiteralUnion<DefaultLogTypes, T>, L>;
-    protected readonly longestLabel: string;
-    protected readonly processors: Set<Processor<L>>;
-    protected readonly generalLogLevel: LiteralUnion<ExtendedRfc5424LogLevels, L>;
-    protected reporters: Set<Reporter<L>>;
-    protected readonly throttle: number;
-    protected readonly throttleMin: number;
-    protected readonly stringify: typeof stringify;
-    protected groups: string[];
-    protected readonly startTimerMessage: string;
-    protected readonly endTimerMessage: string;
-    protected rawReporter: Reporter<L>;
-    protected force: Record<string, LoggerFunction>;
-    /**
-     * Creates a new Pail browser logger instance.
-     *
-     * Initializes the logger with the provided configuration options,
-     * setting up reporters, processors, log levels, and other internal state.
-     * @param options Configuration options for the logger
-     */
-    constructor(options: ConstructorOptions<T, L>);
-    /**
-     * Wraps the global console methods to redirect them through the logger.
-     *
-     * This method replaces console methods (log, info, warn, error, etc.) with
-     * calls to the corresponding logger methods. The original console methods
-     * are backed up and can be restored using restoreConsole().
-     * @example
-     * ```typescript
-     * const logger = createPail();
-     * logger.wrapConsole();
-     *
-     * console.log("This will go through the logger");
-     * console.error("This too!");
-     *
-     * logger.restoreConsole(); // Restore original console methods
-     * ```
-     */
-    wrapConsole(): void;
-    /**
-     * Restores the original global console methods.
-     *
-     * This method restores the console methods that were backed up by wrapConsole().
-     * After calling this, console methods will work as they did before wrapping.
-     * @example
-     * ```typescript
-     * const logger = createPail();
-     * logger.wrapConsole();
-     *
-     * // Console methods are now wrapped
-     * logger.restoreConsole();
-     * // Console methods are restored to original behavior
-     * ```
-     */
-    restoreConsole(): void;
-    /**
-     * Wraps uncaught exception and unhandled rejection handlers.
-     *
-     * This method sets up global error handlers that will log uncaught exceptions
-     * and unhandled promise rejections through the logger. This is useful for
-     * capturing and logging application crashes.
-     * @example
-     * ```typescript
-     * const logger = createPail();
-     * logger.wrapException();
-     *
-     * // Now uncaught errors will be logged
-     * throw new Error("This will be logged");
-     * ```
-     */
-    wrapException(): void;
-    /**
-     * Disables all logging output.
-     *
-     * When disabled, all log calls will be silently ignored and no output
-     * will be produced by any reporters. This can be useful for temporarily
-     * suppressing log output in production or during testing.
-     * @example
-     * ```typescript
-     * const logger = createPail();
-     * logger.disable();
-     * logger.info("This won't be logged"); // Silent
-     * logger.enable();
-     * logger.info("This will be logged"); // Output produced
-     * ```
-     */
-    disable(): void;
-    /**
-     * Enables logging output.
-     *
-     * Re-enables logging after it has been disabled. All subsequent log calls
-     * will produce output according to the configured reporters.
-     * @example
-     * ```typescript
-     * const logger = createPail();
-     * logger.disable();
-     * logger.info("This won't be logged");
-     * logger.enable(); // Re-enable logging
-     * logger.info("This will be logged");
-     * ```
-     */
-    enable(): void;
-    /**
-     * Checks if logging is currently enabled.
-     *
-     * Returns true if logging is enabled and false if it has been disabled.
-     * @returns True if logging is enabled, false if disabled
-     * @example
-     * ```typescript
-     * const logger = createPail();
-     * console.log(logger.isEnabled()); // true
-     * logger.disable();
-     * console.log(logger.isEnabled()); // false
-     * ```
-     */
-    isEnabled(): boolean;
-    /**
-     * Pauses logging and starts queuing messages.
-     *
-     * When paused, all log calls will be queued instead of being output immediately.
-     * The queued messages will be processed when resume() is called. This is useful
-     * for temporarily buffering log output during critical operations.
-     * @example
-     * ```typescript
-     * const logger = createPail();
-     * logger.pause();
-     * logger.info("This will be queued"); // Queued, not output yet
-     * logger.warn("This too"); // Also queued
-     * logger.resume(); // Now both messages are output
-     * ```
-     */
-    pause(): void;
-    /**
-     * Resumes logging and flushes all queued messages.
-     *
-     * Processes all messages that were queued during the pause period and
-     * resumes normal logging behavior. Messages are output in the order
-     * they were originally called.
-     * @example
-     * ```typescript
-     * const logger = createPail();
-     * logger.pause();
-     * logger.info("Message 1"); // Queued
-     * logger.info("Message 2"); // Queued
-     * logger.resume(); // Both messages are now output in order
-     * logger.info("Message 3"); // Output immediately
-     * ```
-     */
-    resume(): void;
-    /**
-     * Creates a scoped logger instance.
-     *
-     * Returns a new logger instance that inherits all configuration but adds
-     * the specified scope names to all log messages. This is useful for
-     * categorizing logs by component, module, or feature.
-     * @template N - The new custom logger type names
-     * @param name Scope names to apply to all log messages
-     * @returns A new scoped logger instance
-     * @throws {Error} If no scope name is provided
-     * @example
-     * ```typescript
-     * const logger = createPail();
-     * const scopedLogger = logger.scope("auth", "login");
-     * scopedLogger.info("User logged in"); // Will include scope: ["auth", "login"]
-     * ```
-     */
-    scope<N extends string = T>(...name: string[]): PailBrowserType<N, L>;
-    /**
-     * Removes the current scope from the logger.
-     *
-     * Clears all scope names that were set by previous scope() calls.
-     * After calling this, log messages will no longer include scope information.
-     * @example
-     * ```typescript
-     * const logger = createPail();
-     * const scopedLogger = logger.scope("auth");
-     * scopedLogger.info("Scoped message"); // Has scope
-     * scopedLogger.unscope();
-     * scopedLogger.info("Unscoped message"); // No scope
-     * ```
-     */
-    unscope(): void;
-    /**
-     * Creates a child logger that inherits settings from the parent.
-     *
-     * Returns a new logger instance that inherits all configuration from the parent
-     * (reporters, processors, types, log levels, throttle settings, etc.) while allowing
-     * you to override only what you need. Child loggers are independent instances with
-     * their own state (timers, counters, etc.).
-     * @template N - The new custom logger type names
-     * @template LC - The new log level types
-     * @param options Configuration options to override or extend parent settings
-     * @returns A new child logger instance
-     * @example
-     * ```typescript
-     * const parent = createPail({
-     *   logLevel: "info",
-     *   types: { http: { label: "HTTP", logLevel: "info" } },
-     *   reporters: [new PrettyReporter()],
-     * });
-     *
-     * // Child inherits parent settings but overrides log level
-     * const child = parent.child({ logLevel: "debug" });
-     * child.info("This will be logged"); // Uses debug level from child
-     * child.http("GET /api 200"); // Inherits http type from parent
-     *
-     * // Child can add new types
-     * const childWithNewType = parent.child({
-     *   types: { db: { label: "DB", logLevel: "info" } },
-     * });
-     * childWithNewType.db("Query executed"); // New type available
-     * ```
-     */
-    child<N extends string = T, LC extends string = L>(options?: Partial<ConstructorOptions<N, LC>>): PailBrowserType<N, LC>;
-    /**
-     * Starts a timer with the specified label.
-     *
-     * Records the current timestamp and associates it with the given label.
-     * Multiple timers can be active simultaneously with different labels.
-     * @param label The timer label (defaults to "default")
-     * @example
-     * ```typescript
-     * const logger = createPail();
-     * logger.time("operation");
-     * // ... some operation ...
-     * logger.timeEnd("operation"); // Logs: "Timer run for: X ms"
-     * ```
-     */
-    time(label?: string): void;
-    /**
-     * Logs the current elapsed time for a timer without stopping it.
-     *
-     * Calculates and logs the time elapsed since the timer was started,
-     * but keeps the timer running. If no label is provided, uses the
-     * most recently started timer.
-     * @param label The timer label (uses last timer if not specified)
-     * @param data Additional data to include in the log message
-     * @example
-     * ```typescript
-     * const logger = createPail();
-     * logger.time("task");
-     * // ... some work ...
-     * logger.timeLog("task"); // Logs current elapsed time
-     * // ... more work ...
-     * logger.timeEnd("task"); // Logs final time and stops timer
-     * ```
-     */
-    timeLog(label?: string, ...data: unknown[]): void;
-    /**
-     * Stops a timer and logs the final elapsed time.
-     *
-     * Calculates the total time elapsed since the timer was started,
-     * logs the result, and removes the timer. If no label is provided,
-     * uses the most recently started timer.
-     * @param label The timer label (uses last timer if not specified)
-     * @example
-     * ```typescript
-     * const logger = createPail();
-     * logger.time("operation");
-     * // ... perform operation ...
-     * logger.timeEnd("operation"); // Logs: "Timer run for: X ms"
-     * ```
-     */
-    timeEnd(label?: string): void;
-    /**
-     * Starts a log group with the specified label.
-     *
-     * Groups related log messages together. In browser environments,
-     * this uses the native console.group() functionality. In other
-     * environments, it tracks group nesting internally.
-     * @param label The group label (defaults to "console.group")
-     * @example
-     * ```typescript
-     * const logger = createPail();
-     * logger.group("Database Operations");
-     * logger.info("Connecting to database");
-     * logger.info("Running migration");
-     * logger.groupEnd(); // End the group
-     * ```
-     */
-    group(label?: string): void;
-    /**
-     * Ends the current log group.
-     *
-     * Closes the most recently opened log group. In browser environments,
-     * this uses the native console.groupEnd() functionality.
-     * @example
-     * ```typescript
-     * const logger = createPail();
-     * logger.group("Processing");
-     * logger.info("Step 1");
-     * logger.info("Step 2");
-     * logger.groupEnd(); // Closes the "Processing" group
-     * ```
-     */
-    groupEnd(): void;
-    /**
-     * Increments and logs a counter with the specified label.
-     *
-     * Maintains an internal counter for each label and logs the current count
-     * each time it's called. Useful for tracking how many times certain
-     * code paths are executed.
-     * @param label The counter label (defaults to "default")
-     * @example
-     * ```typescript
-     * const logger = createPail();
-     * logger.count("requests"); // Logs: "requests: 1"
-     * logger.count("requests"); // Logs: "requests: 2"
-     * logger.count("errors");   // Logs: "errors: 1"
-     * ```
-     */
-    count(label?: string): void;
-    /**
-     * Resets a counter to zero.
-     *
-     * Removes the counter with the specified label, effectively resetting
-     * it to zero. If the counter doesn't exist, logs a warning.
-     * @param label The counter label to reset (defaults to "default")
-     * @example
-     * ```typescript
-     * const logger = createPail();
-     * logger.count("requests"); // Logs: "requests: 1"
-     * logger.countReset("requests"); // Resets counter
-     * logger.count("requests"); // Logs: "requests: 1" (starts over)
-     * ```
-     */
-    countReset(label?: string): void;
-    /**
-     * Clears the console output.
-     *
-     * Calls the native console.clear() method to clear all output from
-     * the console. This is a convenience method that wraps the native
-     * console.clear() functionality.
-     * @example
-     * ```typescript
-     * const logger = createPail();
-     * logger.info("Some message");
-     * logger.clear(); // Clears the console
-     * ```
-     */
-    clear(): void;
-    /**
-     * Logs a raw message bypassing normal processing.
-     *
-     * Sends a message directly to the raw reporter without going through
-     * the normal logging pipeline (processors, throttling, etc.). This is
-     * useful for logging that needs to bypass all formatting and processing.
-     * @param message The raw message to log
-     * @param arguments_ Additional arguments to include
-     * @example
-     * ```typescript
-     * const logger = createPail();
-     * logger.raw("Direct message", { data: "value" });
-     * ```
-     */
-    raw(message: string, ...arguments_: unknown[]): void;
-    protected extendReporter(reporter: Reporter<L>): Reporter<L>;
-    protected registerReporters(reporters: Reporter<L>[]): void;
-    protected registerProcessors(processors: Processor<L>[]): void;
-    protected logger(type: LiteralUnion<DefaultLogTypes, T>, raw: boolean, force: boolean, ...messageObject: any[]): void;
-}
-export type PailBrowserType<T extends string = string, L extends string = string> = Console & (new <TC extends string = string, LC extends string = string>(options?: ConstructorOptions<TC, LC>) => PailBrowserType<TC, LC>) & PailBrowserImpl<T, L> & Record<DefaultLogTypes, LoggerFunction> & Record<T, LoggerFunction> & {
-    force: Record<DefaultLogTypes, LoggerFunction> & Record<T, LoggerFunction>;
-};
-export type PailConstructor<T extends string = string, L extends string = string> = new (options?: ConstructorOptions<T, L>) => PailBrowserType<T, L>;
-export declare const PailBrowser: PailBrowserType;