@visulima/pail 4.0.0-alpha.3 → 4.0.0-alpha.5

package/dist/packem_shared/constants-B1RjD_ps.js

@@ -0,0 +1,99 @@
+const LOG_TYPES = {
+  alert: {
+    color: "red",
+    label: "alert",
+    logLevel: "alert"
+  },
+  await: {
+    color: "blue",
+    label: "awaiting",
+    logLevel: "informational"
+  },
+  complete: {
+    color: "cyan",
+    label: "complete",
+    logLevel: "informational"
+  },
+  critical: {
+    color: "redBright",
+    label: "critical",
+    logLevel: "critical"
+  },
+  debug: {
+    color: "gray",
+    label: "debug",
+    logLevel: "debug"
+  },
+  emergency: {
+    color: "redBright",
+    label: "emergency",
+    logLevel: "emergency"
+  },
+  error: {
+    color: "red",
+    label: "error",
+    logLevel: "error"
+  },
+  info: {
+    color: "blueBright",
+    label: "info",
+    logLevel: "informational"
+  },
+  log: {
+    label: "",
+    logLevel: "informational"
+  },
+  notice: {
+    color: "magentaBright",
+    label: "notice",
+    logLevel: "notice"
+  },
+  pending: {
+    color: "magenta",
+    label: "pending",
+    logLevel: "informational"
+  },
+  start: {
+    color: "greenBright",
+    label: "start",
+    logLevel: "informational"
+  },
+  stop: {
+    color: "red",
+    label: "stop",
+    logLevel: "informational"
+  },
+  success: {
+    color: "green",
+    label: "success",
+    logLevel: "informational"
+  },
+  trace: {
+    color: "cyanBright",
+    label: "trace",
+    logLevel: "trace"
+  },
+  wait: {
+    color: "blue",
+    label: "waiting",
+    logLevel: "informational"
+  },
+  warn: {
+    color: "yellow",
+    label: "warning",
+    logLevel: "warning"
+  },
+  warning: {
+    color: "yellow",
+    label: "warning",
+    logLevel: "warning"
+  },
+  watch: {
+    color: "yellowBright",
+    label: "watching",
+    logLevel: "informational"
+  }
+};
+const EMPTY_SYMBOL = /* @__PURE__ */ Symbol("EMPTY");
+
+export { EMPTY_SYMBOL as E, LOG_TYPES as L };

package/dist/packem_shared/getBarChar-BWj1UrH3.js

@@ -0,0 +1,404 @@
+const CHAR_GRADIENTS = {
+  default: ["█", "▓", "▒", "░"],
+  rect: ["▬", "▮", "▯", "▭"]
+};
+const BAR_REGEX = /\[([^[\]]*)\]/u;
+const getBarChar = (char, style, complete = true) => {
+  if (char) {
+    return char;
+  }
+  switch (style) {
+    case "ascii": {
+      return complete ? "#" : "-";
+    }
+    case "filled": {
+      return complete ? "█" : " ";
+    }
+    case "rect": {
+      return complete ? "▬" : "▭";
+    }
+    case "shades_classic": {
+      return complete ? "█" : "░";
+    }
+    case "shades_grey": {
+      return complete ? "▓" : "░";
+    }
+    case "solid": {
+      return complete ? "█" : " ";
+    }
+    default: {
+      return complete ? "█" : "░";
+    }
+  }
+};
+const applyStyleToOptions = (options) => {
+  if (!options.style) {
+    return options;
+  }
+  const { style } = options;
+  const result = { ...options };
+  if (result.barCompleteChar === void 0) {
+    result.barCompleteChar = getBarChar(void 0, style, true);
+  }
+  if (result.barIncompleteChar === void 0) {
+    result.barIncompleteChar = getBarChar(void 0, style, false);
+  }
+  if (result.barGlue === void 0) {
+    result.barGlue = "";
+  }
+  return result;
+};
+class ProgressBar {
+  options;
+  current;
+  startTime;
+  interactiveManager;
+  isActive = false;
+  payload;
+  /**
+   * Creates a new progress bar instance.
+   * @param options Configuration options for the progress bar
+   * @param interactiveManager Optional interactive manager for rendering
+   * @param payload Optional initial payload data for format placeholders
+   */
+  constructor(options, interactiveManager, payload) {
+    const isCompleteArray = Array.isArray(options.barCompleteChar);
+    const isIncompleteArray = Array.isArray(options.barIncompleteChar);
+    const isGradientMode = isCompleteArray || isIncompleteArray;
+    const completeChar = isCompleteArray ? options.barCompleteChar : getBarChar(options.barCompleteChar, "shades_classic");
+    const incompleteChar = isIncompleteArray ? options.barIncompleteChar : getBarChar(options.barIncompleteChar, "shades_classic", false);
+    this.options = {
+      barCompleteChar: completeChar,
+      barIncompleteChar: incompleteChar,
+      current: 0,
+      fps: 10,
+      width: 40,
+      ...options
+    };
+    if (isGradientMode) {
+      if (!Array.isArray(this.options.barCompleteChar)) {
+        this.options.barCompleteChar = [this.options.barCompleteChar];
+      }
+      if (!Array.isArray(this.options.barIncompleteChar)) {
+        this.options.barIncompleteChar = [this.options.barIncompleteChar];
+      }
+    }
+    this.current = this.options.current ?? 0;
+    this.startTime = Date.now();
+    this.interactiveManager = interactiveManager;
+    this.payload = payload;
+  }
+  /**
+   * Updates the progress bar to a new value.
+   * @param current The current progress value
+   * @param payload Optional payload data to merge with existing data
+   */
+  update(current, payload) {
+    this.current = Math.min(current, this.options.total);
+    if (payload) {
+      this.payload = { ...this.payload, ...payload };
+    }
+    if (this.interactiveManager && this.isActive) {
+      const progressBar = this.render();
+      this.interactiveManager.update("stdout", [progressBar]);
+    }
+  }
+  /**
+   * Increments the progress bar by a specified step.
+   * @param step Amount to increment (default: 1)
+   * @param payload Optional payload data to merge with existing data
+   */
+  increment(step = 1, payload) {
+    this.update(this.current + step, payload);
+  }
+  /**
+   * Renders the progress bar as a formatted string.
+   * @returns Formatted progress bar string with all placeholders replaced
+   */
+  // eslint-disable-next-line sonarjs/cognitive-complexity
+  render() {
+    const total = this.options.total > 0 ? this.options.total : 1;
+    const width = Math.max(0, this.options.width ?? 40);
+    const percentage = Math.max(0, Math.min(100, Math.round(this.current / total * 100)));
+    const filled = Math.max(0, Math.min(width, Math.round(this.current / total * width)));
+    const empty = width - filled;
+    let bar;
+    if (Array.isArray(this.options.barCompleteChar) || Array.isArray(this.options.barIncompleteChar)) {
+      const completeChars = Array.isArray(this.options.barCompleteChar) ? this.options.barCompleteChar : void 0;
+      const incompleteChars = Array.isArray(this.options.barIncompleteChar) ? this.options.barIncompleteChar : void 0;
+      const completeChar = completeChars?.[completeChars.length - 1] ?? (typeof this.options.barCompleteChar === "string" ? this.options.barCompleteChar : "█");
+      const incompleteChar = incompleteChars?.[0] ?? (typeof this.options.barIncompleteChar === "string" ? this.options.barIncompleteChar : "░");
+      const completeLength = completeChars?.length ?? 1;
+      const progressRatio = this.current / total;
+      const totalSteps = width * completeLength;
+      const currentStep = Math.round(progressRatio * totalSteps);
+      const fractional = currentStep % completeLength;
+      let barContent = "";
+      for (let i = 0; i < width; i += 1) {
+        if (i < filled) {
+          const isGradientBoundary = i === filled - 1 && fractional > 0 && completeChars;
+          barContent += isGradientBoundary ? completeChars[Math.max(0, fractional - 1)] : completeChar;
+        } else {
+          barContent += incompleteChar;
+        }
+      }
+      bar = barContent;
+    } else {
+      const completeChar = typeof this.options.barCompleteChar === "string" ? this.options.barCompleteChar : "█";
+      const incompleteChar = typeof this.options.barIncompleteChar === "string" ? this.options.barIncompleteChar : "░";
+      bar = completeChar.repeat(filled) + incompleteChar.repeat(empty);
+    }
+    let format = this.options.format ?? "progress [{bar}] {percentage}% | ETA: {eta}s | {value}/{total}";
+    if (this.payload) {
+      for (const [k, v] of Object.entries(this.payload)) {
+        format = format.replaceAll(`{${k}}`, String(v));
+      }
+    }
+    const eta = this.calculateETA();
+    return format.replaceAll("{bar}", bar).replaceAll("{percentage}", String(percentage)).replaceAll("{value}", String(this.current)).replaceAll("{total}", String(this.options.total)).replaceAll("{eta}", String(eta));
+  }
+  /**
+   * Starts the progress bar.
+   * @param total Optional total value to set
+   * @param startValue Optional starting value
+   * @param payload Optional initial payload data
+   */
+  start(total, startValue, payload) {
+    if (total !== void 0) {
+      this.options.total = total;
+    }
+    if (startValue !== void 0) {
+      this.current = startValue;
+    }
+    this.startTime = Date.now();
+    this.isActive = true;
+    if (this.interactiveManager) {
+      this.interactiveManager.hook();
+      this.update(this.current, payload);
+    }
+  }
+  /**
+   * Stops the progress bar and cleanup.
+   */
+  stop() {
+    this.isActive = false;
+    if (this.interactiveManager) {
+      this.interactiveManager.unhook(false);
+    }
+  }
+  calculateETA() {
+    if (this.current === 0) {
+      return 0;
+    }
+    const elapsed = (Date.now() - this.startTime) / 1e3;
+    if (elapsed < 0.1) {
+      return 0;
+    }
+    const rate = this.current / elapsed;
+    const remaining = this.options.total - this.current;
+    return Math.round(remaining / rate);
+  }
+}
+class MultiBarInstance extends ProgressBar {
+  multiBar;
+  constructor(multiBar, options, payload) {
+    super(options, void 0, payload);
+    this.multiBar = multiBar;
+  }
+  update(current, payload) {
+    super.update(current, payload);
+    this.multiBar.renderAll();
+  }
+  getBarState() {
+    const completeChar = Array.isArray(this.options.barCompleteChar) ? this.options.barCompleteChar[this.options.barCompleteChar.length - 1] : getBarChar(this.options.barCompleteChar, this.options.style ?? "shades_classic", true);
+    return {
+      char: completeChar ?? "█",
+      current: this.current,
+      total: this.options.total
+    };
+  }
+}
+class MultiProgressBar {
+  bars = /* @__PURE__ */ new Map();
+  options;
+  interactiveManager;
+  isActive = false;
+  nextBarId = 0;
+  composite = false;
+  barColors = /* @__PURE__ */ new Map();
+  /**
+   * Creates a new multi progress bar manager.
+   * @param options Configuration options for the progress bars
+   * @param interactiveManager Optional interactive manager for rendering
+   */
+  constructor(options = {}, interactiveManager) {
+    this.options = {
+      barCompleteChar: getBarChar(void 0, "shades_classic"),
+      barIncompleteChar: getBarChar(void 0, "shades_classic", false),
+      composite: false,
+      format: "progress [{bar}] {percentage}% | ETA: {eta}s | {value}/{total}",
+      fps: 10,
+      ...options
+    };
+    this.composite = this.options.composite ?? false;
+    this.interactiveManager = interactiveManager;
+  }
+  /**
+   * Creates a new progress bar within this multi-bar manager.
+   * @param total Total value for the progress bar
+   * @param current Starting current value (default: 0)
+   * @param payload Optional initial payload data for format placeholders
+   * @returns The created progress bar instance
+   */
+  create(total, current = 0, payload) {
+    const barId = `bar_${this.nextBarId++}`;
+    const bar = new MultiBarInstance(
+      this,
+      {
+        barCompleteChar: this.options.barCompleteChar,
+        barIncompleteChar: this.options.barIncompleteChar,
+        current,
+        format: this.options.format,
+        fps: this.options.fps,
+        total,
+        width: 40
+      },
+      payload
+    );
+    this.bars.set(barId, bar);
+    if (!this.isActive && this.interactiveManager) {
+      this.interactiveManager.hook();
+      this.isActive = true;
+      this.renderAll();
+    }
+    return bar;
+  }
+  /**
+   * Removes a progress bar from the manager.
+   * @param bar The progress bar instance to remove
+   * @returns True if the bar was removed, false if not found
+   */
+  remove(bar) {
+    for (const [id, existingBar] of this.bars.entries()) {
+      if (existingBar === bar) {
+        this.bars.delete(id);
+        if (this.bars.size === 0) {
+          if (this.interactiveManager) {
+            this.interactiveManager.unhook(false);
+          }
+          this.isActive = false;
+        } else {
+          this.renderAll();
+        }
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Renders all progress bars.
+   */
+  renderAll() {
+    if (!this.interactiveManager || !this.isActive) {
+      return;
+    }
+    const lines = [];
+    if (this.composite) {
+      const barsArray = [...this.bars.values()];
+      if (barsArray.length > 0) {
+        const compositeOutput = this.renderComposite(barsArray);
+        lines.push(compositeOutput);
+      }
+    } else {
+      for (const bar of this.bars.values()) {
+        lines.push(bar.render());
+      }
+    }
+    this.interactiveManager.update("stdout", lines);
+  }
+  /**
+   * Sets or removes a color function for a specific bar.
+   * @param bar The progress bar instance to color (must be from this MultiProgressBar)
+   * @param color Color function or undefined to remove color
+   */
+  setBarColor(bar, color) {
+    for (const instance of this.bars.values()) {
+      if (instance === bar) {
+        if (color) {
+          this.barColors.set(instance, color);
+        } else {
+          this.barColors.delete(instance);
+        }
+        break;
+      }
+    }
+  }
+  /**
+   * Stops all progress bars and cleanup.
+   */
+  // eslint-disable-next-line sonarjs/no-identical-functions
+  stop() {
+    this.isActive = false;
+    if (this.interactiveManager) {
+      this.interactiveManager.unhook(false);
+    }
+  }
+  renderComposite(bars) {
+    if (bars.length === 0) {
+      return "";
+    }
+    const firstBar = bars[0];
+    if (!firstBar) {
+      return "";
+    }
+    const output = firstBar.render();
+    const barMatch = output.match(BAR_REGEX);
+    if (!barMatch || !barMatch[1]) {
+      return output;
+    }
+    const width = barMatch[1].length;
+    const grid = Array.from({ length: width }, () => []);
+    bars.forEach((bar, index) => {
+      const state = bar.getBarState();
+      const filled = Math.round(state.current / state.total * width);
+      for (let i = 0; i < width; i += 1) {
+        if (i < filled) {
+          grid[i]?.push(index);
+        }
+      }
+    });
+    const composite = Array.from({ length: width }, (_, i) => this.getCompositeChar(bars, grid[i])).join("");
+    return output.replace(BAR_REGEX, `[${composite}]`);
+  }
+  getCompositeChar(bars, stack) {
+    if (!stack || stack.length === 0) {
+      const defaultBar = bars[0];
+      return defaultBar?.getBarState().char ?? "█";
+    }
+    const charGradient = CHAR_GRADIENTS[this.options.style === "rect" ? "rect" : "default"];
+    const char = charGradient?.[Math.min(stack.length - 1, charGradient.length - 1)] ?? "█";
+    let selectedBar;
+    let smallestPercent = 100;
+    for (const stackBarIndex of stack) {
+      const bar = bars[stackBarIndex];
+      if (!bar) {
+        continue;
+      }
+      const barState = bar.getBarState();
+      const barPercent = barState.current / barState.total * 100;
+      if (barPercent < smallestPercent || barPercent === smallestPercent && (selectedBar === void 0 || stackBarIndex > selectedBar)) {
+        smallestPercent = barPercent;
+        selectedBar = stackBarIndex;
+      }
+    }
+    const barIndex = selectedBar ?? stack[0];
+    const targetBar = bars[barIndex ?? 0];
+    if (!targetBar) {
+      return char;
+    }
+    const barColor = this.barColors.get(targetBar);
+    return barColor ? barColor(char) : char;
+  }
+}
+
+export { MultiBarInstance, MultiProgressBar, ProgressBar, applyStyleToOptions, getBarChar };

package/dist/packem_shared/{index-BomQ3E6J.js → index-DnkF86LQ.js}

@@ -1,3 +1,11 @@
+const getLongestLabel = (types) => {
+  const labels = Object.keys(types).map((x) => types[x].label ?? "");
+  if (labels.length === 0) {
+    return "";
+  }
+  return labels.reduce((x, y) => x.length > y.length ? x : y);
+};
+
 const colorKeywords = /* @__PURE__ */ new Map([
   ["aliceblue", "#f0f8ff"],
   ["antiquewhite", "#faebd7"],
@@ -647,4 +655,4 @@ const build = (options = {}) => {
   return (f, arguments_ = [], formatOptions = {}) => format(f, arguments_, { ...formatOptions, formatters });
 };
 
-export { build as b, format as f };
+export { build as b, format as f, getLongestLabel as g };