@visulima/pail 3.1.0 → 3.2.0

package/dist/index.server.js

@@ -1,2 +1,535 @@
-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-CPDOE_d1.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;
+  }
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  setStdout(stdout_) {
+    this.#stdout = stdout_;
+  }
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  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.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/object-tree.js

@@ -1,2 +1,89 @@
-var O=Object.defineProperty;var y=(o,r)=>O(o,"name",{value:r,configurable:!0});var m=Object.defineProperty,a=y((o,r)=>m(o,"name",{value:r,configurable:!0}),"s");const j=a(o=>{const r={breakCircularWith:" (circular ref.)",joined:!0,keyNeighbour:"├─ ",keyNoNeighbour:"└─ ",renderFn:a(t=>{if(["boolean","number","string"].includes(typeof t))return String(t)},"renderFn"),separator:": ",sortFn:void 0,spacerNeighbour:"│  ",spacerNoNeighbour:"   ",...o};if(typeof r.joined!="boolean")throw new TypeError('Option "joined" must be a boolean');if(typeof r.spacerNoNeighbour!="string")throw new TypeError('Option "spacerNoNeighbour" must be a string');if(typeof r.spacerNeighbour!="string")throw new TypeError('Option "spacerNeighbour" must be a string');if(typeof r.keyNoNeighbour!="string")throw new TypeError('Option "keyNoNeighbour" must be a string');if(typeof r.keyNeighbour!="string")throw new TypeError('Option "keyNeighbour" must be a string');if(typeof r.separator!="string")throw new TypeError('Option "separator" must be a string');if(typeof r.renderFn!="function")throw new TypeError('Option "renderFn" must be a function');if(r.sortFn!==void 0&&typeof r.sortFn!="function")throw new TypeError('Option "sortFn" must be a function or undefined');if(r.breakCircularWith!==null&&typeof r.breakCircularWith!="string")throw new TypeError('Option "breakCircularWith" must be a string or null');return r},"buildContext"),T=a((o,r)=>{const t=j(r),s=[],b=t.renderFn(o);b!==void 0&&s.push(String(b));const l=a(e=>t.sortFn===void 0?e:e.toSorted((n,u)=>t?.sortFn?.(u,n)??0),"sort"),p=[],i=l(Object.keys(o)).map(e=>[e]),h=[o];for(;i.length>0;){const e=i.pop()??[],n=h[e.length-1][e[e.length-1]??""],u=t.breakCircularWith!==null&&h.slice(0,e.length).includes(n);p[e.length-1]=i.length>0&&(i[i.length-1]?.length??0)===e.length;const f=p.slice(0,e.length-1).map(g=>g?t.spacerNeighbour:t.spacerNoNeighbour).join(""),d=p[e.length-1]?t.keyNeighbour:t.keyNoNeighbour,N=e[e.length-1],c=t.renderFn(n),w=c===void 0?"":`${t.separator}${c}`,k=u?t.breakCircularWith:"";s.push(`${f}${d}${N}${w}${k}`),n!==null&&typeof n=="object"&&!Array.isArray(n)&&!u&&(i.push(...l(Object.keys(n)).map(g=>[...e,g])),h[e.length]=n)}return t.joined===!0?s.join(`
-`):s},"renderObjectTree");export{T as default,T as renderObjectTree};
+const buildContext = (options) => {
+  const context = {
+    breakCircularWith: " (circular ref.)",
+    joined: true,
+    keyNeighbour: "├─ ",
+    keyNoNeighbour: "└─ ",
+    renderFn: (node) => {
+      if (["boolean", "number", "string"].includes(typeof node)) {
+        return String(node);
+      }
+      return void 0;
+    },
+    separator: ": ",
+    sortFn: void 0,
+    spacerNeighbour: "│  ",
+    spacerNoNeighbour: "   ",
+    ...options
+  };
+  if (typeof context.joined !== "boolean") {
+    throw new TypeError('Option "joined" must be a boolean');
+  }
+  if (typeof context.spacerNoNeighbour !== "string") {
+    throw new TypeError('Option "spacerNoNeighbour" must be a string');
+  }
+  if (typeof context.spacerNeighbour !== "string") {
+    throw new TypeError('Option "spacerNeighbour" must be a string');
+  }
+  if (typeof context.keyNoNeighbour !== "string") {
+    throw new TypeError('Option "keyNoNeighbour" must be a string');
+  }
+  if (typeof context.keyNeighbour !== "string") {
+    throw new TypeError('Option "keyNeighbour" must be a string');
+  }
+  if (typeof context.separator !== "string") {
+    throw new TypeError('Option "separator" must be a string');
+  }
+  if (typeof context.renderFn !== "function") {
+    throw new TypeError('Option "renderFn" must be a function');
+  }
+  if (context.sortFn !== void 0 && typeof context.sortFn !== "function") {
+    throw new TypeError('Option "sortFn" must be a function or undefined');
+  }
+  if (context.breakCircularWith !== null && typeof context.breakCircularWith !== "string") {
+    throw new TypeError('Option "breakCircularWith" must be a string or null');
+  }
+  return context;
+};
+const renderObjectTree = (tree, options) => {
+  const context = buildContext(options);
+  const result = [];
+  const rootRendered = context.renderFn(tree);
+  if (rootRendered !== void 0) {
+    result.push(String(rootRendered));
+  }
+  const sort = (input) => {
+    if (context.sortFn === void 0) {
+      return input;
+    }
+    return input.toSorted((a, b) => context?.sortFn?.(b, a) ?? 0);
+  };
+  const neighbours = [];
+  const keys = sort(Object.keys(tree)).map((k) => [k]);
+  const lookup = [tree];
+  while (keys.length > 0) {
+    const key = keys.pop() ?? [];
+    const node = lookup[key.length - 1][key[key.length - 1] ?? ""];
+    const isCircular = context.breakCircularWith !== null && lookup.slice(0, key.length).includes(node);
+    neighbours[key.length - 1] = keys.length > 0 && (keys[keys.length - 1]?.length ?? 0) === key.length;
+    const indent = neighbours.slice(0, key.length - 1).map((n) => {
+      if (n) {
+        return context.spacerNeighbour;
+      }
+      return context.spacerNoNeighbour;
+    }).join("");
+    const connector = neighbours[key.length - 1] ? context.keyNeighbour : context.keyNoNeighbour;
+    const keyName = key[key.length - 1];
+    const nodeRendered = context.renderFn(node);
+    const value = nodeRendered === void 0 ? "" : `${context.separator}${nodeRendered}`;
+    const circular = isCircular ? context.breakCircularWith : "";
+    result.push(`${indent}${connector}${keyName}${value}${circular}`);
+    if (node !== null && typeof node === "object" && !Array.isArray(node) && !isCircular) {
+      keys.push(...sort(Object.keys(node)).map((k) => [...key, k]));
+      lookup[key.length] = node;
+    }
+  }
+  return context.joined === true ? result.join("\n") : result;
+};
+
+export { renderObjectTree as default, renderObjectTree };