@reliverse/relinka 1.0.0

package/output/components/select.js

@@ -0,0 +1,97 @@
+import { Value } from "@sinclair/typebox/value";
+import { stdout } from "node:process";
+import color from "picocolors";
+import { useKeyPress } from "../hooks/useKeyPress";
+import { colorize } from "../utils/colorize";
+import { resetCursorAndClear, moveCursorAndClear } from "../utils/readline";
+export async function selectPrompt(options) {
+  const {
+    title,
+    choices,
+    defaultValue,
+    schema,
+    titleColor = "cyanBright",
+    answerColor = "none",
+    titleTypography = "bold"
+  } = options;
+  if (schema) {
+    throw new Error(
+      "Schema providing is currently not supported for selectPrompt().\n\u2502  But don't worry, we're already handling some validations for you."
+    );
+  }
+  if (!choices || choices.length === 0) {
+    throw new Error("Choices are required for select prompt.");
+  }
+  const coloredTitle = colorize(title, titleColor, titleTypography);
+  let selectedIndex = defaultValue !== void 0 ? choices.findIndex(
+    (choice, index) => choice.id === defaultValue || index + 1 === Number(defaultValue)
+  ) : 0;
+  if (selectedIndex === -1) selectedIndex = 0;
+  function renderChoices() {
+    if (!choices) {
+      throw new Error("Choices are required for select prompt.");
+    }
+    resetCursorAndClear(stdout, 0, 0);
+    console.log(color.cyanBright(color.bold(coloredTitle)));
+    choices.forEach((choice, index) => {
+      const isSelected = index === selectedIndex;
+      const prefix = isSelected ? color.greenBright(">") : " ";
+      const choiceText = isSelected ? color.bgGreen(color.black(choice.title)) : choice.title;
+      console.log(`${prefix} ${choiceText}`);
+    });
+  }
+  renderChoices();
+  return new Promise((resolve, reject) => {
+    const finalizeSelection = () => {
+      cleanupKeyPress();
+      moveCursorAndClear(stdout, 0, choices.length + 2);
+      const selectedChoice = choices[selectedIndex];
+      const selectedValue = selectedChoice?.id;
+      let isValid = true;
+      let errorMessage = "Invalid input.";
+      if (schema) {
+        try {
+          isValid = Value.Check(schema, selectedValue);
+        } catch (error) {
+          isValid = false;
+          errorMessage = "Validation error.";
+          console.error(error);
+        }
+        if (!isValid) {
+          const errors = [...Value.Errors(schema, selectedValue)];
+          if (errors.length > 0) {
+            errorMessage = errors[0]?.message ?? "Invalid input.";
+          }
+        }
+      }
+      if (isValid) {
+        if (selectedChoice?.action) {
+          selectedChoice.action().then(() => resolve(selectedValue ?? "")).catch(reject);
+        } else {
+          resolve(selectedValue ?? "");
+        }
+      } else {
+        console.log(errorMessage);
+        renderChoices();
+      }
+    };
+    const handleKeyPress = (str, key) => {
+      if (key.name === "up") {
+        selectedIndex = (selectedIndex - 1 + choices.length) % choices.length;
+        renderChoices();
+      } else if (key.name === "down") {
+        selectedIndex = (selectedIndex + 1) % choices.length;
+        renderChoices();
+      } else if (key.name === "return") {
+        finalizeSelection();
+      } else if (key.ctrl && key.name === "c") {
+        cleanupKeyPress();
+        process.exit();
+      } else if (!isNaN(Number(str)) && Number(str) >= 1 && Number(str) <= choices.length) {
+        selectedIndex = Number(str) - 1;
+        finalizeSelection();
+      }
+    };
+    const cleanupKeyPress = useKeyPress(handleKeyPress);
+  });
+}

package/output/components/spinner.d.ts

@@ -0,0 +1,15 @@
+import { type SpinnerName } from "cli-spinners";
+type SimpleSpinnerType = "default" | "dottedCircle" | "boxSpinner";
+type OraAllowedSpinners = "dots" | "bouncingBar" | "arc";
+type OraSpinnerType = Extract<SpinnerName, OraAllowedSpinners>;
+type CreateSpinnerOptions<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 spinnerPrompts<T extends "simple" | "ora">(options: CreateSpinnerOptions<T>): Promise<void>;
+export {};

package/output/components/spinner.js

@@ -0,0 +1,110 @@
+import process from "node:process";
+import ora from "ora";
+import color from "picocolors";
+import { cursor, erase } from "sisteransi";
+import { msg } from "../utils/messages";
+export async function spinnerPrompts(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: "green"
+      });
+    } catch (error) {
+      oraSpinner.stopAndPersist({
+        symbol: color.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 = color.magenta(frames[frameIndex]);
+        process.stdout.write(
+          `${cursor.move(-999, 0)}${erase.line}${frame} ${color.cyan(message)}`
+        );
+        frameIndex = (frameIndex + 1) % frames.length;
+      }, delay);
+      await action((newMessage) => {
+        message = newMessage;
+      });
+      clearInterval(interval);
+      interval = null;
+      process.stdout.write(
+        `\r${erase.line}${color.green("\u2714")} ${successMessage}
+`
+      );
+      msg({
+        type: "M_INFO",
+        title: successMessage,
+        titleColor: "green"
+      });
+    } catch (error) {
+      if (interval) {
+        clearInterval(interval);
+      }
+      process.stdout.write(
+        `\r${erase.line}${color.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/output/components/start.d.ts

@@ -0,0 +1,2 @@
+import type { PromptOptions } from "../types/prod";
+export declare function startPrompt({ title, titleColor, answerColor, titleTypography, titleVariant, borderColor, clearConsole, }: PromptOptions): Promise<void>;

package/output/components/start.js

@@ -0,0 +1,33 @@
+import { msg } from "../utils/messages";
+export async function startPrompt({
+  title,
+  titleColor = "cyanBright",
+  answerColor = "none",
+  titleTypography = "bold",
+  titleVariant,
+  borderColor = "viceGradient",
+  clearConsole = true
+}) {
+  if (clearConsole) {
+    console.clear();
+    console.log();
+  } else {
+    console.log();
+  }
+  msg({
+    type: "M_START",
+    title: ` ${title} `,
+    titleColor,
+    titleTypography,
+    titleVariant,
+    borderColor
+  });
+  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_NEWLINE"
+    });
+  }
+}

package/output/components/text.d.ts

@@ -0,0 +1,3 @@
+import type { TSchema, Static } from "@sinclair/typebox";
+import type { PromptOptions } from "../types/prod";
+export declare function textPrompt<T extends TSchema>(options: PromptOptions<T>): Promise<Static<T>>;

package/output/components/text.js

@@ -0,0 +1,88 @@
+import { Value } from "@sinclair/typebox/value";
+import { stdin as input, stdout as output } from "node:process";
+import readline from "node:readline/promises";
+import { fmt, msg } from "../utils/messages";
+import { countLines, deleteLastLine, deleteLastLines } from "../utils/terminal";
+export async function textPrompt(options) {
+  const {
+    title,
+    hint,
+    validate,
+    defaultValue = "",
+    schema,
+    titleColor = "cyanBright",
+    answerColor = "none",
+    titleTypography = "bold",
+    titleVariant,
+    content,
+    contentColor,
+    contentTypography,
+    contentVariant,
+    borderColor = "viceGradient",
+    variantOptions
+  } = options;
+  const rl = readline.createInterface({ input, output });
+  let linesToDelete = 0;
+  let errorMessage = "";
+  while (true) {
+    if (linesToDelete > 0) {
+      deleteLastLines(linesToDelete);
+    }
+    const question = fmt({
+      type: errorMessage !== "" ? "M_ERROR" : "M_GENERAL",
+      title,
+      titleColor,
+      titleTypography,
+      titleVariant,
+      content,
+      contentColor,
+      contentTypography,
+      contentVariant,
+      borderColor,
+      hint,
+      variantOptions,
+      errorMessage
+    });
+    const questionLines = countLines(question);
+    const prompt = await rl.question(question);
+    linesToDelete = questionLines + 1;
+    const answer = prompt.trim() || defaultValue;
+    if (prompt.trim() === "" && defaultValue !== "") {
+      deleteLastLine();
+      const defaultMsg = fmt({
+        type: "M_MIDDLE",
+        title: `  ${defaultValue}`,
+        borderColor
+      });
+      console.log(defaultMsg);
+      linesToDelete += countLines(defaultMsg);
+    }
+    let isValid = true;
+    errorMessage = "";
+    if (schema) {
+      isValid = Value.Check(schema, answer);
+      if (!isValid) {
+        const errors = [...Value.Errors(schema, answer)];
+        if (errors.length > 0) {
+          errorMessage = errors[0]?.message ?? "Invalid input.";
+        } else {
+          errorMessage = "Invalid input.";
+        }
+      }
+    }
+    if (validate && isValid) {
+      const validation = await validate(answer);
+      if (validation !== true) {
+        isValid = false;
+        errorMessage = typeof validation === "string" ? validation : "Invalid input.";
+      }
+    }
+    if (isValid) {
+      msg({ type: "M_NEWLINE" });
+      rl.close();
+      return answer;
+    } else {
+      linesToDelete += 0;
+    }
+  }
+}

package/output/hooks/useKeyPress.d.ts

@@ -0,0 +1,4 @@
+import readline from "node:readline";
+type KeyPressCallback = (str: string, key: readline.Key) => void;
+export declare function useKeyPress(callback: KeyPressCallback): () => void;
+export {};

package/output/hooks/useKeyPress.js

@@ -0,0 +1,14 @@
+import { stdin } from "node:process";
+import readline from "node:readline";
+export function useKeyPress(callback) {
+  readline.emitKeypressEvents(stdin);
+  if (stdin.isTTY) stdin.setRawMode(true);
+  const onKeypress = (str, key) => {
+    callback(str, key);
+  };
+  stdin.on("keypress", onKeypress);
+  return () => {
+    stdin.setRawMode(false);
+    stdin.off("keypress", onKeypress);
+  };
+}

package/output/main.d.ts

@@ -0,0 +1,16 @@
+export { colorize } from "./utils/colorize";
+export { msg, fmt } from "./utils/messages";
+export { animateText } from "./components/animate";
+export { createAsciiArt } from "./components/ascii-art";
+export { spinnerPrompts } from "./components/spinner";
+export { startPrompt } from "./components/start";
+export { textPrompt } from "./components/text";
+export { selectPrompt } from "./components/select";
+export { confirmPrompt } from "./components/confirm";
+export { datePrompt } from "./components/date";
+export { numMultiSelectPrompt } from "./components/num-multi-select";
+export { nextStepsPrompt } from "./components/next-steps";
+export { numberPrompt } from "./components/number";
+export { passwordPrompt } from "./components/password";
+export { endPrompt } from "./components/end";
+export { prompt } from "./components/mono";

package/output/main.js

@@ -0,0 +1,16 @@
+export { colorize } from "./utils/colorize";
+export { msg, fmt } from "./utils/messages";
+export { animateText } from "./components/animate";
+export { createAsciiArt } from "./components/ascii-art";
+export { spinnerPrompts } from "./components/spinner";
+export { startPrompt } from "./components/start";
+export { textPrompt } from "./components/text";
+export { selectPrompt } from "./components/select";
+export { confirmPrompt } from "./components/confirm";
+export { datePrompt } from "./components/date";
+export { numMultiSelectPrompt } from "./components/num-multi-select";
+export { nextStepsPrompt } from "./components/next-steps";
+export { numberPrompt } from "./components/number";
+export { passwordPrompt } from "./components/password";
+export { endPrompt } from "./components/end";
+export { prompt } from "./components/mono";

package/output/types/prod.d.ts

@@ -0,0 +1,83 @@
+import type { AnimationName } from "@figliolia/chalk-animation";
+import type { TSchema } from "@sinclair/typebox";
+export type MsgType = "M_NULL" | "M_START" | "M_MIDDLE" | "M_GENERAL" | "M_INFO" | "M_NEWLINE" | "M_END" | "M_END_ANIMATED" | "M_ERROR";
+export type TypographyName = "bold" | "strikethrough" | "underline" | "italic";
+export type Variant = "box" | "doubleBox" | "banner" | "underline" | "none" | "animated";
+export type ColorName = "dim" | "inverse" | "black" | "red" | "redBright" | "bgRed" | "bgRedBright" | "green" | "greenBright" | "bgGreen" | "bgGreenBright" | "yellow" | "yellowBright" | "blue" | "blueBright" | "magenta" | "cyan" | "cyanBright" | "bgCyan" | "bgCyanBright" | "white" | "gray" | "gradientGradient" | "rainbowGradient" | "cristalGradient" | "mindGradient" | "passionGradient" | "viceGradient" | "retroGradient" | "none";
+export type MsgConfig = {
+    symbol: string;
+    prefix?: string;
+    color?: (text: string) => string;
+    newLineBefore?: boolean;
+    newLineAfter?: boolean;
+    suffix?: string;
+};
+export type FmtMsgOptions = {
+    type: MsgType;
+    title?: string;
+    titleAfterAnim?: string;
+    content?: string;
+    titleColor?: ColorName;
+    titleTypography?: TypographyName;
+    titleVariant?: Variant;
+    contentColor?: ColorName;
+    contentTypography?: TypographyName;
+    contentVariant?: Variant;
+    hint?: string;
+    border?: boolean;
+    borderColor?: ColorName;
+    variantOptions?: {
+        box?: {
+            limit?: number;
+        };
+    };
+    errorMessage?: string;
+    addNewLineBefore?: boolean;
+    addNewLineAfter?: boolean;
+};
+export type RequiredPromptOptions = {
+    id: string;
+    title: string;
+};
+export type OptionalPromptOptions<T extends TSchema = any> = {
+    schema?: T;
+    titleColor?: ColorName;
+    titleTypography?: TypographyName;
+    titleVariant?: Variant;
+    titleAnimation?: AnimationName;
+    titleAnimationDelay?: number;
+    content?: string;
+    contentColor?: ColorName;
+    contentTypography?: TypographyName;
+    contentVariant?: Variant;
+    hint?: string;
+    validate?: (value: any) => boolean | string | Promise<boolean | string>;
+    defaultValue?: string | string[] | number | boolean;
+    defaultColor?: ColorName;
+    defaultTypography?: TypographyName;
+    choices?: ChoiceOptions[];
+    variantOptions?: {
+        box?: {
+            limit?: number;
+        };
+    };
+    action?: () => Promise<void>;
+    border?: boolean;
+    borderColor?: ColorName;
+    clearConsole?: boolean;
+    additionalLinesToDelete?: number;
+    answerColor?: ColorName;
+    hintColor?: ColorName;
+};
+export type PromptOptions<T extends TSchema = any> = RequiredPromptOptions & OptionalPromptOptions<T>;
+export type ChoiceRequiredOptions = {
+    id: string;
+    title: string;
+};
+export type ChoiceOptionalOptions = {
+    description?: string;
+    titleTypography?: TypographyName;
+    action?: () => Promise<void>;
+};
+export type ChoiceOptions = ChoiceRequiredOptions & ChoiceOptionalOptions;
+export type PromptType = "text" | "number" | "confirm" | "numSelect" | "select" | "multiselect" | "password" | "date" | "start" | "nextSteps" | "end";

package/output/utils/colorize.d.ts

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

package/output/utils/colorize.js

@@ -0,0 +1,129 @@
+import gradient, {
+  cristal,
+  mind,
+  passion,
+  rainbow,
+  vice
+} from "gradient-string";
+import {
+  red,
+  inverse,
+  dim,
+  black,
+  green,
+  yellow,
+  blue,
+  magenta,
+  cyan,
+  cyanBright,
+  bgCyan,
+  bgCyanBright,
+  white,
+  gray,
+  underline,
+  bold,
+  strikethrough,
+  italic
+} from "picocolors";
+export function colorize(text, colorName, typography) {
+  let result = text;
+  switch (colorName) {
+    case "inverse":
+      result = inverse(` ${result} `);
+      break;
+    case "dim":
+      result = dim(result);
+      break;
+    case "black":
+      result = black(result);
+      break;
+    case "red":
+      result = red(result);
+      break;
+    case "green":
+      result = green(result);
+      break;
+    case "yellow":
+      result = yellow(result);
+      break;
+    case "blue":
+      result = blue(result);
+      break;
+    case "magenta":
+      result = magenta(result);
+      break;
+    case "cyan":
+      result = cyan(result);
+      break;
+    case "cyanBright":
+      result = cyanBright(result);
+      break;
+    case "bgCyan":
+      result = bgCyan(` ${result} `);
+      break;
+    case "bgCyanBright":
+      result = bgCyanBright(` ${result} `);
+      break;
+    case "white":
+      result = white(result);
+      break;
+    case "gray":
+      result = gray(result);
+      break;
+    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 "none":
+      break;
+    default:
+      break;
+  }
+  const gradientColors = [
+    "gradientGradient",
+    "cristalGradient",
+    "mindGradient",
+    "passionGradient",
+    "rainbowGradient",
+    "viceGradient"
+  ];
+  if (gradientColors.includes(colorName ?? "") && typography)
+    throw new Error(
+      "[colorize] Cannot apply typography to gradient color.\n\u2502  Use regular colorize()'s color or remove typography."
+    );
+  if (!gradientColors.includes(colorName ?? "") && typography) {
+    switch (typography) {
+      case "bold":
+        result = bold(result);
+        break;
+      case "strikethrough":
+        result = strikethrough(result);
+        break;
+      case "underline":
+        result = underline(result);
+        break;
+      case "italic":
+        result = italic(result);
+        break;
+      default:
+        break;
+    }
+  }
+  return result;
+}

package/output/utils/errors.d.ts

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

package/output/utils/errors.js

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

package/output/utils/mapping.d.ts

@@ -0,0 +1,4 @@
+import type { TypographyName } from "../types/prod";
+import type { ColorName } from "../types/prod";
+export declare const colorMap: Record<ColorName, (text: string) => string>;
+export declare const typographyMap: Record<TypographyName, (text: string) => string>;