@reliverse/rempts 1.7.56 → 1.7.58

package/bin/libs/spinner/spinner-mod.js

@@ -1,255 +1,454 @@
 import { re } from "@reliverse/relico";
-import { block } from "../cancel/cancel.js";
-const unicode = process.platform !== "win32" || process.env["TERM_PROGRAM"] === "vscode";
-const defaultFrames = unicode ? ["\u25D2", "\u25D0", "\u25D3", "\u25D1"] : ["\u2022", "o", "O", "0"];
-const defaultDelay = unicode ? 80 : 120;
-function isInteractive() {
-  return process.stdout.isTTY && !process.env["CI"] && !process.env["GITHUB_ACTIONS"] && !process.env["GITLAB_CI"] && !process.env["BUILDKITE"] && process.env["TERM"] !== "dumb";
-}
-function formatProgress(options) {
-  const { current, total, format = "both" } = options;
-  const percentage = Math.round(current / total * 100);
-  switch (format) {
-    case "percentage":
-      return `${percentage}%`;
-    case "count":
-      return `${current}/${total}`;
-    case "both":
-      return `${current}/${total} (${percentage}%)`;
-    default:
-      return `${current}/${total}`;
+import cliSpinners, { randomSpinner } from "cli-spinners";
+import ora, {
+  oraPromise
+} from "ora";
+import prettyBytes from "pretty-bytes";
+import prettyMilliseconds from "pretty-ms";
+function isColorsEnabled(isSpinnerEnabledFlag) {
+  if (process.env["CLI_NO_COLOR"] === "1") return false;
+  return isSpinnerEnabledFlag;
+}
+function toStyler(input, fallback) {
+  if (!input) return fallback;
+  if (typeof input === "function") return input;
+  const fn = re[input];
+  if (typeof fn === "function") return fn;
+  return fallback;
+}
+const identity = (s) => s;
+function isCIEnvironment() {
+  const { CI, GITHUB_ACTIONS, BUILD_NUMBER, RUN_ID } = process.env;
+  return CI === "true" || GITHUB_ACTIONS === "true" || typeof BUILD_NUMBER !== "undefined" || typeof RUN_ID !== "undefined";
+}
+const defaultStderr = process.stderr;
+function isInteractive(stream = defaultStderr) {
+  return Boolean(stream && stream.isTTY);
+}
+function getDefaultEnabled(stream = defaultStderr) {
+  const disabledByEnv = process.env["CLI_NO_SPINNER"] === "1" || process.env["CLI_NO_COLOR"] === "1";
+  if (disabledByEnv) return false;
+  if (isCIEnvironment()) return false;
+  return isInteractive(stream);
+}
+export const defaultSpinnerOptions = {
+  color: "cyan",
+  spinner: "dots",
+  hideCursor: true,
+  indent: 0,
+  discardStdin: true,
+  respectEnv: true,
+  showTiming: false
+};
+export function isSpinnerEnabled(options) {
+  const stream = options?.stream ?? defaultStderr;
+  const respectEnv = options?.respectEnv !== false;
+  if (typeof options?.isEnabled === "boolean") return options.isEnabled;
+  return respectEnv ? getDefaultEnabled(stream) : true;
+}
+export function createSpinner(input) {
+  const base = typeof input === "string" ? { text: input } : { ...input ?? {} };
+  const stream = base.stream ?? defaultStderr;
+  const respectEnv = base.respectEnv !== false;
+  const isEnabled = base.isEnabled ?? (respectEnv ? getDefaultEnabled(stream) : true);
+  const isSilent = base.isSilent ?? false;
+  const resolvedColor = base.color ?? defaultSpinnerOptions.color ?? "cyan";
+  const resolvedSpinner = base.spinner ?? defaultSpinnerOptions.spinner ?? "dots";
+  const resolvedHideCursor = base.hideCursor ?? defaultSpinnerOptions.hideCursor ?? true;
+  const resolvedIndent = base.indent ?? defaultSpinnerOptions.indent ?? 0;
+  const resolvedDiscardStdin = base.discardStdin ?? defaultSpinnerOptions.discardStdin ?? true;
+  const options = {
+    // Defaults chosen to be broadly useful; callers can override
+    color: resolvedColor,
+    hideCursor: resolvedHideCursor,
+    indent: resolvedIndent,
+    stream,
+    isEnabled,
+    isSilent,
+    discardStdin: resolvedDiscardStdin,
+    ...resolvedSpinner !== void 0 ? { spinner: resolvedSpinner } : {},
+    ...base.interval !== void 0 ? { interval: base.interval } : {},
+    ...base.prefixText !== void 0 ? { prefixText: base.prefixText } : {},
+    ...base.suffixText !== void 0 ? { suffixText: base.suffixText } : {},
+    ...base.text !== void 0 ? { text: base.text } : {}
+  };
+  const spinner = ora(options);
+  const colorsEnabled = isColorsEnabled(isEnabled);
+  const themeObj = base.theme ?? {};
+  const dim = colorsEnabled ? themeObj.dim ?? re.dim ?? identity : identity;
+  const info = colorsEnabled ? themeObj.info ?? re.cyan ?? identity : identity;
+  const success = colorsEnabled ? themeObj.success ?? re.green ?? identity : identity;
+  const error = colorsEnabled ? themeObj.error ?? re.red ?? identity : identity;
+  const progress = colorsEnabled ? themeObj.progress ?? re.cyan ?? identity : identity;
+  const rate = colorsEnabled ? themeObj.rate ?? re.cyan ?? identity : identity;
+  const bytesColor = colorsEnabled ? themeObj.bytes ?? re.cyan ?? identity : identity;
+  const percent = colorsEnabled ? themeObj.percentage ?? re.yellow ?? identity : identity;
+  spinner.__reTheme = { dim, info, success, error, progress, rate, bytesColor, percent };
+  spinner.__textStyler = toStyler(base.textColor, info);
+  spinner.__prefixStyler = toStyler(base.prefixColor, identity);
+  spinner.__suffixStyler = toStyler(base.suffixColor, identity);
+  spinner.__successStyler = toStyler(base.successColor, success);
+  spinner.__failStyler = toStyler(base.failColor, error);
+  if (options.text) {
+    const style = spinner.__textStyler;
+    spinner.text = style(options.text);
   }
+  return spinner;
+}
+export async function withSpinnerPromise(action, options) {
+  return oraPromise(
+    action,
+    options
+  );
 }
-function formatTimer(origin) {
-  const duration = (performance.now() - origin) / 1e3;
-  const min = Math.floor(duration / 60);
-  const secs = Math.floor(duration % 60);
-  return min > 0 ? `[${min}m ${secs}s]` : `[${secs}s]`;
-}
-function removeTrailingDots(msg) {
-  return msg.replace(/\.+$/, "");
-}
-export function useSpinner(options) {
-  let loop;
-  const interactive = isInteractive();
-  let unblock = null;
-  const state = {
-    isActive: false,
-    isPaused: false,
-    startTime: null,
-    pausedTime: 0,
-    text: options.text,
-    isCancelled: false,
-    origin: performance.now(),
-    indicatorTimer: 0
+export async function withSpinner(textOrOptions, action, onSuccessText, onFailText) {
+  const startTime = Date.now();
+  const options = typeof textOrOptions === "string" ? { text: textOrOptions } : textOrOptions;
+  const spinner = createSpinner(textOrOptions).start();
+  try {
+    const result = await action(spinner);
+    const successMsg = getSuccessMessage(result, onSuccessText, options, startTime);
+    const style = spinner.__successStyler ?? identity;
+    spinner.succeed(successMsg ? style(successMsg) : void 0);
+    return result;
+  } catch (error) {
+    const err = error;
+    const failMsg = getFailMessage(err, onFailText, options);
+    const style = spinner.__failStyler ?? identity;
+    spinner.fail(failMsg ? style(failMsg) : void 0);
+    throw err;
+  }
+}
+function getSuccessMessage(result, onSuccessText, options, startTime) {
+  let message;
+  if (typeof onSuccessText === "function") {
+    message = onSuccessText(result);
+  } else if (typeof onSuccessText === "string") {
+    message = onSuccessText;
+  } else if (options.defaultSuccess) {
+    message = options.defaultSuccess;
+  }
+  if (options.showTiming && message) {
+    const elapsed = Date.now() - startTime;
+    const timing = prettyMilliseconds(elapsed, { compact: true });
+    message = `${message} (${timing})`;
+  }
+  return message;
+}
+function getFailMessage(error, onFailText, options) {
+  if (typeof onFailText === "function") {
+    return onFailText(error);
+  } else if (typeof onFailText === "string") {
+    return onFailText;
+  } else if (options.defaultFail) {
+    return options.defaultFail;
+  }
+}
+export function updateSpinnerText(spinner, text, options) {
+  const { prefix, suffix } = options ?? {};
+  const styleText = spinner.__textStyler ?? identity;
+  const stylePrefix = spinner.__prefixStyler ?? identity;
+  const styleSuffix = spinner.__suffixStyler ?? identity;
+  const prefixStyled = prefix ? stylePrefix(prefix) : "";
+  const suffixStyled = suffix ? styleSuffix(suffix) : "";
+  const fullText = `${prefixStyled}${styleText(text)}${suffixStyled}`;
+  spinner.text = fullText;
+}
+export function stopAndPersist(spinner, options) {
+  spinner.stopAndPersist({
+    symbol: options.symbol ?? " ",
+    text: options.text ?? spinner.text,
+    prefixText: options.prefixText ?? spinner.prefixText,
+    suffixText: options.suffixText ?? spinner.suffixText
+  });
+}
+export function createTimedSpinner(input) {
+  const startTime = Date.now();
+  const options = typeof input === "string" ? { text: input } : { ...input ?? {} };
+  const spinner = createSpinner({ ...options, showTiming: true });
+  return {
+    spinner,
+    getElapsed: () => Date.now() - startTime,
+    succeedWithTiming: (text) => {
+      const elapsed = Date.now() - startTime;
+      const timing = prettyMilliseconds(elapsed, { compact: true });
+      const dim = spinner.__reTheme?.dim ?? identity;
+      const successStyle = spinner.__successStyler ?? identity;
+      const message = text ? `${successStyle(text)} ${dim(`(${timing})`)}` : void 0;
+      spinner.succeed(message);
+    },
+    failWithTiming: (text) => {
+      const elapsed = Date.now() - startTime;
+      const timing = prettyMilliseconds(elapsed, { compact: true });
+      const dim = spinner.__reTheme?.dim ?? identity;
+      const failStyle = spinner.__failStyler ?? identity;
+      const message = text ? `${failStyle(text)} ${dim(`(failed after ${timing})`)}` : void 0;
+      spinner.fail(message);
+    }
   };
-  const handleExit = (code) => {
-    const msg = code > 1 ? options.errorMessage ?? "Operation failed" : options.cancelMessage ?? "Operation cancelled";
-    state.isCancelled = code === 1;
-    if (state.isActive) {
-      controls.stop(msg, code);
-      if (state.isCancelled && typeof options.onCancel === "function") {
-        options.onCancel();
+}
+export function createSpinnerGroup(options) {
+  const { items, concurrent = false, ...baseOptions } = options;
+  const spinners2 = items.map((item, index) => {
+    const spinnerOptions = {
+      ...baseOptions,
+      text: item,
+      indent: (baseOptions.indent ?? 0) + (concurrent ? 0 : index * 2)
+    };
+    return createSpinner(spinnerOptions);
+  });
+  return {
+    spinners: spinners2,
+    updateAll: (text) => {
+      for (const spinner of spinners2) {
+        updateSpinnerText(spinner, text);
+      }
+    },
+    succeedAll: (text) => {
+      for (const spinner of spinners2) {
+        const style = spinner.__successStyler ?? identity;
+        spinner.succeed(text ? style(text) : void 0);
+      }
+    },
+    failAll: (text) => {
+      for (const spinner of spinners2) {
+        const style = spinner.__failStyler ?? identity;
+        spinner.fail(text ? style(text) : void 0);
+      }
+    },
+    stopAll: () => {
+      for (const spinner of spinners2) {
+        spinner.stop();
       }
     }
   };
-  const errorEventHandler = () => handleExit(2);
-  const signalEventHandler = () => handleExit(1);
-  const registerHooks = () => {
-    process.on("uncaughtExceptionMonitor", errorEventHandler);
-    process.on("unhandledRejection", errorEventHandler);
-    process.on("SIGINT", signalEventHandler);
-    process.on("SIGTERM", signalEventHandler);
-    process.on("exit", handleExit);
-    if (options.signal) {
-      options.signal.addEventListener("abort", signalEventHandler);
+}
+export async function withEnhancedSpinner(textOrOptions, action) {
+  const startTime = Date.now();
+  const options = typeof textOrOptions === "string" ? { text: textOrOptions, showTiming: false } : { showTiming: false, ...textOrOptions };
+  const baseSpinner = createSpinner(options).start();
+  const enhancedSpinner = Object.assign(baseSpinner, {
+    updateText: (text, updateOptions) => {
+      updateSpinnerText(baseSpinner, text, updateOptions);
+    },
+    setProgress: (current, total, text) => {
+      const progressText = text ? `${text} (${current}/${total})` : `${current}/${total}`;
+      baseSpinner.text = progressText;
     }
-  };
-  const clearHooks = () => {
-    process.removeListener("uncaughtExceptionMonitor", errorEventHandler);
-    process.removeListener("unhandledRejection", errorEventHandler);
-    process.removeListener("SIGINT", signalEventHandler);
-    process.removeListener("SIGTERM", signalEventHandler);
-    process.removeListener("exit", handleExit);
-    if (options.signal) {
-      options.signal.removeEventListener("abort", signalEventHandler);
+  });
+  try {
+    const result = await action(enhancedSpinner);
+    let successText = options.successText;
+    if (options.showTiming && successText) {
+      const elapsed = Date.now() - startTime;
+      const timing = prettyMilliseconds(elapsed, { compact: true });
+      successText = `${successText} (${timing})`;
+    }
+    baseSpinner.succeed(successText);
+    return result;
+  } catch (error) {
+    const err = error;
+    let failText = options.failText;
+    if (options.showTiming && failText) {
+      const elapsed = Date.now() - startTime;
+      const timing = prettyMilliseconds(elapsed, { compact: true });
+      failText = `${failText} (failed after ${timing})`;
+    }
+    baseSpinner.fail(failText);
+    throw err;
+  }
+}
+export function isSpinnerRunning(spinner) {
+  return spinner.isSpinning;
+}
+export function safeStopSpinner(spinner) {
+  if (spinner?.isSpinning) {
+    spinner.stop();
+  }
+}
+export function createBuildSpinner(operation, options) {
+  const spinner = createSpinner({ text: operation, ...options }).start();
+  return {
+    spinner,
+    complete: (message) => {
+      const successStyle = spinner.__successStyler ?? identity;
+      spinner.succeed(successStyle(message ?? `${operation} completed successfully!`));
+    },
+    error: (error) => {
+      const errorMessage = typeof error === "string" ? error : error.message;
+      const failStyle = spinner.__failStyler ?? identity;
+      spinner.fail(failStyle(`${operation} failed: ${errorMessage}`));
+    },
+    updateProgress: (step) => {
+      const info = spinner.__reTheme?.info ?? identity;
+      updateSpinnerText(spinner, `${operation} - ${info(step)}`);
     }
   };
-  const clearPrevMessage = () => {
-    if (state.prevMessage === void 0) return;
-    if (process.env["CI"]) process.stdout.write("\n");
-    const prevLines = state.prevMessage.split("\n");
-    process.stdout.write(`\x1B[${prevLines.length}A`);
-    process.stdout.write("\x1B[0J");
-  };
-  const controls = {
-    start: (text) => {
-      if (text) {
-        options.text = text;
-        state.text = text;
-      }
-      if (options.silent || !interactive) {
-        console.log(options.prefixText ? `${options.prefixText} ${options.text}` : options.text);
-        state.isActive = true;
-        state.startTime = Date.now();
-        return controls;
+}
+export function createFileProgressSpinner(operation, options) {
+  const { totalBytes, showBytes = true, showRate = false, ...spinnerOptions } = options ?? {};
+  const startTime = Date.now();
+  const spinner = createSpinner({ text: operation, ...spinnerOptions }).start();
+  return {
+    spinner,
+    updateProgress: (bytesProcessed, fileName) => {
+      let progressText = operation;
+      if (fileName) {
+        const info = spinner.__reTheme?.info ?? identity;
+        progressText += ` - ${info(fileName)}`;
       }
-      state.isActive = true;
-      state.origin = performance.now();
-      unblock = block({ output: process.stdout });
-      process.stdout.write(`${re.dim("\u2502")}
-`);
-      let frameIndex = 0;
-      registerHooks();
-      loop = setInterval(() => {
-        if (process.env["CI"] && state.text === state.prevMessage) {
-          return;
-        }
-        clearPrevMessage();
-        state.prevMessage = state.text;
-        const frame = re.magenta((options.frames ?? defaultFrames)[frameIndex] ?? "");
-        if (process.env["CI"]) {
-          process.stdout.write(`${frame}  ${state.text}...`);
-        } else if (options.indicator === "timer") {
-          process.stdout.write(`${frame}  ${state.text} ${formatTimer(state.origin)}`);
+      if (showBytes) {
+        if (totalBytes) {
+          const percentage = Math.round(bytesProcessed / totalBytes * 100);
+          const bytesColor = spinner.__reTheme?.bytesColor ?? identity;
+          const percent = spinner.__reTheme?.percent ?? identity;
+          progressText += ` (${bytesColor(prettyBytes(bytesProcessed))}/${bytesColor(prettyBytes(totalBytes))} - ${percent(`${percentage}%`)})`;
         } else {
-          const loadingDots = ".".repeat(Math.floor(state.indicatorTimer)).slice(0, 3);
-          process.stdout.write(`${frame}  ${state.text}${loadingDots}`);
+          const bytesColor = spinner.__reTheme?.bytesColor ?? identity;
+          progressText += ` (${bytesColor(prettyBytes(bytesProcessed))})`;
         }
-        frameIndex = (frameIndex + 1) % (options.frames ?? defaultFrames).length;
-        state.indicatorTimer = state.indicatorTimer < 4 ? state.indicatorTimer + 0.125 : 0;
-      }, options.delay ?? defaultDelay);
-      return controls;
-    },
-    stop: (text, code = 0) => {
-      if (!state.isActive) return;
-      state.isActive = false;
-      clearInterval(loop);
-      clearPrevMessage();
-      const step = code === 0 ? re.green("\u2713") : code === 1 ? re.red("\u2717") : re.red("\u2717");
-      const finalText = text ?? state.text;
-      if (options.indicator === "timer") {
-        process.stdout.write(`${step}  ${finalText} ${formatTimer(state.origin)}
-`);
-      } else {
-        process.stdout.write(`${step}  ${finalText}
-`);
-      }
-      clearHooks();
-      if (unblock) unblock();
-    },
-    setText: (text) => {
-      state.text = removeTrailingDots(text);
-      options.text = text;
-    },
-    setProgress: (progress) => {
-      const progressText = formatProgress(progress);
-      const newText = `${state.text} [${progressText}]`;
-      state.text = newText;
-      options.text = newText;
-    },
-    succeed: (text) => {
-      const successText = text ?? options.successText ?? state.text;
-      controls.stop(successText, 0);
-    },
-    fail: (text) => {
-      const failText = text ?? options.failText ?? state.text;
-      controls.stop(failText, 2);
-    },
-    warn: (text) => {
-      const warnText = text ?? state.text;
-      controls.stop(warnText, 0);
-    },
-    info: (text) => {
-      const infoText = text ?? state.text;
-      controls.stop(infoText, 0);
-    },
-    isSpinning: () => {
-      return state.isActive && !state.isPaused;
-    },
-    clear: () => {
-      clearPrevMessage();
-    },
-    getElapsedTime: () => {
-      if (!state.startTime) return 0;
-      const currentTime = Date.now();
-      return currentTime - state.startTime - state.pausedTime;
-    },
-    pause: () => {
-      if (state.isActive && !state.isPaused) {
-        clearInterval(loop);
-        state.isPaused = true;
       }
+      spinner.text = progressText;
     },
-    resume: () => {
-      if (state.isActive && state.isPaused) {
-        loop = setInterval(() => {
-        }, options.delay ?? defaultDelay);
-        state.isPaused = false;
+    updateRate: (bytesPerSecond) => {
+      if (showRate) {
+        const currentText = spinner.text;
+        const rate = spinner.__reTheme?.rate ?? identity;
+        const rateText = rate(`${prettyBytes(bytesPerSecond)}/s`);
+        spinner.text = `${currentText} @ ${rateText}`;
       }
     },
-    dispose: () => {
-      if (state.isActive) {
-        controls.stop();
-      }
-      state.isActive = false;
-      state.isPaused = false;
+    complete: (message) => {
+      const elapsed = Date.now() - startTime;
+      const timing = prettyMilliseconds(elapsed, { compact: true });
+      const dim = spinner.__reTheme?.dim ?? identity;
+      const successStyle = spinner.__successStyler ?? identity;
+      const successMessage = successStyle(message ?? `${operation} completed successfully`);
+      spinner.succeed(`${successMessage} ${dim(`(${timing})`)}`);
     },
-    get isCancelled() {
-      return state.isCancelled;
+    error: (error) => {
+      const elapsed = Date.now() - startTime;
+      const timing = prettyMilliseconds(elapsed, { compact: true });
+      const errorMessage = typeof error === "string" ? error : error.message;
+      const dim = spinner.__reTheme?.dim ?? identity;
+      const failStyle = spinner.__failStyler ?? identity;
+      spinner.fail(
+        `${failStyle(`${operation} failed: ${errorMessage}`)} ${dim(`(after ${timing})`)}`
+      );
     }
   };
-  return controls;
 }
-useSpinner.promise = async (operation, options) => {
-  const spinner = useSpinner(options).start();
-  try {
-    const result = await operation(spinner);
-    spinner.succeed();
-    return result;
-  } catch (error) {
-    spinner.fail();
-    throw error;
-  } finally {
-    spinner.dispose();
-  }
-};
-useSpinner.nested = (parentOptions) => {
-  const parentSpinner = useSpinner({
-    ...parentOptions,
-    silent: true
-    // Parent is silent, children will show progress
-  });
+export function createMultiStepSpinner(operationName, steps, options) {
+  const startTime = Date.now();
+  let currentStepIndex = 0;
+  const totalSteps = steps.length;
+  const getStepText = (stepIndex) => {
+    const step = steps[stepIndex];
+    return `${operationName} - ${step} (${stepIndex + 1}/${totalSteps})`;
+  };
+  const spinner = createSpinner({ text: getStepText(0), ...options }).start();
   return {
-    start: () => {
-      parentSpinner.start();
-      return {
-        child: (childOptions) => useSpinner(childOptions),
-        finish: (success, text) => {
-          if (success) {
-            parentSpinner.succeed(text);
-          } else {
-            parentSpinner.fail(text);
-          }
-        },
-        dispose: () => parentSpinner.dispose()
-      };
-    }
+    spinner,
+    nextStep: (stepIndex) => {
+      if (stepIndex !== void 0) {
+        currentStepIndex = Math.min(stepIndex, totalSteps - 1);
+      } else {
+        currentStepIndex = Math.min(currentStepIndex + 1, totalSteps - 1);
+      }
+      const text = getStepText(currentStepIndex);
+      updateSpinnerText(spinner, text);
+    },
+    complete: (message) => {
+      const elapsed = Date.now() - startTime;
+      const timing = prettyMilliseconds(elapsed, { compact: true });
+      const dim = spinner.__reTheme?.dim ?? identity;
+      const successStyle = spinner.__successStyler ?? identity;
+      const successMessage = successStyle(message ?? `${operationName} completed successfully`);
+      spinner.succeed(`${successMessage} ${dim(`(${timing})`)}`);
+    },
+    error: (error, stepIndex) => {
+      const elapsed = Date.now() - startTime;
+      const timing = prettyMilliseconds(elapsed, { compact: true });
+      const errorMessage = typeof error === "string" ? error : error.message;
+      const stepInfo = stepIndex !== void 0 ? ` at step ${stepIndex + 1}` : "";
+      const dim = spinner.__reTheme?.dim ?? identity;
+      const failStyle = spinner.__failStyler ?? identity;
+      spinner.fail(
+        `${failStyle(`${operationName} failed${stepInfo}: ${errorMessage}`)} ${dim(`(after ${timing})`)}`
+      );
+    },
+    getCurrentStep: () => currentStepIndex
   };
-};
-useSpinner.withTiming = async (operation, options) => {
-  const spinner = useSpinner(options).start();
+}
+export function formatSpinnerTiming(startTime, options) {
+  const elapsed = Date.now() - startTime;
+  const pmOptions = { compact: !options?.verbose };
+  if (options?.verbose !== void 0) pmOptions["verbose"] = options.verbose;
+  return prettyMilliseconds(elapsed, pmOptions);
+}
+export function formatSpinnerBytes(bytes, options) {
+  return prettyBytes(bytes, options);
+}
+export function formatSpinnerElapsed(elapsed, options) {
+  const pmOptions = { compact: !options?.verbose };
+  if (options?.verbose !== void 0) pmOptions["verbose"] = options.verbose;
+  return prettyMilliseconds(elapsed, pmOptions);
+}
+export function createTransferSpinner(operation, options) {
+  const { totalBytes, showRate = true, ...spinnerOptions } = options ?? {};
   const startTime = Date.now();
-  try {
-    const result = await operation(spinner);
-    const duration = Date.now() - startTime;
-    spinner.succeed(`${options.successText || options.text} (${duration}ms)`);
-    return { result, duration };
-  } catch (error) {
-    const duration = Date.now() - startTime;
-    spinner.fail(`${options.failText || options.text} (failed after ${duration}ms)`);
-    throw error;
-  } finally {
-    spinner.dispose();
-  }
-};
+  const spinner = createSpinner({ text: operation, ...spinnerOptions }).start();
+  return {
+    spinner,
+    updateBytes: (bytesTransferred, fileName) => {
+      let text = operation;
+      if (fileName) {
+        const info = spinner.__reTheme?.info ?? identity;
+        text += ` - ${info(fileName)}`;
+      }
+      if (totalBytes) {
+        const percentage = Math.round(bytesTransferred / totalBytes * 100);
+        const bytesColor = spinner.__reTheme?.bytesColor ?? identity;
+        const percent = spinner.__reTheme?.percent ?? identity;
+        text += ` (${bytesColor(prettyBytes(bytesTransferred))}/${bytesColor(prettyBytes(totalBytes))} - ${percent(`${percentage}%`)})`;
+      } else {
+        const bytesColor = spinner.__reTheme?.bytesColor ?? identity;
+        text += ` (${bytesColor(prettyBytes(bytesTransferred))})`;
+      }
+      spinner.text = text;
+    },
+    updateRate: (bytesPerSecond) => {
+      if (showRate) {
+        const currentText = spinner.text;
+        const rate = spinner.__reTheme?.rate ?? identity;
+        const rateText = rate(`${prettyBytes(bytesPerSecond)}/s`);
+        spinner.text = `${currentText} @ ${rateText}`;
+      }
+    },
+    complete: (message, totalBytesTransferred) => {
+      const elapsed = Date.now() - startTime;
+      const timing = prettyMilliseconds(elapsed, { compact: true });
+      const dim = spinner.__reTheme?.dim ?? identity;
+      const successStyle = spinner.__successStyler ?? identity;
+      let successMessage = successStyle(message ?? `${operation} completed successfully`);
+      if (totalBytesTransferred) {
+        const bytesColor = spinner.__reTheme?.bytesColor ?? identity;
+        successMessage += ` (${bytesColor(prettyBytes(totalBytesTransferred))})`;
+      }
+      successMessage += ` ${dim(`in ${timing}`)}`;
+      spinner.succeed(successMessage);
+    },
+    error: (error) => {
+      const elapsed = Date.now() - startTime;
+      const timing = prettyMilliseconds(elapsed, { compact: true });
+      const errorMessage = typeof error === "string" ? error : error.message;
+      const dim = spinner.__reTheme?.dim ?? identity;
+      const failStyle = spinner.__failStyler ?? identity;
+      spinner.fail(
+        `${failStyle(`${operation} failed: ${errorMessage}`)} ${dim(`(after ${timing})`)}`
+      );
+    }
+  };
+}
+export const spinners = cliSpinners;
+export { randomSpinner, prettyBytes, prettyMilliseconds };