@visulima/pail 3.0.3 → 3.2.0

package/dist/packem_shared/{types-RidvA4RN.d.ts → types-D3ycu8-x.d.ts}

@@ -1,32 +1,6 @@
 import { AnsiColors } from '@visulima/colorize';
 import { LiteralUnion, Primitive } from 'type-fest';
-
-declare class InteractiveStreamHook {
-    #private;
-    static readonly DRAIN = true;
-    constructor(stream: NodeJS.WriteStream);
-    active(): void;
-    erase(count: number): void;
-    inactive(separateHistory?: boolean): void;
-    renew(): void;
-    write(message: string): void;
-}
-
-type StreamType = "stderr" | "stdout";
-declare class InteractiveManager {
-    #private;
-    constructor(stdout: InteractiveStreamHook, stderr: InteractiveStreamHook);
-    get lastLength(): number;
-    get outside(): number;
-    get isHooked(): boolean;
-    get isSuspended(): boolean;
-    erase(stream: StreamType, count?: number): void;
-    hook(): boolean;
-    resume(stream: StreamType, eraseRowCount?: number): void;
-    suspend(stream: StreamType, erase?: boolean): void;
-    unhook(separateHistory?: boolean): boolean;
-    update(stream: StreamType, rows: string[], from?: number): void;
-}
+import { InteractiveManager } from '../interactive/index.js';
 
 declare global {
     namespace VisulimaPail {
@@ -118,5 +92,4 @@ type Message = {
     suffix?: string;
 };
 
-export { InteractiveManager as I };
-export type { ConstructorOptions as C, DefaultLoggerTypes as D, ExtendedRfc5424LogLevels as E, LoggerConfiguration as L, Meta as M, Processor as P, Reporter as R, StreamAwareReporter as S, DefaultLogTypes as a, LoggerFunction as b, LoggerTypesAwareReporter as c, LoggerTypesConfig as d, ServerConstructorOptions as e, StringifyAwareProcessor as f, StringifyAwareReporter as g, ReadonlyMeta as h, InteractiveStreamReporter as i };
+export type { ConstructorOptions as C, DefaultLoggerTypes as D, ExtendedRfc5424LogLevels as E, InteractiveStreamReporter as I, LoggerConfiguration as L, Meta as M, Processor as P, Reporter as R, StreamAwareReporter as S, DefaultLogTypes as a, LoggerFunction as b, LoggerTypesAwareReporter as c, LoggerTypesConfig as d, ReadonlyMeta as e, StringifyAwareReporter as f, ServerConstructorOptions as g, StringifyAwareProcessor as h };

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

@@ -0,0 +1,14 @@
+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

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

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

@@ -1,6 +1,7 @@
-import { P as Processor, M as Meta } from '../../packem_shared/types-RidvA4RN.js';
+import { P as Processor, M as Meta } from '../../packem_shared/types-D3ycu8-x.js';
 import '@visulima/colorize';
 import 'type-fest';
+import '../../interactive/index.js';
 
 declare global {
     namespace VisulimaPail {

package/dist/processor/caller/caller-processor.js

@@ -1 +1,59 @@
-var u=Object.defineProperty;var n=(a,e)=>u(a,"name",{value:e,configurable:!0});var m=Object.defineProperty,o=n((a,e)=>m(a,"name",{value:e,configurable:!0}),"u");const c=o(()=>{const a=Error.prepareStackTrace;try{let e=[];Error.prepareStackTrace=(i,r)=>{const t=r.slice(1);return e=t,t};const l=e.reduce((i,r)=>(r.isNative()||r.getFileName()?.includes("pail/dist")||i.push({columnNumber:r.getColumnNumber(),fileName:r.getFileName()??void 0,lineNumber:r.getLineNumber()}),i),[])[0];return l?{columnNumber:l.columnNumber??void 0,fileName:l.fileName,lineNumber:l.lineNumber??void 0}:{fileName:"anonymous",lineNumber:void 0}}finally{Error.prepareStackTrace=a}},"getCallerFilename");var s=Object.defineProperty,N=n((a,e)=>s(a,"name",{value:e,configurable:!0}),"r");class f{static{n(this,"a")}static{N(this,"CallerProcessor")}process(e){const{columnNumber:l,fileName:i,lineNumber:r}=c();return e.file={column:l,line:r,name:i},e}}export{f as default};
+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 };

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

@@ -1,6 +1,7 @@
-import { f as StringifyAwareProcessor, M as Meta } from '../packem_shared/types-RidvA4RN.js';
+import { h as StringifyAwareProcessor, M as Meta } from '../packem_shared/types-D3ycu8-x.js';
 import '@visulima/colorize';
 import 'type-fest';
+import '../interactive/index.js';
 
 type FormatterFunction = (argument: any) => string;
 

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

@@ -1 +1,67 @@
-var f=Object.defineProperty;var n=(o,t)=>f(o,"name",{value:t,configurable:!0});import{G as c}from"../packem_shared/index-D9hWq9ka.js";var y=Object.defineProperty,a=n((o,t)=>y(o,"name",{value:t,configurable:!0}),"s");class p{static{n(this,"p")}static{a(this,"MessageFormatterProcessor")}#t;#e;constructor(t={}){this.#e=t.formatters}setStringify(t){this.#t=t}process(t){const e=c({formatters:this.#e,stringify:a(s=>{const r=this.#t(s);return r===void 0?(console.warn(`Unable to stringify value of type ${typeof s}`,s),"undefined"):r},"stringify")});return t.message!==void 0&&(t.message=this.#s(e,t.message,t.context??[])),t}#s(t,e,s=[]){if(typeof e=="string")return t(e,s);if(typeof e=="object"&&e!==null)for(const r in e){const i=e[r];(typeof i=="string"||Array.isArray(i)||typeof i=="object")&&(e[r]=this.#s(t,i,s))}return e}}export{p as default};
+import { b as build } from '../packem_shared/index-BomQ3E6J.js';
+
+class MessageFormatterProcessor {
+  /** Custom stringify function for object serialization */
+  #stringify;
+  /** Custom formatters for message interpolation */
+  #formatters;
+  /**
+   * Creates a new MessageFormatterProcessor instance.
+   * @param options Configuration options
+   * @param options.formatters Custom formatters for message interpolation
+   */
+  constructor(options = {}) {
+    this.#formatters = options.formatters;
+  }
+  /**
+   * Sets the stringify function for object serialization.
+   * @param function_ The stringify function to use for serializing objects
+   */
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+  setStringify(function_) {
+    this.#stringify = function_;
+  }
+  /**
+   * 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) {
+    const formatter = build({
+      formatters: this.#formatters});
+    if (meta.message !== void 0) {
+      meta.message = this.#format(formatter, meta.message, meta.context ?? []);
+    }
+    return meta;
+  }
+  /**
+   * Recursively formats data using the formatter.
+   *
+   * Applies string interpolation and formatting to strings, arrays, and objects.
+   * @param formatter The formatter function to use
+   * @param data The data to format (string, array, or object)
+   * @param arguments_ Additional arguments for formatting
+   * @returns The formatted data
+   * @private
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  #format(formatter, data, arguments_ = []) {
+    if (typeof data === "string") {
+      return formatter(data, arguments_);
+    }
+    if (typeof data === "object" && data !== null) {
+      for (const index in data) {
+        const value = data[index];
+        if (typeof value === "string" || Array.isArray(value) || typeof value === "object") {
+          data[index] = this.#format(formatter, value, arguments_);
+        }
+      }
+    }
+    return data;
+  }
+}
+
+export { MessageFormatterProcessor as default };

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

@@ -0,0 +1,19 @@
+import { P as Processor, M as Meta } from '../packem_shared/types-D3ycu8-x.js';
+import '@visulima/colorize';
+import 'type-fest';
+import '../interactive/index.js';
+
+interface OpenTelemetryProcessorOptions {
+    spanIdFieldName?: string;
+    traceFieldName?: string;
+    traceFlagsFieldName?: string;
+    traceIdFieldName?: string;
+}
+declare class OpenTelemetryProcessor<L extends string = string> implements Processor<L> {
+    #private;
+    constructor(options?: OpenTelemetryProcessorOptions);
+    process(meta: Meta<L>): Meta<L>;
+}
+
+export { OpenTelemetryProcessor };
+export type { OpenTelemetryProcessorOptions };

package/dist/processor/opentelemetry-processor.js

@@ -0,0 +1,52 @@
+import { trace, context, isSpanContextValid } from '@opentelemetry/api';
+
+class OpenTelemetryProcessor {
+  /** Field name for trace ID */
+  #traceIdField;
+  /** Field name for span ID */
+  #spanIdField;
+  /** Field name for trace flags */
+  #traceFlagsField;
+  /** Optional field name to nest all trace fields under */
+  #traceFieldName;
+  /**
+   * Creates a new OpenTelemetryProcessor instance.
+   * @param options Configuration options for field names and nesting
+   */
+  constructor(options = {}) {
+    this.#traceIdField = options.traceIdFieldName || "trace_id";
+    this.#spanIdField = options.spanIdFieldName || "span_id";
+    this.#traceFlagsField = options.traceFlagsFieldName || "trace_flags";
+    this.#traceFieldName = options.traceFieldName;
+  }
+  /**
+   * 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) {
+    const span = trace.getSpan(context.active());
+    if (!span) {
+      return meta;
+    }
+    const spanContext = span.spanContext();
+    if (!isSpanContextValid(spanContext)) {
+      return meta;
+    }
+    const fields = {
+      [this.#spanIdField]: spanContext.spanId,
+      [this.#traceFlagsField]: `0${spanContext.traceFlags.toString(16)}`,
+      [this.#traceIdField]: spanContext.traceId
+    };
+    const traceData = this.#traceFieldName ? {
+      [this.#traceFieldName]: fields
+    } : fields;
+    meta.context = [...meta.context || [], traceData];
+    return meta;
+  }
+}
+
+export { OpenTelemetryProcessor };

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

@@ -1,7 +1,8 @@
 import { Rules, RedactOptions } from '@visulima/redact';
-import { P as Processor, M as Meta } from '../packem_shared/types-RidvA4RN.js';
+import { P as Processor, M as Meta } from '../packem_shared/types-D3ycu8-x.js';
 import '@visulima/colorize';
 import 'type-fest';
+import '../interactive/index.js';
 
 declare class RedactProcessor<L extends string = string> implements Processor<L> {
     #private;

package/dist/processor/redact-processor.js

@@ -1 +1,30 @@
-var o=Object.defineProperty;var s=(t,r)=>o(t,"name",{value:r,configurable:!0});import{redact as c,standardRules as i}from"@visulima/redact";var n=Object.defineProperty,u=s((t,r)=>n(t,"name",{value:r,configurable:!0}),"r");class l{static{s(this,"a")}static{u(this,"RedactProcessor")}#r;constructor(r,e){this.#r=a=>c(a,r||i,e)}process(r){return r.message=this.#r(r.message),r.context=this.#r(r.context),r.error=this.#r(r.error),r}}export{l as default};
+import { redact, standardRules } from '@visulima/redact';
+
+class RedactProcessor {
+  /** The redact function configured with custom rules and options */
+  #redact;
+  /**
+   * Creates a new RedactProcessor instance.
+   * @param rules Custom redaction rules (uses standardRules if not provided)
+   * @param options Additional redaction options
+   */
+  constructor(rules, options) {
+    this.#redact = (input) => redact(input, rules || standardRules, options);
+  }
+  /**
+   * Processes log metadata to redact sensitive information.
+   *
+   * Applies redaction rules to the message, context, and error properties
+   * in the log metadata to prevent sensitive data from being logged.
+   * @param meta The log metadata to process
+   * @returns The processed metadata with sensitive data redacted
+   */
+  process(meta) {
+    meta.message = this.#redact(meta.message);
+    meta.context = this.#redact(meta.context);
+    meta.error = this.#redact(meta.error);
+    return meta;
+  }
+}
+
+export { RedactProcessor as default };

package/dist/progress-bar.d.ts

@@ -0,0 +1,76 @@
+import { InteractiveManager } from './interactive/index.js';
+
+type ProgressBarStyle = "shades_classic" | "shades_grey" | "rect" | "filled" | "solid" | "ascii" | "custom";
+interface ProgressBarOptions {
+    barCompleteChar?: string | string[];
+    barGlue?: string;
+    barIncompleteChar?: string | string[];
+    current?: number;
+    format?: string;
+    fps?: number;
+    style?: ProgressBarStyle;
+    total: number;
+    width?: number;
+}
+interface SingleBarOptions extends ProgressBarOptions {
+    format?: string;
+}
+interface MultiBarOptions {
+    barCompleteChar?: string | string[];
+    barGlue?: string;
+    barIncompleteChar?: string | string[];
+    composite?: boolean;
+    format?: string;
+    fps?: number;
+    style?: ProgressBarStyle;
+}
+interface ProgressBarPayload {
+    [key: string]: string | number | boolean;
+}
+declare const getBarChar: (char: string | undefined, style: ProgressBarStyle, complete?: boolean) => string;
+declare const applyStyleToOptions: <T extends ProgressBarOptions | MultiBarOptions>(options: T) => T;
+declare class ProgressBar {
+    protected options: ProgressBarOptions;
+    protected current: number;
+    private startTime;
+    private interactiveManager?;
+    private isActive;
+    private payload?;
+    constructor(options: ProgressBarOptions, interactiveManager?: InteractiveManager, payload?: ProgressBarPayload);
+    update(current: number, payload?: ProgressBarPayload): void;
+    increment(step?: number, payload?: ProgressBarPayload): void;
+    render(): string;
+    start(total?: number, startValue?: number, payload?: ProgressBarPayload): void;
+    stop(): void;
+    private calculateETA;
+}
+declare class MultiBarInstance extends ProgressBar {
+    private multiBar;
+    constructor(multiBar: MultiProgressBar, options: ProgressBarOptions, payload?: ProgressBarPayload);
+    update(current: number, payload?: ProgressBarPayload): void;
+    getBarState(): {
+        char: string;
+        current: number;
+        total: number;
+    };
+}
+declare class MultiProgressBar {
+    private bars;
+    private options;
+    private interactiveManager?;
+    private isActive;
+    private nextBarId;
+    private composite;
+    private barColors;
+    constructor(options?: MultiBarOptions, interactiveManager?: InteractiveManager);
+    create(total: number, current?: number, payload?: ProgressBarPayload): ProgressBar;
+    remove(bar: ProgressBar): boolean;
+    renderAll(): void;
+    setBarColor(bar: MultiBarInstance, color: ((text: string) => string) | undefined): void;
+    stop(): void;
+    private renderComposite;
+    private getCompositeChar;
+}
+
+export { MultiBarInstance, MultiProgressBar, ProgressBar, applyStyleToOptions, getBarChar };
+export type { MultiBarOptions, ProgressBarOptions, ProgressBarPayload, ProgressBarStyle, SingleBarOptions };