@visulima/pail 3.1.0 → 3.2.1

package/dist/index.server.js

@@ -1,2 +1,533 @@
-var y=Object.defineProperty;var n=(e,t)=>y(e,"name",{value:t,configurable:!0});import{createRequire as M}from"node:module";import S from"./packem_shared/InteractiveManager-CgmJyW9x.js";import{t as d,c as g}from"./packem_shared/interactive-stream-hook-CeVo4Kth.js";import{a as b}from"./packem_shared/pail.browser-BmHoDvEA.js";import{applyStyleToOptions as v,ProgressBar as I,MultiProgressBar as E}from"./progress-bar.js";import{getBarChar as nt}from"./progress-bar.js";import{a as f}from"./packem_shared/format-label-CpyyTBom.js";import{E as L}from"./packem_shared/constants-DKfCaSUR.js";import{n as R}from"./packem_shared/write-stream-CD8XFv1L.js";import{Spinner as j,MultiSpinner as T}from"./spinner.js";import O from"./processor/message-formatter-processor.js";import{PrettyReporter as B}from"./packem_shared/PrettyReporter-Bns0ZWLy.js";const z=M(import.meta.url),P=typeof globalThis<"u"&&typeof globalThis.process<"u"?globalThis.process:process,{stdout:w,stderr:m,env:o}=P;var C=Object.defineProperty,x=n((e,t)=>C(e,"name",{value:t,configurable:!0}),"c");class A{static{n(this,"v")}static{x(this,"RawReporter")}#t;#e;#r;#s=!1;#i;constructor(t={}){this.#t=w,this.#e=m,this.#i=t}setStdout(t){this.#t=t}setStderr(t){this.#e=t}setInteractiveManager(t){this.#r=t}setIsInteractive(t){this.#s=t}log(t){const{context:r,groups:c,message:i,type:h}=t,s=[];if(i!==L){const a=typeof i=="string"?i:f(i,this.#i);s.push(a)}r&&s.push(...r.map(a=>typeof a=="object"?` ${f(a,this.#i)}`:` ${a}`));const p=["error","trace","warn"].includes(h.level)?"stderr":"stdout",u=p==="stderr"?this.#e:this.#t,l=c.map(()=>"    ").join("");this.#s&&this.#r!==void 0&&u.isTTY?this.#r.update(p,(l+s.join("")).split(`
-`),0):R(l+s.join(""),u)}}var N=Object.defineProperty,$=n((e,t)=>N(e,"name",{value:t,configurable:!0}),"a");class D extends b{static{n(this,"m")}constructor(t){const{interactive:r,rawReporter:c,reporters:i,stderr:h,stdout:s,...p}=t;super(p),this.options=t,this.interactive=r??!1,this.stdout=s,this.stderr=h,this.interactive&&(this.interactiveManager=new S(new d(this.stdout),new d(this.stderr))),Array.isArray(i)&&this.registerReporters(i),this.rawReporter=this.extendReporter(t.rawReporter??new A)}static{$(this,"PailServerImpl")}stdout;stderr;interactiveManager;interactive;scope(...t){if(t.length===0)throw new Error("No scope name was defined.");return this.scopeName=t.flat(),this}getInteractiveManager(){return this.interactiveManager}wrapStd(){this.#t(this.stdout,"log"),this.#t(this.stderr,"log")}restoreStd(){this.#e(this.stdout),this.#e(this.stderr)}wrapAll(){this.wrapConsole(),this.wrapStd()}restoreAll(){this.restoreConsole(),this.restoreStd()}createProgressBar(t){if(!this.interactiveManager)throw new Error("Interactive mode is not enabled. Create Pail with { interactive: true } to use progress bars.");const r=v(t);return new I(r,this.interactiveManager)}createMultiProgressBar(t={}){if(!this.interactiveManager)throw new Error("Interactive mode is not enabled. Create Pail with { interactive: true } to use progress bars.");const r=v(t);return new E(r,this.interactiveManager)}createSpinner(t={}){if(!this.interactiveManager)throw new Error("Interactive mode is not enabled. Create Pail with { interactive: true } to use spinners.");return new j(t,this.interactiveManager)}createMultiSpinner(t={}){if(!this.interactiveManager)throw new Error("Interactive mode is not enabled. Create Pail with { interactive: true } to use spinners.");return new T(t,this.interactiveManager)}clear(){this.stdout.write(g),this.stderr.write(g)}extendReporter(t){return typeof t.setStdout=="function"&&t.setStdout(this.stdout),typeof t.setStderr=="function"&&t.setStderr(this.stderr),typeof t.setLoggerTypes=="function"&&t.setLoggerTypes(this.types),typeof t.setStringify=="function"&&t.setStringify(this.stringify),typeof t.setIsInteractive=="function"&&t.setIsInteractive(this.interactive),this.interactive&&typeof t.setInteractiveManager=="function"&&t.setInteractiveManager(this.interactiveManager),t}#t(t,r){t&&(t.__write||(t.__write=t.write),t.write=c=>{this[r](String(c).trim())})}#e(t){t&&t.__write&&(t.write=t.__write,delete t.__write)}}const V=D;var q=Object.defineProperty,_=n((e,t)=>q(e,"name",{value:t,configurable:!0}),"o");const G=_(()=>o.NODE_ENV==="debug"||o.DEBUG!==void 0?"debug":o.NODE_ENV==="test"?"warning":"informational","getDefaultLogLevel"),Y=_(e=>{let t=G();return o.PAIL_LOG_LEVEL!==void 0&&(t=o.PAIL_LOG_LEVEL),new V({logLevel:t,processors:[new O],reporters:[new B],stderr:m,stdout:w,...e})},"createPail"),rt=Y();export{E as MultiProgressBar,T as MultiSpinner,I as ProgressBar,j as Spinner,Y as createPail,nt as getBarChar,rt as pail};
+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 {
+  stdout,
+  stderr,
+  env
+} = __cjs_getProcess;
+import InteractiveManager from './packem_shared/InteractiveManager-CZ85hGNW.js';
+import { I as InteractiveStreamHook, c as clearTerminal } from './packem_shared/interactive-stream-hook-DG4BtN12.js';
+import { a as PailBrowserImpl, m as mergeTypes, b as arrayify } from './packem_shared/pail.browser-CPjQrsyy.js';
+import { ProgressBar, applyStyleToOptions, MultiProgressBar } from './progress-bar.js';
+export { getBarChar } from './progress-bar.js';
+import { i as inspect } from './packem_shared/format-label-Btft2KGP.js';
+import { E as EMPTY_SYMBOL } from './packem_shared/constants-DfDr4MHC.js';
+import { w as writeStream } from './packem_shared/write-stream-BG8fhcs3.js';
+import { Spinner, MultiSpinner } from './spinner.js';
+import { g as getLongestLabel } from './packem_shared/get-longest-label-C9PWeyKq.js';
+import MessageFormatterProcessor from './processor/message-formatter-processor.js';
+import { PrettyReporter } from './packem_shared/PrettyReporter-BFWaYP_J.js';
+
+class RawReporter {
+  #stdout;
+  #stderr;
+  #interactiveManager;
+  #interactive = false;
+  #inspectOptions;
+  constructor(inspectOptions = {}) {
+    this.#stdout = stdout;
+    this.#stderr = stderr;
+    this.#inspectOptions = inspectOptions;
+  }
+  setStdout(stdout_) {
+    this.#stdout = stdout_;
+  }
+  setStderr(stderr_) {
+    this.#stderr = stderr_;
+  }
+  setInteractiveManager(manager) {
+    this.#interactiveManager = manager;
+  }
+  setIsInteractive(interactive) {
+    this.#interactive = interactive;
+  }
+  log(meta) {
+    const { context, groups, message, type } = meta;
+    const items = [];
+    if (message !== EMPTY_SYMBOL) {
+      const formattedMessage = typeof message === "string" ? message : inspect(message, this.#inspectOptions);
+      items.push(formattedMessage);
+    }
+    if (context) {
+      items.push(
+        ...context.map((value) => {
+          if (typeof value === "object") {
+            return ` ${inspect(value, this.#inspectOptions)}`;
+          }
+          return ` ${value}`;
+        })
+      );
+    }
+    const streamType = ["error", "trace", "warn"].includes(type.level) ? "stderr" : "stdout";
+    const stream = streamType === "stderr" ? this.#stderr : this.#stdout;
+    const groupSpaces = groups.map(() => "    ").join("");
+    if (this.#interactive && this.#interactiveManager !== void 0 && stream.isTTY) {
+      this.#interactiveManager.update(streamType, (groupSpaces + items.join("")).split("\n"), 0);
+    } else {
+      writeStream(groupSpaces + items.join(""), stream);
+    }
+  }
+}
+
+class PailServerImpl extends PailBrowserImpl {
+  /**
+   * Creates a new Pail server logger instance.
+   *
+   * Initializes the server-compatible logger with streams, interactive support,
+   * and server-specific configuration options.
+   * @param options Server-specific configuration options
+   */
+  constructor(options) {
+    const parentStderr = options.parentStderr;
+    const parentStdout = options.parentStdout;
+    const { interactive, processors, rawReporter, reporters, stderr: optionsStderr, stdout: optionsStdout } = options;
+    const stderr = parentStderr ?? optionsStderr;
+    const stdout = parentStdout ?? optionsStdout;
+    const parentLongestLabel = options.parentLongestLabel;
+    const parentTypes = options.parentTypes;
+    const { parentLogLevels, parentMessages, parentStringify } = options;
+    const parentOptions = {
+      disabled: options.disabled,
+      logLevel: options.logLevel,
+      logLevels: options.logLevels,
+      messages: options.messages,
+      processors: [],
+      rawReporter: options.rawReporter,
+      reporters: [],
+      scope: options.scope,
+      throttle: options.throttle,
+      throttleMin: options.throttleMin
+    };
+    const hasTypesProperty = "types" in options;
+    if (parentTypes && parentLongestLabel && !hasTypesProperty) {
+      parentOptions.parentTypes = parentTypes;
+      parentOptions.parentLongestLabel = parentLongestLabel;
+    } else if (hasTypesProperty && options.types !== void 0) {
+      parentOptions.types = options.types;
+    }
+    if (parentStringify) {
+      parentOptions.parentStringify = parentStringify;
+    }
+    if (parentLogLevels && !options.logLevels) {
+      parentOptions.parentLogLevels = parentLogLevels;
+    }
+    if (parentMessages && !options.messages) {
+      parentOptions.parentMessages = parentMessages;
+    }
+    super(parentOptions);
+    this.options = options;
+    this.interactive = interactive ?? false;
+    this.stdout = stdout;
+    this.stderr = stderr;
+    if (this.interactive) {
+      this.interactiveManager = new InteractiveManager(new InteractiveStreamHook(this.stdout), new InteractiveStreamHook(this.stderr));
+    }
+    if (Array.isArray(reporters)) {
+      this.registerReporters(reporters);
+    }
+    this.rawReporter = this.extendReporter(rawReporter ?? new RawReporter());
+    if (Array.isArray(processors)) {
+      this.registerProcessors(processors);
+    }
+  }
+  stdout;
+  stderr;
+  interactiveManager;
+  interactive;
+  // @ts-expect-error - this returns a different type
+  scope(...name) {
+    if (name.length === 0) {
+      throw new Error("No scope name was defined.");
+    }
+    this.scopeName = name.flat();
+    return this;
+  }
+  /**
+   * 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
+   * ```
+   */
+  // @ts-expect-error - override signature differs due to server-specific options
+  child(options) {
+    const typesChanged = options?.types !== void 0 && options.types !== null;
+    const mergedTypes = typesChanged ? mergeTypes(this.types, options.types) : this.types;
+    const childReporters = options?.reporters ?? [];
+    const allReporters = childReporters.length > 0 ? [...this.reporters, ...childReporters] : [...this.reporters];
+    const childProcessors = options?.processors ?? [];
+    const allProcessors = childProcessors.length > 0 ? [...this.processors, ...childProcessors] : [...this.processors];
+    const mergedLogLevels = options?.logLevels ? { ...this.logLevels, ...options.logLevels } : this.logLevels;
+    let mergedScope;
+    if (options?.scope) {
+      const childScope = arrayify(options.scope).filter(Boolean);
+      mergedScope = this.scopeName.length > 0 ? [...this.scopeName, ...childScope] : childScope;
+    } else {
+      mergedScope = this.scopeName.length > 0 ? this.scopeName : [];
+    }
+    const mergedMessages = options?.messages ? {
+      timerEnd: this.endTimerMessage,
+      timerStart: this.startTimerMessage,
+      ...options.messages
+    } : {
+      timerEnd: this.endTimerMessage,
+      timerStart: this.startTimerMessage
+    };
+    const childOptions = {
+      disabled: options?.disabled ?? this.disabled,
+      interactive: options?.interactive ?? this.interactive,
+      logLevel: options?.logLevel ?? this.generalLogLevel,
+      logLevels: mergedLogLevels,
+      messages: mergedMessages,
+      processors: allProcessors,
+      rawReporter: options?.rawReporter ?? this.rawReporter,
+      reporters: allReporters,
+      scope: mergedScope,
+      stderr: options?.stderr ?? this.stderr,
+      stdout: options?.stdout ?? this.stdout,
+      throttle: options?.throttle ?? this.throttle,
+      throttleMin: options?.throttleMin ?? this.throttleMin
+    };
+    this.#assignParentValues(childOptions, options, typesChanged, mergedTypes);
+    return new PailServerImpl(childOptions);
+  }
+  /**
+   * Assigns parent values to child options for optimization.
+   *
+   * Reuses parent values when they haven't changed to avoid unnecessary recalculations.
+   */
+  /* eslint-disable no-param-reassign */
+  #assignParentValues(childOptions, options, typesChanged, mergedTypes) {
+    if (typesChanged) {
+      childOptions.parentTypes = mergedTypes;
+      childOptions.parentLongestLabel = getLongestLabel(mergedTypes);
+    } else {
+      childOptions.parentTypes = this.types;
+      childOptions.parentLongestLabel = this.longestLabel;
+    }
+    if (!options?.logLevels) {
+      childOptions.parentLogLevels = this.logLevels;
+    }
+    if (!options?.messages) {
+      childOptions.parentMessages = {
+        timerEnd: this.endTimerMessage,
+        timerStart: this.startTimerMessage
+      };
+    }
+    childOptions.parentStringify = this.stringify;
+    if (!options?.stdout) {
+      childOptions.parentStdout = this.stdout;
+    }
+    if (!options?.stderr) {
+      childOptions.parentStderr = this.stderr;
+    }
+  }
+  /* eslint-enable no-param-reassign */
+  /**
+   * Gets the interactive manager instance if interactive mode is enabled.
+   *
+   * Returns the InteractiveManager instance that handles interactive terminal
+   * features like progress bars and dynamic updates. Only available when
+   * interactive mode is enabled in the constructor options.
+   * @returns The interactive manager instance, or undefined if not in interactive mode
+   * @example
+   * ```typescript
+   * const logger = createPail({ interactive: true });
+   * const manager = logger.getInteractiveManager();
+   * if (manager) {
+   *   manager.hook();
+   *   // Use interactive features
+   *   manager.unhook();
+   * }
+   * ```
+   */
+  getInteractiveManager() {
+    return this.interactiveManager;
+  }
+  /**
+   * Wraps stdout and stderr streams to redirect them through the logger.
+   *
+   * Intercepts writes to process.stdout and process.stderr, redirecting them
+   * through the logger instead of writing directly to the streams. This allows
+   * all output to be processed by the logging pipeline.
+   * @example
+   * ```typescript
+   * const logger = createPail();
+   * logger.wrapStd();
+   *
+   * console.log("This goes through logger");
+   * process.stdout.write("This too");
+   *
+   * logger.restoreStd(); // Restore original streams
+   * ```
+   */
+  wrapStd() {
+    this.#wrapStream(this.stdout, "log");
+    this.#wrapStream(this.stderr, "log");
+  }
+  /**
+   * Restores the original stdout and stderr streams.
+   *
+   * Removes the stream wrapping that was applied by wrapStd(),
+   * restoring the original stream write methods.
+   * @example
+   * ```typescript
+   * const logger = createPail();
+   * logger.wrapStd();
+   * // Streams are wrapped
+   * logger.restoreStd();
+   * // Streams are restored to original behavior
+   * ```
+   */
+  restoreStd() {
+    this.#restoreStream(this.stdout);
+    this.#restoreStream(this.stderr);
+  }
+  /**
+   * Wraps all output sources (console and streams).
+   *
+   * Convenience method that calls both wrapConsole() and wrapStd()
+   * to redirect all output through the logger.
+   * @example
+   * ```typescript
+   * const logger = createPail();
+   * logger.wrapAll(); // Wraps console and streams
+   *
+   * // All output now goes through logger
+   * console.log("Console output");
+   * process.stdout.write("Stream output");
+   *
+   * logger.restoreAll(); // Restore everything
+   * ```
+   */
+  wrapAll() {
+    this.wrapConsole();
+    this.wrapStd();
+  }
+  /**
+   * Restores all wrapped output sources.
+   *
+   * Convenience method that calls both restoreConsole() and restoreStd()
+   * to restore all original output behavior.
+   * @example
+   * ```typescript
+   * const logger = createPail();
+   * logger.wrapAll();
+   * // All output is wrapped
+   * logger.restoreAll();
+   * // All output sources are restored
+   * ```
+   */
+  restoreAll() {
+    this.restoreConsole();
+    this.restoreStd();
+  }
+  /**
+   * Creates a single progress bar.
+   * @param options Configuration options for the progress bar
+   * @returns A new ProgressBar instance
+   * @example
+   * ```typescript
+   * const logger = createPail({ interactive: true });
+   * const bar = logger.createProgressBar({
+   *   total: 100,
+   *   format: 'Downloading [{bar}] {percentage}% | ETA: {eta}s | {value}/{total}'
+   * });
+   *
+   * bar.start();
+   * // ... do work and update progress
+   * bar.update(50);
+   * bar.stop();
+   * ```
+   */
+  createProgressBar(options) {
+    if (!this.interactiveManager) {
+      throw new Error("Interactive mode is not enabled. Create Pail with { interactive: true } to use progress bars.");
+    }
+    const styledOptions = applyStyleToOptions(options);
+    return new ProgressBar(styledOptions, this.interactiveManager);
+  }
+  /**
+   * Creates a multi-bar progress manager for displaying multiple progress bars.
+   * @param options Configuration options for the multi-bar manager
+   * @returns A new MultiProgressBar instance
+   * @example
+   * ```typescript
+   * const logger = createPail({ interactive: true });
+   * const multiBar = logger.createMultiProgressBar();
+   *
+   * const bar1 = multiBar.create(100);
+   * const bar2 = multiBar.create(200);
+   *
+   * bar1.start();
+   * bar2.start();
+   * // ... update bars as needed
+   * multiBar.stop();
+   * ```
+   */
+  createMultiProgressBar(options = {}) {
+    if (!this.interactiveManager) {
+      throw new Error("Interactive mode is not enabled. Create Pail with { interactive: true } to use progress bars.");
+    }
+    const styledOptions = applyStyleToOptions(options);
+    return new MultiProgressBar(styledOptions, this.interactiveManager);
+  }
+  /**
+   * Creates a single spinner.
+   * @param options Configuration options for the spinner
+   * @returns A new Spinner instance
+   * @example
+   * ```typescript
+   * const logger = createPail({ interactive: true });
+   * const spinner = logger.createSpinner({ name: 'dots' });
+   * spinner.start('Loading...');
+   * // ... do work
+   * spinner.succeed('Done');
+   * ```
+   */
+  createSpinner(options = {}) {
+    if (!this.interactiveManager) {
+      throw new Error("Interactive mode is not enabled. Create Pail with { interactive: true } to use spinners.");
+    }
+    return new Spinner(options, this.interactiveManager);
+  }
+  /**
+   * Creates a multi-spinner manager for displaying multiple spinners.
+   * @param options Configuration options for the multi-spinner manager
+   * @returns A new MultiSpinner instance
+   * @example
+   * ```typescript
+   * const logger = createPail({ interactive: true });
+   * const multiSpinner = logger.createMultiSpinner();
+   *
+   * const spinner1 = multiSpinner.create('Loading 1');
+   * const spinner2 = multiSpinner.create('Loading 2');
+   *
+   * spinner1.start();
+   * spinner2.start();
+   * // ... update spinners as needed
+   * multiSpinner.stop();
+   * ```
+   */
+  createMultiSpinner(options = {}) {
+    if (!this.interactiveManager) {
+      throw new Error("Interactive mode is not enabled. Create Pail with { interactive: true } to use spinners.");
+    }
+    return new MultiSpinner(options, this.interactiveManager);
+  }
+  /**
+   * Clears the terminal screen.
+   *
+   * Sends ANSI escape sequences to clear the terminal screen and move
+   * the cursor to the top-left position. This overrides the browser
+   * implementation to work with terminal streams.
+   * @example
+   * ```typescript
+   * const logger = createPail();
+   * logger.info("Some output");
+   * logger.clear(); // Clears the terminal screen
+   * ```
+   */
+  clear() {
+    this.stdout.write(clearTerminal);
+    this.stderr.write(clearTerminal);
+  }
+  extendReporter(reporter) {
+    if (typeof reporter.setStdout === "function") {
+      reporter.setStdout(this.stdout);
+    }
+    if (typeof reporter.setStderr === "function") {
+      reporter.setStderr(this.stderr);
+    }
+    if (typeof reporter.setLoggerTypes === "function") {
+      reporter.setLoggerTypes(this.types);
+    }
+    if (typeof reporter.setStringify === "function") {
+      reporter.setStringify(this.stringify);
+    }
+    if (typeof reporter.setIsInteractive === "function") {
+      reporter.setIsInteractive(this.interactive);
+    }
+    if (this.interactive && typeof reporter.setInteractiveManager === "function") {
+      reporter.setInteractiveManager(this.interactiveManager);
+    }
+    return reporter;
+  }
+  #wrapStream(stream, type) {
+    if (!stream) {
+      return;
+    }
+    if (!stream.__write) {
+      stream.__write = stream.write;
+    }
+    stream.write = (data) => {
+      this[type](String(data).trim());
+    };
+  }
+  // eslint-disable-next-line class-methods-use-this
+  #restoreStream(stream) {
+    if (!stream) {
+      return;
+    }
+    if (stream.__write) {
+      stream.write = stream.__write;
+      delete stream.__write;
+    }
+  }
+}
+const PailServer = PailServerImpl;
+
+const getDefaultLogLevel = () => {
+  if (env.NODE_ENV === "debug" || env.DEBUG !== void 0) {
+    return "debug";
+  }
+  if (env.NODE_ENV === "test") {
+    return "warning";
+  }
+  return "informational";
+};
+const createPail = (options) => {
+  let logLevel = getDefaultLogLevel();
+  if (env.PAIL_LOG_LEVEL !== void 0) {
+    logLevel = env.PAIL_LOG_LEVEL;
+  }
+  return new PailServer({
+    logLevel,
+    processors: [new MessageFormatterProcessor()],
+    reporters: [new PrettyReporter()],
+    stderr,
+    stdout,
+    ...options
+  });
+};
+const pail = createPail();
+
+export { MultiProgressBar, MultiSpinner, ProgressBar, Spinner, createPail, pail };

package/dist/interactive/index.d.ts

@@ -1,28 +1,2 @@
-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;
-}
-
-export { InteractiveManager, InteractiveStreamHook };
+export { default as InteractiveManager } from "./interactive-manager.d.ts";
+export { default as InteractiveStreamHook } from "./interactive-stream-hook.d.ts";

package/dist/interactive/index.js

@@ -1 +1,2 @@
-import{default as a}from"../packem_shared/InteractiveManager-CgmJyW9x.js";import{t as o}from"../packem_shared/interactive-stream-hook-CeVo4Kth.js";export{a as InteractiveManager,o as InteractiveStreamHook};
+export { default as InteractiveManager } from '../packem_shared/InteractiveManager-CZ85hGNW.js';
+export { I as InteractiveStreamHook } from '../packem_shared/interactive-stream-hook-DG4BtN12.js';

package/dist/interactive/interactive-manager.d.ts

@@ -0,0 +1,108 @@
+import type InteractiveStreamHook from "./interactive-stream-hook.d.ts";
+/** Supported stream types for interactive output */
+type StreamType = "stderr" | "stdout";
+/**
+ * Interactive Manager.
+ *
+ * Manages interactive terminal output by coordinating stdout and stderr streams.
+ * Enables features like progress bars, spinners, and dynamic updates by temporarily
+ * capturing and controlling terminal output. Supports suspending and resuming
+ * interactive mode for external output.
+ * @example
+ * ```typescript
+ * const manager = new InteractiveManager(stdoutHook, stderrHook);
+ *
+ * // Start interactive mode
+ * manager.hook();
+ *
+ * // Update output dynamically
+ * manager.update("stdout", ["Processing...", "50% complete"]);
+ *
+ * // Temporarily suspend for external output
+ * manager.suspend("stdout");
+ * console.log("External message");
+ * manager.resume("stdout");
+ *
+ * // End interactive mode and show final output
+ * manager.unhook();
+ * ```
+ */
+declare class InteractiveManager {
+    #private;
+    /**
+     * Creates a new InteractiveManager with the given stream hooks.
+     * @param stdout Hook for stdout stream
+     * @param stderr Hook for stderr stream
+     */
+    constructor(stdout: InteractiveStreamHook, stderr: InteractiveStreamHook);
+    /**
+     * 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(): number;
+    /**
+     * 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(): number;
+    /**
+     * Hook activity status.
+     *
+     * Indicates whether the interactive hooks are currently active.
+     * When true, streams are being intercepted for interactive output.
+     */
+    get isHooked(): boolean;
+    /**
+     * Suspend status for active hooks.
+     *
+     * Indicates whether interactive mode is temporarily suspended.
+     * When suspended, external output can be written without interference.
+     */
+    get isSuspended(): boolean;
+    /**
+     * 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: StreamType, count?: number): void;
+    /**
+     * Hook stdout and stderr streams.
+     * @returns Success status
+     */
+    hook(): boolean;
+    /**
+     * Resume suspend hooks.
+     * @param stream Stream to resume
+     * @param eraseRowCount erase output rows count
+     */
+    resume(stream: StreamType, eraseRowCount?: number): void;
+    /**
+     * Suspend active hooks for external output.
+     * @param stream Stream to suspend
+     * @param erase erase output
+     */
+    suspend(stream: StreamType, erase?: boolean): void;
+    /**
+     * 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?: boolean): boolean;
+    /**
+     * 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: StreamType, rows: string[], from?: number): void;
+}
+export default InteractiveManager;