@reliverse/rempts 1.7.52 → 1.7.53

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

@@ -0,0 +1,255 @@
+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}`;
+  }
+}
+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
+  };
+  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();
+      }
+    }
+  };
+  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);
+    }
+  };
+  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);
+    }
+  };
+  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;
+      }
+      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)}`);
+        } else {
+          const loadingDots = ".".repeat(Math.floor(state.indicatorTimer)).slice(0, 3);
+          process.stdout.write(`${frame}  ${state.text}${loadingDots}`);
+        }
+        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;
+      }
+    },
+    resume: () => {
+      if (state.isActive && state.isPaused) {
+        loop = setInterval(() => {
+        }, options.delay ?? defaultDelay);
+        state.isPaused = false;
+      }
+    },
+    dispose: () => {
+      if (state.isActive) {
+        controls.stop();
+      }
+      state.isActive = false;
+      state.isPaused = false;
+    },
+    get isCancelled() {
+      return state.isCancelled;
+    }
+  };
+  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
+  });
+  return {
+    start: () => {
+      parentSpinner.start();
+      return {
+        child: (childOptions) => useSpinner(childOptions),
+        finish: (success, text) => {
+          if (success) {
+            parentSpinner.succeed(text);
+          } else {
+            parentSpinner.fail(text);
+          }
+        },
+        dispose: () => parentSpinner.dispose()
+      };
+    }
+  };
+};
+useSpinner.withTiming = async (operation, options) => {
+  const spinner = useSpinner(options).start();
+  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();
+  }
+};

package/bin/libs/task/progress.d.ts

@@ -0,0 +1,2 @@
+import type { ProgressBar, ProgressBarOptions } from "../../types";
+export declare function taskProgressPrompt(options: ProgressBarOptions): Promise<ProgressBar>;

package/bin/libs/task/progress.js

@@ -0,0 +1,57 @@
+import { re } from "@reliverse/relico";
+import { cursor, erase } from "sisteransi";
+export async function taskProgressPrompt(options) {
+  if (options.total <= 0) {
+    throw new Error("Total must be a positive number");
+  }
+  const state = {
+    total: options.total,
+    current: 0,
+    width: options.width ?? 40,
+    completeChar: options.completeChar ?? "\u2588",
+    incompleteChar: options.incompleteChar ?? "\u2591",
+    startTime: Date.now(),
+    format: options.format ?? "Progress: [:bar] :percent% | Elapsed: :elapsed s",
+    colorize: options.colorize ?? false
+  };
+  const getElapsedTime = () => {
+    return ((Date.now() - state.startTime) / 1e3).toFixed(2);
+  };
+  const getPercentage = () => {
+    return (state.current / state.total * 100).toFixed(2);
+  };
+  const getBar = () => {
+    const percent = state.current / state.total;
+    const filledLength = Math.round(state.width * percent);
+    const emptyLength = state.width - filledLength;
+    const filled = state.completeChar.repeat(filledLength);
+    const empty = state.incompleteChar.repeat(emptyLength);
+    return state.colorize ? re.green(filled) + re.red(empty) : filled + empty;
+  };
+  const render = async () => {
+    const bar = getBar();
+    const percentage = getPercentage();
+    const elapsed = getElapsedTime();
+    const output = state.format.replace(":bar", bar).replace(":percent", percentage).replace(":elapsed", elapsed);
+    process.stdout.write(cursor.move(-999, 0) + erase.line);
+    process.stdout.write(`${re.green("\u25C6")}  ${output}`);
+    if (state.current >= state.total) {
+      process.stdout.write("\n");
+    }
+  };
+  const update = async (value) => {
+    const newValue = Math.min(value, state.total);
+    if (newValue !== state.current) {
+      state.current = newValue;
+      await render();
+    }
+  };
+  const increment = async (amount = 1) => {
+    await update(state.current + amount);
+  };
+  return {
+    update,
+    increment,
+    render
+  };
+}

package/bin/libs/task/task-spin.d.ts

@@ -0,0 +1,15 @@
+import type { SpinnerName } from "cli-spinners";
+type SimpleSpinnerType = "default" | "dottedCircle" | "boxSpinner";
+type OraSpinnerType = Extract<SpinnerName, OraAllowedSpinners>;
+type OraAllowedSpinners = "dots" | "bouncingBar" | "arc";
+interface TaskOptions<T extends "simple" | "ora"> {
+    initialMessage: string;
+    successMessage?: string;
+    errorMessage?: string;
+    delay?: number;
+    spinnerSolution: T;
+    spinnerType?: T extends "simple" ? SimpleSpinnerType : OraSpinnerType;
+    action: (updateMessage: (message: string) => void) => Promise<void>;
+}
+export declare function taskSpinPrompt<T extends "simple" | "ora">(options: TaskOptions<T>): Promise<void>;
+export {};

package/bin/libs/task/task-spin.js

@@ -0,0 +1,106 @@
+import process from "node:process";
+import { re } from "@reliverse/relico";
+import ora from "ora";
+import { cursor, erase } from "sisteransi";
+import { msg } from "../msg-fmt/messages.js";
+export async function taskSpinPrompt(options) {
+  const {
+    initialMessage,
+    successMessage = "Task completed successfully.",
+    errorMessage = "An error occurred during the task.",
+    delay = 100,
+    spinnerSolution,
+    spinnerType,
+    action
+  } = options;
+  let message = initialMessage;
+  let interval = null;
+  let frameIndex = 0;
+  if (spinnerSolution === "ora") {
+    const oraSpinner = ora({
+      text: initialMessage,
+      spinner: spinnerType
+    });
+    try {
+      oraSpinner.start();
+      await action((newMessage) => {
+        message = newMessage;
+        oraSpinner.text = newMessage;
+      });
+      oraSpinner.stop();
+      msg({
+        type: "M_INFO",
+        title: successMessage,
+        titleColor: "cyan"
+      });
+    } catch (error) {
+      oraSpinner.stopAndPersist({
+        symbol: re.red("\u2716"),
+        text: errorMessage
+      });
+      msg({
+        type: "M_ERROR",
+        title: error instanceof Error ? error.message : "An unknown error occurred.",
+        titleColor: "red"
+      });
+      process.exit(1);
+    }
+  } else {
+    const simpleSpinners = {
+      default: ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"],
+      dottedCircle: ["\u25CB", "\u25D4", "\u25D1", "\u25D5", "\u25CF"],
+      boxSpinner: ["\u2596", "\u2598", "\u259D", "\u2597"]
+    };
+    const frames = spinnerType && spinnerType in simpleSpinners ? simpleSpinners[spinnerType] : simpleSpinners.default;
+    const handleInput = (data) => {
+      const key = data.toString();
+      if (key === "\r" || key === "\n") {
+        return;
+      }
+    };
+    try {
+      if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.on("data", handleInput);
+      }
+      interval = setInterval(() => {
+        const frame = re.magenta(frames[frameIndex] ?? "");
+        process.stdout.write(`${cursor.move(-999, 0)}${erase.line}${frame} ${re.cyan(message)}`);
+        frameIndex = (frameIndex + 1) % frames.length;
+      }, delay);
+      await action((newMessage) => {
+        message = newMessage;
+      });
+      clearInterval(interval);
+      interval = null;
+      process.stdout.write(`\r${erase.line}${re.green("\u2714")} ${successMessage}
+`);
+      msg({
+        type: "M_INFO",
+        title: successMessage,
+        titleColor: "cyan"
+      });
+    } catch (error) {
+      if (interval) {
+        clearInterval(interval);
+      }
+      process.stdout.write(
+        `\r${erase.line}${re.red("\u2716")} ${error instanceof Error ? errorMessage : "An unknown error occurred."}
+`
+      );
+      msg({
+        type: "M_ERROR",
+        title: error instanceof Error ? error.message : "An unknown error occurred.",
+        titleColor: "red"
+      });
+      process.exit(1);
+    } finally {
+      if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        process.stdin.removeListener("data", handleInput);
+      }
+    }
+  }
+}

package/bin/libs/utils/colorize.d.ts

@@ -0,0 +1,2 @@
+import type { ColorName, TypographyName } from "../../types";
+export declare function colorize(text: string, colorName?: ColorName, typography?: TypographyName): string;

package/bin/libs/utils/colorize.js

@@ -0,0 +1,122 @@
+import { re } from "@reliverse/relico";
+import { relinka } from "@reliverse/relinka";
+import gradient, { cristal, mind, passion, rainbow, vice } from "gradient-string";
+function stripAnsi(text) {
+  return re.reset(text);
+}
+export function colorize(text, colorName, typography) {
+  if (!colorName) return text;
+  text = stripAnsi(text);
+  let result = text;
+  if (colorName.endsWith("Gradient")) {
+    switch (colorName) {
+      case "gradientGradient":
+        result = gradient(["red", "yellow", "green", "cyan", "blue", "magenta"])(result);
+        break;
+      case "rainbowGradient":
+        result = rainbow(result);
+        break;
+      case "cristalGradient":
+        result = cristal(result);
+        break;
+      case "mindGradient":
+        result = mind(result);
+        break;
+      case "passionGradient":
+        result = passion(result);
+        break;
+      case "viceGradient":
+        result = vice(result);
+        break;
+      case "retroGradient":
+        result = gradient(["#ff8a00", "#e52e71"])(result);
+        break;
+      default:
+        break;
+    }
+    return result;
+  }
+  switch (colorName) {
+    case "inverse":
+      result = re.inverse(` ${result} `);
+      break;
+    case "dim":
+      result = re.dim(result);
+      break;
+    case "black":
+      result = re.black(result);
+      break;
+    case "red":
+      result = re.red(result);
+      break;
+    case "redBright":
+      result = re.redBright(result);
+      break;
+    case "green":
+      result = re.green(result);
+      break;
+    case "greenBright":
+      result = re.greenBright(result);
+      break;
+    case "yellow":
+      result = re.yellow(result);
+      break;
+    case "yellowBright":
+      result = re.yellowBright(result);
+      break;
+    case "blue":
+      result = re.blue(result);
+      break;
+    case "blueBright":
+      result = re.blueBright(result);
+      break;
+    case "magenta":
+      result = re.magenta(result);
+      break;
+    case "magentaBright":
+      result = re.magentaBright(result);
+      break;
+    case "cyan":
+      result = re.cyan(result);
+      break;
+    case "cyanBright":
+      result = re.cyanBright(result);
+      break;
+    case "bgCyan":
+      result = re.bgCyan(` ${result} `);
+      break;
+    case "bgCyanBright":
+      result = re.bgCyanBright(` ${result} `);
+      break;
+    case "white":
+      result = re.white(result);
+      break;
+    case "gray":
+      result = re.gray(result);
+      break;
+    case "none":
+      break;
+    default:
+      relinka("warn", `Warning: Unknown color "${colorName}"`);
+      break;
+  }
+  if (typography) {
+    switch (typography) {
+      case "bold":
+        result = re.bold(result);
+        break;
+      case "strikethrough":
+        result = re.strikethrough(result);
+        break;
+      case "underline":
+        result = re.underline(result);
+        break;
+      case "italic":
+        result = re.italic(result);
+        break;
+      default:
+        break;
+    }
+  }
+  return result;
+}

package/bin/libs/utils/errors.d.ts

@@ -0,0 +1 @@
+export declare const errorHandler: (error: Error, customMessage?: string) => never;

package/bin/libs/utils/errors.js

@@ -0,0 +1,17 @@
+import { relinka } from "@reliverse/relinka";
+export const errorHandler = (error, customMessage) => {
+  const separator = "\u2500".repeat(71);
+  relinka("error", `\u2502${separator}`);
+  relinka("error", "\u2502  AN ERROR OCCURRED:\n\u2502 ", error.message);
+  relinka("error", `\u2502${separator}`);
+  if (customMessage) {
+    relinka("error", `\u2502  ${customMessage}`);
+  } else {
+    relinka(
+      "error",
+      "\u2502  If this issue is related to @reliverse/rempts itself, please\n\u2502  report the details at https://github.com/reliverse/rempts/issues"
+    );
+  }
+  relinka("error", `\u2570${separator}`);
+  process.exit(1);
+};

package/bin/libs/utils/prevent.d.ts

@@ -0,0 +1,8 @@
+import type { PreventWrongTerminalSizeOptions } from "../../types";
+export declare function preventUnsupportedTTY(): void;
+/**
+ * Prevents EISDIR errors when trying to read Windows home directory as a file
+ * @param filePath The file path to check
+ */
+export declare function preventWindowsHomeDirRoot(filePath: string): never | undefined;
+export declare function preventWrongTerminalSize({ isDev, shouldExit, minWidth, minHeight, sizeErrorDescription, }: PreventWrongTerminalSizeOptions): Promise<void>;

package/bin/libs/utils/prevent.js

@@ -0,0 +1,62 @@
+import { homedir } from "node:os";
+import { re } from "@reliverse/relico";
+import { relinka } from "@reliverse/relinka";
+import terminalSize from "terminal-size";
+import { msg } from "../msg-fmt/messages.js";
+import { getExactTerminalWidth, getTerminalWidth } from "../msg-fmt/terminal.js";
+export function preventUnsupportedTTY() {
+  if (!process.stdout.isTTY) {
+    relinka(
+      "warn",
+      "\u2502  Your terminal does not support terminal's cursor manipulations.\n\u2502  It's recommended to use a terminal which supports TTY."
+    );
+  }
+}
+export function preventWindowsHomeDirRoot(filePath) {
+  if (process.platform !== "win32") {
+    return;
+  }
+  const home = homedir();
+  if (filePath === home || filePath === `${home}\\`) {
+    msg({
+      type: "M_ERROR",
+      title: re.redBright("Cannot operate in Windows home directory root"),
+      content: `Please use a command like ${re.cyan(`cd ${home}\\Desktop`)} to move to a safe working directory first.`,
+      contentColor: "redBright"
+    });
+    process.exit(1);
+  }
+}
+export async function preventWrongTerminalSize({
+  isDev = false,
+  shouldExit = true,
+  minWidth = 80,
+  minHeight = 12,
+  sizeErrorDescription = "Please increase the terminal size to run the application"
+}) {
+  const size = terminalSize();
+  const exactTerminalWidth = getExactTerminalWidth();
+  const terminalWidth = getTerminalWidth();
+  const errors = [];
+  if (terminalWidth < minWidth) {
+    errors.push(
+      isDev ? `Oops! Terminal width is too small. Expected >${minWidth} | Current: ${terminalWidth} (Exact: ${exactTerminalWidth})` : `Oops! Terminal width is too small. Expected >${minWidth} | Current: ${terminalWidth}`
+    );
+  }
+  if (size.rows < minHeight) {
+    errors.push(
+      `Oops! Terminal height is too small. Expected >${minHeight} | Current: ${size.rows}`
+    );
+  }
+  if (errors.length > 0) {
+    msg({
+      type: "M_ERROR",
+      title: re.redBright(errors.join("\n\u2502\u2502    ")),
+      content: size.rows >= 7 && terminalWidth >= 70 ? sizeErrorDescription : "",
+      contentColor: "redBright"
+    });
+    if (shouldExit) {
+      process.exit(1);
+    }
+  }
+}

package/bin/libs/utils/prompt-end.d.ts

@@ -0,0 +1,8 @@
+import type { BorderColorName, ColorName, TypographyName, VariantName } from "../../types";
+/**
+ * Ends the prompt by optionally displaying an end message and running the action if confirmed.
+ * Preserves the last prompt state unless there's an endTitle.
+ */
+export declare function completePrompt(prompt: "input" | "confirm" | "select" | "multiselect" | "toggle", isCtrlC: boolean, _endTitle: string | undefined, _endTitleColor: ColorName | undefined, _titleTypography: TypographyName | undefined, _titleVariant: VariantName | undefined, _border?: boolean, borderColor?: BorderColorName, action?: () => Promise<void>, value?: boolean): Promise<boolean>;
+export declare function renderEndLine(): void;
+export declare function renderEndLineInput(): void;