@reliverse/rempts-core 1.6.1

package/bin/core-impl/st-end/start.d.ts

@@ -0,0 +1,17 @@
+import type { PreventWrongTerminalSizeOptions, PromptOptions } from "../../core-types.js";
+type StartPromptOptions = PromptOptions & {
+    clearConsole?: boolean;
+    horizontalLine?: boolean;
+    horizontalLineLength?: number;
+    packageName?: string;
+    packageVersion?: string;
+    terminalSizeOptions?: PreventWrongTerminalSizeOptions;
+    isDev?: boolean;
+    prevent?: {
+        unsupportedTTY?: boolean;
+        wrongTerminalSize?: boolean;
+        windowsHomeDirRoot?: boolean;
+    };
+};
+export declare function startPrompt({ title, titleColor, titleTypography, titleVariant, borderColor, clearConsole, horizontalLine, horizontalLineLength, packageName, packageVersion, terminalSizeOptions, isDev, prevent, }: StartPromptOptions): Promise<void>;
+export {};

package/bin/core-impl/st-end/start.js

@@ -0,0 +1,66 @@
+import { getCurrentTerminalName } from "@reliverse/runtime";
+import { msg } from "../msg-fmt/messages.js";
+import {
+  getExactTerminalWidth,
+  getTerminalHeight,
+  getTerminalWidth
+} from "../msg-fmt/terminal.js";
+import {
+  preventWrongTerminalSize,
+  preventWindowsHomeDirRoot,
+  preventUnsupportedTTY
+} from "../utils/prevent.js";
+import { pm, reliversePrompts } from "../utils/system.js";
+export async function startPrompt({
+  title = "",
+  titleColor = "inverse",
+  titleTypography = "none",
+  titleVariant,
+  borderColor = "dim",
+  clearConsole = false,
+  horizontalLine = true,
+  horizontalLineLength = 0,
+  packageName = reliversePrompts.name,
+  packageVersion = reliversePrompts.version,
+  terminalSizeOptions = {},
+  isDev = false,
+  prevent = {
+    unsupportedTTY: true,
+    wrongTerminalSize: true,
+    windowsHomeDirRoot: true
+  }
+}) {
+  if (prevent.windowsHomeDirRoot) {
+    preventWindowsHomeDirRoot(process.cwd());
+  }
+  if (prevent.unsupportedTTY) {
+    preventUnsupportedTTY({ borderColor });
+  }
+  if (prevent.wrongTerminalSize) {
+    await preventWrongTerminalSize({ ...terminalSizeOptions, isDev });
+  }
+  const terminalWidth = getTerminalWidth();
+  const exactTerminalWidth = getExactTerminalWidth();
+  const terminalHeight = getTerminalHeight();
+  const formattedTitle = title !== "" ? title : `${packageName} v${packageVersion} | ${pm.packageManager} v${pm.version} | ${getCurrentTerminalName()}${isDev && terminalWidth > 80 ? ` | isDev | w${terminalWidth} h${terminalHeight}` : ""}`;
+  if (horizontalLineLength === 0) {
+    const titleFullLength = titleColor === "inverse" ? `\u2800${formattedTitle}\u2800`.length + 5 : formattedTitle.length + 5;
+    horizontalLineLength = Math.max(1, exactTerminalWidth - titleFullLength);
+  }
+  if (clearConsole) {
+    console.clear();
+    console.log("");
+  } else {
+    console.log("");
+  }
+  msg({
+    type: "M_START",
+    title: titleColor === "inverse" ? `\u2800${formattedTitle}\u2800` : formattedTitle,
+    titleColor,
+    titleTypography,
+    ...titleVariant ? { titleVariant } : {},
+    borderColor,
+    horizontalLine,
+    horizontalLineLength
+  });
+}

package/bin/core-impl/task/progress.d.ts

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

package/bin/core-impl/task/progress.js

@@ -0,0 +1,57 @@
+import { re } from "@reliverse/relico";
+import { cursor, erase } from "sisteransi";
+export async function progressTaskPrompt(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/core-impl/task/spinner.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";
+type 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 spinnerTaskPrompt<T extends "simple" | "ora">(options: TaskOptions<T>): Promise<void>;
+export {};

package/bin/core-impl/task/spinner.js

@@ -0,0 +1,110 @@
+import { re } from "@reliverse/relico";
+import process from "node:process";
+import ora from "ora";
+import { cursor, erase } from "sisteransi";
+import { msg } from "../msg-fmt/messages.js";
+export async function spinnerTaskPrompt(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/core-impl/utils/colorize.d.ts

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

package/bin/core-impl/utils/colorize.js

@@ -0,0 +1,134 @@
+import { re } from "@reliverse/relico";
+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:
+      console.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/core-impl/utils/errors.d.ts

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

package/bin/core-impl/utils/errors.js

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

package/bin/core-impl/utils/prevent.d.ts

@@ -0,0 +1,10 @@
+import type { ColorName, PreventWrongTerminalSizeOptions } from "../../core-types.js";
+export declare function preventUnsupportedTTY({ borderColor, }: {
+    borderColor?: ColorName;
+}): 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/core-impl/utils/prevent.js

@@ -0,0 +1,69 @@
+import { re } from "@reliverse/relico";
+import { homedir } from "node:os";
+import terminalSize from "terminal-size";
+import { msg } from "../msg-fmt/messages.js";
+import {
+  getExactTerminalWidth,
+  getTerminalWidth
+} from "../msg-fmt/terminal.js";
+export function preventUnsupportedTTY({
+  borderColor = "redBright"
+}) {
+  if (!process.stdout.isTTY) {
+    console.error(
+      "\u2502  Your terminal does not support cursor manipulations.\n\u2502  It's recommended to use a terminal which supports TTY."
+    );
+    msg({
+      type: "M_BAR",
+      borderColor
+    });
+  }
+}
+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/core-impl/utils/prompt-end.d.ts

@@ -0,0 +1,8 @@
+import type { BorderColorName, ColorName, TypographyName, VariantName } from "../../core-types.js";
+/**
+ * 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, _endTitleColor?: ColorName, _titleTypography?: TypographyName, _titleVariant?: VariantName | undefined, _border?: boolean, borderColor?: BorderColorName, action?: () => Promise<void>, value?: boolean): Promise<boolean>;
+export declare function renderEndLine(): void;
+export declare function renderEndLineInput(): void;

package/bin/core-impl/utils/prompt-end.js

@@ -0,0 +1,33 @@
+import { re } from "@reliverse/relico";
+import { msg, symbols } from "../msg-fmt/messages.js";
+import { getExactTerminalWidth } from "../msg-fmt/terminal.js";
+export async function completePrompt(prompt, isCtrlC, _endTitle = "", _endTitleColor = "dim", _titleTypography = "none", _titleVariant = void 0, _border = true, borderColor = "dim", action, value) {
+  if (action && value) {
+    await action();
+  }
+  if (prompt === "input") {
+    renderEndLineInput();
+    return value ?? false;
+  }
+  if (isCtrlC) {
+    renderEndLine();
+  } else {
+    msg({
+      type: "M_BAR",
+      borderColor
+    });
+  }
+  return value ?? false;
+}
+export function renderEndLine() {
+  const lineLength = getExactTerminalWidth() - 2;
+  console.log(re.dim(symbols.middle));
+  console.log(re.dim(`${symbols.end}${symbols.line.repeat(lineLength)}\u22B1`));
+  console.log();
+}
+export function renderEndLineInput() {
+  const lineLength = getExactTerminalWidth() - 2;
+  console.log();
+  console.log(re.dim(`${symbols.end}${symbols.line.repeat(lineLength)}\u22B1`));
+  console.log();
+}

package/bin/core-impl/utils/stream-text.d.ts

@@ -0,0 +1,18 @@
+import type { BorderColorName, StreamTextOptions } from "../../core-types.js";
+/**
+ * Simulates streaming text output in the console, character by character
+ */
+export declare function streamText({ text, delay, showCursor, color, newline, clearLine, onProgress, }: StreamTextOptions): Promise<void>;
+/**
+ * Simulates streaming text output in a message box
+ */
+export declare function streamTextBox({ text, delay, color, borderColor, }: Omit<StreamTextOptions, "showCursor" | "newline" | "clearLine"> & {
+    borderColor?: BorderColorName;
+}): Promise<void>;
+/**
+ * Simulates streaming text output with a loading spinner using ora
+ */
+export declare function streamTextWithSpinner({ text, delay, color, spinnerFrames, spinnerDelay, }: StreamTextOptions & {
+    spinnerFrames?: string[];
+    spinnerDelay?: number;
+}): Promise<void>;