@reliverse/rempts 1.7.52 → 1.7.54

package/bin/libs/animate/animate-mod.d.ts

@@ -0,0 +1,14 @@
+import { type Animation, type AnimationName } from "@figliolia/chalk-animation";
+import type { BorderColorName, ColorName, MsgType, TypographyName } from "../../types";
+export declare const animationMap: Record<AnimationName, (text: string) => Animation>;
+export declare function animateText({ title, anim, delay, type, titleColor, titleTypography, border, borderColor, horizontalLineLength, }: {
+    title: string;
+    anim: AnimationName;
+    delay?: number;
+    type?: MsgType;
+    titleColor?: ColorName;
+    titleTypography?: TypographyName;
+    borderColor?: BorderColorName;
+    border?: boolean;
+    horizontalLineLength?: number;
+}): Promise<void>;

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

@@ -0,0 +1,60 @@
+import { ChalkAnimation } from "@figliolia/chalk-animation";
+import { relinka } from "@reliverse/relinka";
+import { msg } from "../msg-fmt/messages.js";
+import { deleteLastLine, getTerminalWidth } from "../msg-fmt/terminal.js";
+export const animationMap = {
+  rainbow: ChalkAnimation.rainbow,
+  pulse: ChalkAnimation.pulse,
+  glitch: ChalkAnimation.glitch,
+  radar: ChalkAnimation.radar,
+  neon: ChalkAnimation.neon,
+  karaoke: ChalkAnimation.karaoke
+};
+function calculateDelay(text) {
+  const baseDelay = 1e3;
+  const delayPerCharacter = 50;
+  return baseDelay + text.length * delayPerCharacter;
+}
+export async function animateText({
+  title = "",
+  anim,
+  delay,
+  type = "M_INFO",
+  titleColor = "cyan",
+  titleTypography = "none",
+  border = true,
+  borderColor = "dim",
+  horizontalLineLength = 0
+}) {
+  if (horizontalLineLength === 0) {
+    horizontalLineLength = getTerminalWidth() - 5;
+  }
+  const finalDelay = delay ?? calculateDelay(title);
+  const animation = animationMap[anim](title);
+  try {
+    await new Promise((resolve) => {
+      setTimeout(() => {
+        animation.stop();
+        deleteLastLine();
+        if (title.includes("\u2502  ")) {
+          title = title.replace("\u2502  ", "");
+        } else if (title.includes("\u2139  ")) {
+          title = title.replace("\u2139  ", "");
+        }
+        msg({
+          type,
+          title,
+          titleColor,
+          titleTypography,
+          content: "",
+          borderColor,
+          border,
+          horizontalLineLength
+        });
+        resolve();
+      }, finalDelay);
+    });
+  } catch (error) {
+    relinka("error", "Animation failed to complete.", error);
+  }
+}

package/bin/libs/anykey/anykey-mod.d.ts

@@ -0,0 +1,12 @@
+import type { ColorName } from "../../types";
+interface Options {
+    ctrlC?: number | false | "reject";
+    preserveLog?: boolean;
+    hideMessage?: boolean;
+    shouldStream?: boolean;
+    streamDelay?: number;
+    color?: ColorName;
+    placeholderColor?: ColorName;
+}
+export declare function anykeyPrompt(message?: string, options?: Options): Promise<void>;
+export {};

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

@@ -0,0 +1,125 @@
+import logUpdate from "log-update";
+import { cursor } from "sisteransi";
+import { fmt } from "../msg-fmt/messages.js";
+import { outroPrompt } from "../outro/outro-mod.js";
+import { streamText } from "../utils/stream-text.js";
+const DEFAULT_MESSAGE = "Press any key to continue...";
+const CTRL_C_CODE = 3;
+const terminal = {
+  /**
+   * Move cursor to start of line
+   */
+  moveToStart: () => process.stdout.write("\r"),
+  /**
+   * Clear current line and move cursor up
+   */
+  clearLineAndMoveUp: () => process.stdout.write("\x1B[1A\x1B[2K"),
+  /**
+   * Clear multiple lines above current position
+   */
+  clearLines: (count) => {
+    terminal.moveToStart();
+    process.stdout.write("\x1B[2K");
+    for (let i = 0; i < count; i++) {
+      terminal.clearLineAndMoveUp();
+    }
+  }
+};
+export async function anykeyPrompt(message = DEFAULT_MESSAGE, options = {}) {
+  const {
+    ctrlC = 1,
+    preserveLog = false,
+    hideMessage = false,
+    shouldStream = false,
+    streamDelay = 20,
+    color = "dim",
+    placeholderColor = "gray"
+  } = options;
+  if (message) {
+    if (!shouldStream) {
+      const { text } = fmt({
+        hintPlaceholderColor: placeholderColor,
+        type: "M_GENERAL",
+        title: message,
+        titleColor: color,
+        dontRemoveBar: true
+      });
+      message = text;
+    }
+  }
+  if (message && !hideMessage) {
+    if (shouldStream) {
+      await streamText({
+        text: `\u25C6  ${message}`,
+        delay: streamDelay,
+        newline: false,
+        clearLine: true,
+        color
+      });
+      const lineCount = message.split("\n").length;
+      terminal.clearLines(lineCount);
+      const { text } = fmt({
+        hintPlaceholderColor: placeholderColor,
+        type: "M_GENERAL",
+        title: message,
+        titleColor: color,
+        dontRemoveBar: true
+      });
+      terminal.moveToStart();
+      logUpdate(text);
+    } else {
+      logUpdate(message);
+    }
+  }
+  return new Promise((resolve, reject) => {
+    const cleanup = () => {
+      process.stdin.removeListener("data", handler);
+      if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
+        process.stdin.setRawMode(false);
+      }
+      process.stdin.pause();
+      process.stdout.write(cursor.show);
+    };
+    const handleCtrlC = () => {
+      cleanup();
+      void outroPrompt({
+        title: "\u270B User pressed Ctrl+C, exiting...",
+        titleAnimation: "pulse",
+        titleColor: "redBright",
+        titleTypography: "bold",
+        endTitleColor: "redBright",
+        titleAnimationDelay: 400
+      }).then(() => {
+        if (ctrlC === "reject") {
+          reject(new Error("User pressed CTRL+C"));
+        } else if (ctrlC === false) {
+          resolve();
+        } else if (typeof ctrlC === "number") {
+          process.exit(0);
+        } else {
+          throw new TypeError("Invalid ctrlC option");
+        }
+      }).catch(reject);
+    };
+    const handler = (buffer) => {
+      cleanup();
+      if (message && !preserveLog) {
+        logUpdate.clear();
+      } else {
+        logUpdate.done();
+        process.stdout.write("\n");
+      }
+      const [firstByte] = buffer;
+      if (firstByte === CTRL_C_CODE) {
+        handleCtrlC();
+      } else {
+        resolve();
+      }
+    };
+    process.stdin.resume();
+    if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.once("data", handler);
+  });
+}

package/bin/libs/cancel/cancel.d.ts

@@ -0,0 +1,45 @@
+import type { Readable, Writable } from "node:stream";
+/**
+ * Special value that indicates a cancelled operation
+ */
+export declare const CANCEL: unique symbol;
+/**
+ * Type for the cancel value
+ */
+export type CancelValue = typeof CANCEL;
+export declare const isWindows: boolean;
+/**
+ * Sets raw mode on input stream
+ */
+export declare function setRawMode(input: Readable, value: boolean): void;
+/**
+ * Gets the number of columns in the terminal
+ */
+export declare function getColumns(output: Writable): number;
+interface BlockOptions {
+    input?: Readable;
+    output?: Writable;
+    overwrite?: boolean;
+    hideCursor?: boolean;
+}
+/**
+ * Creates a block for handling input with proper cursor and cleanup
+ */
+export declare function block({ input, output, overwrite, hideCursor, }?: BlockOptions): () => void;
+/**
+ * Checks if a value represents a cancelled operation
+ * @param value - The value to check
+ * @returns true if the value represents a cancelled operation
+ */
+export declare function isCancel(value: unknown): value is CancelValue;
+/**
+ * Handles cancellation of an operation
+ * @param message - Optional message to display before exiting
+ */
+export declare function cancel(message?: string): never;
+/**
+ * Creates a cancel value that can be returned from operations
+ * @returns The cancel value
+ */
+export declare function createCancel(): CancelValue;
+export {};

package/bin/libs/cancel/cancel.js

@@ -0,0 +1,72 @@
+import { stdin, stdout } from "node:process";
+import * as readline from "node:readline";
+import { ReadStream, WriteStream } from "node:tty";
+import { cursor } from "sisteransi";
+export const CANCEL = Symbol("CANCEL");
+export const isWindows = globalThis.process.platform.startsWith("win");
+export function setRawMode(input, value) {
+  const i = input;
+  if (i.isTTY) i.setRawMode(value);
+}
+export function getColumns(output) {
+  if (output instanceof WriteStream && output.columns) {
+    return output.columns;
+  }
+  return 80;
+}
+export function block({
+  input = stdin,
+  output = stdout,
+  overwrite = true,
+  hideCursor = true
+} = {}) {
+  const rl = readline.createInterface({
+    input,
+    output,
+    prompt: "",
+    tabSize: 1
+  });
+  readline.emitKeypressEvents(input, rl);
+  if (input instanceof ReadStream && input.isTTY) {
+    input.setRawMode(true);
+  }
+  const clear = (data, { name, sequence }) => {
+    const str = String(data);
+    if (str === "" || name === "c" && sequence === "") {
+      if (hideCursor) output.write(cursor.show);
+      process.exit(0);
+      return;
+    }
+    if (!overwrite) return;
+    const dx = name === "return" ? 0 : -1;
+    const dy = name === "return" ? -1 : 0;
+    readline.moveCursor(output, dx, dy, () => {
+      readline.clearLine(output, 1, () => {
+        input.once("keypress", clear);
+      });
+    });
+  };
+  if (hideCursor) output.write(cursor.hide);
+  input.once("keypress", clear);
+  return () => {
+    input.off("keypress", clear);
+    if (hideCursor) output.write(cursor.show);
+    if (input instanceof ReadStream && input.isTTY && !isWindows) {
+      input.setRawMode(false);
+    }
+    rl.terminal = false;
+    rl.close();
+  };
+}
+export function isCancel(value) {
+  return value === CANCEL;
+}
+export function cancel(message) {
+  if (message) {
+    console.log(message);
+  }
+  process.exit(0);
+}
+export function createCancel() {
+  return CANCEL;
+}

package/bin/libs/confirm/confirm-alias.d.ts

@@ -0,0 +1,2 @@
+import type { ConfirmPromptOptions } from "../../types";
+export declare const confirm: (options: ConfirmPromptOptions) => Promise<boolean>;

package/bin/libs/confirm/confirm-alias.js

@@ -0,0 +1,2 @@
+import { confirmPrompt } from "./confirm-mod.js";
+export const confirm = confirmPrompt;

package/bin/libs/confirm/confirm-mod.d.ts

@@ -0,0 +1,5 @@
+import type { ConfirmPromptOptions } from "../../types";
+/**
+ * Prompts the user with a yes/no question, returning a boolean based on their input.
+ */
+export declare function confirmPrompt(options: ConfirmPromptOptions): Promise<boolean>;

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

@@ -0,0 +1,179 @@
+import { stdin as input, stdout as output } from "node:process";
+import readline from "node:readline/promises";
+import { re } from "@reliverse/relico";
+import { bar, msg } from "../msg-fmt/messages.js";
+import { deleteLastLine } from "../msg-fmt/terminal.js";
+import { completePrompt } from "../utils/prompt-end.js";
+function renderPrompt(params) {
+  const {
+    title,
+    content,
+    borderColor,
+    titleColor,
+    titleTypography,
+    titleVariant,
+    contentColor,
+    contentTypography,
+    contentVariant,
+    hintPlaceholderColor,
+    border,
+    variantOptions,
+    errorMessage,
+    displayInstructions,
+    instructions,
+    isRerender = false
+  } = params;
+  let uiLineCount = 0;
+  if (!isRerender) {
+    msg({
+      hintPlaceholderColor,
+      type: errorMessage ? "M_ERROR" : "M_GENERAL",
+      title,
+      titleColor,
+      titleTypography,
+      ...titleVariant ? { titleVariant } : {},
+      ...content ? {
+        content: content.split("\n").map((line) => line.trim()).join("\n")
+      } : {},
+      contentColor,
+      contentTypography,
+      ...contentVariant ? { contentVariant } : {},
+      borderColor,
+      variantOptions,
+      errorMessage,
+      border
+    });
+  }
+  if (displayInstructions && !isRerender) {
+    msg({
+      type: "M_NULL",
+      title: re.blue(instructions)
+    });
+    uiLineCount++;
+  }
+  if (errorMessage) {
+    msg({
+      type: "M_NULL",
+      title: re.redBright(errorMessage)
+    });
+    uiLineCount++;
+  }
+  return uiLineCount;
+}
+export async function confirmPrompt(options) {
+  const {
+    title = "",
+    message,
+    // Alias for title
+    defaultValue,
+    initialValue,
+    // Alias for defaultValue
+    content,
+    titleColor = "cyan",
+    titleTypography = "none",
+    titleVariant,
+    contentColor = "dim",
+    contentTypography = "italic",
+    contentVariant,
+    borderColor = "dim",
+    hintPlaceholderColor = "blue",
+    variantOptions,
+    action,
+    displayInstructions = false,
+    endTitle = "",
+    endTitleColor = "dim",
+    border = true
+  } = options;
+  const finalTitle = message && title ? `${title}: ${message}` : message ?? title ?? "Confirm";
+  const finalDefaultValue = defaultValue ?? initialValue;
+  const rl = readline.createInterface({ input, output });
+  let errorMessage = "";
+  const effectiveDefault = finalDefaultValue ?? true;
+  const defaultHint = effectiveDefault ? "[Y/n]" : "[y/N]";
+  const adjustedTitle = displayInstructions ? finalTitle : `${re.blue(defaultHint)} ${finalTitle}`;
+  const instructions = `Use <y/n> to confirm or deny, <Enter> for default (${effectiveDefault ? "Y" : "N"}), <Ctrl+C> to exit`;
+  let lastUILineCount = 0;
+  function endPrompt(isCtrlC = false) {
+    if (endTitle !== "") {
+      msg({
+        type: "M_END",
+        title: endTitle,
+        titleColor: endTitleColor,
+        titleTypography,
+        ...titleVariant ? { titleVariant } : {},
+        border,
+        borderColor
+      });
+    }
+    rl.close();
+    if (isCtrlC) {
+      process.exit(0);
+    }
+  }
+  rl.on("SIGINT", () => {
+    endPrompt(true);
+  });
+  try {
+    while (true) {
+      if (lastUILineCount > 0) {
+        for (let i = 0; i < lastUILineCount; i++) {
+          process.stdout.write("\x1B[1A\x1B[2K");
+        }
+      }
+      lastUILineCount = renderPrompt({
+        title: adjustedTitle,
+        ...content ? { content } : {},
+        borderColor,
+        titleColor,
+        titleTypography,
+        ...titleVariant ? { titleVariant } : {},
+        contentColor,
+        contentTypography,
+        ...contentVariant ? { contentVariant } : {},
+        hintPlaceholderColor,
+        border,
+        variantOptions,
+        errorMessage,
+        effectiveDefault,
+        displayInstructions,
+        defaultHint,
+        instructions,
+        isRerender: errorMessage !== ""
+        // Only rerender if there's an error
+      });
+      const formattedBar = bar({ borderColor });
+      const answer = (await rl.question(`${formattedBar}  `)).toLowerCase().trim();
+      let result;
+      if (!answer) {
+        deleteLastLine();
+        msg({
+          type: "M_NULL",
+          title: `${formattedBar}  ${effectiveDefault ? "y" : "n"}`
+        });
+        result = effectiveDefault;
+      } else if (answer === "y" || answer === "yes") {
+        result = true;
+      } else if (answer === "n" || answer === "no") {
+        result = false;
+      } else {
+        errorMessage = 'Please answer with "y" or "n".';
+        deleteLastLine();
+        continue;
+      }
+      return await completePrompt(
+        "confirm",
+        false,
+        endTitle,
+        endTitleColor,
+        titleTypography,
+        titleVariant ? titleVariant : void 0,
+        border,
+        borderColor,
+        action,
+        result
+      );
+    }
+  } finally {
+    rl.close();
+  }
+}

package/bin/libs/date/date.d.ts

@@ -0,0 +1,2 @@
+import type { DatePromptOptions } from "../../types";
+export declare function datePrompt(opts: DatePromptOptions): Promise<string>;