@visulima/pail 4.0.0-alpha.8 → 4.0.0

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

@@ -0,0 +1 @@
+const o=new Set(["alert","critical","emergency","error"]),n=r=>{const e=console;return o.has(r)?e.__error??console.error:r==="warning"?e.__warn??console.warn:r==="trace"?e.__trace??console.trace:e.__log??console.log};export{n as t};

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

@@ -0,0 +1 @@
+const a=new Set(["alert","critical","emergency","error","trace","warning"]),e=t=>a.has(t),c=(t,r)=>(r.__write??r.write.bind(r)).call(r,t);export{c as a,e as r};

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

@@ -1,54 +1,57 @@
-import type { Meta, Processor } from "../../types.d.ts";
+import { M as Meta, P as Processor } from "../../packem_shared/types.d-bWnqHJKL.js";
+import '@visulima/colorize';
+import '@visulima/interactive-manager';
+import 'type-fest';
 /**
- * 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/caller/caller-processor.js

@@ -1,59 +1 @@
-const getCallerFilename = () => {
-  const errorStack = Error.prepareStackTrace;
-  try {
-    let result = [];
-    Error.prepareStackTrace = (_error, stack) => {
-      const callSitesWithoutCurrent = stack.slice(1);
-      result = callSitesWithoutCurrent;
-      return callSitesWithoutCurrent;
-    };
-    const callers = result.reduce((accumulator, x) => {
-      if (x.isNative() || x.getFileName()?.includes("pail/dist")) {
-        return accumulator;
-      }
-      accumulator.push({
-        columnNumber: x.getColumnNumber(),
-        fileName: x.getFileName() ?? void 0,
-        lineNumber: x.getLineNumber()
-      });
-      return accumulator;
-    }, []);
-    const firstExternalFilePath = callers[0];
-    if (firstExternalFilePath) {
-      return {
-        columnNumber: firstExternalFilePath.columnNumber ?? void 0,
-        fileName: firstExternalFilePath.fileName,
-        lineNumber: firstExternalFilePath.lineNumber ?? void 0
-      };
-    }
-    return {
-      fileName: "anonymous",
-      lineNumber: void 0
-    };
-  } finally {
-    Error.prepareStackTrace = errorStack;
-  }
-};
-
-class CallerProcessor {
-  /**
-   * 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
-   */
-  // eslint-disable-next-line class-methods-use-this
-  process(meta) {
-    const { columnNumber, fileName, lineNumber } = getCallerFilename();
-    meta.file = {
-      column: columnNumber,
-      line: lineNumber,
-      name: fileName
-    };
-    return meta;
-  }
-}
-
-export { CallerProcessor as default };
+const u=()=>{const i=Error.prepareStackTrace;try{let l=[];Error.prepareStackTrace=(n,e)=>{const m=e.slice(1);return l=m,m};const r=l.reduce((n,e)=>(e.isNative()||e.getFileName()?.includes("pail/dist")||n.push({columnNumber:e.getColumnNumber(),fileName:e.getFileName()??void 0,lineNumber:e.getLineNumber()}),n),[]).at(0);return r?{columnNumber:r.columnNumber??void 0,fileName:r.fileName,lineNumber:r.lineNumber??void 0}:{fileName:"anonymous",lineNumber:void 0}}finally{Error.prepareStackTrace=i}};class a{process(l){const{columnNumber:r,fileName:n,lineNumber:e}=u();return l.file={column:r,line:e,name:n},l}}export{a as default};

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

@@ -1,124 +1,125 @@
-import type { Meta, Processor } from "../types.d.ts";
+import { M as Meta, P as Processor } from "../packem_shared/types.d-bWnqHJKL.js";
+import '@visulima/colorize';
+import '@visulima/interactive-manager';
+import 'type-fest';
 /**
- * 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

@@ -1,78 +1 @@
-const detectEnvironment = () => {
-  if (!process.env) {
-    return {};
-  }
-  const { env } = process;
-  const info = {
-    // Commit hash
-    commit: env.COMMIT_SHA || env.GIT_COMMIT || env.VERCEL_GIT_COMMIT_SHA?.slice(0, 7) || env.RAILWAY_GIT_COMMIT_SHA?.slice(0, 7) || env.RENDER_GIT_COMMIT?.slice(0, 7) || env.HEROKU_SLUG_COMMIT?.slice(0, 7) || env.CF_PAGES_COMMIT_SHA?.slice(0, 7) || void 0,
-    // Environment / Node env
-    environment: env.NODE_ENV || env.ENVIRONMENT || env.APP_ENV || void 0,
-    // Hostname
-    hostname: env.HOSTNAME || env.HOST || void 0,
-    // 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 || 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 || 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 || env.GAE_VERSION || env.RAILWAY_GIT_COMMIT_SHA?.slice(0, 7) || env.RENDER_GIT_COMMIT?.slice(0, 7) || void 0
-  };
-  return Object.fromEntries(Object.entries(info).filter(([, v]) => v !== void 0));
-};
-class EnvironmentProcessor {
-  #envInfo;
-  /**
-   * 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 = {}) {
-    const detected = detectEnvironment();
-    const cleanOverrides = {};
-    if (options.overrides) {
-      for (const [key, value] of Object.entries(options.overrides)) {
-        if (value !== void 0) {
-          cleanOverrides[key] = value;
-        }
-      }
-    }
-    const merged = { ...detected, ...cleanOverrides };
-    if (!options.includePid && cleanOverrides.pid === void 0) {
-      delete merged.pid;
-    }
-    if (!options.includeHostname && cleanOverrides.hostname === void 0) {
-      delete merged.hostname;
-    }
-    this.#envInfo = merged;
-  }
-  /**
-   * 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) {
-    const enriched = { ...meta, envStorage: { ...this.#envInfo } };
-    return enriched;
-  }
-  /**
-   * 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() {
-    return { ...this.#envInfo };
-  }
-}
-
-export { EnvironmentProcessor as default, detectEnvironment };
+const O=()=>{if(!process.env)return{};const{env:e}=process,E={commit:e.COMMIT_SHA||e.GIT_COMMIT||e.VERCEL_GIT_COMMIT_SHA?.slice(0,7)||e.RAILWAY_GIT_COMMIT_SHA?.slice(0,7)||e.RENDER_GIT_COMMIT?.slice(0,7)||e.HEROKU_SLUG_COMMIT?.slice(0,7)||e.CF_PAGES_COMMIT_SHA?.slice(0,7)||void 0,environment:e.NODE_ENV||e.ENVIRONMENT||e.APP_ENV||void 0,hostname:e.HOSTNAME||e.HOST||void 0,pid:process.pid,region:e.AWS_REGION||e.VERCEL_REGION||e.FLY_REGION||e.RENDER_REGION||e.CF_REGION||e.GOOGLE_CLOUD_REGION||e.FUNCTION_REGION||void 0,service:e.SERVICE_NAME||e.APP_NAME||e.K_SERVICE||e.GAE_SERVICE||e.FUNCTION_TARGET||e.VERCEL_PROJECT_PRODUCTION_URL||e.FLY_APP_NAME||e.RAILWAY_SERVICE_NAME||e.RENDER_SERVICE_NAME||e.HEROKU_APP_NAME||void 0,version:e.APP_VERSION||e.npm_package_version||e.K_REVISION||e.GAE_VERSION||e.RAILWAY_GIT_COMMIT_SHA?.slice(0,7)||e.RENDER_GIT_COMMIT?.slice(0,7)||void 0};return Object.fromEntries(Object.entries(E).filter(([,i])=>i!==void 0))};class R{#e;constructor(E={}){const i=O(),_={};if(E.overrides){const t=Object.entries(E.overrides);for(let o=0;o<t.length;o+=1){const[n,I]=t[o];I!==void 0&&(_[n]=I)}}const s={...i,..._};!E.includePid&&_.pid===void 0&&delete s.pid,!E.includeHostname&&_.hostname===void 0&&delete s.hostname,this.#e=s}process(E){return{...E,envStorage:{...this.#e}}}getEnvironmentInfo(){return{...this.#e}}}export{R as default,O as detectEnvironment};

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

@@ -1,52 +1,62 @@
-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-bWnqHJKL.js";
+import '@visulima/colorize';
+import '@visulima/interactive-manager';
+import 'type-fest';
 /**
- * Message Formatter Processor.
- *
- * A processor that formats log messages using the {@link https://www.visulima.com/docs/package/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"
- * ```
- */
+* A custom specifier formatter: receives the matched argument and returns its string form.
+*/
+type FormatterFunction = (argument: any) => string;
+/**
+* Internal map of custom formatters keyed by the specifier character's codepoint, as produced by
+* {@link build}.
+*/
+/**
+* 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 };