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

package/dist/middleware/next/storage.d.ts

@@ -1,14 +0,0 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-import type { WideEvent } from "../../wide-event.d.ts";
-/**
- * AsyncLocalStorage instance used to propagate the WideEvent logger
- * through Next.js server actions, route handlers, and server components.
- */
-export declare const pailStorage: AsyncLocalStorage<WideEvent>;
-/**
- * Retrieve the request-scoped WideEvent logger from AsyncLocalStorage.
- * Must be called within a `withPail()` wrapped handler or server action.
- * @returns The request-scoped WideEvent logger
- * @throws Error if called outside of a withPail context
- */
-export declare const useLogger: () => WideEvent;

package/dist/middleware/shared/create-middleware-logger.d.ts

@@ -1,82 +0,0 @@
-import type { PailBrowserImpl } from "../../pail.d.ts";
-import type { DefaultLogTypes, LoggerFunction } from "../../types.d.ts";
-import type { WideEventFinishOptions } from "../../wide-event.d.ts";
-import { WideEvent } from "../../wide-event.d.ts";
-import type { RouteConfig } from "./routes.d.ts";
-/**
- * A pail instance with dynamically generated log methods.
- */
-type PailLike<T extends string = string> = PailBrowserImpl<T> & Record<DefaultLogTypes | T, LoggerFunction>;
-/**
- * Base options shared by all framework middleware adapters.
- * @template T - Custom logger type names from the pail instance
- */
-export interface PailMiddlewareOptions<T extends string = string> {
-    /**
-     * Glob patterns for paths to exclude from logging.
-     * Exclusions take precedence over inclusions.
-     * @example ["/health", "/api/_internal/**"]
-     */
-    exclude?: string[];
-    /**
-     * Glob patterns for paths to include in logging.
-     * If not set, all non-excluded paths are logged.
-     * @example ["/api/**"]
-     */
-    include?: string[];
-    /**
-     * The pail logger instance to use for wide event emission.
-     */
-    pail: PailLike<T>;
-    /**
-     * Route-specific configuration. Maps glob patterns to config.
-     * First matching route wins.
-     * @example { "/api/auth/**": { service: "auth-service" } }
-     */
-    routes?: Record<string, RouteConfig>;
-    /**
-     * Default service name for all wide events.
-     * Can be overridden per-route via `routes`.
-     */
-    service?: string;
-}
-/**
- * Result of creating a middleware logger for a request.
- */
-export interface MiddlewareLoggerResult {
-    /**
-     * Finalize and emit the wide event. Sets status/error before emitting.
-     * Safe to call multiple times — only the first call emits.
-     */
-    finish: (options?: WideEventFinishOptions) => void;
-    /**
-     * The request-scoped WideEvent logger.
-     * Use `set()`, `info()`, `warn()`, `error()`, `debug()` to accumulate context.
-     */
-    logger: WideEvent;
-    /**
-     * Whether this request was skipped (excluded from logging).
-     * When true, `logger` and `finish` should not be used.
-     */
-    skipped: boolean;
-}
-/**
- * Core factory function used by all framework middleware adapters.
- *
- * Creates a WideEvent for the given request, checks route inclusion/exclusion,
- * resolves the service name, and returns a logger + finish callback.
- * @param options Middleware options including pail instance and route config
- * @param request Request metadata for the current HTTP request
- * @param request.headers Safe headers extracted from the request
- * @param request.method The HTTP method (GET, POST, etc.)
- * @param request.path The URL path of the request
- * @param request.requestId A unique identifier for this request
- * @returns A result object with logger, finish callback, and skipped flag
- */
-export declare const createMiddlewareLogger: <T extends string = string>(options: PailMiddlewareOptions<T>, request: {
-    headers?: Record<string, string>;
-    method: string;
-    path: string;
-    requestId: string;
-}) => MiddlewareLoggerResult;
-export {};

package/dist/middleware/shared/headers.d.ts

@@ -1,14 +0,0 @@
-/**
- * Extract safe headers from a Web API Headers object, filtering out
- * sensitive headers like Authorization, Cookie, and API keys.
- * @param headers Web API Headers object
- * @returns Plain object of safe header key-value pairs
- */
-export declare const extractSafeHeaders: (headers: Headers) => Record<string, string>;
-/**
- * Extract safe headers from a Node.js IncomingHttpHeaders object,
- * filtering out sensitive headers.
- * @param headers Node.js IncomingHttpHeaders-like object
- * @returns Plain object of safe header key-value pairs
- */
-export declare const extractSafeNodeHeaders: (headers: Record<string, string | string[] | undefined>) => Record<string, string>;

package/dist/middleware/shared/routes.d.ts

@@ -1,30 +0,0 @@
-/**
- * Check if a path matches a glob pattern.
- */
-export declare const matchesPattern: (path: string, pattern: string) => boolean;
-/**
- * Route configuration for a specific path pattern.
- */
-export interface RouteConfig {
-    /** Override the service name for requests matching this route. */
-    service?: string;
-}
-/**
- * Determine whether a request path should be logged based on include/exclude patterns.
- *
- * - Exclusions take precedence over inclusions.
- * - If no include patterns are provided, all non-excluded paths are logged.
- * @param path The request path
- * @param include Glob patterns of paths to include
- * @param exclude Glob patterns of paths to exclude
- * @returns Whether the path should be logged
- */
-export declare const shouldLog: (path: string, include?: string[], exclude?: string[]) => boolean;
-/**
- * Get the service name override for a given path based on route configuration.
- * Returns the first matching route's service name, or undefined if no match.
- * @param path The request path
- * @param routes Route configuration map (pattern → config)
- * @returns The service name override, or undefined
- */
-export declare const getServiceForPath: (path: string, routes?: Record<string, RouteConfig>) => string | undefined;

package/dist/middleware/shared/storage.d.ts

@@ -1,29 +0,0 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-import type { WideEvent } from "../../wide-event.d.ts";
-/**
- * Create an isolated AsyncLocalStorage instance and a `useLogger` accessor
- * for retrieving the request-scoped WideEvent from anywhere in the call stack.
- *
- * Each framework adapter should call this once at module level to get its own
- * isolated storage instance.
- * @param contextHint A description of the expected context, used in the
- * error message when `useLogger` is called outside of a request scope.
- * @returns An object with `storage` and `useLogger`
- * @example
- * ```typescript
- * const { storage, useLogger } = createLoggerStorage(
- *   "Express middleware context. Make sure evlog middleware is registered."
- * );
- *
- * // In middleware:
- * storage.run(wideEvent, () => next());
- *
- * // In handler:
- * const log = useLogger();
- * log.set({ user: { id: 1 } });
- * ```
- */
-export declare const createLoggerStorage: (contextHint: string) => {
-    storage: AsyncLocalStorage<WideEvent>;
-    useLogger: () => WideEvent;
-};

package/dist/packem_shared/InteractiveManager-CowYA3Hx.js

@@ -1,178 +0,0 @@
-import { t as terminalSize, w as wordWrap, W as WrapMode } from './index-BEfVUy9P.js';
-
-class InteractiveManager {
-  #stream;
-  #isActive = false;
-  #isSuspended = false;
-  #lastLength = 0;
-  #outside = 0;
-  /**
-   * Creates a new InteractiveManager with the given stream hooks.
-   * @param stdout Hook for stdout stream
-   * @param stderr Hook for stderr stream
-   */
-  constructor(stdout, stderr) {
-    this.#stream = {
-      stderr,
-      stdout
-    };
-  }
-  /**
-   * Last printed rows count.
-   *
-   * Tracks the number of rows that were last written to the terminal.
-   * Used internally for managing cursor positioning and output updates.
-   */
-  get lastLength() {
-    return this.#lastLength;
-  }
-  /**
-   * Rows count outside editable area.
-   *
-   * Tracks the number of rows that extend beyond the current terminal height.
-   * Used for managing scrolling and ensuring all output remains visible.
-   */
-  get outside() {
-    return this.#outside;
-  }
-  /**
-   * Hook activity status.
-   *
-   * Indicates whether the interactive hooks are currently active.
-   * When true, streams are being intercepted for interactive output.
-   */
-  get isHooked() {
-    return this.#isActive;
-  }
-  /**
-   * Suspend status for active hooks.
-   *
-   * Indicates whether interactive mode is temporarily suspended.
-   * When suspended, external output can be written without interference.
-   */
-  get isSuspended() {
-    return this.#isSuspended;
-  }
-  /**
-   * Removes lines from the terminal output.
-   *
-   * Erases the specified number of lines from the bottom of the output,
-   * moving the cursor up and clearing the lines. Useful for removing
-   * previous interactive output before displaying new content.
-   * @param stream The stream to erase lines from ("stdout" or "stderr")
-   * @param count Number of lines to remove (defaults to lastLength)
-   * @throws {TypeError} If the specified stream is not available
-   */
-  erase(stream, count = this.#lastLength) {
-    this.#stream[stream].erase(count);
-  }
-  /**
-   * Hook stdout and stderr streams.
-   * @returns Success status
-   */
-  hook() {
-    if (!this.#isActive) {
-      const hooks = Object.values(this.#stream);
-      for (let i = 0; i < hooks.length; i += 1) {
-        hooks[i].active();
-      }
-      this.#clear(true);
-    }
-    return this.#isActive;
-  }
-  /**
-   * Resume suspend hooks.
-   * @param stream Stream to resume
-   * @param eraseRowCount erase output rows count
-   */
-  resume(stream, eraseRowCount) {
-    if (this.#isSuspended) {
-      this.#isSuspended = false;
-      if (eraseRowCount) {
-        this.erase(stream, eraseRowCount);
-      }
-      this.#lastLength = 0;
-      const hooks = Object.values(this.#stream);
-      for (let i = 0; i < hooks.length; i += 1) {
-        hooks[i].active();
-      }
-    }
-  }
-  /**
-   * Suspend active hooks for external output.
-   * @param stream Stream to suspend
-   * @param erase erase output
-   */
-  suspend(stream, erase = true) {
-    if (!this.#isSuspended) {
-      this.#isSuspended = true;
-      if (erase) {
-        this.erase(stream);
-      }
-      const hooks = Object.values(this.#stream);
-      for (let i = 0; i < hooks.length; i += 1) {
-        hooks[i].renew();
-      }
-    }
-  }
-  /**
-   * Unhooks both stdout and stderr streams and print their story of logs.
-   * @param separateHistory If `true`, will add an empty line to the history output for individual recorded lines and console logs
-   * @returns Success status
-   */
-  unhook(separateHistory = true) {
-    if (this.#isActive) {
-      const hooks = Object.values(this.#stream);
-      for (let i = 0; i < hooks.length; i += 1) {
-        hooks[i].inactive(separateHistory);
-      }
-      this.#clear();
-    }
-    return !this.#isActive;
-  }
-  /**
-   * Update output.
-   * @param stream Stream to write to
-   * @param rows Text lines to write to standard output
-   * @param from Index of the line starting from which the contents of the terminal are being overwritten
-   */
-  update(stream, rows, from = 0) {
-    if (rows.length > 0) {
-      const hook = this.#stream[stream];
-      const { columns: width, rows: height } = terminalSize();
-      const position = from > height ? height - 1 : Math.max(0, Math.min(height - 1, from));
-      const actualLength = this.lastLength - position;
-      const outside = Math.max(actualLength - height, this.outside);
-      let output = rows.reduce(
-        (accumulator, row) => [
-          ...accumulator,
-          wordWrap(row, {
-            trim: false,
-            width,
-            wrapMode: WrapMode.STRICT_WIDTH
-          })
-        ],
-        []
-      );
-      if (height <= actualLength) {
-        hook.erase(height);
-        if (position < outside) {
-          output = output.slice(outside - position + 1);
-        }
-      } else if (actualLength) {
-        hook.erase(actualLength);
-      }
-      hook.write(`${output.join("\n")}
-`);
-      this.#lastLength = outside ? outside + output.length + 1 : output.length;
-      this.#outside = Math.max(this.lastLength - height, this.outside);
-    }
-  }
-  #clear(status = false) {
-    this.#isActive = status;
-    this.#lastLength = 0;
-    this.#outside = 0;
-  }
-}
-
-export { InteractiveManager as default };

package/dist/packem_shared/InteractiveStreamHook-BypRlYTX.js

@@ -1,133 +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 {
-  StringDecoder
-} = __cjs_getBuiltinModule("node:string_decoder");
-
-const ESC = "\x1B[";
-const eraseLine = `${ESC}2K`;
-const cursorLeft = `${ESC}G`;
-const cursorUp = (count = 1) => `${ESC}${String(count)}A`;
-const cursorHide = `${ESC}?25l`;
-const cursorShow = `${ESC}?25h`;
-const eraseLines = (count) => {
-  let clear = "";
-  for (let index = 0; index < count; index++) {
-    clear += eraseLine + (index < count - 1 ? cursorUp() : "");
-  }
-  if (count) {
-    clear += cursorLeft;
-  }
-  return clear;
-};
-
-class InteractiveStreamHook {
-  /** Constant indicating the stream write operation was successful */
-  static DRAIN = true;
-  #decoder = new StringDecoder();
-  #history = [];
-  #method;
-  #stream;
-  /**
-   * Creates a new InteractiveStreamHook for the given stream.
-   * @param stream The Node.js WriteStream to hook into (usually stdout or stderr)
-   */
-  constructor(stream) {
-    this.#method = stream.write.bind(stream);
-    this.#stream = stream;
-  }
-  /**
-   * Activates the stream hook.
-   *
-   * When active, all writes to the stream are captured in history instead of
-   * being written immediately. This allows for interactive features like
-   * progress bars that can update dynamically.
-   */
-  active() {
-    this.write(cursorHide);
-    this.#stream.write = (data, ...arguments_) => {
-      const callback = arguments_.at(-1);
-      this.#history.push(
-        // prettier-ignore
-        this.#decoder.write(
-          typeof data === "string" ? Buffer.from(data, typeof arguments_[0] === "string" ? arguments_[0] : void 0) : Buffer.from(data)
-        )
-      );
-      if (typeof callback === "function") {
-        callback();
-      }
-      return InteractiveStreamHook.DRAIN;
-    };
-  }
-  /**
-   * Erases the specified number of lines from the terminal.
-   *
-   * Uses ANSI escape sequences to remove lines from the current cursor position
-   * upwards, which is useful for clearing previous output in interactive applications.
-   * @param count Number of lines to erase (including the current line)
-   */
-  erase(count) {
-    if (count > 0) {
-      this.write(eraseLines(count + 1));
-    }
-  }
-  /**
-   * Deactivates the stream hook and replays captured output.
-   *
-   * Restores normal stream operation and outputs all captured history.
-   * Optionally adds a newline separator before replaying the history.
-   * @param separateHistory Whether to add a newline before replaying history
-   */
-  inactive(separateHistory = false) {
-    if (this.#history.length > 0) {
-      if (separateHistory) {
-        this.write("\n");
-      }
-      this.#history.forEach((element) => {
-        this.write(element);
-      });
-      this.#history = [];
-    }
-    this.renew();
-  }
-  /**
-   * Renews the stream hook state.
-   *
-   * Restores the original stream write method and shows the cursor.
-   * This is typically called when temporarily suspending interactive mode.
-   */
-  renew() {
-    this.#stream.write = this.#method;
-    this.write(cursorShow);
-  }
-  /**
-   * Writes a message directly to the underlying stream.
-   *
-   * Bypasses the hook mechanism and writes directly using the original
-   * stream write method. Useful for writing control sequences or
-   * messages that should not be captured in history.
-   * @param message The message to write to the stream
-   */
-  write(message) {
-    this.#method.apply(this.#stream, [message]);
-  }
-}
-
-export { InteractiveStreamHook as default };