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

package/dist/processor/caller/caller-processor.d.ts

@@ -1,54 +1,56 @@
-import type { Meta, Processor } from "../../types.d.ts";
+import { M as Meta, P as Processor } from "../../packem_shared/types.d-BeLumqgD.js";
+import '@visulima/colorize';
+import '@visulima/interactive-manager';
 /**
- * Global namespace extension for caller file metadata.
- *
- * Extends the VisulimaPail.CustomMeta interface to include file information
- * that will be added by the CallerProcessor.
- */
+* Global namespace extension for caller file metadata.
+*
+* Extends the VisulimaPail.CustomMeta interface to include file information
+* that will be added by the CallerProcessor.
+*/
 declare global {
-    namespace VisulimaPail {
-        interface CustomMeta<L> {
-            /** File information where the log was called from */
-            file: {
-                /** Column number in the source file */
-                column: number | undefined;
-                /** Line number in the source file */
-                line: number | undefined;
-                /** Name/path of the source file */
-                name: string | undefined;
-            } | undefined;
-        }
+  namespace VisulimaPail {
+    interface CustomMeta<L> {
+      /** File information where the log was called from */
+      file: {
+        /** Column number in the source file */
+        column: number | undefined;
+        /** Line number in the source file */
+        line: number | undefined;
+        /** Name/path of the source file */
+        name: string | undefined;
+      } | undefined;
     }
+  }
 }
 /**
- * Caller Processor.
- *
- * A processor that adds file location information to log metadata.
- * Uses stack trace analysis to determine the file, line, and column
- * where the log call originated from.
- * @template L - The log level type
- * @example
- * ```typescript
- * import { createPail } from "@visulima/pail";
- * import CallerProcessor from "@visulima/pail/processor/caller";
- *
- * const logger = createPail({
- *   processors: [new CallerProcessor()]
- * });
- *
- * logger.info("This log will include file location info");
- * // Result includes: file: { name: "...", line: 123, column: 45 }
- * ```
- */
+* Caller Processor.
+*
+* A processor that adds file location information to log metadata.
+* Uses stack trace analysis to determine the file, line, and column
+* where the log call originated from.
+* @template L - The log level type
+* @example
+* ```typescript
+* import { createPail } from "@visulima/pail";
+* import CallerProcessor from "@visulima/pail/processor/caller";
+*
+* const logger = createPail({
+*   processors: [new CallerProcessor()]
+* });
+*
+* logger.info("This log will include file location info");
+* // Result includes: file: { name: "...", line: 123, column: 45 }
+* ```
+*/
 declare class CallerProcessor<L extends string = string> implements Processor<L> {
-    /**
-     * Processes log metadata to add caller file information.
-     *
-     * Analyzes the call stack to determine the file location where the log
-     * was called from and adds this information to the metadata.
-     * @param meta The log metadata to process
-     * @returns The processed metadata with file location information added
-     */
-    process(meta: Meta<L>): Meta<L>;
+  /**
+  * Processes log metadata to add caller file information.
+  *
+  * Analyzes the call stack to determine the file location where the log
+  * was called from and adds this information to the metadata.
+  * @param meta The log metadata to process
+  * @returns The processed metadata with file location information added
+  */
+  process(meta: Meta<L>): Meta<L>;
 }
-export default CallerProcessor;
+export { CallerProcessor as default };

package/dist/processor/environment-processor.d.ts

@@ -1,124 +1,124 @@
-import type { Meta, Processor } from "../types.d.ts";
+import { M as Meta, P as Processor } from "../packem_shared/types.d-BeLumqgD.js";
+import '@visulima/colorize';
+import '@visulima/interactive-manager';
 /**
- * Detected environment information.
- *
- * Contains runtime environment details that are automatically detected
- * from environment variables and process information.
- */
+* Detected environment information.
+*
+* Contains runtime environment details that are automatically detected
+* from environment variables and process information.
+*/
 interface EnvironmentInfo {
-    /** Git commit hash or short SHA */
-    commit?: string;
-    /** Runtime environment (e.g., "production", "development", "test") */
-    environment?: string;
-    /** Hostname of the machine */
-    hostname?: string;
-    /** Process ID */
-    pid?: number;
-    /** Cloud region (e.g., "us-east-1") */
-    region?: string;
-    /** Application/service name */
-    service?: string;
-    /** Application version */
-    version?: string;
+  /** Git commit hash or short SHA */
+  commit?: string;
+  /** Runtime environment (e.g., "production", "development", "test") */
+  environment?: string;
+  /** Hostname of the machine */
+  hostname?: string;
+  /** Process ID */
+  pid?: number;
+  /** Cloud region (e.g., "us-east-1") */
+  region?: string;
+  /** Application/service name */
+  service?: string;
+  /** Application version */
+  version?: string;
 }
 /**
- * Environment processor configuration options.
- */
+* Environment processor configuration options.
+*/
 interface EnvironmentProcessorOptions {
-    /**
-     * Whether to include the hostname. Defaults to false.
-     */
-    includeHostname?: boolean;
-    /**
-     * Whether to include the process ID. Defaults to false.
-     */
-    includePid?: boolean;
-    /**
-     * Static environment info to use instead of or in addition to auto-detection.
-     * Values provided here take precedence over auto-detected values.
-     */
-    overrides?: Partial<EnvironmentInfo>;
+  /**
+  * Whether to include the hostname. Defaults to false.
+  */
+  includeHostname?: boolean;
+  /**
+  * Whether to include the process ID. Defaults to false.
+  */
+  includePid?: boolean;
+  /**
+  * Static environment info to use instead of or in addition to auto-detection.
+  * Values provided here take precedence over auto-detected values.
+  */
+  overrides?: Partial<EnvironmentInfo>;
 }
 /**
- * Detects the runtime environment from environment variables.
- *
- * Checks common environment variable patterns used by various hosting
- * platforms (Vercel, AWS, GCP, Heroku, Railway, Fly.io, Render, etc.)
- * to automatically determine service name, version, environment, region,
- * and commit hash.
- * @returns Detected environment information
- */
+* Detects the runtime environment from environment variables.
+*
+* Checks common environment variable patterns used by various hosting
+* platforms (Vercel, AWS, GCP, Heroku, Railway, Fly.io, Render, etc.)
+* to automatically determine service name, version, environment, region,
+* and commit hash.
+* @returns Detected environment information
+*/
 declare const detectEnvironment: () => EnvironmentInfo;
 /**
- * Environment Enrichment Processor.
- *
- * Inspired by evlog's automatic environment detection, this processor
- * enriches log metadata with runtime environment information. It auto-detects
- * details like service name, version, environment, region, and commit hash
- * from common environment variables used by popular hosting platforms.
- *
- * The detected info is added to the log's context, making it easier to
- * correlate logs across services and deployments in production.
- * @template L - The log level type
- * @example
- * ```typescript
- * import { createPail } from "@visulima/pail";
- * import EnvironmentProcessor from "@visulima/pail/processor/environment";
- *
- * const logger = createPail({
- *   processors: [
- *     new EnvironmentProcessor({
- *       overrides: { service: "my-api" },
- *       includePid: true,
- *     }),
- *   ],
- * });
- *
- * logger.info("Server started");
- * // Log metadata will include: { __env: { service: "my-api", environment: "production", ... } }
- * ```
- * @example
- * ```typescript
- * // With static configuration only (no auto-detection)
- * new EnvironmentProcessor({
- *   overrides: {
- *     service: "payment-service",
- *     version: "2.1.0",
- *     environment: "staging",
- *   },
- * });
- * ```
- */
+* Environment Enrichment Processor.
+*
+* Inspired by evlog's automatic environment detection, this processor
+* enriches log metadata with runtime environment information. It auto-detects
+* details like service name, version, environment, region, and commit hash
+* from common environment variables used by popular hosting platforms.
+*
+* The detected info is added to the log's context, making it easier to
+* correlate logs across services and deployments in production.
+* @template L - The log level type
+* @example
+* ```typescript
+* import { createPail } from "@visulima/pail";
+* import EnvironmentProcessor from "@visulima/pail/processor/environment";
+*
+* const logger = createPail({
+*   processors: [
+*     new EnvironmentProcessor({
+*       overrides: { service: "my-api" },
+*       includePid: true,
+*     }),
+*   ],
+* });
+*
+* logger.info("Server started");
+* // Log metadata will include: { __env: { service: "my-api", environment: "production", ... } }
+* ```
+* @example
+* ```typescript
+* // With static configuration only (no auto-detection)
+* new EnvironmentProcessor({
+*   overrides: {
+*     service: "payment-service",
+*     version: "2.1.0",
+*     environment: "staging",
+*   },
+* });
+* ```
+*/
 declare class EnvironmentProcessor<L extends string = string> implements Processor<L> {
-    #private;
-    /**
-     * Creates a new EnvironmentProcessor instance.
-     *
-     * Auto-detects environment information on construction and merges
-     * with any provided overrides. Undefined values in overrides are
-     * filtered out so they don't overwrite detected values.
-     * @param options Processor configuration options
-     */
-    constructor(options?: EnvironmentProcessorOptions);
-    /**
-     * Processes log metadata to add environment information.
-     *
-     * Adds a `__env` property to the meta containing detected and
-     * configured environment details. Each call receives a shallow
-     * clone of the environment info to prevent cross-record mutation.
-     * @param meta The log metadata to process
-     * @returns The processed metadata with environment info added
-     */
-    process(meta: Meta<L>): Meta<L>;
-    /**
-     * Returns the detected environment information.
-     *
-     * Useful for inspecting what environment details were auto-detected.
-     * Returns a shallow clone to prevent external mutation.
-     * @returns The environment information object
-     */
-    getEnvironmentInfo(): Readonly<EnvironmentInfo>;
+  #private;
+  /**
+  * Creates a new EnvironmentProcessor instance.
+  *
+  * Auto-detects environment information on construction and merges
+  * with any provided overrides. Undefined values in overrides are
+  * filtered out so they don't overwrite detected values.
+  * @param options Processor configuration options
+  */
+  constructor(options?: EnvironmentProcessorOptions);
+  /**
+  * Processes log metadata to add environment information.
+  *
+  * Adds a `__env` property to the meta containing detected and
+  * configured environment details. Each call receives a shallow
+  * clone of the environment info to prevent cross-record mutation.
+  * @param meta The log metadata to process
+  * @returns The processed metadata with environment info added
+  */
+  process(meta: Meta<L>): Meta<L>;
+  /**
+  * Returns the detected environment information.
+  *
+  * Useful for inspecting what environment details were auto-detected.
+  * Returns a shallow clone to prevent external mutation.
+  * @returns The environment information object
+  */
+  getEnvironmentInfo(): Readonly<EnvironmentInfo>;
 }
-export { detectEnvironment };
-export default EnvironmentProcessor;
-export type { EnvironmentInfo, EnvironmentProcessorOptions };
+export { type EnvironmentInfo, type EnvironmentProcessorOptions, EnvironmentProcessor as default, detectEnvironment };

package/dist/processor/environment-processor.js

@@ -14,18 +14,11 @@ const detectEnvironment = () => {
     // PID
     pid: process.pid,
     // Region (including GCP Cloud Functions FUNCTION_REGION and GOOGLE_CLOUD_REGION)
-    region: env.AWS_REGION || env.VERCEL_REGION || env.FLY_REGION || env.RENDER_REGION || env.CF_REGION || env.GOOGLE_CLOUD_REGION || // GCP general
-    env.FUNCTION_REGION || // GCP Cloud Functions
-    void 0,
+    region: env.AWS_REGION || env.VERCEL_REGION || env.FLY_REGION || env.RENDER_REGION || env.CF_REGION || env.GOOGLE_CLOUD_REGION || env.FUNCTION_REGION || void 0,
     // Service name - check common platform variables (including GCP Cloud Run / App Engine)
-    service: env.SERVICE_NAME || env.APP_NAME || env.K_SERVICE || // GCP Cloud Run
-    env.GAE_SERVICE || // GCP App Engine
-    env.FUNCTION_TARGET || // GCP Cloud Functions
-    env.VERCEL_PROJECT_PRODUCTION_URL || env.FLY_APP_NAME || env.RAILWAY_SERVICE_NAME || env.RENDER_SERVICE_NAME || env.HEROKU_APP_NAME || void 0,
+    service: env.SERVICE_NAME || env.APP_NAME || env.K_SERVICE || env.GAE_SERVICE || env.FUNCTION_TARGET || env.VERCEL_PROJECT_PRODUCTION_URL || env.FLY_APP_NAME || env.RAILWAY_SERVICE_NAME || env.RENDER_SERVICE_NAME || env.HEROKU_APP_NAME || void 0,
     // Version (including GCP Cloud Run K_REVISION and App Engine GAE_VERSION)
-    version: env.APP_VERSION || env.npm_package_version || env.K_REVISION || // GCP Cloud Run revision
-    env.GAE_VERSION || // GCP App Engine version
-    env.RAILWAY_GIT_COMMIT_SHA?.slice(0, 7) || env.RENDER_GIT_COMMIT?.slice(0, 7) || void 0
+    version: env.APP_VERSION || env.npm_package_version || env.K_REVISION || env.GAE_VERSION || env.RAILWAY_GIT_COMMIT_SHA?.slice(0, 7) || env.RENDER_GIT_COMMIT?.slice(0, 7) || void 0
     /* eslint-enable @typescript-eslint/no-unnecessary-condition, @typescript-eslint/prefer-nullish-coalescing */
   };
   return Object.fromEntries(Object.entries(info).filter(([, v]) => v !== void 0));

package/dist/processor/message-formatter-processor.d.ts

@@ -1,52 +1,54 @@
-import type { FormatterFunction } from "@visulima/fmt";
-import type { Meta, StringifyAwareProcessor } from "../types.d.ts";
+import { M as Meta, b as StringifyAwareProcessor } from "../packem_shared/types.d-BeLumqgD.js";
+import '@visulima/colorize';
+import '@visulima/interactive-manager';
+type FormatterFunction = (argument: any) => string;
 /**
- * Message Formatter Processor.
- *
- * A processor that formats log messages using the {@link https://visulima.com/packages/fmt/|@visulima/fmt} library.
- * Supports custom formatters, string interpolation, and complex object formatting.
- * Processes both the main message and contextual data.
- * @template L - The log level type
- * @example
- * ```typescript
- * import { createPail } from "@visulima/pail";
- * import MessageFormatterProcessor from "@visulima/pail/processor/message-formatter";
- *
- * const logger = createPail({
- *   processors: [new MessageFormatterProcessor({
- *     formatters: {
- *       user: (value) => `[USER:${value.id}]`
- *     }
- *   })]
- * });
- *
- * logger.info("User {user} logged in", { user: { id: 123 } });
- * // Output: "User [USER:123] logged in"
- * ```
- */
+* Message Formatter Processor.
+*
+* A processor that formats log messages using the {@link https://visulima.com/packages/fmt/|@visulima/fmt} library.
+* Supports custom formatters, string interpolation, and complex object formatting.
+* Processes both the main message and contextual data.
+* @template L - The log level type
+* @example
+* ```typescript
+* import { createPail } from "@visulima/pail";
+* import MessageFormatterProcessor from "@visulima/pail/processor/message-formatter";
+*
+* const logger = createPail({
+*   processors: [new MessageFormatterProcessor({
+*     formatters: {
+*       user: (value) => `[USER:${value.id}]`
+*     }
+*   })]
+* });
+*
+* logger.info("User {user} logged in", { user: { id: 123 } });
+* // Output: "User [USER:123] logged in"
+* ```
+*/
 declare class MessageFormatterProcessor<L extends string = string> implements StringifyAwareProcessor<L> {
-    #private;
-    /**
-     * Creates a new MessageFormatterProcessor instance.
-     * @param options Configuration options
-     * @param options.formatters Custom formatters for message interpolation
-     */
-    constructor(options?: {
-        formatters?: Record<string, FormatterFunction>;
-    });
-    /**
-     * Sets the stringify function for object serialization.
-     * @param function_ The stringify function to use for serializing objects
-     */
-    setStringify(function_: typeof JSON.stringify): void;
-    /**
-     * Processes log metadata to format messages.
-     *
-     * Applies string interpolation and custom formatters to the message
-     * and contextual data in the log metadata.
-     * @param meta The log metadata to process
-     * @returns The processed metadata with formatted messages
-     */
-    process(meta: Meta<L>): Meta<L>;
+  #private;
+  /**
+  * Creates a new MessageFormatterProcessor instance.
+  * @param options Configuration options
+  * @param options.formatters Custom formatters for message interpolation
+  */
+  constructor(options?: {
+    formatters?: Record<string, FormatterFunction>;
+  });
+  /**
+  * Sets the stringify function for object serialization.
+  * @param function_ The stringify function to use for serializing objects
+  */
+  setStringify(function_: typeof JSON.stringify): void;
+  /**
+  * Processes log metadata to format messages.
+  *
+  * Applies string interpolation and custom formatters to the message
+  * and contextual data in the log metadata.
+  * @param meta The log metadata to process
+  * @returns The processed metadata with formatted messages
+  */
+  process(meta: Meta<L>): Meta<L>;
 }
-export default MessageFormatterProcessor;
+export { MessageFormatterProcessor as default };

package/dist/processor/message-formatter-processor.js

@@ -322,7 +322,7 @@ const parseCss = (cssString) => {
   }
   return css;
 };
-const cssToAnsi = (css, previousCss = null) => {
+const cssToAnsi = (css, previousCss) => {
   previousCss = previousCss ?? getDefaultCss();
   let ansi = "";
   if (!colorEquals(css.backgroundColor, previousCss.backgroundColor)) {
@@ -499,7 +499,7 @@ const format = (fmt, arguments_ = [], options = {}) => {
   let a = 1 - offset;
   let lastPosition = -1;
   let usedStyle = false;
-  let previousCss = null;
+  let previousCss;
   for (let index = 0; index < fmt.length; ) {
     if (fmt.codePointAt(index) === CHAR_PERCENT && index + 1 < fmt.length) {
       lastPosition = lastPosition > -1 ? lastPosition : 0;

package/dist/processor/opentelemetry-processor.d.ts

@@ -1,70 +1,73 @@
-import type { Meta, Processor } from "../types.d.ts";
+import { M as Meta, P as Processor } from "../packem_shared/types.d-BeLumqgD.js";
+import '@visulima/colorize';
+import '@visulima/interactive-manager';
 /**
- * Configuration options for the OpenTelemetry processor.
- */
-export interface OpenTelemetryProcessorOptions {
-    /**
-     * Field name for the span ID. Defaults to 'span_id'
-     */
-    spanIdFieldName?: string;
-    /**
-     * If specified, all trace fields will be nested under this key
-     */
-    traceFieldName?: string;
-    /**
-     * Field name for the trace flags. Defaults to 'trace_flags'
-     */
-    traceFlagsFieldName?: string;
-    /**
-     * Field name for the trace ID. Defaults to 'trace_id'
-     */
-    traceIdFieldName?: string;
+* Configuration options for the OpenTelemetry processor.
+*/
+interface OpenTelemetryProcessorOptions {
+  /**
+  * Field name for the span ID. Defaults to 'span_id'
+  */
+  spanIdFieldName?: string;
+  /**
+  * If specified, all trace fields will be nested under this key
+  */
+  traceFieldName?: string;
+  /**
+  * Field name for the trace flags. Defaults to 'trace_flags'
+  */
+  traceFlagsFieldName?: string;
+  /**
+  * Field name for the trace ID. Defaults to 'trace_id'
+  */
+  traceIdFieldName?: string;
 }
 /**
- * OpenTelemetry Processor.
- *
- * A processor that adds OpenTelemetry trace context to log metadata.
- * Extracts trace ID, span ID, and trace flags from the active OpenTelemetry span
- * and adds them to the log context for distributed tracing correlation.
- * @template L - The log level type
- * @example
- * ```typescript
- * import { createPail } from "@visulima/pail";
- * import { OpenTelemetryProcessor } from "@visulima/pail/processor/opentelemetry";
- *
- * const logger = createPail({
- *   processors: [new OpenTelemetryProcessor()]
- * });
- *
- * logger.info("Processing request");
- * // Context includes: { trace_id: "...", span_id: "...", trace_flags: "01" }
- * ```
- * @example
- * ```typescript
- * // With custom field names
- * const logger = createPail({
- *   processors: [new OpenTelemetryProcessor({
- *     traceFieldName: "trace",
- *     traceIdFieldName: "traceId",
- *     spanIdFieldName: "spanId"
- *   })]
- * });
- * ```
- */
-export declare class OpenTelemetryProcessor<L extends string = string> implements Processor<L> {
-    #private;
-    /**
-     * Creates a new OpenTelemetryProcessor instance.
-     * @param options Configuration options for field names and nesting
-     */
-    constructor(options?: OpenTelemetryProcessorOptions);
-    /**
-     * Processes log metadata to add OpenTelemetry trace context.
-     *
-     * Extracts trace information from the active OpenTelemetry span and adds it
-     * to the log context. If no valid span is found, the metadata is returned unchanged.
-     * @param meta The log metadata to process
-     * @returns The processed metadata with trace context added
-     */
-    process(meta: Meta<L>): Meta<L>;
+* OpenTelemetry Processor.
+*
+* A processor that adds OpenTelemetry trace context to log metadata.
+* Extracts trace ID, span ID, and trace flags from the active OpenTelemetry span
+* and adds them to the log context for distributed tracing correlation.
+* @template L - The log level type
+* @example
+* ```typescript
+* import { createPail } from "@visulima/pail";
+* import { OpenTelemetryProcessor } from "@visulima/pail/processor/opentelemetry";
+*
+* const logger = createPail({
+*   processors: [new OpenTelemetryProcessor()]
+* });
+*
+* logger.info("Processing request");
+* // Context includes: { trace_id: "...", span_id: "...", trace_flags: "01" }
+* ```
+* @example
+* ```typescript
+* // With custom field names
+* const logger = createPail({
+*   processors: [new OpenTelemetryProcessor({
+*     traceFieldName: "trace",
+*     traceIdFieldName: "traceId",
+*     spanIdFieldName: "spanId"
+*   })]
+* });
+* ```
+*/
+declare class OpenTelemetryProcessor<L extends string = string> implements Processor<L> {
+  #private;
+  /**
+  * Creates a new OpenTelemetryProcessor instance.
+  * @param options Configuration options for field names and nesting
+  */
+  constructor(options?: OpenTelemetryProcessorOptions);
+  /**
+  * Processes log metadata to add OpenTelemetry trace context.
+  *
+  * Extracts trace information from the active OpenTelemetry span and adds it
+  * to the log context. If no valid span is found, the metadata is returned unchanged.
+  * @param meta The log metadata to process
+  * @returns The processed metadata with trace context added
+  */
+  process(meta: Meta<L>): Meta<L>;
 }
+export { OpenTelemetryProcessor, OpenTelemetryProcessorOptions };